[\w\.-]+(:[\w\.-]+){2,2}(:[\w\.-]*){0,2}

map_age=5000

{ "age" => Long.parseLong("5000") }

curl -v -H 'Accept: application/json' -u eko 'localhost:8080/kie/rest/tasks/'

package rest;

import java.io.InputStream;
import java.net.URL;

import javax.xml.bind.JAXBContext;
import javax.xml.transform.stream.StreamSource;

import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.client.DefaultHttpClient;
import org.jboss.resteasy.client.ClientExecutor;
import org.jboss.resteasy.client.ClientRequest;
import org.jboss.resteasy.client.ClientRequestFactory;
import org.jboss.resteasy.client.ClientResponse;
import org.jboss.resteasy.client.core.executors.ApacheHttpClient4Executor;
import org.jboss.resteasy.spi.ResteasyProviderFactory;
import org.kie.api.task.model.Task;
import org.kie.services.client.serialization.jaxb.impl.task.JaxbTaskResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public Task getTaskInstanceInfo(long taskId) throws Exception {
    URL address = new URL(url + "/task/" + taskId);
    ClientRequest restRequest = createRequest(address);

    ClientResponse<JaxbTaskResponse> responseObj = restRequest.get(JaxbTaskResponse.class);
    ClientResponse<InputStream> taskResponse = responseObj.get(InputStream.class);
    JAXBContext jaxbTaskContext = JAXBContext.newInstance(JaxbTaskResponse.class);
    StreamSource source  = new StreamSource(taskResponse.getEntity());
    return jaxbTaskContext.createUnmarshaller().unmarshal(source, JaxbTaskResponse.class).getValue();

}

private ClientRequest createRequest(URL address) {
    return getClientRequestFactory().createRequest(address.toExternalForm());
    }

private ClientRequestFactory getClientRequestFactory() {
    DefaultHttpClient httpClient = new DefaultHttpClient();
    httpClient.getCredentialsProvider().setCredentials(new AuthScope(AuthScope.ANY_HOST,
    AuthScope.ANY_PORT, AuthScope.ANY_REALM), new UsernamePasswordCredentials(userId, password));
    ClientExecutor clientExecutor = new ApacheHttpClient4Executor(httpClient);
    return new ClientRequestFactory(clientExecutor, ResteasyProviderFactory.getInstance());
}

/task/query
/history/instances
/history/instance/{id: [0-9]+}
/history/instance/{id: [0-9]+}/child
/history/instance/{id: [0-9]+}/node
/history/instance/{id: [0-9]+}/node/{id: [a-zA-Z0-9-:\\.]+}
/history/instance/{id: [0-9]+}/variable/
/history/instance/{id: [0-9]+}/variable/{id: [a-zA-Z0-9-:\\.]+}
/history/process/{id: [a-zA-Z0-9-:\\.]+}

/history/instances?page=3&pageSize=20
/history/instances?p=3&s=20

/rest/runtime/business-central/process/org.jbpm.test/start?map_var1=1234i

package com.redhat.gss.jbpm;

import java.io.StringReader;
import java.io.StringWriter;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

import javax.ws.rs.core.MediaType;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import org.MyPOJO;
import org.apache.commons.codec.binary.Base64;
import org.jboss.resteasy.client.ClientRequest;
import org.jboss.resteasy.client.ClientRequestFactory;
import org.jboss.resteasy.client.ClientResponse;
import org.kie.api.command.Command;
import org.kie.remote.client.jaxb.JaxbCommandsRequest;
import org.kie.remote.client.jaxb.JaxbCommandsResponse;
import org.kie.remote.jaxb.gen.JaxbStringObjectPairArray;
import org.kie.remote.jaxb.gen.StartProcessCommand;
import org.kie.remote.jaxb.gen.util.JaxbStringObjectPair;
import org.kie.services.client.serialization.JaxbSerializationProvider;
import org.kie.services.client.serialization.jaxb.impl.JaxbCommandResponse;

public class StartProcessWithPOJO {

	  /*
	   * Set the parameters according your installation
	   */
	  private static final String DEPLOYMENT_ID = "org.kie.example:project1:3.0";
	  private static final String PROCESS_ID = "project1.proc_start";
	  private static final String PROCESS_PARAM_NAME = "myPOJO";
	  private static final String APP_URL = "http://localhost:8080/business-central/rest";
	  private static final String USER = "jesuino";
	  private static final String PASSWORD = "redhat2014!";



