import org.kie.api.runtime.KieSession;
import org.kie.api.task.TaskService;
import org.kie.api.runtime.process.ProcessInstance;
import org.kie.services.client.api.RemoteRestRuntimeEngineFactory;
import org.kie.services.client.api.RemoteRestRuntimeEngineFactoryBuilderImpl;
import org.kie.services.client.api.command.RemoteRuntimeEngine;


public void javaRemoteApiRestExample(String deploymentId, URL baseUrl, String user, String password) {
  // The serverRestUrl should contain a URL similar to "http://localhost:8080/business-central/"

  RemoteRestRuntimeEngineFactory remoteRestRuntimeEngineFactory = RemoteRestRuntimeEngineFactory.newBuilder()
	  .addDeploymentId(deploymentId)
		.addUrl(url)
		.addUserName(userName)
		.addPassword(passWord)
		.addTimeout(timeOut)
		.build();
				
	RemoteRuntimeEngine engine = remoteRestRuntimeEngineFactory.newRuntimeEngine();		

  // Create KieSession and TaskService instances and use them
   KieSession ksession = engine.getKieSession();
   TaskService taskService = engine.getTaskService();
   
  // Each opertion on a KieSession, TaskService or AuditLogService (client) instance
  // sends a request for the operation to the server side and waits for the response
  // If something goes wrong on the server side, the client will throw an exception.
   ProcessInstance processInstance
       = ksession.startProcess("com.burns.reactor.maintenance.cycle");
   long procId = processInstance.getId();
   
   String taskUserId = user;
   taskService = engine.getTaskService();
   List<TaskSummary> tasks = taskService.getTasksAssignedAsPotentialOwner(user, "en-UK");
   
   long taskId = -1;
   for (TaskSummary task : tasks) {
        if (task.getProcessInstanceId() == procId) {
          taskId = task.getId();
        }
    }
    
    if (taskId == -1) {
      throw new IllegalStateException("Unable to find task for " + user + " in process instance " + procId);
    }
		
    taskService.start(taskId, taskUserId);
  }
}

Example Usage

import org.kie.api.runtime.KieSession;
import org.kie.api.task.TaskService;
import org.kie.api.runtime.process.ProcessInstance;
import org.kie.services.client.api.RemoteJmsRuntimeEngineFactory;
import org.kie.services.client.api.command.RemoteRuntimeEngine;


public void javaRemoteApiJmsExample(String deploymentId, Long processInstanceId, String user, String password) {

  // create a factory class with all the values
  RemoteJmsRuntimeEngineFactory jmsRuntimeFactory = 
          RemoteJmsRuntimeEngineFactory.newBuilder()
          .addDeploymentId(deploymentId)
          .addProcessInstanceId(processInstanceId)
          .addUserName(user)
          .addPassword(password)
          .addRemoteInitialContext(remoteInitialContext)
          .addTimeout(3)
          .addExtraJaxbClasses(MyType.class)
          .useSsl(false)
          .build();

	RemoteRuntimeEngine engine = jmsRuntimeFactory.newRuntimeEngine();		

  // Create KieSession and TaskService instances and use them
   KieSession ksession = engine.getKieSession();
   TaskService taskService = engine.getTaskService();
   
  // Each opertion on a KieSession, TaskService or AuditLogService (client) instance
  // sends a request for the operation to the server side and waits for the response
  // If something goes wrong on the server side, the client will throw an exception.
   ProcessInstance processInstance
       = ksession.startProcess("com.burns.reactor.maintenance.cycle");
   long procId = processInstance.getId();
   
   String taskUserId = user;
   taskService = engine.getTaskService();
   List<TaskSummary> tasks = taskService.getTasksAssignedAsPotentialOwner(user, "en-UK");
   
   long taskId = -1;
   for (TaskSummary task : tasks) {
        if (task.getProcessInstanceId() == procId) {
          taskId = task.getId();
        }
    }
    
    if (taskId == -1) {
      throw new IllegalStateException("Unable to find task for " + user + " in process instance " + procId);
    }
		
    taskService.start(taskId, taskUserId);
  }
}

