Attachment #31953 for bug #56900

View | Details | Raw Unified | Return to bug 56900
Collapse All | Expand All




import org.apache.catalina.Globals;
import org.apache.catalina.security.SecurityUtil;
import org.apache.catalina.util.Introspection;
import org.apache.juli.logging.Log;
import org.apache.tomcat.InstanceManager;
import org.apache.tomcat.util.ExceptionUtils;
import org.apache.tomcat.util.res.StringManager;

    protected final ClassLoader containerClassLoader;
    protected final boolean privileged;
    protected final boolean ignoreAnnotations;
    private final Properties restrictedFilters;
    private final Properties restrictedListeners;
    private final Properties restrictedServlets;
    private final Map<Class<?>, AnnotationCacheEntry[]> annotationCache =
        new WeakHashMap<>();
    private final Map<String, String> postConstructMethods;
    private final Map<String, String> preDestroyMethods;
    
    private Properties loadProperties(String propertiesName, String errorString, Log logger) {
        Properties result = new Properties();
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(propertiesName);
        if (is != null) {
            try {
                result.load(is);
            } catch (IOException e) {
                logger.error(errorString, e);
            } finally {
                try {
                    is.close();
                } catch (IOException e) {
                    // do nothing, since we either already read it, or got an exception already
                }
            }
        } else {
            logger.error(errorString);
        }
        return result;
    }

    public DefaultInstanceManager(Context context,
            Map<String, Map<String, String>> injectionMap,

        this.containerClassLoader = containerClassLoader;
        ignoreAnnotations = catalinaContext.getIgnoreAnnotations();
        StringManager sm = StringManager.getManager(Constants.Package);
        restrictedServlets = loadProperties(
                "org/apache/catalina/core/RestrictedServlets.properties",
                sm.getString("defaultInstanceManager.restrictedServletsResource"),
                catalinaContext.getLogger());
        restrictedListeners = loadProperties(
                "org/apache/catalina/core/RestrictedListeners.properties",
                "defaultInstanceManager.restrictedListenersResources",
                catalinaContext.getLogger());
        restrictedFilters = loadProperties(
                "org/apache/catalina/core/RestrictedFilters.properties",
                "defaultInstanceManager.restrictedFiltersResource",
                catalinaContext.getLogger());
                    "defaultInstanceManager.restrictedServletsResource"), e);
        }

        try {
            InputStream is =
                    this.getClass().getClassLoader().getResourceAsStream
                            ("org/apache/catalina/core/RestrictedListeners.properties");
            if (is != null) {
                restrictedListeners.load(is);
            } else {
                catalinaContext.getLogger().error(sm.getString(
                        "defaultInstanceManager.restrictedListenersResources"));
            }
        } catch (IOException e) {
            catalinaContext.getLogger().error(sm.getString(
                    "defaultInstanceManager.restrictedListenersResources"), e);
        }
        try {
            InputStream is =
                    this.getClass().getClassLoader().getResourceAsStream
                            ("org/apache/catalina/core/RestrictedFilters.properties");
            if (is != null) {
                restrictedFilters.load(is);
            } else {
                catalinaContext.getLogger().error(sm.getString(
                        "defaultInstanceManager.restrictedFiltersResource"));
            }
        } catch (IOException e) {
            catalinaContext.getLogger().error(sm.getString(
                    "defaultInstanceManager.restrictedServletsResources"), e);
        }
        this.context = context;
        this.injectionMap = injectionMap;
        this.postConstructMethods = catalinaContext.findPostConstructMethods();
- 

Return to bug 56900

Lines 49-54 import org.apache.catalina.ContainerServlet; Link Here

(-)a/java/org/apache/catalina/core/DefaultInstanceManager.java (-47 / +37 lines)
49	import org.apache.catalina.Globals;	49	import org.apache.catalina.Globals;
50	import org.apache.catalina.security.SecurityUtil;	50	import org.apache.catalina.security.SecurityUtil;
51	import org.apache.catalina.util.Introspection;	51	import org.apache.catalina.util.Introspection;
		52	import org.apache.juli.logging.Log;
