JetService (Hazelcast Root 5.0.2 API)

All Known Subinterfaces:

JetInstance
```
public interface JetService
```
Jet is a component of Hazelcast to execute streaming or batch computations.

Since:

5.0

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`JetConfig`	`getConfig()` Returns the configuration for this Jet member.
`Job`	`getJob(long jobId)` Returns the job with the given id or `null` if no such job could be found.
`default Job`	`getJob(String name)` Returns the active or last submitted job with the given name or `null` if no such job could be found.
`List<Job>`	`getJobs()` Returns all submitted jobs.
`List<Job>`	`getJobs(String name)` Returns all jobs submitted with the given name, ordered in descending order by submission time.
`JobStateSnapshot`	`getJobStateSnapshot(String name)` Returns the `JobStateSnapshot` object representing an exported snapshot with the given name.
`Collection<JobStateSnapshot>`	`getJobStateSnapshots()` Returns the collection of exported job state snapshots stored in the cluster.
`<T> Observable<T>`	`getObservable(String name)` Returns an `Observable` instance with the specified name.
`Collection<Observable<?>>`	`getObservables()` Returns a list of all the `Observables` that are active.
`default Job`	`newJob(DAG dag)` Creates and returns a Jet job based on the supplied DAG.
`Job`	`newJob(DAG dag, JobConfig config)` Creates and returns a Jet job based on the supplied DAG and job configuration.
`default Job`	`newJob(Pipeline pipeline)` Creates and returns an executable job based on the supplied pipeline.
`Job`	`newJob(Pipeline pipeline, JobConfig config)` Creates and returns a Jet job based on the supplied pipeline and job configuration.
`Job`	`newJobIfAbsent(DAG dag, JobConfig config)` Creates and returns a Jet job based on the supplied DAG and job configuration.
`Job`	`newJobIfAbsent(Pipeline pipeline, JobConfig config)` Creates and returns a Jet job based on the supplied pipeline and job configuration.
`default Job`	`newLightJob(DAG dag)` Submits a job defined in the Core API with a default config.
`Job`	`newLightJob(DAG dag, JobConfig config)` Submits a job defined in the Core API.
`default Job`	`newLightJob(Pipeline p)` Submits a new light job with a default config.
`Job`	`newLightJob(Pipeline p, JobConfig config)` Submits a light job for execution.
`default <T> Observable<T>`	`newObservable()` Returns a new observable with a randomly generated name

- Method Detail
  - getConfig
```
@Nonnull
JetConfig getConfig()
```
    Returns the configuration for this Jet member. This method is not available on client instances.
  - newJob
```
@Nonnull
default Job newJob(@Nonnull
                            DAG dag)
```
    Creates and returns a Jet job based on the supplied DAG. Jet will asynchronously start executing the job.
  - newJob
```
@Nonnull
default Job newJob(@Nonnull
                            Pipeline pipeline)
```
    Creates and returns an executable job based on the supplied pipeline. Jet will asynchronously start executing the job.
  - newJob
```
@Nonnull
Job newJob(@Nonnull
                    DAG dag,
                    @Nonnull
                    JobConfig config)
```
    Creates and returns a Jet job based on the supplied DAG and job configuration. Jet will asynchronously start executing the job.
    If the name in the JobConfig is non-null, Jet checks if there is an active job with equal name, in which case it throws JobAlreadyExistsException. Job is active if it is running, suspended or waiting to be run; that is it has not completed or failed. Thus there can be at most one active job with a given name at a time and you can re-use the job name after the previous job completed.
    See also newJobIfAbsent(com.hazelcast.jet.core.DAG, com.hazelcast.jet.config.JobConfig).
    
    Throws:
    
    JobAlreadyExistsException - if there is an active job with an equal name
  - newJob
```
@Nonnull
Job newJob(@Nonnull
                    Pipeline pipeline,
                    @Nonnull
                    JobConfig config)
```
    Creates and returns a Jet job based on the supplied pipeline and job configuration. Jet will asynchronously start executing the job.
    If the name in the JobConfig is non-null, Jet checks if there is an active job with equal name, in which case it throws JobAlreadyExistsException. Job is active if it is running, suspended or waiting to be run; that is it has not completed or failed. Thus there can be at most one active job with a given name at a time and you can re-use the job name after the previous job completed.
    See also newJobIfAbsent(com.hazelcast.jet.core.DAG, com.hazelcast.jet.config.JobConfig).
    
    Throws:
    
    JobAlreadyExistsException - if there is an active job with an equal name
  - newJobIfAbsent
```
@Nonnull
Job newJobIfAbsent(@Nonnull
                            DAG dag,
                            @Nonnull
                            JobConfig config)
```
    Creates and returns a Jet job based on the supplied DAG and job configuration. Jet will asynchronously start executing the job.
    If the name in the JobConfig is non-null, Jet checks if there is an active job with equal name. If there is, it will join that job instead of submitting a new one. Job is active if it is running, suspended or waiting to be run; that is it has not completed or failed. In other words, this method ensures that the job with this name is running and is not running multiple times in parallel.
    This method is useful for microservices deployment when each package contains a jet member and the job and you want the job to run only once. But if the job is a batch job and runs very quickly, it can happen that it executes multiple times, because the job name can be reused after a previous execution completed.
    If the job name is null, a new job is always submitted.
    See also newJob(com.hazelcast.jet.core.DAG).
  - newJobIfAbsent
