Package com.bosch.iot.dm.mme

Provides Mass Management Engine APIs for managing devices in a mass and automated way.

See: Description

Interface Summary

Interface	Description
DeviceExecItem	Represents status report of partial execution for a device within a given Task.
DeviceExecStatus	Represents abstract execution status of given device.
DeviceRuleStatus	Represents execution status of device in the scope of a Rule.
DeviceStatusEvent
DeviceStatusEventOptions
DeviceTaskStatus	Represents execution status of device in the scope of a Task.
FilteredSet<T>	Represents a generic set used for retrieving Rules or Tasks that are filtered by some criteria on the target attributes.
MassManagementEngine	The MassManagementEngine service provides functionality for appointing and monitoring of Task executions and automation Rules for mass management over devices or arbitrary business logic.
Rule	Represents a Rule.
RuleBuilder	A builder utility for facilitating the creating of Rules in a 'builder-like pattern'.
RuleEvent
RuleEventOptions
Selection	Represents a selection of devices to be used for the creation of a DeviceScope.
Task	Represents a Task.
TaskBuilder	A builder utility for facilitating the launching of Tasks in a 'builder-like pattern'.
TaskEvent
TaskEventOptions

Class Summary

Class	Description
Action
DeviceScope<S extends Selection>	Represents Device scope.
DeviceScope.Builder	Deprecated Use DeviceScope.create(Selection) instead
ExecOptions	Execution options define execution behavior of Tasks and Rules, providing possible choices for various aspects of the execution.
GroovySelection	Represents a dynamic selection of devices determined by a custom Groovy listing script.
GroovySelection.Builder
GroupSelection	Represents a selection composed of a group of devices.
GroupSelection.Builder
IdSelection	Represents a selection composed of a list of device ids.
IdSelection.Builder
ListOptions
ListOptions.Builder
ListOptions.SortingOption
Option
Option.Builder
RuleParameters
RuleParameters.Builder<T extends RuleParameters.Builder<T>>
Scope	Represents a scope abstraction for Tasks and Rules.
SortingOptions
SortingOptions.Builder
SystemScope	Represents System scope.
TaskParameters
TaskParameters.Builder<T extends TaskParameters.Builder<T>>
Trigger	Defines definition of situation that triggers a Rule.
TriggerFireDef	Part of the Rule Trigger defining what can fire this Rule.
TriggerList	Defines a Rule trigger.

Enum Summary

Enum	Description
DeviceExecItem.State	Defines possible execution statuses.
DeviceExecStatus.State	Defines possible statuses for device executions.
DeviceStatusEvent.Type	Defines possible Device status event states.
ExecOptions.Overlapping	Defines whether multiple Tasks (launched out of the same Rule) over a particular device can be overlapped or should be replaced.
ListOptions.SortOrder
Rule.State	Defines possible Rule states.
RuleEvent.Type	Defines possible Rule events.
Scope.Type
Task.State	Defines possible Task states.
TaskEvent.Type	Defines possible Task events.

Exception Summary

Exception	Description
MassManagementException	Represents generic exception occurred in MassManagementEngine service.

Package com.bosch.iot.dm.mme Description

Provides Mass Management Engine APIs for managing devices in a mass and automated way.

The Mass Management Engine (MME) is a key service feature in the Bosch IoT Suite services defining:

• groovy scripting language way to define global mass management actions over devices
• notion of Tasks and Rules for organizing mass execution and automation
• various ways to define the Scope of mass executions and automations
• various Execution Options to define specifics in multi-device and multi-run behavior, such as concurrency limit, overlapping of executions and others.
• asynchronous model for sending commands to devices and means to program sequential processing and result/error handling
• very detailed monitoring of executions defining fine-grained reports even to partial results, such as like command responses and asynchronous groovy code processing.
• Event notifications for the progress of executions. There are two basic ways of event listening - with so called
  1) persistent events (instructing MME to send them to some message broker from where the client can consume them) and
  2) session events - runtime notifications which can be consumed if there is active listener at the moment of firing.

Mass Management Engine can be considered as separate microservice in the Bosch IoT Suite having its own access point. Standalone applications can use dedicated MME Client libraries which open gRPC connection to the MME Service end-point and delegate needed requests to the server part. MME Client library is rich client application, which means - part of the logic is delegated to the server, part of the processing is done on the client side internally.

Needed class path libraries can be found at the public maven repo: https://maven.bosch-si.com/.
All needed dependencies are:

     <dependency>
       <groupId>com.bosch.iot.dm.libs</groupId>
       <artifactId>dm.grpc.sa.client</artifactId>
       <version> <!-- use latest available here --> </version>
     </dependency>
    <dependency>
       <groupId>com.bosch.iot.dm.mme.libs</groupId>
       <artifactId>dm.mme.client</artifactId>
       <version> <!-- use latest available here --> </version>
     </dependency> * 

The root interface of the API is the MassManagementEngine, instance of which could be obtains as follows:

 import com.bosch.iot.dm.grpc.sa.GRPCServiceFactory;
 import com.bosch.iot.dm.mme.MassManagementEngine;
 import com.bosch.iot.dm.mme.be.remote.MMERemote;
 import com.bosch.iot.dm.mme.sa.MMERemoteFactory;

   public static void main(String[] args) {
     GRPCServiceFactory grpcServiceFactory =  GRPCServiceFactory.newBuilder()
         .ssl(true)
         .host("grpc.mass-management.eu-1.bosch-iot-suite.com")
         .port(443)
         .credential(new Token(
             accessToken, // use your obtained access and refresh tokens here
             refreshToken
         ))
         .vertx(vertx)
         .build();

     MMERemote mmeRemote = grpcServiceFactory.service(MMERemote.class);
     MassManagementEngine mme = MMERemoteFactory.createServiceInstance(mmeRemote);
   }