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;
18
19 import org.apache.logging.log4j.Logger;
20 import org.apache.logging.log4j.status.StatusLogger;
21
22 import java.util.HashMap;
23 import java.util.Map;
24 import java.util.concurrent.locks.Lock;
25 import java.util.concurrent.locks.ReentrantLock;
26
27 /**
28 * Abstract base class used to register managers.
29 */
30 public abstract class AbstractManager {
31
32 /**
33 * Allow subclasses access to the status logger without creating another instance.
34 */
35 protected static final Logger LOGGER = StatusLogger.getLogger();
36
37 // Need to lock that map instead of using a ConcurrentMap due to stop removing the
38 // manager from the map and closing the stream, requiring the whole stop method to be locked.
39 private static final Map<String, AbstractManager> map = new HashMap<String, AbstractManager>();
40
41 private static final Lock lock = new ReentrantLock();
42
43 /**
44 * Number of Appenders using this manager.
45 */
46 protected int count;
47
48 private final String name;
49
50 protected AbstractManager(String name) {
51 this.name = name;
52 LOGGER.debug("Starting {} {}", this.getClass().getSimpleName(), name);
53 }
54
55 /**
56 * Retrieves a Manager if it has been previously created or creates a new Manager.
57 * @param name The name of the Manager to retrieve.
58 * @param factory The Factory to use to create the Manager.
59 * @param data An Object that should be passed to the factory when creating the Manager.
60 * @param <M> The Type of the Manager to be created.
61 * @return A Manager with the specified name and type.
62 */
63 public static <M extends AbstractManager, T> M getManager(String name, ManagerFactory<M, T> factory, T data) {
64 lock.lock();
65 try {
66 M manager = (M) map.get(name);
67 if (manager == null) {
68 manager = factory.createManager(name, data);
69 if (manager == null) {
70 throw new IllegalStateException("Unable to create a manager");
71 }
72 map.put(name, manager);
73 }
74 manager.count++;
75 return manager;
76 } finally {
77 lock.unlock();
78 }
79 }
80
81 /**
82 * Determines if a Manager with the specified name exists.
83 * @param name The name of the Manager.
84 * @return True if the Manager exists, false otherwise.
85 */
86 public static boolean hasManager(String name) {
87 lock.lock();
88 try {
89 return map.containsKey(name);
90 } finally {
91 lock.unlock();
92 }
93 }
94
95 /**
96 * May be overriden by Managers to perform processing while the Manager is being released and the
97 * lock is held.
98 */
99 protected void releaseSub() {
100 }
101
102 protected int getCount() {
103 return count;
104 }
105
106 /**
107 * Called to signify that this Manager is no longer required by an Appender.
108 */
109 public void release() {
110 lock.lock();
111 try {
112 --count;
113 if (count <= 0) {
114 map.remove(name);
115 LOGGER.debug("Shutting down {} {}", this.getClass().getSimpleName(), getName());
116 releaseSub();
117 }
118 } finally {
119 lock.unlock();
120 }
121 }
122
123 /**
124 * Returns the name of the Manager.
125 * @return The name of the Manager.
126 */
127 public String getName() {
128 return name;
129 }
130 }