akka.actor.ExtendedActorSystem Java Examples

@Override
protected void setup(final Config customConfig) {
    super.setup(customConfig);
    eventAdapter = new ThingMongoEventAdapter((ExtendedActorSystem) actorSystem);
    journalTestHelper = new ThingsJournalTestHelper<>(actorSystem, this::convertJournalEntryToEvent,
            PersistenceActorTestBaseWithSnapshotting::convertDomainIdToPersistenceId);
    snapshotTestHelper = new ThingsSnapshotTestHelper<>(actorSystem,
            PersistenceActorTestBaseWithSnapshotting::convertSnapshotDataToThing,
            PersistenceActorTestBaseWithSnapshotting::convertDomainIdToPersistenceId);

    commandToEventMapperRegistry = new HashMap<>();
    commandToEventMapperRegistry.put(CreateThing.class, (command, revision) -> {
        final CreateThing createCommand = (CreateThing) command;
        return ThingCreated.of(createCommand.getThing(), revision, DittoHeaders.empty());
    });
    commandToEventMapperRegistry.put(ModifyThing.class, (command, revision) -> {
        final ModifyThing modifyCommand = (ModifyThing) command;
        return ThingModified.of(modifyCommand.getThing(), revision, DittoHeaders.empty());
    });
    commandToEventMapperRegistry.put(DeleteThing.class, (command, revision) -> {
        final DeleteThing deleteCommand = (DeleteThing) command;
        return ThingDeleted.of(deleteCommand.getThingEntityId(), revision, DittoHeaders.empty());
    });
}
 

/**
 * Constructs a new {@code AbstractJsonifiableWithDittoHeadersSerializer} object.
 *
 * @param identifier a unique identifier identifying the serializer.
 * @param actorSystem the ExtendedActorSystem to use in order to dynamically load mapping strategies.
 * @param manifestProvider a function for retrieving string manifest information from arbitrary to map objects.
 * @param serializerName a name to be used for this serializer when reporting metrics, in the log and in error
 * messages.
 */
protected AbstractJsonifiableWithDittoHeadersSerializer(final int identifier, final ExtendedActorSystem actorSystem,
        final Function<Object, String> manifestProvider, final String serializerName) {

    this.identifier = identifier;
    this.serializerName = serializerName;

    mappingStrategies = MappingStrategies.loadMappingStrategies(actorSystem);
    this.manifestProvider = checkNotNull(manifestProvider, "manifestProvider");

    final ActorSystem.Settings settings = actorSystem.settings();
    final Config config = settings.config();
    defaultBufferSize = config.withFallback(FALLBACK_CONF).getBytes(CONFIG_DIRECT_BUFFER_SIZE);
    final int maxPoolEntries = config.withFallback(FALLBACK_CONF).getInt(CONFIG_DIRECT_BUFFER_POOL_LIMIT);
    byteBufferPool = new DirectByteBufferPool(defaultBufferSize.intValue(), maxPoolEntries);

    inCounter = DittoMetrics.counter(serializerName.toLowerCase() + METRIC_NAME_SUFFIX)
            .tag(METRIC_DIRECTION, "in");
    outCounter = DittoMetrics.counter(serializerName.toLowerCase() + METRIC_NAME_SUFFIX)
            .tag(METRIC_DIRECTION, "out");
}
 

@Override
protected void setup(final Config customConfig) {
    super.setup(customConfig);
    eventAdapter = new DefaultPolicyMongoEventAdapter((ExtendedActorSystem) actorSystem);

    journalTestHelper = new PoliciesJournalTestHelper<>(actorSystem, this::convertJournalEntryToEvent,
            PolicyPersistenceActorSnapshottingTest::convertDomainIdToPersistenceId);
    snapshotTestHelper = new PoliciesSnapshotTestHelper<>(actorSystem,
            PolicyPersistenceActorSnapshottingTest::convertSnapshotDataToPolicy,
            PolicyPersistenceActorSnapshottingTest::convertDomainIdToPersistenceId);

    commandToEventMapperRegistry = new HashMap<>();
    commandToEventMapperRegistry.put(CreatePolicy.class, (command, revision) -> {
        final CreatePolicy createCommand = (CreatePolicy) command;
        return PolicyCreated.of(createCommand.getPolicy(), revision, DittoHeaders.empty());
    });
    commandToEventMapperRegistry.put(ModifyPolicy.class, (command, revision) -> {
        final ModifyPolicy modifyCommand = (ModifyPolicy) command;
        return PolicyModified.of(modifyCommand.getPolicy(), revision, DittoHeaders.empty());
    });
    commandToEventMapperRegistry.put(DeletePolicy.class, (command, revision) -> {
        final DeletePolicy deleteCommand = (DeletePolicy) command;
        return PolicyDeleted.of(deleteCommand.getEntityId(), revision, DittoHeaders.empty());
    });
}
 

