org.apache.juli.logging.Log Java Examples

private static void loadProperties(Set<String> classNames, String resourceName,
        String messageKey, Log log) {
    Properties properties = new Properties();
    ClassLoader cl = DefaultInstanceManager.class.getClassLoader();
    try (InputStream is = cl.getResourceAsStream(resourceName)) {
        if (is == null) {
            log.error(sm.getString(messageKey, resourceName));
        } else {
            properties.load(is);
        }
    } catch (IOException ioe) {
        log.error(sm.getString(messageKey, resourceName), ioe);
    }
    if (properties.isEmpty()) {
        return;
    }
    for (Map.Entry<Object, Object> e : properties.entrySet()) {
        if ("restricted".equals(e.getValue())) {
            classNames.add(e.getKey().toString());
        } else {
            log.warn(sm.getString(
                    "defaultInstanceManager.restrictedWrongValue",
                    resourceName, e.getKey(), e.getValue()));
        }
    }
}
 

public static void replaceSystemProperties() {
    Log log = LogFactory.getLog(Digester.class);
    if (propertySource != null) {
        IntrospectionUtils.PropertySource[] propertySources =
                new IntrospectionUtils.PropertySource[] { propertySource };
        Properties properties = System.getProperties();
        Set<String> names = properties.stringPropertyNames();
        for (String name : names) {
            String value = System.getProperty(name);
            if (value != null) {
                try {
                    String newValue = IntrospectionUtils.replaceProperties(value, null, propertySources, null);
                    if (!value.equals(newValue)) {
                        System.setProperty(name, newValue);
                    }
                } catch (Exception e) {
                    log.warn(sm.getString("digester.failedToUpdateSystemProperty", name, value), e);
                }
            }
        }
    }
}
 

/**
 * Return the Logger for this Container.
 */
@Override
public Log getLogger() {
    if (logger != null)
        return logger;
    logger = LogFactory.getLog(getLogName());
    return logger;
}
 

@Override
public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {

    String name = null;
    Principal principal = null;
    Subject subject = null;
    String[] groups = null;

    if (callbacks != null) {
        // Need to combine data from multiple callbacks so use this to hold
        // the data
        // Process the callbacks
        for (Callback callback : callbacks) {
            if (callback instanceof CallerPrincipalCallback) {
                CallerPrincipalCallback cpc = (CallerPrincipalCallback) callback;
                name = cpc.getName();
                principal = cpc.getPrincipal();
                subject = cpc.getSubject();
            } else if (callback instanceof GroupPrincipalCallback) {
                GroupPrincipalCallback gpc = (GroupPrincipalCallback) callback;
                groups = gpc.getGroups();
            } else {
                // This is a singleton so need to get correct Logger for
                // current TCCL
                Log log = LogFactory.getLog(CallbackHandlerImpl.class);
                log.error(sm.getString("callbackHandlerImpl.jaspicCallbackMissing",
                        callback.getClass().getName()));
            }
        }

        // Create the GenericPrincipal
        Principal gp = getPrincipal(principal, name, groups);
        if (subject != null && gp != null) {
            subject.getPrivateCredentials().add(gp);
        }
    }
}
 

/**
 * Load and return the Session associated with the specified session
 * identifier from this Store, without removing it.  If there is no
 * such stored Session, return <code>null</code>.
 *
 * @param id Session identifier of the session to load
 *
 * @exception ClassNotFoundException if a deserialization error occurs
 * @exception IOException if an input/output error occurs
 */
@Override
public Session load(String id) throws ClassNotFoundException, IOException {
    // Open an input stream to the specified pathname, if any
    File file = file(id);
    if (file == null) {
        return null;
    }

    if (!file.exists()) {
        return null;
    }

    Context context = getManager().getContext();
    Log contextLog = context.getLogger();

    if (contextLog.isDebugEnabled()) {
        contextLog.debug(sm.getString(getStoreName()+".loading", id, file.getAbsolutePath()));
    }

    ClassLoader oldThreadContextCL = context.bind(Globals.IS_SECURITY_ENABLED, null);

    try (FileInputStream fis = new FileInputStream(file.getAbsolutePath());
            ObjectInputStream ois = getObjectInputStream(fis)) {

        StandardSession session = (StandardSession) manager.createEmptySession();
        session.readObjectData(ois);
        session.setManager(manager);
        return session;
    } catch (FileNotFoundException e) {
        if (contextLog.isDebugEnabled()) {
            contextLog.debug("No persisted data file found");
        }
        return null;
    } finally {
        context.unbind(Globals.IS_SECURITY_ENABLED, oldThreadContextCL);
    }
}
 

