def test_is_true(monkeypatch):
for val in ("1", "TRUE", "T", "Y", "YES"):
assert utils.is_true(val)
for val in ("0", "FALSE", "F", "N", "NO", "NONE", "", None):
assert not utils.is_true(val)
for val in ("00", "FF", "NN", "NONO", "434324"):
assert not utils.is_true(val)
def _parse_field(self, content):
field = RestField(
content["field"],
required=is_true(content.get("required")),
encrypted=is_true(content.get("encrypted")),
default=content.get("defaultValue"),
)
return RestFieldBuilder(
field, self._parse_validation(content.get("validators")),
)
def _parse_field(self, content):
field = RestField(
content['field'],
required=is_true(content.get('required')),
encrypted=is_true(content.get('encrypted')),
default=content.get('defaultValue'),
)
return RestFieldBuilder(
field,
self._parse_validation(content.get('validators')),
)
def getProxyDetails(self):
# Create confmanger object for the app with realm
cfm = conf_manager.ConfManager(self.getSessionKey(
), "TA-lansweeper-add-on-for-splunk", realm="__REST_CREDENTIAL__#TA-lansweeper-add-on-for-splunk#configs/conf-ta_lansweeper_add_on_for_splunk_settings")
# Get Conf object of apps settings
conf = cfm.get_conf('ta_lansweeper_add_on_for_splunk_settings')
# Get proxy stanza from the settings
proxy_config = conf.get("proxy", True)
if not proxy_config or not is_true(proxy_config.get('proxy_enabled')):
logger.info('Proxy is not enabled')
return None
url = proxy_config.get('proxy_url')
port = proxy_config.get('proxy_port')
if url or port:
if not url:
raise ValueError('Proxy "url" must not be empty')
if not self.is_valid_port(port):
raise ValueError(
'Proxy "port" must be in range [1,65535]: %s' % port
)
user = proxy_config.get('proxy_username')
password = proxy_config.get('proxy_password')
if not all((user, password)):
logger.info('Proxy has no credentials found')
user, password = None, None
proxy_type = proxy_config.get('proxy_type')
proxy_type = proxy_type.lower() if proxy_type else 'http'
if proxy_type in _PROXY_TYPE_MAP:
ptv = _PROXY_TYPE_MAP[proxy_type]
elif proxy_type in _PROXY_TYPE_MAP.values():
ptv = proxy_type
else:
ptv = socks.PROXY_TYPE_HTTP
logger.info('Proxy type not found, set to "HTTP"')
rdns = is_true(proxy_config.get('proxy_rdns'))
proxy_info = ProxyInfo(
proxy_host=url,
proxy_port=int(port),
proxy_type=ptv,
proxy_user=user,
proxy_pass=password,
proxy_rdns=rdns
)
# logger.info(proxy_info)
return proxy_info
def is_captain_ready(self) -> bool:
"""Check if captain is ready.
Client usually first polls this function until captain is ready
and then call is_captain to detect current captain machine
Returns:
True if captain is ready else False.
Examples:
>>> from solnlib import server_info
>>> serverinfo = server_info.ServerInfo(session_key)
>>> while 1:
>>> if serverinfo.is_captain_ready():
>>> break
>>> time.sleep(2)
>>>
>>> # If do_stuff can only be executed in SH captain
>>> if serverinfo.is_captain():
>>> do_stuff()
"""
cap_info = self.captain_info()
return utils.is_true(
cap_info["service_ready_flag"]) and utils.is_false(
cap_info["maintenance_mode"])
def _parse_input_args_from_env(self, inputs):
"""Parse input arguments from os environment. This is used for testing inputs.
:param inputs:
"""
data_inputs_options = json.loads(os.environ.get(DATA_INPUTS_OPTIONS, '[]'))
account_fields = self.get_account_fields()
checkbox_fields = self.get_checkbox_fields()
self.input_stanzas = {}
while len(inputs.inputs) > 0:
input_stanza, stanza_args = inputs.inputs.popitem()
kind_and_name = input_stanza.split("://")
if len(kind_and_name) == 2:
stanza_params = {}
for arg_name, arg_value in stanza_args.iteritems():
try:
arg_value_trans = json.loads(arg_value)
except ValueError:
arg_value_trans = arg_value
stanza_params[arg_name] = arg_value_trans
if arg_name in account_fields:
stanza_params[arg_name] = self.get_user_credential_by_id(arg_value_trans)
elif arg_name in checkbox_fields:
stanza_params[arg_name] = sutils.is_true(arg_value_trans)
self.input_stanzas[kind_and_name[1]] = stanza_params
def is_captain_ready(self):
'''Check if captain is ready.
Client usually first polls this function until captain is ready
and then call is_captain to detect current captain machine
:returns: True/False
:rtype: ``bool``
Usage::
>>> serverinfo = solnlib.server_info.ServerInfo(session_key)
>>> while 1:
>>> if serverinfo.is_captain_ready():
>>> break
>>> time.sleep(2)
>>>
>>> # If do_stuff can only be executed in SH captain
>>> if serverinfo.is_captain():
>>> do_stuff()
'''
cap_info = self.captain_info()
return utils.is_true(cap_info["service_ready_flag"]) and \
utils.is_false(cap_info["maintenance_mode"])
def list_existing_solutions(service):
solutions = list()
candidate_list = []
for app in service.apps:
if app.name in APP_BLACK_LIST:
continue
if sutils.is_true(app.disabled):
continue
if not os.path.isdir(os.path.join(app_path, app.name)):
# filter out the app whose dir does not exist.
# when a TA is deleted without restarting splunk, we will get inconsistent data
continue
candidate_list.append(app)
for app in candidate_list:
solutions.append({
'name':
app.content['label'],
'id':
app.name,
'author':
app.content['author'] if app.content.get('author') else '',
'version':
app.content['version'] if app.content.get('version') else '',
'icon':
get_icon_from_name(service, app.name),
'visible':
common_util.is_true(app.content['visible'])
if 'visible' in app.content else False,
'last_modified':
get_app_modify_time(app.name)
})
return solutions
def _parse_conf_from_global_config(self, key):
if self.__cached_global_settings and key in self.__cached_global_settings:
return self.__cached_global_settings.get(key)
self.init_global_config()
if self.__global_config is None:
return None
if key in CONFIGS:
accounts = self.__global_config.configs.load().get(
UCC_CREDENTIAL, [])
if accounts:
for account in accounts:
if 'disabled' in account:
del account['disabled']
self.__cached_global_settings[CREDENTIAL_SETTINGS] = accounts
elif key in SETTINGS:
settings = self.__global_config.settings.load()
self.__cached_global_settings.update({
UCC_PROXY: None,
UCC_LOGGING: None,
UCC_CUSTOMIZED: None
})
customized_setting = {}
for setting in settings.get('settings', []):
# filter out disabled setting page and 'disabled' field
if setting.get('disabled', False):
continue
if setting['name'] == UCC_LOGGING:
self.__cached_global_settings[LOG_SETTINGS] = {
LOG_LEVEL_KEY: setting.get(LOG_LEVEL_KEY)
}
elif setting['name'] == UCC_PROXY:
if 'disabled' in setting:
del setting['disabled']
setting[PROXY_ENABLE_KEY] = utils.is_true(
setting.get(PROXY_ENABLE_KEY, '0'))
setting[PROXY_RDNS_KEY] = utils.is_true(
setting.get(PROXY_RDNS_KEY, '0'))
self.__cached_global_settings[PROXY_SETTINGS] = setting
else: # should be customized settings
if 'disabled' in setting:
del setting['disabled']
customized_setting.update(setting)
self.__cached_global_settings[
CUSTOMIZED_SETTINGS] = customized_setting
return self.__cached_global_settings.get(key)
def get_proxy_settings(self):
proxy_settings = self._parse_conf().get('proxy_settings', None)
if not proxy_settings:
self.log_info("Proxy is not set!")
return {}
proxy_enabled = utils.is_true(proxy_settings.get("proxy_enabled", '0'))
if not proxy_enabled:
return {}
proxy_settings = {
"proxy_url": proxy_settings.get("proxy_url", ""),
"proxy_port": proxy_settings.get("proxy_port", ""),
"proxy_username": proxy_settings.get("proxy_username", ""),
"proxy_password": proxy_settings.get("proxy_password", ""),
"proxy_type": proxy_settings.get("proxy_type", ""),
"proxy_rdns": utils.is_true(proxy_settings.get("proxy_rdns", '0'))
}
return proxy_settings
def get_global_setting(self, var_name):
"""Get customized setting value configured in global configuration.
:param var_name: `string`
:return: customized global configuration value or None
"""
var_value = self.setup_util.get_customized_setting(var_name)
if var_value is not None and var_name in self.get_global_checkbox_fields():
var_value = sutils.is_true(var_value)
return var_value
def get_proxy_info(proxy_config):
if not proxy_config or not is_true(proxy_config.get('proxy_enabled')):
_logger.info('Proxy is not enabled')
return None
url = proxy_config.get('proxy_url')
port = proxy_config.get('proxy_port')
if url or port:
if not url:
raise ValueError('Proxy "url" must not be empty')
if not util.is_valid_port(port):
raise ValueError('Proxy "port" must be in range [1,65535]: %s' %
port)
user = proxy_config.get('proxy_username')
password = proxy_config.get('proxy_password')
if not all((user, password)):
_logger.info('Proxy has no credentials found')
user, password = None, None
proxy_type = proxy_config.get('proxy_type')
proxy_type = proxy_type.lower() if proxy_type else 'http'
if proxy_type in _PROXY_TYPE_MAP:
ptv = _PROXY_TYPE_MAP[proxy_type]
elif proxy_type in list(_PROXY_TYPE_MAP.values()):
ptv = proxy_type
else:
ptv = socks.PROXY_TYPE_HTTP
_logger.info('Proxy type not found, set to "HTTP"')
rdns = is_true(proxy_config.get('proxy_rdns'))
proxy_info = ProxyInfo(proxy_host=url,
proxy_port=int(port),
proxy_type=ptv,
proxy_user=user,
proxy_pass=password,
proxy_rdns=rdns)
return proxy_info
def handleEdit(self, confInfo):
disabled = self.payload.get('disabled')
if disabled is None:
return self.handler.update(
self.callerArgs.id,
self.payload,
)
elif is_true(disabled):
return self.handler.disable(self.callerArgs.id)
else:
return self.handler.enable(self.callerArgs.id)
def is_migration_job_disabled(self):
# check if the job stanza exists
job_stanza = self.inputs.get('job')
if job_stanza is None:
logger.warning('No valid job stanza found. Exiting...')
return True
conf_job_stanza = self.inputs_conf.get(ENTITY_MIGRATION_INPUT)
if is_true(conf_job_stanza['disabled']):
logger.info('job stanza is disabled. Exiting...')
return True
return False
def _parse_conf_from_env(self, global_settings):
"""
this is run in test env
"""
if not self.__cached_global_settings:
# format the settings, the setting from env is from global_setting
# meta
self.__cached_global_settings = {}
for s_k, s_v in list(global_settings.items()):
if s_k == PROXY_SETTINGS:
proxy_enabled = s_v.get(PROXY_ENABLE_KEY)
proxy_rdns = s_v.get(PROXY_RDNS_KEY)
if type(proxy_enabled) != bool:
s_v[PROXY_ENABLE_KEY] = utils.is_true(proxy_enabled)
if type(proxy_rdns) != bool:
s_v[PROXY_RDNS_KEY] = utils.is_true(proxy_rdns)
self.__cached_global_settings[PROXY_SETTINGS] = s_v
elif s_k == LOG_SETTINGS:
self.__cached_global_settings[LOG_SETTINGS] = {
LOG_LEVEL_KEY: s_v.get(LOG_LEVEL_KEY_ENV)
}
elif s_k == CREDENTIAL_SETTINGS:
# add account id to accounts
for i in range(0, len(s_v)):
s_v[i]["name"] = "account" + str(i)
self.__cached_global_settings[CREDENTIAL_SETTINGS] = s_v
else: # should be customized settings
self.__cached_global_settings[CUSTOMIZED_SETTINGS] = {}
for s in s_v:
field_type = s.get("type")
if not field_type:
self.log_error(
"unknown type for customized var:{}".format(s)
)
continue
self.__cached_global_settings["customized_settings"][
s.get("name", "")
] = self._transform(s.get("value", ""), field_type)
return self.__cached_global_settings
def validate_meta(self, meta):
if not meta.get('appname'):
raise builder_exception.CommonException(
err_code=2022, e_message='appname not found in basic meta')
visible = libsutil.is_true(meta.get('visible', False))
if (visible):
# check the icon file
large_uri = meta.get('large_icon', None)
small_uri = meta.get('small_icon', None)
if large_uri is None or small_uri is None:
raise builder_exception.CommonException(
err_code=2016,
e_message='icon not found in visible app basic meta')
def _get_shc_disable_flag(service):
flag = True
shc_conf_endpoint = "/services/shcluster/config"
try:
resp = service.get(shc_conf_endpoint, output_mode='json').body.read()
content = json.loads(resp)
_logger.debug("get shc conf:%s", content)
for entry in content.get('entry', []):
flag = sutils.is_true(entry['content']['disabled'])
except binding.HTTPError as e:
_logger.error('SHC config return HTTPError:%s.',
traceback.format_exc())
return flag
def _parse_conf_from_env(self, global_settings):
'''
this is run in test env
'''
if not self.__cached_global_settings:
# format the settings, the setting from env is from global_setting
# meta
self.__cached_global_settings = {}
for s_k, s_v in global_settings.items():
if s_k == PROXY_SETTINGS:
proxy_enabled = s_v.get(PROXY_ENABLE_KEY)
proxy_rdns = s_v.get(PROXY_RDNS_KEY)
if not isinstance(proxy_enabled, bool):
s_v[PROXY_ENABLE_KEY] = utils.is_true(proxy_enabled)
if not isinstance(proxy_rdns, bool):
s_v[PROXY_RDNS_KEY] = utils.is_true(proxy_rdns)
self.__cached_global_settings[PROXY_SETTINGS] = s_v
elif s_k == LOG_SETTINGS:
self.__cached_global_settings[LOG_SETTINGS] = {
LOG_LEVEL_KEY: s_v.get(LOG_LEVEL_KEY_ENV)
}
elif s_k == CREDENTIAL_SETTINGS:
# add account id to accounts
for i in range(0, len(s_v)):
s_v[i]['name'] = 'account' + str(i)
self.__cached_global_settings[CREDENTIAL_SETTINGS] = s_v
else: # should be customized settings
self.__cached_global_settings[CUSTOMIZED_SETTINGS] = {}
for s in s_v:
field_type = s.get('type')
if not field_type:
self.log_error(
'unknown type for customized var:{}'.format(s))
continue
self.__cached_global_settings['customized_settings'][s.get('name', '')] = self._transform(
s.get("value", ""), field_type)
return self.__cached_global_settings
def handleEdit(self, confInfo):
disabled = self.payload.get('disabled')
if disabled is None:
self.edit_hook(session_key=self.getSessionKey(),
config_name=self._get_name(),
stanza_id=self.callerArgs.id,
payload=self.payload)
return self.handler.update(
self.callerArgs.id,
self.payload,
)
elif is_true(disabled):
return self.handler.disable(self.callerArgs.id)
else:
return self.handler.enable(self.callerArgs.id)
def _transform(self, value, field_type):
'''
This is method is only used when parsing customized global params from env.
Only checkbox type needs transform. Other types will be extracted automatically when apply json.loads.
:param value:
:param field_type: can be checkbox, text, password, dropdownlist, multi_dropdownlist, radiogroup
:return:
'''
if field_type == TYPE_CHECKBOX:
return utils.is_true(value)
elif field_type in ALL_SETTING_TYPES:
return value
else:
raise Exception("Type of this customized setting is corrupted. Value: {}, type: {}"
.format(value, field_type))
def _parse_input_args_from_global_config(self, inputs):
"""Parse input arguments from global configuration.
:param inputs:
"""
# dirname at this point will be <splunk_home>/etc/apps/<ta-name>/lib/splunktaucclib/modinput_wrapper, go up 3 dirs from this file to find the root TA directory
dirname = os.path.dirname
config_path = os.path.join(
dirname(dirname(dirname(dirname(__file__)))),
"appserver",
"static",
"js",
"build",
"globalConfig.json",
)
with open(config_path) as f:
schema_json = "".join([l for l in f])
global_schema = GlobalConfigSchema(json.loads(schema_json))
uri = inputs.metadata["server_uri"]
session_key = inputs.metadata["session_key"]
global_config = GlobalConfig(uri, session_key, global_schema)
ucc_inputs = global_config.inputs.load(input_type=self.input_type)
all_stanzas = ucc_inputs.get(self.input_type, {})
if not all_stanzas:
# for single instance input. There might be no input stanza.
# Only the default stanza. In this case, modinput should exit.
self.log_warning("No stanza found for input type: " + self.input_type)
sys.exit(0)
account_fields = self.get_account_fields()
checkbox_fields = self.get_checkbox_fields()
self.input_stanzas = {}
for stanza in all_stanzas:
full_stanza_name = "{}://{}".format(self.input_type, stanza.get("name"))
if full_stanza_name in inputs.inputs:
if stanza.get("disabled", False):
raise RuntimeError("Running disabled data input!")
stanza_params = {}
for k, v in stanza.items():
if k in checkbox_fields:
stanza_params[k] = sutils.is_true(v)
elif k in account_fields:
stanza_params[k] = copy.deepcopy(v)
else:
stanza_params[k] = v
self.input_stanzas[stanza.get("name")] = stanza_params
def get_proxy_uri(session_key, proxy_settings=None):
"""
Generate proxy uri from provided configurations.
:param session_key: Splunk Session Key
:param proxy_settings: Proxy configuration dict. Defaults to None.
:return: if proxy configuration available returns uri string else None.
"""
_LOGGER.info("Reading proxy configurations from file.")
if not proxy_settings:
proxy_settings = get_proxy_configuration(session_key)
if proxy_settings.get("proxy_username"):
proxy_settings["proxy_password"] = get_proxy_clear_password(
session_key)
if all([
proxy_settings,
is_true(proxy_settings.get("proxy_enabled")),
proxy_settings.get("proxy_url"),
proxy_settings.get("proxy_type"),
]):
http_uri = proxy_settings["proxy_url"]
if proxy_settings.get("proxy_port"):
http_uri = "{}:{}".format(http_uri,
proxy_settings.get("proxy_port"))
if proxy_settings.get("proxy_username") and proxy_settings.get(
"proxy_password"):
http_uri = "{}:{}@{}".format(
quote(proxy_settings["proxy_username"], safe=""),
quote(proxy_settings["proxy_password"], safe=""),
http_uri,
)
http_uri = "{}://{}".format(proxy_settings['proxy_type'], http_uri)
proxy_data = {"http": http_uri, "https": http_uri}
_LOGGER.info("Returning proxy configurations.")
return proxy_data
else:
return None
def handleList(self, confInfo):
decrypt = self.callerArgs.data.get(
self.ACTION_CRED,
[False],
)
decrypt = is_true(decrypt[0])
if self.callerArgs.id:
result = self.handler.get(
self.callerArgs.id,
decrypt=decrypt,
)
else:
result = self.handler.all(
decrypt=decrypt,
count=0,
)
return result
def get_tab_global_settings(self, action, **params):
session_key = cherrypy.session.get("sessionKey")
splunkd_uri = scc.getMgmtUri()
try:
conf_mgr = common_util.create_conf_mgr(session_key, splunkd_uri)
conf = conf_mgr.get_conf(builder_constant.GLOBAL_SETTING_CONF_NAME)
settings = conf.get_all()
app_cert_conf = settings.get("app_cert")
app_cert_conf["proxy_enabled"] = is_true(
app_cert_conf["proxy_enabled"])
return self.render_json({"data": settings})
except CommonException as ce:
return self.render_json({
'err_code': ce.get_err_code(),
'err_args': ce.get_options()
})
def _get_hec_config(self, hec_input_name, session_key, scheme, host, port,
**context):
hc = HECConfig(session_key,
scheme=scheme,
host=host,
port=port,
**context)
settings = hc.get_settings()
if utils.is_true(settings.get('disabled')):
# Enable HEC input
logging.info('Enabling HEC')
settings['disabled'] = '0'
settings['enableSSL'] = context.get('hec_enablessl', '1')
settings['port'] = context.get('hec_port', '8088')
hc.update_settings(settings)
hec_input = hc.get_input(hec_input_name)
if not hec_input:
# Create HEC input
logging.info('Create HEC datainput, name=%s', hec_input_name)
hinput = {
'index': context.get('index', 'main'),
}
if context.get('sourcetype'):
hinput['sourcetype'] = context['sourcetype']
if context.get('token'):
hinput['token'] = context['token']
if context.get('source'):
hinput['source'] = context['source']
if context.get('host'):
hinput['host'] = context['host']
hec_input = hc.create_input(hec_input_name, hinput)
limits = hc.get_limits()
HECEvent.max_hec_event_length = int(
limits.get('max_content_length', 1000000))
return settings['port'], hec_input['token']
def _parse_input_args_from_global_config(self, inputs):
"""Parse input arguments from global configuration.
:param inputs:
"""
dirname = os.path.dirname
config_path = os.path.join(
dirname(dirname(dirname(dirname(dirname(__file__))))), 'appserver',
'static', 'js', 'build', 'globalConfig.json')
with open(config_path) as f:
schema_json = ''.join([l for l in f])
global_schema = GlobalConfigSchema(json.loads(schema_json))
uri = inputs.metadata["server_uri"]
session_key = inputs.metadata['session_key']
global_config = GlobalConfig(uri, session_key, global_schema)
ucc_inputs = global_config.inputs.load(input_type=self.input_type)
all_stanzas = ucc_inputs.get(self.input_type, {})
if not all_stanzas:
# for single instance input. There might be no input stanza.
# Only the default stanza. In this case, modinput should exit.
self.log_warning("No stanza found for input type: " +
self.input_type)
sys.exit(0)
account_fields = self.get_account_fields()
checkbox_fields = self.get_checkbox_fields()
self.input_stanzas = {}
for stanza in all_stanzas:
full_stanza_name = '{}://{}'.format(self.input_type,
stanza.get('name'))
if full_stanza_name in inputs.inputs:
if stanza.get('disabled', False):
raise RuntimeError("Running disabled data input!")
stanza_params = {}
for k, v in stanza.items():
if k in checkbox_fields:
stanza_params[k] = sutils.is_true(v)
elif k in account_fields:
stanza_params[k] = copy.deepcopy(v)
else:
stanza_params[k] = v
self.input_stanzas[stanza.get('name')] = stanza_params
def get_customized_setting(self, key):
customized_settings = self._parse_conf().get(
setup_const.myta_customized_settings, None)
if not customized_settings:
self.log_info("Customized setting is not set")
return None
if not key in customized_settings:
self.log_info("Customized key can not be found")
return None
customized_setting = customized_settings.get(key, {})
_type = customized_setting.get("type", None)
if not _type:
self.__logger.error("Type of this customized setting is not set")
return None
if _type == "bool":
return utils.is_true(customized_setting.get("bool", '0'))
elif _type == "text":
return customized_setting.get("content", "")
elif _type == "password":
return customized_setting.get("password", "")
else:
raise Exception("Type of this customized setting is corrupted")
def get_proxy_uri(proxy: Dict[str, Any]) -> Optional[str]:
"""
:proxy: dict like, proxy information are in the following
format {
"proxy_url": zz,
"proxy_port": aa,
"proxy_username": bb,
"proxy_password": cc,
"proxy_type": http,sock4,sock5,
"proxy_rdns": 0 or 1,
}
:return: proxy uri or None
"""
uri = None
if proxy and proxy.get("proxy_url") and proxy.get("proxy_type"):
uri = proxy["proxy_url"]
# socks5 causes the DNS resolution to happen on the client
# socks5h causes the DNS resolution to happen on the proxy server
if proxy.get("proxy_type") == "socks5" and utils.is_true(
proxy.get("proxy_rdns")
):
proxy["proxy_type"] = "socks5h"
# setting default value of proxy_type to "http" if
# its value is not from ["http", "socks4", "socks5"]
if proxy.get("proxy_type") not in ["http", "socks4", "socks5"]:
proxy["proxy_type"] = "http"
if proxy.get("proxy_port"):
uri = "{}:{}".format(uri, proxy.get("proxy_port"))
if proxy.get("proxy_username") and proxy.get("proxy_password"):
uri = "{}://{}:{}@{}/".format(
proxy["proxy_type"],
proxy["proxy_username"],
proxy["proxy_password"],
uri,
)
else:
uri = "{}://{}".format(proxy["proxy_type"], uri)
return uri
def get_splunkd_access_info():
'''Get splunkd server access info.
:returns: Tuple of (scheme, host, port).
:rtype: ``tuple``
'''
if utils.is_true(
get_conf_key_value('server', 'sslConfig', 'enableSplunkdSSL')):
scheme = 'https'
else:
scheme = 'http'
host_port = get_conf_key_value('web', 'settings', 'mgmtHostPort')
host_port = host_port.strip()
host = host_port.split(':')[0]
port = int(host_port.split(':')[1])
if 'SPLUNK_BINDIP' in os.environ:
bindip = os.environ['SPLUNK_BINDIP']
port_idx = bindip.rfind(':')
host = bindip[:port_idx] if port_idx > 0 else bindip
return (scheme, host, port)
def _prepare_savedsearches(self):
for savedsearch in self.svc.saved_searches.iter(
search='alert.managedBy=%s*' % em_constants.APP_NAME):
state = 'disabled' if is_true(
savedsearch['disabled']) else 'enabled'
self.savedsearch_with_states.append((savedsearch, state))
