Exemplo n.º 1
0
    def clean(self, endpoint):
        url = self.make_uri(endpoint) + '?count=-1'
        resp, cont = splunkd_request(url,
                                     self.getSessionKey(),
                                     method='GET',
                                     data={'output_mode': 'json'},
                                     retry=3)
        if resp.status != 200:
            return {url: self.convertErrMsg(cont)}

        cont = json.loads(cont)
        ents = [ent['name'] for ent in cont.get('entry', [])]
        errs = {}
        for ent in ents:
            args = self.getArgs()
            if not self.distinguish(endpoint, ent, **args):
                continue
            url_ent = self.make_uri(endpoint, entry=ent)
            resp, cont = splunkd_request(url_ent,
                                         self.getSessionKey(),
                                         method='DELETE',
                                         data={'output_mode': 'json'},
                                         retry=3)
            if resp.status != 200:
                errs[url_ent] = self.convertErrMsg(cont)
        return errs
    def reload_http_input(self):
        """
        :return: Response object and content
        """

        uri = "{}/servicesNS/-/{}/data/inputs/http/_reload?output_mode=json".format(
            self._conf_mgr.splunkd_uri, "splunk_httpinput")
        sr.splunkd_request(uri, self._conf_mgr.session_key)
Exemplo n.º 3
0
def user_caps(mgmt_uri, session_key):
    """
    Get capabilities of sessioned Splunk user.
    :param mgmt_uri:
    :param session_key:
    :return:
    """
    url = mgmt_uri.strip('/') + '/services/authentication/current-context'

    resp, cont = splunkd_request(url,
                                 session_key,
                                 method='GET',
                                 data={'output_mode': 'json'},
                                 retry=3
                                 )
    if resp is None:
        RH_Err.ctl(500,
                   logLevel=logging.ERROR,
                   msgx='Fail to get capabilities of sessioned user')
    elif resp.status not in (200, '200'):
        RH_Err.ctl(resp.status,
                   logLevel=logging.ERROR,
                   msgx=cont
                   )

    cont = json.loads(cont)
    caps = cont['entry'][0]['content']['capabilities']
    return set(caps)
Exemplo n.º 4
0
    def _do_request(self,
                    uri,
                    method,
                    data=None,
                    content_type="application/x-www-form-urlencoded"):
        headers = {"Content-Type": content_type}

        resp, content = rest.splunkd_request(uri,
                                             self._session_key,
                                             method,
                                             headers,
                                             data,
                                             http=self._http)

        if resp is None and content is None:
            raise KVException("Failed uri={0}, data={1}".format(uri, data))

        if resp.status in (200, 201):
            return content
        elif resp.status == 409:
            raise KVAlreadyExists("{0}-{1} already exists".format(uri, data))
        elif resp.status == 404:
            raise KVNotExists("{0}-{1} not exists".format(uri, data))
        else:
            raise KVException("Failed to {0} {1}, reason={2}".format(
                method, uri, resp.reason))
Exemplo n.º 5
0
def content_request(uri, session_key, method, payload, err_msg):
    """
    :return: response content if successful otherwise raise
    ConfRequestException
    """

    resp, content = rest.splunkd_request(uri,
                                         session_key,
                                         method,
                                         data=payload,
                                         retry=3)
    if resp is None and content is None:
        return None

    if resp.status >= 200 and resp.status <= 204:
        return content
    else:
        msg = "{}, status={}, reason={}, detail={}".format(
            err_msg, resp.status, resp.reason, content)
        logger.error(msg)

        if resp.status == 404:
            raise ConfNotExistsException(msg)
        if resp.status == 409:
            raise ConfExistsException(msg)
        else:
            if content and "already exists" in content:
                raise ConfExistsException(msg)
            raise ConfRequestException(msg)
