View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements. See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache license, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License. You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the license for the specific language governing permissions and
15   * limitations under the license.
16   */
17  package org.apache.logging.log4j.core.appender.db.nosql.couchdb;
18  
19  import java.lang.reflect.Method;
20  
21  import org.apache.logging.log4j.Logger;
22  import org.apache.logging.log4j.core.appender.AbstractAppender;
23  import org.apache.logging.log4j.core.appender.db.nosql.NoSQLProvider;
24  import org.apache.logging.log4j.core.config.plugins.Plugin;
25  import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
26  import org.apache.logging.log4j.core.config.plugins.PluginFactory;
27  import org.apache.logging.log4j.core.helpers.NameUtil;
28  import org.apache.logging.log4j.core.helpers.Strings;
29  import org.apache.logging.log4j.status.StatusLogger;
30  import org.lightcouch.CouchDbClient;
31  import org.lightcouch.CouchDbProperties;
32  
33  /**
34   * The Apache CouchDB implementation of {@link NoSQLProvider}.
35   */
36  @Plugin(name = "CouchDB", category = "Core", printObject = true)
37  public final class CouchDBProvider implements NoSQLProvider<CouchDBConnection> {
38      private static final int HTTP = 80;
39      private static final int HTTPS = 443;
40      private static final Logger LOGGER = StatusLogger.getLogger();
41  
42      private final CouchDbClient client;
43      private final String description;
44  
45      private CouchDBProvider(final CouchDbClient client, final String description) {
46          this.client = client;
47          this.description = "couchDb{ " + description + " }";
48      }
49  
50      @Override
51      public CouchDBConnection getConnection() {
52          return new CouchDBConnection(this.client);
53      }
54  
55      @Override
56      public String toString() {
57          return this.description;
58      }
59  
60      /**
61       * Factory method for creating an Apache CouchDB provider within the plugin manager.
62       *
63       * @param databaseName The name of the database to which log event documents will be written.
64       * @param protocol Either "http" or "https," defaults to "http" and mutually exclusive with
65       *                 {@code factoryClassName&factoryMethodName!=null}.
66       * @param server The host name of the CouchDB server, defaults to localhost and mutually exclusive with
67       *               {@code factoryClassName&factoryMethodName!=null}.
68       * @param port The port that CouchDB is listening on, defaults to 80 if {@code protocol} is "http" and 443 if
69       *             {@code protocol} is "https," and mutually exclusive with
70       *             {@code factoryClassName&factoryMethodName!=null}.
71       * @param username The username to authenticate against the MongoDB server with, mutually exclusive with
72       *                 {@code factoryClassName&factoryMethodName!=null}.
73       * @param password The password to authenticate against the MongoDB server with, mutually exclusive with
74       *                 {@code factoryClassName&factoryMethodName!=null}.
75       * @param factoryClassName A fully qualified class name containing a static factory method capable of returning a
76       *                         {@link CouchDbClient} or {@link CouchDbProperties}.
77       * @param factoryMethodName The name of the public static factory method belonging to the aforementioned factory
78       *                          class.
79       * @return a new Apache CouchDB provider.
80       */
81      @PluginFactory
82      public static CouchDBProvider createNoSQLProvider(
83              @PluginAttribute("databaseName") final String databaseName,
84              @PluginAttribute("protocol") String protocol,
85              @PluginAttribute("server") String server,
86              @PluginAttribute("port") final String port,
87              @PluginAttribute("username") final String username,
88              @PluginAttribute("password") final String password,
89              @PluginAttribute("factoryClassName") final String factoryClassName,
90              @PluginAttribute("factoryMethodName") final String factoryMethodName) {
91          CouchDbClient client;
92          String description;
93          if (factoryClassName != null && factoryClassName.length() > 0 &&
94                  factoryMethodName != null && factoryMethodName.length() > 0) {
95              try {
96                  final Class<?> factoryClass = Class.forName(factoryClassName);
97                  final Method method = factoryClass.getMethod(factoryMethodName);
98                  final Object object = method.invoke(null);
99  
100                 if (object instanceof CouchDbClient) {
101                     client = (CouchDbClient) object;
102                     description = "uri=" + client.getDBUri();
103                 } else if (object instanceof CouchDbProperties) {
104                     final CouchDbProperties properties = (CouchDbProperties) object;
105                     client = new CouchDbClient(properties);
106                     description = "uri=" + client.getDBUri() + ", username=" + properties.getUsername()
107                             + ", passwordHash=" + NameUtil.md5(password + CouchDBProvider.class.getName())
108                             + ", maxConnections=" + properties.getMaxConnections() + ", connectionTimeout="
109                             + properties.getConnectionTimeout() + ", socketTimeout=" + properties.getSocketTimeout();
110                 } else if (object == null) {
111                     LOGGER.error("The factory method [{}.{}()] returned null.", factoryClassName, factoryMethodName);
112                     return null;
113                 } else {
114                     LOGGER.error("The factory method [{}.{}()] returned an unsupported type [{}].", factoryClassName,
115                             factoryMethodName, object.getClass().getName());
116                     return null;
117                 }
118             } catch (final ClassNotFoundException e) {
119                 LOGGER.error("The factory class [{}] could not be loaded.", factoryClassName, e);
120                 return null;
121             } catch (final NoSuchMethodException e) {
122                 LOGGER.error("The factory class [{}] does not have a no-arg method named [{}].", factoryClassName,
123                         factoryMethodName, e);
124                 return null;
125             } catch (final Exception e) {
126                 LOGGER.error("The factory method [{}.{}()] could not be invoked.", factoryClassName, factoryMethodName,
127                         e);
128                 return null;
129             }
130         } else if (databaseName != null && databaseName.length() > 0) {
131             if (protocol != null && protocol.length() > 0) {
132                 protocol = protocol.toLowerCase();
133                 if (!protocol.equals("http") && !protocol.equals("https")) {
134                     LOGGER.error("Only protocols [http] and [https] are supported, [{}] specified.", protocol);
135                     return null;
136                 }
137             } else {
138                 protocol = "http";
139                 LOGGER.warn("No protocol specified, using default port [http].");
140             }
141 
142             final int portInt = AbstractAppender.parseInt(port, protocol.equals("https") ? HTTPS : HTTP);
143 
144             if (Strings.isEmpty(server)) {
145                 server = "localhost";
146                 LOGGER.warn("No server specified, using default server localhost.");
147             }
148 
149             if (Strings.isEmpty(username) || Strings.isEmpty(password)) {
150                 LOGGER.error("You must provide a username and password for the CouchDB provider.");
151                 return null;
152             }
153 
154             client = new CouchDbClient(databaseName, false, protocol, server, portInt, username, password);
155             description = "uri=" + client.getDBUri() + ", username=" + username + ", passwordHash="
156                     + NameUtil.md5(password + CouchDBProvider.class.getName());
157         } else {
158             LOGGER.error("No factory method was provided so the database name is required.");
159             return null;
160         }
161 
162         return new CouchDBProvider(client, description);
163     }
164 }