001package org.eclipse.aether.internal.impl.slf4j;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 * 
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 * 
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import javax.inject.Inject;
023import javax.inject.Named;
024
025import org.eclipse.aether.spi.locator.Service;
026import org.eclipse.aether.spi.locator.ServiceLocator;
027import org.eclipse.aether.spi.log.Logger;
028import org.eclipse.aether.spi.log.LoggerFactory;
029import org.eclipse.sisu.Nullable;
030import org.slf4j.ILoggerFactory;
031import org.slf4j.spi.LocationAwareLogger;
032
033/**
034 * A logger factory that delegates to <a href="http://www.slf4j.org/" target="_blank">SLF4J</a> logging.
035 */
036@Named( "slf4j" )
037public class Slf4jLoggerFactory
038    implements LoggerFactory, Service
039{
040
041    private static final boolean AVAILABLE;
042
043    static
044    {
045        boolean available;
046        try
047        {
048            Slf4jLoggerFactory.class.getClassLoader().loadClass( "org.slf4j.ILoggerFactory" );
049            available = true;
050        }
051        catch ( Exception | LinkageError e )
052        {
053            available = false;
054        }
055        AVAILABLE = available;
056    }
057
058    public static boolean isSlf4jAvailable()
059    {
060        return AVAILABLE;
061    }
062
063    private ILoggerFactory factory;
064
065    /**
066     * Creates an instance of this logger factory.
067     */
068    public Slf4jLoggerFactory()
069    {
070        // enables no-arg constructor
071    }
072
073    @Inject
074    Slf4jLoggerFactory( @Nullable ILoggerFactory factory )
075    {
076        setLoggerFactory( factory );
077    }
078
079    public void initService( ServiceLocator locator )
080    {
081        setLoggerFactory( locator.getService( ILoggerFactory.class ) );
082    }
083
084    public Slf4jLoggerFactory setLoggerFactory( ILoggerFactory factory )
085    {
086        this.factory = factory;
087        return this;
088    }
089
090    public Logger getLogger( String name )
091    {
092        org.slf4j.Logger logger = getFactory().getLogger( name );
093        if ( logger instanceof LocationAwareLogger )
094        {
095            return new Slf4jLoggerEx( (LocationAwareLogger) logger );
096        }
097        return new Slf4jLogger( logger );
098    }
099
100    private ILoggerFactory getFactory()
101    {
102        if ( factory == null )
103        {
104            factory = org.slf4j.LoggerFactory.getILoggerFactory();
105        }
106        return factory;
107    }
108
109    private static final class Slf4jLogger
110        implements Logger
111    {
112
113        private final org.slf4j.Logger logger;
114
115        Slf4jLogger( org.slf4j.Logger logger )
116        {
117            this.logger = logger;
118        }
119
120        public boolean isDebugEnabled()
121        {
122            return logger.isDebugEnabled();
123        }
124
125        public void debug( String msg )
126        {
127            logger.debug( msg );
128        }
129
130        public void debug( String msg, Throwable error )
131        {
132            logger.debug( msg, error );
133        }
134
135        public boolean isWarnEnabled()
136        {
137            return logger.isWarnEnabled();
138        }
139
140        public void warn( String msg )
141        {
142            logger.warn( msg );
143        }
144
145        public void warn( String msg, Throwable error )
146        {
147            logger.warn( msg, error );
148        }
149
150    }
151
152    private static final class Slf4jLoggerEx
153        implements Logger
154    {
155
156        private static final String FQCN = Slf4jLoggerEx.class.getName();
157
158        private final LocationAwareLogger logger;
159
160        Slf4jLoggerEx( LocationAwareLogger logger )
161        {
162            this.logger = logger;
163        }
164
165        public boolean isDebugEnabled()
166        {
167            return logger.isDebugEnabled();
168        }
169
170        public void debug( String msg )
171        {
172            logger.log( null, FQCN, LocationAwareLogger.DEBUG_INT, msg, null, null );
173        }
174
175        public void debug( String msg, Throwable error )
176        {
177            logger.log( null, FQCN, LocationAwareLogger.DEBUG_INT, msg, null, error );
178        }
179
180        public boolean isWarnEnabled()
181        {
182            return logger.isWarnEnabled();
183        }
184
185        public void warn( String msg )
186        {
187            logger.log( null, FQCN, LocationAwareLogger.WARN_INT, msg, null, null );
188        }
189
190        public void warn( String msg, Throwable error )
191        {
192            logger.log( null, FQCN, LocationAwareLogger.WARN_INT, msg, null, error );
193        }
194
195    }
196
197}