def _get_conn(self):
'''Return connection to server'''
conn = HTTPConnection(self.hostname, self.port, proxy=self.proxy,
ssl_context=self.ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 20))
return conn
def _get_conn(self):
'''Return connection to server'''
conn = HTTPConnection(self.hostname, self.port, proxy=self.proxy,
ssl_context=self.ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 20))
return conn
def _get_conn(self):
'''Obtain connection to server and authentication token'''
log.debug('started')
if 'no-ssl' in self.options:
ssl_context = None
else:
ssl_context = self.ssl_context
headers = CaseInsensitiveDict()
headers['X-Auth-User'] = self.login
headers['X-Auth-Key'] = self.password
with HTTPConnection(self.hostname,
self.port,
proxy=self.proxy,
ssl_context=ssl_context) as conn:
conn.timeout = int(self.options.get('tcp-timeout', 20))
for auth_path in ('/v1.0', '/auth/v1.0'):
log.debug('GET %s', auth_path)
conn.send_request('GET', auth_path, headers=headers)
resp = conn.read_response()
if resp.status in (404, 412):
log.debug('auth to %s failed, trying next path', auth_path)
conn.discard()
continue
elif resp.status == 401:
raise AuthorizationError(resp.reason)
elif resp.status > 299 or resp.status < 200:
raise HTTPError(resp.status, resp.reason, resp.headers)
# Pylint can't infer SplitResult Types
#pylint: disable=E1103
self.auth_token = resp.headers['X-Auth-Token']
o = urlsplit(resp.headers['X-Storage-Url'])
self.auth_prefix = urllib.parse.unquote(o.path)
if o.scheme == 'https':
ssl_context = self.ssl_context
elif o.scheme == 'http':
ssl_context = None
else:
# fall through to scheme used for authentication
pass
conn = HTTPConnection(o.hostname,
o.port,
proxy=self.proxy,
ssl_context=ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 20))
return conn
raise RuntimeError('No valid authentication path found')
def _get_conn(self):
'''Obtain connection to server and authentication token'''
log.debug('started')
if 'no-ssl' in self.options:
ssl_context = None
else:
ssl_context = self.ssl_context
headers = CaseInsensitiveDict()
headers['X-Auth-User'] = self.login
headers['X-Auth-Key'] = self.password
with HTTPConnection(self.hostname, self.port, proxy=self.proxy,
ssl_context=ssl_context) as conn:
conn.timeout = int(self.options.get('tcp-timeout', 10))
for auth_path in ('/v1.0', '/auth/v1.0'):
log.debug('GET %s', auth_path)
conn.send_request('GET', auth_path, headers=headers)
resp = conn.read_response()
if resp.status in (404, 412):
log.debug('auth to %s failed, trying next path', auth_path)
conn.discard()
continue
elif resp.status == 401:
raise AuthorizationError(resp.reason)
elif resp.status > 299 or resp.status < 200:
raise HTTPError(resp.status, resp.reason, resp.headers)
# Pylint can't infer SplitResult Types
#pylint: disable=E1103
self.auth_token = resp.headers['X-Auth-Token']
o = urlsplit(resp.headers['X-Storage-Url'])
self.auth_prefix = urllib.parse.unquote(o.path)
if o.scheme == 'https':
ssl_context = self.ssl_context
elif o.scheme == 'http':
ssl_context = None
else:
# fall through to scheme used for authentication
pass
conn = HTTPConnection(o.hostname, o.port, proxy=self.proxy,
ssl_context=ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 10))
return conn
raise RuntimeError('No valid authentication path found')
def _request_upload_url_info(self):
request_data = {'bucketId': self._get_bucket_id()}
response = self._do_api_call('b2_get_upload_url', request_data)
new_upload_url = urlparse(response['uploadUrl'])
new_authorization_token = response['authorizationToken']
upload_connection = HTTPConnection(new_upload_url.hostname,
443,
ssl_context=self.ssl_context)
upload_connection.timeout = self.tcp_timeout
return {
'hostname': new_upload_url.hostname,
'connection': upload_connection,
'path': new_upload_url.path,
'authorizationToken': new_authorization_token,
'isUploading': False
}
def _get_conn(self):
'''Obtain connection to server and authentication token'''
log.debug('started')
if 'no-ssl' in self.options:
ssl_context = None
else:
ssl_context = self.ssl_context
headers = CaseInsensitiveDict()
headers['Content-Type'] = 'application/json'
headers['Accept'] = 'application/json; charset="utf-8"'
if ':' in self.login:
(tenant,user) = self.login.split(':')
else:
tenant = None
user = self.login
domain = self.options.get('domain', None)
if domain:
if not tenant:
raise ValueError("Tenant is required when Keystone v3 is used")
# In simple cases where there's only one domain, the project domain
# will be the same as the authentication domain, but this option
# allows for them to be different
project_domain = self.options.get('project-domain', domain)
auth_body = {
'auth': {
'identity': {
'methods': ['password'],
'password': {
'user': {
'name': user,
'domain': {
'id': domain
},
'password': self.password
}
}
},
'scope': {
'project': {
'id': tenant,
'domain': {
'id': project_domain
}
}
}
}
}
auth_url_path = '/v3/auth/tokens'
else:
# If a domain is not specified, assume v2
auth_body = { 'auth':
{ 'passwordCredentials':
{ 'username': user,
'password': self.password } }}
auth_url_path = '/v2.0/tokens'
if tenant:
auth_body['auth']['tenantName'] = tenant
with HTTPConnection(self.hostname, port=self.port, proxy=self.proxy,
ssl_context=ssl_context) as conn:
conn.timeout = int(self.options.get('tcp-timeout', 20))
conn.send_request('POST', auth_url_path, headers=headers,
body=json.dumps(auth_body).encode('utf-8'))
resp = conn.read_response()
if resp.status == 401:
raise AuthorizationError(resp.reason)
elif resp.status > 299 or resp.status < 200:
raise HTTPError(resp.status, resp.reason, resp.headers)
cat = json.loads(conn.read().decode('utf-8'))
if self.options.get('domain', None):
self.auth_token = resp.headers['X-Subject-Token']
service_catalog = cat['token']['catalog']
else:
self.auth_token = cat['access']['token']['id']
service_catalog = cat['access']['serviceCatalog']
avail_regions = []
for service in service_catalog:
if service['type'] != 'object-store':
continue
for endpoint in service['endpoints']:
if endpoint['region'] != self.region:
avail_regions.append(endpoint['region'])
continue
if 'publicURL' in endpoint:
# The publicURL nomenclature is found in v2 catalogs
o = urlsplit(endpoint['publicURL'])
else:
# Whereas v3 catalogs do 'interface' == 'public' and
# 'url' for the URL itself
if endpoint['interface'] != 'public':
continue
o = urlsplit(endpoint['url'])
self.auth_prefix = urllib.parse.unquote(o.path)
if o.scheme == 'https':
ssl_context = self.ssl_context
elif o.scheme == 'http':
ssl_context = None
else:
# fall through to scheme used for authentication
pass
self._detect_features(o.hostname, o.port, ssl_context)
conn = HTTPConnection(o.hostname, o.port, proxy=self.proxy,
ssl_context=ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 20))
return conn
if len(avail_regions) < 10:
raise DanglingStorageURLError(self.container_name,
'No accessible object storage service found in region %s'
' (available regions: %s)' % (self.region, ', '.join(avail_regions)))
else:
raise DanglingStorageURLError(self.container_name,
'No accessible object storage service found in region %s'
% self.region)
def _get_conn(self):
'''Obtain connection to server and authentication token'''
log.debug('started')
if 'no-ssl' in self.options:
ssl_context = None
else:
ssl_context = self.ssl_context
headers = CaseInsensitiveDict()
headers['Content-Type'] = 'application/json'
headers['Accept'] = 'application/json; charset="utf-8"'
if ':' in self.login:
(tenant,user) = self.login.split(':')
else:
tenant = None
user = self.login
auth_body = { 'auth':
{ 'passwordCredentials':
{ 'username': user,
'password': self.password } }}
if tenant:
auth_body['auth']['tenantName'] = tenant
with HTTPConnection(self.hostname, port=self.port, proxy=self.proxy,
ssl_context=ssl_context) as conn:
conn.timeout = int(self.options.get('tcp-timeout', 20))
conn.send_request('POST', '/v2.0/tokens', headers=headers,
body=json.dumps(auth_body).encode('utf-8'))
resp = conn.read_response()
if resp.status == 401:
raise AuthorizationError(resp.reason)
elif resp.status > 299 or resp.status < 200:
raise HTTPError(resp.status, resp.reason, resp.headers)
cat = json.loads(conn.read().decode('utf-8'))
self.auth_token = cat['access']['token']['id']
avail_regions = []
for service in cat['access']['serviceCatalog']:
if service['type'] != 'object-store':
continue
for endpoint in service['endpoints']:
if endpoint['region'] != self.region:
avail_regions.append(endpoint['region'])
continue
o = urlsplit(endpoint['publicURL'])
self.auth_prefix = urllib.parse.unquote(o.path)
if o.scheme == 'https':
ssl_context = self.ssl_context
elif o.scheme == 'http':
ssl_context = None
else:
# fall through to scheme used for authentication
pass
conn = HTTPConnection(o.hostname, o.port, proxy=self.proxy,
ssl_context=ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 20))
return conn
if len(avail_regions) < 10:
raise DanglingStorageURLError(self.container_name,
'No accessible object storage service found in region %s'
' (available regions: %s)' % (self.region, ', '.join(avail_regions)))
else:
raise DanglingStorageURLError(self.container_name,
'No accessible object storage service found in region %s'
% self.region)
def _get_conn(self):
'''Obtain connection to server and authentication token'''
log.debug('started')
if 'no-ssl' in self.options:
ssl_context = None
else:
ssl_context = self.ssl_context
headers = CaseInsensitiveDict()
headers['Content-Type'] = 'application/json'
headers['Accept'] = 'application/json; charset="utf-8"'
if ':' in self.login:
(tenant, user) = self.login.split(':')
else:
tenant = None
user = self.login
auth_body = {
'auth': {
'passwordCredentials': {
'username': user,
'password': self.password
}
}
}
if tenant:
auth_body['auth']['tenantName'] = tenant
with HTTPConnection(self.hostname,
port=self.port,
proxy=self.proxy,
ssl_context=ssl_context) as conn:
conn.timeout = int(self.options.get('tcp-timeout', 20))
conn.send_request('POST',
'/v2.0/tokens',
headers=headers,
body=json.dumps(auth_body).encode('utf-8'))
resp = conn.read_response()
if resp.status == 401:
raise AuthorizationError(resp.reason)
elif resp.status > 299 or resp.status < 200:
raise HTTPError(resp.status, resp.reason, resp.headers)
cat = json.loads(conn.read().decode('utf-8'))
self.auth_token = cat['access']['token']['id']
avail_regions = []
for service in cat['access']['serviceCatalog']:
if service['type'] != 'object-store':
continue
for endpoint in service['endpoints']:
if endpoint['region'] != self.region:
avail_regions.append(endpoint['region'])
continue
o = urlsplit(endpoint['publicURL'])
self.auth_prefix = urllib.parse.unquote(o.path)
if o.scheme == 'https':
ssl_context = self.ssl_context
elif o.scheme == 'http':
ssl_context = None
else:
# fall through to scheme used for authentication
pass
self._detect_features(o.hostname, o.port, ssl_context)
conn = HTTPConnection(o.hostname,
o.port,
proxy=self.proxy,
ssl_context=ssl_context)
conn.timeout = int(self.options.get('tcp-timeout', 20))
return conn
if len(avail_regions) < 10:
raise DanglingStorageURLError(
self.container_name,
'No accessible object storage service found in region %s'
' (available regions: %s)' %
(self.region, ', '.join(avail_regions)))
else:
raise DanglingStorageURLError(
self.container_name,
'No accessible object storage service found in region %s' %
self.region)
