Python auth.HTTPBasicAuth方法代码示例

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def __init__(self, infinispan_config, **kwargs):
        logger.debug("Creating Infinispan client")
        self.infinispan_config = infinispan_config
        self.is_pywren_function = is_pywren_function()
        self.basicAuth = HTTPBasicAuth(infinispan_config.get('username'),
                                       infinispan_config.get('password'))
        self.endpoint = infinispan_config.get('endpoint')
        self.cache_manager = infinispan_config.get('cache_manager', 'default')
        self.cache_name = self.__generate_cache_name(kwargs['bucket'], kwargs['executor_id'])
        self.infinispan_client = requests.session()

        self.__is_server_version_supported()

        res = self.infinispan_client.head(self.endpoint + '/rest/v2/caches/' + self.cache_name,
                                          auth=self.basicAuth)
        if res.status_code == 404:
            logger.debug('going to create new Infinispan cache {}'.format(self.cache_name))
            res = self.infinispan_client.post(self.endpoint + '/rest/v2/caches/' + self.cache_name + '?template=org.infinispan.DIST_SYNC')
            logger.debug('New Infinispan cache {} created with status {}'.format(self.cache_name, res.status_code))

        logger.debug("Infinispan client created successfully") 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def _request_data(self, url):
        try:
            if set(["COUCHBASE_USERNAME","COUCHBASE_PASSWORD"]).issubset(os.environ):
                response = requests.get(url, auth=HTTPBasicAuth(os.environ["COUCHBASE_USERNAME"], os.environ["COUCHBASE_PASSWORD"]))
            else:
                response = requests.get(url)
        except Exception as e:
            print('Failed to establish a new connection. Is {0} correct?'.format(self.BASE_URL))
            sys.exit(1)

        if response.status_code != requests.codes.ok:
            print('Response Status ({0}): {1}'.format(response.status_code, response.text))
            sys.exit(1)

        result = response.json()
        return result 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def _list_project(self):
        self._last_update_projects = time.time()
        self.projects = set()
        if self.collection_prefix:
            prefix = "%s." % self.collection_prefix
        else:
            prefix = ''

        url = self.base_url + "_all_dbs"
        res = requests.get(url,
                           data=json.dumps({}),
                           headers={"Content-Type": "application/json"},
                           auth=HTTPBasicAuth(self.username, self.password)).json()
        for each in res:
            if each.startswith('_'):
                continue
            if each.startswith(self.database):
                self.projects.add(each[len(self.database)+1+len(prefix):]) 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def get(self, name, fields=None):
        if fields is None:
            fields = []
        payload = {
            "selector": {"name": name},
            "fields": fields,
            "limit": 1,
            "use_index": self.index
        }
        url = self.url + "_find"
        res = requests.post(url,
                            data=json.dumps(payload),
                            headers={"Content-Type": "application/json"},
                            auth=HTTPBasicAuth(self.username, self.password)).json()
        if len(res['docs']) == 0:
            return None
        return self._default_fields(res['docs'][0]) 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def _create_project(self, project):
        collection_name = self._get_collection_name(project)
        self.create_database(collection_name)
        # create index
        payload = {
            'index': {
                'fields': ['status', 'taskid']
            },
            'name': collection_name
        }
        res = requests.post(self.base_url + collection_name + "/_index",
                            data=json.dumps(payload),
                            headers={"Content-Type": "application/json"},
                            auth=HTTPBasicAuth(self.username, self.password)).json()
        self.index = res['id']
        self._list_project() 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def setAuthMethod(self, auth_method):
        "Set the authentication method to use for the requests."
        self.auth_method = auth_method
        if len(self.auth_credentials) == 2:
            username, password = self.auth_credentials
            if self.auth_method == "basic":
                from requests.auth import HTTPBasicAuth
                self.h.auth = HTTPBasicAuth(username, password)
            elif self.auth_method == "digest":
                from requests.auth import HTTPDigestAuth
                self.h.auth = HTTPDigestAuth(username, password)
            elif self.auth_method == "ntlm":
                from requests_ntlm import HttpNtlmAuth
                self.h.auth = HttpNtlmAuth(username, password)
        elif self.auth_method == "kerberos":
            from requests_kerberos import HTTPKerberosAuth
            self.h.auth = HTTPKerberosAuth() 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def send_request(self, commands, method='cli', timeout=30):
        """
        Send a HTTP/HTTPS request containing the JSON-RPC payload, headers, and username/password.

        method = cli for structured data response
        method = cli_ascii for a string response (still in JSON-RPC dict, but in 'msg' key)
        """
        timeout = int(timeout)
        payload_list = self._build_payload(commands, method)
        response = requests.post(self.url,
                                 timeout=timeout,
                                 data=json.dumps(payload_list),
                                 headers=self.headers,
                                 auth=HTTPBasicAuth(self.username, self.password),
                                 verify=self.verify)
        response_list = json.loads(response.text)

        if isinstance(response_list, dict):
            response_list = [response_list]

        # Add the 'command' that was executed to the response dictionary
        for i, response_dict in enumerate(response_list):
            response_dict['command'] = commands[i]
        return response_list 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def __build_auth_kwargs(self, **kwargs):
        """Setup authentication for requests

        If `access_token` is given, it is used in Authentication header.
        Otherwise basic auth is used with the client credentials.
        """

        if "access_token" in kwargs:
            headers = self.get_auth_headers(kwargs["access_token"])

            if "headers" in kwargs:
                headers.update(kwargs["headers"])

            kwargs["headers"] = headers
            del kwargs["access_token"]
        elif "auth" not in kwargs:
            kwargs["auth"] = HTTPBasicAuth(self.client_id, self.client_secret)

        return kwargs 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def setup_memory_quota(
    *,
    cluster_url,
    username,
    password,
    memory_quota_mb="256",
    index_memory_quota_mb="256",
    fts_memory_quota_mb="256",
):
    auth = HTTPBasicAuth(username, password)
    url = f"{cluster_url}/pools/default"
    r = requests.post(
        url,
        data={
            "memoryQuota": memory_quota_mb,
            "indexMemoryQuota": index_memory_quota_mb,
            "ftsMemoryQuota": fts_memory_quota_mb,
        },
        auth=auth,
    )
    return r.status_code == 200 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def test(self):
        auth = HTTPBasicAuth(username=self.username,
                             password=self.password)

        response = requests.get(self.url, auth=auth)

        # https://developer.atlassian.com/cloud/jira/platform/rest/v2/?utm_source=%2Fcloud%2Fjira%2Fplatform%2Frest%2F&utm_medium=302#error-responses
        if response.status_code == 200:
            return True
        elif response.status_code == 401:
            raise ConnectionTestException(preset=ConnectionTestException.Preset.USERNAME_PASSWORD)
        elif response.status_code == 404:
            raise ConnectionTestException(cause=f"Unable to reach Jira instance at: {self.url}.",
                                          assistance="Verify the Jira server at the URL configured in your plugin "
                                                     "connection is correct.")
        else:
            self.logger.error(ConnectionTestException(cause=f"Unhandled error occurred: {response.content}"))
            raise ConnectionTestException(cause=f"Unhandled error occurred.",
                                          assistance=response.content) 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def connect(self, params):
        self.logger.info("Connect: Connecting...")

        api_route = "api/now/"
        incident_table = "incident"

        base_url = params.get(Input.URL, "")

        if not base_url.endswith('/'):
            base_url = f'{base_url}/'

        username = params[Input.CLIENT_LOGIN].get("username", "")
        password = params[Input.CLIENT_LOGIN].get("password", "")

        self.session = requests.Session()
        self.session.auth = HTTPBasicAuth(username, password)
        self.request = RequestHelper(self.session, self.logger)

        self.table_url = f'{base_url}{api_route}table/'
        self.incident_url = f'{self.table_url}{incident_table}'
        self.attachment_url = f'{base_url}{api_route}attachment'
        self.timeout = params.get("timeout", 30) 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def getStats(data):
	print "\nCost Computation....\n"
	global cost
	txRate = 0
	for i in data["node-connector"]:
		tx = int(i["opendaylight-port-statistics:flow-capable-node-connector-statistics"]["packets"]["transmitted"])
		rx = int(i["opendaylight-port-statistics:flow-capable-node-connector-statistics"]["packets"]["received"])
		txRate = tx + rx
		#print txRate

	time.sleep(2)

	response = requests.get(stats, auth=HTTPBasicAuth('admin', 'admin'))
	tempJSON = ""
	if(response.ok):
		tempJSON = json.loads(response.content)

	for i in tempJSON["node-connector"]:
		tx = int(i["opendaylight-port-statistics:flow-capable-node-connector-statistics"]["packets"]["transmitted"])
		rx = int(i["opendaylight-port-statistics:flow-capable-node-connector-statistics"]["packets"]["received"])
		cost = cost + tx + rx - txRate

	#cost = cost + txRate
	#print cost 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def authenticate_basic(self, username: str, password: str) -> 'Connection':
        """
        Authenticate a user to the backend using basic username and password.

        :param username: User name
        :param password: User passphrase
        """
        resp = self.get(
            '/credentials/basic',
            # /credentials/basic is the only endpoint that expects a Basic HTTP auth
            auth=HTTPBasicAuth(username, password)
        ).json()
        # Switch to bearer based authentication in further requests.
        if self._api_version.at_least("1.0.0"):
            self.auth = BearerAuth(bearer='basic//{t}'.format(t=resp["access_token"]))
        else:
            self.auth = BearerAuth(bearer=resp["access_token"])
        return self 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def register_tokens_from_app(host_address, auth_username, auth_password):
    token_req = requests.get(host_address + '/api/token', auth=HTTPBasicAuth(auth_username, auth_password))

    if token_req.status_code == 200:

        for token in token_req.json()['data']['tokens']:
            try:
                blockchain_processor.registry.register_contract(token['address'], dai_abi.abi)
            except BadFunctionCallOutput as e:
                # It's probably a contract on a different chain
                if not config.IS_PRODUCTION:
                    pass
                else:
                    raise e

        return True

    else:
        return False 

# 需要导入模块: from requests import auth [as 别名]
# 或者: from requests.auth import HTTPBasicAuth [as 别名]
def create_address_only_credit_transfer_in_app(self,
                                                   sender_address,
                                                   recipient_address,
                                                   transaction_hash,
                                                   amount):

        converted_amount = self.native_amount_to_cents(amount)

        body = {
            'sender_blockchain_address': sender_address,
            'recipient_blockchain_address': recipient_address,
            'blockchain_transaction_hash': transaction_hash,
            'transfer_amount': converted_amount
        }

        r = requests.post(config.APP_HOST + '/api/credit_transfer/internal/',
                          json=body,
                          auth=HTTPBasicAuth(config.BASIC_AUTH_USERNAME,
                                             config.BASIC_AUTH_PASSWORD))

        return r