org.springframework.cloud.CloudException Java Examples

/**
 * Return object representation of the VCAP_SERVICES environment variable
 * <p>
 * Returns a list whose element is a map with service attributes. 
 * </p>
 * @return parsed service data
 */
@SuppressWarnings("unchecked")
protected List<Map<String,Object>> getServicesData() {
	String servicesString = environment.getEnvValue("VCAP_SERVICES");
	CloudFoundryRawServiceData rawServices = new CloudFoundryRawServiceData();
	
	if (servicesString != null && servicesString.length() > 0) {
		try {
			rawServices = objectMapper.readValue(servicesString, CloudFoundryRawServiceData.class);
		} catch (Exception e) {
			throw new CloudException(e);
		}
	}

	for (ServiceDataPostProcessor postProcessor : serviceDataPostProcessors) {
		rawServices = postProcessor.process(rawServices);
	}

	List<Map<String, Object>> flatServices = new ArrayList<Map<String, Object>>();
	for (Map.Entry<String, List<Map<String,Object>>> entry : rawServices.entrySet()) {
		flatServices.addAll(entry.getValue());
	}

	return flatServices;
}
 

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
	super.doParse(element, parserContext, builder);

	String connectorTypeName = element.getAttribute(CONNECTOR_TYPE);
	if (StringUtils.hasText(connectorTypeName)) {
		try {
			connectorType = Class.forName(connectorTypeName);
			builder.addPropertyValue("serviceConnectorType", connectorType);
		} catch (ClassNotFoundException ex) {
			throw new CloudException("Failed to load " + connectorTypeName, ex);
		}
	}

	// TBD: Support generic (map-based?) service config
	builder.addConstructorArgValue(null);
}
 

@Override
public void afterPropertiesSet() throws Exception {
	ConfigurableListableBeanFactory beanFactory = (ConfigurableListableBeanFactory) getBeanFactory();

	if (cloud == null) {
		if (beanFactory.getBeansOfType(CloudFactory.class).isEmpty()) {
			beanFactory.registerSingleton(CLOUD_FACTORY_BEAN_NAME, new CloudFactory());
		}
		CloudFactory cloudFactory = beanFactory.getBeansOfType(CloudFactory.class).values().iterator().next();
		cloud = cloudFactory.getCloud();
	}
	if (!StringUtils.hasText(serviceId)) {
		List<? extends ServiceInfo> infos = cloud.getServiceInfos(serviceConnectorType);
		if (infos.size() != 1) {
			throw new CloudException("Expected 1 service matching " + serviceConnectorType.getName() + " type, but found "
				+ infos.size());
		}
		serviceId = infos.get(0).getId();
	}

	super.afterPropertiesSet();
}
 

public String getDriverClassName(SI serviceInfo) {
	String userSpecifiedDriver = System.getProperty(driverSystemPropKey);

	if (userSpecifiedDriver != null && !userSpecifiedDriver.isEmpty()) {
		return userSpecifiedDriver;
	} else {
		for (String driver : driverClasses) {
			try {
				Class.forName(driver);
				return driver;
			} catch (ClassNotFoundException ex) {
				// continue...
			}
		}
	}
	throw new CloudException("No suitable database driver found for " + serviceInfo.getId() + " service ");
}
 

private ObjectStoreServiceInfo getServiceInfo() {
    if (StringUtils.isEmpty(serviceName)) {
        LOGGER.warn("service name not specified in config files");
        return null;
    }
    try {
        CloudFactory cloudFactory = new CloudFactory();
        Cloud cloud = cloudFactory.getCloud();
        ServiceInfo serviceInfo = cloud.getServiceInfo(serviceName);
        if (serviceInfo instanceof ObjectStoreServiceInfo) {
            return (ObjectStoreServiceInfo) serviceInfo;
        }
        LOGGER.warn("Service instance did not match allowed label and plans.");
    } catch (CloudException e) {
        LOGGER.warn(MessageFormat.format("Failed to detect service info for service \"{0}\"!", serviceName), e);
    }
    return null;
}
 