Exemplo n.º 6
0
def content_request(uri, session_key, method, payload, err_msg):
    """
    :return: response content if successful otherwise raise
    ConfRequestException
    """

    resp, content = rest.splunkd_request(uri, session_key, method,
                                         data=payload, retry=3)
    if resp is None and content is None:
        return None

    if resp.status >= 200 and resp.status <= 204:
        return content
    else:
        msg = "%s, status=%s, reason=%s, detail=%s" % (
            err_msg, resp.status, resp.reason, content.decode('utf-8'))

        if not (method == "GET" and resp.status == 404):
            logger.error(msg)

        if resp.status == 404:
            raise ConfNotExistsException(msg)
        if resp.status == 409:
            raise ConfExistsException(msg)
        else:
            if content and "already exists" in content:
                raise ConfExistsException(msg)
            raise ConfRequestException(msg)
Exemplo n.º 7
0
def content_request(uri, session_key, method, payload, err_msg):
    """
    :return: response content if successful otherwise raise
    ConfRequestException
    """

    resp, content = rest.splunkd_request(uri,
                                         session_key,
                                         method,
                                         data=payload,
                                         retry=3)
    if resp is None and content is None:
        return None

    if resp.status >= 200 and resp.status <= 204:
        return content
    else:
        msg = "{}, status={}, reason={}, detail={}".format(
            err_msg,
            resp.status,
            resp.reason,
            content.decode("utf-8"),
        )

        if not (method == "GET" and resp.status == 404):
            log.logger.error(msg)

        if resp.status == 404:
            raise ConfNotExistsException(msg)
        if resp.status == 409:
            raise ConfExistsException(msg)
        else:
            if content and "already exists" in content:
                raise ConfExistsException(msg)
            raise ConfRequestException(msg)
Exemplo n.º 8
0
def get_global_settings(server_uri,
                        session_key,
                        user="******",
                        app=ggc.splunk_ta_google):
    """
    :param: get global settings for global settings
    :return: a dict of dict which contains global settings .
    """

    url = ("{server_uri}/servicesNS/{user}/{app}/splunk_ta_google"
           "/google_settings?--get-clear-credential--=1").format(
               server_uri=server_uri, user=user, app=app)
    response, content = sr.splunkd_request(url, session_key, method="GET")
    if not response or response.status not in (200, 201):
        raise Exception("Failed to get google global settings."
                        "Check util log for more details %s" % url)
    stanzas = xdp.parse_conf_xml_dom(content)
    settings = {}
    for stanza in stanzas:
        settings[stanza[ggc.name]] = stanza

    if not utils.is_true(settings[ggc.proxy_settings].get(ggc.proxy_enabled)):
        settings[ggc.proxy_settings][ggc.proxy_url] = None

    return settings
Exemplo n.º 9
0
def get_google_creds(server_uri,
                     session_key,
                     user="******",
                     app=ggc.splunk_ta_google,
                     cred_name=""):
    """
    :param: get clear creds for cred_name.
    :return: a dict of dict which contains all creds. if cred_name is in
             (None, ""), return all creds
    """

    if not cred_name:
        cred_name = ""

    url = ("{server_uri}/servicesNS/{user}/{app}/splunk_ta_google"
           "/google_credentials/{name}?--get-clear-credential--=1").format(
               server_uri=server_uri,
               user=user,
               app=app,
               name=urllib.quote(cred_name, safe=''),
           )
    response, content = sr.splunkd_request(url, session_key, method="GET")
    if not response or response.status not in (200, 201):
        raise Exception("Failed to get google credentials for name={}. "
                        "Check util log for more details".format(cred_name))
    stanzas = xdp.parse_conf_xml_dom(content)
    creds = {}
    for stanza in stanzas:
        cred = json.loads(stanza[ggc.google_credentials])
        stanza[ggc.google_credentials] = cred
        creds[stanza[ggc.name]] = stanza
    return creds
