class WorkerCoordinator extends Actor with ActorLogging
The WorkerCoordinator actor spawns as soon as it receives
EnsureActive(tagName)
messages from the cluster and remains alive forever. Even when the requested status for given
WorkerCoordinates
dictate the status to be
Stopped
the
WorkerCoordinator
will exist. When getting the first EnsureActive message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
Stopped }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinates }}} the status to be
Stopped
the
WorkerCoordinator
will exist. When getting the first EnsureActive message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
Stopped }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
EnsureActive(tagName) }}} cluster and remains alive forever. Even when the requested status for given
WorkerCoordinates
dictate the status to be
Stopped
the
WorkerCoordinator
will exist. When getting the first EnsureActive message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
Stopped }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinates }}} the status to be
Stopped
the
WorkerCoordinator
will exist. When getting the first EnsureActive message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
Stopped }}} message, the WorkerCoordinator pings back to the
ProjectionRegistryActor
to indicate “I’m here, I represent a worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
ProjectionRegistryActor }}} worker for this WorkerCoordinates”. That is, when the cluster starts up there are as many instances of
WorkerCoordinator
as (numProjections x numTags). The same is not true for the actual worker actors running the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
WorkerCoordinator }}} the queryByTag streams. The actual worker actors are only started when requested and are stopped when requested.
An advantage of this pattern is that, because a WorkerCoordinator actor will know the projectionName and the tagName before the actual worker actor is created we can now make up a unique repeatable name for the worker actor. This unique String is called the workerKey. The workerKey is used in the worker actor name. This is useful in monitoring since the information regarding projection and tagName is easily accessible, but also because the ActorSystem can't run two actors with the same name. Trying to spawn the same worker in a single node will cause a failure.
See https://github.com/playframework/play-meta/blob/master/docs/design/projections-design.md#workercoordinator-actor
- Source
- WorkerCoordinator.scala
- Alphabetic
- By Inheritance
- WorkerCoordinator
- ActorLogging
- Actor
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
- new WorkerCoordinator(projectionName: String, workerProps: (WorkerCoordinates) ⇒ Props, projectionRegistryActorRef: ActorRef)
Type Members
-
type
Receive = PartialFunction[Any, Unit]
- Definition Classes
- Actor
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
+(other: String): String
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to any2stringadd[WorkerCoordinator] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
-
def
->[B](y: B): (WorkerCoordinator, B)
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to ArrowAssoc[WorkerCoordinator] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
aroundPostRestart(reason: Throwable): Unit
- Attributes
- protected[akka]
- Definition Classes
- Actor
- Annotations
- @InternalApi()
-
def
aroundPostStop(): Unit
- Attributes
- protected[akka]
- Definition Classes
- Actor
- Annotations
- @InternalApi()
-
def
aroundPreRestart(reason: Throwable, message: Option[Any]): Unit
- Attributes
- protected[akka]
- Definition Classes
- Actor
- Annotations
- @InternalApi()
-
def
aroundPreStart(): Unit
- Attributes
- protected[akka]
- Definition Classes
- Actor
- Annotations
- @InternalApi()
-
def
aroundReceive(receive: akka.actor.Actor.Receive, msg: Any): Unit
- Attributes
- protected[akka]
- Definition Classes
- Actor
- Annotations
- @InternalApi()
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
implicit
val
context: ActorContext
- Definition Classes
- Actor
-
def
ensuring(cond: (WorkerCoordinator) ⇒ Boolean, msg: ⇒ Any): WorkerCoordinator
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to Ensuring[WorkerCoordinator] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: (WorkerCoordinator) ⇒ Boolean): WorkerCoordinator
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to Ensuring[WorkerCoordinator] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean, msg: ⇒ Any): WorkerCoordinator
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to Ensuring[WorkerCoordinator] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean): WorkerCoordinator
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to Ensuring[WorkerCoordinator] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to StringFormat[WorkerCoordinator] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- var lastStashed: Option[Status]
-
def
log: LoggingAdapter
- Definition Classes
- ActorLogging
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
postRestart(reason: Throwable): Unit
- Definition Classes
- Actor
- Annotations
- @throws( classOf[java.lang.Exception] )
-
def
postStop(): Unit
- Definition Classes
- Actor
- Annotations
- @throws( classOf[java.lang.Exception] )
-
def
preRestart(reason: Throwable, message: Option[Any]): Unit
- Definition Classes
- Actor
- Annotations
- @throws( classOf[java.lang.Exception] )
-
def
preStart(): Unit
- Definition Classes
- Actor
- Annotations
- @throws( classOf[java.lang.Exception] )
-
def
receive: Receive
- Definition Classes
- WorkerCoordinator → Actor
-
implicit final
val
self: ActorRef
- Definition Classes
- Actor
-
final
def
sender(): ActorRef
- Definition Classes
- Actor
-
def
supervisorStrategy: SupervisorStrategy
- Definition Classes
- Actor
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unhandled(message: Any): Unit
- Definition Classes
- Actor
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
def
→[B](y: B): (WorkerCoordinator, B)
- Implicit
- This member is added by an implicit conversion from WorkerCoordinator to ArrowAssoc[WorkerCoordinator] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc