Mimecast

Find Processing Messages

Description

This API endpoint will return messages currently being processed by Mimecast. Given the speed at which messages are processed, it is not uncommon for this endpoint to return no results, as the platform may not be processing a messasge at the moment or request. More information on the Processing Queue can be found in Mimecaster Central.

All request fields are optional, however at least one option must be presented in the request body.

Pre-requisites

  • In order to successfully use this endpoint the logged in user must be a Mimecast administrator with at least the Monitoring | Processing | Read permission.

URI

To use this endpont you send a POST request to:

  • /api/gateway/find-processing-messages

Request Headers

The following request headers must be included in your request:

Field Description
Authorization Please see the Authorization guide for more information on building the Authorization header.
x-mc-req-id

A randomly generated GUID, for example,

8578FCFC-A305-4D9A-99CB-F4D5ECEFE297
x-mc-app-id The Application ID provided with your Registered API Application.
x-mc-date

The current date and time in the following format, for example,

Tue, 24 Nov 2015 12:50:11 UTC

Request Body

{
 "data": [
  {
   "end": "2015-11-16T14:49:18+0000", 
   "filterBy": [
    {
     "fieldName": "String", 
     "value": "String"
    }
   ], 
   "start": "2015-11-16T14:49:18+0000", 
   "sortOrder": "String", 
   "searchBy": {
    "fieldName": "String", 
    "value": "String"
   }, 
   "type": "String", 
   "sortBy": "String"
  }
 ]
}
data
Field Type Required Description
sortOrder String Optional Sort reesults in order according to date. Possible values are ascending or descending, with descending being the default value.
start Date String Optional The start date of results to return in ISO 8601 format. Default value is 7 days prior to current date.
searchBy searchBy Object Optional Accepts search filter field and value to apply when searching.
end Date String Optional The end date of results to return in ISO 8601 format. Default value is the current date.
type String Optional The message queue type to return. Possible values are processing, bulk_processing with the default value being processing.
filterBy Array of filterBy Objects Optional Filters by route and attachment to apply to results
searchBy Object
Field Type Required Description
value String Required The search value to be used
fieldName String Required The field to be searched. Possible values are ALL, fromAddress, toAddress, subject, info or remoteIp
filterBy Object
Field Type Required Description
route String Optional The message route. Possible values are all, internal, outbound, inbound, external
attachments Boolean Optional The presence of an attachment in the message. Messages with attachments will return true, while messages without attachments will return false.

Response

{
 "fail": [], 
 "meta": {
  "status": 200
 }, 
 "data": [
  {
   "messages": [
    {
     "attempts": "Integer", 
     "id": "String", 
     "size": "Integer", 
     "info": "String", 
     "routing": "String", 
     "nextAttempt": "2015-10-07T20:03:56+0000", 
     "created": "2015-10-07T20:03:56+0000", 
     "lockedUntil": "2015-10-07T21:33:56+0000", 
     "fromHeader": {
      "emailAddress": "String", 
      "displayableName": "String"
     }, 
     "to": {
      "emailAddress": "String", 
      "displayableName": "String"
     }, 
     "fromEnv": {
      "emailAddress": "String", 
      "displayableName": "String"
     }, 
     "attachment": "Boolean", 
     "subject": "String", 
     "remoteIp": "String"
    }
   ]
  }
 ]
}
meta object
Field Type Description
status Number The function level status of the request.
meta
Field Type Description
status Number The function level status of the request.
data
Field Type Description
messages Array An array of messages in the processing queue
messages
Field Type Description
id String The Mimecast secure id of the message
fromEnv emailAddress Object The envelope from address
fromHeader emailAddress Object The header from address
to emailAddress Object The recipient address
subject String The message subject
attachment Boolean The presence of an attachment in the message
routing String The directional route of the message. Possible values are internal, outbound, inbound or external
size Integer The size of the message in bytes
remoteIP String The connecting IP address
attempts Integer The processing attemp count of the message
nextAttempt Date String The date of the next process attempt for the message
created Date String The date of the processing request creation
info String Current processing status of the message
lockedUntil Date String The time until the the message is locked for system synchronization
emailAddress Object
Field Type Description
displayName String The display name provided for an address, if avilable
emailAddress String The routable email address

Sample Code

Sample code is provided to demonstrate how to use the API and is not representative of a production application. To use the sample code; complete the required variables as described, populate the desired values in the request body, and execute in your favorite IDE.  Please see the Global Base URL's page to find the correct base URL to use for your account.

POST {base_url}/api/gateway/find-processing-messages
Authorization: MC {accesskKey}:{Base64 encoded signed Data To Sign}
x-mc-date: {dateTime}
x-mc-req-id: {unique id}
x-mc-app-id: {applicationId}
Content-Type: application/json
Accept: application/json


