JavaScript Plug-in

The JavaScript Plug-in Runs a specific JavaScript code. The plug-in can run any specified JavaScript code as follows:

• To view any service property and plug-in property value.
• To pass the maximum of 10 arguments via plug-in properties to the JavaScript code.
• To keep the maximum of 10 values in plug-in output properties.
• To return a value and keep the return value in the output properties.

Return codes

The JavaScript Plug-in generates the following return codes:

Property list

The following properties are available for the JavaScript Plug-in:

You specify the plug-in input/output properties in the property list. Combinations of service property values, reserved property values, and literal characters can be used for the input properties.

JavaScript code specifiable for the JavaScript body

The following table shows the JavaScript codes that are allowable in the body of the script:

auto util Library

The JavaScript plug-in supports the auto util library with the following features:

• Sends an http or https request to any destination.
• The setting values of Web Service Connection can be referred to as the connection information.

The following table shows the auto util methods that are available:

The following members are available for the JSON object of the request:

The following table shows the allowable response members:

The following members are available for the object with retry conditions:

The following table shows the specification differences between the http.call and storage.restCall methods.

Sample code (scriptBody)

JavaScript sample code that can be specified in the plug-in property JavaScript body is as follows:

function(serviceProperties, pluginProperties, arg0, arg1, arg2) {
    var obj = new Object();
    print("[Debug] Function begin.");

    obj.mem1 = arg0;
    obj.mem2 = arg1;

    if (arg2 == "") {
        pluginProperties["notify"] = 999;
        pluginProperties["out1"] = "NOTE!: The arg2 is EMPTY.";
    } else {
        obj.mem3 = arg2;
        obj.status = "success";
        pluginProperties["out1"] = "Finished successfully.";
    }

    print("[Debug] Function end.");

    return obj;
}

As described in the previous table, there are two ways of obtaining arg0, arg1,... where each can provide a different value. For pluginProperties, the arguments are obtained as a string but when obtained from the argument arg0, arg1,..., the evaluated value can be obtained from JavaScript. The example that shows the difference between the case of obtaining the input property of the plug-in from pluginProperties and the case of obtaining it from arg0, arg1,... is as follows.

Suppose that the following sample code is run by specifying 3 to arg0 and 5 to arg1.

function(serviceProperties, pluginProperties, arg0, arg1) {
    pluginProperties["out0"] = pluginProperties["arg0"] + pluginProperties["arg1"];
    pluginProperties["out1"] = arg0 + arg1;
}

When this sample code is run, "35" is set to out0, and "8.0" is set to out1. From pluginProperties, the arguments are handled as strings of "3" and "5" respectively, while the "+" symbol is handled as the string concatenation. In addition, for arg0 and arg1, they become 3.0 and 5.0 respectively, while the "+" symbol is handled as the addition function.

The following sample shows how to get the pool list from the Platform REST API server included in the storage system by referring to the connection information provided by Web Service Connection, and sets to the output property out0. As a prerequisite, the Web Service Connection whose category is StorageSystem" and whose name is "storage1" must already be registered.

function getPools(productname, connectionname) {
  var respBody = null;
  var request = {
    requestMethod:'GET',
    requestUrl:'/ConfigurationManager/v1/objects/pools',
    requestHeaders:auto.util.http.toRawHeader({
      'Accept':'application/json',
      'Accept-Language':'en',
      'Content-Type':'application/json',
    }),
    authScheme:'basic',
    connectionName: connectionname,
    productName: productname,
  };
  auto.util.http.handleCall(auto.util.http.call, request,
    function(resp, req) {
      respBody = resp.responseBody;
    }, function(resp, req) {
      auto.util.http.defaultErrorHandler(null, req, resp);
    }, function(err, req) {
      auto.util.http.defaultErrorHandler(err, req);
    }
  );
  return JSON.parse(respBody);
}
function fn(serviceProperties, pluginProperties, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
  var data = getPools('StorageSystem', 'storage1').data;
  var poolList = [];
  _.each(data, function(d){
    poolList.push({
      poolId: d.poolId,
      poolStatus: d.poolStatus,
      availableVolumeCapacity: d.availableVolumeCapacity
    }); 
  }); 
  pluginProperties.out0 = JSON.stringify(poolList, null, 2);
}

The following sample shows how to get the pool list from the Platform REST API server included in the storage system without referring to the connection information of Web Service Connection, and sets to the output property out0. As a prerequisite, the host name of Platform REST API server must be "host", the logon user name is "user", and the password is "password".

