/** * Creates key managers using the receiver's key store configuration. * @param context context for status messages * @return an array of key managers or {@code null} if no key store * configuration was provided * @throws NoSuchProviderException if a provider specified for one * of the key manager components is not known to the platform * @throws NoSuchAlgorithmException if an algorithm specified for * one of the key manager components is not known to the relevant * provider * @throws KeyStoreException if an error occurs in reading a key store */ private KeyManager[] createKeyManagers(ContextAware context) throws NoSuchProviderException, NoSuchAlgorithmException, UnrecoverableKeyException, KeyStoreException { if (getKeyStore() == null) return null; KeyStore keyStore = getKeyStore().createKeyStore(); context.addInfo( "key store of type '" + keyStore.getType() + "' provider '" + keyStore.getProvider() + "': " + getKeyStore().getLocation()); KeyManagerFactory kmf = getKeyManagerFactory().createKeyManagerFactory(); context.addInfo("key manager algorithm '" + kmf.getAlgorithm() + "' provider '" + kmf.getProvider() + "'"); char[] passphrase = getKeyStore().getPassword().toCharArray(); kmf.init(keyStore, passphrase); return kmf.getKeyManagers(); }
/** * Creates trust managers using the receiver's trust store configuration. * @param context context for status messages * @return an array of trust managers or {@code null} if no trust store * configuration was provided * @throws NoSuchProviderException if a provider specified for one * of the trust manager components is not known to the platform * @throws NoSuchAlgorithmException if an algorithm specified for * one of the trust manager components is not known to the relevant * provider * @throws KeyStoreException if an error occurs in reading a key * store containing trust anchors */ private TrustManager[] createTrustManagers(ContextAware context) throws NoSuchProviderException, NoSuchAlgorithmException, KeyStoreException { if (getTrustStore() == null) return null; KeyStore trustStore = getTrustStore().createKeyStore(); context.addInfo( "trust store of type '" + trustStore.getType() + "' provider '" + trustStore.getProvider() + "': " + getTrustStore().getLocation()); TrustManagerFactory tmf = getTrustManagerFactory() .createTrustManagerFactory(); context.addInfo("trust manager algorithm '" + tmf.getAlgorithm() + "' provider '" + tmf.getProvider() + "'"); tmf.init(trustStore); return tmf.getTrustManagers(); }
/** * @param contextAware the {@link ContextAware} implementation to which potential errors will be added */ public void addErrors(final ContextAware contextAware) { if (isEndpointInvalid()) { contextAware.addError("endpoint must not be null nor empty"); } if (isApiKeyInvalid()) { contextAware.addError("apiKey must not be null nor empty"); } if (isReleaseStageInvalid()) { contextAware.addError("releaseStage must not be null nor empty"); } if (isMetaProviderClassNameInValid()) { contextAware.addError("Could not instantiate class: " + getMetaDataProviderClassName().get() + ". " + "Make sure that you provided the fully qualified class name and that the class has a public " + "accessible default constructor."); } }
public static FlumeAvroManager create( final List<RemoteFlumeAgent> agents, final Properties overrides, final Integer batchSize, final Long reportingWindow, final Integer reporterMaxThreadPoolSize, final Integer reporterMaxQueueSize, final ContextAware context) { if (agents != null && agents.size() > 0) { Properties props = buildFlumeProperties(agents); props.putAll(overrides); return new FlumeAvroManager(props, reportingWindow, batchSize, reporterMaxThreadPoolSize, reporterMaxQueueSize, context); } else { context.addError("No valid agents configured"); } return null; }
private FlumeAvroManager(final Properties props, final Long reportingWindowReq, final Integer batchSizeReq, final Integer reporterMaxThreadPoolSizeReq, final Integer reporterMaxQueueSizeReq, final ContextAware context) { this.loggingContext = context; final int reporterMaxThreadPoolSize = reporterMaxThreadPoolSizeReq == null ? DEFAULT_REPORTER_MAX_THREADPOOL_SIZE : reporterMaxThreadPoolSizeReq; final int reporterMaxQueueSize = reporterMaxQueueSizeReq == null ? DEFAULT_REPORTER_MAX_QUEUE_SIZE : reporterMaxQueueSizeReq; this.reporter = new EventReporter(props, loggingContext, reporterMaxThreadPoolSize, reporterMaxQueueSize); this.evQueue = new ArrayBlockingQueue<Event>(1000); final long reportingWindow = hamonizeReportingWindow(reportingWindowReq); final int batchSize = batchSizeReq == null ? DEFAULT_BATCH_SIZE : batchSizeReq; this.asyncThread = new AsyncThread(evQueue, batchSize, reportingWindow); loggingContext.addInfo("Created a new flume agent with properties: " + props.toString()); asyncThread.start(); }
private static void initAndAddListener(KonkerLoggerContext loggerContext, StatusListener listener) { if(listener != null) { if(listener instanceof ContextAware) { ((ContextAware)listener).setContext(loggerContext); } if(listener instanceof LifeCycle) { ((LifeCycle)listener).start(); } loggerContext.getStatusManager().add(listener); } }
public static <E> void setContextForConverters(Context context, Converter<E> head) { Converter<E> c = head; while (c != null) { if (c instanceof ContextAware) { ((ContextAware) c).setContext(context); } c = c.getNext(); } }
/** * Convert <code>val</code> a String parameter to an object of a given type. */ @SuppressWarnings("unchecked") public static Object convertArg(ContextAware ca, String val, Class<?> type) { if (val == null) { return null; } String v = val.trim(); if (String.class.isAssignableFrom(type)) { return v; } else if (Integer.TYPE.isAssignableFrom(type)) { return new Integer(v); } else if (Long.TYPE.isAssignableFrom(type)) { return new Long(v); } else if (Float.TYPE.isAssignableFrom(type)) { return new Float(v); } else if (Double.TYPE.isAssignableFrom(type)) { return new Double(v); } else if (Boolean.TYPE.isAssignableFrom(type)) { if ("true".equalsIgnoreCase(v)) { return Boolean.TRUE; } else if ("false".equalsIgnoreCase(v)) { return Boolean.FALSE; } } else if (type.isEnum()) { return convertToEnum(ca, v, (Class<? extends Enum>) type); } else if (StringToObjectConverter.followsTheValueOfConvention(type)) { return convertByValueOfMethod(ca, type, v); } else if (isOfTypeCharset(type)) { return convertToCharset(ca, val); } return null; }
static private Charset convertToCharset(ContextAware ca, String val) { try { return Charset.forName(val); } catch (UnsupportedCharsetException e) { ca.addError("Failed to get charset [" + val + "]", e); return null; } }
private static Object convertByValueOfMethod(ContextAware ca, Class<?> type, String val) { try { Method valueOfMethod = type.getMethod(CoreConstants.VALUE_OF, STING_CLASS_PARAMETER); return valueOfMethod.invoke(null, val); } catch (Exception e) { ca.addError("Failed to invoke " + CoreConstants.VALUE_OF + "{} method in class [" + type.getName() + "] with value [" + val + "]"); return null; } }
public void begin(InterpretationContext ec, String name, Attributes attributes) throws ActionException { inError = false; String className = attributes.getValue(CLASS_ATTRIBUTE); if (OptionHelper.isEmpty(className)) { addError("Missing class name for statusListener. Near [" + name + "] line " + getLineNumber(ec)); inError = true; return; } try { statusListener = (StatusListener) OptionHelper.instantiateByClassName( className, StatusListener.class, context); ec.getContext().getStatusManager().add(statusListener); if (statusListener instanceof ContextAware) { ((ContextAware) statusListener).setContext(context); } addInfo("Added status listener of type [" + className + "]"); ec.pushObject(statusListener); } catch (Exception e) { inError = true; addError( "Could not create an StatusListener of type [" + className + "].", e); throw new ActionException(e); } }
public static void setSystemProperties(ContextAware contextAware, Properties props) { for (Object o : props.keySet()) { String key = (String) o; String value = props.getProperty(key); setSystemProperty(contextAware, key, value); } }
public static void setSystemProperty(ContextAware contextAware, String key, String value) { try { System.setProperty(key, value); } catch (SecurityException e) { contextAware.addError("Failed to set system property [" + key + "]", e); } }
private SecureRandom createSecureRandom(ContextAware context) throws NoSuchProviderException, NoSuchAlgorithmException { SecureRandom secureRandom = getSecureRandom().createSecureRandom(); context.addInfo("secure random algorithm '" + secureRandom.getAlgorithm() + "' provider '" + secureRandom.getProvider() + "'"); return secureRandom; }
@Override public void begin(InterpretationContext ec, String name, Attributes attributes) throws ActionException { inError = false; String className = attributes.getValue(CLASS_ATTRIBUTE); if (OptionHelper.isEmpty(className)) { addError("Mandatory \"" + CLASS_ATTRIBUTE + "\" attribute not set for <loggerContextListener> element"); inError = true; return; } try { lcl = (LoggerContextListener) OptionHelper.instantiateByClassName( className, LoggerContextListener.class, context); if(lcl instanceof ContextAware) { ((ContextAware) lcl).setContext(context); } ec.pushObject(lcl); addInfo("Adding LoggerContextListener of type [" + className + "] to the object stack"); } catch (Exception oops) { inError = true; addError("Could not create LoggerContextListener of type " + className + "].", oops); } }
private static void initAndAddListener(LoggerContext loggerContext, StatusListener listener) { if (listener != null) { if(listener instanceof ContextAware) // LOGBACK-767 ((ContextAware) listener).setContext(loggerContext); if(listener instanceof LifeCycle) // LOGBACK-767 ((LifeCycle) listener).start(); loggerContext.getStatusManager().add(listener); } }
@Override public SSLContext createContext(ContextAware context) throws NoSuchProviderException, NoSuchAlgorithmException, KeyManagementException, UnrecoverableKeyException, KeyStoreException, CertificateException { contextCreated = true; return super.createContext(context); }
@Override protected ContextAware postProcessBeforeInitializationInternal(ContextAware bean, String beanName) throws Exception { bean.setContext(LoggingInitializerRunListener.this.loggerContext); if (bean instanceof LoggerContextAware) { ((LoggerContextAware) bean).setLoggerContext(LoggingInitializerRunListener.this.loggerContext); } return bean; }
private <T extends LifeCycle> T buildLifeCycle(T lifeCycle, boolean start) { if (lifeCycle instanceof ContextAware) { ((ContextAware) lifeCycle).setContext(this.loggerContext); } if (start) { lifeCycle.start(); } return lifeCycle; }
/** * Starts the sender with the given {@code configuration} and {@code contextAware}. * * @param configuration the {@link Configuration} to apply * @param contextAware the {@link ContextAware} to use for error reporting */ public void start(final Configuration configuration, final ContextAware contextAware) { this.endpoint = configuration.getEndpointWithProtocol(); this.contextAware = contextAware; this.gsonProvider = new GsonProvider(configuration); this.client = createClient(); this.started = true; }
@Test public void addsNoErrorsForValidConfiguration() { // given configuration.setApiKey("someKey"); final ContextAware contextAware = mock(ContextAware.class); // when configuration.addErrors(contextAware); // then verifyZeroInteractions(contextAware); }
@Test public void addsErrorWhenEndpointIsInvalid() { // given configuration.setApiKey("someKey"); configuration.setEndpoint(null); final ContextAware contextAware = mock(ContextAware.class); // when configuration.addErrors(contextAware); // then verify(contextAware).addError("endpoint must not be null nor empty"); }
@Test public void addsErrorWhenApiKeyIsInvalid() { // given configuration.setApiKey(null); final ContextAware contextAware = mock(ContextAware.class); // when configuration.addErrors(contextAware); // then verify(contextAware).addError("apiKey must not be null nor empty"); }
@Test public void addsErrorWhenReleaseStageIsInvalid() { // given configuration.setApiKey("someKey"); configuration.setReleaseStage(null); final ContextAware contextAware = mock(ContextAware.class); // when configuration.addErrors(contextAware); // then verify(contextAware).addError("releaseStage must not be null nor empty"); }
@Test public void addsErrorWhenProviderClassNameIsInvalid() { // given configuration.setApiKey("someKey"); configuration.setMetaDataProviderClassName("foo.bar.SomeRandomClass"); final ContextAware contextAware = mock(ContextAware.class); // when configuration.addErrors(contextAware); // then verify(contextAware).addError("Could not instantiate class: foo.bar.SomeRandomClass. " + "Make sure that you provided the fully qualified class name and that the class " + "has a public accessible default constructor."); }
public EventReporter(final Properties properties, final ContextAware context, final int maximumThreadPoolSize, final int maxQueueSize) { BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(maxQueueSize); this.connectionProps = properties; this.loggingContext = context; int corePoolSize = 1; TimeUnit threadKeepAliveUnits = TimeUnit.SECONDS; int threadKeepAliveTime = 30; RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); this.es = new ThreadPoolExecutor(corePoolSize, maximumThreadPoolSize, threadKeepAliveTime, threadKeepAliveUnits, blockingQueue, handler); }
public void start(LifeCycle lifeCycle) { if (lifeCycle instanceof ContextAware) { ((ContextAware) lifeCycle).setContext(this.context); } lifeCycle.start(); }
@SuppressWarnings("unchecked") private static Object convertToEnum(ContextAware ca, String val, Class<? extends Enum> enumType) { return Enum.valueOf(enumType, val); }
public void begin(InterpretationContext ec, String localName, Attributes attributes) { // LogLog.debug("in NestComponentIA begin method"); // get the action data object pushed in isApplicable() method call IADataForComplexProperty actionData = (IADataForComplexProperty) actionDataStack .peek(); String className = attributes.getValue(CLASS_ATTRIBUTE); // perform variable name substitution className = ec.subst(className); Class<?> componentClass = null; try { if (!OptionHelper.isEmpty(className)) { componentClass = Loader.loadClass(className, context); } else { // guess class name via implicit rules PropertySetter parentBean = actionData.parentBean; componentClass = parentBean.getClassNameViaImplicitRules(actionData .getComplexPropertyName(), actionData.getAggregationType(), ec .getDefaultNestedComponentRegistry()); } if (componentClass == null) { actionData.inError = true; String errMsg = "Could not find an appropriate class for property [" + localName + "]"; addError(errMsg); return; } if (OptionHelper.isEmpty(className)) { addInfo("Assuming default type [" + componentClass.getName() + "] for [" + localName + "] property"); } actionData.setNestedComplexProperty(componentClass.newInstance()); // pass along the repository if (actionData.getNestedComplexProperty() instanceof ContextAware) { ((ContextAware) actionData.getNestedComplexProperty()) .setContext(this.context); } //addInfo("Pushing component [" + localName // + "] on top of the object stack."); ec.pushObject(actionData.getNestedComplexProperty()); } catch (Exception oops) { actionData.inError = true; String msg = "Could not create component [" + localName + "] of type [" + className + "]"; addError(msg, oops); } }
/** * Creates a new {@link SSLContext} using the receiver's configuration. * @param context context for status messages * @return {@link SSLContext} object * @throws NoSuchProviderException if a provider specified for one of the * JCA or JSSE components utilized in creating the context is not * known to the platform * @throws NoSuchAlgorithmException if a JCA or JSSE algorithm, protocol, * or type name specified for one of the context's components is not * known to a given provider (or platform default provider for the * component) * @throws KeyManagementException if an error occurs in creating a * {@link KeyManager} for the context * @throws UnrecoverableKeyException if a private key needed by a * {@link KeyManager} cannot be obtained from a key store * @throws KeyStoreException if an error occurs in reading the * contents of a key store * @throws CertificateException if an error occurs in reading the * contents of a certificate */ public SSLContext createContext(ContextAware context) throws NoSuchProviderException, NoSuchAlgorithmException, KeyManagementException, UnrecoverableKeyException, KeyStoreException, CertificateException { SSLContext sslContext = getProvider() != null ? SSLContext.getInstance(getProtocol(), getProvider()) : SSLContext.getInstance(getProtocol()); context.addInfo("SSL protocol '" + sslContext.getProtocol() + "' provider '" + sslContext.getProvider() + "'"); KeyManager[] keyManagers = createKeyManagers(context); TrustManager[] trustManagers = createTrustManagers(context); SecureRandom secureRandom = createSecureRandom(context); sslContext.init(keyManagers, trustManagers, secureRandom); return sslContext; }
public LoggerContextAwareBeanPostProcessor() { super(ContextAware.class); }
@Test public void isStartedAfterStart() { sender.start(mock(Configuration.class), mock(ContextAware.class)); assertThat(sender.isStarted(), is(true)); }
@Test public void isStoppedAfterStop() { sender.start(mock(Configuration.class), mock(ContextAware.class)); sender.stop(); assertThat(sender.isStopped(), is(true)); }
public LogExceptionHandler(ContextAware context) { this.context = context; }
public LoggingEventHandler(ContextAware contextAware, CountDownLatch latch, String errorMessage) { this.contextAware = contextAware; this.latch = latch; this.errorMessage = errorMessage; }
public ContextAwareExecutorService(ContextAware contextAware) { this.contextAware = contextAware; }