{
  "data":[
    {
        "sortOrder": "String",
        "start": "2015-11-16T14:49:18+0000",
        "searchBy": {
            "value": "String",
            "fieldName": "String"
        },
        "end": "2015-11-16T14:49:18+0000",
        "sortBy": "String",
        "type": "String",
        "filterBy": [
            {
            "value": "String",
            "fieldName": "String"
            }
        ]
    }
  ]
}
import base64
import hashlib
import hmac
import uuid
import datetime
import requests

# Setup required variables
base_url = "https://xx-api.mimecast.com"
uri = "/api/gateway/find-processing-messages"
url = base_url + uri
access_key = "YOUR ACCESS KEY"
secret_key = "YOUR SECRET KEY"
app_id = "YOUR APPLICATION ID"
app_key = "YOUR APPLICATION KEY"

# Generate request header values
request_id = str(uuid.uuid4())
hdr_date = datetime.datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S") + " UTC"

# Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
hmac_sha1 = hmac.new(secret_key.decode("base64"), ':'.join([hdr_date, request_id, uri, app_key]),
                  digestmod=hashlib.sha1).digest()

# Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
sig = base64.encodestring(hmac_sha1).rstrip()

# Create request headers
headers = {
    'Authorization': 'MC ' + access_key + ':' + sig,
    'x-mc-app-id': app_id,
    'x-mc-date': hdr_date,
    'x-mc-req-id': request_id,
    'Content-Type': 'application/json'
}

payload = {
        'data': [
            {
                "sortOrder": "String",
                "start": "2015-11-16T14:49:18+0000",
                "searchBy": {
                    "value": "String",
                    "fieldName": "String"
                },
                "end": "2015-11-16T14:49:18+0000",
                "sortBy": "String",
                "type": "String",
                "filterBy": [
                    {
                    "value": "String",
                    "fieldName": "String"
                    }
                ]
            }
        ]
    }

r = requests.post(url=url, headers=headers, data=str(payload))

print r.text
static void Main(string[] args)
        {
            //Setup required variables
            string baseUrl = "https://xx-api.mimecast.com";
            string uri = "/api/gateway/find-processing-messages";
            string accessKey = "YOUR ACCESS KEY";
            string secretKey = "YOUR SECRET KEY";
            string appId = "YOUR APPLICATION ID";
            string appKey = "YOUR APPLICATION KEY";

            //Generate request header values
            string hdrDate = System.DateTime.Now.ToUniversalTime().ToString("R");
            string requestId = System.Guid.NewGuid().ToString();

            //Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
            System.Security.Cryptography.HMAC h = new System.Security.Cryptography.HMACSHA1(System.Convert.FromBase64String(secretKey));

            //Use the HMAC SHA1 value to sign the hdrDate + ":" requestId + ":" + URI + ":" + appkey
            byte[] hash = h.ComputeHash(System.Text.Encoding.Default.GetBytes(hdrDate + ":" + requestId + ":" + uri + ":" + appKey));

            //Build the signature to be included in the Authorization header in your request
            string signature = "MC " + accessKey + ":" + System.Convert.ToBase64String(hash);

            //Build Request
            System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(baseUrl + uri);
            request.Method = "POST";
            request.ContentType = "application/json";

            //Add Headers
            request.Headers[System.Net.HttpRequestHeader.Authorization] = signature;
            request.Headers.Add("x-mc-date", hdrDate);
            request.Headers.Add("x-mc-req-id", requestId);
            request.Headers.Add("x-mc-app-id", appId);

            //Add request body
            //Create and write data to stream
            string postData = @"{
                    ""data"": [
                        {
                            ""sortOrder"": ""String"",
                            ""start"": ""2015-11-16T14:49:18+0000"",
                            ""searchBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            },
                            ""end"": ""2015-11-16T14:49:18+0000"",
                            ""sortBy"": ""String"",
                            ""type"": ""String"",
                            ""filterBy"": [
                                {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                                }
                            ]
                        }
                    ]
                }";

            byte[] payload = System.Text.Encoding.UTF8.GetBytes(postData);

            System.IO.Stream stream = request.GetRequestStream();
            stream.Write(payload, 0, payload.Length);
            stream.Close();

            //Send Request
            System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponse();

            //Output response to console
            System.IO.StreamReader reader = new System.IO.StreamReader(response.GetResponseStream());
            string responseBody = "";
            string temp = null;
            while ((temp = reader.ReadLine()) != null)
            {
                responseBody += temp;
            };
            System.Console.WriteLine(responseBody);
            System.Console.ReadLine();
        }
#Setup required variables
$baseUrl = "https://xx-api.mimecast.com"
$uri = "/api/gateway/find-processing-messages"
$url = $baseUrl + $uri
$accessKey = "YOUR ACCESS KEY"
$secretKey = "YOUR SECRET KEY"
$appId = "YOUR APPLICATION ID"
$appKey = "YOUR APPLICATION KEY"

