Example usage for org.apache.commons.configuration ConfigurationException getClass

List of usage examples for org.apache.commons.configuration ConfigurationException getClass

Introduction

In this page you can find the example usage for org.apache.commons.configuration ConfigurationException getClass.

Prototype

@HotSpotIntrinsicCandidate
public final native Class<?> getClass();

Source Link

Document

Returns the runtime class of this Object .

Usage

From source file:org.sakaiproject.dash.dao.impl.DashboardDaoImpl.java

/**
 * Loads our SQL statements from the appropriate properties file
 * @param vendor   DB vendor string. Must be one of mysql, oracle, hsqldb
 *///from   w  w w.  j  a  va 2 s  .  co  m
protected void initStatements(String vendor) {

    URL url = getClass().getClassLoader().getResource(vendor + ".properties");

    try {
        statements = new PropertiesConfiguration(); //must use blank constructor so it doesn't parse just yet (as it will split)
        statements.setReloadingStrategy(new InvariantReloadingStrategy()); //don't watch for reloads
        statements.setThrowExceptionOnMissing(true); //throw exception if no prop
        statements.setDelimiterParsingDisabled(true); //don't split properties
        statements.load(url); //now load our file
    } catch (ConfigurationException e) {
        log.warn(e.getClass() + ": " + e.getMessage());
        return;
    }
}

From source file:org.sakaiproject.delegatedaccess.dao.impl.DelegatedAccessDaoImpl.java

/**
 * Loads our SQL statements from the appropriate properties file
         // w ww .j  ava2  s .  com
 * @param vendor   DB vendor string. Must be one of mysql, oracle, hsqldb
 */
private void initStatements(String vendor) {

    URL url = getClass().getClassLoader().getResource(vendor + ".properties");

    try {
        statements = new PropertiesConfiguration(); //must use blank constructor so it doesn't parse just yet (as it will split)
        statements.setReloadingStrategy(new InvariantReloadingStrategy()); //don't watch for reloads
        statements.setThrowExceptionOnMissing(true); //throw exception if no prop
        statements.setDelimiterParsingDisabled(true); //don't split properties
        statements.load(url); //now load our file
    } catch (ConfigurationException e) {
        log.error(e.getClass() + ": " + e.getMessage(), e);
        return;
    }
}

From source file:pl.bristleback.server.bristle.conf.resolver.init.PropertiesFileConfigResolver.java

private void getPropertiesFromFileName() {
    try {//from www.  j a v  a 2s .  c  o  m
        if (StringUtils.isBlank(configurationPath)) {
            configurationPath = DEFAULT_CONFIG_FILE_LOCATION;
        }
        propertiesConfiguration = new PropertiesConfiguration(configurationPath);
    } catch (ConfigurationException e) {
        throw new BristleInitializationException("Unexpected " + e.getClass().getSimpleName()
                + " has occurred while resolving Bristleback properties file", e);
    }
}

From source file:tld.yourname.jms.server.JMSServer.java

/**
 *
 * @param aArgs//  w  ww  . j  a va 2s  .c o m
 * @return
 */