Sending and receiving JMS messages

import org.kie.api.runtime.process.ProcessInstance;
import org.kie.api.task.model.TaskSummary;
	
public void sendAndReceiveJmsMessage() {
	
    String USER = "charlie";
    String PASSWORD = "ch0c0licious";
    
    String DEPLOYMENT_ID = "test-project";
    String PROCESS_ID_1 = "oompa-processing";
    URL serverUrl;
    try {
        serverUrl = new URL("http://localhost:8080/business-central/");
    } catch (MalformedURLException murle) {
        logger.error("Malformed URL for the server instance!", murle);
        return;
    }
    
// Create JaxbCommandsRequest instance and add commands
    Command<?> cmd = new StartProcessCommand(PROCESS_ID_1);
    int oompaProcessingResultIndex = 0;
    JaxbCommandsRequest req = new JaxbCommandsRequest(DEPLOYMENT_ID, cmd);
    req.getCommands().add(new GetTaskAssignedAsPotentialOwnerCommand(USER));
    int loompaMonitoringResultIndex = 1;
    
// Get JNDI context from server
    InitialContext context = getRemoteJbossInitialContext(serverUrl, USER, PASSWORD);
    
// Create JMS connection
    ConnectionFactory connectionFactory;
    try {
        connectionFactory = (ConnectionFactory) context.lookup("jms/RemoteConnectionFactory");
    } catch (NamingException ne) {
        throw new RuntimeException("Unable to lookup JMS connection factory.", ne);
    }
    
// Setup queues
    Queue sendQueue, responseQueue;
    try {
        sendQueue = (Queue) context.lookup("jms/queue/KIE.SESSION");
        responseQueue = (Queue) context.lookup("jms/queue/KIE.RESPONSE");
    } catch (NamingException ne) {
        throw new RuntimeException("Unable to lookup send or response queue", ne);
    }
    
// Send command request
    Long processInstanceId = null; // needed if you're doing an operation on a PER_PROCESS_INSTANCE deployment
    String humanTaskUser = USER;
    JaxbCommandsResponse cmdResponse = sendJmsCommands(
          DEPLOYMENT_ID, processInstanceId, humanTaskUser, req,
          connectionFactory, sendQueue, responseQueue,
          USER, PASSWORD, 5);
        
// Retrieve results
    ProcessInstance oompaProcInst = null;
    List<TaskSummary> charliesTasks = null;
    for (JaxbCommandResponse<?> response : cmdResponse.getResponses()) {
        if (response instanceof JaxbExceptionResponse) {

          // something went wrong on the server side
          JaxbExceptionResponse exceptionResponse = (JaxbExceptionResponse) response;
          throw new RuntimeException(exceptionResponse.getMessage());
        }
        if (response.getIndex() == oompaProcessingResultIndex) {
          oompaProcInst = (ProcessInstance) response.getResult();
        } else if (response.getIndex() == loompaMonitoringResultIndex) {
          charliesTasks = (List<TaskSummary>) response.getResult();
        }
    }
}

Sending JMS commands

