@SuppressWarnings("rawtypes")
protected Object doExecute() throws Exception {
Configuration[] configs = configRepository.getConfigAdmin().listConfigurations(query);
if (configs != null) {
Map<String, Configuration> sortedConfigs = new TreeMap<String, Configuration>();
for (Configuration config : configs) {
sortedConfigs.put(config.getPid(), config);
}
for (String pid : sortedConfigs.keySet()) {
Configuration config = sortedConfigs.get(pid);
System.out.println("----------------------------------------------------------------");
System.out.println("Pid: " + config.getPid());
if (config.getFactoryPid() != null) {
System.out.println("FactoryPid: " + config.getFactoryPid());
}
System.out.println("BundleLocation: " + config.getBundleLocation());
if (config.getProperties() != null) {
System.out.println("Properties:");
Dictionary props = config.getProperties();
Map<String, Object> sortedProps = new TreeMap<String, Object>();
for (Enumeration e = props.keys(); e.hasMoreElements(); ) {
Object key = e.nextElement();
sortedProps.put(key.toString(), props.get(key));
}
for (String key : sortedProps.keySet()) {
System.out.println(" " + key + " = " + sortedProps.get(key));
}
}
}
}
return null;
}
private void pushKeyValue(String key, String value) {
ServiceReference<?> reference =
Activator.getContext().getServiceReference(ConfigurationAdmin.class.getName());
if (reference != null) {
ConfigurationAdmin service =
(ConfigurationAdmin) Activator.getContext().getService(reference);
if (service != null) {
try {
Configuration configuration = service.getConfiguration("PrettyPrinterConfigurator");
if (configuration != null) {
Dictionary<String, Object> properties = configuration.getProperties();
if (properties == null) properties = new Hashtable<String, Object>();
properties.put(key, value);
configuration.update(properties);
configuration.update();
} else {
System.out.println("configuration (PrettyPrinterConfigurator) bulunamadi");
}
} catch (IOException e) {
System.out.println("hata olustu: ");
e.printStackTrace(System.out);
}
} else {
System.out.println("ConfigurationAdmin servisini bulamadim.");
}
} else {
System.out.println("ConfigurationAdmin servisine ait bir referans bulamadim.");
}
}
@Override
public Object getSettingValue(SettingSpecifierProvider provider, SettingSpecifier setting) {
if (setting instanceof KeyedSettingSpecifier<?>) {
KeyedSettingSpecifier<?> keyedSetting = (KeyedSettingSpecifier<?>) setting;
if (keyedSetting.isTransient()) {
return keyedSetting.getDefaultValue();
}
final String providerUID = provider.getSettingUID();
final String instanceUID =
(provider instanceof FactorySettingSpecifierProvider
? ((FactorySettingSpecifierProvider) provider).getFactoryInstanceUID()
: null);
try {
Configuration conf = getConfiguration(providerUID, instanceUID);
@SuppressWarnings("unchecked")
Dictionary<String, ?> props = conf.getProperties();
Object val = (props == null ? null : props.get(keyedSetting.getKey()));
if (val == null) {
val = keyedSetting.getDefaultValue();
}
return val;
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InvalidSyntaxException e) {
throw new RuntimeException(e);
}
}
return null;
}
@Override
public String addProviderFactoryInstance(String factoryUID) {
synchronized (factories) {
List<KeyValuePair> instanceKeys = settingDao.getSettings(getFactorySettingKey(factoryUID));
int next = instanceKeys.size() + 1;
// verify key doesn't exist
boolean done = false;
while (!done) {
done = true;
for (KeyValuePair instanceKey : instanceKeys) {
if (instanceKey.getKey().equals(String.valueOf(next))) {
done = false;
next++;
}
}
}
String newInstanceKey = String.valueOf(next);
settingDao.storeSetting(getFactorySettingKey(factoryUID), newInstanceKey, newInstanceKey);
try {
Configuration conf = getConfiguration(factoryUID, newInstanceKey);
@SuppressWarnings("unchecked")
Dictionary<String, Object> props = conf.getProperties();
if (props == null) {
props = new Hashtable<String, Object>();
}
props.put(OSGI_PROPERTY_KEY_FACTORY_INSTANCE_KEY, newInstanceKey);
conf.update(props);
return newInstanceKey;
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InvalidSyntaxException e) {
throw new RuntimeException(e);
}
}
}
// FIXME public access on the impl
public String getZookeeperInfo(String name) {
assertValid();
String zooKeeperUrl = null;
// We are looking directly for at the zookeeper for the url, since container might not even be
// mananaged.
// Also this is required for the integration with the IDE.
try {
if (curator.get().getZookeeperClient().isConnected()) {
Version defaultVersion = getDefaultVersion();
if (defaultVersion != null) {
Profile profile = defaultVersion.getProfile("default");
if (profile != null) {
Map<String, String> zookeeperConfig =
profile.getConfiguration(Constants.ZOOKEEPER_CLIENT_PID);
if (zookeeperConfig != null) {
zooKeeperUrl = getSubstitutedData(curator.get(), zookeeperConfig.get(name));
}
}
}
}
} catch (Exception e) {
// Ignore it.
}
if (zooKeeperUrl == null) {
try {
Configuration config =
configAdmin.get().getConfiguration(Constants.ZOOKEEPER_CLIENT_PID, null);
zooKeeperUrl = (String) config.getProperties().get(name);
} catch (Exception e) {
// Ignore it.
}
}
return zooKeeperUrl;
}
/**
* Removes and unbinds a bundle location from the list of known locations.
*
* @param location The bundle location to remove
*/
public synchronized void removedBundle(String location) {
bundleLocations.remove(location);
String filter =
"&(("
+ ConfigurationAdmin.SERVICE_BUNDLELOCATION
+ "="
+ location
+ ")("
+ CMConstants.SERVICE_DYNAMICLOCATION
+ "="
+ Boolean.TRUE
+ "))";
try {
List /* <Configuration> */ configurations = getConfigurations(filter, null, false);
Iterator it = configurations.iterator();
while (it.hasNext()) {
Configuration configuration = (Configuration) it.next();
ConfigurationDictionary dictionary =
(ConfigurationDictionary) configuration.getProperties();
setBundleLocation(configuration.getPid(), configuration.getFactoryPid(), null, dictionary);
}
} catch (IOException e) {
LOG.error("Error while unbinding configurations bound to " + location, e);
} catch (InvalidSyntaxException e) {
LOG.error("Error while unbinding configurations bound to " + location, e);
}
}
/**
* Set the values of an OSGi configuration for a given PID.
*
* @param pid The PID of the OSGi component to update
* @param properties The properties and values of the config to update
* @return true if the properties were updated successfully
*/
public boolean setProperties(final String pid, final Map<String, Object> properties) {
try {
Configuration conf = configAdmin.getConfiguration(pid);
@SuppressWarnings("unchecked")
Dictionary<String, Object> props = conf.getProperties();
if (props == null) {
props = new Hashtable<String, Object>();
}
/* props is of type org.apache.felix.cm.impl.CaseInsensitiveDictionary which
* contains an internal HashTable and doesn't contain a putAll(Map) method.
* Iterate over the map and put the values into the Dictionary individually.
* Remove null values from HashMap as HashTable doesn't support them. */
for (Map.Entry<String, Object> entry : properties.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
props.put(key, value != null ? value : StringUtils.EMPTY);
}
conf.update(props);
} catch (IOException e) {
LOGGER.error("Could not set property", e);
return false;
}
return true;
}
protected Dictionary<String, Object> getConfigurationDictionary(Class<?> configurationClass)
throws IOException {
Configuration configuration = configurationAdmin.getConfiguration(configurationClass.getName());
boolean allowDeleted = false;
if ((getClass() == FileSystemStore.class)
&& (configurationClass != FileSystemStoreConfiguration.class)) {
allowDeleted = true;
}
if ((getClass() == AdvancedFileSystemStore.class)
&& (configurationClass != AdvancedFileSystemStoreConfiguration.class)) {
allowDeleted = true;
}
try {
return configuration.getProperties();
} catch (IllegalStateException ise) {
if (allowDeleted) {
return null;
}
throw ise;
}
}
@Test
public void testValidConfiguration() {
configureActionProvider();
Dictionary<String, Object> testDictionary = new Hashtable<>();
testDictionary.put(RegistryObjectMetacardType.REGISTRY_ID, SAMPLE_REGISTRY_ID);
when(configuration.getProperties()).thenReturn(testDictionary);
List<Action> actions = actionProvider.getActions(configuration);
assertThat(actions.size(), is(1));
assertThat(
actions.get(0).getUrl().toString(),
is(
SAMPLE_PROTOCOL
+ SAMPLE_IP
+ ":"
+ SAMPLE_PORT
+ SAMPLE_SERVICES_ROOT
+ SAMPLE_PATH
+ metacard
.getAttribute(RegistryObjectMetacardType.REGISTRY_ID)
.getValue()
.toString()
+ PATH_AND_FORMAT));
}
public void execute(Session session, String line, PrintStream out, PrintStream err) {
// Parse command line.
StringTokenizer st = new StringTokenizer(line, " ");
// Ignore the command name.
st.nextToken();
// Check for optional argument.
String property = null;
if (st.countTokens() >= 1) {
property = st.nextToken().trim();
}
try {
if (session.getAttribute(Activator.CURRENT) == null) {
throw new Exception("No configuration open currently");
}
Dictionary dict = (Dictionary) session.getAttribute(Activator.EDITED);
if (dict == null) {
Configuration cfg = (Configuration) session.getAttribute(Activator.CURRENT);
dict = cfg.getProperties();
session.setAttribute(Activator.EDITED, dict);
}
Object oldValue = dict.remove(property);
if (oldValue == null) {
throw new Exception("No property named " + property + " in current configuration.");
}
} catch (Exception e) {
out.println("Unset failed. Details:");
String reason = e.getMessage();
out.println(reason == null ? "<unknown>: " + e.toString() : reason);
}
}
Configuration mockConfiguration(Dictionary<String, Object> props) {
Configuration commandConfig = EasyMock.createMock(Configuration.class);
EasyMock.expect(commandConfig.getPid())
.andReturn((String) props.get(Constants.SERVICE_PID))
.anyTimes();
EasyMock.expect(commandConfig.getProperties()).andReturn(props).anyTimes();
EasyMock.replay(commandConfig);
return commandConfig;
}
@Test
public void testNullRegistryIdConfiguration() {
configureActionProvider();
when(configuration.getProperties()).thenReturn(new Hashtable<>());
List<Action> actions = actionProvider.getActions(configuration);
assertThat(actions.size(), is(0));
}
@SuppressWarnings("rawtypes")
@Test(priority = 3)
public void testCreateNew() throws Exception {
config.put("property1", "value1");
config.put("property2", "value2");
configObjectService.create(rname, id, json(config), false).getOrThrow();
ConfigObjectService.ParsedId parsedId = configObjectService.getParsedId(rname, id);
Configuration config = configObjectService.findExistingConfiguration(parsedId);
assertNotNull(config);
assertNotNull(config.getProperties());
Dictionary properties = config.getProperties();
EnhancedConfig enhancedConfig = new JSONEnhancedConfig();
JsonValue value = enhancedConfig.getConfiguration(properties, rname.toString(), false);
assertTrue(value.keys().contains("property1"));
Assert.assertEquals(value.get("property1").asString(), "value1");
}
@Test
public void testConfigAdminService() throws IOException {
Assert.assertNotNull(configAdmin, "Configuration Service is null");
Configuration config = configAdmin.getConfiguration(LOGGING_CONFIG_PID);
Assert.assertNotNull(config, "PAX Logging Configuration is null");
config.update();
Dictionary properties = config.getProperties();
Assert.assertNotNull(properties, "PAX Logging Configuration Admin Service properties is null");
Assert.assertEquals(properties.get("service.pid"), LOGGING_CONFIG_PID);
}
/**
* Callback when a {@link SettingSpecifierProvider} has been registered.
*
* @param provider the provider object
* @param properties the service properties
*/
public void onBind(SettingSpecifierProvider provider, Map<String, ?> properties) {
log.debug("Bind called on {} with props {}", provider, properties);
final String pid = provider.getSettingUID();
List<SettingSpecifierProvider> factoryList = null;
String factoryInstanceKey = null;
synchronized (factories) {
FactoryHelper helper = factories.get(pid);
if (helper != null) {
// Note: SERVICE_PID not normally provided by Spring: requires
// custom SN implementation bundle
String instancePid = (String) properties.get(Constants.SERVICE_PID);
Configuration conf;
try {
conf = configurationAdmin.getConfiguration(instancePid, null);
@SuppressWarnings("unchecked")
Dictionary<String, ?> props = conf.getProperties();
if (props != null) {
factoryInstanceKey = (String) props.get(OSGI_PROPERTY_KEY_FACTORY_INSTANCE_KEY);
log.debug("Got factory {} instance key {}", pid, factoryInstanceKey);
factoryList = helper.getInstanceProviders(factoryInstanceKey);
factoryList.add(provider);
}
} catch (IOException e) {
log.error("Error getting factory instance configuration {}", instancePid, e);
}
}
}
if (factoryList == null) {
synchronized (providers) {
providers.put(pid, provider);
}
}
final String settingKey = getFactoryInstanceSettingKey(pid, factoryInstanceKey);
List<KeyValuePair> settings = settingDao.getSettings(settingKey);
if (settings.size() < 1) {
return;
}
SettingsCommand cmd = new SettingsCommand();
for (KeyValuePair pair : settings) {
SettingValueBean bean = new SettingValueBean();
bean.setProviderKey(provider.getSettingUID());
bean.setInstanceKey(factoryInstanceKey);
bean.setKey(pair.getKey());
bean.setValue(pair.getValue());
cmd.getValues().add(bean);
}
updateSettings(cmd);
}
@Override
public synchronized void unregisterConfiguration(Configuration configuration) {
Dictionary<String, Object> properties = configuration.getProperties();
T configurable = Configurable.createConfigurable(getMetatype(), properties);
long companyId = configurable.companyId();
_configurations.remove(companyId);
}
@Test(priority = 5)
public void testCreateDupeOk() throws Exception {
when(enhancedConfig.getConfiguration(any(Dictionary.class), any(String.class), eq(false)))
.thenReturn(json(config));
configObjectService.create(rname, id, json(config), true).getOrThrow();
ConfigObjectService.ParsedId parsedId = configObjectService.getParsedId(rname, id);
Configuration config = configObjectService.findExistingConfiguration(parsedId);
assertNotNull(config);
assertNotNull(config.getProperties());
}
public String getZooKeeperUrl() {
try {
Configuration config =
configurationAdmin.getConfiguration("org.fusesource.fabric.zookeeper", null);
final String zooKeeperUrl = (String) config.getProperties().get("zookeeper.url");
if (zooKeeperUrl == null) {
throw new IllegalStateException("Unable to find the zookeeper url");
}
return zooKeeperUrl;
} catch (Exception e) {
throw new FabricException("Unable to load zookeeper current url", e);
}
}
@Test
public void testConfigAdmin() throws IOException {
assertThat(configAdmin, is(notNullValue()));
org.osgi.service.cm.Configuration config = configAdmin.getConfiguration(DEBUG_OPTIONS);
assertThat(config, is(notNullValue()));
config.update();
@SuppressWarnings("unchecked")
Dictionary<String, String> dictionary = config.getProperties();
assertThat(dictionary, is(notNullValue()));
assertThat(dictionary.get("service.pid"), is(DEBUG_OPTIONS));
}
@SuppressWarnings("rawtypes")
@Test(priority = 6)
public void testUpdate() throws Exception {
config.put("property1", "newvalue1");
config.put("property2", "newvalue2");
when(enhancedConfig.getConfiguration(any(Dictionary.class), any(String.class), eq(false)))
.thenReturn(json(config));
configObjectService.update(rname, id, json(config)).getOrThrow();
ConfigObjectService.ParsedId parsedId = configObjectService.getParsedId(rname, id);
Configuration config = configObjectService.findExistingConfiguration(parsedId);
assertNotNull(config);
assertNotNull(config.getProperties());
Dictionary properties = config.getProperties();
JSONEnhancedConfig enhancedConfig = new JSONEnhancedConfig();
JsonValue value = enhancedConfig.getConfiguration(properties, rname.toString(), false);
assertTrue(value.keys().contains("property1"));
Assert.assertEquals(value.get("property1").asString(), "newvalue1");
}
@Test
public void testConfigurationBadUri() {
configureActionProvider(SAMPLE_PROTOCOL, "23^&*#", SAMPLE_PORT, SAMPLE_SERVICES_ROOT);
Dictionary<String, Object> testDictionary = new Hashtable<>();
testDictionary.put(RegistryObjectMetacardType.REGISTRY_ID, SAMPLE_REGISTRY_ID);
when(configuration.getProperties()).thenReturn(testDictionary);
List<Action> actions = actionProvider.getActions(configuration);
assertThat(actions.size(), is(0));
}
@Test
public void test_not_updated_new_configuration_not_bound_after_bundle_uninstall()
throws IOException, BundleException {
final String pid = "test_not_updated_new_configuration_not_bound_after_bundle_uninstall";
// create a configuration but do not update with properties
final Configuration newConfig = configure(pid, null, false);
TestCase.assertNull(newConfig.getProperties());
TestCase.assertNull(newConfig.getBundleLocation());
// start and settle bundle
bundle = installBundle(pid);
bundle.start();
delay();
// ensure no properties provided to bundle
final ManagedServiceTestActivator tester = ManagedServiceTestActivator.INSTANCE;
TestCase.assertNotNull("Activator not started !!", tester);
TestCase.assertNull("Expect no properties after Service Registration", tester.props);
TestCase.assertEquals("Expect a single update call", 1, tester.numManagedServiceUpdatedCalls);
// assert configuration is still unset but bound
TestCase.assertNull(newConfig.getProperties());
TestCase.assertEquals(bundle.getLocation(), newConfig.getBundleLocation());
// uninstall bundle, should unbind configuration
bundle.uninstall();
bundle = null;
delay();
// assert configuration is still unset and unbound
TestCase.assertNull(newConfig.getProperties());
TestCase.assertNull(newConfig.getBundleLocation());
// remove the configuration for good
deleteConfig(pid);
}
public static void toJSON(ConfigurationAdmin admin, Writer osw, String filter) throws Exception {
Configuration[] list = admin.listConfigurations(filter);
Encoder encoder = codec.enc().to(osw);
Protocol p = new Protocol();
p.version = 1;
p.date = new Date();
p.size = list.length;
encoder.put(p).append('\n');
if (list != null)
for (Configuration c : list) {
Dictionary<String, Object> d = c.getProperties();
Export export = new Export();
export.values = new HashMap<String, Object>();
export.factoryPid = c.getFactoryPid();
export.pid = c.getPid();
for (Enumeration<String> e = d.keys(); e.hasMoreElements(); ) {
String k = e.nextElement();
Object v = d.get(k);
if (!(v instanceof String)) {
if (export.types == null) export.types = new HashMap<String, Type>();
Type type = new Type();
Class<?> clazz = v.getClass();
if (v instanceof Collection) {
Collection<?> coll = (Collection<?>) v;
clazz = String.class;
if (coll.size() > 0) type.vectorOf = shortName(coll.iterator().next().getClass());
else type.vectorOf = shortName(String.class);
} else if (v.getClass().isArray()) {
type.arrayOf = shortName(clazz.getComponentType());
} else type.scalar = shortName(v.getClass());
export.types.put(k, type);
}
export.values.put(k, v);
}
encoder.mark().put(export);
// encoder.put(encoder.digest());
encoder.append('\n');
}
osw.flush();
}
@Test
public void test_create_with_location_unbind_before_service_supply()
throws BundleException, IOException {
final String pid = "test_create_with_location_unbind_before_service_supply";
final String dummyLocation = "http://some/dummy/location";
// 1. create and statically bind the configuration
final Configuration config = configure(pid, dummyLocation, false);
TestCase.assertEquals(pid, config.getPid());
TestCase.assertEquals(dummyLocation, config.getBundleLocation());
// 2. update configuration
Hashtable<String, String> props = new Hashtable<String, String>();
props.put(PROP_NAME, PROP_NAME);
config.update(props);
TestCase.assertEquals(PROP_NAME, config.getProperties().get(PROP_NAME));
TestCase.assertEquals(pid, config.getPid());
TestCase.assertEquals(dummyLocation, config.getBundleLocation());
// 3. (statically) set location to null
config.setBundleLocation(null);
TestCase.assertNull(config.getBundleLocation());
// 4. install bundle with service
bundle = installBundle(pid);
bundle.start();
delay();
final ManagedServiceTestActivator tester = ManagedServiceTestActivator.INSTANCE;
TestCase.assertNotNull("Activator not started !!", tester);
// assert activater has configuration (two calls, one per pid)
TestCase.assertNotNull("Expect Properties after Service Registration", tester.props);
TestCase.assertEquals("Expect a single update call", 1, tester.numManagedServiceUpdatedCalls);
TestCase.assertEquals(bundle.getLocation(), config.getBundleLocation());
bundle.uninstall();
bundle = null;
delay();
// statically bound configurations must remain bound after bundle
// uninstall
TestCase.assertNull(config.getBundleLocation());
// remove the configuration for good
deleteConfig(pid);
}
@Override
public void start(BundleContext bundleContext) throws Exception {
try {
this.bundleContext = bundleContext;
log.debug("Initializing bundle {}.", bundleContext.getBundle().getBundleId());
camelContext = createCamelContext();
camelContext.addRoutes(this);
ConfigurationAdmin configurationAdmin = requiredService(ConfigurationAdmin.class);
Configuration camelKuraConfig = configurationAdmin.getConfiguration("kura.camel");
if (camelKuraConfig != null && camelKuraConfig.getProperties() != null) {
Object routePropertyValue = camelKuraConfig.getProperties().get(camelXmlRoutesProperty());
if (routePropertyValue != null) {
InputStream routesXml =
new ByteArrayInputStream(routePropertyValue.toString().getBytes());
RoutesDefinition loadedRoutes = camelContext.loadRoutesDefinition(routesXml);
camelContext.addRouteDefinitions(loadedRoutes.getRoutes());
}
}
beforeStart(camelContext);
log.debug("About to start Camel Kura router: {}", getClass().getName());
camelContext.start();
producerTemplate = camelContext.createProducerTemplate();
consumerTemplate = camelContext.createConsumerTemplate();
log.debug("Bundle {} started.", bundleContext.getBundle().getBundleId());
} catch (Throwable e) {
String errorMessage = "Problem when starting Kura module " + getClass().getName() + ":";
log.warn(errorMessage, e);
// Print error to the Kura console.
System.err.println(errorMessage);
e.printStackTrace();
throw e;
}
}
/**
* Store the handler switch configuration in configuration admin.
*
* @param handler the handler to store.
* @param switchStatus the switch status to store.
*/
private void persist(String handler, SwitchStatus switchStatus) {
try {
Configuration configuration = configurationAdmin.getConfiguration(Configurations.NODE, null);
if (configuration != null) {
Dictionary<String, Object> properties = configuration.getProperties();
if (properties != null) {
properties.put(
Configurations.HANDLER + "." + handler, switchStatus.getValue().toString());
configuration.update(properties);
}
}
} catch (Exception e) {
LOGGER.warn("Can't persist the handler {} status", handler, e);
}
}
@Test(priority = 8)
public void testDelete() throws Exception {
when(enhancedConfig.getConfiguration(any(Dictionary.class), any(String.class), eq(false)))
.thenReturn(json(object(field(ResourceResponse.FIELD_CONTENT_REVISION, "revX"))));
configObjectService.delete(rname, "0").getOrThrow();
ConfigObjectService.ParsedId parsedId = configObjectService.getParsedId(rname, id);
Configuration config = configObjectService.findExistingConfiguration(parsedId);
// "deleting" the object does not remove it from the configAdmin but it does invalidate the
// config
assertNotNull(config);
assertNull(config.getProperties());
}
/**
* Get the value of an OSGi configuration boolean property for a given PID.
*
* @param pid The PID of the OSGi component to retrieve
* @param property The property of the config to retrieve
* @param value The value to assign the provided property
* @return The property value
*/
public boolean getBooleanProperty(
final String pid, final String property, final boolean defaultValue) {
try {
Configuration conf = configAdmin.getConfiguration(pid);
@SuppressWarnings("unchecked")
Dictionary<String, Object> props = conf.getProperties();
if (props != null) {
return PropertiesUtil.toBoolean(props.get(property), defaultValue);
}
} catch (IOException e) {
LOGGER.error("Could not get property", e);
}
return defaultValue;
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void testConfiguration_shouldHaveWrittenTheLaterOne() throws Exception {
ServiceReference[] allServiceReferences =
ctx.getAllServiceReferences(ConfigurationAdmin.class.getName(), null);
for (ServiceReference serviceReference : allServiceReferences) {
ConfigurationAdmin service = (ConfigurationAdmin) ctx.getService(serviceReference);
try {
org.osgi.service.cm.Configuration configuration = service.getConfiguration("tests");
assertEquals("myvalue2", configuration.getProperties().get("mykey"));
return;
} catch (Exception e) {
// continue
}
}
fail();
}
@Test
public void testLocalFabricCluster() throws Exception {
// Test autostartup.
assertNotNull(fabricService);
Thread.sleep(DEFAULT_WAIT);
Container[] containers = fabricService.getContainers();
assertNotNull(containers);
assertEquals("Expected to find 1 container", 1, containers.length);
assertEquals("Expected to find the root container", "root", containers[0].getId());
// Test that a generated password exists
// We don't inject the configuration admin as it causes issues when the tracker gets closed.
ConfigurationAdmin configurationAdmin = getOsgiService(ConfigurationAdmin.class);
org.osgi.service.cm.Configuration configuration =
configurationAdmin.getConfiguration("org.fusesource.fabric.zookeeper");
Dictionary<String, Object> dictionary = configuration.getProperties();
assertNotNull("Expected a generated zookeeper password", dictionary.get("zookeeper.password"));
}