    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements. See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache license, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License. You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the license for the specific language governing permissions and
    015     * limitations under the license.
    016     */
    017    package org.apache.logging.log4j.nosql.appender.couchdb;
    018
    019    import java.lang.reflect.Method;
    020
    021    import org.apache.logging.log4j.Logger;
    022    import org.apache.logging.log4j.core.appender.AbstractAppender;
    023    import org.apache.logging.log4j.core.config.plugins.Plugin;
    024    import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
    025    import org.apache.logging.log4j.core.config.plugins.PluginFactory;
    026    import org.apache.logging.log4j.core.util.Loader;
    027    import org.apache.logging.log4j.core.util.NameUtil;
    028    import org.apache.logging.log4j.nosql.appender.NoSqlProvider;
    029    import org.apache.logging.log4j.status.StatusLogger;
    030    import org.apache.logging.log4j.util.Strings;
    031    import org.lightcouch.CouchDbClient;
    032    import org.lightcouch.CouchDbProperties;
    033
    034    /**
    035     * The Apache CouchDB implementation of {@link NoSqlProvider}.
    036     */
    037    @Plugin(name = "CouchDB", category = "Core", printObject = true)
    038    public final class CouchDbProvider implements NoSqlProvider<CouchDbConnection> {
    039        private static final int HTTP = 80;
    040        private static final int HTTPS = 443;
    041        private static final Logger LOGGER = StatusLogger.getLogger();
    042
    043        private final CouchDbClient client;
    044        private final String description;
    045
    046        private CouchDbProvider(final CouchDbClient client, final String description) {
    047            this.client = client;
    048            this.description = "couchDb{ " + description + " }";
    049        }
    050
    051        @Override
    052        public CouchDbConnection getConnection() {
    053            return new CouchDbConnection(this.client);
    054        }
    055
    056        @Override
    057        public String toString() {
    058            return this.description;
    059        }
    060
    061        /**
    062         * Factory method for creating an Apache CouchDB provider within the plugin manager.
    063         *
    064         * @param databaseName The name of the database to which log event documents will be written.
    065         * @param protocol Either "http" or "https," defaults to "http" and mutually exclusive with
    066         *                 {@code factoryClassName&factoryMethodName!=null}.
    067         * @param server The host name of the CouchDB server, defaults to localhost and mutually exclusive with
    068         *               {@code factoryClassName&factoryMethodName!=null}.
    069         * @param port The port that CouchDB is listening on, defaults to 80 if {@code protocol} is "http" and 443 if
    070         *             {@code protocol} is "https," and mutually exclusive with
    071         *             {@code factoryClassName&factoryMethodName!=null}.
    072         * @param username The username to authenticate against the MongoDB server with, mutually exclusive with
    073         *                 {@code factoryClassName&factoryMethodName!=null}.
    074         * @param password The password to authenticate against the MongoDB server with, mutually exclusive with
    075         *                 {@code factoryClassName&factoryMethodName!=null}.
    076         * @param factoryClassName A fully qualified class name containing a static factory method capable of returning a
    077         *                         {@link CouchDbClient} or {@link CouchDbProperties}.
    078         * @param factoryMethodName The name of the public static factory method belonging to the aforementioned factory
    079         *                          class.
    080         * @return a new Apache CouchDB provider.
    081         */
    082        @PluginFactory
    083        public static CouchDbProvider createNoSqlProvider(
    084                @PluginAttribute("databaseName") final String databaseName,
    085                @PluginAttribute("protocol") String protocol,
    086                @PluginAttribute("server") String server,
    087                @PluginAttribute("port") final String port,
    088                @PluginAttribute("username") final String username,
    089                @PluginAttribute(value = "password", sensitive = true) final String password,
    090                @PluginAttribute("factoryClassName") final String factoryClassName,
    091                @PluginAttribute("factoryMethodName") final String factoryMethodName) {
    092            CouchDbClient client;
    093            String description;
    094            if (factoryClassName != null && factoryClassName.length() > 0 &&
    095                    factoryMethodName != null && factoryMethodName.length() > 0) {
    096                try {
    097                    final Class<?> factoryClass = Loader.loadClass(factoryClassName);
    098                    final Method method = factoryClass.getMethod(factoryMethodName);
    099                    final Object object = method.invoke(null);
    100
    101                    if (object instanceof CouchDbClient) {
    102                        client = (CouchDbClient) object;
    103                        description = "uri=" + client.getDBUri();
    104                    } else if (object instanceof CouchDbProperties) {
    105                        final CouchDbProperties properties = (CouchDbProperties) object;
    106                        client = new CouchDbClient(properties);
    107                        description = "uri=" + client.getDBUri() + ", username=" + properties.getUsername()
    108                                + ", passwordHash=" + NameUtil.md5(password + CouchDbProvider.class.getName())
    109                                + ", maxConnections=" + properties.getMaxConnections() + ", connectionTimeout="
    110                                + properties.getConnectionTimeout() + ", socketTimeout=" + properties.getSocketTimeout();
    111                    } else if (object == null) {
    112                        LOGGER.error("The factory method [{}.{}()] returned null.", factoryClassName, factoryMethodName);
    113                        return null;
    114                    } else {
    115                        LOGGER.error("The factory method [{}.{}()] returned an unsupported type [{}].", factoryClassName,
    116                                factoryMethodName, object.getClass().getName());
    117                        return null;
    118                    }
    119                } catch (final ClassNotFoundException e) {
    120                    LOGGER.error("The factory class [{}] could not be loaded.", factoryClassName, e);
    121                    return null;
    122                } catch (final NoSuchMethodException e) {
    123                    LOGGER.error("The factory class [{}] does not have a no-arg method named [{}].", factoryClassName,
    124                            factoryMethodName, e);
    125                    return null;
    126                } catch (final Exception e) {
    127                    LOGGER.error("The factory method [{}.{}()] could not be invoked.", factoryClassName, factoryMethodName,
    128                            e);
    129                    return null;
    130                }
    131            } else if (databaseName != null && databaseName.length() > 0) {
    132                if (protocol != null && protocol.length() > 0) {
    133                    protocol = protocol.toLowerCase();
    134                    if (!protocol.equals("http") && !protocol.equals("https")) {
    135                        LOGGER.error("Only protocols [http] and [https] are supported, [{}] specified.", protocol);
    136                        return null;
    137                    }
    138                } else {
    139                    protocol = "http";
    140                    LOGGER.warn("No protocol specified, using default port [http].");
    141                }
    142
    143                final int portInt = AbstractAppender.parseInt(port, protocol.equals("https") ? HTTPS : HTTP);
    144
    145                if (Strings.isEmpty(server)) {
    146                    server = "localhost";
    147                    LOGGER.warn("No server specified, using default server localhost.");
    148                }
    149
    150                if (Strings.isEmpty(username) || Strings.isEmpty(password)) {
    151                    LOGGER.error("You must provide a username and password for the CouchDB provider.");
    152                    return null;
    153                }
    154
    155                client = new CouchDbClient(databaseName, false, protocol, server, portInt, username, password);
    156                description = "uri=" + client.getDBUri() + ", username=" + username + ", passwordHash="
    157                        + NameUtil.md5(password + CouchDbProvider.class.getName());
    158            } else {
    159                LOGGER.error("No factory method was provided so the database name is required.");
    160                return null;
    161            }
    162
    163            return new CouchDbProvider(client, description);
    164        }
    165    }