Example #1
0
 def __init__(self, service):
     self.service = service
     metas, stanzas = modinput.get_modinput_configs_from_stdin()
     self.metas = metas
     self.stanzas = stanzas
     self._task_configs = self._get_tasks()
     self._handle_hec()
Example #2
0
 def __init__(self, service):
     self.service = service
     metas, stanzas = modinput.get_modinput_configs_from_stdin()
     self.metas = metas
     self.stanzas = stanzas
     self._task_configs = self._get_tasks()
     self._handle_hec()
Example #3
0
def validate_config():
    """
    Validate inputs.conf
    """

    _, configs = modinput.get_modinput_configs_from_stdin()
    return 0
Example #4
0
def create_ta_config(settings, config_cls=TaConfig, log_suffix=None):
    meta_config, configs = modinput.get_modinput_configs_from_stdin()
    if configs and "://" in configs[0].get("name", ""):
        stanza_name = configs[0].get("name").split("://", 1)[1]
    else:
        stanza_name = None
    return config_cls(meta_config, settings, stanza_name, log_suffix)
Example #5
0
def create_ta_config(settings, config_cls=TaConfig, log_suffix=None,
                     single_instance=True):
    meta_config, configs = modinput.get_modinput_configs_from_stdin()
    stanza_name = None
    input_type = None
    if configs and "://" in configs[0].get("name", ""):
        input_type, stanza_name = configs[0].get("name").split("://", 1)
    return config_cls(meta_config, settings, log_suffix, stanza_name,
                      input_type, single_instance=single_instance)
Example #6
0
    def __init__(self):
        metas, stanzas = modinput.get_modinput_configs_from_stdin()
        self.metas = metas
        self.stanzas = stanzas
        self._task_configs = []
        self._server_info = sc.ServerInfo(self.metas[c.server_uri],
                                          self.metas[c.session_key])
        setup_signal_handler(None, self)
        self._servername, self._port = extract_hostname_port(
            self.metas[c.server_uri])

        self._task_configs = self._get_tasks()
Example #7
0
def create_ta_config(settings, config_cls=TaConfig):
    meta_config, _ = modinput.get_modinput_configs_from_stdin()
    return config_cls(meta_config, settings)
Example #8
0
 def __init__(self):
     metas, stanzas = mod.get_modinput_configs_from_stdin()
     self._metas, self._stanzas = metas, stanzas
Example #9
0
def create_kafka_config():
    meta_configs, stanza_configs = modinput.get_modinput_configs_from_stdin()
    return KafkaConfig(meta_configs, stanza_configs)
Example #10
0
def run(ucc_setting):
    """
    Splunk TA Modualr Input entry.
    """
    # Clean http proxy environ
    utils.remove_http_proxy_env_vars()

    # Set log level
    stulog.set_log_level("INFO")

    meta_configs, _ = modinput.get_modinput_configs_from_stdin()
    server_info = sc.ServerInfo(meta_configs["server_uri"],
                                meta_configs["session_key"])

    if server_info.is_shc_member() and not server_info.is_captain():
        # In SHC env, only captain is able to refresh all tokens
        stulog.logger.info("message=\"{title} will exit\" "
                           "detail_info=\"This search header is not captain\""
                           .format(title=ucc_setting["title"]))
        return

    app_name = ssp.get_appname_from_path(
        os.path.abspath(_get_modular_input_file()))
    assert app_name, UCCServerException("app_name is None.")

    ucc_config = UCCConfig(splunkd_uri=meta_configs["server_uri"],
                           session_key=meta_configs["session_key"],
                           schema=json.dumps(ucc_setting["config"]),
                           user="******",
                           app=app_name)
    ucc_config_loader = UCCServerConfigLoader(
        ucc_config,
        id_locator=ucc_setting["meta.id"],
        logging_locator=ucc_setting["meta.logging"],
        local_forwarder_locator=ucc_setting["meta.local_forwarder"],
        forwarders_snapshot_locator=ucc_setting["meta.forwarder_snapshot"],
        dispatch_snapshot_locator=ucc_setting["meta.dispatch_snapshot"])

    ucc_server_id = ucc_config_loader.get_ucc_server_id(create_if_empty=False)
    if not ucc_server_id and not server_info.is_shc_member():
        ucc_config_loader.enable_local_forwarder()

    # force to get again
    ucc_server_id = ucc_config_loader.get_ucc_server_id(create_if_empty=True)
    ucc_server = UCCServer(
        meta_configs["server_uri"],
        meta_configs["session_key"],
        ucc_config_loader.load_ucc_server_input,
        [_get_local_conf_dir() + _file for _file in
         ucc_setting["monitor_file"]],
        ucc_setting["filter"],
        ucc_setting["division"],
        ucc_setting["dispatch"],
        ucc_config_loader.get_forwarders_snapshot,
        ucc_config_loader.update_forwarders_snapshot,
        ucc_config_loader.get_dispatch_snapshot,
        ucc_config_loader.update_dispatch_snapshot,
        ucc_server_id,
        get_log_level_callback=ucc_config_loader.get_ucc_server_log_level)
    # Setup signal handler
    _setup_signal(ucc_server, ucc_setting)
    # Start ucc server
    ucc_server.start()