def __init__(self, splunk_uri, session_key, app_name, service_with_tab_context=None, service_with_ta_context=None): _LOGGER.info("Init Splunk Regex Loader...") self.splunk_endpoint = splunk_uri self.splunk_session_key = session_key self.app_name = app_name if service_with_ta_context: self.service = service_with_ta_context else: self.service = common_util.create_splunk_service( session_key, splunk_uri, app_name) if service_with_tab_context: self.service_with_tab_context = service_with_tab_context else: self.service_with_tab_context = common_util.create_splunk_service( session_key, splunk_uri) self.meta_mgr = meta_manager.create_meta_manager( session_key, splunk_uri, meta_const.FIELD_EXTRACT_BUILDER, app_name) self.tab_conf_mgr = tab_conf_manager.create_tab_conf_manager( session_key, splunk_uri, app_name) self.internal_conf_mgr = tab_conf_manager.create_tab_conf_manager( session_key, splunk_uri, builder_constant.ADDON_BUILDER_APP_NAME) self.event_mgr = meta_manager_event.EventMetaManager( self.splunk_endpoint, self.splunk_session_key, service=self.service_with_tab_context)
def __init__(self, appname, uri, session_key, service_with_tab_context=None, service_with_ta_context=None): self.__appname = appname self.__app_namespace = common_util.get_python_lib_dir_name( self.__appname) self.__logger = logger.get_input_builder_logger() self.__parent_dir = os.path.split(os.path.realpath(__file__))[0] self.__resource_dir = os.path.join(self.__parent_dir, "resources") self.__resource_lib_dir = os.path.join(self.__parent_dir, "resources_lib") self.__splunk_home = os.environ['SPLUNK_HOME'] self.__splunk_app_dir = os.path.join(self.__splunk_home, "etc", "apps") self.__current_ta_dir = os.path.join(self.__splunk_app_dir, self.__appname) self.__asset_generator = ta_static_asset_generator.AssetGenerator( self.__resource_dir, self.__current_ta_dir, self.__resource_lib_dir, app_name=self.__appname) self.__uri = uri self.__session_key = session_key if service_with_ta_context: self.__service_with_ta_context = service_with_ta_context else: self.__service_with_ta_context = common_util.create_splunk_service( session_key, uri, self.__appname) self.__logger.info('Create splunk service with args: %s, %s', session_key, uri) self.__conf_mgr = common_util.create_conf_mgr( self.__session_key, self.__uri, app=self.__appname) self.__conf_mgr_with_tab_context = common_util.create_conf_mgr( self.__session_key, self.__uri) if not service_with_tab_context: service_with_tab_context = common_util.create_splunk_service( session_key, uri) self.__service_with_tab_context = service_with_tab_context self.required_meta_keys = ['name', 'type', 'sourcetype'] self.__global_vars = None self.__input_meta_mgr = TAInputMetaMgr(appname, uri, session_key, self.__service_with_tab_context) self._ta_configuration_builder = builder_ta_configuration.TAConfigurationBuilder( self.__appname, self.__service_with_tab_context, self.__service_with_ta_context)
def __init__(self, appname, uri, session_key, service_with_tab_context=None, service_with_ta_context=None): self.__appname = appname self.__app_namespace = common_util.get_python_lib_dir_name( self.__appname) self.__logger = logger.get_alert_builder_logger() self.__parent_dir = os.path.split(os.path.realpath(__file__))[0] self.__resource_dir = os.path.join(self.__parent_dir, "resources") self.__resource_lib_dir = os.path.join(self.__parent_dir, "resources_lib") self.__splunk_home = os.environ['SPLUNK_HOME'] self.__splunk_app_dir = os.path.join(self.__splunk_home, "etc", "apps") self.__current_ta_dir = os.path.join(self.__splunk_app_dir, self.__appname) self.__asset_generator = ta_static_asset_generator.AssetGenerator( self.__resource_dir, self.__current_ta_dir, self.__resource_lib_dir, app_name=self.__appname) self.__uri = uri self.__session_key = session_key if service_with_ta_context: self.__service_with_ta_context = service_with_ta_context else: self.__service_with_ta_context = common_util.create_splunk_service( session_key, uri, self.__appname) self.__conf_mgr = common_util.create_conf_mgr(self.__session_key, self.__uri, app=self.__appname) self.__conf_mgr_with_tab_context = common_util.create_conf_mgr( self.__session_key, self.__uri) if not service_with_tab_context: service_with_tab_context = common_util.create_splunk_service( session_key, uri) self.__service_with_tab_context = service_with_tab_context self.__meta_mgr = meta_manager.create_meta_manager( session_key, uri, meta_const.ALERT_ACTION_BUILER, self.__appname) self.required_meta_keys = ['name', 'type', 'sourcetype'] self.__global_vars = None self.__basic_builder = TABasicBuilder(self.__appname, uri, session_key, self.__service_with_tab_context, self.__service_with_ta_context)
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 __init__(self, appname, uri, session_key, service_with_tab_context=None): self.__appname = appname self.__logger = logger.get_input_builder_logger() self.__uri = uri self.__session_key = session_key self.__conf_mgr_with_tab_context = common_util.create_conf_mgr( self.__session_key, self.__uri) self.__default_input_properties = { "index": "default", "sourcetype": "{}_sourcetype".format(self.__appname), "interval": 60, "use_external_validation": True, "streaming_mode_xml": True, } if not service_with_tab_context: service_with_tab_context = common_util.create_splunk_service( session_key, uri) self.__service_with_tab_context = service_with_tab_context self.__meta_mgr = meta_manager.create_meta_manager( session_key, uri, meta_const.DATA_INPUT_BUILDER, self.__appname) self.required_meta_keys = ['name', 'type', 'sourcetype'] self.__alert_builder = None
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 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 __init__(self, splunk_endpoint, splunk_session_key, namespace, app_name, service=None): """ :splunk_endpoint: splunk management uri :splunk_session_key: splunk session key :namespace: unique name of the builder, such as fied_extraction_builder :app_name: default app name. Could be reset via set_app_name() :service: an splunk service object. """ self.namespace = namespace self.app_name = app_name if service: self.service = service else: self.service = common_util.create_splunk_service( splunk_session_key, splunk_endpoint) self.tabuilder_meta_state = self._get_ta_builder_meta_state_store() self.project_meta_state = self._get_project_meta_state_store()
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 get_input_names(self, action, **params): session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() service = common_util.create_splunk_service(session_key, splunkd_uri) tabuilder = builder.TABuilder(controller_util.get_current_ta_project(), splunkd_uri, session_key, service) all_inputs = tabuilder.get_all_TA_inputs() or [] return self.render_json({"input_names": [_input['name'] for _input in all_inputs]})
def is_loaded(self, action, **params): session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() service = common_util.create_splunk_service(session, splunk_uri) app_name = params['app_name'] is_loaded = False if app_name: is_loaded = app_util.is_app_loaded(service, app_name) return self.render_json({'loaded': is_loaded})
def create_meta_manager(session_key, uri, meta_namespace, appname, max_pool_len=1): service_with_tab_context = common_util.create_splunk_service( session_key, uri) m = MetaManager(uri, session_key, meta_namespace, appname, service_with_tab_context) return m
def __init__(self, app_name, splunk_uri, session_key, service_with_tab_context=None, service_with_ta_context=None): if service_with_ta_context: self.service = service_with_ta_context else: self.service = common_util.create_splunk_service( session_key, splunk_uri, app_name) self.splunk_endpoint = splunk_uri self.splunk_session_key = session_key if not service_with_tab_context: service_with_tab_context = common_util.create_splunk_service( session_key, splunk_uri) self.st_builder = SourcetypeBuilder(app_name, splunk_uri, session_key, service_with_tab_context, self.service)
def is_user_allow_to_user_tabuilder(self, action, **params): 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) r = app_util.is_user_allow_to_create_ta(username, service) if r: return self.render_json(r) else: return self.render_json({})
def __init__(self, appname, splunkd_uri, session_key, service_with_tab_context=None, service_with_ta_context=None, ): self.appname = appname self.splunkd_uri = splunkd_uri self.session_key = session_key if service_with_ta_context: self.service = service_with_ta_context else: self.service = common_util.create_splunk_service(session_key, splunkd_uri, appname) if not service_with_tab_context: service_with_tab_context = common_util.create_splunk_service(session_key, splunkd_uri) self.meta_mgr = meta_manager.create_meta_manager(session_key, splunkd_uri, meta_const.CIM_MAPPING_BUILDER, appname) self.conf_mgr = common_util.create_conf_mgr(session_key, splunkd_uri, self.appname) self.tab_conf_mgr = tab_conf_manager.create_tab_conf_manager(session_key, splunkd_uri, appname) self.tab_conf_mgr_with_tab_context = tab_conf_manager.create_tab_conf_manager(session_key, splunkd_uri, builder_constant.ADDON_BUILDER_APP_NAME)
def __init__(self, splunk_endpoint, splunk_session_key, service=None): self.splunk_uri = splunk_endpoint self.session_key = splunk_session_key if service: self.service = service else: self.service = common_util.create_splunk_service( splunk_session_key, splunk_endpoint) self.mgr = meta_client.MetaClient(self.service, meta_const.EVENT_COLLECTION_NAME)
def __init__(self, app_name, splunk_uri, splunk_session_key, service_with_tab_context=None, service_with_ta_context=None): self.splunk_uri = splunk_uri self.splunk_session_key = splunk_session_key self.meta_mgr = meta_manager.create_meta_manager(splunk_session_key, splunk_uri, SOURCETYPE_BUILDER, app_name) self.tab_conf_mgr = tab_conf_manager.create_tab_conf_manager(splunk_session_key, splunk_uri, app_name) self._app = app_name if not service_with_tab_context: service_with_tab_context = common_util.create_splunk_service(splunk_session_key, splunk_uri) self.service_with_tab_context = service_with_tab_context
def __init__(self, splunk_uri, session_key, app_name): self.splunk_uri = splunk_uri self.session_key = session_key self.app_name = app_name self.service = common_util.create_splunk_service( session_key, splunk_uri, app_name) self.meta_mgr = meta_manager.create_meta_manager( session_key, splunk_uri, meta_const.TA_VALIDATION_NS, app_name) self.conf_mgr = tab_conf_manager.create_tab_conf_manager( session_key, splunk_uri, app_name) self.tab_conf_mgr = tab_conf_manager.create_tab_conf_manager( session_key, splunk_uri, builder_constant.ADDON_BUILDER_APP_NAME) self.engine = Engine(splunk_uri, session_key) self.engine.start() self.ta_folder = None
def __init__(self, appname, uri, session_key, service_with_tab_context=None, service_with_ta_context=None): self.__appname = appname self.__logger = logger.get_generator_logger() self.__parent_dir = os.path.split(os.path.realpath(__file__))[0] self.__resource_dir = os.path.join(self.__parent_dir, "resources") self.__resource_lib_dir = os.path.join(self.__parent_dir, "resources_lib") self.__splunk_home = os.environ['SPLUNK_HOME'] self.__splunk_app_dir = os.path.join(self.__splunk_home, "etc", "apps") if service_with_tab_context: self.__service_with_tab_context = service_with_tab_context else: self.__service_with_tab_context = common_util.create_splunk_service( session_key, uri) if service_with_ta_context: self.__service_with_ta_context = service_with_ta_context else: self.__service_with_ta_context = common_util.create_splunk_service( session_key, uri, self.__appname) self.__splunk_uri = uri self.__session_key = session_key self.__current_ta_dir = os.path.join(self.__splunk_app_dir, self.__appname) self.__asset_generator = ta_static_asset_generator.AssetGenerator( self.__resource_dir, self.__current_ta_dir, self.__resource_lib_dir) self._basic_meta = ta_basic_meta.TABasicMeta( self.__appname, self.__service_with_tab_context)
def gen_test_id(self, action, **params): 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) 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)) meta = 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) meta = input_builder.get_dry_run_job_id(meta) return self.render_json(meta)
def upload_sample_file(self, action, **params): try: sample_file = params['sample_file'] sample_source_name = sample_file.filename sample_sourcetype = params['sourcetype'] # put the sample file to the tmp directory temp_mgr = temp_manager.TempManager() ts = int(time.time()) rn = random.randint(0, 100) sample_file_name = 'sample_{}_{}.txt'.format(ts, rn) temp_mgr.create_temp_file(sample_file_name) with open(temp_mgr.get_full_path(sample_file_name), 'w') as sf: while True: data = sample_file.file.read(8192) if not data: break sf.write(data.decode()) # upload the events to index service = common_util.create_splunk_service( cherrypy.session.get("sessionKey"), scc.getMgmtUri()) main_idx = service.indexes['add_on_builder_index'] upload_args = { 'sourcetype': sample_sourcetype, 'rename-source': sample_source_name } main_idx.upload(temp_mgr.get_full_path(sample_file_name), **upload_args) logger.info( 'upload sample file: {0} to index: {1}, sourcetype: {2}, source:{3}' .format(temp_mgr.get_full_path(sample_file_name), 'main', sample_sourcetype, sample_source_name)) return self.render_json({ 'temp_sample_file': sample_file_name, 'sample_source_name': sample_source_name, 'status': 'success' }) except Exception as e: logger.error('fail to upload sample:' + traceback.format_exc()) return self.render_json({ 'err_code': 1001, 'err_args': { 'err_msg': traceback.format_exc() } })
def get_current_creating_app(params={}): if 'appname' in params: app_name = params['appname'] else: session = cherrypy.session.get("sessionKey") uri = scc.getMgmtUri() service = common_util.create_splunk_service(session, uri) installed_apps = [app.name for app in service.apps if app.name] conf_manager = common_util.create_conf_mgr(session, uri) current_creating_app = conf_manager.get_conf( tabuilder_status_conf).get(create_ta_stanza).get(cca_key, None) if current_creating_app in installed_apps: app_name = current_creating_app else: app_name = builder_constant.ADDON_BUILDER_APP_NAME return app_name
def get_inputs_summary(self, action, **params): session_key = cherrypy.session.get("sessionKey") splunkd_uri = scc.getMgmtUri() service = common_util.create_splunk_service(session_key, splunkd_uri) tabuilder = builder.TABuilder(controller_util.get_current_ta_project(), splunkd_uri, session_key, service) all_inputs = tabuilder.get_all_TA_inputs() or [] search_result = search_util.get_sourcetype_from_index(service) sourcetypes_totalcount = {entry['sourcetype']: entry['totalCount'] for entry in search_result} for _input in all_inputs: _input['sample_count'] = sourcetypes_totalcount.get( _input['sourcetype'], 0) # get the code for customized modinput input_codes = tabuilder.get_customized_data_input_code(all_inputs) for _input in all_inputs: if _input['name'] in input_codes: _input['code'] = input_codes[_input['name']] return self.render_json(all_inputs)
def __init__(self, splunk_uri, splunk_session_key, app_name, service): ''' the conf manager should be in the context of app_name! ''' self.logger = logger.get_builder_util_logger() self.app_name = app_name self.conf_mgr = common_util.create_conf_mgr(splunk_session_key, splunk_uri, app_name) self.default_kv = {} self.default_value_sets = ( {1, "1", "t", "true", 'y', 'yes'}, # true set {0, "0", "f", "false", "n", "no"}, # false set {None, "none", ""}, # None set ) if service: self.service = service else: self.service = common_util.create_splunk_service( splunk_session_key, splunk_uri, app_name)
def apps_delete(self, **params): session = cherrypy.session.get("sessionKey") splunk_uri = scc.getMgmtUri() cl = cherrypy.request.headers["Content-Length"] raw_body = cherrypy.request.body.read(int(cl)) app_context = json.loads(raw_body) to_be_deleted_apps = app_context.get("names", []) deleted_apps = [] current_app = None service = common_util.create_splunk_service(session, splunk_uri) try: while len(to_be_deleted_apps) > 0: current_app = to_be_deleted_apps.pop() if meta_util.is_app_created_by_aob(service, current_app): app_util.delete_app(service, current_app, splunk_uri, session) deleted_apps.append(current_app) else: raise RuntimeError() common_util.reload_splunk_apps(service) logger.info("TA %s has been successfully deleted", ', '.join(deleted_apps)) return self.render_json({"result": "success"}) except Exception as e: logger.error('Fail to delete app %s. %s', current_app, traceback.format_exc()) if len(deleted_apps) > 0: common_util.reload_splunk_apps(service) return self.render_json({ 'err_code': 60, 'err_args': { 'current_app': current_app, 'deleted_apps': deleted_apps }, 'deleted_app_list': deleted_apps })
def execute(self, validation_context): self.splunk_endpoint = validation_context.get_splunk_endpoint() self.splunk_session_key = validation_context.get_splunk_session_key() self.service = common_util.create_splunk_service( self.splunk_session_key, self.splunk_endpoint) self.app_name = validation_context.get_global_property("app_name") # self.conf_mgr = common_util.create_conf_mgr(self.splunk_session_key, self.splunk_endpoint, self.app_name) self.tab_conf_mgr = tab_conf_manager.TabConfMgr( self.splunk_endpoint, self.splunk_session_key, self.app_name, service=None) self.ta_builder_conf_mgr = common_util.create_conf_mgr( self.splunk_session_key, self.splunk_endpoint, app=TA_BUILDER_APP_NAME) self.vid = validation_context.get_job_id() self.temp_mgr = TempManager() validation_utility.unlock_props(self.app_name)
def __init__(self, appname, uri=None, session_key=None, service_with_tab_context=None): if common_util.contain_reserved_chars(appname): ce = CommonException() ce.set_err_code(2015) raise ce self.__splunk_uri = uri self.__splunk_session_key = session_key self.__appname = appname self.__logger = logger.get_generator_logger() self.__parent_dir = os.path.split(os.path.realpath(__file__))[0] self.__resource_dir = os.path.join(self.__parent_dir, "resources") self.__resource_lib_dir = os.path.join(self.__parent_dir, "resources_lib") self.__splunk_home = os.environ['SPLUNK_HOME'] self.__splunk_app_dir = os.path.join(self.__splunk_home, "etc", "apps") if service_with_tab_context: self.__service_with_tab_context = service_with_tab_context else: self.__service_with_tab_context = common_util.create_splunk_service( session_key, uri, builder_constant.ADDON_BUILDER_APP_NAME) self.__service_with_ta_context = common_util.create_splunk_service( session_key, uri, self.__appname) self.__basic_builder = TABasicBuilder(self.__appname, uri, session_key, self.__service_with_tab_context, self.__service_with_ta_context) self.__input_builder = TAInputBuilder(self.__appname, uri, session_key, self.__service_with_tab_context, self.__service_with_ta_context) self.__cim_builder = TACIMBuilder(self.__appname, uri, session_key, self.__service_with_tab_context, self.__service_with_ta_context) self.__st_builder = TASourcetypeBuilder( appname, uri, session_key, self.__service_with_tab_context, self.__service_with_ta_context) self.__extraction_builder = TAExtractionBuilder( uri, session_key, appname, self.__service_with_tab_context, self.__service_with_ta_context) self.__alert_builder = TAAlertBuilder(self.__appname, uri, session_key, self.__service_with_tab_context, self.__service_with_ta_context) self.__ta_configuration_builder = TAConfigurationBuilder( self.__appname, self.__service_with_tab_context, self.__service_with_ta_context) self.__tab_conf_mgr = tab_conf_manager.create_tab_conf_manager( session_key, uri, appname) self.__builder_name_const = { 'BASIC_BUILDER': 'BASIC_BUILDER', 'INPUT_BUILDER': 'INPUT_BUILDER', 'SETUP_BUILDER': 'SETUP_BUILDER', 'CIM_BUILDER': 'CIM_BUILDER' } self.__basic_builder_meta_mgr = meta_manager.create_meta_manager( session_key, uri, meta_const.BASIC_BUILDER, self.__appname) self.__inputs_builder_meta_mgr = meta_manager.create_meta_manager( session_key, uri, meta_const.DATA_INPUT_BUILDER, self.__appname) self.__field_extract_builder_meta_mgr = meta_manager.create_meta_manager( session_key, uri, meta_const.FIELD_EXTRACT_BUILDER, self.__appname) self.__input_builder.set_alert_builder(self.__alert_builder) self.__upgrade_methods = { '1.0.1': { 'function': 'upgrade_from_1_0_1_to_1_1_0', 'next': '1.1.0' }, '1.1.0': { 'function': 'upgrade_from_1_1_0_to_2_0_0', 'next': '2.0.0' }, '2.0.0': { 'function': 'upgrade_from_2_0_0_to_2_1_0', 'next': '2.1.0' }, '2.1.0': { 'function': 'upgrade_from_2_1_0_to_2_1_1', 'next': '2.1.1' }, '2.1.1': { 'function': 'upgrade_from_2_1_1_to_2_1_2', 'next': '2.1.2' }, '2.1.2': { 'function': 'upgrade_from_2_1_2_to_2_2_0', 'next': '2.2.0' }, '2.2.0': { 'function': 'upgrade_from_2_2_0_to_3_0_0', 'next': '3.0.0' } }
def update_TA_name(self, meta): """ param: meta is the basic project info meta when renaming the add-on. Try to provide rollback machnism """ self._validation_project_basic_meta(meta) curdir = self.__basic_builder.get_current_ta_dir() bak_dir = os.path.join(tempfile.mkdtemp(), self.__appname + '.bak') new_name = meta["appname"] new_dir = os.path.join(self.__splunk_app_dir, new_name) if os.path.isdir(new_dir): # do not put this into the try. Because no need to revert raise CommonException( err_code=71, options={'new_name': new_name}, e_message="App directory {0} exists.".format(new_name)) try: # back up the current ta if os.path.isdir(bak_dir): shutil.rmtree(bak_dir) shutil.copytree(curdir, bak_dir) # before renaming, should clean up the UCC resources, # because there is app name in the rest hanlder prefix, # this will change self.__ta_configuration_builder.delete_ta_configuration_resources() # begin to rename the app shutil.copytree(curdir, new_dir) common_util.delete_app(self.__service_with_tab_context, self.__appname) meta_manager.MetaManager.rename_app( self.__service_with_tab_context, self.__appname, new_name) # need to load the new app before generate the UCC resources common_util.reload_splunk_apps(self.__service_with_tab_context) new_ta_service = common_util.create_splunk_service( self.__splunk_session_key, self.__splunk_uri, new_name) new_basic_builder = TABasicBuilder(new_name, self.__splunk_uri, self.__splunk_session_key, self.__service_with_tab_context, new_ta_service) new_datainput_builder = TAInputBuilder( new_name, self.__splunk_uri, self.__splunk_session_key, self.__service_with_tab_context, new_ta_service) new_configuration_builder = TAConfigurationBuilder( new_name, self.__service_with_tab_context, new_ta_service) # data input builder needs to update the libs and declare files new_datainput_builder.on_rename_add_on(self.__appname) # UCC page contains the app name in the rest endpoint new_configuration_builder.on_rename_add_on(self.__appname) # should update the app.conf and default.xml # this should happens at the last step, update the basic meta after # the ucc and inputs migration success globalsetting_enabled = not ( not new_configuration_builder.get_global_settings()) has_inputs = not (not new_datainput_builder.get_all_TA_inputs()) new_basic_builder.update_TA_basic( meta, is_setup_page_enabled=(globalsetting_enabled or has_inputs)) except Exception as e: self.__logger.error('Error when renaming TA from %s to %s. %s', self.__appname, new_name, traceback.format_exc()) # try to revert the app if meta_manager.MetaManager.is_app_created_by_aob( self.__service_with_tab_context, new_name): self.__logger.info('rollback the meta of TA %s', self.__appname) meta_manager.MetaManager.rename_app( self.__service_with_tab_context, new_name, self.__appname) if os.path.isdir(bak_dir): if os.path.isdir(curdir): shutil.rmtree(curdir) self.__logger.info('rollback the app dir of TA %s', self.__appname) shutil.copytree(bak_dir, curdir) if os.path.isdir(new_dir): # should clean up the new app folder shutil.rmtree(new_dir) # load the old app common_util.reload_splunk_apps(self.__service_with_tab_context) if isinstance(e, CommonException): raise e else: raise CommonException( err_code=70, options={'app_name': self.__appname}, e_message='error happens when renaming TA:' + self.__appname) finally: if os.path.isdir(bak_dir): self.__logger.info('delete the backup dir:%s', bak_dir) shutil.rmtree(bak_dir)
def create_tab_conf_manager(session_key, uri, appname, max_pool_len=1): s = common_util.create_splunk_service(session_key, uri, appname) m = TabConfMgr(uri, session_key, appname, s) return m
def import_ta_project_package_file(self, action, **params): uri = scc.getMgmtUri() session = cherrypy.session.get("sessionKey") pkg_file = params.get('app_package_file', None) try: if pkg_file is None: raise CommonException( e_message='app_package_file is not in the parameter.', err_code=42) file_name = pkg_file.filename # WINDOWNS will get file_name like: # C:\Users\Administrator\Desktop\TA-t2458_1_0_0_export.tgz file_name = os.path.basename(file_name) full_package_path = AppMigrator.get_import_package_full_path( file_name) if os.path.isfile(full_package_path): os.remove(full_package_path) # must use binary mode to open file. otherwise windows will fail # TAB-1666 with open(full_package_path, 'wb') as tar_f: while True: data = pkg_file.file.read(16384) if not data: break tar_f.write(data) service = create_splunk_service(session, uri) app_brief = AppMigrator.import_project(full_package_path, service) # should align the imported app info with the app_home list app interface version, build = common_util.get_tab_version_and_build(service) app_service = App(app_brief["id"], service) app_tab_version = app_service.get_tabuilder_build() imported_app_info = { 'id': app_brief['id'], 'name': app_brief['name'], 'icon': app_util.get_icon(service, app_brief), 'author': app_brief['author'], 'visible': app_brief['visible'], 'last_modified': time.strftime('%Y/%m/%d', time.gmtime(app_brief['last_modify_time'])), 'version': app_brief['version'], 'create_by_builder': True, "upgrade_info": upgrade_util.get_upgrade_info(app_tab_version, version) } return self.render_json(imported_app_info) except CommonException as ce: logger.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('fail to import TA project. %s', traceback.format_exc()) return self.render_json({'err_code': 77})