public ThingMongoEventAdapter(@Nullable final ExtendedActorSystem system) {
    this.system = system;
    eventRegistry = GlobalEventRegistry.getInstance();

    migrationMappings = new HashMap<>();
    migrationMappings.put(FeatureModified.NAME,
            jsonObject -> migrateModifiedToCreated(jsonObject, FeatureCreated.TYPE));

    migrationMappings.put(FeaturesModified.NAME,
            jsonObject -> migrateModifiedToCreated(jsonObject, FeaturesCreated.TYPE));

    migrationMappings.put(THING_ACL_MODIFIED, ThingMongoEventAdapter::migrateId);
    migrationMappings.put(THING_ACL_ENTRY_DELETED, ThingMongoEventAdapter::migrateId);
    migrationMappings.put(THING_ACL_ENTRY_MODIFIED,
            jsonObject -> migrateModifiedToCreated(migrateId(jsonObject), AclEntryCreated.TYPE));

    migrationMappings.put(THING_ATTRIBUTE_DELETED,
            jsonObject -> renameJsonPointer(ATTRIBUTE, migrateId(jsonObject)));
    migrationMappings.put(THING_ATTRIBUTE_MODIFIED, jsonObject -> renameValue(ATTRIBUTE,
            renameJsonPointer(ATTRIBUTE, migrateModifiedToCreated(migrateId(jsonObject), AttributeCreated.TYPE))));

    migrationMappings.put(THING_ATTRIBUTES_DELETED, ThingMongoEventAdapter::migrateId);
    migrationMappings.put(THING_ATTRIBUTES_MODIFIED,
            jsonObject -> migrateModifiedToCreated(migrateId(jsonObject), AttributesCreated.TYPE));

    migrationMappings.put(FeaturePropertyDeleted.NAME, jsonObject -> renameJsonPointer(PROPERTY, jsonObject));
    migrationMappings.put(FeaturePropertyModified.NAME, jsonObject -> renameValue(PROPERTY,
            renameJsonPointer(PROPERTY, migrateModifiedToCreated(jsonObject, FeaturePropertyCreated.TYPE))));

    migrationMappings.put(FeaturePropertiesModified.NAME,
            jsonObject -> migrateModifiedToCreated(jsonObject, FeaturePropertiesCreated.TYPE));
}
 

private DefaultMessageMapperFactory(final ConnectionId connectionId,
        final MappingConfig mappingConfig,
        final ExtendedActorSystem actorSystem,
        final List<MessageMapperExtension> messageMapperExtensions,
        final LoggingAdapter log) {

    this.connectionId = checkNotNull(connectionId);
    this.mappingConfig = checkNotNull(mappingConfig, "MappingConfig");
    this.actorSystem = checkNotNull(actorSystem);
    this.messageMapperExtensions = checkNotNull(messageMapperExtensions);
    this.log = checkNotNull(log);
}
 

/**
 * Creates a new factory and returns the instance
 *
 * @param connectionId ID of the connection.
 * @param actorSystem the actor system to use for mapping config + dynamicAccess.
 * @param mappingConfig the configuration of the mapping behaviour.
 * @param log the log adapter used for debug and warning logs.
 * @return the new instance.
 * @throws NullPointerException if any argument is {@code null}.
 */
public static DefaultMessageMapperFactory of(final ConnectionId connectionId,
        final ActorSystem actorSystem,
        final MappingConfig mappingConfig,
        final LoggingAdapter log) {

    final ExtendedActorSystem extendedActorSystem = (ExtendedActorSystem) actorSystem;
    final List<MessageMapperExtension> messageMapperExtensions =
            tryToLoadMessageMappersExtensions(extendedActorSystem);
    return new DefaultMessageMapperFactory(connectionId, mappingConfig, extendedActorSystem,
            messageMapperExtensions, log);
}
 

private static List<MessageMapperExtension> tryToLoadMessageMappersExtensions(
        final ExtendedActorSystem actorSystem) {
    try {
        return loadMessageMapperExtensions(actorSystem.dynamicAccess());
    } catch (final Exception e) {
        final String message = e.getClass().getCanonicalName() + ": " + e.getMessage();
        throw MessageMapperConfigurationFailedException.newBuilder(message).build();
    }
}
 

@Override
public ConnectivitySignalEnrichmentProvider createExtension(final ExtendedActorSystem system) {
    final SignalEnrichmentConfig signalEnrichmentConfig =
            DefaultSignalEnrichmentConfig.of(
                    system.settings().config().getConfig(SIGNAL_ENRICHMENT_CONFIG_PATH));
    return AkkaClassLoader.instantiate(system, ConnectivitySignalEnrichmentProvider.class,
            signalEnrichmentConfig.getProvider(),
            Arrays.asList(ActorSystem.class, SignalEnrichmentConfig.class),
            Arrays.asList(system, signalEnrichmentConfig)
    );
}
 