public static void securityClassLoad(ClassLoader loader) {

        if (System.getSecurityManager() == null) {
            return;
        }

        final String basePackage = "org.apache.jasper.";
        try {
            // Ensure XMLInputFactory is loaded with Tomcat's class loader
            loader.loadClass(basePackage + "compiler.EncodingDetector");

            loader.loadClass(basePackage + "runtime.JspFactoryImpl$PrivilegedGetPageContext");
            loader.loadClass(basePackage + "runtime.JspFactoryImpl$PrivilegedReleasePageContext");

            loader.loadClass(basePackage + "runtime.JspRuntimeLibrary");

            loader.loadClass(basePackage + "runtime.ServletResponseWrapperInclude");
            loader.loadClass(basePackage + "runtime.TagHandlerPool");
            loader.loadClass(basePackage + "runtime.JspFragmentHelper");

            loader.loadClass(basePackage + "runtime.ProtectedFunctionMapper");

            loader.loadClass(basePackage + "runtime.PageContextImpl");
            loadAnonymousInnerClasses(loader, basePackage + "runtime.PageContextImpl");

            loader.loadClass(basePackage + "runtime.JspContextWrapper");

            // Trigger loading of class and reading of property
            SecurityUtil.isPackageProtectionEnabled();

            loader.loadClass(basePackage + "servlet.JspServletWrapper");

            loadAnonymousInnerClasses(loader, "runtime.JspWriterImpl");
        } catch (ClassNotFoundException ex) {
            Log log = LogFactory.getLog(SecurityClassLoad.class);
            log.error("SecurityClassLoad", ex);
        }
    }
 

private static String locationFor(String name) {
    URL location = CLASS_SERVLET_CONTEXT.getResource("resources/" + name);
    if (location == null && CLASS_JSP_CONTEXT != null) {
        location = CLASS_JSP_CONTEXT.getResource("resources/" + name);
    }
    if (location == null) {
        Log log = LogFactory.getLog(DigesterFactory.class);
        log.warn(sm.getString("digesterFactory.missingSchema", name));
        return null;
    }
    return location.toExternalForm();
}
 

/**
 * Return the Logger for this Container.
 */
@Override
public Log getLogger() {

    if (logger != null)
        return (logger);
    logger = LogFactory.getLog(logName());
    return (logger);

}
 

private Log getLog() {
    if (log == null) {
        synchronized (this) {
            if (log == null) {
                log = LogFactory.getLog(LazyReplicatedMap.class);
            }
        }
    }
    return log;
}
 

private Log getLog() {
    if (log == null) {
        synchronized (this) {
            if (log == null) {
                log = LogFactory.getLog(ReplicatedMap.class);
            }
        }
    }
    return log;
}
 

public UserDataHelper(Log log) {
    this.log = log;

    Config tempConfig;
    String configString = System.getProperty(
            "org.apache.juli.logging.UserDataHelper.CONFIG");
    if (configString == null) {
        tempConfig = Config.INFO_THEN_DEBUG;
    } else {
        try {
            tempConfig = Config.valueOf(configString);
        } catch (IllegalArgumentException iae) {
            // Ignore - use default
            tempConfig = Config.INFO_THEN_DEBUG;
        }
    }

    // Default suppression time of 1 day.
    suppressionTime = Integer.getInteger(
            "org.apache.juli.logging.UserDataHelper.SUPPRESSION_TIME",
            60 * 60 * 24).intValue() * 1000L;

    if (suppressionTime == 0) {
        tempConfig = Config.INFO_ALL;
    }

    config = tempConfig;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
public Log getLogger() {
    return null;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
public Log getLogger() {
    return log;
}
 

static <T> List<T> getEnabled(String name, Log log, boolean warnOnSkip, Collection<T> configured,
        Collection<T> implemented) {

    List<T> enabled = new ArrayList<>();

    if (implemented.size() == 0) {
        // Unable to determine the list of available protocols. This will
        // have been logged previously.
        // Use the configuredProtocols and hope they work. If not, an error
        // will be generated when the list is used. Not ideal but no more
        // can be done at this point.
        enabled.addAll(configured);
    } else {
        enabled.addAll(configured);
        enabled.retainAll(implemented);

        if (enabled.isEmpty()) {
            // Don't use the defaults in this case. They may be less secure
            // than the configuration the user intended.
            // Force the failure of the connector
            throw new IllegalArgumentException(
                    sm.getString("sslUtilBase.noneSupported", name, configured));
        }
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("sslUtilBase.active", name, enabled));
        }
        if (log.isDebugEnabled() || warnOnSkip) {
            if (enabled.size() != configured.size()) {
                List<T> skipped = new ArrayList<>();
                skipped.addAll(configured);
                skipped.removeAll(enabled);
                String msg = sm.getString("sslUtilBase.skipped", name, skipped);
                if (warnOnSkip) {
                    log.warn(msg);
                } else {
                    log.debug(msg);
                }
            }
        }
    }

    return enabled;
}
 

@Override
protected Log getLog() {return log;}
 

@Override
protected Log getLogger() {
    return log;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
protected Log getLog() { return log; }
 

@Override
protected Log getLog() { return log; }
 

@Override
protected Log getLogger() {
    return log;
}
 

@Override
protected Log getLogger() {
    return log;
}
 

@Override
protected Log getLog() {
    return log;
}
 

@Override
protected Log getLog() {return log;}
 

@Override
protected Log getLog() { return log; }
 

@Override
protected Log getLog() {
    return log;
}