private static String getConfigProperty(String propertyName) { return ConfigurationUtil.getProperty(propertyName); }
/** * Returns the public address of the host if the public address feature is enabled. Otherwise, * returns the API (default) address of the host. */ public static void getHostPublicAddress(ServiceHost serviceHost, ComputeState computeHost, Consumer<String> addressConsumer) { AssertUtil.assertNotNull(serviceHost, "serviceHost"); AssertUtil.assertNotNull(computeHost, "computeHost"); ConfigurationUtil.getConfigProperty(serviceHost, FEATURE_TOGGLE_HOST_PUBLIC_ADDRESS, (publicAddressEnabled) -> { // if the feature toggle is disabled, use the host address if (publicAddressEnabled == null || !Boolean.valueOf(publicAddressEnabled)) { addressConsumer.accept(computeHost.address); return; } // try to obtain and use the public address of the host. If it is not available, // fall back to the host address if (computeHost.customProperties == null) { addressConsumer.accept(computeHost.address); return; } String publicAddress = computeHost.customProperties .get(ContainerHostService.HOST_PUBLIC_ADDRESS_PROP_NAME); if (publicAddress == null || publicAddress.isEmpty()) { addressConsumer.accept(computeHost.address); } else { addressConsumer.accept(publicAddress); } }); }
/** * Checks whether the document specified is a {@link CompositeDescription} in embedded. * Templates ({@link CompositeDescription} instances) in embedded mode are shared among all * projects so the project tenant link must not be added. * * @return whether addition of the project tenant link should be skipped or not */ private static boolean skipAddProjectTenantLink(MultiTenantDocument document) { return ConfigurationUtil.isEmbedded() && document.documentKind != null && document.documentKind.equals(TEMPLATE_DOCUMENT_KIND); }
if (!ConfigurationUtil.isEmbedded()) { return DeferredResult.completed(null); ConfigurationUtil.getConfigProperty(serviceHost, ConfigurationUtil.VCH_MIN_VERSION_INCLUSIVE_PROPERTY, (minVersionInclusive) -> { ConfigurationUtil.getConfigProperty(serviceHost, ConfigurationUtil.VCH_MAX_VERSION_EXCLUSIVE_PROPERTY, (maxVersionExclusive) -> {
@Before public void before() { // see comment in UiService's isEmbedded assignment ConfigurationState config = new ConfigurationState(); config.key = ConfigurationUtil.EMBEDDED_MODE_PROPERTY; config.value = Boolean.toString(false); ConfigurationUtil.initialize(config); }
public static String encode(String principalId) { if (ConfigurationUtil.isVca()) { return principalId; } if (principalId == null || principalId.isEmpty()) { return principalId; } if (!principalId.contains(ENCODE_MARKER)) { return principalId; } return new String(Base64.getUrlEncoder().encode( principalId.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); }
isEmbedded = ConfigurationUtil.isEmbedded(); isVca = ConfigurationUtil.isVca();
private static void configurePullFromRegistry(String runtime, String registryUrl) { ConfigurationState[] configs = ConfigurationService.getConfigurationProperties(); List<ConfigurationState> newConfigs = Arrays.stream(configs).collect(Collectors.toList()); ConfigurationState confState = findConfigPropertyState(newConfigs, runtime); if (confState != null) { confState.value = registryUrl; } else { confState = new ConfigurationState(); confState.key = ClosureProps.CLOSURE_RUNTIME_IMAGE_REGISTRY + runtime; confState.value = registryUrl; newConfigs.add(confState); } ConfigurationUtil.initialize(newConfigs.toArray(new ConfigurationState[newConfigs.size()])); }
public static String decode(String principalId) { if (ConfigurationUtil.isVca()) { return principalId; } if (principalId == null || principalId.isEmpty()) { return principalId; } if (principalId.contains(ENCODE_MARKER)) { return principalId; } try { return new String(Base64.getUrlDecoder().decode( principalId.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); } catch (IllegalArgumentException iae) { if (iae.getMessage().contains("Illegal base64 character") || (iae.getMessage().contains("Last unit does not have enough valid bits"))) { // In this case principal id is not encoded string without @ sign in it // so the decoding is failing, we return the same string. return principalId; } throw new RuntimeException(iae); } } }
@Test public void testEncodeDecodeVca() { ConfigurationState config = new ConfigurationState(); config.key = ConfigurationUtil.VCA_MODE_PROPERTY; config.value = Boolean.toString(true); ConfigurationUtil.initialize(config); String fritzEmail = "fritz@admiral.com"; String encodedEmail = encode(fritzEmail); assertEquals(fritzEmail, encodedEmail); String decodedEmail = decode(encodedEmail); assertEquals(fritzEmail, decodedEmail); ConfigurationUtil.initialize((ConfigurationState[]) null); }
/** * Returns whether Admiral is running on embedded mode or not based on the "embedded" * configuration property. */ public static boolean isEmbedded() { return Boolean.valueOf(ConfigurationUtil.getProperty(EMBEDDED_MODE_PROPERTY)); }
private void makeSubscription(CommandInput input, Operation op, ComputeState computeState, URI uri, Boolean simulateIOExceptionPropertyValue) { boolean maxAllowedNumberOfThreadsExceeded = maxAllowedNumberOfThreadsExceeded(); if (maxAllowedNumberOfThreadsExceeded) { return; } if (simulateIOExceptionPropertyValue == null) { ConfigurationUtil.getConfigProperty(host, ConfigurationUtil.THROW_IO_EXCEPTION, (prop) -> { Boolean b = Boolean.valueOf(prop); makeSubscription(input, op, computeState, uri, b); }); return; } EventsMonitor eventsMonitor = new EventsMonitor( op, uri, input, computeState, simulateIOExceptionPropertyValue); executor.submit(eventsMonitor); }
@Override public void authorizeRequest(Operation op) { if (ConfigurationUtil.isEmbedded()) { op.complete(); return; } super.authorizeRequest(op); }
public static void startServices(ServiceHost host) { startServices(host, CompositeDescriptionTransformationService.class, ContainersTransformationService.class, ComputePlacementPoolRelationTransformationService.class, ContainerVolumesTransformationService.class, ContainerNetworksTransformationService.class, CompositeComponentsTransformationService.class, ResourcePoolTransformationService.class); if (!ConfigurationUtil.isVca()) { startServiceFactories(host, ProjectsTransformationBootstrapService.class); } } }
config.key = "embedded"; config.value = Boolean.toString(true); ConfigurationUtil.initialize(config); config.key = "embedded"; config.value = Boolean.toString(false); ConfigurationUtil.initialize(config);
/** * Checks for additional runtimes that are not provided out of the box. We need to provide * registry to download the image from. * * @param runtime * @return */ public static boolean isAdditionalRuntimeSwitchedOn(String runtime) { String runtimeOn = ConfigurationUtil .getProperty(ClosureProps.CLOSURE_RUNTIME_IMAGE_REGISTRY + runtime); return !(runtimeOn == null || runtimeOn.isEmpty()); }
ConfigurationUtil.getConfigProperty(this, ConfigurationUtil.EMBEDDED_MODE_PROPERTY, (embedded) -> { isEmbedded = Boolean.valueOf(embedded); ConfigurationUtil.getConfigProperty(this, ConfigurationUtil.VIC_MODE_PROPERTY, (vic) -> { isVic = Boolean.valueOf(vic); ConfigurationUtil.getConfigProperty(this, ConfigurationUtil.ALLOW_SSH_CONSOLE_PROPERTY, (sshConsole) -> { allowSshConsole = Boolean.valueOf(sshConsole);
@Override public void authorizeRequest(Operation op) { if (ConfigurationUtil.isEmbedded()) { op.complete(); return; } super.authorizeRequest(op); }
/** * Start all services required to support management of infrastructure and applications. */ protected void startCommonServices() throws Throwable { this.log(Level.INFO, "Common service starting ..."); HostInitCommonServiceConfig.startServices(this); HostInitAuthServiceConfig.startServices(this); HostInitUpgradeServiceConfig.startServices(this); registerForServiceAvailability(AuthBootstrapService.startTask(this), true, AuthBootstrapService.FACTORY_LINK); if (!ConfigurationUtil.isVca()) { registerForServiceAvailability(ProjectsTransformationBootstrapService.startTask(this), true, ProjectsTransformationBootstrapService.FACTORY_LINK, ProjectFactoryService.SELF_LINK); } this.log(Level.INFO, "Common services started."); }
@Test public void testDeleteDefaultRegistryOnStartup() throws Throwable { RegistryState registryState = new RegistryState(); registryState.documentSelfLink = RegistryService.DEFAULT_INSTANCE_LINK; registryState.endpointType = RegistryState.DOCKER_REGISTRY_ENDPOINT_TYPE; registryState.address = RegistryService.DEFAULT_REGISTRY_ADDRESS; registryState = doPost(registryState, RegistryFactoryService.SELF_LINK); assertNotNull("Failed to create default registry", registryState); ConfigurationState config = new ConfigurationState(); config.key = RegistryService.DISABLE_DEFAULT_REGISTRY_PROP_NAME; config.value = Boolean.toString(true); ConfigurationUtil.initialize(config); RegistryService.buildDefaultStateInstance(host); waitFor("Ensure default registry is deleted.", () -> { List<String> resourceLinks = findResourceLinks(RegistryState.class, Collections.singletonList(RegistryService.DEFAULT_INSTANCE_LINK)); return resourceLinks.size() == 0; }); } }