How to initiate a Service with a random generated value at runtime without loosing the snapshot feature?

[reda-alaoui]

Hi,

I have a service that needs a random value to operate. I want this random value to be part of the service configuration. I also want this value to be restorable via snapshots.
I can't manage to achieve both for now.

[pintify]

Hi @reda-alaoui, I think there is a way of doing it. You could explore how the "Randomize Password" works in the FileSystemKeystore management:

This feature generates a random password, changes it over the keystore and updates the password field on the snapshot accordingly. The source for the whole component is here

However, such feature is very specific, I would advise to be very sure that there is no better (or simpler) way of doing it.

[reda-alaoui]

Hi @pintify ,

Thanks for your answer. Between the moment I asked the question and now, I managed to make something similar to the keystore work:

public interface SingletonConfigurationService {

  Future<?> merge(ComponentContext componentContext, Map<String, Object> properties);
}

import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import org.eclipse.kura.KuraException;
import org.eclipse.kura.configuration.ComponentConfiguration;
import org.eclipse.kura.configuration.ConfigurationService;
import org.osgi.service.cm.ConfigurationAdmin;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Réda Housni Alaoui
 */
@Component
public class DefaultSingletonConfigurationService implements SingletonConfigurationService {

  private static final Logger LOGGER =
      LoggerFactory.getLogger(DefaultSingletonConfigurationService.class);

  private final ExecutorService updateExecutor = Executors.newSingleThreadExecutor();
  private final ConfigurationService configurationService;

  @Activate
  public DefaultSingletonConfigurationService(
      @Reference ConfigurationService configurationService) {
    this.configurationService = configurationService;
  }

  @Deactivate
  public void deactivate() {
    updateExecutor.shutdownNow();
  }

  @Override
  public Future<?> merge(ComponentContext componentContext, Map<String, Object> properties) {
    if (componentContext.getProperties().get(ConfigurationAdmin.SERVICE_FACTORYPID) != null) {
      throw new IllegalArgumentException(
          "%s has a factory pid. %s can only manage singleton configurations."
              .formatted(componentContext, this));
    }
    return updateExecutor.submit(() -> mergeConfiguration(componentContext, properties));
  }

  private void mergeConfiguration(
      ComponentContext componentContext, Map<String, Object> properties) {

    Duration throttleDuration = Duration.ofSeconds(1);

    while (!Thread.currentThread().isInterrupted()) {
      try {
        String kuraServicePid =
            (String) componentContext.getProperties().get(ConfigurationService.KURA_SERVICE_PID);
        if (kuraServicePid == null) {
          LOGGER.debug(
              "Waiting <{}> before retrying update of <{}>.", throttleDuration, componentContext);
          TimeUnit.MILLISECONDS.sleep(throttleDuration.toMillis());
          continue;
        }
        ComponentConfiguration configuration =
            configurationService.getComponentConfiguration(kuraServicePid);
        if (configuration == null) {
          LOGGER.debug(
              "Waiting <{}> before retrying update of <{}>.", throttleDuration, componentContext);
          TimeUnit.MILLISECONDS.sleep(throttleDuration.toMillis());
          continue;
        }
        LOGGER.debug("Updating <{}>.", componentContext);
        configuration.getConfigurationProperties().putAll(properties);
        configurationService.updateConfigurations(List.of(configuration));
        break;
      } catch (KuraException e) {
        LOGGER.warn(e.getMessage(), e);
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException(e);
      }
    }
  }
}

import com.aqme.Passphrases;
import com.aqme.SingletonConfigurationService;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.Future;
import org.eclipse.kura.configuration.ConfigurableComponent;
import org.jspecify.annotations.Nullable;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.metatype.annotations.AttributeDefinition;
import org.osgi.service.metatype.annotations.AttributeType;
import org.osgi.service.metatype.annotations.Designate;
import org.osgi.service.metatype.annotations.ObjectClassDefinition;

/**
 * @author Réda Housni Alaoui
 */
@Designate(ocd = SomePassword.Configuration.class)
@Component(
    immediate = true,
    service = {SomePassword.class, ConfigurableComponent.class})
public class SomePassword implements ConfigurableComponent {

  @ObjectClassDefinition(
      // The id MUST be the full qualified name of the assigned component. Otherwise, the component
      // is
      // never loaded.
      id = PID,
      name = "Some Password")
  public @interface Configuration {

    @AttributeDefinition(name = "Password", type = AttributeType.STRING)
    @Nullable String password();
  }

  static final String PID = "com.aqme.SomePassword";

  private static final String PASSWORD_FIELD = "password";

  @Nullable private final Future<?> selfUpdateFuture;
  private final String password;

  @Activate
  public SomePassword(
      ComponentContext componentContext,
      @Reference SingletonConfigurationService singletonConfigurationService,
      Configuration configuration) {

    String passwordCandidate = configuration.password();
    if (passwordCandidate == null) {
      password = Passphrases.INSTANCE.generate(2);
      selfUpdateFuture =
          singletonConfigurationService.merge(componentContext, Map.of(PASSWORD_FIELD, password));
    } else {
      password = passwordCandidate;
      selfUpdateFuture = null;
    }
  }

  @Deactivate
  public void deactivate() {
    Optional.ofNullable(selfUpdateFuture).ifPresent(future -> future.cancel(true));
  }

  public String value() {
    return password;
  }
}

But I find this very clunky.

However, such feature is very specific, I would advise to be very sure that there is no better (or simpler) way of doing it.

I have multiple features requiring a random password generation to ease provisionning. From my window, this is pretty common.

[gnunzi]

@reda-alaoui The solution in the FileSystemKeystore like suggested above is maybe less clunky 😃 You just need to call configurationService.updateConfiguration with the list of new props. The ConfigurationService does a merge of existing+new props. No need to have your own DefaultSingletonConfigurationService.

If the component updates its own configuration, then it needs to do it within a new delayed thread (afaik because the component will be restarted after a configuration update).

Here are the lines to look at. Hope it helps.

kura/kura/org.eclipse.kura.core.keystore/src/main/java/org/eclipse/kura/core/keystore/FilesystemKeystoreServiceImpl.java

Lines 263 to 277 in ca95dd7

	this.selfUpdaterFuture = this.selfUpdaterExecutor.scheduleAtFixedRate(() -> {
	try {
	if (this.componentContext.getServiceReference() != null
	&& this.configurationService.getComponentConfiguration(pid) != null
	&& this.configurationService.getComponentConfiguration(pid).getDefinition() != null) {
	this.configurationService.updateConfiguration(pid, props);
	throw new KuraRuntimeException(KuraErrorCode.CONFIGURATION_SNAPSHOT_TAKING,
	"Updated. The task will be terminated.");
	} else {
	logger.info("No service or configuration available yet.");
	}
	} catch (KuraException e) {
	logger.warn("Cannot get/update configuration for pid: {}", pid, e);
	}
	}, 1000, 1000, TimeUnit.MILLISECONDS);