52	import org.apache.tomcat.InstanceManager;	53	import org.apache.tomcat.InstanceManager;
53	import org.apache.tomcat.util.ExceptionUtils;	54	import org.apache.tomcat.util.ExceptionUtils;
54	import org.apache.tomcat.util.res.StringManager;	55	import org.apache.tomcat.util.res.StringManager;
Lines 71-83 public class DefaultInstanceManager implements InstanceManager { Link Here
71	protected final ClassLoader containerClassLoader;	72	protected final ClassLoader containerClassLoader;
72	protected final boolean privileged;	73	protected final boolean privileged;
73	protected final boolean ignoreAnnotations;	74	protected final boolean ignoreAnnotations;
74	private final Properties restrictedFilters = new Properties();	75	private final Properties restrictedFilters;
75	private final Properties restrictedListeners = new Properties();	76	private final Properties restrictedListeners;
76	private final Properties restrictedServlets = new Properties();	77	private final Properties restrictedServlets;
77	private final Map<Class<?>, AnnotationCacheEntry[]> annotationCache =	78	private final Map<Class<?>, AnnotationCacheEntry[]> annotationCache =
78	new WeakHashMap<>();	79	new WeakHashMap<>();
79	private final Map<String, String> postConstructMethods;	80	private final Map<String, String> postConstructMethods;
80	private final Map<String, String> preDestroyMethods;	81	private final Map<String, String> preDestroyMethods;
		82
		83	private Properties loadProperties(String propertiesName, String errorString, Log logger) {
		84	Properties result = new Properties();
		85	InputStream is = this.getClass().getClassLoader().getResourceAsStream(propertiesName);
		86	if (is != null) {
		87	try {
		88	result.load(is);
		89	} catch (IOException e) {
		90	logger.error(errorString, e);
		91	} finally {
		92	try {
		93	is.close();
		94	} catch (IOException e) {
		95	// do nothing, since we either already read it, or got an exception already
		96	}
		97	}
		98	} else {
		99	logger.error(errorString);
		100	}
		101	return result;
		102	}
81		103
82	public DefaultInstanceManager(Context context,	104	public DefaultInstanceManager(Context context,
83	Map<String, Map<String, String>> injectionMap,	105	Map<String, Map<String, String>> injectionMap,
Lines 88-136 public class DefaultInstanceManager implements InstanceManager { Link Here
88	this.containerClassLoader = containerClassLoader;	110	this.containerClassLoader = containerClassLoader;
89	ignoreAnnotations = catalinaContext.getIgnoreAnnotations();	111	ignoreAnnotations = catalinaContext.getIgnoreAnnotations();
90	StringManager sm = StringManager.getManager(Constants.Package);	112	StringManager sm = StringManager.getManager(Constants.Package);
91	try {	113	restrictedServlets = loadProperties(
92	InputStream is =	114	"org/apache/catalina/core/RestrictedServlets.properties",
93	this.getClass().getClassLoader().getResourceAsStream	115	sm.getString("defaultInstanceManager.restrictedServletsResource"),
94	("org/apache/catalina/core/RestrictedServlets.properties");	116	catalinaContext.getLogger());
95	if (is != null) {	117	restrictedListeners = loadProperties(
96	restrictedServlets.load(is);	118	"org/apache/catalina/core/RestrictedListeners.properties",
97	} else {	119	"defaultInstanceManager.restrictedListenersResources",
98	catalinaContext.getLogger().error(sm.getString(	120	catalinaContext.getLogger());
99	"defaultInstanceManager.restrictedServletsResource"));	121	restrictedFilters = loadProperties(
100	}	122	"org/apache/catalina/core/RestrictedFilters.properties",
101	} catch (IOException e) {	123	"defaultInstanceManager.restrictedFiltersResource",
102	catalinaContext.getLogger().error(sm.getString(	124	catalinaContext.getLogger());
103	"defaultInstanceManager.restrictedServletsResource"), e);
104	}
105
106	try {
107	InputStream is =
108	this.getClass().getClassLoader().getResourceAsStream
109	("org/apache/catalina/core/RestrictedListeners.properties");
110	if (is != null) {
111	restrictedListeners.load(is);
112	} else {
113	catalinaContext.getLogger().error(sm.getString(
114	"defaultInstanceManager.restrictedListenersResources"));
115	}
116	} catch (IOException e) {
117	catalinaContext.getLogger().error(sm.getString(
118	"defaultInstanceManager.restrictedListenersResources"), e);
119	}
120	try {
121	InputStream is =
122	this.getClass().getClassLoader().getResourceAsStream
123	("org/apache/catalina/core/RestrictedFilters.properties");
124	if (is != null) {
125	restrictedFilters.load(is);
126	} else {
127	catalinaContext.getLogger().error(sm.getString(
128	"defaultInstanceManager.restrictedFiltersResource"));
129	}
130	} catch (IOException e) {
131	catalinaContext.getLogger().error(sm.getString(
132	"defaultInstanceManager.restrictedServletsResources"), e);
133	}
134	this.context = context;	125	this.context = context;
135	this.injectionMap = injectionMap;	126	this.injectionMap = injectionMap;
136	this.postConstructMethods = catalinaContext.findPostConstructMethods();	127	this.postConstructMethods = catalinaContext.findPostConstructMethods();
137	-