@Override
public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
    if (cloud != null) return;
    try {
        cloud = new CloudFactory().getCloud();
    } catch (CloudException e) {
        return; // not running on a known cloud environment, so nothing to do
    }

    for (ServiceInfo serviceInfo : cloud.getServiceInfos()) {
        if (serviceInfo instanceof SsoServiceInfo) {
            Map<String, Object> map = new HashMap<>();
            SsoServiceInfo ssoServiceInfo = (SsoServiceInfo) serviceInfo;
            map.put("security.oauth2.client.clientId", ssoServiceInfo.getClientId());
            map.put("security.oauth2.client.clientSecret", ssoServiceInfo.getClientSecret());
            map.put("security.oauth2.client.accessTokenUri", ssoServiceInfo.getAuthDomain() + "/oauth/token");
            map.put("security.oauth2.client.userAuthorizationUri", ssoServiceInfo.getAuthDomain() + "/oauth/authorize");
            map.put("ssoServiceUrl", ssoServiceInfo.getAuthDomain());
            map.put("security.oauth2.resource.userInfoUri", ssoServiceInfo.getAuthDomain() + "/userinfo");
            map.put("security.oauth2.resource.tokenInfoUri", ssoServiceInfo.getAuthDomain() + "/check_token");
            map.put("security.oauth2.resource.jwk.key-set-uri", ssoServiceInfo.getAuthDomain() + "/token_keys");
            MapPropertySource mapPropertySource = new MapPropertySource("vcapPivotalSso", map);

            event.getEnvironment().getPropertySources().addFirst(mapPropertySource);
        }
    }
}
 

@Override
public ApplicationInstanceInfo getApplicationInstanceInfo() {
	try {
		return applicationInstanceInfoCreator.createApplicationInstanceInfo();
	} catch (Exception e) {
		throw new CloudException(e);
	}
}
 

@Override
public ApplicationInstanceInfo getApplicationInstanceInfo() {
	try {
		@SuppressWarnings("unchecked")
		Map<String, Object> rawApplicationInstanceInfo 
			= objectMapper.readValue(environment.getEnvValue("VCAP_APPLICATION"), Map.class);
		return applicationInstanceInfoCreator.createApplicationInstanceInfo(rawApplicationInstanceInfo);
	} catch (Exception e) {
		throw new CloudException(e);
	} 
}
 

public String getHost() {
	try {
		return InetAddress.getLocalHost().getHostAddress();
	} catch (UnknownHostException ex) {
		throw new CloudException(ex);
	}
}
 

private Cloud getCloud() {
    try {
        CloudFactory cloudFactory = new CloudFactory();
        return cloudFactory.getCloud();
    } catch (CloudException ce) {
        return null;
    }
}
 

protected Cloud getCloud() {
    try {
        CloudFactory cloudFactory = new CloudFactory();
        return cloudFactory.getCloud();
    } catch (CloudException ce) {
        return null;
    }
}
 

/** 
 * Returns cloud object if the application runs on cloud environment
 * 
 * @return cloud object if the application runs on cloud environment
 */
private Cloud getCloud() {
	try {
		CloudFactory cloudFactory = new CloudFactory();
		return cloudFactory.getCloud();
	} catch (CloudException ce) {
		logger.error("no suitable cloud found");
		return null;
	}
}
 

private Cloud getCloud() {
  try {
    CloudFactory cloudFactory = new CloudFactory();
    return cloudFactory.getCloud();
  } catch (CloudException ce) {
    return null;
  }
}
 

private Cloud getCloud() {
    try {
        CloudFactory cloudFactory = new CloudFactory();
        return cloudFactory.getCloud();
    } catch (CloudException e) {
        return null;
    }
}
 

private Cloud getCloud() {
    try {
        CloudFactory cloudFactory = new CloudFactory();
        return cloudFactory.getCloud();
    } catch (CloudException e) {
        return null;
    }
}
 

@Test
public void testFallBackToDefault() {
    when(configurationMock.getDbConnectionThreads()).thenReturn(30);
    when(springCloudMock.getServiceConnector(any(), any(), any())).thenThrow(new CloudException("unknown service"));

    testedFactory.setDefaultDataSource(defaultDataSource);
    testedFactory.setServiceName("any");
    testedFactory.setConfiguration(configurationMock);
    testedFactory.afterPropertiesSet();

    verify(springCloudMock, atLeastOnce()).getServiceConnector(any(), any(), any());
    assertEquals(testedFactory.getObject(), defaultDataSource);
}
 