function getPools() {
  var respBody = null;
  var request = {
    requestMethod:'GET',
    requestUrl:'https://host/ConfigurationManager/v1/objects/pools',
    requestHeaders:auto.util.http.toRawHeader({
      'Accept':'application/json',
      'Accept-Language':'en',
      'Content-Type':'application/json',
    }),
    authScheme:'basic',
    userName:'user',
    password:'password',
    useProxy:'false'
  };
  auto.util.http.handleCall(auto.util.http.call, request,
    function(resp, req) {
      respBody = resp.responseBody;
    }, function(resp, req) {
      auto.util.http.defaultErrorHandler(null, req, resp);
    }, function(err, req) {
      auto.util.http.defaultErrorHandler(err, req);
    }
  );
  return JSON.parse(respBody);
}
function fn(serviceProperties, pluginProperties, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
  var data = getPools().data;
  var poolList = [];
  _.each(data, function(d){
    poolList.push({
      poolId: d.poolId,
      poolStatus: d.poolStatus,
      availableVolumeCapacity: d.availableVolumeCapacity
    }); 
  });
  pluginProperties.out0 = JSON.stringify(poolList, null, 2);
}

Sample code (scriptBody/importedScript)

JavaScript sample code that can be specified in the plug-in property scriptBody/importedScript is as follows:

-------------------------------------------
(scriptBody)
-------------------------------------------
function fn(serviceProperties, pluginProperties, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {

  hoge(CNST);

}
-------------------------------------------
(importedScript)
-------------------------------------------
var CNST = "hoge";

function hoge(a){
  print(a + " from common js!");
}
-------------------------------------------

Sample code (Retry settings)

JavaScript sample code in which the custom retry condition is specified as the sixth argument of http.handleCall.

var retrySettings = {};
retrySettings.retryCondition = function (response) {return response.responseStatusCode===503;};  // Retry when the response is 503
retrySettings.maxRetryCount = 10;  // Retry up to 10 times
retrySettings.retryWaitTime = 60;  // Retry every 60 seconds

auto.util.http.handleCall(auto.util.storage.restCall, request, successHandler, serverErrorHandler, clientErrorHandler, retrySettings);

Sample code (Running the Configuration Manager REST API)

The following shows a sample code when running the Configuration Manager REST API to obtain the pool information.

function fn(serviceProperties, pluginProperties, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
  var storageDeviceId = <storageDeviceId>;

  //Step 1. Generate a method to run REST API to Configuration Manager.
  var configurationManagerCall = function(request) {
    var respBody = null;
    auto.util.http.handleCall(auto.util.storage.restCall, request, 
      function(resp, req) {
        respBody = auto.util.parseJson(resp.responseBody);
      }, function(resp, req) {
        auto.util.http.defaultErrorHandler(null, req, resp);
      }, function(err, req) {
        auto.util.http.defaultErrorHandler(err, req);
      }, auto.util.storage.retrySettings
    );
    return respBody;
  };
  
  //Step 2. Get accessible Web Service Connections by specifying a category name.
  var wsc = auto.util.env.getWebServiceConnections("ConfigurationManager");
  
  //Step 3. Get Session
  //You can pass arguments by using the plug-in input properties or you can specify them directly in a script. For example, you can pass the device ID through the query parameters (queryParamMap).
  var request = {
    "requestMethod": "POST",
    "requestUrl": "/ConfigurationManager/v1/objects/storages/" + storageDeviceId + "/sessions",
    "requestHeaders": auto.util.http.toRawHeader({}),
    "authScheme": "basic",
    "connectionName": wsc[0].name,
    "productName": wsc[0].productName
  };
  var responseBody = configurationManagerCall(request);
  var token = responseBody.token;
  var sId = responseBody.sessionId;

  //Step 4. Call the API that is associated with your use case based on the session obtained in Step 3.
//When specifying the Authorization header for the request in the user program, specify "none" for authScheme.
  var headers = {
    "Authorization": "Session " + token,
  };
  var queryMap = {
    "poolType" : "DP"
  };
  var queryStr = auto.util.http.buildQuery(queryMap);
  request = {
    "requestMethod": "GET",
    "requestUrl": "/ConfigurationManager/v1/objects/storages/" + storageDeviceId + "/pools" + queryStr,
    "requestHeaders": auto.util.http.toRawHeader(headers),
    "authScheme": "none",
    "connectionName": wsc[0].name,
    "productName": wsc[0].productName
  };
  var ret = configurationManagerCall(request);

  //Final Step. Set the required information for the output property of the plug-in or return value.
  pluginProperties.out0 = ret.data[0].poolId;
  pluginProperties.out1 = ret.data[0].poolName;
  return ret;
}