splunk-sdk
Version:
SDK for usage with the Splunk REST API
1,757 lines (1,557 loc) • 2.62 MB
JavaScript
(function() {
var __exportName = 'splunkjs';
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
(function (process,Buffer){(function (){
/*!
* commander
* Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
* MIT Licensed
*/
/*!
* Console
*/
var util = require('util');
var fs = require("fs");
/* Monkey patching */
if (!util.format) {
var formatRegExp = /%[sdj%]/g;
util.format = function(f) {
if (typeof f !== 'string') {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(util.inspect(arguments[i]));
}
return objects.join(' ');
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j': return JSON.stringify(args[i++]);
case '%%': return '%';
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (x === null || typeof x !== 'object') {
str += ' ' + x;
} else {
str += ' ' + util.inspect(x);
}
}
return str;
}
}
var consoleFlush = function(data) {
if (!Buffer.isBuffer(data)) {
data= Buffer.from(''+ data);
}
if (data.length) {
var written= 0;
do {
try {
var len = data.length- written;
written += fs.writeSync(process.stdout.fd, data, written, len, -1);
}
catch (e) {
}
} while(written < data.length);
}
};
/**
* Module dependencies.
*/
var EventEmitter = require('events').EventEmitter
, path = require('path')
, tty = require('tty')
, basename = path.basename;
/**
* Expose the root command.
*/
exports = module.exports = new Command;
/**
* Expose `Command`.
*/
exports.Command = Command;
/**
* Expose `Option`.
*/
exports.Option = Option;
/**
* Initialize a new `Option` with the given `flags` and `description`.
*
* @param {String} flags
* @param {String} description
* @api public
*/
function Option(flags, description) {
this.flags = flags;
this.required = ~flags.indexOf('<');
this.optional = ~flags.indexOf('[');
this.bool = !~flags.indexOf('-no-');
flags = flags.split(/[ ,|]+/);
if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();
this.long = flags.shift();
this.description = description;
}
/**
* Return option name.
*
* @return {String}
* @api private
*/
Option.prototype.name = function(){
return this.long
.replace('--', '')
.replace('no-', '');
};
/**
* Check if `arg` matches the short or long flag.
*
* @param {String} arg
* @return {Boolean}
* @api private
*/
Option.prototype.is = function(arg){
return arg == this.short
|| arg == this.long;
};
/**
* Initialize a new `Command`.
*
* @param {String} name
* @api public
*/
function Command(name) {
this.commands = [];
this.options = [];
this.args = [];
this.name = name;
this.opts = {};
}
/**
* Inherit from `EventEmitter.prototype`.
*/
Command.prototype.__proto__ = EventEmitter.prototype;
/**
* Add command `name`.
*
* The `.action()` callback is invoked when the
* command `name` is specified via __ARGV__,
* and the remaining arguments are applied to the
* function for access.
*
* When the `name` is "*" an un-matched command
* will be passed as the first arg, followed by
* the rest of __ARGV__ remaining.
*
* Examples:
*
* program
* .version('0.0.1')
* .option('-C, --chdir <path>', 'change the working directory')
* .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
* .option('-T, --no-tests', 'ignore test hook')
*
* program
* .command('setup')
* .description('run remote setup commands')
* .action(function(){
* console.log('setup');
* });
*
* program
* .command('exec <cmd>')
* .description('run the given remote command')
* .action(function(cmd){
* console.log('exec "%s"', cmd);
* });
*
* program
* .command('*')
* .description('deploy the given env')
* .action(function(env){
* console.log('deploying "%s"', env);
* });
*
* program.parse(process.argv);
*
* @param {String} name
* @return {Command} the new command
* @api public
*/
Command.prototype.command = function(name){
var args = name.split(/ +/);
var cmd = new Command(args.shift());
this.commands.push(cmd);
cmd.parseExpectedArgs(args);
cmd.parent = this;
return cmd;
};
/**
* Parse expected `args`.
*
* For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
*
* @param {Array} args
* @return {Command} for chaining
* @api public
*/
Command.prototype.parseExpectedArgs = function(args){
if (!args.length) return;
var self = this;
args.forEach(function(arg){
switch (arg[0]) {
case '<':
self.args.push({ required: true, name: arg.slice(1, -1) });
break;
case '[':
self.args.push({ required: false, name: arg.slice(1, -1) });
break;
}
});
return this;
};
/**
* Register callback `fn` for the command.
*
* Examples:
*
* program
* .command('help')
* .description('display verbose help')
* .action(function(){
* // output help here
* });
*
* @param {Function} fn
* @return {Command} for chaining
* @api public
*/
Command.prototype.action = function(fn){
var self = this;
this.parent.on(this.name, function(args, unknown){
args = args.slice();
// Parse any so-far unknown options
unknown = unknown || [];
var parsed = self.parseOptions(unknown);
// Output help if necessary
outputHelpIfNecessary(self, parsed.unknown);
// If there are still any unknown options, then we simply
// die, unless someone asked for help, in which case we give it
// to them, and then we die.
if (parsed.unknown.length > 0) {
self.unknownOption(parsed.unknown[0]);
}
// If we were expecting a required option and we missed it,
// error out
self.options.forEach(function(option, i) {
var oname = option.name();
var name = camelcase(oname);
if (option.isPresenceRequired && self[name] === undefined && !parsed.required[oname]) {
self.optionMissing(option);
}
});
self.args.forEach(function(arg, i){
if (arg.required && null == args[i]) {
self.missingArgument(arg.name);
}
});
// Always append ourselves to the end of the arguments,
// to make sure we match the number of arguments the user
// expects
// If we have expected arguments and we have at most the number of
// expected arguments, then add it to the end. If not, push us
// at the end (for the case of varargs).
if (self.args.length && (args.length <= self.args.length - 1)) {
args[self.args.length] = self;
} else {
args.push(self);
}
fn.apply(this, args);
});
return this;
};
/**
* Define option with `flags`, `description` and optional
* coercion `fn`.
*
* The `flags` string should contain both the short and long flags,
* separated by comma, a pipe or space. The following are all valid
* all will output this way when `--help` is used.
*
* "-p, --pepper"
* "-p|--pepper"
* "-p --pepper"
*
* Examples:
*
* // simple boolean defaulting to false
* program.option('-p, --pepper', 'add pepper');
*
* --pepper
* program.pepper
* // => Boolean
*
* // simple boolean defaulting to false
* program.option('-C, --no-cheese', 'remove cheese');
*
* program.cheese
* // => true
*
* --no-cheese
* program.cheese
* // => true
*
* // required argument
* program.option('-C, --chdir <path>', 'change the working directory');
*
* --chdir /tmp
* program.chdir
* // => "/tmp"
*
* // optional argument
* program.option('-c, --cheese [type]', 'add cheese [marble]');
*
* @param {String} flags
* @param {String} description
* @param {Function|Mixed} fn or default
* @param {Mixed} defaultValue
* @return {Command} for chaining
* @api public
*/
Command.prototype.option = function(flags, description, fn, defaultValue, isRequired){
var self = this
, option = new Option(flags, description)
, oname = option.name()
, name = camelcase(oname);
// default as 3rd arg
if ('function' != typeof fn) isRequired = defaultValue, defaultValue = fn, fn = null;
// preassign default value only for --no-*, [optional], or <required>
if (false == option.bool || option.optional || option.required) {
// when --no-* we make sure default is true
if (false == option.bool) defaultValue = true;
// preassign only if we have a default
if (undefined !== defaultValue) self[name] = defaultValue;
}
option.isPresenceRequired = isRequired;
// register the option
this.options.push(option);
// when it's passed assign the value
// and conditionally invoke the callback
this.on(oname, function(val){
// coercion
if (null != val && fn) val = fn(val);
// unassigned or bool
if ('boolean' == typeof self[name] || 'undefined' == typeof self[name]) {
// if no value, bool true, and we have a default, then use it!
if (null == val) {
self[name] = self.opts[name] = option.bool
? defaultValue || true
: false;
} else {
self[name] = self.opts[name] = val;
}
} else if (null !== val) {
// reassign
self[name] = self.opts[name] = val;
}
});
return this;
};
/**
* Parse `argv`, settings options and invoking commands when defined.
*
* @param {Array} argv
* @return {Command} for chaining
* @api public
*/
Command.prototype.parse = function(argv){
// store raw args
this.rawArgs = argv;
// guess name
if (!this.name) this.name = basename(argv[1]);
// process argv
var parsed = this.parseOptions(this.normalize(argv.slice(2)));
this.args = parsed.args;
return this.parseArgs(this.args, parsed.unknown, parsed.required);
};
/**
* Normalize `args`, splitting joined short flags. For example
* the arg "-abc" is equivalent to "-a -b -c".
*
* @param {Array} args
* @return {Array}
* @api private
*/
Command.prototype.normalize = function(args){
var ret = []
, arg;
for (var i = 0, len = args.length; i < len; ++i) {
arg = args[i];
if (arg.length > 1 && '-' == arg[0] && '-' != arg[1]) {
arg.slice(1).split('').forEach(function(c){
ret.push('-' + c);
});
} else {
ret.push(arg);
}
}
return ret;
};
/**
* Parse command `args`.
*
* When listener(s) are available those
* callbacks are invoked, otherwise the "*"
* event is emitted and those actions are invoked.
*
* @param {Array} args
* @return {Command} for chaining
* @api private
*/
Command.prototype.parseArgs = function(args, unknown, required){
var cmds = this.commands
, len = cmds.length
, self = this
, name;
if (args.length) {
name = args[0];
if (this.listeners(name).length) {
var commandName = args.shift();
this.executedCommand = commandName;
this.emit(commandName, args, unknown);
} else {
this.executedCommand = "*";
this.emit('*', args);
}
} else {
outputHelpIfNecessary(this, unknown);
// If there were no args and we have unknown options,
// then they are extraneous and we need to error.
if (unknown.length > 0) {
this.unknownOption(unknown[0]);
}
// If we were expecting a required option and we missed it,
// error out
this.options.forEach(function(option, i) {
var oname = option.name();
var name = camelcase(oname);
if (option.isPresenceRequired && self[name] === undefined && !required[oname]) {
self.optionMissing(option);
}
});
}
return this;
};
/**
* Return an option matching `arg` if any.
*
* @param {String} arg
* @return {Option}
* @api private
*/
Command.prototype.optionFor = function(arg){
for (var i = 0, len = this.options.length; i < len; ++i) {
if (this.options[i].is(arg)) {
return this.options[i];
}
}
};
/**
* Parse options from `argv` returning `argv`
* void of these options.
*
* @param {Array} argv
* @return {Array}
* @api public
*/
Command.prototype.parseOptions = function(argv){
var args = []
, len = argv.length
, literal
, option
, arg;
var unknownOptions = [];
var required = {};
// parse options
for (var i = 0; i < len; ++i) {
arg = argv[i];
// literal args after --
if ('--' == arg) {
literal = true;
continue;
}
if (literal) {
args.push(arg);
continue;
}
// find matching Option
option = this.optionFor(arg);
// option is defined
if (option) {
if (option.isPresenceRequired) {
required[option.name()] = true;
}
// requires arg
if (option.required) {
arg = argv[++i];
if (null == arg) return this.optionMissingArgument(option);
if ('-' == arg[0]) return this.optionMissingArgument(option, arg);
this.emit(option.name(), arg);
// optional arg
} else if (option.optional) {
arg = argv[i+1];
if (null == arg || '-' == arg[0]) {
arg = null;
} else {
++i;
}
this.emit(option.name(), arg);
// bool
} else {
this.emit(option.name());
}
continue;
}
// looks like an option
if (arg.length > 1 && '-' == arg[0]) {
unknownOptions.push(arg);
// If the next argument looks like it might be
// an argument for this option, we pass it on.
// If it isn't, then it'll simply be ignored
if (argv[i+1] && '-' != argv[i+1][0]) {
unknownOptions.push(argv[++i]);
}
continue;
}
// arg
args.push(arg);
}
return { args: args, unknown: unknownOptions, required: required };
};
/**
* Argument `name` is missing.
*
* @param {String} name
* @api private
*/
Command.prototype.missingArgument = function(name){
console.error();
console.error(" error: missing required argument `%s'", name);
console.error();
process.exit(1);
};
/**
* `Option` is missing an argument, but received `flag` or nothing.
*
* @param {String} option
* @param {String} flag
* @api private
*/
Command.prototype.optionMissingArgument = function(option, flag){
console.error();
if (flag) {
console.error(" error: option `%s' argument missing, got `%s'", option.flags, flag);
} else {
console.error(" error: option `%s' argument missing", option.flags);
}
console.error();
process.exit(1);
};
/**
* `Option` is missing.
*
* @param {String} option
* @param {String} flag
* @api private
*/
Command.prototype.optionMissing = function(option){
console.error();
console.error(" error: option `%s' is missing", option.name());
console.error();
process.exit(1);
};
/**
* Unknown option `flag`.
*
* @param {String} flag
* @api private
*/
Command.prototype.unknownOption = function(flag){
console.error();
console.error(" error: unknown option `%s'", flag);
console.error();
process.exit(1);
};
/**
* Set the program version to `str`.
*
* This method auto-registers the "-V, --version" flag
* which will print the version number when passed.
*
* @param {String} str
* @param {String} flags
* @return {Command} for chaining
* @api public
*/
Command.prototype.version = function(str, flags){
if (0 == arguments.length) return this._version;
this._version = str;
flags = flags || '-V, --version';
this.option(flags, 'output the version number');
this.on('version', function(){
console.log(str);
process.exit(0);
});
return this;
};
/**
* Set the description `str`.
*
* @param {String} str
* @return {String|Command}
* @api public
*/
Command.prototype.description = function(str){
if (0 == arguments.length) return this._description;
this._description = str;
return this;
};
/**
* Set / get the command usage `str`.
*
* @param {String} str
* @return {String|Command}
* @api public
*/
Command.prototype.usage = function(str){
var args = this.args.map(function(arg){
return arg.required
? '<' + arg.name + '>'
: '[' + arg.name + ']';
});
var usage = '[options'
+ (this.commands.length ? '] [command' : '')
+ ']'
+ (this.args.length ? ' ' + args : '');
if (0 == arguments.length) return this._usage || usage;
this._usage = str;
return this;
};
/**
* Return the largest option length.
*
* @return {Number}
* @api private
*/
Command.prototype.largestOptionLength = function(){
return this.options.reduce(function(max, option){
return Math.max(max, option.flags.length);
}, 0);
};
/**
* Return help for options.
*
* @return {String}
* @api private
*/
Command.prototype.optionHelp = function(){
var width = this.largestOptionLength();
// Prepend the help information
return [pad('-h, --help', width) + ' ' + 'output usage information']
.concat(this.options.map(function(option){
return pad(option.flags, width)
+ ' ' + option.description;
}))
.join('\n');
};
/**
* Return command help documentation.
*
* @return {String}
* @api private
*/
Command.prototype.commandHelp = function(){
if (!this.commands.length) return '';
return [
''
, ' Commands:'
, ''
, this.commands.map(function(cmd){
var args = cmd.args.map(function(arg){
return arg.required
? '<' + arg.name + '>'
: '[' + arg.name + ']';
}).join(' ');
return cmd.name
+ (cmd.options.length
? ' [options]'
: '') + ' ' + args
+ (cmd.description()
? '\n' + cmd.description()
: '');
}).join('\n\n').replace(/^/gm, ' ')
, ''
].join('\n');
};
/**
* Return program help documentation.
*
* @return {String}
* @api private
*/
Command.prototype.helpInformation = function(){
return [
''
, ' Usage: ' + this.name + ' ' + this.usage()
, '' + this.commandHelp()
, ' Options:'
, ''
, '' + this.optionHelp().replace(/^/gm, ' ')
, ''
, ''
].join('\n');
};
/**
* Prompt for a `Number`.
*
* @param {String} str
* @param {Function} fn
* @api private
*/
Command.prototype.promptForNumber = function(str, fn){
var self = this;
this.promptSingleLine(str, function parseNumber(val){
val = Number(val);
if (isNaN(val)) return self.promptSingleLine(str + '(must be a number) ', parseNumber);
fn(val);
});
};
/**
* Prompt for a `Date`.
*
* @param {String} str
* @param {Function} fn
* @api private
*/
Command.prototype.promptForDate = function(str, fn){
var self = this;
this.promptSingleLine(str, function parseDate(val){
val = new Date(val);
if (isNaN(val.getTime())) return self.promptSingleLine(str + '(must be a date) ', parseDate);
fn(val);
});
};
/**
* Single-line prompt.
*
* @param {String} str
* @param {Function} fn
* @api private
*/
Command.prototype.promptSingleLine = function(str, fn){
if ('function' == typeof arguments[2]) {
return this['promptFor' + (fn.name || fn)](str, arguments[2]);
}
process.stdout.write(str);
process.stdin.setEncoding('utf8');
process.stdin.once('data', function(val){
fn(val.trim());
}).resume();
};
/**
* Multi-line prompt.
*
* @param {String} str
* @param {Function} fn
* @api private
*/
Command.prototype.promptMultiLine = function(str, fn){
var buf = [];
console.log(str);
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(val){
if ('\n' == val || '\r\n' == val) {
process.stdin.removeAllListeners('data');
fn(buf.join('\n'));
} else {
buf.push(val.trimRight());
}
}).resume();
};
/**
* Prompt `str` and callback `fn(val)`
*
* Commander supports single-line and multi-line prompts.
* To issue a single-line prompt simply add white-space
* to the end of `str`, something like "name: ", whereas
* for a multi-line prompt omit this "description:".
*
*
* Examples:
*
* program.prompt('Username: ', function(name){
* console.log('hi %s', name);
* });
*
* program.prompt('Description:', function(desc){
* console.log('description was "%s"', desc.trim());
* });
*
* @param {String} str
* @param {Function} fn
* @api public
*/
Command.prototype.prompt = function(str, fn){
if (/ $/.test(str)) return this.promptSingleLine.apply(this, arguments);
this.promptMultiLine(str, fn);
};
/**
* Prompt for password with `str`, `mask` char and callback `fn(val)`.
*
* The mask string defaults to '', aka no output is
* written while typing, you may want to use "*" etc.
*
* Examples:
*
* program.password('Password: ', function(pass){
* console.log('got "%s"', pass);
* process.stdin.destroy();
* });
*
* program.password('Password: ', '*', function(pass){
* console.log('got "%s"', pass);
* process.stdin.destroy();
* });
*
* @param {String} str
* @param {String} mask
* @param {Function} fn
* @api public
*/
Command.prototype.password = function(str, mask, fn){
var self = this
, buf = '';
// default mask
if ('function' == typeof mask) {
fn = mask;
mask = '';
}
tty.setRawMode(true);
process.stdout.write(str);
// keypress
process.stdin.on('keypress', function(c, key){
if (key && 'enter' == key.name) {
console.log();
process.stdin.removeAllListeners('keypress');
tty.setRawMode(false);
if (!buf.trim().length) return self.password(str, mask, fn);
fn(buf);
return;
}
if (key && key.ctrl && 'c' == key.name) {
console.log('%s', buf);
process.exit();
}
process.stdout.write(mask);
buf += c;
}).resume();
};
/**
* Confirmation prompt with `str` and callback `fn(bool)`
*
* Examples:
*
* program.confirm('continue? ', function(ok){
* console.log(' got %j', ok);
* process.stdin.destroy();
* });
*
* @param {String} str
* @param {Function} fn
* @api public
*/
Command.prototype.confirm = function(str, fn){
var self = this;
this.prompt(str, function(ok){
if (!ok.trim()) {
return self.confirm(str, fn);
}
fn(parseBool(ok));
});
};
/**
* Choice prompt with `list` of items and callback `fn(index, item)`
*
* Examples:
*
* var list = ['tobi', 'loki', 'jane', 'manny', 'luna'];
*
* console.log('Choose the coolest pet:');
* program.choose(list, function(i){
* console.log('you chose %d "%s"', i, list[i]);
* process.stdin.destroy();
* });
*
* @param {Array} list
* @param {Function} fn
* @api public
*/
Command.prototype.choose = function(list, fn){
var self = this;
list.forEach(function(item, i){
console.log(' %d) %s', i + 1, item);
});
function again() {
self.prompt(' : ', function(val){
val = parseInt(val, 10) - 1;
if (null == list[val]) {
again();
} else {
fn(val, list[val]);
}
});
}
again();
};
/**
* Camel-case the given `flag`
*
* @param {String} flag
* @return {String}
* @api private
*/
function camelcase(flag) {
return flag.split('-').reduce(function(str, word){
return str + word[0].toUpperCase() + word.slice(1);
});
}
/**
* Parse a boolean `str`.
*
* @param {String} str
* @return {Boolean}
* @api private
*/
function parseBool(str) {
return /^y|yes|ok|true$/i.test(str);
}
/**
* Pad `str` to `width`.
*
* @param {String} str
* @param {Number} width
* @return {String}
* @api private
*/
function pad(str, width) {
var len = Math.max(0, width - str.length);
return str + Array(len + 1).join(' ');
}
/**
* Output help information if necessary
*
* @param {Command} command to output help for
* @param {Array} array of options to search for -h or --help
* @api private
*/
function outputHelpIfNecessary(cmd, options) {
options = options || [];
for (var i = 0; i < options.length; i++) {
if (options[i] == '--help' || options[i] == '-h') {
process.on('exit', function() {
consoleFlush(cmd.helpInformation());
cmd.emit('--help');
consoleFlush("");
});
process.exit();
}
return true;
}
}
}).call(this)}).call(this,require('_process'),require("buffer").Buffer)
},{"_process":242,"buffer":70,"events":147,"fs":68,"path":234,"tty":288,"util":295}],2:[function(require,module,exports){
(function (process){(function (){
// Copyright 2011 Splunk, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
(function() {
var root = exports || this;
var env = require("dotenv").config();
// Declare a process environment so that we can set
// some globals here and have interop with node
try {
process.env = process.env || {};
} catch (e) {
// Depending on the browser implementation process.env may not
// be assignable but still accessible, ignore these errors
}
module.exports = root = {
Logger : require('./lib/log').Logger,
Context : require('./lib/context'),
Service : require('./lib/service'),
Http : require('./lib/http'),
Utils : require('./lib/utils'),
Paths : require('./lib/paths').Paths,
Class : require('./lib/jquery.class').Class
};
if (typeof(window) === 'undefined') {
root.NodeHttp = require('./lib/platform/node/node_http').NodeHttp;
} else {
let jqueryHttp = require('./lib/platform/client/jquery_http').JQueryHttp;
let proxyHttps = require('./lib/platform/client/proxy_http');
root.ProxyHttp = proxyHttps.ProxyHttp;
root.JQueryHttp = jqueryHttp;
root.SplunkWebHttp = proxyHttps.SplunkWebHttp;
}
})();
}).call(this)}).call(this,require('_process'))
},{"./lib/context":3,"./lib/http":5,"./lib/jquery.class":6,"./lib/log":7,"./lib/paths":8,"./lib/platform/client/jquery_http":9,"./lib/platform/client/proxy_http":10,"./lib/platform/node/node_http":11,"./lib/service":12,"./lib/utils":13,"_process":242,"dotenv":128}],3:[function(require,module,exports){
/*!*/
// Copyright 2012 Splunk, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
(function() {
"use strict";
var Paths = require('./paths').Paths;
var Class = require('./jquery.class').Class;
var Http = require('./http');
var utils = require('./utils');
var root = exports || this;
var prefixMap = {
"5": "",
"4.3": "/services/json/v2",
"default": ""
};
/**
* An abstraction over the Splunk HTTP-wire protocol that provides the basic
* functionality for communicating with a Splunk instance over HTTP, handles
* authentication and authorization, and formats HTTP requests (GET, POST,
* and DELETE) in the format that Splunk expects.
*
* @class splunkjs.Context
*/
module.exports = root = Class.extend({
/**
* Constructor for `splunkjs.Context`.
*
* @constructor
* @param {splunkjs.Http} http An instance of a `splunkjs.Http` class.
* @param {Object} params A dictionary of optional parameters:
* - `scheme` (_string_): The scheme ("http" or "https") for accessing Splunk.
* - `host` (_string_): The host name (the default is "localhost").
* - `port` (_integer_): The port number (the default is 8089).
* - `username` (_string_): The Splunk account username, which is used to authenticate the Splunk instance.
* - `password` (_string_): The password, which is used to authenticate the Splunk instance.
* - `owner` (_string_): The owner (username) component of the namespace.
* - `app` (_string_): The app component of the namespace.
* - `sessionKey` (_string_): The current session token.
* - `autologin` (_boolean_): `true` to automatically try to log in again if the session terminates, `false` if not (`true` by default).
* - 'timeout' (_integer): The connection timeout in milliseconds. ('0' by default).
* - `version` (_string_): The version string for Splunk, for example "4.3.2" (the default is "5.0").
* @return {splunkjs.Context} A new `splunkjs.Context` instance.
*
* @method splunkjs.Context
*/
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;
this.instanceType = "";
// 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 {
let 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
let 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
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);
this.getInfo = utils.bind(this, this.getInfo);
this.disableV2SearchApi = utils.bind(this, this.disableV2SearchApi);
},
/**
* Appends Splunk-specific headers.
*
* @param {Object} headers A dictionary of headers (optional).
* @return {Object} An augmented dictionary of headers.
*
* @method splunkjs.Context
* @private
*/
_headers: function (headers) {
headers = headers || {};
if (this.sessionKey) {
headers["Authorization"] = this.authorization + " " + this.sessionKey;
}
return headers;
},
/*!*/
_shouldAutoLogin: function() {
return this.username && this.password && this.autologin;
},
/*!*/
/**
* This internal function aids with the autologin feature.
* It takes one parameters: `task`, which is a function describing an
* HTTP request.
*
* @param {Function} task A function with no arguments which returns a promise.
*/
_requestWrapper:function (task){
var that = this;
if (!this._shouldAutoLogin() || this.sessionKey) {
// Since we are not auto-logging in, just execute our task,
// but intercept any 401s so we can login then
return task().then((res)=>{
return res;
})
.catch((err)=>{
if(err && err.status===401 && that._shouldAutoLogin()){
that.sessionKey = null;
return that.login().then((response)=>{
return task();
}).catch((error)=>{
throw error;
});
}
throw err;
});
}
return this.login()
.then((res)=>{
return task();
})
.catch((err)=>{
throw err;
});
},
/**
* Converts a partial path to a fully-qualified path to a REST endpoint,
* and if necessary includes the namespace owner and app.
*
* @param {String} path The partial path.
* @param {String} namespace The namespace, in the format "_owner_/_app_".
* @return {String} The fully-qualified path.
*
* @method splunkjs.Context
*/
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
let owner = namespace.owner || this.owner || "-";
let 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);
},
/**
* Converts a partial path to a fully-qualified URL.
*
* @param {String} path The partial path.
* @return {String} The fully-qualified URL.
*
* @method splunkjs.Context
* @private
*/
urlify: function(path) {
return this.prefix + this.fullpath(path);
},
/**
* Get Splunk version during login phase.
*
* @param {Number} response_timeout A timeout period for aborting a request in milisecs (0 means no timeout).
*
* @method splunkjs.Context
* @private
*/
getInfo: function (response_timeout) {
var that = this;
let url = this.paths.info;
return this.http.get(
this.urlify(url),
this._headers(),
"",
this.timeout,
response_timeout
).then((response)=>{
let hasVersion = !!(response.data && response.data.generator.version);
let hasInstanceType = !!(response.data && response.data.generator["instance_type"]);
if (!hasVersion) {
return Promise.reject("No version found");
}
else{
that.instanceType = hasInstanceType ? response.data.generator["instance_type"] : "";
that.version = response.data.generator.version;
that.http.version = that.version;
return Promise.resolve(true);
}
});
},
/**
* Authenticates and logs in to a Splunk instance, then stores the
* resulting session key.
*
* @param {Number} response_timeout A timeout period for aborting a request in milisecs (0 means no timeout).
*
* @method splunkjs.Context
* @private
*/
login: function(response_timeout) {
var that = this;
let url = this.paths.login;
let params = {
username: this.username,
password: this.password,
cookie : '1'
};
return this.http.post(
this.urlify(url),
this._headers(),
params,
this.timeout,
response_timeout
).then((response)=>{
let hasSessionKey = !!(response.data && response.data.sessionKey);
if (!hasSessionKey) {
return Promise.reject("No session key available");
}
else {
that.sessionKey = response.data.sessionKey;
return that.getInfo();
}
})
},
/**
* Logs the session out resulting in the removal of all cookies and the
* session key.
*
* @method splunkjs.Context
* @private
*/
logout: function() {
this.sessionKey = null;
this.http._cookieStore = {};
},
/**
* Performs a GET request.
*
* @param {String} path The REST endpoint path of the GET request.
* @param {Object} params The entity-specific parameters for this request.
* @param {Number} response_timeout A timeout period for aborting a request in milisecs (0 means no timeout).
*
* @method splunkjs.Context
*/
get: function(path, params, response_timeout, isAsync) {
var that = this;
if(isAsync) {
return that.http.get(
that.urlify(path),
that._headers(),
params,
that.timeout,
response_timeout,
true
);
}
else {
let request = function() {
return that.http.get(
that.urlify(path),
that._headers(),
params,
that.timeout,
response_timeout
);
};
return this._requestWrapper(request);
}
},
/**
* Performs a DELETE request.
*
* @param {String} path The REST endpoint path of the DELETE request.
* @param {Object} params The entity-specific parameters for this request.
* @param {Number} response_timeout A timeout period for aborting a request in milisecs (0 means no timeout).
* @method splunkjs.Context
*/
del: function(path, params,response_timeout) {
var that = this;
let request = function() {
return that.http.del(
that.urlify(path),
that._headers(),
params,
that.timeout,
response_timeout
);
};
return this._requestWrapper(request);
},
/**
* Performs a POST request.
*
* @param {String} path The REST endpoint path of the POST request.
* @param {Object} params The entity-specific parameters for this request.
* @param {Number} response_timeout A timeout period for aborting a request in milisecs (0 means no timeout).
* @method splunkjs.Context
*/
post: function(path, params, response_timeout) {
var that = this;
let request = function() {
return that.http.post(
that.urlify(path),
that._headers(),
params,
that.timeout,
response_timeout
);
};
return this._requestWrapper(request);
},
/**
* Issues an arbitrary HTTP request to the REST endpoint path segment.
*
* @param {String} path The REST endpoint path segment (with any query parameters already appended and encoded).
* @param {String} method The HTTP method (can be `GET`, `POST`, or `DELETE`).
* @param {Object} query The entity-specific parameters for this request.
* @param {Object} post A dictionary of POST argument that will get form encoded.
* @param {Object} body The body of the request, mutually exclusive with `post`.
* @param {Object} headers Headers for this request.
* @param {Number} response_timeout A timeout period for aborting a request in milisecs (0 means no timeout).
*
* @method splunkjs.Context
*/
request: function(path, method, query, post, body, headers,response_timeout) {
var that = this;
let request = function() {
return that.http.request(
that.urlify(path),
{
method: method,
headers: that._headers(headers),
query: query,
post: post,
body: body,
timeout: that.timeout
}
,response_timeout);
};
return this._requestWrapper(request);
},
/**
* 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).
*
* @param {String} otherVersion The other version string, for example "5.0".
*
* @method splunkjs.Context
*/
versionCompare: function (otherVersion) {
let thisVersion = this.version;
if (thisVersion === "default") {
thisVersion = "5.0";
}
let components1 = thisVersion.split(".");
let components2 = otherVersion.split(".");
let numComponents = Math.max(components1.length, components2.length);
for (let i = 0; i < numComponents; i++) {
let c1 = (i < components1.length) ? parseInt(components1[i], 10) : 0;
let c2 = (i < components2.length) ? parseInt(components2[i], 10) : 0;
if (c1 < c2) {
return -1;
} else if (c1 > c2) {
return 1;
}
}
return 0;
},
disableV2SearchApi: function(){
let val;
if(this.instanceType.toLowerCase() == "cloud"){
val = this.versionCompare("9.0.2209");
}else{
val = this.versionCompare("9.0.2")
}
return val < 0;
}
});
/*!*/
root.Sharing = {
USER: "user",
APP: "app",
GLOBAL: "global",
SYSTEM: "system"
};
})();
},{"./http":5,"./jquery.class":6,"./paths":8,"./platform/node/node_http":11,"./utils":13}],4:[function(require,module,exports){
// Copyright 2011 Splunk, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
// This file is the entry point for client-side code, so it "exports" the
// important functionality to the "window", such that others can easily
// include it.
window.SplunkTest = {
Utils : require('../../tests/test_utils'),
Http : require('../../tests/test_http'),
Context : require('../../tests/test_context'),
Service : require('../../tests/test_service')
};
},{"../../tests/test_context":319,"../../tests/test_http":320,"../../tests/test_service":321,"../../tests/test_utils":322}],5:[function(require,module,exports){
/*!*/
// Copyright 2012 Splunk, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
(function() {
"use strict";
var Class = require('./jquery.class').Class;
var logger = require('./log').Logger;
var utils = require('./utils');
var CookieHandler = require('cookie');
var root = exports || this;
var Http = null;
var queryBuilderMap = {
"5": function(message) {
var query = message.query || {};
var post = message.post || {};
var outputMode = query.output_mode || post.output_mode || "json";
query.output_mode = outputMode;
return query;
},
"4": function(message) {
return message.query || {};
},
"default": function(message) {
return queryBuilderMap["5"](message);
},
"none": function(message) {
return message.query || {};
}
};
/**
* A base class for HTTP abstraction that provides the basic functionality
* for performing GET, POST, DELETE, and REQUEST operations, and provides
* utilities to construct uniform responses.
*
* Base classes should only override `makeRequest` and `parseJSON`.
*
* @class splunkjs.Http
*/
module.exports = root = Http = Class.extend({
/**
* Constructor for `splunkjs.Http`.
*
* @constructor
* @return {splunkjs.Http} A new `splunkjs.Http` instance.
*
* @method splunkjs.Http
*/
init: function() {
// We perform the bindings so that ever