Exemplo n.º 10
0
    def _get_credentials(self, prop, name=None):
        """
        :return: clear or encrypted password for specified realm, user
        """

        endpoint = self._get_endpoint(name, True)
        response, content = rest.splunkd_request(
            endpoint,
            self._session_key,
            method="GET")

        if response is None and content is None:
            raise CredException("Failed to get clear credentials")

        results = {}
        if response and response.status in (200, 201) and content:
            passwords = xdp.parse_conf_xml_dom(content)
            for password in passwords:
                if password.get("realm") == self._realm:
                    values = password[prop].split(self._sep)
                    if len(values) % 2 == 1:
                        continue
                    result = {
                        values[i]: values[i + 1]
                        for i in range(0, len(values), 2)
                    }
                    results[password.get("username")] = result
        return results
Exemplo n.º 11
0
    def _do_send_safe(self, clusters, dispatched_tasks, forwarder_stanza,
                      forwarder, settings, localhost):
        session_key = self._get_forwarder_session_key(forwarder)

        if not localhost and c.global_settings in settings["config_settings"]:
            logger.info("Config global settings for forwarder=%s",
                        forwarder[c.hostname])
            uri = ("{}/servicesNS/nobody/{}/kafka_input_setup"
                   "/kafka_settings/kafka_settings")
            url = uri.format(forwarder[c.hostname], self._appname)
            payload = {c.all_settings: json.dumps(settings["config_settings"])}
            resp, content = rest.splunkd_request(url,
                                                 session_key,
                                                 method="POST",
                                                 data=payload)
            if resp is None or resp.status not in (200, 201):
                logger.error(
                    "Failed to update config settings on forwarder=%s",
                    forwarder[c.hostname])
                self._dispatch_errors = True
                return

        conf_mgr = cm.ConfManager(forwarder[c.hostname],
                                  session_key,
                                  app_name=self._appname)
        for name, datainput in settings["data_input_settings"].iteritems():
            res = self._create_or_update(clusters, dispatched_tasks,
                                         forwarder_stanza, datainput, name,
                                         forwarder, conf_mgr)
            if not res:
                self._dispatch_errors = True
Exemplo n.º 12
0
    def get_session_key(username,
                        password,
                        splunkd_uri="https://localhost:8089"):
        """
        Get session key by using login username and passwrod
        :return: session_key if successful, None if failed
        """

        eid = "".join((splunkd_uri, "/services/auth/login"))
        postargs = {"username": username, "password": password, }

        response, content = rest.splunkd_request(
            eid,
            None,
            method="POST",
            data=postargs)

        if response is None and content is None:
            raise CredException("Get session key failed.")

        xml_obj = xdm.parseString(content)
        session_nodes = xml_obj.getElementsByTagName("sessionKey")
        if not session_nodes:
            raise CredException("Invalid username or password.")
        session_key = session_nodes[0].firstChild.nodeValue
        if not session_key:
            raise CredException("Get session key failed.")
        return session_key
Exemplo n.º 13
0
    def _delete(self, name, throw=False):
        """
        Delete the encrypted entry
        """

        endpoint = self._get_endpoint(name)
        response, content = rest.splunkd_request(
            endpoint, self._session_key, method="DELETE")
        if not response or response.status not in (200, 201, "200", "201"):
            if throw:
                raise CredException(
                    "Failed to delete credential stanza {}".format(name))
Exemplo n.º 14
0
    def delete(self, name):
        """
        Delete the encrypted entry
        @return: True for success, False for failure
        """

        endpoint = self._get_endpoint(name)
        response, content = rest.splunkd_request(endpoint,
                                                 self._session_key,
                                                 method="DELETE")
        if response and response.status in (200, 201):
            return True
        return False
Exemplo n.º 15
0
 def handleRemove(self, confInfo):
     try:
         for ep in self._depended_endpoints:
             url = self.make_endpoint_url(ep.get('endpoint'))
             resp, cont = splunkd_request(url,
                                          self.getSessionKey(),
                                          data={'output_mode': 'json'})
             if resp.status not in (200, '200'):
                 raise Exception(cont)
             res = json.loads(cont)
             self.check_entries(ep, res['entry'])
     except Exception, exc:
         RH_Err.ctl(1105, exc)
