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