	    public static void main(String[] args) throws Exception {
	        // List of commands to be executed;
	        List<Command> commands = new ArrayList<Command>();
	        // a sample command to start a process:
	        StartProcessCommand startProcessCommand = new StartProcessCommand();
	        JaxbStringObjectPairArray params = new JaxbStringObjectPairArray();
	        params.getItems().add(new JaxbStringObjectPair(PROCESS_PARAM_NAME, new MyPOJO("My POJO TESTING")));
	        startProcessCommand.setProcessId(PROCESS_ID);
	        startProcessCommand.setParameter(params);
	        commands.add(startProcessCommand);
	        List<JaxbCommandResponse<?>> response = executeCommand(DEPLOYMENT_ID,
	                commands);
	        System.out.printf("Command %s executed.\n", response.toString());
	        System.out.println("commands1" + commands);
	    }

	    static List<JaxbCommandResponse<?>> executeCommand(String deploymentId,
	            List<Command> commands) throws Exception {
	        URL address = new URL(APP_URL + "/execute");
	        ClientRequest request = createRequest(address);


	        request.header(JaxbSerializationProvider.EXECUTE_DEPLOYMENT_ID_HEADER, DEPLOYMENT_ID);
	        JaxbCommandsRequest commandMessage = new JaxbCommandsRequest();
	        commandMessage.setCommands(commands);
	        commandMessage.setDeploymentId(DEPLOYMENT_ID);
	        String body = convertJaxbObjectToString(commandMessage);
	        request.body(MediaType.APPLICATION_XML, body);
	        ClientResponse<String> responseObj = request.post(String.class);
	        String strResponse = responseObj.getEntity();
	        System.out.println("RESPONSE FROM THE SERVER: \n" + strResponse);
	        JaxbCommandsResponse cmdsResp = convertStringToJaxbObject(strResponse);
	        return cmdsResp.getResponses();
	    }

	    static private ClientRequest createRequest(URL address) {
	        return new ClientRequestFactory().createRequest(
	                address.toExternalForm()).header("Authorization",
	                getAuthHeader());
	    }

	    static private String getAuthHeader() {
	        String auth = USER + ":" + PASSWORD;
	        byte[] encodedAuth = Base64.encodeBase64(auth.getBytes(Charset.forName("US-ASCII")));
	        return "Basic " + new String(encodedAuth);
	    }

	    static String convertJaxbObjectToString(Object object) throws JAXBException {
	    	// TODO: Add your classes here
	        Class<?>[] classesToBeBound = { JaxbCommandsRequest.class, MyPOJO.class };
	        Marshaller marshaller = JAXBContext.newInstance(classesToBeBound)
	                .createMarshaller();
	        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
	        StringWriter stringWriter = new StringWriter();
	        marshaller.marshal(object, stringWriter);
	        String output = stringWriter.toString();
	        System.out.println("REQUEST CONTENT: \n" + output);
	        return output;
	    }

	    static JaxbCommandsResponse convertStringToJaxbObject(String str)
	            throws JAXBException {
	        Unmarshaller unmarshaller = JAXBContext.newInstance(
	                JaxbCommandsResponse.class).createUnmarshaller();
	        return (JaxbCommandsResponse) unmarshaller.unmarshal(new StringReader(
	                str));
	    }
}

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.redhat.gss</groupId>
	<artifactId>sample-rest-client</artifactId>
	<version>1</version>
	<name>Rest Client - Execute</name>

	<properties>
		<version.org.jboss.bom.eap>6.4.4.GA</version.org.jboss.bom.eap>
		<!-- Define the version of brms/bpmsuite core artifacts -->
		<version.org.jboss.bom.brms>6.2.1.GA-redhat-2</version.org.jboss.bom.brms>
		<maven.compiler.target>1.7</maven.compiler.target>
		<maven.compiler.source>1.7</maven.compiler.source>
	</properties>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.jboss.bom.eap</groupId>
				<artifactId>jboss-javaee-6.0-with-resteasy</artifactId>
				<version>${version.org.jboss.bom.eap}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<dependency>
				<groupId>org.jboss.bom.brms</groupId>
				<artifactId>jboss-brms-bpmsuite-bom</artifactId>
				<version>${version.org.jboss.bom.brms}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<dependencies>
		<dependency>
			<groupId>org.kie.remote</groupId>
			<artifactId>kie-remote-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.drools</groupId>
			<artifactId>drools-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.jboss.resteasy</groupId>
			<artifactId>resteasy-jaxrs</artifactId>
		</dependency>
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.2</version>
		</dependency>
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>1.9</version>
		</dependency>
		<!-- STARTING MY BUSINESS CENTRAL PROJECT DEPENDENCY WHICH CONTAINS THE POJO -->
		<dependency>
			<artifactId>ExecuteProject</artifactId>
			<groupId>org.redhat.gss</groupId>
			<version>1.0</version>
		</dependency>
		<!-- ENDING MY BUSINESS CENTRAL PROJECT DEPENDENCY WHICH CONTAINS THE POJO -->
	</dependencies>

</project>