def get_appname(params): if 'appname' in params: app_name = params['appname'] else: service = common_util.create_splunk_service( cherrypy.session.get("sessionKey"), scc.getMgmtUri()) apps = [app.name for app in service.apps if app.name] conf_manager = common_util.create_conf_mgr( cherrypy.session.get("sessionKey"), scc.getMgmtUri()) conf_file = conf_manager.get_conf(tabuilder_status_conf) app_name_create = None app_name_edit = None if tab_conf_manager.is_stanza_exists(conf_file, create_ta_stanza): app_name_create = conf_file.get(create_ta_stanza).get( cca_key, None) create_in_action = conf_file.get(create_ta_stanza).get( "action", False) if create_in_action and app_name_create in apps: return app_name_create if tab_conf_manager.is_stanza_exists(conf_file, edit_ta_stanza): app_name_edit = conf_file.get(edit_ta_stanza).get(cca_key, None) if app_name_edit in apps: return app_name_edit return builder_constant.ADDON_BUILDER_APP_NAME
def handleEdit(self, confInfo): logger.info("start edit") # all_settings = utils.escape_json_control_chars( # self.callerArgs.data[c.all_settings][0]) all_settings = self.callerArgs.data[c.all_settings][0] all_settings = json.loads(all_settings) proxy_settings = all_settings[c.proxy_settings] if utils.is_false(proxy_settings.get(c.proxy_enabled, None)): del all_settings[c.proxy_settings] # 1) Global settings / Proxy settings ta_conf_mgr = ta_conf.TAConfManager( c.myta_global_settings_conf, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields) for k in (c.global_settings, c.proxy_settings): settings = all_settings.get(k, {}) settings[c.name] = k ta_conf_mgr.update(settings) # 2) Credentials / Data collections for name, conf_file in self.confs: settings = all_settings.get(name, {}) ta_conf_mgr = ta_conf.TAConfManager( conf_file, scc.getMgmtUri(), self.getSessionKey(), appname=self.appName) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields) self._updateCredentials(settings, ta_conf_mgr) logger.info("end edit")
def handleList(self, confInfo): logger.info("start list") conf_mgr = conf.ConfManager(scc.getMgmtUri(), self.getSessionKey()) conf_mgr.reload_conf(c.myta_conf) conf_mgr.reload_conf(c.myta_credential_conf) conf_mgr.reload_conf(c.myta_customized_conf) # read globala and proxy settings all_settings = conf_mgr.all_stanzas_as_dicts(c.myta_conf) if not all_settings: all_settings = {} self._setNoneValues(all_settings.get(c.global_settings, {})) # read account credential settings for cred, cred_conf in self.cred_confs: ta_conf_mgr = ta_conf.TAConfManager(cred_conf, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields_credential) creds = ta_conf_mgr.all(return_acl=False) if creds: self._setNoneValues(creds) all_settings.update({cred: creds}) # read customized settings ta_conf_mgr = ta_conf.TAConfManager(c.myta_customized_conf, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields_customized) customized_settings = ta_conf_mgr.all(return_acl=False) all_settings.update({c.myta_customized_settings: customized_settings}) self._clearPasswords(all_settings, self.cred_fields) all_settings = json.dumps(all_settings) all_settings = utils.escape_json_control_chars(all_settings) confInfo[c.myta_settings].append(c.all_settings, all_settings) logger.info("end list")
def handleList(self, confInfo): logger.info("start list") conf_mgr = conf.ConfManager(scc.getMgmtUri(), self.getSessionKey()) conf_mgr.reload_conf(c.myta_conf) conf_mgr.reload_conf(c.myta_credential_conf) conf_mgr.reload_conf(c.myta_customized_conf) # read globala and proxy settings all_settings = conf_mgr.all_stanzas_as_dicts(c.myta_conf) if not all_settings: all_settings = {} self._setNoneValues(all_settings.get(c.global_settings, {})) # read account credential settings for cred, cred_conf in self.cred_confs: ta_conf_mgr = ta_conf.TAConfManager( cred_conf, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields_credential) creds = ta_conf_mgr.all(return_acl=False) if creds: self._setNoneValues(creds) all_settings.update({cred: creds}) # read customized settings ta_conf_mgr = ta_conf.TAConfManager( c.myta_customized_conf, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields_customized) customized_settings = ta_conf_mgr.all(return_acl=False) all_settings.update({c.myta_customized_settings: customized_settings}) self._clearPasswords(all_settings, self.cred_fields) all_settings = json.dumps(all_settings) all_settings = utils.escape_json_control_chars(all_settings) confInfo[c.myta_settings].append(c.all_settings, all_settings) logger.info("end list")
def handleList(self, confInfo): logger.info("start list") conf_mgr = conf.ConfManager(scc.getMgmtUri(), self.getSessionKey(), app_name=self.appName) conf_mgr.reload_conf(c.myta_conf) conf_mgr.reload_conf(c.myta_cred_conf) conf_mgr.reload_conf(c.myta_forwarder_conf) all_settings = conf_mgr.all_stanzas_as_dicts(c.myta_conf) if not all_settings: all_settings = {} self._setNoneValues(all_settings.get(c.global_settings, {})) for cred, cred_conf in self.cred_confs: ta_conf_mgr = ta_conf.TAConfManager(cred_conf, scc.getMgmtUri(), self.getSessionKey(), appname=self.appName) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields) creds = ta_conf_mgr.all(return_acl=False) if creds: self._setNoneValues(creds) all_settings.update({cred: creds}) self._clearPasswords(all_settings, self.cred_fields) all_settings = json.dumps(all_settings) all_settings = utils.escape_json_control_chars(all_settings) confInfo[c.myta_settings].append(c.all_settings, all_settings) logger.info("end list")
def handleList(self, confInfo): _LOGGER.info("start list") conf.reload_confs(("okta", ), self.getSessionKey(), scc.getMgmtUri()) conf_mgr = oc.OktaConfManager(scc.getMgmtUri(), self.getSessionKey()) confDict = conf_mgr.get(self.appName, self.okta_endpoint) if confDict: for key, val in confDict.iteritems(): if key in self.okta_args: if val is None: val = "" confInfo[self.okta_endpoint].append(key, val) _LOGGER.info("end list")
def global_settings(self, resource, **params): session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() tabuilder = builder.TABuilder(controller_util.get_current_ta_project(), splunkd_uri, session_key) if cherrypy.request.method == 'GET': global_settings = tabuilder.get_global_settings() if global_settings is None: global_settings = {} return self.render_json(global_settings) elif cherrypy.request.method == 'POST': cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) try: # did some clean up in case frontend does not clean it up if 'customized_settings' in params and len( params['customized_settings']) == 0: del params['customized_settings'] logger.info("global settings params are : %s", params) tabuilder.update_global_settings(params) return self.render_json({"status": "success"}) except CommonException as e: logger.error("fail to save global settings. Error: %s", traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error("fail to save global settings. Error: %s", traceback.format_exc()) raise e
def handleList(self, conf_info): logger.info("start list google projects") if (not self.callerArgs or not self.callerArgs.get(ggc.google_credentials_name)): logger.error("Missing Google credentials") raise Exception("Missing Google credentials") stanza_name = self.callerArgs[ggc.google_credentials_name][0] logger.info(self.callerArgs[ggc.google_credentials_name]) config = gconf.get_google_settings(scc.getMgmtUri(), self.getSessionKey(), cred_name=stanza_name) res_mgr = grm.GoogleResourceManager(logger, config) try: projects = [project["projectId"] for project in res_mgr.projects()] except googleapiclient.errors.HttpError as e: if e.resp.status == 403: projects = [config[ggc.google_credentials]["project_id"]] else: raise e except Exception as e: print(e) raise BaseException() conf_info["google_projects"].append("projects", projects) logger.info("end of listing google projects")
def set_level(name, token, level, appName='-'): if level in _levelNames: HOST = scc.getMgmtUri() response=simpleRequest(HOST + '/servicesNS/nobody/%s/properties/log_info/%s' % (appName,name), postargs={'level':level},sessionKey=token) return response else: return None
def start_parse_unstructured_data(self, action, **params): session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() app_name = params['app_name'] sourcetype = params['sourcetype'] batch_size = params.get("batch_size", None) try: tabuilder = TABuilder(app_name, splunk_uri, session) tabuilder.remove_all_unstructured_data_inputs() tabuilder.start_parse_unstructured_data(sourcetype, batch_size) return self.render_json({"data": {"successful": True, "app_name": app_name, "sourcetype": sourcetype}}) except CommonException as e: tabuilder.cancel_parse_unstructured_data(sourcetype) logger.error('Get CommonException when getting auto extraction results. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({'err_code': e.get_err_code(), 'err_args': e.get_options()}) except Exception as e: tabuilder.cancel_parse_unstructured_data(sourcetype) logger.error("Cannot get extractions for sourcetype %s. error: %s", sourcetype, traceback.format_exc()) raise e
def get_unstructured_data_status(self, action, **params): session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() app_name = params['app_name'] sourcetype = params['sourcetype'] try: tabuilder = TABuilder(app_name, splunk_uri, session) results = tabuilder.get_unstructured_data_status(sourcetype) if results.get("error"): tabuilder.cancel_parse_unstructured_data(sourcetype) return self.render_json(results.get("error")) return self.render_json({"data": results}) except CommonException as e: tabuilder.cancel_parse_unstructured_data(sourcetype) logger.error('Get CommonException when getting auto extraction results. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({'err_code': e.get_err_code(), 'err_args': e.get_options()}) except Exception as e: tabuilder.cancel_parse_unstructured_data(sourcetype) logger.error("Cannot get extractions for sourcetype %s. error: %s", sourcetype, traceback.format_exc()) raise e
def app_delete(self, **params): session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() service = common_util.create_splunk_service(session, splunk_uri) cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) app_context = json.loads(raw_body) app_name = app_context["name"] try: if meta_util.is_app_created_by_aob(service, app_name): app_util.delete_app(service, app_name, splunk_uri, session) else: raise builder_exception.CommonException( err_code=64, options={'current_app': app_name}) return self.render_json({ "result": "success", "message": "TA {} has been successfully deleted".format(app_name) }) except builder_exception.CommonException as e: logger.error('Fail to delete app. %s', traceback.format_exc()) return self.render_json({ "err_code": e.get_err_code(), "err_args": e.get_options() }) except Exception as e: logger.error('Fail to delete app %s. %s', app_name, traceback.format_exc()) return self.render_json({'err_code': 1003, 'err_args': app_name})
def handleList(self, conf_info): logger.info("start listing google subscriptions") for required in self.valid_params: if not self.callerArgs or not self.callerArgs.get(required): logger.error('Missing "%s"', required) raise Exception('Missing "{}"'.format(required)) stanza_name = self.callerArgs[ggc.google_credentials_name][0] config = gconf.get_google_settings(scc.getMgmtUri(), self.getSessionKey(), cred_name=stanza_name) project = self.callerArgs[ggc.google_project][0] config.update({ "service_name": "storage", "version": "v1", "scopes": ["https://www.googleapis.com/auth/cloud-platform.read-only"] }) storage = create_google_client(config) buckets = storage.buckets() bucket_names = list() request = buckets.list(project=project) while request: try: response = request.execute() except googleapiclient.errors.HttpError, exc: RH_Err.ctl(400, exc) names = [item.get('name') for item in response.get('items')] bucket_names.extend(names) request = buckets.list_next(request, response)
def get_modular_alerts_summary(self, action, **params): session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() tabuilder = builder.TAAlertBuilder( controller_util.get_current_ta_project(), splunkd_uri, session_key) all_modular_alerts = tabuilder.get_all_TA_alerts() or [] return self.render_json(all_modular_alerts)
def get_sourcetype_basic_info(self, action, **params): session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() app_name = params['app_name'] try: tabuilder = TABuilder(app_name, splunk_uri, session) data = tabuilder.get_sourcetype_basic_info() or {} sourcetypes = [] for k, v in list(data.items()): item = {"name": k} item.update(v) sourcetypes.append(item) sourcetypes.sort(key=lambda x: x.get("name")) ret = { 'status': 'success', 'data': sourcetypes, } return self.render_json(ret) except CommonException as ce: logger.error("Can not get basic info. error:%s", traceback.format_exc()) return self.render_json({ 'err_code': ce.get_err_code(), 'err_args': ce.get_options() }) except Exception as e: logger.error("Cannot get basic info. error: %s", traceback.format_exc()) raise e
def edit_data_input(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) appname = controller_util.get_current_ta_project() reload_input = params.get('reload_input', True) if 'reload_input' in params: del params['reload_input'] splunkd_uri, session_key = scc.getMgmtUri(), cherrypy.session.get( "sessionKey") try: tabuilder = builder.TABuilder(appname, splunkd_uri, session_key) tabuilder.update_TA_input(params, reload_input) return self.render_json({"status": "success", "meta": params}) except CommonException as e: logger.error( 'Get CommonException when update data input. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({'err_code': e.get_err_code(), 'err_args': e.get_options()}) except Exception as e: logger.error( 'Get exception when update data input. meta:%s, error:%s', params, traceback.format_exc()) raise e
def _handleUpdateProxyAccount(self, confInfo, args): settings = ("proxy_url", "proxy_username", "proxy_password", "proxy_port", "proxy_enabled", "proxy_rdns", "proxy_type") if not utils.is_true(args["proxy_enabled"][0]): _LOGGER.info("Disabling proxy") for k in settings: if k not in ("proxy_type", "proxy_rdns"): args[k] = [""] args["proxy_enabled"][0] = "0" confDict = self.readConf("service_now") if (confDict.get("snow_proxy") and confDict["snow_proxy"].get("proxy_url")): proxy_url = confDict["snow_proxy"]["proxy_url"] _LOGGER.info("Remove credentials for proxy %s", proxy_url) mgr = cred.CredentialManager(self.getSessionKey(), scc.getMgmtUri()) mgr.delete(proxy_url, self.dummy, self.appName) if (utils.is_true(args["proxy_enabled"][0]) and args["proxy_username"][0] and not args["proxy_password"][0]): _LOGGER.error("Missing proxy password") raise Exception("Missing proxy password") self._handleUpdateAccount(confInfo, args, "snow_proxy", settings)
def delete_alias(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() appname = controller_util.get_current_ta_project() sourcetype = params['sourcetype'] input_field = params['input_field'] output_field = params['output_field'] search = params["search"] try: builder = TACIMBuilder(appname, splunk_uri, session) res = builder.delete_alias(sourcetype, output_field, input_field, search) return self.render_json({"data": res}) except CommonException as e: logger.error( 'Get CommonException when deleting alias. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error("Cannot delete alias %s. error: %s", output_field, traceback.format_exc()) raise e
def code_run(self, action, **params): # check the role of current user, only admin can run code username = cherrypy.session.get('user').get('name') session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() service = common_util.create_splunk_service(session_key, splunkd_uri) params = None try: r = app_util.is_user_allow_to_create_ta(username, service) if r: # if getting error code, just render it return self.render_json(r) cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) # params is the meta for this input appname = controller_util.get_current_ta_project() input_builder = builder_ta_input.TAInputBuilder( appname, splunkd_uri, session_key) dryrun_result = input_builder.dryrun_modinput_code(params) return self.render_json(dryrun_result) except CommonException as ce: logger.error('Fail to dryrun data input. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({'err_code': ce.get_err_code(), 'err_args': ce.get_options()})
def handleEdit(self, confInfo): logger.info("start edit setup configure.") scheme, host, port = utils.extract_http_scheme_host_port( scc.getMgmtUri()) conf_mgr = conf.ConfManager(self.getSessionKey(), self.appName, scheme=scheme, host=host, port=port) ta_conf_file = get_or_create_conf_file(conf_mgr, setup_const.myta_conf) customized_conf_file = get_or_create_conf_file( conf_mgr, setup_const.myta_customized_conf) all_origin_settings = ta_conf_file.get_all() all_settings = utils.escape_json_control_chars( self.callerArgs.data[setup_const.all_settings][0]) all_settings = json.loads(all_settings) # write global and proxy settings self._updateGlobalSettings(setup_const.global_settings, all_settings, all_origin_settings, ta_conf_file) self._updateGlobalSettings(setup_const.proxy_settings, all_settings, all_origin_settings, ta_conf_file) # write customized settings customized_conf_file = get_or_create_conf_file( conf_mgr, setup_const.myta_customized_conf) self._updateConfStanzas( all_settings.get(setup_const.myta_customized_settings, {}), customized_conf_file, self.encrypt_fields_customized) logger.info("edit setup configure is done")
def create_eventtype(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() appname = controller_util.get_current_ta_project() name = params['name'] search = params['search'] sourcetype_dict = params['sourcetypes'] try: builder = TACIMBuilder(appname, splunk_uri, session) builder.create_eventtype(name, search, sourcetype_dict) return self.render_json({"data": {"successful": True}}) except CommonException as e: logger.error( 'Get CommonException when creating eventtype. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error("Cannot create eventtype %s. error: %s", name, traceback.format_exc()) raise e
def handleList(self, confInfo): logger.info("start list setup configure.") scheme, host, port = utils.extract_http_scheme_host_port( scc.getMgmtUri()) conf_mgr = conf.ConfManager(self.getSessionKey(), self.appName, scheme=scheme, host=host, port=port) ta_conf_file = get_or_create_conf_file(conf_mgr, setup_const.myta_conf) # read globala and proxy settings all_settings = ta_conf_file.get_all() if not all_settings: all_settings = {} self._setNoneValues(all_settings.get(setup_const.global_settings, {})) # customized conf customized_conf_file = get_or_create_conf_file( conf_mgr, setup_const.myta_customized_conf) settings = customized_conf_file.get_all() all_settings[setup_const.myta_customized_settings] = settings self._clearPasswords(all_settings, self.cred_fields) all_settings = filter_eai_property(all_settings) all_settings = json.dumps(all_settings) all_settings = utils.escape_json_control_chars(all_settings) confInfo[setup_const.myta_settings].append(setup_const.all_settings, all_settings) logger.info("list setup configure is done.")
def get_eventtypes(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() appname = params['app_name'] name = params['name'] try: builder = TACIMBuilder(appname, splunk_uri, session) res = eventtype_util.get_eventtype(builder.tab_conf_mgr, stanza=None, with_tags=False) return self.render_json({"data": res}) except CommonException as e: logger.error( 'Get CommonException when getting eventtype. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error("Cannot get eventtype %s. error: %s", name, traceback.format_exc()) raise e
def validate_input_meta(self, action, **params): ''' post body: { "uuid": uuid // first time to create the input, no uuid yet "name": name, "title": title, "description": description, "type": type, "sourcetype": sourcetype, "interval": interval, } ''' session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() input_builder = builder_ta_input.TAInputBuilder( controller_util.get_current_ta_project(), splunkd_uri, session_key) alert_builder = builder_ta_alert.TAAlertBuilder( controller_util.get_current_ta_project(), splunkd_uri, session_key) input_builder.set_alert_builder(alert_builder) cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) meta = json.loads(raw_body) response = {} try: input_builder.validate_input_name_and_sourcetype(meta) response['validate_result'] = 'success' except CommonException as ce: logger.error('Validate input meta fails. %s', traceback.format_exc()) response['err_code'] = ce.get_err_code() response['err_args'] = ce.get_options() return self.render_json(response)
def check_cim_available(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() appname = controller_util.get_current_ta_project() try: builder = TACIMBuilder(appname, splunk_uri, session) confs = builder.check_cim_available() res = {"data": {"successful": True}} if confs: res = {"data": {"successful": False, "conf_names": confs}} return self.render_json(res) except CommonException as e: logger.error( 'Get CommonException when checking CIM available for app %s. meta:%s, error:%s', appname, params, traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error("Cannot check CIM available for app %s. error: %s", appname, traceback.format_exc()) raise e
def create_eval(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() appname = controller_util.get_current_ta_project() sourcetypes = params['sourcetypes'] output_field = params['output_field'] expression = params['expression'] search = params['search'] try: builder = TACIMBuilder(appname, splunk_uri, session) res = builder.update_eval(sourcetypes, output_field, expression, search, check_exist=True) return self.render_json({"data": res}) except CommonException as e: logger.error( 'Get CommonException when creating eval. meta:%s, error:%s', params, traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error("Cannot create eval %s. error: %s", expression, traceback.format_exc()) raise e
def handleList(self, confInfo): """ Read the initial values of the parameters from the custom file service_now.conf, and write them to the setup screen. If the app has never been set up, uses default/service_now.conf. If app has been set up, looks at local/service_now.conf first, then looks at default/service_now.conf only if there is no value for a field in local/service_now.conf For text fields, if the conf file says None, set to the empty string. """ _LOGGER.info("start list") conf.reload_confs(("service_now", ), self.getSessionKey(), scc.getMgmtUri()) confDict = self.readConf("service_now") if confDict is not None: self._decrypt_username_password(confDict) for stanza, settings in confDict.items(): for key, val in settings.items(): if key in self.snow_args and val is None: val = "" if key in ("password", "proxy_password"): val = "" confInfo[stanza].append(key, val) _LOGGER.info("end list")
def upgrade_app_project(self, action, **params): session = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) app_context = json.loads(raw_body) app_name = app_context.get('app_name', '') try: service = common_util.create_splunk_service( session, splunkd_uri, builder_constant.ADDON_BUILDER_APP_NAME) app_project = app.App(app_name, service) ta_builder = builder.TABuilder(app_name, uri=splunkd_uri, session_key=session) app_project.upgrade(ta_builder) return self.render_json({}) except CommonException as ce: logger.error("Fail to upgrade app. %s", traceback.format_exc()) return self.render_json({ 'err_code': ce.get_err_code(), 'err_args': ce.get_options() }) except Exception as e: logger.error("Fail to upgrade app. %s", traceback.format_exc()) return self.render_json({'err_code': 19})
def get_global_is_secure(session_key): conf_manager = ConfManager(scc.getMgmtUri(), session_key) conn = conf_manager.get_stanza('aws_global_settings', 'aws_connection', do_reload=False) return (utils.is_true(conn["is_secure"]), utils.is_true(conn["verify_certificates"]))
def set_tab_global_settings(self, action, **params): session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() settings = json.loads(params['settings']) try: encrypt_keys = ("password", "username", "proxy_username", "proxy_password") conf_mgr = common_util.create_conf_mgr(session_key, splunkd_uri) conf = conf_mgr.get_conf(builder_constant.GLOBAL_SETTING_CONF_NAME) conf_settings = conf.get_all() app_cert = AppCert(splunkd_uri, session_key, builder_constant.ADDON_BUILDER_APP_NAME) app_cert_settings = conf_settings.get("app_cert", {}).copy() app_cert_settings.update(settings.get("app_cert")) app_cert.validate_settings(app_cert_settings) for stanza, key_values in list(settings.items()): conf.update(stanza, key_values, encrypt_keys) 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 current_creating_app(self, action, **params): # POST cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) app_context = json.loads(raw_body) app_name = app_context.get('app_name', '') if app_name: controller_util.set_current_ta_project(app_name) else: controller_util.delete_current_ta_project() app_display_name = app_context.get('app_display_name', '') controller_util.set_current_ta_display_name(app_display_name) # default is built by tabuilder built = app_context.get('built', 'yes') controller_util.set_built_flag(built) if app_name: mgr = meta_manager.create_meta_manager( cherrypy.session.get("sessionKey"), scc.getMgmtUri(), meta_const.APP_CONTEXT, app_name) return self.render_json({ 'app_name': app_name, 'app_display_name': app_display_name, 'built': built, 'cookies': controller_util.format_response_cookie() })
def save_models(self, action, **params): cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) params = json.loads(raw_body) session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() appname = controller_util.get_current_ta_project() eventtype_name = params["eventtype_name"] new_models = params['new_models'] old_models = params['old_models'] try: builder = TACIMBuilder(appname, splunk_uri, session) res = builder.save_models(eventtype_name, new_models, old_models) return self.render_json({"data": {"successful": True}}) except CommonException as e: logger.error( 'Get CommonException when saving models for eventtype %s. meta:%s, error:%s', eventtype_name, params, traceback.format_exc()) return self.render_json({ 'err_code': e.get_err_code(), 'err_args': e.get_options() }) except Exception as e: logger.error( "Cannot save models objects for eventtype %s. error: %s", eventtype_name, traceback.format_exc()) raise e
def handleList(self, conf_info): logger.info("start get iwork orgchart") config = { c.session_key: self.getSessionKey(), c.server_uri: scc.getMgmtUri(), } emp = ckpt.EmployeeDetailLookup(config) lookups = emp.all() conf_info[self.key].append(self.key, json.dumps(lookups)) logger.info("end of getting iwork orgchart")
def setup(self): """ Set up supported arguments """ if self.requestedAction == admin.ACTION_EDIT: for arg in self.valid_args: self.supportedArgs.addOptArg(arg) conf_mgr = conf.ConfManager(scc.getMgmtUri(), self.getSessionKey(), app_name=self.appName) reload_confs(conf_mgr)
def handleList(self, confInfo): logger.info("start list") all_settings = {} # 1) Global settings / Proxy settings ta_conf_mgr = ta_conf.TAConfManager( c.myta_global_settings_conf, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields) all_settings = ta_conf_mgr.all(return_acl=False) if not all_settings: all_settings = {} self._setNoneValues(all_settings.get(c.global_settings, {})) self._setNoneValues(all_settings.get(c.proxy_settings, {})) # 2) Credentials / Data colletions for name, conf_file in self.confs: ta_conf_mgr = ta_conf.TAConfManager( conf_file, scc.getMgmtUri(), self.getSessionKey()) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields) settings = ta_conf_mgr.all(return_acl=False) if settings: for setting in settings.itervalues(): cred = setting.get(gpc.google_credentials) if cred: setting[gpc.google_credentials] = b64decode(cred) self._setNoneValues(settings) all_settings.update({name: settings}) # self._clearPasswords(all_settings, self.encrypt_fields) all_settings = json.dumps(all_settings) # all_settings = utils.unescape_json_control_chars(all_settings) confInfo[c.myta_settings].append(c.all_settings, all_settings) logger.info("end list")
def handleEdit(self, confInfo): logger.info("start edit") conf_mgr = conf.ConfManager(scc.getMgmtUri(), self.getSessionKey(), app_name=self.appName) conf_mgr.reload_conf(c.myta_conf) conf_mgr.reload_conf(c.myta_credential_conf) conf_mgr.reload_conf(c.myta_customized_conf) all_origin_settings = conf_mgr.all_stanzas_as_dicts(c.myta_conf) all_settings = utils.escape_json_control_chars( self.callerArgs.data[c.all_settings][0]) all_settings = json.loads(all_settings) # write globala and proxy settings self._updateGlobalSettings(c.global_settings, all_settings, all_origin_settings, conf_mgr) # write account credential settings for cred, conf_file in self.cred_confs: creds = all_settings.get(cred, {}) if creds == c.ignore_backend_req: logger.info("Ignore backend rest request") continue ta_conf_mgr = ta_conf.TAConfManager( conf_file, scc.getMgmtUri(), self.getSessionKey(), appname=self.appName) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields_credential) self._updateCredentials(creds, ta_conf_mgr) # write customized settings customized_settings = all_settings.get(c.myta_customized_settings, {}) ta_conf_mgr = ta_conf.TAConfManager( c.myta_customized_conf, scc.getMgmtUri(), self.getSessionKey(), appname=self.appName) ta_conf_mgr.set_encrypt_keys(self.encrypt_fields_customized) self._updateCredentials(customized_settings, ta_conf_mgr) conf_mgr.reload_conf(c.myta_conf) conf_mgr.reload_conf(c.myta_credential_conf) conf_mgr.reload_conf(c.myta_customized_conf) logger.info("end edit")
def handleCreate(self, conf_info): logger.info("start creating iwork settings") if not self.callerArgs or not self.callerArgs.get(self.key): logger.error("Missing iwork settings") raise Exception("Missing iwork settings") mgr = tcm.TAConfManager( c.iwork, scc.getMgmtUri(), self.getSessionKey(), c.splunk_app_iwork) mgr.set_encrypt_keys([c.password]) settings = json.loads(self.callerArgs[self.key][0]) for stanza_name in (c.iemail_settings, c.icalendar_settings): settings[c.name] = stanza_name mgr.update(settings) logger.info("end of creating iwork settings")
def handleList(self, conf_info): logger.info("start listing iwork settings") mgr = tcm.TAConfManager( c.iwork, scc.getMgmtUri(), self.getSessionKey(), c.splunk_app_iwork) mgr.reload() mgr.set_encrypt_keys([c.password]) stanzas = mgr.all(return_acl=False) result = {} for key in self.valid_params: if key is "password": continue result[key] = stanzas[c.iemail_settings].get(key) conf_info[self.key].append(self.key, json.dumps(result)) logger.info("end of listing iwork settings")
def _getSplunkdUri(): return comm.getMgmtUri().replace('127.0.0.1',socket.gethostname().lower())