Exemplo n.º 16
0
    def delete(self, name, throw=False):
        """
        Delete the encrypted entry
        """

        endpoint = self._get_endpoint(name)
        response, content = rest.splunkd_request(endpoint,
                                                 self._session_key,
                                                 method="DELETE")
        if not response or response not in (200, 201):
            if throw:
                raise CredException(
                    "Failed to delete credential stanza {}".format(name))
Exemplo n.º 17
0
def _do_rest(uri, session_key):
    resp, content = rest.splunkd_request(uri, session_key)
    if resp is None:
        return None

    if resp.status not in (200, 201):
        return None

    stanza_objs = xdp.parse_conf_xml_dom(content)
    if not stanza_objs:
        return None

    return stanza_objs[0]
def load_config(url, session_key, config_label):
    """
    Get AWS configuration.

    :param url:
    :param session_key:
    :param config_label:
    :return:
    """
    resp, cont = splunkd_request(url, session_key, retry=3)
    if resp is None or resp.status not in (200, '200'):
        raise Exception('Fail to load %s - %s' % (config_label, cont))
    cont = json.loads(cont)
    return {ent['name']: ent['content'] for ent in cont['entry']}
Exemplo n.º 19
0
def _content_request(uri, session_key, method, payload, err_msg):
    resp, content = rest.splunkd_request(uri,
                                         session_key,
                                         method,
                                         data=payload,
                                         retry=3)
    if resp is None and content is None:
        return None

    if resp.status >= 200 and resp.status <= 204:
        return content
    else:
        _LOGGER.error("%s, reason=%s", err_msg, resp.reason)
    return None
Exemplo n.º 20
0
 def _do_update(self, name, password):
     try:
         self._create(name, password)
     except CredException:
         payload = {"password": password}
         endpoint = self._get_endpoint(name)
         response, _ = rest.splunkd_request(endpoint,
                                            self._session_key,
                                            method="POST",
                                            data=payload)
         if not response or response.status not in (200, 201):
             raise CredException(
                 "Unable to update password for username={}, status={}".
                 format(name, response.status))
    def _do_request(self, uri, method, payload, err_msg):
        resp, content = rest.splunkd_request(uri,
                                             self.session_key,
                                             method,
                                             data=payload,
                                             retry=3)
        if resp is None and content is None:
            return None

        if resp.status in (200, 201):
            return content
        else:
            _LOGGER.debug("%s, reason=%s", err_msg, resp.reason)
        return None
    def clean(self, endpoint):
        url = self.make_uri(endpoint) + "?count=-1"
        resp, cont = splunkd_request(
            url,
            self.getSessionKey(),
            method="GET",
            data={"output_mode": "json"},
            retry=3,
        )

        if resp is None:
            return {url: "Unknown reason"}
        if resp.status != 200:
            return {url: self.convertErrMsg(cont)}

        cont = json.loads(cont)
        ents = [ent["name"] for ent in cont.get("entry", [])]
        errs = {}
        for ent in ents:
            args = self.getArgs()
            if not self.distinguish(endpoint, ent, **args):
                continue
            url_ent = self.make_uri(endpoint, entry=ent)
            resp, cont = splunkd_request(
                url_ent,
                self.getSessionKey(),
                method="DELETE",
                data={"output_mode": "json"},
                retry=3,
            )

            if resp is None:
                errs[url_ent] = "Unknown reason"
            if resp.status != 200:
                errs[url_ent] = self.convertErrMsg(cont)
        return errs
