Appends Splunk-specific headers.
Appends Splunk-specific headers.
| Name | Type | Description |
|---|---|---|
| headers | Object | A dictionary of headers (optional). |
An augmented dictionary of headers.
_headers: function (headers) {
headers = headers || {};
if (this.sessionKey) {
headers["Authorization"] = this.authorization + " " + this.sessionKey;
}
return headers;
},Performs a DELETE request.
| Name | Type | Description |
|---|---|---|
| path | String | The REST endpoint path of the DELETE request. |
| params | Object | The entity-specific parameters for this request. |
| callback | Function | The function to call when the request is complete: |
del: function(path, params, callback) {
var that = this;
var request = function(callback) {
return that.http.del(
that.urlify(path),
that._headers(),
params,
that.timeout,
callback
);
};
return this._requestWrapper(request, callback);
},Converts a partial path to a fully-qualified path to a REST endpoint, and if necessary includes the namespace owner and app.
| Name | Type | Description |
|---|---|---|
| path | String | The partial path. |
| namespace | String | The namespace, in the format "owner/app". |
The fully-qualified path.
fullpath: function(path, namespace) {
namespace = namespace || {};
if (utils.startsWith(path, "/")) {
return path;
}
// If we don't have an app name (explicitly or implicitly), we default to /services/
if (!namespace.app && !this.app && namespace.sharing !== root.Sharing.SYSTEM) {
return "/services/" + path;
}
// Get the app and owner, first from the passed in namespace, then the service,
// finally defaulting to wild cards
var owner = namespace.owner || this.owner || "-";
var app = namespace.app || this.app || "-";
namespace.sharing = (namespace.sharing || "").toLowerCase();
// Modify the owner and app appropriately based on the sharing parameter
if (namespace.sharing === root.Sharing.APP || namespace.sharing === root.Sharing.GLOBAL) {
owner = "nobody";
}
else if (namespace.sharing === root.Sharing.SYSTEM) {
owner = "nobody";
app = "system";
}
return utils.trim("/servicesNS/" + encodeURIComponent(owner) + "/" + encodeURIComponent(app) + "/" + path);
},Performs a GET request.
| Name | Type | Description |
|---|---|---|
| path | String | The REST endpoint path of the GET request. |
| params | Object | The entity-specific parameters for this request. |
| callback | Function | The function to call when the request is complete: |
get: function(path, params, callback, isAsync) {
var that = this;
if(isAsync) {
return that.http.get(
that.urlify(path),
that._headers(),
params,
that.timeout,
null,
true
);
}
else {
var request = function(callback) {
return that.http.get(
that.urlify(path),
that._headers(),
params,
that.timeout,
callback
);
};
return this._requestWrapper(request, callback);
}
},Constructor for splunkjs.Context.
| Name | Type | Description |
|---|---|---|
| http | splunkjs.Http | An instance of a |
| params | Object | A dictionary of optional parameters: |
A new splunkjs.Context instance.
init: function(http, params) {
if (!(http instanceof Http) && !params) {
// Move over the params
params = http;
http = null;
}
params = params || {};
this.scheme = params.scheme || "https";
this.host = params.host || "localhost";
this.port = params.port || 8089;
this.username = params.username || null;
this.password = params.password || null;
this.owner = params.owner;
this.app = params.app;
this.sessionKey = params.sessionKey || "";
this.authorization = params.authorization || "Splunk";
this.paths = params.paths || Paths;
this.version = params.version || "default";
this.timeout = params.timeout || 0;
this.autologin = true;
// Initialize autologin
// The reason we explicitly check to see if 'autologin'
// is actually set is because we need to distinguish the
// case of it being set to 'false', and it not being set.
// Unfortunately, in JavaScript, these are both false-y
if (params.hasOwnProperty("autologin")) {
this.autologin = params.autologin;
}
if (!http) {
// If there is no HTTP implementation set, we check what platform
// we're running on. If we're running in the browser, then complain,
// else, we instantiate NodeHttp.
if (typeof(window) !== 'undefined') {
throw new Error("Http instance required when creating a Context within a browser.");
}
else {
var NodeHttp = require('./platform/node/node_http').NodeHttp;
http = new NodeHttp();
}
}
// Store the HTTP implementation
this.http = http;
this.http._setSplunkVersion(this.version);
// Store our full prefix, which is just combining together
// the scheme with the host
var versionPrefix = utils.getWithVersion(this.version, prefixMap);
this.prefix = this.scheme + "://" + this.host + ":" + this.port + versionPrefix;
// We perform the bindings so that every function works
// properly when it is passed as a callback.
this._headers = utils.bind(this, this._headers);
this.fullpath = utils.bind(this, this.fullpath);
this.urlify = utils.bind(this, this.urlify);
this.get = utils.bind(this, this.get);
this.del = utils.bind(this, this.del);
this.post = utils.bind(this, this.post);
this.login = utils.bind(this, this.login);
this._shouldAutoLogin = utils.bind(this, this._shouldAutoLogin);
this._requestWrapper = utils.bind(this, this._requestWrapper);
},Authenticates and logs in to a Splunk instance, then stores the resulting session key.
| Name | Type | Description |
|---|---|---|
| callback | Function | The function to call when login has finished: |
login: function(callback) {
var that = this;
var url = this.paths.login;
var params = {
username: this.username,
password: this.password,
cookie : '1'
};
callback = callback || function() {};
var wrappedCallback = function(err, response) {
// Let's make sure that not only did the request succeed, but
// we actually got a non-empty session key back.
var hasSessionKey = !!(!err && response.data && response.data.sessionKey);
if (err || !hasSessionKey) {
callback(err || "No session key available", false);
}
else {
that.sessionKey = response.data.sessionKey;
callback(null, true);
}
};
return this.http.post(
this.urlify(url),
this._headers(),
params,
this.timeout,
wrappedCallback
);
},Logs the session out resulting in the removal of all cookies and the session key.
| Name | Type | Description |
|---|---|---|
| callback | Function | The function to call when logout has finished: |
logout: function(callback) {
callback = callback || function() {};
this.sessionKey = null;
this.http._cookieStore = {};
callback();
},Performs a POST request.
| Name | Type | Description |
|---|---|---|
| path | String | The REST endpoint path of the POST request. |
| params | Object | The entity-specific parameters for this request. |
| callback | Function | The function to call when the request is complete: |
post: function(path, params, callback) {
var that = this;
var request = function(callback) {
return that.http.post(
that.urlify(path),
that._headers(),
params,
that.timeout,
callback
);
};
return this._requestWrapper(request, callback);
},Issues an arbitrary HTTP request to the REST endpoint path segment.
| Name | Type | Description |
|---|---|---|
| path | String | The REST endpoint path segment (with any query parameters already appended and encoded). |
| method | String | The HTTP method (can be |
| query | Object | The entity-specific parameters for this request. |
| post | Object | A dictionary of POST argument that will get form encoded. |
| body | Object | The body of the request, mutually exclusive with |
| headers | Object | Headers for this request. |
| callback | Function | The function to call when the request is complete: |
request: function(path, method, query, post, body, headers, callback) {
var that = this;
var request = function(callback) {
return that.http.request(
that.urlify(path),
{
method: method,
headers: that._headers(headers),
query: query,
post: post,
body: body,
timeout: that.timeout
},
callback
);
};
return this._requestWrapper(request, callback);
},Converts a partial path to a fully-qualified URL.
| Name | Type | Description |
|---|---|---|
| path | String | The partial path. |
The fully-qualified URL.
urlify: function(path) {
return this.prefix + this.fullpath(path);
},Compares the Splunk server's version to the specified version string. Returns -1 if (this.version < otherVersion), 0 if (this.version == otherVersion), 1 if (this.version > otherVersion).
| Name | Type | Description |
|---|---|---|
| otherVersion | String | The other version string, for example "5.0". |
versionCompare: function(otherVersion) {
var thisVersion = this.version;
if (thisVersion === "default") {
thisVersion = "5.0";
}
var components1 = thisVersion.split(".");
var components2 = otherVersion.split(".");
var numComponents = Math.max(components1.length, components2.length);
for (var i = 0; i < numComponents; i++) {
var c1 = (i < components1.length) ? parseInt(components1[i], 10) : 0;
var c2 = (i < components2.length) ? parseInt(components2[i], 10) : 0;
if (c1 < c2) {
return -1;
} else if (c1 > c2) {
return 1;
}
}
return 0;
}
});