657 lines
29 KiB
JavaScript
657 lines
29 KiB
JavaScript
// Copyright (C) 2016 Intel Corporation
|
|
|
|
var WSManRequests = {
|
|
GET : "http://schemas.xmlsoap.org/ws/2004/09/transfer/Get",
|
|
PUT : "http://schemas.xmlsoap.org/ws/2004/09/transfer/Put",
|
|
DELETE : "http://schemas.xmlsoap.org/ws/2004/09/transfer/Delete",
|
|
CREATE : "http://schemas.xmlsoap.org/ws/2004/09/transfer/Create",
|
|
RELEASE : "http://schemas.xmlsoap.org/ws/2004/09/enumeration/Release",
|
|
IDENTITY : "http://schemas.xmlsoap.org/ws/2005/05/identity"
|
|
};
|
|
|
|
var namespacesURI = {
|
|
RESOURCE_URI_PREFIX_AMT : "http://intel.com/wbem/wscim/1/amt-schema/1/",
|
|
RESOURCE_URI_PREFIX_CIM : "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/",
|
|
RESOURCE_URI_PREFIX_IPS : "http://intel.com/wbem/wscim/1/ips-schema/1/",
|
|
RESOURCE_URI_WSMAN : "http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd",
|
|
RESOURCE_URI_ADDRESSING : "http://schemas.xmlsoap.org/ws/2004/08/addressing",
|
|
RESOURCE_URI_ENVELOPE : "http://www.w3.org/2003/05/soap-envelope",
|
|
RESOURCE_URI_ENUMERATION : "http://schemas.xmlsoap.org/ws/2004/09/enumeration",
|
|
RESOURCE_URI_COMMON : "http://schemas.dmtf.org/wbem/wscim/1/common"
|
|
};
|
|
|
|
/**
|
|
* XML resources
|
|
*/
|
|
var resources = {
|
|
WSManRequestXmlString : "<s:Envelope xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:w=\"http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\"><s:Header><a:To></a:To><w:ResourceURI s:mustunderstand=\"true\"></w:ResourceURI><a:ReplyTo><a:Address s:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address></a:ReplyTo><a:Action s:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2004/09/transfer/Get</a:Action><w:MaxEnvelopeSize s:mustUnderstand=\"true\">153600</w:MaxEnvelopeSize><a:MessageID></a:MessageID><w:Locale xml:lang=\"en-US\" s:mustUnderstand=\"false\" /><w:OperationTimeout>PT60.000S</w:OperationTimeout><w:SelectorSet></w:SelectorSet></s:Header><s:Body></s:Body></s:Envelope>",
|
|
referenceXmlString : "<a:EndpointReference xmlns:w=\"http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\" xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\"><a:Address>http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address><a:ReferenceParameters><w:ResourceURI></w:ResourceURI><w:SelectorSet /></a:ReferenceParameters></a:EndpointReference>",
|
|
enumerateXmlString : "<s:Envelope xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:n=\"http://schemas.xmlsoap.org/ws/2004/09/enumeration\" xmlns:w=\"http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\"><s:Header><a:To></a:To><w:ResourceURI s:mustUnderstand=\"true\"></w:ResourceURI><a:ReplyTo><a:Address s:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address></a:ReplyTo><a:Action s:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2004/09/enumeration/Enumerate</a:Action><w:MaxEnvelopeSize s:mustUnderstand=\"true\">153600</w:MaxEnvelopeSize><a:MessageID>uuid:00000000-0000-0000-0000-000000000000</a:MessageID><w:Locale xml:lang=\"en-US\" s:mustUnderstand=\"false\" /><w:OperationTimeout>PT60.000S</w:OperationTimeout><w:SelectorSet/></s:Header><s:Body><n:Enumerate><w:Filter Dialect=\"http://schemas.dmtf.org/wbem/wsman/1/wsman/SelectorFilter\"><w:SelectorSet xmlns:w=\"http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\" /></w:Filter><w:MaxElements></w:MaxElements></n:Enumerate></s:Body></s:Envelope>",
|
|
pullXmlString: "<s:Envelope xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:a=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:n=\"http://schemas.xmlsoap.org/ws/2004/09/enumeration\" xmlns:w=\"http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd\"><s:Header><a:To></a:To><w:ResourceURI s:mustUnderstand=\"true\"></w:ResourceURI><a:ReplyTo><a:Address s:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2004/08/addressing/role/anonymous</a:Address></a:ReplyTo><a:Action s:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2004/09/enumeration/Pull</a:Action><w:MaxEnvelopeSize s:mustUnderstand=\"true\">153600</w:MaxEnvelopeSize><a:MessageID></a:MessageID><w:Locale xml:lang=\"en-US\" s:mustUnderstand=\"false\" /><w:SelectorSet/><w:OperationTimeout>PT60.000S</w:OperationTimeout></s:Header><s:Body><n:Pull><n:EnumerationContext>00000000-0000-0000-0000-000000000000</n:EnumerationContext><n:MaxElements>20</n:MaxElements></n:Pull></s:Body></s:Envelope>"
|
|
};
|
|
|
|
//Converts WS-Man class object to reference xml.
|
|
function objectToEPR(classObj) {
|
|
if (!classObj.className) {
|
|
return null;
|
|
}
|
|
var refXml = new XmlDocument(resources.referenceXmlString);
|
|
var resUri = getResourceUriByName(classObj.className);
|
|
if (!resUri) {
|
|
return null;
|
|
}
|
|
refXml.setNode(namespacesURI.RESOURCE_URI_WSMAN,"ResourceURI", resUri);
|
|
if (classObj.selectors) {
|
|
refXml.setSelectoresNode(classObj.selectors);
|
|
}
|
|
return refXml;
|
|
}
|
|
|
|
//Converts WS-Man class object to xml.
|
|
function objectToStringXml(classObj) {
|
|
if (!classObj.className) {
|
|
return null;
|
|
}
|
|
var resUri = getResourceUriByName(classObj.className);
|
|
if (!resUri) {
|
|
return null;
|
|
}
|
|
var xmlStr = "<g:" + classObj.className + " xmlns:g=\"" + resUri + "\">";
|
|
for (var p in classObj.properties) {
|
|
if (classObj.properties[p] instanceof Array) {
|
|
for (var ii = 0; ii < classObj.properties[p].length; ++ii) {
|
|
xmlStr += "<g:" + p + ">" + classObj.properties[p][ii] + "</g:" + p + ">";
|
|
}
|
|
} else {
|
|
xmlStr += "<g:" + p + ">" + classObj.properties[p] + "</g:" + p + ">";
|
|
}
|
|
}
|
|
xmlStr += "</g:" + classObj.className + ">";
|
|
return xmlStr;
|
|
}
|
|
|
|
//Converts the method input parameters object to a WS-Man input parameters xml string
|
|
function objectParamToXml(className, methodName, params) {
|
|
if (!methodName) {
|
|
return null;
|
|
}
|
|
|
|
var xmlStr = "<p:" + methodName + "_INPUT xmlns:p=\"" + getResourceUriByName(className) + "\">";
|
|
for (var p in params) {
|
|
if (params[p] instanceof Array) {
|
|
for (var ii = 0; ii < params[p].length; ++ii) {
|
|
xmlStr += paramToElementNode(p, params[p][ii]);
|
|
}
|
|
} else {
|
|
xmlStr += paramToElementNode(p, params[p]);
|
|
}
|
|
}
|
|
xmlStr += "</p:" + methodName + "_INPUT>";
|
|
return xmlStr;
|
|
}
|
|
|
|
function paramToElementNode(key, val) {
|
|
if (!key || !val) {
|
|
return null;
|
|
}
|
|
var xmlStr = "<p:" + key + ">";
|
|
if (val.className) {
|
|
xmlStr += objectToEPR(val).getNode(namespacesURI.RESOURCE_URI_ADDRESSING,"EndpointReference").innerHTML;
|
|
} else {
|
|
xmlStr += val;
|
|
}
|
|
xmlStr += "</p:" + key + ">";
|
|
return xmlStr;
|
|
}
|
|
|
|
//Converts class reference xml to object.
|
|
function EPRtoObject(ref) {
|
|
var obj = {};
|
|
var refXml = new XmlDocument(ref);
|
|
if (!refXml.getNode(namespacesURI.RESOURCE_URI_ADDRESSING, "Address")) {
|
|
return null;
|
|
}
|
|
var resUriNode = refXml.getNode(namespacesURI.RESOURCE_URI_WSMAN, "ResourceURI");
|
|
if (!resUriNode) {
|
|
return null;
|
|
}
|
|
var pos = resUriNode.innerHTML.lastIndexOf("/");
|
|
obj.className = resUriNode.innerHTML.slice(pos + 1);
|
|
var childs = refXml.getNode(namespacesURI.RESOURCE_URI_WSMAN, "SelectorSet").childNodes;
|
|
if (childs.length) {
|
|
obj.selectors = {};
|
|
// selectorSetChilds.forEach(function(element) {
|
|
// var key = element.getAttribute("Name");
|
|
// obj.selectors[key] = element.innerHTML;
|
|
// });
|
|
for (var ii = 0; ii < childs.length; ++ii) {
|
|
var key = childs[ii].getAttribute("Name");
|
|
obj.selectors[key] = childs[ii].innerHTML;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
//Converts the AMT's WS-Man response body xml content to JavaScript Object containing its properties.
|
|
function wsXmlToObject(propertiesNodes) {
|
|
if (!propertiesNodes)
|
|
return null;
|
|
|
|
var res = {};
|
|
/*propertiesNodes.forEach(function(element) {
|
|
if (res[element.localName] && res[element.localName] instanceof Array)
|
|
res[element.localName].push(element.innerHTML);
|
|
else if (res[element.localName])
|
|
res[element.localName] = [res[element.localName] , element.innerHTML];
|
|
else if (element.firstElementChild) {
|
|
var obj = EPRtoObject(element);
|
|
if (!obj) obj = wsXmlToObject(element.childNodes);
|
|
res[element.localName] = obj;
|
|
}
|
|
else
|
|
res[element.localName] = element.innerHTML;
|
|
});*/
|
|
for (var ii = 0; ii < propertiesNodes.length; ++ii) {
|
|
if (res[propertiesNodes[ii].localName] && res[propertiesNodes[ii].localName] instanceof Array) {
|
|
res[propertiesNodes[ii].localName].push(propertiesNodes[ii].innerHTML);
|
|
} else if (res[propertiesNodes[ii].localName]) {
|
|
res[propertiesNodes[ii].localName] = [res[propertiesNodes[ii].localName] , propertiesNodes[ii].innerHTML];
|
|
} else if (propertiesNodes[ii].firstElementChild) {
|
|
var obj = EPRtoObject(propertiesNodes[ii]);
|
|
if (!obj) obj = wsXmlToObject(propertiesNodes[ii].childNodes);
|
|
res[propertiesNodes[ii].localName] = obj;
|
|
} else {
|
|
res[propertiesNodes[ii].localName] = propertiesNodes[ii].innerHTML;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
//Converts items xml to an array of WS-Man objects
|
|
function wsEnumXmlToObjectArray(itemsNode) {
|
|
var arr = [];
|
|
for (var ii = 0; ii < itemsNode.length; ++ii) {
|
|
var res = {
|
|
className : itemsNode[ii].localName
|
|
};
|
|
res.properties = wsXmlToObject(itemsNode[ii].childNodes);
|
|
arr.push(res);
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
//Returns the resource uri of the WS-Man class
|
|
function getResourceUriByName(className) {
|
|
var ns = {
|
|
"CIM" : "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/",
|
|
"AMT" : "http://intel.com/wbem/wscim/1/amt-schema/1/",
|
|
"IPS" : "http://intel.com/wbem/wscim/1/ips-schema/1/"
|
|
};
|
|
|
|
var pos = className.indexOf("_");
|
|
if (pos === -1) {
|
|
return null;
|
|
}
|
|
|
|
var prefix = className.slice(0, pos);
|
|
if (!ns[prefix]) {
|
|
return null;
|
|
}
|
|
return ns[prefix] + className;
|
|
}
|
|
|
|
/**
|
|
* Creates an xml document class
|
|
* @param {String\Document} The xml code of the document to manipulate
|
|
* @constructor
|
|
*/
|
|
function XmlDocument(xml) {
|
|
var doc = {};
|
|
|
|
if (typeof xml === "string") {
|
|
doc = (new DOMParser()).parseFromString(xml, "text/xml");
|
|
} else {
|
|
doc = xml;
|
|
}
|
|
|
|
/**
|
|
* Sets the inner text of an XML node
|
|
* @param {String} The node's namespace
|
|
* @param {String} The node's name
|
|
* @param {String} The text to insert
|
|
*/
|
|
this.setNode = function (ns, node, value) {
|
|
var nodeList = getNodeListObject(ns,node);
|
|
if (!nodeList.length) {
|
|
return;
|
|
}
|
|
nodeList[0].innerHTML = value;
|
|
}
|
|
|
|
/**
|
|
* Fills the SelectorSet node of the WS-MAN command
|
|
* @param {Object} An object containing the selectors to insert.
|
|
*/
|
|
this.setSelectoresNode = function (selectors) {
|
|
for (var key in selectors) {
|
|
//Create new node
|
|
var selectorNode = doc.createElement("w:Selector");
|
|
//Add node attribute
|
|
selectorNode.setAttribute("Name", key);
|
|
//Insert text to node
|
|
var textNode = {};
|
|
if (selectors[key].className) { //Selector is a reference to another class
|
|
var epr = objectToEPR(selectors[key]);
|
|
textNode = epr.getNode(namespacesURI.RESOURCE_URI_ADDRESSING,"EndpointReference");
|
|
}
|
|
else { textNode = doc.createTextNode(selectors[key]); }
|
|
|
|
selectorNode.appendChild(textNode);
|
|
//Insert node to SelectorSet node
|
|
getNodeListObject(namespacesURI.RESOURCE_URI_WSMAN,"SelectorSet")[0].appendChild(selectorNode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the first node in the xml object that matches the provided name.
|
|
* @param {String} The node's namespace
|
|
* @param {String} The node's name
|
|
* @retruns {Node} The first instance of a node with the provided name
|
|
*/
|
|
this.getNode = function(ns, node) {
|
|
var nodeList = getNodeListObject(ns,node);
|
|
if (!nodeList.length) {
|
|
return null;
|
|
}
|
|
return nodeList[0];
|
|
}
|
|
|
|
/**
|
|
* Returns a list of all nodes in the xml object that match the provided name.
|
|
* @param {String} The node's namespace
|
|
* @param {String} The node's name
|
|
* @retruns {NodeList} The list of all nodes with the provided name
|
|
*/
|
|
this.getNodeList = function(ns, node) {
|
|
var nodeList = getNodeListObject(ns,node);
|
|
if (!nodeList.length) {
|
|
return null;
|
|
}
|
|
return nodeList;
|
|
}
|
|
|
|
/**
|
|
* Returns the xml object
|
|
* @returns {Document} JavaScript xml document
|
|
*/
|
|
this.getXml = function() {
|
|
return doc;
|
|
}
|
|
|
|
/**
|
|
* Prints the document to the console log
|
|
*/
|
|
this.print = function() {
|
|
console.log("XmlDocument:");
|
|
console.log(doc);
|
|
}
|
|
|
|
function getNodeListObject(ns,nodeName) { return doc.getElementsByTagNameNS(ns,nodeName); }
|
|
}
|
|
|
|
/**
|
|
* Create an AMT manager
|
|
* @constructor
|
|
*/
|
|
var AMTConnection = (function() {
|
|
|
|
var connected = false;
|
|
|
|
var address = window.location.origin + "/wsman";
|
|
|
|
/**
|
|
* User name
|
|
* @type {String}
|
|
*/
|
|
var user = null;
|
|
|
|
/**
|
|
* Password
|
|
* @type {String}
|
|
*/
|
|
var password = null;
|
|
|
|
/**
|
|
* AMT FW version
|
|
* @type {Object}
|
|
*/
|
|
var FWVersion = {
|
|
|
|
/**
|
|
* AMT FW version number
|
|
* @type {Number}
|
|
*/
|
|
versionNumber : null,
|
|
|
|
/**
|
|
* Compare the AMT version to the argument
|
|
* @param {String/Number} verCmp string of version to compare
|
|
* @returns {Boolean} true if version
|
|
*/
|
|
compare : function(verCmp) {
|
|
if (isNaN(verCmp))
|
|
throw "version.compare(): Argument is not a number";
|
|
if (this.versionNumber > verCmp)
|
|
return 1;
|
|
if (this.versionNumber < verCmp)
|
|
return -1;
|
|
|
|
//Equals
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
var ajax = new AjaxManager();
|
|
|
|
// - - - - - - - - - - - WS-Man requests - - - - - - - - - - -
|
|
|
|
var performGet = function (params) {
|
|
if (!params.className) {
|
|
return;
|
|
}
|
|
var getRequestXml = new XmlDocument(resources.WSManRequestXmlString);
|
|
getRequestXml.setNode(namespacesURI.RESOURCE_URI_ADDRESSING,"Action",WSManRequests.GET);
|
|
ajax.sendRequest(getRequestXml, params);
|
|
}
|
|
|
|
var performPut = function (params) {
|
|
if (params.className !== params.input.className) {
|
|
return;
|
|
}
|
|
if (!params.className || !params.input.properties) {
|
|
return;
|
|
}
|
|
var putRequestXml = new XmlDocument(resources.WSManRequestXmlString);
|
|
putRequestXml.setNode(namespacesURI.RESOURCE_URI_ADDRESSING,"Action",WSManRequests.PUT);
|
|
putRequestXml.setNode(namespacesURI.RESOURCE_URI_ENVELOPE,"Body", objectToStringXml(params.input));
|
|
ajax.sendRequest(putRequestXml, params);
|
|
}
|
|
|
|
var performInvokeMethod = function (params) {
|
|
if (!params.className || !params.method) {
|
|
return;
|
|
}
|
|
var invokeXml = new XmlDocument(resources.WSManRequestXmlString);
|
|
var resourceUri = getResourceUriByName(params.className);
|
|
if (!resourceUri) {
|
|
return;
|
|
}
|
|
invokeXml.setNode(namespacesURI.RESOURCE_URI_ADDRESSING,"Action", resourceUri + "/" + params.method);
|
|
if (!params.input) {
|
|
params.input = {};
|
|
}
|
|
invokeXml.setNode(namespacesURI.RESOURCE_URI_ENVELOPE,"Body", objectParamToXml(params.className, params.method, params.input));
|
|
ajax.sendRequest(invokeXml, params);
|
|
}
|
|
|
|
var performEnumerate = function (params) {
|
|
if (!params.className) {
|
|
return;
|
|
}
|
|
var enumerateXml = new XmlDocument(resources.enumerateXmlString);
|
|
ajax.sendEnumerateRequest(enumerateXml, params);
|
|
}
|
|
|
|
var performDelete = function (params) {
|
|
if (!params.className) {
|
|
return;
|
|
}
|
|
var deleteXml = new XmlDocument(resources.WSManRequestXmlString);
|
|
deleteXml.setNode(namespacesURI.RESOURCE_URI_ADDRESSING,"Action",WSManRequests.DELETE);
|
|
ajax.sendRequest(deleteXml, params);
|
|
}
|
|
|
|
/**
|
|
* Creates an Ajax manager class that will execute and handle the ajax calls
|
|
* @constructor
|
|
*/
|
|
function AjaxManager() {
|
|
|
|
var uuid = 1;
|
|
|
|
this.sendRequest = function (xmlDoc, params) {
|
|
var resUri = getResourceUriByName(params.className);
|
|
if (!resUri) {
|
|
return;
|
|
}
|
|
xmlDoc.setNode(namespacesURI.RESOURCE_URI_ADDRESSING, "MessageID", uuid++);
|
|
xmlDoc.setNode(namespacesURI.RESOURCE_URI_ADDRESSING, "To", address);
|
|
xmlDoc.setNode(namespacesURI.RESOURCE_URI_WSMAN, "ResourceURI", resUri);
|
|
if (params.selectors)
|
|
xmlDoc.setSelectoresNode(params.selectors);
|
|
|
|
send(xmlDoc, params, parseResponse);
|
|
}
|
|
|
|
this.sendEnumerateRequest = function (xmlDoc, params) {
|
|
var resUri = getResourceUriByName(params.className);
|
|
if (!resUri) {
|
|
return;
|
|
}
|
|
xmlDoc.setNode(namespacesURI.RESOURCE_URI_ADDRESSING, "To", address);
|
|
xmlDoc.setNode(namespacesURI.RESOURCE_URI_WSMAN, "ResourceURI", resUri);
|
|
if (params.selectors) {
|
|
xmlDoc.setSelectoresNode(params.selectors);
|
|
}
|
|
send(xmlDoc, params, parseEnumerationResponse);
|
|
}
|
|
|
|
function send(xmlDoc, params, func_, res ) {
|
|
var xdr = new XMLHttpRequest();
|
|
xdr.open("POST", "/wsman", true, user, password);
|
|
xdr.setRequestHeader("Content-Type", "application/soap+xml;charset=UTF-8");
|
|
xdr.timeout = 15000;
|
|
xdr.onload = function () { func_(xdr.responseXML, xdr.status, params, res); };
|
|
xdr.onerror = function () {
|
|
console.log("Failed to perform the request. Status:" + xdr.status.toString());
|
|
if (params.onError instanceof Function) {
|
|
var failure = {
|
|
status : xdr.status,
|
|
}
|
|
params.onError(failure, params.args);
|
|
}
|
|
};
|
|
xdr.ontimeout = function () {
|
|
console.log("Failed to perform the request. Received Time-out. Status: " + xdr.status.toString());
|
|
if (params.onError instanceof Function) {
|
|
var failure = {
|
|
status : xdr.status,
|
|
reason : "Received Time-out."
|
|
}
|
|
params.onError(failure, params.args);
|
|
}
|
|
};
|
|
xdr.send("<?xml version=\"1.0\" encoding=\"utf-8\"?>" + xmlDoc.getNode(namespacesURI.RESOURCE_URI_ENVELOPE,"Envelope").outerHTML);
|
|
}
|
|
|
|
function parseResponse(recDataXml, status, params) {
|
|
var res = {
|
|
className : params.className
|
|
};
|
|
if (status !== 200) { handleFault(status, params, recDataXml); return; }
|
|
if (params.onSuccess instanceof Function) {
|
|
var xmlDoc = new XmlDocument(recDataXml);
|
|
var body = xmlDoc.getNode(namespacesURI.RESOURCE_URI_ENVELOPE, "Body");
|
|
if (body.firstElementChild) {
|
|
res.properties = wsXmlToObject(body.firstElementChild.childNodes);
|
|
}
|
|
if (params.method) {
|
|
res.method = params.method;
|
|
}
|
|
Object.preventExtensions(res.properties);
|
|
params.onSuccess(res, params.args);
|
|
}
|
|
}
|
|
|
|
function parseEnumerationResponse(recDataXml, status, params, res) {
|
|
if (status !== 200) { handleFault(status, params, recDataXml); return; }
|
|
var enumerationResXml = new XmlDocument(recDataXml);
|
|
var pullXml = new XmlDocument(resources.pullXmlString);
|
|
pullXml.setNode(namespacesURI.RESOURCE_URI_ADDRESSING,"To",address);
|
|
pullXml.setNode(namespacesURI.RESOURCE_URI_WSMAN,"ResourceURI", getResourceUriByName(params.className));
|
|
pullXml.setNode(namespacesURI.RESOURCE_URI_ADDRESSING,"MessageID", uuid++);
|
|
pullXml.setNode(namespacesURI.RESOURCE_URI_ENUMERATION,"EnumerationContext", enumerationResXml.getNode(namespacesURI.RESOURCE_URI_ENUMERATION,"EnumerationContext").innerHTML);
|
|
send(pullXml, params, parseEnumerationResponse1, res);
|
|
}
|
|
|
|
function parseEnumerationResponse1(recDataXml, status, params, res) {
|
|
if (status !== 200) { handleFault(status, params, recDataXml); return; }
|
|
var pullResXml = new XmlDocument(recDataXml);
|
|
var enumContext = pullResXml.getNode(namespacesURI.RESOURCE_URI_ENUMERATION,"EnumerationContext");
|
|
if (params.onSuccess instanceof Function) {
|
|
if (res === undefined) {
|
|
var res = {
|
|
className : params.className,
|
|
items : []
|
|
};
|
|
}
|
|
var itemsNode = pullResXml.getNode(namespacesURI.RESOURCE_URI_ENUMERATION, "Items");
|
|
if (itemsNode.firstElementChild) {
|
|
var arr = wsEnumXmlToObjectArray(itemsNode.childNodes);
|
|
for (var ii = 0; ii < arr.length; ++ii)
|
|
res.items.push(arr[ii]);
|
|
}
|
|
|
|
if (enumContext) { //Not all instances were pulled
|
|
parseEnumerationResponse(recDataXml, status, params, res);
|
|
} else {
|
|
Object.preventExtensions(res.items);
|
|
params.onSuccess(res, params.args);
|
|
}
|
|
}
|
|
}
|
|
|
|
function handleFault(status, params, recDataXml) {
|
|
var failure = {
|
|
status : status
|
|
}
|
|
//Unauthorized
|
|
if (status === 401) {
|
|
failure.reason = "Wsman request is unauthorized. HTTP response status code: " + status.toString();
|
|
} else if (status === 400 || status === 500) { //Bad request or Internal Server Error
|
|
var faultXml = new XmlDocument(recDataXml);
|
|
var reason = faultXml.getNode(namespacesURI.RESOURCE_URI_ENVELOPE,"Reason");
|
|
failure.reason = reason.firstChild.innerHTML;
|
|
} else {
|
|
failure.reason = "Failed to perform the request. HTTP response status code: " + status.toString();
|
|
}
|
|
|
|
if (params.onError instanceof Function) {
|
|
params.onError(failure, params.args);
|
|
}
|
|
}
|
|
} //AjaxManager
|
|
|
|
return {
|
|
|
|
/** Sets the username the connection will use to authenticate */
|
|
setUserName : function (userName) { user = userName;},
|
|
|
|
/** Sets the password the connection will use to authenticate */
|
|
setPassword : function (pass) { password = pass;},
|
|
|
|
/**
|
|
* Connects to the WS-Man client. This function must be called before any of the others may be invoked.
|
|
* @param {info} The object containing the arguments that will be used in this function.
|
|
* Optional fields in the info object:
|
|
* * onSuccess: A callback function that will be immediately run once the command is completed successfully.
|
|
* * onError: A callback function that will be immediately run if the command is not completed successfully.
|
|
*/
|
|
connect : function (info) { performGet({ className : "CIM_SoftwareIdentity",
|
|
onSuccess : function(cimsoftwareidentity) {
|
|
connected = true;
|
|
FWVersion.versionNumber = parseFloat(cimsoftwareidentity.properties.VersionString);
|
|
if (info.onSuccess instanceof Function) {info.onSuccess();}
|
|
},
|
|
onError : function(failure) {
|
|
connected = false;
|
|
console.log("Failed to connect to AMT."); console.log(failure.reason);
|
|
if (info.onError instanceof Function) {info.onError(failure);}
|
|
},
|
|
selectors : { InstanceID : "AMT FW Core Version" }
|
|
}); },
|
|
|
|
/**
|
|
* Performs a WS-Man Get request. The request will not succeed if more than one instance exists of the given
|
|
* className and not enough selectors have been provided to isolate a single instance.
|
|
* @param {info} The object containing the arguments that will be used in this function.
|
|
* Required fields in the info object:
|
|
* * className: The name of the class to get.
|
|
* Optional fields in the info object:
|
|
* * selectors: Any key/value pairs that may be needed to isolate a single instance of the named class.
|
|
* * onSuccess: A callback function that will be immediately run once the command is completed successfully.
|
|
* * onError: A callback function that will be immediately run if the command is not completed successfully.
|
|
*
|
|
*/
|
|
get: function (info) { if (connected == false) return; performGet(info); },
|
|
|
|
/**
|
|
* Performs a WS-Man Put request. The request will not succeed if more than one instance exists of the given
|
|
* className and not enough selectors have been provided to isolate a single instance.
|
|
* @param {info} The object containing the arguments that will be used in this function.
|
|
* Required fields in the info object:
|
|
* * className: The name of the class to put.
|
|
* * input: A set of key/value pairs containing the set of properties that will be saved in the selected object.
|
|
* This must include a "className" key with a value equal to the "className" field above.
|
|
* Optional fields in the info object:
|
|
* * selectors: Any key/value pairs that may be needed to isolate a single instance of the named class.
|
|
* * onSuccess: A callback function that will be immediately run once the command is completed successfully.
|
|
* * onError: A callback function that will be immediately run if the command is not completed successfully.
|
|
*/
|
|
put: function (info) { if (connected == false) return; performPut(info); },
|
|
|
|
/**
|
|
* Invokes a method within AMT. The request will not succeed if more than one instance exists of the given
|
|
* className and not enough selectors have been provided to isolate a single instance.
|
|
* @param {info} The object containing the arguments that will be used in this function.
|
|
* Required fields in the info object:
|
|
* * className: The name of the class containing the method you want to invoke.
|
|
* * method: The name of the method that you want to invoke.
|
|
* * input: The set of key/value pairs containing the set of parameters that will be sent to the invoked method.
|
|
* The key half of each pair must be the same as the name of the parameter.
|
|
* Optional fields in the info object:
|
|
* * selectors: Any key/value pairs that may be needed to isolate a single instance of the named class.
|
|
* * onSuccess: A callback function that will be immediately run once the command is completed successfully.
|
|
* * onError: A callback function that will be immediately run if the command is not completed successfully.
|
|
*/
|
|
invokeMethod: function (info) { if (connected == false) return; performInvokeMethod(info); },
|
|
|
|
/**
|
|
* Performs a WS-Man Get request that retrieves all instances of the requested class.
|
|
* @param {info} The object containing the arguments that will be used in this function.
|
|
* Required fields in the info object:
|
|
* * className: The name of the class to get.
|
|
* Optional fields in the info object:
|
|
* * selectors: Any key/value pairs that you want to use to narrow down the list of retrieved objects.
|
|
* * onSuccess: A callback function that will be immediately run once the command is completed successfully.
|
|
* * onError: A callback function that will be immediately run if the command is not completed successfully.
|
|
* */
|
|
enumerate: function (info) { if (connected == false) return; performEnumerate(info); },
|
|
|
|
/**
|
|
* Performs a WS-Man Delete request that deletes an object.
|
|
* @param {info} The object containing the arguments that will be used in this function. The request will not succeed
|
|
* if more than one instance exists of the given className and not enough selectors have been provided to isolate a single instance.
|
|
* Required fields in the info object:
|
|
* * className: The class of the object that you want to delete.
|
|
* Optional fields in the info object:
|
|
* * selectors: Any key/value pairs that may be needed to isolate a single instance of the named class.
|
|
* * onSuccess: A callback function that will be immediately run once the command is completed successfully.
|
|
* * onError: A callback function that will be immediately run if the command is not completed successfully.
|
|
*/
|
|
delete : function (info) { if (connected == false) return; performDelete(info); },
|
|
|
|
/** AMT FW version number */
|
|
version : FWVersion
|
|
};
|
|
})(); |