private JaxbCommandsResponse sendJmsCommands(String deploymentId, Long processInstanceId, String user,
  JaxbCommandsRequest req, ConnectionFactory factory, Queue sendQueue, Queue responseQueue, String jmsUser,
  String jmsPassword, int timeout) {
    req.setProcessInstanceId(processInstanceId);
    req.setUser(user);

    Connection connection = null;
    Session session = null;
    String corrId = UUID.randomUUID().toString();
    String selector = "JMSCorrelationID = '" + corrId + "'";
    JaxbCommandsResponse cmdResponses = null;
    try {
    
        // setup
        MessageProducer producer;
        MessageConsumer consumer;
        try {
          if (jmsPassword != null) {
            connection = factory.createConnection(jmsUser, jmsPassword);
          } else {
            connection = factory.createConnection();
          }
          session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
          
          producer = session.createProducer(sendQueue);
          consumer = session.createConsumer(responseQueue, selector);
          
          connection.start();
        } catch (JMSException jmse) {
            throw new RemoteCommunicationException("Unable to setup a JMS connection.", jmse);
        }

        JaxbSerializationProvider serializationProvider = new JaxbSerializationProvider();
        // if necessary, add user-created classes here:
        // xmlSerializer.addJaxbClasses(MyType.class, AnotherJaxbAnnotatedType.class);

        // Create msg
        BytesMessage msg;
        try {
          msg = session.createBytesMessage();

          // serialize request
          String xmlStr = serializationProvider.serialize(req);
          msg.writeUTF(xmlStr);
          
          // set properties
         msg.setJMSCorrelationID(corrId);
         msg.setIntProperty(SerializationConstants.SERIALIZATION_TYPE_PROPERTY_NAME, JaxbSerializationProvider.JMS_SERIALIZATION_TYPE);
         Collection<Class<?>> extraJaxbClasses = serializationProvider.getExtraJaxbClasses();
         if (!extraJaxbClasses.isEmpty()) {
           String extraJaxbClassesPropertyValue = JaxbSerializationProvider
             .classSetToCommaSeperatedString(extraJaxbClasses);
           msg.setStringProperty(SerializationConstants.EXTRA_JAXB_CLASSES_PROPERTY_NAME, extraJaxbClassesPropertyValue);
           msg.setStringProperty(SerializationConstants.DEPLOYMENT_ID_PROPERTY_NAME, deploymentId);
         }
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to create and fill a JMS message.", jmse);
       } catch (SerializationException se) {
         throw new RemoteCommunicationException("Unable to deserialze JMS message.", se.getCause());
       }
       
       // send
       try {
         producer.send(msg);
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to send a JMS message.", jmse);
       }
       
       // receive
       Message response;
       try {
         response = consumer.receive(timeout);
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to receive or retrieve the JMS response.", jmse);
       }
       
       if (response == null) {
         logger.warn("Response is empty, leaving");
         return null;
       }
       // extract response
       assert response != null : "Response is empty.";
       try {
         String xmlStr = ((BytesMessage) response).readUTF();
         cmdResponses = (JaxbCommandsResponse) serializationProvider.deserialize(xmlStr);
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to extract " + JaxbCommandsResponse.class.getSimpleName()
           + " instance from JMS response.", jmse);
       } catch (SerializationException se) {
         throw new RemoteCommunicationException("Unable to extract " + JaxbCommandsResponse.class.getSimpleName()
           + " instance from JMS response.", se.getCause());
       }
       assert cmdResponses != null : "Jaxb Cmd Response was null!";
       } finally {
         if (connection != null) {
           try {
             connection.close();
             if( session != null ) {
               session.close();
             }
          } catch (JMSException jmse) {
             logger.warn("Unable to close connection or session!", jmse);
          }
       }
    }
    return cmdResponses;
}

Configuration using an InitialContext instance

private InitialContext getRemoteJbossInitialContext(URL url, String user, String password) {
    Properties initialProps = new Properties();
    initialProps.setProperty(InitialContext.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");
    String jbossServerHostName = url.getHost();
    initialProps.setProperty(InitialContext.PROVIDER_URL, "remote://"+ jbossServerHostName + ":4447");
    initialProps.setProperty(InitialContext.SECURITY_PRINCIPAL, user);
    initialProps.setProperty(InitialContext.SECURITY_CREDENTIALS, password);
    
    for (Object keyObj : initialProps.keySet()) {
        String key = (String) keyObj;
        System.setProperty(key, (String) initialProps.get(key));
    }
    try {
        return new InitialContext(initialProps);
    } catch (NamingException e) {
        throw new RemoteCommunicationException("Unable to create " + InitialContext.class.getSimpleName(), e);
    }
}