Exemplo n.º 23
0
def get_default_metric_names(config, namespace):
    # Get default metric names for standard namespace
    url = ("{server_uri}/servicesNS/-/-/splunk_ta_aws/"
           "splunk_ta_aws_cloudwatch_default_settings?namespace={namespace}&"
           "output_mode=json").format(server_uri=config["server_uri"],
                                      namespace=namespace)
    response, content = sr.splunkd_request(url, config[tac.session_key])
    if not response or response.status not in (200, 201):
        return None

    content = json.loads(content)
    metrics = json.loads(content["entry"][0]["content"]["metrics"])
    logger.info("Got default metric_names=%s for namespace=%s", metrics,
                namespace)
    return metrics
Exemplo n.º 24
0
    def delete(self, name):
        """
        Delete the encrypted entry
        @return: True for success, False for failure
        """

        allpwd = self.get_all_passwords()
        if name in [pw.get("username") for pw in allpwd]:
            endpoint = self._get_endpoint(name)
            response, content = rest.splunkd_request(endpoint,
                                                     self._session_key,
                                                     method="DELETE")
            if response and response.status in (200, 201):
                return True
        return False
Exemplo n.º 25
0
    def getProxyInfo(self, splunkdMgmtUri, sessionKey, user, app):
        """
        Get Proxy Information on given REST endpoint.
        It should be in form (if not, override the this method):
            {
               'proxy_url': '<proxy_url>',
               'proxy_port': '<proxy_port>',
               'proxy_username': '******',
               'proxy_password': '******',
               'proxy_enabled': '<proxy_enabled>',
               'proxy_rdns': '<proxy_rdns>',
               'proxy_type': '<proxy_type>'
            }
        :return:
        """
        if not self.proxyInfoEndpoint:
            RH_Err.ctl(1104, msgx="Empty endpoint for proxy is being used")
        url = "{splunkdMgmtUri}servicesNS/{user}/{app}/{proxyInfoEndpoint}".format(
            splunkdMgmtUri=splunkdMgmtUri,
            user=user,
            app=app,
            proxyInfoEndpoint=self.proxyInfoEndpoint,
        )
        data = {"output_mode": "json", "--get-clear-credential--": "1"}
        resp, cont = splunkd_request(url, sessionKey, data=data, retry=3)
        if resp is None or resp.status != 200:
            RH_Err.ctl(
                1104,
                msgx="failed to load proxy info. {err}".format(
                    err=code_to_msg(resp, cont) if resp else cont
                ),
            )

        try:
            proxy_info = json.loads(cont)["entry"][0]["content"]
        except IndexError | KeyError:
            proxy_info = {}

        return {
            "proxy_enabled": is_true(proxy_info.get("proxy_enabled", "false")),
            "proxy_url": proxy_info.get("proxy_url", ""),
            "proxy_port": proxy_info.get("proxy_port", ""),
            "proxy_username": proxy_info.get("proxy_username", ""),
            "proxy_password": proxy_info.get("proxy_password", ""),
            "proxy_rdns": proxy_info.get("proxy_rdns", "false"),
            "proxy_type": proxy_info.get("proxy_type", "http"),
        }
Exemplo n.º 26
0
    def load(self):
        """Load Configurations in UCC according to the schema
        It will raise exception if failing to load any endpoint,
        because it make no sense with not complete configuration info.
        """
        log('"load" method in', level=logging.DEBUG)

        ret = {
            meta_field: getattr(self, meta_field)
            for meta_field in Config.META_FIELDS
        }

        for ep_id, ep in self._endpoints.items():
            data = {"output_mode": "json", "--cred--": "1"}

            retries = 4
            waiting_time = [1, 2, 2]
            for retry in range(retries):
                resp, cont = splunkd_request(
                    splunkd_uri=self.make_uri(ep_id),
                    session_key=self.session_key,
                    data=data,
                    retry=3,
                )

                if resp is None or resp.status != 200:
                    msg = 'Fail to load endpoint "{ep_id}" - {err}' "".format(
                        ep_id=ep_id,
                        err=code_to_msg(resp, cont) if resp else cont)
                    log(msg, level=logging.ERROR, need_tb=True)
                    raise ConfigException(msg)

                try:
                    ret[ep_id] = self._parse_content(ep_id, cont)
                except ConfigException as exc:
                    log(exc, level=logging.WARNING, need_tb=True)
                    if retry < retries - 1:
                        time.sleep(waiting_time[retry])
                else:
                    break
            else:
                log(exc, level=logging.ERROR, need_tb=True)
                raise exc

        log('"load" method out', level=logging.DEBUG)
        return ret
