@Override protected ConfigUpdateNodeResponse nodeOperation(final NodeConfigUpdateRequest request) { final Map<String, Settings> setn = configurationRepository.reloadConfiguration(Arrays.asList(request.request.getConfigTypes())); String licenseText = null; if(setn.get("config") != null) { licenseText = setn.get("config").get("searchguard.dynamic.license"); } if(licenseText != null && !licenseText.isEmpty()) { try { final SearchGuardLicense license = new SearchGuardLicense(XContentHelper.convertToMap(XContentType.JSON.xContent(), LicenseHelper.validateLicense(licenseText), true), clusterService); if(!license.isValid()) { logger.warn("License "+license.getUid()+" is invalid due to "+license.getMsgs()); //throw an exception here if loading of invalid license should be denied } } catch (Exception e) { logger.error("Invalid license",e); return new ConfigUpdateNodeResponse(clusterService.localNode(), new String[0], "Invalid license: "+e); } } backendRegistry.get().invalidateCache(); return new ConfigUpdateNodeResponse(clusterService.localNode(), setn.keySet().toArray(new String[0]), null); } }
@Override public T get() { if (lookup.delegate == null) { throw new IllegalStateException( "This Provider cannot be used until the Injector has been created."); } return lookup.delegate.get(); }
@Override public Map<K, V> get() { Map<K, V> map = new LinkedHashMap<>(); for (Entry<K, Provider<V>> entry : mapProvider.get().entrySet()) { V value = entry.getValue().get(); K key = entry.getKey(); Multibinder.checkConfiguration(value != null, "Map injection failed due to null value for key \"%s\"", key); map.put(key, value); } return Collections.unmodifiableMap(map); }
@Override public <T> T getInstance(Class<T> type) { return getProvider(type).get(); }
@Override public T get() { Object[] parameters = new Object[parameterProviders.size()]; for (int i = 0; i < parameters.length; i++) { parameters[i] = parameterProviders.get(i).get(); } try { // We know this cast is safe because T is the method's return type. @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"}) T result = (T) method.invoke(instance, parameters); return result; } catch (IllegalAccessException e) { throw new AssertionError(e); } catch (InvocationTargetException e) { throw new RuntimeException(e); } }
@Override public <T> T getInstance(Key<T> key) { return getProvider(key).get(); }
@SuppressWarnings({"unchecked", "unused"}) // code is silly stupid with generics @Inject public void initialize() { binder.binder = null; Map<K, Provider<V>> providerMapMutable = new LinkedHashMap<>(); for (Entry<K, Provider<V>> entry : provider.get()) { Multibinder.checkConfiguration(providerMapMutable.put(entry.getKey(), entry.getValue()) == null, "Map injection failed due to duplicated key \"%s\"", entry.getKey()); } providerMap = Collections.unmodifiableMap(providerMapMutable); }
@Override public void makeAllBindingsToEagerSingletons(Injector injector) { Map<Key<?>, Binding<?>> x = new LinkedHashMap<>(); for (Map.Entry<Key<?>, Binding<?>> entry : this.explicitBindingsMutable.entrySet()) { Key key = entry.getKey(); BindingImpl<?> binding = (BindingImpl<?>) entry.getValue(); Object value = binding.getProvider().get(); x.put(key, new InstanceBindingImpl<Object>(injector, key, SourceProvider.UNKNOWN_SOURCE, new InternalFactory.Instance(value), emptySet(), value)); } this.explicitBindingsMutable.clear(); this.explicitBindingsMutable.putAll(x); }
@Override public Set<T> get() { checkConfiguration(isInitialized(), "Multibinder is not initialized"); Set<T> result = new LinkedHashSet<>(); for (Provider<T> provider : providers) { final T newValue = provider.get(); checkConfiguration(newValue != null, "Set injection failed due to null element"); checkConfiguration(result.add(newValue), "Set injection failed due to duplicated element \"%s\"", newValue); } return Collections.unmodifiableSet(result); }
@Override public T get(Errors errors, InternalContext context, Dependency<?> dependency) throws ErrorsException { errors = errors.withSource(providerKey); Provider<? extends T> provider = providerFactory.get(errors, context, dependency); try { return errors.checkForNull(provider.get(), source, dependency); } catch (RuntimeException userException) { throw errors.errorInProvider(userException).toException(); } }
@Override public T get(Errors errors, InternalContext context, Dependency<?> dependency) throws ErrorsException { try { return errors.checkForNull(initializable.get(errors).get(), source, dependency); } catch (RuntimeException userException) { throw errors.withSource(source).errorInProvider(userException).toException(); } }
@Override public T get(Errors errors, InternalContext context, Dependency dependency) throws ErrorsException { errors = errors.withSource(providerKey); Provider<?> provider = providerBinding.getInternalFactory().get( errors, context, dependency); try { Object o = provider.get(); if (o != null && !rawType.isInstance(o)) { throw errors.subtypeNotProvided(providerType, rawType).toException(); } @SuppressWarnings("unchecked") // protected by isInstance() check above T t = (T) o; return t; } catch (RuntimeException e) { throw errors.errorInProvider(e).toException(); } } };
@Override public T get() { if (lookup.delegate == null) { throw new IllegalStateException( "This Provider cannot be used until the Injector has been created."); } return lookup.delegate.get(); }
@Override public T get() { if (lookup.delegate == null) { throw new IllegalStateException( "This Provider cannot be used until the Injector has been created."); } return lookup.delegate.get(); }
@Override public T get() { if (lookup.delegate == null) { throw new IllegalStateException( "This Provider cannot be used until the Injector has been created."); } return lookup.delegate.get(); }
@Override public Map<K, V> get() { Map<K, V> map = new LinkedHashMap<>(); for (Entry<K, Provider<V>> entry : mapProvider.get().entrySet()) { V value = entry.getValue().get(); K key = entry.getKey(); Multibinder.checkConfiguration(value != null, "Map injection failed due to null value for key \"%s\"", key); map.put(key, value); } return Collections.unmodifiableMap(map); }
@Override public Map<K, V> get() { Map<K, V> map = new LinkedHashMap<>(); for (Entry<K, Provider<V>> entry : mapProvider.get().entrySet()) { V value = entry.getValue().get(); K key = entry.getKey(); Multibinder.checkConfiguration(value != null, "Map injection failed due to null value for key \"%s\"", key); map.put(key, value); } return Collections.unmodifiableMap(map); }
@Override public Map<K, V> get() { Map<K, V> map = new LinkedHashMap<>(); for (Entry<K, Provider<V>> entry : mapProvider.get().entrySet()) { V value = entry.getValue().get(); K key = entry.getKey(); Multibinder.checkConfiguration(value != null, "Map injection failed due to null value for key \"%s\"", key); map.put(key, value); } return Collections.unmodifiableMap(map); }
String stringValue = stringBinding.getProvider().get(); Object source = stringBinding.getSource();
@Override public T get() { checkState(lookup.delegate != null, "This Provider cannot be used until the Injector has been created."); return lookup.delegate.get(); }