protected AbstractPolicyMongoEventAdapter(final Logger logger, @Nullable final ExtendedActorSystem system) {
    this.logger = logger;
    this.system = system;
    eventRegistry = GlobalEventRegistry.getInstance();
}
 

public ConnectivityMongoEventAdapter(final ExtendedActorSystem system) {
    super(system, createEventRegistry());
}
 

private static ExtendedActorSystem getActorSystem(final Class<?> implClass) {
    final Config cfg = ConfigFactory.parseMap(Map.of("ditto.mapping-strategy.implementation", implClass.getName()));
    return (ExtendedActorSystem) ExtendedActorSystem.create("test", cfg);
}
 

public DefaultPolicyMongoEventAdapter(@Nullable final ExtendedActorSystem system) {
    super(LoggerFactory.getLogger(DefaultPolicyMongoEventAdapter.class), system);
    migrationMappings = new HashMap<>();
}
 

public Replication createExtension(ExtendedActorSystem system) {
    return new Replication(system);
}
 

public SharedActorMaterializer createExtension(ExtendedActorSystem system) {
    return new SharedActorMaterializer(system);
}
 

private SharedActorMaterializer(ExtendedActorSystem system) {
    this.materializer = ActorMaterializer.create(system);
}
 

@Override
public AkkaExtension createExtension(ExtendedActorSystem system) {
    return new AkkaExtension();
}
 

/**
 * Is used by Akka to instantiate the Extension identified by this
 * ExtensionId, internal use only.
 */
@Override
public SpringExt createExtension(ExtendedActorSystem system) {
    return new SpringExt();
}
 

@Override
public SpringExt createExtension(ExtendedActorSystem system) {
    return new SpringExt();
}
 

@Override
public abstract T createExtension(ExtendedActorSystem system);
 

@Override
public FlowerExtension createExtension(ExtendedActorSystem system) {
  return new FlowerExtension(system);
}
 

public FlowerExtension(ExtendedActorSystem system) {
  this.actorSystem = system;
}
 

@Override
public HessianSerializer createExtension(ExtendedActorSystem system) {
  return new HessianSerializer();
}
 

@Override
public SagaDataExt createExtension(ExtendedActorSystem system) {
  return new SagaDataExt();
}
 

@Override
public SpringExt createExtension(ExtendedActorSystem system) {
  return new SpringExt();
}
 

/**
 * Loads the configured {@code ProtocolAdapterProvider} by reflection.
 * This calls the 1-argument constructor every subclass of ProtocolAdapterProvider should implement.
 *
 * @param protocolConfig provides the class name of the ProtocolAdapterProvider to be loaded.
 * @param actorSystem Akka actor system to perform reflection with.
 * @return the loaded protocol adapter provider.
 */
public static ProtocolAdapterProvider load(final ProtocolConfig protocolConfig, final ActorSystem actorSystem) {
    final String className = protocolConfig.getProviderClassName();
    final ClassTag<ProtocolAdapterProvider> tag = ClassTag$.MODULE$.apply(ProtocolAdapterProvider.class);
    final List<Tuple2<Class<?>, Object>> constructorArgs =
            Collections.singletonList(new Tuple2<>(ProtocolConfig.class, protocolConfig));
    final DynamicAccess dynamicAccess = ((ExtendedActorSystem) actorSystem).dynamicAccess();
    final Try<ProtocolAdapterProvider> providerBox = dynamicAccess.createInstanceFor(className,
            JavaConverters.asScalaBuffer(constructorArgs).toList(), tag);

    return providerBox.get();
}
 

@Override
public CompressedDDataHandler createExtension(final ExtendedActorSystem system) {
    return CompressedDDataHandler.create(system, getConfig(system), clusterRole, PubSubConfig.of(system));
}
 

/**
 * Is used by Akka to instantiate the Extension identified by this
 * ExtensionId, internal use only.
 */
@Override
public SpringExt createExtension(ExtendedActorSystem system) {
	return new SpringExt();
}
 

protected AbstractMongoEventAdapter(final ExtendedActorSystem system, final EventRegistry<T> eventRegistry) {
    this.system = system;
    this.eventRegistry = eventRegistry;
}
 

@Override
public BlockedNamespaces createExtension(final ExtendedActorSystem system) {
    return new BlockedNamespaces(DistributedData.createConfig(system, ACTOR_NAME, CLUSTER_ROLE), system);
}
 

@Override
public AbstractJsonifiableWithDittoHeadersSerializer getInstance(final ExtendedActorSystem actorSystem) {
    return new JsonJsonifiableSerializer(actorSystem);
}