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))