public JWSEndPoint start(String[] aArgs) {
    // set up log4j logging
    // later this should be read from a shared log4j properties or xml file!
    Properties lProps = new Properties();
    lProps.setProperty("log4j.rootLogger", "INFO, console");
    lProps.setProperty("log4j.logger.org.apache.activemq", "WARN");
    lProps.setProperty("log4j.logger.org.springframework", "WARN");
    lProps.setProperty("log4j.logger.org.apache.xbean", "WARN");
    lProps.setProperty("log4j.logger.org.apache.camel", "INFO");
    lProps.setProperty("log4j.logger.org.eclipse.jetty", "WARN");
    lProps.setProperty("log4j.appender.console", "org.apache.log4j.ConsoleAppender");
    lProps.setProperty("log4j.appender.console.layout", "org.apache.log4j.PatternLayout");
    lProps.setProperty("log4j.appender.console.layout.ConversionPattern",
            // "%p: %m%n"
            "%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p - %C{1}: %m%n");
    // set here the jWebSocket log level:
    lProps.setProperty("log4j.logger.org.jwebsocket", "DEBUG");
    lProps.setProperty("log4j.appender.console.threshold", "DEBUG");
    PropertyConfigurator.configure(lProps);

    final JWSAutoSelectAuthenticator lAuthenticator = new JWSAutoSelectAuthenticator();
    final JWSOAuthAuthenticator lOAuthAuthenticator = new JWSOAuthAuthenticator();
    final JWSLDAPAuthenticator lLDAPAuthenticator = new JWSLDAPAuthenticator();

    mLog.info("jWebSocket JMS Gateway Server Endpoint");
    Configuration lConfig = null;
    boolean lConfigLoaded;
    try {
        // try to load properties files from local folder or jar
        String lPath = "JMSServer.properties";
        mLog.debug("Trying to read properties from: " + lPath);
        lConfig = new PropertiesConfiguration(lPath);
    } catch (ConfigurationException ex) {
    }
    if (null == lConfig) {
        try {
            // try to load properties files from JWEBSOCKET_HOME/conf/JMSPlugIn
            String lPath = Tools.expandEnvVarsAndProps("/private/JMSServer.properties");
            // String lPath = Tools.expandEnvVarsAndProps("${JWEBSOCKET_HOME}conf/JMSPlugIn/JMSServer.properties");
            mLog.debug("Tring to read properties from: " + lPath);
            lConfig = new PropertiesConfiguration(lPath);
        } catch (ConfigurationException ex) {
        }
    }
    if (null == lConfig) {
        mLog.error("Configuration file could not be opened.");
        return null;
    }

    // the URL of the message broker
    String lBrokerURL = lConfig.getString("BrokerURL", "tcp://127.0.0.1:61616");
    // "failover:(tcp://0.0.0.0:61616,tcp://127.0.0.1:61616)?initialReconnectDelay=100&randomize=false";
    // the name of the JMS Gateway topic
    String lGatewayTopic = lConfig.getString("GatewayTopic", "org.jwebsocket.jms.gateway");
    // endpoint id of JMS Gateway
    String lGatewayId = lConfig.getString("GatewayId", "org.jwebsocket.jms.gateway");
    String lEndPointId = lConfig.getString("EndPointId", UUID.randomUUID().toString());

    // get authentication information against jWebSocket
    final String lJWSUsername = lConfig.getString("JWSUsername");
    final String lJWSPassword = lConfig.getString("JWSPassword");
    final boolean lFullTextLogging = lConfig.getBoolean("FullTextLogging", false);

    // set up OAuth Authenticator
    boolean lUseOAuth = lConfig.getBoolean("UseOAuth", false);

    String lOAuthHost = lConfig.getString("OAuthHost");
    String lOAuthAppId = lConfig.getString("OAuthAppId");
    String lOAuthAppSecret = lConfig.getString("OAuthAppSecret");
    String lOAuthUsername = lConfig.getString("OAuthUsername");
    String lOAuthPassword = lConfig.getString("OAuthPassword");
    long lOAuthTimeout = lConfig.getLong("OAuthTimeout", 5000);

    lUseOAuth = lUseOAuth && null != lOAuthHost && null != lOAuthAppId && null != lOAuthAppSecret
            && null != lOAuthUsername && null != lOAuthPassword;

    if (lUseOAuth) {
        lOAuthAuthenticator.init(lOAuthHost, lOAuthAppId, lOAuthAppSecret, lOAuthTimeout);
        lAuthenticator.addAuthenticator(lOAuthAuthenticator);
    }

    // set up LDAP Authenticator
    boolean lUseLDAP = lConfig.getBoolean("UseLDAP", false);

    String lLDAPURL = lConfig.getString("LDAPURL");
    String lBaseDNGroups = lConfig.getString("BaseDNGroups");
    String lBaseDNUsers = lConfig.getString("BaseDNUsers");

    if (lUseLDAP) {
        lLDAPAuthenticator.init(lLDAPURL, lBaseDNGroups, lBaseDNUsers);
        lAuthenticator.addAuthenticator(lLDAPAuthenticator);
    }

    // TODO: Validate config data here!
    lConfigLoaded = true;

    if (!lConfigLoaded) {
        mLog.error("Config not loaded.");
        System.exit(1);
    }

    mLog.info("Using: " + lBrokerURL + ", " + "topic: " + lGatewayTopic + ", " + "gateway-id: " + lGatewayId
            + ", " + "endpoint-id: " + lEndPointId);

    // todo: Comment that for production purposes
    JMSLogging.setFullTextLogging(lFullTextLogging);

    // instantiate a new jWebSocket JMS Gateway Client
    try {
        lJWSEndPoint = JWSEndPoint.getInstance(lBrokerURL, lGatewayTopic, // gateway topic
                lGatewayId, // gateway endpoint id
                lEndPointId, // unique node id
                5, // thread pool size, messages being processed concurrently
                JMSEndPoint.TEMPORARY // durable (for servers) or temporary (for clients)
        );
    } catch (JMSException lEx) {
        mLog.fatal("JMSEndpoint could not be instantiated: " + lEx.getMessage());
        System.exit(0);
    }

    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.gateway", "welcome",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {
                    mLog.info("Received 'welcome', authenticating against jWebSocket...");
                    Token lToken = TokenFactory.createToken("org.jwebsocket.plugins.system", "login");
                    lToken.setString("username", lJWSUsername);
                    lToken.setString("password", lJWSPassword);
                    sendToken(aSourceId, lToken);
                }
            });

    // on response of the login...
    lJWSEndPoint.addResponseListener("org.jwebsocket.plugins.system", "login",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {
                    int lCode = aToken.getInteger("code", -1);
                    if (0 == lCode) {
                        if (mLog.isInfoEnabled()) {
                            mLog.info("Authentication against jWebSocket successful.");
                        }
                    } else {
                        mLog.error("Authentication against jWebSocket failed!");
                    }
                }
            });

    // on response of the login...
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "getUser", new JWSMessageListener(lJWSEndPoint) {
        @Override
        public void processToken(String aSourceId, Token aToken) {
            String lPayload = aToken.getString("payload");
            if (mLog.isInfoEnabled()) {
                mLog.info("Processing 'getUser'...");
            }
        }
    });

    // on response of the login...
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "echo", new JWSMessageListener(lJWSEndPoint) {
        @Override
        public void processToken(String aSourceId, Token aToken) {
            String lPayload = aToken.getString("payload");
            if (mLog.isInfoEnabled()) {
                mLog.info("Processing 'demo1 with Payload '" + lPayload + "'");
            }
            Map<String, Object> lAdditionalResults = new FastMap<String, Object>();
            lAdditionalResults.putAll(aToken.getMap());
            // lAdditionalResults.remove("sourceId");
            lAdditionalResults.remove("payload");
            lJWSEndPoint.respondPayload(aToken, 0, // return code
                    "Ok", // return message
                    lAdditionalResults, aToken.getString("payload"));
        }
    });

    // on response of the login...
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "testProgress",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                @SuppressWarnings("SleepWhileInLoop")
                public void processToken(String aSourceId, Token aToken) {
                    int lMax = 10;
                    for (int lIdx = 0; lIdx < lMax; lIdx++) {
                        mLog.debug("Progress iteration " + lIdx + "...");
                        try {
                            Thread.sleep(333);
                        } catch (InterruptedException lEx) {
                        }
                        lJWSEndPoint.sendProgress(aToken, ((lIdx + 1.0) / lMax) * 100, 0, "Iteration #" + lIdx,
                                null);
                    }
                    lJWSEndPoint.respondPayload(aToken, 0, // return code
                            "Ok", // return message
                            null, aToken.getString("payload"));
                }
            });

    // ...
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "testCaughtException",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {
                    mLog.debug("Testing caught exception...");
                    // provoke null pointer exception and DO catch it for test purposes
                    int a = 1;
                    int b = 0;
                    try {
                        int c = a / b;
                        lJWSEndPoint.respondPayload(aToken, 0, // return code
                                "Ok", // return message
                                null, aToken.getString("payload"));
                    } catch (Exception Ex) {
                        lJWSEndPoint.respondPayload(aToken, -1, // return code
                                Ex.getClass().getSimpleName() + ": " + Ex.getMessage(), // return message
                                null, aToken.getString("payload"));
                    }
                }
            });

    // ...
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "testUncaughtException",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {
                    mLog.debug("Testing uncaught exception...");
                    // provoke null pointer exception and do NOT catch it for test purposes
                    int a = 1;
                    int b = 0;
                    int c = a / b;

                    lJWSEndPoint.respondPayload(aToken, 0, // return code
                            "Ok", // return message
                            null, aToken.getString("payload"));
                }
            });

    // test for the OAuth interface
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "testOAuth",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {

                    Map<String, Object> lArgs = new FastMap<String, Object>();

                    String lUsername;
                    int lCode = 0;
                    String lMessage = "Ok";
                    try {
                        lUsername = lOAuthAuthenticator.authToken(aToken);
                        if (null == lUsername) {
                            lCode = -1;
                            lMessage = "User could not be authenticated!";
                        } else {
                            lArgs.put("username", lUsername);
                        }
                    } catch (JMSEndpointException ex) {
                        lCode = -1;
                        lMessage = ex.getClass().getSimpleName() + " on authentication: " + ex.getMessage();
                    }

                    lJWSEndPoint.respondPayload(aToken, lCode, // return code
                            lMessage, // return message
                            lArgs, // additional result fields
                            null); // payload
                }
            });

    // test for the LDAP interface
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "testLDAP",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {

                    Map<String, Object> lArgs = new FastMap<String, Object>();

                    String lUsername;
                    int lCode = 0;
                    String lMessage = "Ok";
                    try {
                        lUsername = lLDAPAuthenticator.authToken(aToken);
                        if (null == lUsername) {
                            lCode = -1;
                            lMessage = "User could not be authenticated!";
                        } else {
                            lArgs.put("username", lUsername);
                        }
                    } catch (JMSEndpointException ex) {
                        lCode = -1;
                        lMessage = ex.getClass().getSimpleName() + " on authentication: " + ex.getMessage();
                    }

                    lJWSEndPoint.respondPayload(aToken, lCode, // return code
                            lMessage, // return message
                            lArgs, // additional result fields
                            null); // payload
                }
            });

    // test for the auto authentication interface
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "testAuth",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {

                    mLog.debug("Testing auto authenticator...");
                    Map<String, Object> lArgs = new FastMap<String, Object>();

                    String lUsername;
                    int lCode = 0;
                    String lMessage = "Ok";
                    try {
                        checkADUsername(aToken);
                        lUsername = lAuthenticator.authToken(aToken);
                        if (null == lUsername) {
                            lCode = -1;
                            lMessage = "User could not be authenticated!";
                        } else {
                            lArgs.put("username", lUsername);
                        }
                    } catch (JMSEndpointException lEx) {
                        lCode = -1;
                        lMessage = lEx.getClass().getSimpleName() + " on auto authentication: "
                                + lEx.getMessage();
                    }

                    lJWSEndPoint.respondPayload(aToken, lCode, // return code
                            lMessage, // return message
                            lArgs, // additional result fields
                            null); // payload
                }
            });

    lJWSEndPoint.addRequestListener("tld.yourname.jms", "transferFile", new JWSMessageListener(lJWSEndPoint) {
        @Override
        public void processToken(String aSourceId, Token aToken) {
            // here you can get the additional arguments
            mLog.info("Received 'transferFile' with additional args" + " (arg1=" + aToken.getString("arg1")
                    + " (arg2=" + aToken.getString("arg2") + ")...");
            // here you get the payload from the requester
            String lPayload = aToken.getString("payload");
            // parse the JSON payload into a Token (for simpler processing)
            Token lToken = JSONProcessor.JSONStringToToken(lPayload);
            // extract the base64 and compressed file contents into Strings 
            // (it's a text message)
            // String lBase64Encoded = lToken.getString("fileAsBase64");
            String lBase64Zipped = lToken.getString("fileAsZip");

            // specify the target file
            File lFile = new File("Apache License 2.0 (copy).txt");
            try {
                // take the zipped version of the file... 
                byte[] lBA = Tools.unzip(lBase64Zipped.getBytes("UTF-8"), Boolean.TRUE);
                // and save it to the hard disk
                FileUtils.writeByteArrayToFile(lFile, lBA);
            } catch (Exception lEx) {
                mLog.error("Demo file " + lFile.getAbsolutePath() + " could not be saved!");
            }
        }
    });

    // add a high level listener to listen in coming messages
    lJWSEndPoint.addRequestListener("org.jwebsocket.jms.demo", "helloWorld",
            new JWSMessageListener(lJWSEndPoint) {
                @Override
                public void processToken(String aSourceId, Token aToken) {
                    mLog.info("Received 'helloWorld'...");
                    lJWSEndPoint.respondPayload(aToken.getString("sourceId"), aToken, 0, // return code
                            "Ok", // return message
                            null, // here you can add additional results beside the payload
                            "Hello World!");
                }
            });

    // start the endpoint all all listener have been assigned
    lJWSEndPoint.start();
    return lJWSEndPoint;
}