Exemplo n.º 27
0
    def _create(self, name, str_to_encrypt):
        """
        Create a new stored credential.
        :return: raise on failure
        """

        payload = {
            "name": name,
            "password": str_to_encrypt,
            "realm": self._realm,
        }

        endpoint = self._get_endpoint(name)
        resp, content = rest.splunkd_request(endpoint, self._session_key,
                                             method="POST", data=payload)
        if not resp or resp.status not in (200, 201, "200", "201"):
            raise CredException("Failed to encrypt username {}".format(name))
Exemplo n.º 28
0
    def _get_all_passwords(self):
        """
        :return: a list of dict when successful, None when failed.
        the dict at least contains
        {
            "realm": xxx,
            "username": yyy,
            "clear_password": zzz,
        }
        """

        endpoint = self._get_endpoint()
        response, content = rest.splunkd_request(
            endpoint, self._session_key, method="GET")
        if response and response.status in (200, 201, "200", "201") and content:
            return xdp.parse_conf_xml_dom(content)
        raise CredException("Failed to get credentials")
Exemplo n.º 29
0
    def get_all_passwords(self):
        """
        @return: a list of dict when successful, None when failed.
        the dict at least contains
        {
            "realm": xxx,
            "username": yyy,
            "clear_password": zzz,
        }
        """

        endpoint = "{}/services/storage/passwords".format(self._splunkd_uri)
        response, content = rest.splunkd_request(endpoint,
                                                 self._session_key,
                                                 method="GET")
        if response and response.status in (200, 201) and content:
            return xdp.parse_conf_xml_dom(content)
Exemplo n.º 30
0
    def _do_request(self, uri, method, data=None,
                    content_type="application/x-www-form-urlencoded"):
        headers = {"Content-Type": content_type}

        resp, content = rest.splunkd_request(uri, self._session_key,
                                             method, headers, data)
        if resp is None and content is None:
            raise KVException("Failed uri={0}, data={1}".format(uri, data))

        if resp.status in (200, 201):
            return content
        elif resp.status == 409:
            raise KVAlreadyExists("{0}-{1} already exists".format(uri, data))
        elif resp.status == 404:
            raise KVNotExists("{0}-{1} not exists".format(uri, data))
        else:
            raise KVException("Failed to {0} {1}, reason={2}".format(
                method, uri, resp.reason))
    def _get_all_passwords(self):
        """
        :return: a list of dict when successful, None when failed.
        the dict at least contains
        {
            "realm": xxx,
            "username": yyy,
            "clear_password": zzz,
        }
        """

        endpoint = self._get_endpoint()
        response, content = rest.splunkd_request(
            endpoint, self._session_key, method="GET"
        )
        if response and response.status in (200, 201, "200", "201") and content:
            return xdp.parse_conf_xml_dom(content)
        raise CredException("Failed to get credentials")
    def _create(self, name, str_to_encrypt):
        """
        Create a new stored credential.
        :return: raise on failure
        """

        payload = {
            "name": name,
            "password": str_to_encrypt,
            "realm": self._realm,
        }

        endpoint = self._get_endpoint(name)
        resp, content = rest.splunkd_request(
            endpoint, self._session_key, method="POST", data=payload
        )
        if not resp or resp.status not in (200, 201, "200", "201"):
            raise CredException("Failed to encrypt username {}".format(name))
