def get_client(self, args, debug=False): ST2_CLI_SKIP_CONFIG = os.environ.get('ST2_CLI_SKIP_CONFIG', 0) ST2_CLI_SKIP_CONFIG = int(ST2_CLI_SKIP_CONFIG) skip_config = args.skip_config skip_config = skip_config or ST2_CLI_SKIP_CONFIG # Note: Options provided as the CLI argument have the highest precedence # Precedence order: cli arguments > environment variables > rc file variables cli_options = ['base_url', 'auth_url', 'api_url', 'api_version', 'cacert'] cli_options = {opt: getattr(args, opt) for opt in cli_options} config_file_options = self._get_config_file_options(args=args) kwargs = {} if not skip_config: # Config parsing is skipped kwargs = merge_dicts(kwargs, config_file_options) kwargs = merge_dicts(kwargs, cli_options) kwargs['debug'] = debug client = Client(**kwargs) if ST2_CLI_SKIP_CONFIG: # Config parsing is skipped LOG.info('Skipping parsing CLI config') return client # If credentials are provided in the CLI config use them and try to authenticate rc_config = self._parse_config_file(args=args) credentials = rc_config.get('credentials', {}) username = credentials.get('username', None) password = credentials.get('password', None) cache_token = rc_config.get('cli', {}).get('cache_token', False) if username and password: # Credentials are provided, try to authenticate agaist the API try: token = self._get_auth_token(client=client, username=username, password=password, cache_token=cache_token) except requests.exceptions.ConnectionError as e: LOG.warn('Auth API server is not available, skipping authentication.') LOG.exception(e) return client except Exception as e: print('Failed to authenticate with credentials provided in the config.') raise e client.token = token # TODO: Hack, refactor when splitting out the client os.environ['ST2_AUTH_TOKEN'] = token return client
def test_args(self): base_url = 'http://www.stackstorm.com' api_url = 'http://www.st2.com:9101/v1' stream_url = 'http://www.st2.com:9102/v1' client = Client(base_url=base_url, api_url=api_url, stream_url=stream_url) endpoints = client.endpoints self.assertEqual(endpoints['base'], base_url) self.assertEqual(endpoints['api'], api_url) self.assertEqual(endpoints['stream'], stream_url)
def run(self, deviceIP, cmd_path, subnet, nextHop): cmd_path = cmd_path[:26] subnet = subnet.replace("/", "%2F") # Fetching device credentials based on keys derived from deviceIP ################################################################# user_key_name = deviceIP + "_user" pswd_key_name = deviceIP + "_pswd" print("\n") print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") print("Looking for credentials in KV store") client = Client() try: user = (client.keys.get_by_name(user_key_name)).value pswd = (client.keys.get_by_name(pswd_key_name)).value print(" Obtained from KV store: user = "******" Obtained from KV store: pswd = " + pswd) except Exception: return (False, "No credentials for : " + deviceIP) # Preapring the URL request(s) ################################################################# h = { "accept": "application/json", "content-length": "0" } url_0 = "https://" + deviceIP + "/" + cmd_path url_1 = "/set/protocols/static/route/" + subnet url_2 = "/next-hop/" + nextHop url = url_0 + url_1 + url_2 # Sending the URL call(s) ################################################################# print("Sending REST call(s):") with warnings.catch_warnings(): warnings.simplefilter("ignore") print(" PUT " + url) r = requests.put(url, auth=(user, pswd), headers=h, verify=False) r_code = str(r.status_code) print(" Response code: " + r_code) cmd_response_code = int(r.status_code) if cmd_response_code != 200: return (False, cmd_response_code) else: try: data = json.loads(r.text) print(" Response body: ") print(json.dumps(data, sort_keys=True, indent=4)) except Exception: print(" Response body: empty") print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def test_env_base_only(self): base_url = 'http://www.stackstorm.com' api_url = 'http://www.stackstorm.com:9101' os.environ['ST2_BASE_URL'] = base_url self.assertEqual(os.environ.get('ST2_BASE_URL'), base_url) self.assertEqual(os.environ.get('ST2_API_URL'), None) client = Client() endpoints = client.endpoints self.assertEqual(endpoints['base'], base_url) self.assertEqual(endpoints['api'], api_url)
def get_api_client(self): """ Retrieve API client instance. """ if not self._client: self._logger.debug('Creating new Client object.') api_url = get_full_public_api_url() client = Client(api_url=api_url, token=self._auth_token) self._client = client return self._client
def test_managers(self): property_names = [ k for k, v in six.iteritems(Client.__dict__) if isinstance(v, property) ] client = Client() for property_name in property_names: manager = getattr(client, property_name, None) self.assertIsNotNone(manager) self.assertIsInstance(manager, models.ResourceManager)
def __init__(self, config=None, action_service=None): super(FormatResultAction, self).__init__(config=config, action_service=action_service) api_url = os.environ.get('ST2_ACTION_API_URL', None) token = os.environ.get('ST2_ACTION_AUTH_TOKEN', None) self.client = Client(api_url=api_url, token=token) self.jinja = jinja_utils.get_jinja_environment(allow_undefined=True) self.jinja.tests['in'] = lambda item, list: item in list path = os.path.dirname(os.path.realpath(__file__)) with open(os.path.join(path, 'templates/default.j2'), 'r') as f: self.default_template = f.read()
def run(self, deviceIP, targetIP): # Fetching device credentials based on keys derived from deviceIP ################################################################# user_key_name = deviceIP + "_user" pswd_key_name = deviceIP + "_pswd" print "\n" print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" print "Looking for credentials in KV store" client = Client() try: user = (client.keys.get_by_name(user_key_name)).value pswd = (client.keys.get_by_name(pswd_key_name)).value print " Obtained from KV store: user = "******" Obtained from KV store: pswd = " + pswd except: return (False, "No credentials for : " + deviceIP) # Preapring the URL request(s) ################################################################# h = { "accept": "application/json", "content-length": "0" } url_base = "https://" + deviceIP + "/rest/op/" url = url_base + "ping/" + targetIP # Sending the URL call(s) ################################################################# print "Sending REST call(s):" print " POST " + url with warnings.catch_warnings(): warnings.simplefilter("ignore") r = requests.post(url, auth=(user, pswd), headers=h, verify=False) r_code = str(r.status_code) print " Response code: " + r_code if r.status_code == 201: cmd_path = r.headers["Location"] url = "https://" + deviceIP + "/" + cmd_path time.sleep(2) print " GET " + url with warnings.catch_warnings(): warnings.simplefilter("ignore") r2 = requests.get(url, auth=(user, pswd), headers=h, verify=False) output_response_code = str(r2.status_code) print " Response code: " + output_response_code print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" print"\n" if r2.status_code == 200: print r2.text print("\n")
def test_args(self): base_url = "http://www.stackstorm.com" api_url = "http://www.st2.com:9101/v1" stream_url = "http://www.st2.com:9102/v1" client = Client(base_url=base_url, api_url=api_url, stream_url=stream_url) endpoints = client.endpoints self.assertEqual(endpoints["base"], base_url) self.assertEqual(endpoints["api"], api_url) self.assertEqual(endpoints["stream"], stream_url)
def _get_api_client(self): """ Retrieve API client instance. """ if not self._client: ttl = (24 * 60 * 60) temporary_token = create_token(username=self._api_username, ttl=ttl) api_url = get_full_public_api_url() self._client = Client(api_url=api_url, token=temporary_token.token) return self._client
def run(self, deviceIP, cmd_path, fw_instance_name, intfNum, direction): cmd_path = cmd_path[:26] # Fetching device credentials based on keys derived from deviceIP ################################################################# user_key_name = deviceIP + "_user" pswd_key_name = deviceIP + "_pswd" print "\n" print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" print "Looking for credentials in KV store" client = Client() try: user = (client.keys.get_by_name(user_key_name)).value pswd = (client.keys.get_by_name(pswd_key_name)).value print " Obtained from KV store: user = "******" Obtained from KV store: pswd = " + pswd except: return (False, "No credentials for : " + deviceIP) # Preapring the URL request(s) ################################################################# h = { "accept": "application/json", "content-length": "0" } url_0 = "https://" + deviceIP + "/" + cmd_path url_1 = "/set/interfaces/dataplane/" + intfNum url_2 = "/firewall/" + direction + "/" + fw_instance_name url = url_0 + url_1 + url_2 # Sending the URL call(s) ################################################################# print "Sending REST call(s):" with warnings.catch_warnings(): warnings.simplefilter("ignore") print " PUT " + url r = requests.put(url, auth=(user, pswd), headers=h, verify=False) r_code = str(r.status_code) print " Response code: " + r_code cmd_response_code = int(r.status_code) if cmd_response_code != 200: return (False, cmd_response_code) else: try: data = json.loads(r.text) print " Response body: " print json.dumps(data, sort_keys=True, indent=4) except: print " Response body: empty" print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
def run(self, deviceIP, cmd_path): cmd_path = cmd_path[:26] # Fetching device credentials based on keys derived from deviceIP ################################################################# user_key_name = deviceIP + "_user" pswd_key_name = deviceIP + "_pswd" print("\n") print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") print("Looking for credentials in KV store") client = Client() try: user = (client.keys.get_by_name(user_key_name)).value pswd = (client.keys.get_by_name(pswd_key_name)).value print(" Obtained from KV store: user = "******" Obtained from KV store: pswd = " + pswd) except Exception: return (False, "No credentials for : " + deviceIP) # Preapring the URL request(s) ################################################################# h = { "accept": "application/json", "content-length": "0" } url_base = "https://" + deviceIP + "/" + cmd_path url = url_base + "/commit" # Sending the URL call(s) ################################################################# print("Sending REST call(s):") print(" POST " + url) with warnings.catch_warnings(): warnings.simplefilter("ignore") r = requests.post(url, auth=(user, pswd), headers=h, verify=False) r_code = str(r.status_code) print(" Response code: " + r_code) if r.status_code == 200: try: data = json.loads(r.text) print(" Response body: ") print(json.dumps(data, sort_keys=True, indent=4)) return True, data print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") except Exception: print(" Response body is empty") print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") else: return (False, "Failed!")
def test_get_cached_auth_token_corrupted_token_cache_file(self): client = Client() shell = Shell() username = '******' password = '******' cached_token_path = shell._get_cached_token_path_for_user(username=username) with open(cached_token_path, 'w') as fp: fp.write('CORRRRRUPTED!') expected_msg = 'File (.+) with cached token is corrupted or invalid' self.assertRaisesRegexp(ValueError, expected_msg, shell._get_cached_auth_token, client=client, username=username, password=password)
def run(self, deviceIP, cmd_path): cmd_path = cmd_path[:26] # Fetching device credentials based on keys derived from deviceIP ################################################################# user_key_name = deviceIP + "_user" pswd_key_name = deviceIP + "_pswd" print "\n" print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" print "Looking for credentials in KV store" client = Client() try: user = (client.keys.get_by_name(user_key_name)).value pswd = (client.keys.get_by_name(pswd_key_name)).value print " Obtained from KV store: user = "******" Obtained from KV store: pswd = " + pswd except: return (False, "No credentials for : " + deviceIP) # Preapring the URL request(s) ################################################################# h = {"accept": "application/json", "content-length": "0"} url_list = list() url_base = "https://" + deviceIP + "/" + cmd_path url = url_base + "/delete/protocols/bgp/" url_list.append(url) # Sending the URL call(s) ################################################################# print "Sending REST call(s):" for u in url_list: with warnings.catch_warnings(): warnings.simplefilter("ignore") print " PUT " + u r = requests.put(u, auth=(user, pswd), headers=h, verify=False) r_code = str(r.status_code) print " Response code: " + r_code cmd_response_code = int(r.status_code) if cmd_response_code != 200: return (False, cmd_response_code) else: try: data = json.loads(r.text) print " Response body: " print json.dumps(data, sort_keys=True, indent=4) except: print " Response body: empty" print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
def run(self, repo, user, homepage, description, pack_yaml_data): self.client = Client(base_url='http://localhost') self.templates_folder = 'pack_template' self.templates_dir = '/opt/stackstorm/bitovi-stackstorm-exchange/bitovi_packs/actions/' + self.templates_folder self.temp_templates_root = "/opt/stackstorm/tmp_create_{repo}".format( repo=repo) self.temp_templates_dir = "{a}/{b}".format(a=self.temp_templates_root, b=self.templates_folder) # Prep he tmp directory template files os.system("rm -rf {dir}".format(dir=self.temp_templates_root)) self.makedirs(self.temp_templates_dir) # Copy template files from {templates_dir} to {temp_templates_root} os.system("cp -rf {a} {b}".format(a=self.templates_dir, b=self.temp_templates_root)) self._save_obj_to_yaml_file(self.temp_templates_root, 'pack.yaml', pack_yaml_data) self._save_obj_to_yaml_file(self.temp_templates_root + '/rules', 'watch_pack_commit.yaml', self.get_watch_pack_commit_rule(repo)) self._save_file_contents(self.temp_templates_root, 'README.md', self.get_readme(repo, user, description)) commit_message = "Bootstrap a Bitovi StackStorm Exchange pack repository for pack {repo}".format( repo=repo) os.chdir(self.temp_templates_root) os.system("git init") os.system( "git config user.email '{email}'".format(email="*****@*****.**")) os.system( "git config user.name '{name}'".format(name=self.github_user)) os.system("git add .") os.system("git commit -m '{message}'".format(message=commit_message)) os.system( "git remote add origin https://{gu}:{gt}@github.com/{user}/{repo}.git" .format(gu=self.github_user, gt=self.github_token, user=user, repo=repo)) os.system("git push -u origin master") os.system("git checkout -b dev") os.system("git push -u origin HEAD") # Remove the template files os.system("rm -rf {dir}".format(dir=self.temp_templates_root)) return True
def run(self): self.client = Client(base_url='http://localhost') queryresult = self.client.keys.query(prefix="NPING") iplist = [] for key in queryresult: _name = key.name _ip = _name.split(':')[1] iplist.append(_ip) if iplist: return (True, iplist) return (False)
def test_basic_auth_option_success_password_with_colon(self): client = Client(basic_auth="username:password:with:colon") self.assertEqual(client.basic_auth, ("username", "password:with:colon")) self.assertEqual(requests.get.call_count, 0) client.actions.get_all() self.assertEqual(requests.get.call_count, 1) requests.get.assert_called_with( "http://127.0.0.1:9101/v1/actions", auth=("username", "password:with:colon"), params={}, )
def run(self): self.client = Client(base_url='http://localhost') queryresult = self.client.keys.query(prefix="NDEV") nbgplist = [] for key in queryresult: _name = key.name _nname = _name.split(':')[1] nbgplist.append(_nname) if nbgplist: return (True, nbgplist) return (False)
def run(self, count=100): pool = GreenPool(count) client = Client() rule_ids = [] name_patterns = ['key1', 'key2', 'key3', 'key4', 'key5'] def create_rule(rule): try: rule = client.rules.create(rule) except Exception as e: # Rule already exists, ignore the error print(e) return rule_ids.append(rule.id) start_timestamp = time.time() index_name_pattern = 0 for index in range(0, count): rule = Rule() rule.name = 'rule_%s' % (index) rule.pack = 'default' rule.trigger = {'type': 'core.st2.key_value_pair.create'} # Use uniform distribution of names so if COUNT is 100, each key # will be used COUNT / len(KEYS) if index_name_pattern >= len(name_patterns): index_name_pattern = 0 pattern = name_patterns[index_name_pattern] rule.criteria = { 'trigger.object.name': { 'pattern': (pattern), 'type': 'equals' } } rule.action = {'ref': 'core.noop'} index_name_pattern += 1 pool.spawn(create_rule, rule) pool.waitall() end_timestamp = time.time() delta = (end_timestamp - start_timestamp) print('Created %d rules in %ss.' % (count, delta))
def _get_api_client(self): """ Retrieve API client instance. """ token_expire = self._token_expire <= get_datetime_utc_now() if not self._client or token_expire: self._logger.audit('Creating new Client object.') ttl = cfg.CONF.auth.service_token_ttl self._token_expire = get_datetime_utc_now() + timedelta(seconds=ttl) temporary_token = create_token(username=self._api_username, ttl=ttl, service=True) api_url = get_full_public_api_url() self._client = Client(api_url=api_url, token=temporary_token.token) return self._client
def test_env_base_only(self): base_url = "http://www.stackstorm.com" api_url = "http://www.stackstorm.com:9101/v1" stream_url = "http://www.stackstorm.com:9102/v1" os.environ["ST2_BASE_URL"] = base_url self.assertEqual(os.environ.get("ST2_BASE_URL"), base_url) self.assertEqual(os.environ.get("ST2_API_URL"), None) self.assertEqual(os.environ.get("ST2_STREAM_URL"), None) client = Client() endpoints = client.endpoints self.assertEqual(endpoints["base"], base_url) self.assertEqual(endpoints["api"], api_url) self.assertEqual(endpoints["stream"], stream_url)
def runAction(action_ref, params): client = Client() action_exec_mgr = client.managers['LiveAction'] execution = models.LiveAction() execution.action = action_ref execution.parameters = param_parser(params) actionexec = action_exec_mgr.create(execution) while actionexec.status not in END_STATES: time.sleep(2) actionexec = action_exec_mgr.get_by_id(actionexec.id) return actionexec
def test_get_cached_auth_token_valid_token_in_cache_file(self): client = Client() shell = Shell() username = "******" password = "******" cached_token_path = shell._get_cached_token_path_for_user(username=username) data = {"token": "yayvalid", "expire_timestamp": (int(time.time()) + 20)} with open(cached_token_path, "w") as fp: fp.write(json.dumps(data)) result = shell._get_cached_auth_token( client=client, username=username, password=password ) self.assertEqual(result, "yayvalid")
def execute_actionalias(self, action_alias, representation, msg): """ @action_alias: the st2client action_alias object. @representation: the st2client representation for the action_alias. @msg: errbot message. """ auth_kwargs = self.st2auth.auth_method("st2client") LOG.info("Create st2 client with {} {} {}".format(self.st2config.base_url, self.st2config.api_url, auth_kwargs)) st2_client = Client(base_url=self.st2config.base_url, api_url=self.st2config.api_url, debug=True, **auth_kwargs) execution = ActionAliasExecution() execution.name = action_alias.name execution.format = representation execution.command = msg.body if msg.is_direct == False: execution.notification_channel = str(msg.to) execution.source_channel = str(msg.to) else: execution.notification_channel = str(msg.frm) execution.source_channel = str(msg.frm) execution.notification_route = 'errbot' execution.user = str(msg.frm) LOG.info("Execution: {}".format([execution.command, execution.format, execution.name, execution.notification_channel, execution.notification_route, execution.source_channel, execution.user])) action_exec_mgr = st2_client.managers['ActionAliasExecution'] execution = action_exec_mgr.create(execution) LOG.info("AFTER {}{}".format(type(execution), dir(execution))) try: ret_msg = execution.message LOG.info("AFTER {}{}".format(execution.execution, execution.message)) except AttributeError as e: ret_msg = "Something is happening ... " return ret_msg # " ".join([execution.message])
def _generate_actionaliases(self): """ generate pattern and help for action alias """ self.help = '' self.pattern_action = {} base_url = self.st2config.base_url api_url = self.st2config.api_url auth_kwargs = self.st2auth.auth_method("st2client") LOG.info("\u001b[35m Create st2 client with {} {} {} \u001b[0m".format(base_url, api_url, auth_kwargs)) st2_client = Client(base_url=base_url, api_url=api_url, **auth_kwargs) self.parser.process_actionaliases(st2_client.managers['ActionAlias'].get_all())
def __init__(self, config=None): super(BaseAction, self).__init__(config) if config is None: raise ValueError( "No connection configuration details found for san") if FIREWALLS in config: self.client = Client(base_url='http://localhost') self.list_fws = config[FIREWALLS] if self.list_fws is None: raise ValueError(FIREWALLS + " config defined but empty.") else: pass else: raise ValueError("No connection configuration details found")
def test_cache_auth_token_success(self): client = Client() shell = Shell() username = '******' password = '******' expiry = datetime.datetime.utcnow() + datetime.timedelta(seconds=30) result = shell._get_cached_auth_token(client=client, username=username, password=password) self.assertEqual(result, None) token_db = TokenDB(user=username, token='fyeah', expiry=expiry) shell._cache_auth_token(token_obj=token_db) result = shell._get_cached_auth_token(client=client, username=username, password=password) self.assertEqual(result, 'fyeah')
def test_get_cached_auth_token_valid_token_in_cache_file(self): client = Client() shell = Shell() username = '******' password = '******' cached_token_path = shell._get_cached_token_path_for_user(username=username) data = { 'token': 'yayvalid', 'expire_timestamp': (int(time.time()) + 20) } with open(cached_token_path, 'w') as fp: fp.write(json.dumps(data)) result = shell._get_cached_auth_token(client=client, username=username, password=password) self.assertEqual(result, 'yayvalid')
def test_env(self): base_url = 'http://www.stackstorm.com' api_url = 'http://www.st2.com:9101/v1' stream_url = 'http://www.st2.com:9102/v1' os.environ['ST2_BASE_URL'] = base_url os.environ['ST2_API_URL'] = api_url os.environ['ST2_STREAM_URL'] = stream_url self.assertEqual(os.environ.get('ST2_BASE_URL'), base_url) self.assertEqual(os.environ.get('ST2_API_URL'), api_url) self.assertEqual(os.environ.get('ST2_STREAM_URL'), stream_url) client = Client() endpoints = client.endpoints self.assertEqual(endpoints['base'], base_url) self.assertEqual(endpoints['api'], api_url) self.assertEqual(endpoints['stream'], stream_url)
def _get_api_client(self): """ Retrieve API client instance. """ # TODO: API client is really unfriendly and needs to be re-designed and # improved api_url = os.environ.get(API_URL_ENV_VARIABLE_NAME, None) auth_token = os.environ.get(AUTH_TOKEN_ENV_VARIABLE_NAME, None) if not api_url or not auth_token: raise ValueError('%s and %s environment variable must be set' % (API_URL_ENV_VARIABLE_NAME, AUTH_TOKEN_ENV_VARIABLE_NAME)) if not self._client: self._client = Client(api_url=api_url) return self._client
def select(self, query, data, key): q = query if data: values = self._list_to_string(data) q = q.format(values) c = self.db.cursor() try: c.execute(q) output = self._format_results(c) if key is not None: client = Client(base_url='http://localhost') client.keys.update(KeyValuePair(name=key, value=str(output))) return key else: return output except MySQLdb.Error as e: # pylint: disable=no-member raise Exception(e)
def get_client(self, args, debug=False): ST2_CLI_SKIP_CONFIG = os.environ.get('ST2_CLI_SKIP_CONFIG', 0) ST2_CLI_SKIP_CONFIG = int(ST2_CLI_SKIP_CONFIG) skip_config = args.skip_config skip_config = skip_config or ST2_CLI_SKIP_CONFIG # Note: Options provided as the CLI argument have the highest precedence # Precedence order: cli arguments > environment variables > rc file variables cli_options = ['base_url', 'auth_url', 'api_url', 'api_version', 'cacert'] cli_options = {opt: getattr(args, opt) for opt in cli_options} config_file_options = self._get_config_file_options(args=args) kwargs = {} if not skip_config: # Config parsing is not skipped kwargs = merge_dicts(kwargs, config_file_options) kwargs = merge_dicts(kwargs, cli_options) kwargs['debug'] = debug client = Client(**kwargs) if skip_config: # Config parsing is skipped LOG.info('Skipping parsing CLI config') return client # Ok to use config at this point rc_config = get_config() # Silence SSL warnings silence_ssl_warnings = rc_config.get('general', {}).get('silence_ssl_warnings', False) if silence_ssl_warnings: requests.packages.urllib3.disable_warnings() # We skip automatic authentication for some commands such as auth try: command_class_name = args.func.im_class.__name__ except Exception: command_class_name = None if command_class_name in SKIP_AUTH_CLASSES: return client # We also skip automatic authentication if token is provided via the environment variable # or as a command line argument env_var_token = os.environ.get('ST2_AUTH_TOKEN', None) cli_argument_token = getattr(args, 'token', None) env_var_api_key = os.environ.get('ST2_API_KEY', None) cli_argument_api_key = getattr(args, 'api_key', None) if env_var_token or cli_argument_token or env_var_api_key or cli_argument_api_key: return client # If credentials are provided in the CLI config use them and try to authenticate credentials = rc_config.get('credentials', {}) username = credentials.get('username', None) password = credentials.get('password', None) cache_token = rc_config.get('cli', {}).get('cache_token', False) if username and password: # Credentials are provided, try to authenticate agaist the API try: token = self._get_auth_token(client=client, username=username, password=password, cache_token=cache_token) except requests.exceptions.ConnectionError as e: LOG.warn('Auth API server is not available, skipping authentication.') LOG.exception(e) return client except Exception as e: print('Failed to authenticate with credentials provided in the config.') raise e client.token = token # TODO: Hack, refactor when splitting out the client os.environ['ST2_AUTH_TOKEN'] = token return client