private String getStoragePath(String serviceName) {
    if (StringUtils.isEmpty(serviceName)) {
        LOGGER.warn(Messages.FILE_SYSTEM_SERVICE_NAME_IS_NOT_SPECIFIED);
        return null;
    }
    try {
        CloudFactory cloudFactory = new CloudFactory();
        Cloud cloud = cloudFactory.getCloud();
        FileSystemServiceInfo serviceInfo = (FileSystemServiceInfo) cloud.getServiceInfo(serviceName);
        return serviceInfo.getStoragePath();
    } catch (CloudException e) {
        LOGGER.warn(MessageFormat.format(Messages.FAILED_TO_DETECT_FILE_SERVICE_STORAGE_PATH, serviceName), e);
    }
    return null;
}
 

private DataSource getCloudDataSource(String serviceName) {
    DataSource cloudDataSource = null;
    try {
        if (serviceName != null && !serviceName.isEmpty()) {
            int maxPoolSize = configuration.getDbConnectionThreads();
            DataSourceConfig config = new DataSourceConfig(new PoolConfig(maxPoolSize, 30000), null);
            cloudDataSource = getSpringCloud().getServiceConnector(serviceName, DataSource.class, config);
        }
    } catch (CloudException e) {
        // Do nothing
    }
    return cloudDataSource;
}
 

private DynatraceServiceInfo getDynatraceServiceInfo() {
    String serviceName = DynatraceServiceInfoCreator.DEFAULT_DYNATRACE_SERVICE_ID;
    try {
        CloudFactory cloudFactory = new CloudFactory();
        Cloud cloud = cloudFactory.getCloud();
        ServiceInfo serviceInfo = cloud.getServiceInfo(serviceName);
        if (serviceInfo instanceof DynatraceServiceInfo) {
            return (DynatraceServiceInfo) serviceInfo;
        }
        LOGGER.warn("Service instance did not match allowed name and type.");
    } catch (CloudException e) {
        LOGGER.warn(MessageFormat.format("Failed to detect service info for service \"{0}\"!", serviceName), e);
    }
    return null;
}
 

private Cloud getCloud() {
	try {
		CloudFactory cloudFactory = new CloudFactory();
		return cloudFactory.getCloud();
	} catch (CloudException ce) {
		logger.error("no suitable cloud found");
		return null;
	}
}
 

/** 
 * Returns cloud object if the application runs on cloud environment
 * 
 * @return cloud object if the application runs on cloud environment
 */
private Cloud getCloud() {
	try {
		CloudFactory cloudFactory = new CloudFactory();
		return cloudFactory.getCloud();
	} catch (CloudException ce) {
		logger.error("no suitable cloud found");
		return null;
	}
}
 

/**
 * Returns cloud object if the application runs on cloud environment
 * 
 * @return cloud object if the application runs on cloud environment
 */
private Cloud getCloud() {
	try {
		CloudFactory cloudFactory = new CloudFactory();
		return cloudFactory.getCloud();
	} catch (CloudException ce) {
		logger.error("no suitable cloud found");
		return null;
	}
}
 

/** 
 * Returns cloud object if the application runs on cloud environment
 * 
 * @return cloud object if the application runs on cloud environment
 */
private Cloud getCloud() {
	try {
		CloudFactory cloudFactory = new CloudFactory();
		return cloudFactory.getCloud();
	} catch (CloudException ce) {
		logger.error("no suitable cloud found");
		return null;
	}
}
 

public HystrixAmqpServiceInfo(String id, String uri) throws CloudException {
	super(id);
	delegate = new AmqpServiceInfo(id, uri);
}
 

public AmqpServiceInfo(String id, String uri) throws CloudException {
	this(id, uri, null);
}
 

public AmqpServiceInfo(String id, String uri, String managementUri) throws CloudException {
	super(id, uri);
	this.managementUri = managementUri;
	this.virtualHost = decode(getUriInfo().getPath());
}
 

@Test(expected = CloudException.class)
public void servicesInfosWithNonJsonServices() {
	when(mockEnvironment.getEnvValue("VCAP_SERVICES")).thenReturn("some value");
	testCloudConnector.getServiceInfos();
}