org.apache.ignite

## Interface IgniteServices

All Superinterfaces:
  IgniteAsyncSupport

All Known Implementing Classes:
  IgniteServicesImpl

    public interface IgniteServices
    extends IgniteAsyncSupport

Defines functionality necessary to deploy distributed services on the grid.

Instance of `IgniteServices` which spans all cluster nodes can be obtained from Ignite as follows:

     Ignite ignite = Ignition.ignite();

     IgniteServices svcs = ignite.services();

You can also obtain an instance of the services facade over a specific cluster group:

     // Cluster group over remote nodes (excluding the local node).
     ClusterGroup remoteNodes = ignite.cluster().forRemotes();

     // Services instance spanning all remote cluster nodes.
     IgniteServices svcs = ignite.services(remoteNodes);

With distributed services you can do the following:

- Automatically deploy any number of service instances on the grid.
- Automatically deploy singletons, including cluster-singleton, node-singleton, or key-affinity-singleton.
- Automatically deploy services on node start-up by specifying them in grid configuration.
- Undeploy any of the deployed services.
- Get information about service deployment topology within the grid.

# Deployment From Configuration

In addition to deploying managed services by calling any of the provided `deploy(...)` methods, you can also automatically deploy services on startup by specifying them in `IgniteConfiguration` like so:

     IgniteConfiguration gridCfg = new IgniteConfiguration();

     GridServiceConfiguration svcCfg1 = new GridServiceConfiguration();

     // Cluster-wide singleton configuration.
     svcCfg1.setName("myClusterSingletonService");
     svcCfg1.setMaxPerNodeCount(1);
     svcCfg1.setTotalCount(1);
     svcCfg1.setService(new MyClusterSingletonService());

     GridServiceConfiguration svcCfg2 = new GridServiceConfiguration();

     // Per-node singleton configuration.
     svcCfg2.setName("myNodeSingletonService");
     svcCfg2.setMaxPerNodeCount(1);
     svcCfg2.setService(new MyNodeSingletonService());

     gridCfg.setServiceConfiguration(svcCfg1, svcCfg2);
     ...
     Ignition.start(gridCfg);

# Load Balancing

In all cases, other than singleton service deployment, Ignite will automatically make sure that an about equal number of services are deployed on each node within the grid. Whenever cluster topology changes, Ignite will re-evaluate service deployments and may re-deploy an already deployed service on another node for better load balancing.

# Fault Tolerance

Ignite guarantees that services are deployed according to specified configuration regardless of any topology changes, including node crashes.

# Resource Injection

All distributed services can be injected with ignite resources. Both, field and method based injections are supported. The following ignite resources can be injected:

- `IgniteInstanceResource`
- `LoggerResource`
- `SpringApplicationContextResource`
- `SpringResource`

Refer to corresponding resource documentation for more information.

# Service Example

Here is an example of how an distributed service may be implemented and deployed:

     // Simple service implementation.
     public class MyGridService implements GridService {
          ...
          // Example of ignite resource injection. All resources are optional.
          // You should inject resources only as needed.
          @IgniteInstanceResource
          private Grid grid;
          ...
          @Override public void cancel(GridServiceContext ctx) {
              // No-op.
          }

          @Override public void execute(GridServiceContext ctx) {
              // Loop until service is cancelled.
              while (!ctx.isCancelled()) {
                  // Do something.
                  ...
              }
          }
      }
     ...
     GridServices svcs = grid.services();

     svcs.deployClusterSingleton("mySingleton", new MyGridService());

### Method Summary

Methods
`void` `cancel(String name)` Cancels service deployment.
`void` `cancelAll()` Cancels all deployed services.
`ClusterGroup` `clusterGroup()` Gets the cluster group to which this `GridServices` instance belongs.
`void` `deploy(ServiceConfiguration cfg)` Deploys multiple instances of the service on the grid according to provided configuration.
`void` `deployClusterSingleton(String name, Service svc)` Deploys a cluster-wide singleton service.
`void` `deployKeyAffinitySingleton(String name, Service svc, String cacheName, Object affKey)` Deploys one instance of this service on the primary node for a given affinity key.
`void` `deployMultiple(String name, Service svc, int totalCnt, int maxPerNodeCnt)` Deploys multiple instances of the service on the grid.
`void` `deployNodeSingleton(String name, Service svc)` Deploys a per-node singleton service.
`<T> T` `service(String name)` Gets deployed service with specified name.
`Collection<ServiceDescriptor>` `serviceDescriptors()` Gets metadata about all deployed services.
`<T> T` `serviceProxy(String name, Class<? super T> svcItf, boolean sticky)` Gets a remote handle on the service.
`<T> Collection<T>` `services(String name)` Gets all deployed services with specified name.
`IgniteServices` `withAsync()` Gets instance of this component with asynchronous mode enabled.

### Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport

`future, isAsync`

### Method Detail

#### clusterGroup

    ClusterGroup clusterGroup()

Gets the cluster group to which this `GridServices` instance belongs.

Returns:
  Cluster group to which this `GridServices` instance belongs.

#### deployClusterSingleton

    @IgniteAsyncSupported
    void deployClusterSingleton(String name,
                                                   Service svc)
                                throws IgniteException

Deploys a cluster-wide singleton service. Ignite will guarantee that there is always one instance of the service in the cluster. In case if grid node on which the service was deployed crashes or stops, Ignite will automatically redeploy it on another node. However, if the node on which the service is deployed remains in topology, then the service will always be deployed on that node only, regardless of topology changes.

Note that in case of topology changes, due to network delays, there may be a temporary situation when a singleton service instance will be active on more than one node (e.g. crash detection delay).

This method is analogous to calling `deployMultiple(name, svc, 1, 1)` method.

Parameters:
  `name` - Service name.
  `svc` - Service instance.
Throws:
  `IgniteException` - If failed to deploy service.

#### deployNodeSingleton

    @IgniteAsyncSupported
    void deployNodeSingleton(String name,
                                                Service svc)
                             throws IgniteException

Deploys a per-node singleton service. Ignite will guarantee that there is always one instance of the service running on each node. Whenever new nodes are started within the underlying cluster group, Ignite will automatically deploy one instance of the service on every new node.

This method is analogous to calling `deployMultiple(name, svc, 0, 1)` method.

Parameters:
  `name` - Service name.
  `svc` - Service instance.
Throws:
  `IgniteException` - If failed to deploy service.

#### deployKeyAffinitySingleton

    @IgniteAsyncSupported
    void deployKeyAffinitySingleton(String name,
                                                       Service svc,
                                                       @Nullable
                                                       String cacheName,
                                                       Object affKey)
                                    throws IgniteException

Deploys one instance of this service on the primary node for a given affinity key. Whenever topology changes and primary node assignment changes, Ignite will always make sure that the service is undeployed on the previous primary node and deployed on the new primary node.

Note that in case of topology changes, due to network delays, there may be a temporary situation when a service instance will be active on more than one node (e.g. crash detection delay).

This method is analogous to the invocation of `deploy(org.apache.ignite.services.ServiceConfiguration)` method as follows:

         GridServiceConfiguration cfg = new GridServiceConfiguration();

         cfg.setName(name);
         cfg.setService(svc);
         cfg.setCacheName(cacheName);
         cfg.setAffinityKey(affKey);
         cfg.setTotalCount(1);
         cfg.setMaxPerNodeCount(1);

         grid.services().deploy(cfg);

Parameters:
  `name` - Service name.
  `svc` - Service instance.
  `cacheName` - Name of the cache on which affinity for key should be calculated, `null` for default cache.
  `affKey` - Affinity cache key.
Throws:
  `IgniteException` - If failed to deploy service.

#### deployMultiple

    @IgniteAsyncSupported
    void deployMultiple(String name,
                                           Service svc,
                                           int totalCnt,
                                           int maxPerNodeCnt)
                        throws IgniteException

Deploys multiple instances of the service on the grid. Ignite will deploy a maximum amount of services equal to `'totalCnt'` parameter making sure that there are no more than `'maxPerNodeCnt'` service instances running on each node. Whenever topology changes, Ignite will automatically rebalance the deployed services within cluster to make sure that each node will end up with about equal number of deployed instances whenever possible.

Note that at least one of `'totalCnt'` or `'maxPerNodeCnt'` parameters must have value greater than `0`.

This method is analogous to the invocation of `deploy(org.apache.ignite.services.ServiceConfiguration)` method as follows:

         GridServiceConfiguration cfg = new GridServiceConfiguration();

         cfg.setName(name);
         cfg.setService(svc);
         cfg.setTotalCount(totalCnt);
         cfg.setMaxPerNodeCount(maxPerNodeCnt);

         grid.services().deploy(cfg);

