@BeforeMethod(alwaysRun = true)
public void setUp() throws Exception {
List<String> propsToRemove =
ImmutableList.of(
"imageDescriptionRegex", "imageNameRegex", "inboundPorts", "hardwareId", "minRam");
// Don't let any defaults from brooklyn.properties (except credentials) interfere with test
brooklynProperties = BrooklynProperties.Factory.newDefault();
for (String propToRemove : propsToRemove) {
for (String propVariant :
ImmutableList.of(
propToRemove, CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_HYPHEN, propToRemove))) {
brooklynProperties.remove("brooklyn.locations.jclouds." + PROVIDER + "." + propVariant);
brooklynProperties.remove("brooklyn.locations." + propVariant);
brooklynProperties.remove("brooklyn.jclouds." + PROVIDER + "." + propVariant);
brooklynProperties.remove("brooklyn.jclouds." + propVariant);
}
}
// Also removes scriptHeader (e.g. if doing `. ~/.bashrc` and `. ~/.profile`, then that can
// cause "stdin: is not a tty")
brooklynProperties.remove("brooklyn.ssh.config.scriptHeader");
ctx = new LocalManagementContext(brooklynProperties);
app = ApplicationBuilder.newManagedApp(TestApplication.class, ctx);
}
@Test
public void testAddUsageListenerViaProperties() throws Exception {
BrooklynProperties brooklynProperties = BrooklynProperties.Factory.newEmpty();
brooklynProperties.put(
UsageManager.USAGE_LISTENERS, RecordingStaticUsageListener.class.getName());
mgmt = LocalManagementContextForTests.newInstance(brooklynProperties);
assertUsageListenerCalledWhenApplicationStarted();
}
/**
* checks the supplied candidate user and password against the expect password (or SHA-256 + SALT
* thereof) defined as brooklyn properties.
*/
public static boolean checkExplicitUserPassword(
ManagementContext mgmt, String user, String password) {
BrooklynProperties properties = (BrooklynProperties) mgmt.getConfig();
String expectedPassword = properties.getConfig(BrooklynWebConfig.PASSWORD_FOR_USER(user));
String salt = properties.getConfig(BrooklynWebConfig.SALT_FOR_USER(user));
String expectedSha256 = properties.getConfig(BrooklynWebConfig.SHA256_FOR_USER(user));
return checkPassword(password, expectedPassword, expectedSha256, salt);
}
@Override
protected LocalManagementContext newTestManagementContext() {
ResourceUtils ru = new ResourceUtils(this);
File jar = createJar(ru);
File catalog = createCatalog(ru, jar);
BrooklynProperties properties = BrooklynProperties.Factory.newEmpty();
properties.put(BrooklynServerConfig.BROOKLYN_CATALOG_URL, catalog.toURI().toString());
return LocalManagementContextForTests.builder(true)
.useProperties(properties)
.disableOsgi(false)
.build();
}
@Override
protected LocalManagementContext createNewManagementContext(
File mementoDir, HighAvailabilityMode haMode) {
BrooklynProperties properties = BrooklynProperties.Factory.newDefault();
properties.put(
BrooklynServerConfig.BROOKLYN_CATALOG_URL,
"classpath://brooklyn/entity/rebind/rebind-catalog-item-test-catalog.xml");
return RebindTestUtils.managementContextBuilder(mementoDir, classLoader)
.properties(properties)
.forLive(useLiveManagementContext())
.haMode(haMode)
.emptyCatalog(useEmptyCatalog())
.buildUnstarted();
}
@Override
protected LocalManagementContext createOrigManagementContext() {
BrooklynProperties properties = BrooklynProperties.Factory.newDefault();
properties.put(
BrooklynServerConfig.BROOKLYN_CATALOG_URL,
"classpath://brooklyn/entity/rebind/rebind-catalog-item-test-catalog.xml");
properties.put(
BrooklynServerConfig.CATALOG_LOAD_MODE,
org.apache.brooklyn.core.catalog.CatalogLoadMode.LOAD_BROOKLYN_CATALOG_URL);
return RebindTestUtils.managementContextBuilder(mementoDir, classLoader)
.properties(properties)
.persistPeriodMillis(getPersistPeriodMillis())
.forLive(useLiveManagementContext())
.buildStarted();
}
@Override
public Map<String, Object> asMapWithStringKeys() {
Map<ConfigKey<?>, Object> raw = delegate.getAllConfig();
Map<String, Object> result = Maps.newLinkedHashMap();
for (Map.Entry<ConfigKey<?>, Object> entry : raw.entrySet()) {
result.put(entry.getKey().getName(), transform(entry.getKey(), entry.getValue()));
}
return result;
}
private static void addPropertiesFromMapSupplier(
BrooklynProperties p, Supplier<Map<?, ?>> propertiesSupplier) {
if (propertiesSupplier != null) {
Map<?, ?> newProps = propertiesSupplier.get();
if (newProps != null) {
p.addFrom(newProps);
}
}
}
private static void addPropertiesFromFile(BrooklynProperties p, String file) {
if (file == null) return;
String fileTidied = Os.tidyPath(file);
File f = new File(fileTidied);
if (f.exists()) {
p.addFrom(f);
}
}
public LocalManagementContext buildUnstarted() {
LocalManagementContext unstarted;
BrooklynProperties properties =
this.properties != null ? this.properties : BrooklynProperties.Factory.newDefault();
if (this.emptyCatalog) {
properties.putIfAbsent(
BrooklynServerConfig.BROOKLYN_CATALOG_URL, ManagementContextInternal.EMPTY_CATALOG_URL);
}
if (!enablePersistenceBackups) {
properties.putIfAbsent(
BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED_ON_DEMOTION, false);
properties.putIfAbsent(
BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED_ON_PROMOTION, false);
properties.putIfAbsent(BrooklynServerConfig.PERSISTENCE_BACKUPS_REQUIRED, false);
}
if (forLive) {
unstarted = new LocalManagementContext(properties);
} else {
unstarted =
LocalManagementContextForTests.builder(true)
.useProperties(properties)
.disableOsgi(!enableOsgi)
.build();
}
objectStore.injectManagementContext(unstarted);
objectStore.prepareForSharedUse(
PersistMode.AUTO, (haMode == null ? HighAvailabilityMode.DISABLED : haMode));
BrooklynMementoPersisterToObjectStore newPersister =
new BrooklynMementoPersisterToObjectStore(
objectStore, unstarted.getBrooklynProperties(), classLoader);
((RebindManagerImpl) unstarted.getRebindManager()).setPeriodicPersistPeriod(persistPeriod);
unstarted
.getRebindManager()
.setPersister(newPersister, PersistenceExceptionHandlerImpl.builder().build());
// set the HA persister, in case any children want to use HA
unstarted
.getHighAvailabilityManager()
.setPersister(
new ManagementPlaneSyncRecordPersisterToObjectStore(
unstarted, objectStore, classLoader));
return unstarted;
}
private static void addPropertiesFromUrl(
BrooklynProperties p, String url, boolean warnIfNotFound) {
if (url == null) return;
try {
p.addFrom(ResourceUtils.create(BrooklynProperties.class).getResourceFromUrl(url));
} catch (Exception e) {
if (warnIfNotFound) LOG.warn("Could not load {}; continuing", url);
if (LOG.isTraceEnabled()) LOG.trace("Could not load " + url + "; continuing", e);
}
}
protected static void stripBrooklynProperties(BrooklynProperties props) {
// remove all location properties except for identity and credential
// (so key, scripts, etc settings don't interfere with tests)
for (String key : ImmutableSet.copyOf(props.asMapWithStringKeys().keySet())) {
if (key.startsWith(BROOKLYN_PROPERTIES_PREFIX)
&& !(key.endsWith("identity") || key.endsWith("credential"))) {
props.remove(key);
}
if (key.startsWith(BROOKLYN_PROPERTIES_LEGACY_PREFIX)
&& !(key.endsWith("identity") || key.endsWith("credential"))) {
props.remove(key);
}
// Also removes scriptHeader (e.g. if doing `. ~/.bashrc` and `. ~/.profile`, then that can
// cause "stdin: is not a tty")
if (key.startsWith("brooklyn.ssh")) {
props.remove(key);
}
}
}
public BrooklynProperties build() {
if (originalProperties != null)
return new BrooklynPropertiesImpl().addFromMap(originalProperties);
BrooklynProperties properties = new BrooklynPropertiesImpl();
// TODO Could also read from http://brooklyn.io, for up-to-date values?
// But might that make unit tests run very badly when developer is offline?
addPropertiesFromUrl(properties, defaultLocationMetadataUrl, false);
addPropertiesFromMapSupplier(properties, propertiesSupplier);
addPropertiesFromFile(properties, globalLocationMetadataFile);
addPropertiesFromFile(properties, globalPropertiesFile);
addPropertiesFromFile(properties, localPropertiesFile);
properties.addEnvironmentVars();
properties.addSystemProperties();
return properties;
}
@Override
public boolean equals(Object o) {
return delegate.equals(o);
}
@Override
public Object put(Object key, Object value) {
return delegate.put(key, value);
}
@Override
@SuppressWarnings("rawtypes")
public void putAll(Map vals) {
delegate.putAll(vals);
}
@Test(expectedExceptions = ClassCastException.class)
public void testErrorWhenConfiguredClassIsNotAUsageListener() {
BrooklynProperties brooklynProperties = BrooklynProperties.Factory.newEmpty();
brooklynProperties.put(UsageManager.USAGE_LISTENERS, Integer.class.getName());
mgmt = LocalManagementContextForTests.newInstance(brooklynProperties);
}
@Override
public <T> Object put(ConfigKey<T> key, T value) {
return delegate.put(key, value);
}
@Override
public boolean containsKey(Object key) {
return delegate.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return delegate.containsValue(value);
}
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public Set<Map.Entry> entrySet() {
return delegate.entrySet();
}
@Override
public int size() {
return delegate.size();
}
@Override
@SuppressWarnings("rawtypes")
public Set keySet() {
return delegate.keySet();
}
@Override
public void clear() {
delegate.clear();
}
@Override
public Object remove(Object key) {
return delegate.remove(key);
}
@Override
public Object get(Object key) {
return delegate.get(key);
}
@Override
public int hashCode() {
return delegate.hashCode();
}
@Override
public <T> boolean putIfAbsent(ConfigKey<T> key, T value) {
return delegate.putIfAbsent(key, value);
}
@Override
@SuppressWarnings("rawtypes")
public Collection values() {
return delegate.values();
}
@Override
public boolean isEmpty() {
return delegate.isEmpty();
}
