Get ACL of a user key

 Deprecated: Please us `client.get_api_key` instead.
349934
def get_api_key(key, request_options = {})
      client.get(Protocol.index_key_uri(name, key), :read, request_options)
    end
284523
def get_uaa(self):
        
        import predix.security.uaa
        uaa = predix.security.uaa.UserAccountAuthentication()
        return uaa
410941
def jwt_get_secret_key(payload=None):
    
    User = get_user_model()  # noqa
    if api_settings.JWT_GET_USER_SECRET_KEY:
        user = User.objects.get(pk=payload.get('user_id'))
        key = str(api_settings.JWT_GET_USER_SECRET_KEY(user))
        return key

    return api_settings.JWT_SECRET_KEY
1151822
def get_s3_bucket_keys(api_client, bucket_name, bucket, check_encryption, check_acls):
    
    bucket['keys'] = []
    keys = handle_truncated_response(api_client.list_objects, {'Bucket': bucket_name}, ['Contents'])
    bucket['keys_count'] = len(keys['Contents'])
    key_count = 0
    update_status(key_count, bucket['keys_count'], 'keys')
    for key in keys['Contents']:
        key_count += 1
        key['name'] = key.pop('Key')
        key['LastModified'] = str(key['LastModified'])
        if check_encryption:
            try:
                # The encryption configuration is only accessible via an HTTP header, only returned when requesting one object at a time...
                k = api_client.get_object(Bucket = bucket_name, Key = key['name'])
                key['ServerSideEncryption'] = k['ServerSideEncryption'] if 'ServerSideEncryption' in k else None
                key['SSEKMSKeyId'] = k['SSEKMSKeyId'] if 'SSEKMSKeyId' in k else None
            except Exception as e:
                printException(e)
                continue
        if check_acls:
            try:
                key['grantees'] = get_s3_acls(api_client, bucket_name, bucket, key_name = key['name'])
            except Exception as e:
                continue
        # Save it
        bucket['keys'].append(key)
        update_status(key_count, bucket['keys_count'], 'keys')
1284385
def get_acl_helper(self, key_name, headers, query_args):
        """"""
        response = self.connection.make_request('GET', self.name, key_name,
                                                query_args=query_args, 
                                                headers=headers)
        body = response.read()
        if response.status == 200:
            acl = ACL(self)
            h = handler.XmlHandler(acl, self)
            xml.sax.parseString(body, h)
            return acl
        else:
            raise self.connection.provider.storage_response_error(
                response.status, response.reason, body)
808461
def get_user(uid):
    
    try:
        acl_url = urljoin(_acl_url(), 'users/{}'.format(uid))
        r = http.get(acl_url)
        return r.json()
        # assert r.status_code == 201
    except DCOSHTTPException as e:
        if e.response.status_code == 400:
            return None
        else:
            raise
311445
def __process_acl(self, load, auth_list):
        '''
        
        '''
        if 'eauth' not in load:
            return auth_list
        fstr = '{0}.process_acl'.format(load['eauth'])
        if fstr not in self.auth:
            return auth_list
        try:
            return self.auth[fstr](auth_list, self.opts)
        except Exception as e:
            log.debug('Authentication module threw %s', e)
            return auth_list
1156492
def _get_pkey(self):
        """"""
        keypath = self.config.server["pkey"]
        with open(os.path.expanduser(keypath)) as f:
            pkey = paramiko.RSAKey.from_private_key(f)

        return pkey
959334
function(apiKey) {
  return function(path, data, done) {
    var url = apiBase + path + '?' + querystring.stringify(_.extend({ 'key': apiKey }, data));
    request.get(url, globalResponseHandler({ url: url }, done));
  };
}
733342
def get_activation_key(self, user):
        
        return signing.dumps(
            obj=user.get_username(),
            salt=REGISTRATION_SALT
        )
1315412
private String getApiIndex(Api api) {
        return getApiIndex(api.getOrganizationId(), api.getApiId(), api.getVersion());
    }
1327021
def _get_auth_from_keyring(self):
        """"""
        if not keyring:
            return None

        # Take user from URL if available, else the OS login name
        password = self._get_password_from_keyring(self.user or getpass.getuser())
        if password is not None:
            self.user = self.user or getpass.getuser()
            self.password = password

        return 'keyring'
720386
def get_locked_variable(self, key, access_key):
        
        return self.get_variable(key, per_reference=False, access_key=access_key)
128816
def api_version(self, verbose=False):
        '''
        
        '''
        return self.__auth_req_get(self.rest_url, verbose=verbose)
1146821
def acl(self):
        """"""
        r = fapi.get_repository_method_acl(
            self.namespace, self.name, self.snapshot_id, self.api_url)
        fapi._check_response_code(r, 200)
        return r.json()
417988
public String getAccessKey() {
		String accessKey = getAsNullableString("access_key");
		accessKey = accessKey != null ? accessKey : getAsNullableString("client_key");
		return accessKey;
	}
21170
function(publicKey, aclRuleId, callback) {
        request.get(
            this.getResourceUrl({
                path: '/keys/' + publicKey + '/access/' + aclRuleId,
                user: null
            }),
            function onAccessControlRulesResponse(err, res, body) {
                callback(err, body, res);
            }
        );
        return this;
    }