Parameters:
  `name` - Service name.
  `svc` - Service instance.
  `totalCnt` - Maximum number of deployed services in the grid, `0` for unlimited.
  `maxPerNodeCnt` - Maximum number of deployed services on each node, `0` for unlimited.
Throws:
  `IgniteException` - If failed to deploy service.

#### deploy

    @IgniteAsyncSupported
    void deploy(ServiceConfiguration cfg)
                throws IgniteException

Deploys multiple instances of the service on the grid according to provided configuration. Ignite will deploy a maximum amount of services equal to `cfg.getTotalCount()` parameter making sure that there are no more than `cfg.getMaxPerNodeCount()` service instances running on each node. Whenever topology changes, Ignite will automatically rebalance the deployed services within cluster to make sure that each node will end up with about equal number of deployed instances whenever possible.

If `cfg.getAffinityKey()` is not `null`, then Ignite will deploy the service on the primary node for given affinity key. The affinity will be calculated on the cache with `cfg.getCacheName()` name.

If `cfg.getNodeFilter()` is not `null`, then Ignite will deploy service on all grid nodes for which the provided filter evaluates to `true`. The node filter will be checked in addition to the underlying cluster group filter, or the whole grid, if the underlying cluster group includes all the cluster nodes.

Note that at least one of `'totalCnt'` or `'maxPerNodeCnt'` parameters must have value greater than `0`.

Here is an example of creating service deployment configuration:

         GridServiceConfiguration cfg = new GridServiceConfiguration();

         cfg.setName(name);
         cfg.setService(svc);
         cfg.setTotalCount(0); // Unlimited.
         cfg.setMaxPerNodeCount(2); // Deploy 2 instances of service on each node.

         grid.services().deploy(cfg);

Parameters:
  `cfg` - Service configuration.
Throws:
  `IgniteException` - If failed to deploy service.

#### cancel

    @IgniteAsyncSupported
    void cancel(String name)
                throws IgniteException

Cancels service deployment. If a service with specified name was deployed on the grid, then `Service.cancel(org.apache.ignite.services.ServiceContext)` method will be called on it.

Note that Ignite cannot guarantee that the service exits from `Service.execute(org.apache.ignite.services.ServiceContext)` method whenever `Service.cancel(org.apache.ignite.services.ServiceContext)` is called. It is up to the user to make sure that the service code properly reacts to cancellations.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Parameters:
  `name` - Name of service to cancel.
Throws:
  `IgniteException` - If failed to cancel service.

#### cancelAll

    @IgniteAsyncSupported
    void cancelAll()
                   throws IgniteException

Cancels all deployed services.

Note that depending on user logic, it may still take extra time for a service to finish execution, even after it was cancelled.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Throws:
  `IgniteException` - If failed to cancel services.

#### serviceDescriptors

    Collection<ServiceDescriptor> serviceDescriptors()

Gets metadata about all deployed services.

Returns:
  Metadata about all deployed services.

#### service

    <T> T service(String name)

Gets deployed service with specified name.

Type Parameters:
  `T` - Service type
Parameters:
  `name` - Service name.
Returns:
  Deployed service with specified name.

#### services

    <T> Collection<T> services(String name)

Gets all deployed services with specified name.

Type Parameters:
  `T` - Service type.
Parameters:
  `name` - Service name.
Returns:
  all deployed services with specified name.

#### serviceProxy

    <T> T serviceProxy(String name,
                     Class<? super T> svcItf,
                     boolean sticky)
                   throws IgniteException

Gets a remote handle on the service. If service is available locally, then local instance is returned, otherwise, a remote proxy is dynamically created and provided for the specified service.

Parameters:
  `name` - Service name.
  `svcItf` - Interface for the service.
  `sticky` - Whether or not Ignite should always contact the same remote service or try to load-balance between services.
Returns:
  Either proxy over remote service or local service if it is deployed locally.
Throws:
  `IgniteException` - If failed to create service proxy.

#### withAsync

    IgniteServices withAsync()

Gets instance of this component with asynchronous mode enabled.

Specified by:
  `withAsync` in interface `IgniteAsyncSupport`
Returns:
  Instance of this component with asynchronous mode enabled.

2015 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 1.6.0
Release Date | : May 18 2016