Exemplo n.º 33
0
    def _delete(self, name, throw=False):
        """
        Delete the encrypted entry
        """

        endpoint = self._get_endpoint(name)
        response, content = rest.splunkd_request(endpoint,
                                                 self._session_key,
                                                 method="DELETE")

        if response is not None and response.status in (404, "404"):
            if throw:
                raise CredNotFound(
                    "Credential stanza not exits - {}".format(name))
        elif not response or response.status not in (200, 201, "200", "201"):
            if throw:
                raise CredException(
                    "Failed to delete credential stanza {}".format(name))
Exemplo n.º 34
0
    def getProxyInfo(self, splunkdMgmtUri, sessionKey, user, app):
        """
        Get Proxy Information on given REST endpoint.
        It should be in form (if not, override the this method):
            {
               'proxy_url': '<proxy_url>',
               'proxy_port': '<proxy_port>',
               'proxy_username': '******',
               'proxy_password': '******',
               'proxy_enabled': '<proxy_enabled>',
               'proxy_rdns': '<proxy_rdns>',
               'proxy_type': '<proxy_type>'
            }
        :return:
        """
        if not self.proxyInfoEndpoint:
            RH_Err.ctl(1104, msgx='Empty endpoint for proxy is being used')
        url = "{splunkdMgmtUri}servicesNS/{user}/{app}/{proxyInfoEndpoint}"\
            .format(splunkdMgmtUri=splunkdMgmtUri,
                    user=user,
                    app=app,
                    proxyInfoEndpoint=self.proxyInfoEndpoint)
        data = {'output_mode': 'json', '--get-clear-credential--': '1'}
        resp, cont = splunkd_request(url, sessionKey, data=data, retry=3)
        if resp is None or resp.status != 200:
            RH_Err.ctl(1104,
                       msgx='failed to load proxy info. {err}'.format(
                           err=code_to_msg(resp, cont) if resp else cont))

        try:
            proxy_info = json.loads(cont)['entry'][0]['content']
        except IndexError | KeyError:
            proxy_info = {}

        return {
            'proxy_enabled': is_true(proxy_info.get('proxy_enabled', 'false')),
            'proxy_url': proxy_info.get('proxy_url', ''),
            'proxy_port': proxy_info.get('proxy_port', ''),
            'proxy_username': proxy_info.get('proxy_username', ''),
            'proxy_password': proxy_info.get('proxy_password', ''),
            'proxy_rdns': proxy_info.get('proxy_rdns', 'false'),
            'proxy_type': proxy_info.get('proxy_type', 'http')
        }
def reload_confs(confs,
                 session_key,
                 splunkd_uri="https://localhost:8089",
                 appname="-"):
    new_confs = []
    for conf in confs:
        conf = op.basename(conf)
        if conf.endswith(".conf"):
            conf = conf[:-5]
            new_confs.append(conf)
        else:
            new_confs.append(conf)

    endpoint_template = "{0}/servicesNS/-/{1}/configs/conf-{2}/_reload"
    for conf in new_confs:
        endpoint = endpoint_template.format(splunkd_uri, appname, conf)
        resp, _ = rest.splunkd_request(endpoint, session_key)
        if not resp or resp.status not in (200, 201):
            _LOGGER.error("Failed to refresh %s, reason=%s", endpoint,
                          resp.reason if resp else "")
Exemplo n.º 36
0
def user_caps(mgmt_uri, session_key):
    """
    Get capabilities of sessioned Splunk user.
    :param mgmt_uri:
    :param session_key:
    :return:
    """
    url = mgmt_uri + "/services/authentication/current-context"

    resp = splunkd_request(
        url, session_key, method="GET", data={"output_mode": "json"}, retry=3
    )
    if resp is None:
        RH_Err.ctl(500, logging.ERROR, "Fail to get capabilities of sessioned user")
    elif resp.status_code != 200:
        RH_Err.ctl(resp.status_code, logging.ERROR, resp.text)

    cont = resp.json()
    caps = cont["entry"][0]["content"]["capabilities"]
    return set(caps)