#Generate request header values
$hdrDate = (Get-Date).ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss UTC")
$requestId = [guid]::NewGuid().guid

#Create the HMAC SHA1 of the Base64 decoded secret key for the Authorization header
$sha = New-Object System.Security.Cryptography.HMACSHA1
$sha.key = [Convert]::FromBase64String($secretKey)
$sig = $sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($hdrDate + ":" + $requestId + ":" + $uri + ":" + $appKey))
$sig = [Convert]::ToBase64String($sig)

#Create Headers
$headers = @{"Authorization" = "MC " + $accessKey + ":" + $sig;
                "x-mc-date" = $hdrDate;
                "x-mc-app-id" = $appId;
                "x-mc-req-id" = $requestId;
                "Content-Type" = "application/json"}

#Create post body
$postBody = "{
                    ""data"": [
                        {
                            ""sortOrder"": ""String"",
                            ""start"": ""2015-11-16T14:49:18+0000"",
                            ""searchBy"": {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                            },
                            ""end"": ""2015-11-16T14:49:18+0000"",
                            ""sortBy"": ""String"",
                            ""type"": ""String"",
                            ""filterBy"": [
                                {
                                ""value"": ""String"",
                                ""fieldName"": ""String""
                                }
                            ]
                        }
                    ]
                }"

#Send Request
$response = Invoke-RestMethod -Method Post -Headers $headers -Body $postBody -Uri $url

#Print the response
$response
public static void main(String[] args) throws java.io.IOException, java.security.NoSuchAlgorithmException, java.security.InvalidKeyException {

        //set up variables for request
        String baseUrl = "https://xx-api.mimecast.com";
        String uri = "/api/gateway/find-processing-messages";
        String url = "https://" + baseUrl + uri;
        String accessKey = "YOUR ACCESS KEY";
        String secretKey = "YOUR SECRET KEY";
        String appId = "YOUR APPLICATION ID";
        String appKey = "YOUR APPLICATION KEY";

        //create URL object
        java.net.URL obj = new java.net.URL(url);

        // set guid for x-mc-req-id header
        String guid = java.util.UUID.randomUUID().toString();

        // set date for x-mc-date header
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss z");
        sdf.setTimeZone(java.util.TimeZone.getTimeZone("UTC"));
        String date = sdf.format(new java.util.Date());

        //create signature for the Authorization header
        String dataToSign = date + ":" + guid + ":" + uri + ":" + appKey;
        String hmacSHA1 = "HmacSHA1";
        javax.crypto.spec.SecretKeySpec signingKey = new javax.crypto.spec.SecretKeySpec(org.apache.commons.codec.binary.Base64.decodeBase64(secretKey.getBytes()), hmacSHA1);
        javax.crypto.Mac mac = javax.crypto.Mac.getInstance(hmacSHA1);
        mac.init(signingKey);
        String sig = new String(org.apache.commons.codec.binary.Base64.encodeBase64(mac.doFinal(dataToSign.getBytes())));

        // create request object
        javax.net.ssl.HttpsURLConnection con = (javax.net.ssl.HttpsURLConnection) obj.openConnection();

        //set request type to POST
        con.setRequestMethod("POST");
        con.setDoOutput(true);

        //add reuqest headers
        con.setRequestProperty("Authorization", "MC " + accessKey + ":" + sig);
        con.setRequestProperty("x-mc-req-id", guid);
        con.setRequestProperty("x-mc-app-id", appId);
        con.setRequestProperty("x-mc-date", date);
        con.setRequestProperty("Content-Type", "application/json");
        con.setRequestProperty("Accept", "application/json");

        //Add post body to the request
        String postBody = "{\n" +
        " \"data\": [\n" +
        "     {\n" +
        "          \"sortOrder\": \"String\",\n" +
        "          \"start\": \"2015-11-16T14:49:18+0000\",\n" +
        "          \"searchBy\": {\n" +
        "              "\"value\": \"String\",\n" +
        "              "\"fieldName\": \"String\",\n" +
        "          },\n" +
        "          \"end\": \"2015-11-16T14:49:18+0000\",\n" +
        "          \"sortBy\": \"String\",\n" +
        "          \"type\": \"String\",\n" +
        "          \"filterBy\": [\n" +
        "         "{\n" +
        "              "\"value\": \"String\",\n" +
        "              "\"fieldName\": \"String\",\n" +
        "         "}\n" +
        "     ]\n" +
        "     }\n" +
        " ]\n" +
        "}";
        java.io.OutputStream os = con.getOutputStream();
        os.write(postBody.getBytes("UTF-8"));
        os.close();

        //process response
        java.io.BufferedReader in = new java.io.BufferedReader(
                new java.io.InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer response = new StringBuffer();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        //return result
        java.lang.System.out.println(response.toString());
    }