```
@Nonnull
Job newJobIfAbsent(@Nonnull
                            Pipeline pipeline,
                            @Nonnull
                            JobConfig config)
```
    Creates and returns a Jet job based on the supplied pipeline and job configuration. Jet will asynchronously start executing the job.
    If the name in the JobConfig is non-null, Jet checks if there is an active job with equal name. If there is, it will join that job instead of submitting a new one. Job is active if it is running, suspended or waiting to be run; that is it has not completed or failed. In other words, this method ensures that the job with this name is running and is not running multiple times in parallel.
    This method is useful for microservices deployment when each package contains a jet member and the job and you want the job to run only once. But if the job is a batch job and runs very quickly, it can happen that it executes multiple times, because the job name can be reused after a previous execution completed.
    If the job name is null, a new job is always submitted.
    See also newJob(com.hazelcast.jet.core.DAG).
  - newLightJob
```
@Nonnull
default Job newLightJob(@Nonnull
                                 Pipeline p)
```
    Submits a new light job with a default config. See newLightJob(Pipeline, JobConfig).
  - newLightJob
```
Job newLightJob(@Nonnull
                Pipeline p,
                @Nonnull
                JobConfig config)
```
    Submits a light job for execution. This kind of job is focused on reducing the job startup and teardown time: only a single operation is used to deploy the job instead of 2 for normal jobs.
    Limitations of light jobs:
    - very limited job configuration: no processing guarantee, no custom classes or job resources - all job code must be available in the cluster. Refer to JobConfig for details.
    - metrics not available through Job.getMetrics(). However, light jobs are included in member metrics accessed through other means.
    - failures will be only reported to the caller and logged in the cluster logs, but no trace of the job will remain in the cluster after it's done
    - RestartableException doesn't restart the job, but it will fail
    It substantially reduces the overhead for jobs that take milliseconds to complete.
    A light job will not be cancelled if the client disconnects. It's potential failure will be only logged in member logs.
  - newLightJob
```
@Nonnull
default Job newLightJob(@Nonnull
                                 DAG dag)
```
    Submits a job defined in the Core API with a default config.
    See newLightJob(Pipeline, JobConfig) for more information.
  - newLightJob
```
Job newLightJob(@Nonnull
                DAG dag,
                @Nonnull
                JobConfig config)
```
    Submits a job defined in the Core API.
    See newLightJob(Pipeline, JobConfig) for more information.
  - getJobs
```
@Nonnull
List<Job> getJobs()
```
    Returns all submitted jobs. The result includes completed normal jobs, but doesn't include completed light jobs - for light jobs the cluster doesn't retain any information after they complete.
  - getJob
```
@Nullable
Job getJob(long jobId)
```
    Returns the job with the given id or null if no such job could be found.
  - getJobs
```
@Nonnull
List<Job> getJobs(@Nonnull
                           String name)
```
    Returns all jobs submitted with the given name, ordered in descending order by submission time. The active job is always first. Empty list will be returned if no job with the given name exists. The list includes completed jobs.
  - getJob
```
@Nullable
default Job getJob(@Nonnull
                             String name)
```
    Returns the active or last submitted job with the given name or null if no such job could be found. The returned job can be already completed.
  - getJobStateSnapshot
```
@Nullable
JobStateSnapshot getJobStateSnapshot(@Nonnull
                                               String name)
```
    Returns the JobStateSnapshot object representing an exported snapshot with the given name. Returns null if no such snapshot exists.
  - getJobStateSnapshots
```
@Nonnull
Collection<JobStateSnapshot> getJobStateSnapshots()
```
    Returns the collection of exported job state snapshots stored in the cluster.
  - getObservable
```
@Nonnull
<T> Observable<T> getObservable(@Nonnull
                                         String name)
```
    Returns an Observable instance with the specified name. Represents a flowing sequence of events produced by jobs containing observable sinks.
    Multiple calls of this method with the same name return the same instance (unless it was destroyed in the meantime).
    In order to observe the events register an Observer on the Observable.
    
    Parameters:
    
    name - name of the observable
    
    Returns:
    
    observable with the specified name
    
    Since:
    
    Jet 4.0
  - newObservable
```
@Nonnull
default <T> Observable<T> newObservable()
```
    Returns a new observable with a randomly generated name
    
    Since:
    
    Jet 4.0
  - getObservables
```
@Nonnull
Collection<Observable<?>> getObservables()
```
    Returns a list of all the Observables that are active. By "active" we mean that their backing Ringbuffer has been created, which happens when either their first Observer is registered or when the job publishing their data (via observable sinks) starts executing.
    
    Since:
    
    Jet 4.0

Interface JetService

Method Summary

Method Detail

getConfig

newJob

newJob

newJob

newJob

newJobIfAbsent

newJobIfAbsent

newLightJob

newLightJob

newLightJob

newLightJob

getJobs

getJob

getJobs

getJob

getJobStateSnapshot

getJobStateSnapshots

getObservable

newObservable

getObservables