def userSignUp(request):
if request.method == 'POST':
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
save = serializer.save()
auth = Authentication()
user, token = auth.authenticate(
serializer.validated_data.get('mobile'),
serializer.validated_data.get('password'))
data = AuthUserSerializer(user).data
result = {'token': token}
result.update(data)
wallet = WalletSerializer(data={'win_bal': '0', 'wal_bal': '10'})
if wallet.is_valid():
user_wallet = wallet.save()
user_wallet.user = save
user_wallet.save()
user_txn = TransactionSerializer(
data={
'txn_status': 'credit',
'txn_amount': '10',
'txn_description': 'Signup bonus'
})
if user_txn.is_valid():
user_txn1 = user_txn.save()
user_txn1.user = save
user_txn1.save()
return Response(data=result, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def userSignIn(request):
if request.method == 'POST':
serializer = UserLoginSerializer(data=request.data)
if serializer.is_valid():
auth = Authentication()
user, token = auth.authenticate(**serializer.validated_data)
data = AuthUserSerializer(user).data
result = {'token': token}
result.update(data)
return Response(data=result, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: http_connect
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=10, **kwargs):
"""
Accepts keyword arguments for Rackspace Cloud username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Rackspace Cloud username
@type api_key: str
@param api_key: a Rackspace Cloud API key
"""
self.connection_args = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username, api_key, authurl=authurl,
useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
def convert_iso_datetime(self, dt):
"""
Convert iso8601 to datetime
"""
isoFormat = "%Y-%m-%dT%H:%M:%S.000+0000"
if type(dt) is datetime.datetime:
return dt
if dt.endswith("Z"):
dt = dt.split('Z')[0]
isoFormat = "%Y-%m-%dT%H:%M:%S"
return datetime.datetime.strptime(dt, isoFormat)
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
query_args = ""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join(
[unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = \
['%s=%s' % (quote(x),
quote(str(y))) for (x, y) in parms.items()]
elif isinstance(parms, list) and parms:
query_args = \
["%s" % x for x in parms]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
if 'PYTHON_CLOUDDNS_DEBUG' in os.environ and \
os.environ['PYTHON_CLOUDDNS_DEBUG'].strip():
import sys
url = "https://%s%s\n" % \
(self.connection_args[0],
path)
sys.stderr.write("METHOD: %s\n" % (str(method)))
sys.stderr.write("URL: %s" % (url))
sys.stderr.write("HEADERS: %s\n" % (str(headers)))
sys.stderr.write("DATA: %s\n" % (str(data)))
sys.stderr.write("curl -X '%s' -H 'X-Auth-Token: %s' %s %s" % \
(method, self.token, url, str(data)))
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_domains(self):
return DomainResults(self, self.list_domains_info())
def list_domains_info(self, filter_by_name=None):
parms = {}
if filter_by_name:
parms = {'name': filter_by_name}
response = self.make_request('GET', ['domains'], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
return json.loads(read_output)['domains']
def get_domain(self, id=None, **dico):
filter_by_name = ""
if id:
dico['id'] = id
if 'name' in dico:
dico['name'] = dico['name'].lower()
filter_by_name = dico['name']
domains = self.list_domains_info(filter_by_name=filter_by_name)
for domain in domains:
for k in dico:
if k in domain and domain[k] == dico[k]:
return Domain(self, **domain)
raise UnknownDomain("Not found")
def get_zone(self, **dico):
filter_by_name_split = dico['name'].split('.')
ret = None
for i in range(len(filter_by_name_split),1,-1):
dico['name'] = ".".join(filter_by_name_split[-i:])
try: ret = self.get_domain(**dico)
except UnknownDomain: pass
if not ret: raise UnknownDomain
else: return ret
def get_domain_details(self, id=None):
"""Get details on a particular domain"""
parms = { 'showRecords': 'false', 'showSubdomains': 'false' }
response = self.make_request('GET', ['domains', str(id)], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
domains = json.loads(read_output)
return Domain(self, **domains)
# Take a reponse parse it if there is asyncResponse and wait for
# it (TODO: should offer to not)
def wait_for_async_request(self, response):
if (response.status < 200) or (response.status > 299):
_output = response.read().strip()
try:
output = json.loads(_output)
except ValueError:
output = None
api_reasons = ""
if output and 'validationErrors' in output:
for msg in output['validationErrors']['messages']:
api_reasons += " (%s)" % msg
raise ResponseError(response.status, response.reason+api_reasons)
output = json.loads(response.read())
jobId = output['jobId']
while True:
response = self.make_request('GET', ['status', jobId],
parms=['showDetails=True'])
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
_output = response.read().strip()
output = json.loads(_output)
if output['status'] == 'COMPLETED':
try:
return output['response']
except KeyError:
return output
if output['status'] == 'ERROR':
if (output['error']['code'] == 409 and
output['error']['details'] == 'Domain already exists'):
raise DomainAlreadyExists
if (output['error']['code'] == 409 and
output['error']['details'].find('belongs to another owner')):
raise NotDomainOwner
raise ResponseError(output['error']['code'],
output['error']['details'])
time.sleep(1)
continue
def _domain(self, name, ttl, emailAddress, comment=""):
if not ttl >= 300:
raise Exception("Ttl is a minimun of 300 seconds")
s = '<domain name="%s" ttl="%s" emailAddress="%s" comment="%s"></domain>'
return s % (name, ttl, emailAddress, comment)
def create_domain(self, name, ttl, emailAddress, comment=""):
domain = [name, ttl, emailAddress, comment]
return self.create_domains([domain])[0]
def create_domains(self, domains):
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
ret = []
for dom in domains:
ret.append(self._domain(*dom))
xml += "\n".join(ret)
xml += "</domains>"
response = self.make_request('POST', ['domains'], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output['domains']:
ret.append(Domain(connection=self, **domain))
return ret
def delete_domain(self, domain_id):
return self.delete_domains([domain_id])
def delete_domains(self, domains_id):
ret = ["id=%s" % (i) for i in domains_id]
response = self.make_request('DELETE',
['domains'],
parms=ret,
)
return self.wait_for_async_request(response)
def import_domain(self, bind_zone):
"""
Allows for a bind zone file to be imported in one operation. The
bind_zone parameter can be a string or a file object.
"""
if type(bind_zone) is file:
bind_zone = bind_zone.read()
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
xml += '<domain contentType="BIND_9">'
xml += '<contents>%s</contents>' % bind_zone
xml += '</domain></domains>'
response = self.make_request('POST', ['domains', 'import'], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output['domains']:
ret.append(Domain(self, **domain))
return ret
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: cdn_connect
@undocumented: http_connect
@undocumented: cdn_request
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=5, **kwargs):
"""
Accepts keyword arguments for Mosso username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword. Setting the argument
servicenet to True will make use of Rackspace servicenet network.
@type username: str
@param username: a Mosso username
@type api_key: str
@param api_key: a Mosso API key
@type servicenet: bool
@param servicenet: Use Rackspace servicenet to access Cloud Files.
@type cdn_log_retention: bool
@param cdn_log_retention: set logs retention for this cdn enabled
container.
"""
self.cdn_enabled = False
self.cdn_args = None
self.connection_args = None
self.cdn_connection = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.servicenet = kwargs.get('servicenet', False)
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
# if the environement variable RACKSPACE_SERVICENET is set (to
# anything) it will automatically set servicenet=True
if not 'servicenet' in kwargs \
and 'RACKSPACE_SERVICENET' in os.environ:
self.servicenet = True
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username,
api_key,
authurl=authurl,
useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.cdn_url, self.token) = self.auth.authenticate()
url = self._set_storage_url(url)
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
if self.cdn_url:
self.cdn_connect()
def _set_storage_url(self, url):
if self.servicenet:
return "https://snet-%s" % url.replace("https://", "")
return url
def cdn_connect(self):
"""
Setup the http connection instance for the CDN service.
"""
(host, port, cdn_uri, is_ssl) = parse_url(self.cdn_url)
self.cdn_connection = self.conn_class(host, port, timeout=self.timeout)
self.cdn_enabled = True
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def cdn_request(self, method, path=[], data='', hdrs=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, performs an http request against the CDN service.
"""
if not self.cdn_enabled:
raise CDNNotEnabled()
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
headers = {
'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token
}
if isinstance(hdrs, dict):
headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.cdn_connect()
self.cdn_connection.request(method, path, data, headers)
return self.cdn_connection.getresponse()
try:
self.cdn_connection.request(method, path, data, headers)
response = self.cdn_connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = \
['%s=%s' % (quote(x),
quote(str(y))) for (x, y) in parms.items()]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {
'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token
}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_info(self):
"""
Return tuple for number of containers and total bytes in the account
>>> connection.get_info()
(5, 2309749)
@rtype: tuple
@return: a tuple containing the number of containers and total bytes
used by the account
"""
response = self.make_request('HEAD')
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-account-container-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-account-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return (count, size)
def _check_container_name(self, container_name):
if not container_name or \
'/' in container_name or \
len(container_name) > consts.container_name_limit:
raise InvalidContainerName(container_name)
def create_container(self, container_name, error_on_existing=False):
"""
Given a container name, returns a L{Container} item, creating a new
Container if one does not already exist.
>>> connection.create_container('new_container')
<cloudfiles.container.Container object at 0xb77d628c>
@param container_name: name of the container to create
@type container_name: str
@param error_on_existing: raise ContainerExists if container already
exists
@type error_on_existing: bool
@rtype: L{Container}
@return: an object representing the newly created container
"""
self._check_container_name(container_name)
response = self.make_request('PUT', [container_name])
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
if error_on_existing and (response.status == 202):
raise ContainerExists(container_name)
return Container(self, container_name)
def delete_container(self, container_name):
"""
Given a container name, delete it.
>>> connection.delete_container('old_container')
@param container_name: name of the container to delete
@type container_name: str
"""
if isinstance(container_name, Container):
container_name = container_name.name
self._check_container_name(container_name)
response = self.make_request('DELETE', [container_name])
if (response.status == 409):
raise ContainerNotEmpty(container_name)
elif (response.status == 404):
raise NoSuchContainer
elif (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
if self.cdn_enabled:
response = self.cdn_request('POST', [container_name],
hdrs={'X-CDN-Enabled': 'False'})
def get_all_containers(self, limit=None, marker=None, **parms):
"""
Returns a Container item result set.
>>> connection.get_all_containers()
ContainerResults: 4 containers
>>> print ', '.join([container.name for container in
connection.get_all_containers()])
new_container, old_container, pictures, music
@rtype: L{ContainerResults}
@return: an iterable set of objects representing all containers on the
account
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
return ContainerResults(self, self.list_containers_info(**parms))
def get_container(self, container_name):
"""
Return a single Container item for the given Container.
>>> connection.get_container('old_container')
<cloudfiles.container.Container object at 0xb77d628c>
>>> container = connection.get_container('old_container')
>>> container.size_used
23074
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the container
"""
self._check_container_name(container_name)
response = self.make_request('HEAD', [container_name])
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-container-object-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-container-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if response.status == 404:
raise NoSuchContainer(container_name)
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name, count, size)
def list_public_containers(self):
"""
Returns a list of containers that have been published to the CDN.
>>> connection.list_public_containers()
['container1', 'container2', 'container3']
@rtype: list(str)
@return: a list of all CDN-enabled container names as strings
"""
response = self.cdn_request('GET', [''])
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def list_containers_info(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers, including object count and size.
>>> connection.list_containers_info()
[{u'count': 510, u'bytes': 2081717, u'name': u'new_container'},
{u'count': 12, u'bytes': 23074, u'name': u'old_container'},
{u'count': 0, u'bytes': 0, u'name': u'container1'},
{u'count': 0, u'bytes': 0, u'name': u'container2'},
{u'count': 0, u'bytes': 0, u'name': u'container3'},
{u'count': 3, u'bytes': 2306, u'name': u'test'}]
@rtype: list({"name":"...", "count":..., "bytes":...})
@return: a list of all container info as dictionaries with the
keys "name", "count", and "bytes"
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
parms['format'] = 'json'
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return json_loads(response.read())
def list_containers(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers.
>>> connection.list_containers()
['new_container',
'old_container',
'container1',
'container2',
'container3',
'test']
@rtype: list(str)
@return: a list of all containers names as strings
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def __getitem__(self, key):
"""
Container objects can be grabbed from a connection using index
syntax.
>>> container = conn['old_container']
>>> container.size_used
23074
@rtype: L{Container}
@return: an object representing the container
"""
return self.get_container(key)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: cdn_connect
@undocumented: http_connect
@undocumented: cdn_request
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, **kwargs):
"""
Accepts keyword arguments for Mosso username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Mosso username
@type api_key: str
@param api_key: a Mosso API key
"""
self.cdn_enabled = False
self.cdn_args = None
self.connection_args = None
self.cdn_connection = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
socket.setdefaulttimeout = int(kwargs.get('timeout', 5))
self.auth = kwargs.has_key('auth') and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.default_authurl)
if username and api_key and authurl:
self.auth = Authentication(username, api_key, authurl)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.cdn_url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
if self.cdn_url:
self.cdn_connect()
def cdn_connect(self):
"""
Setup the http connection instance for the CDN service.
"""
(host, port, cdn_uri, is_ssl) = parse_url(self.cdn_url)
conn_class = is_ssl and HTTPSConnection or HTTPConnection
self.cdn_connection = conn_class(host, port)
self.cdn_enabled = True
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port)
self.connection.set_debuglevel(self.debuglevel)
def cdn_request(self, method, path=[], data='', hdrs=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, performs an http request against the CDN service.
"""
if not self.cdn_enabled:
raise CDNNotEnabled()
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([quote(i) for i in path]))
headers = {'Content-Length': len(data), 'User-Agent': consts.user_agent,
'X-Auth-Token': self.token}
if isinstance(hdrs, dict):
headers.update(hdrs)
# Send the request
self.cdn_connection.request(method, path, data, headers)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.cdn_connect()
self.cdn_connection.request(method, path, data, headers)
return self.cdn_connection.getresponse()
try:
response = self.cdn_connection.getresponse()
except HTTPException:
response = retry_request()
if response.status == 401:
self._authenticate()
response = retry_request()
return response
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = \
['%s=%s' % (quote(x),quote(str(y))) for (x,y) in parms.items()]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {'Content-Length': len(data), 'User-Agent': consts.user_agent,
'X-Auth-Token': self.token}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except HTTPException:
response = retry_request()
if response.status == 401:
self._authenticate()
response = retry_request()
return response
def get_info(self):
"""
Return tuple for number of containers and total bytes in the account
>>> connection.get_info()
(5, 2309749)
@rtype: tuple
@return: a tuple containing the number of containers and total bytes
used by the account
"""
response = self.make_request('HEAD')
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-account-container-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-account-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return (count, size)
def _check_container_name(self, container_name):
if not container_name or \
'/' in container_name or \
len(container_name) > consts.container_name_limit:
raise InvalidContainerName(container_name)
def create_container(self, container_name):
"""
Given a container name, returns a L{Container} item, creating a new
Container if one does not already exist.
>>> connection.create_container('new_container')
<cloudfiles.container.Container object at 0xb77d628c>
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the newly created container
"""
self._check_container_name(container_name)
response = self.make_request('PUT', [container_name])
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name)
def delete_container(self, container_name):
"""
Given a container name, delete it.
>>> connection.delete_container('old_container')
@param container_name: name of the container to delete
@type container_name: str
"""
if isinstance(container_name, Container):
container_name = container_name.name
self._check_container_name(container_name)
response = self.make_request('DELETE', [container_name])
buff = response.read()
if (response.status == 409):
raise ContainerNotEmpty(container_name)
elif (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
if self.cdn_enabled:
response = self.cdn_request('POST', [container_name],
hdrs={'X-CDN-Enabled': 'False'})
def get_all_containers(self, limit=None, marker=None, **parms):
"""
Returns a Container item result set.
>>> connection.get_all_containers()
ContainerResults: 4 containers
>>> print ', '.join([container.name for container in
connection.get_all_containers()])
new_container, old_container, pictures, music
@rtype: L{ContainerResults}
@return: an iterable set of objects representing all containers on the
account
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
return ContainerResults(self, self.list_containers_info(**parms))
def get_container(self, container_name):
"""
Return a single Container item for the given Container.
>>> connection.get_container('old_container')
<cloudfiles.container.Container object at 0xb77d628c>
>>> container = connection.get_container('old_container')
>>> container.size_used
23074
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the container
"""
self._check_container_name(container_name)
response = self.make_request('HEAD', [container_name])
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-container-object-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-container-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if response.status == 404:
raise NoSuchContainer(container_name)
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name, count, size)
def list_public_containers(self):
"""
Returns a list of containers that have been published to the CDN.
>>> connection.list_public_containers()
['container1', 'container2', 'container3']
@rtype: list(str)
@return: a list of all CDN-enabled container names as strings
"""
response = self.cdn_request('GET', [''])
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def list_containers_info(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers, including object count and size.
>>> connection.list_containers_info()
[{u'count': 510, u'bytes': 2081717, u'name': u'new_container'},
{u'count': 12, u'bytes': 23074, u'name': u'old_container'},
{u'count': 0, u'bytes': 0, u'name': u'container1'},
{u'count': 0, u'bytes': 0, u'name': u'container2'},
{u'count': 0, u'bytes': 0, u'name': u'container3'},
{u'count': 3, u'bytes': 2306, u'name': u'test'}]
@rtype: list({"name":"...", "count":..., "bytes":...})
@return: a list of all container info as dictionaries with the
keys "name", "count", and "bytes"
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
parms['format'] = 'json'
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return json_loads(response.read())
def list_containers(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers.
>>> connection.list_containers()
['new_container',
'old_container',
'container1',
'container2',
'container3',
'test']
@rtype: list(str)
@return: a list of all containers names as strings
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def __getitem__(self, key):
"""
Container objects can be grabbed from a connection using index
syntax.
>>> container = conn['old_container']
>>> container.size_used
23074
@rtype: L{Container}
@return: an object representing the container
"""
return self.get_container(key)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
create container ---> PUT
delete container ---> DELETE
rename container ---> POST 没实现
set ACL ---> POST 没实现
get container ---> GET
get info ---> HEAD
list containers ---> GET 解析json数据
_authenticate ---> 认证
http_connect ---> 生成conn连接
make_request ---> 向服务端发送http请求
"""
def __init__(self, username=None, api_key=None, timeout=5, **kwargs):
"""
Accepts keyword arguments for chouti username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a chouti username, pattern is account:admin
@type api_key: str
@param api_key: a chouti password
container.
"""
self.connection_args = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.servicenet = kwargs.get('servicenet', False)
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
self.username = username
self.api_key = api_key
self._share_user_uri = kwargs.get('_share_user_uri', None)
self._share_request = kwargs.get('_share_request', False)
if kwargs.get('share_request', False):
# 产生一个专为共享请求的请求连接方法
self.make_request = self.make_share_requst
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.chouti_authurl)
if username and api_key and authurl:
# 此处的auth为Authentication类的实例
self.auth = Authentication(username, api_key, authurl=authurl,
useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
私有方法，开始认证
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
def authorization(self, url=None):
"""
授权功能
@type url: str
@param url: 用户接收到的共享文件的链接. url需要解析，解析出container与object
先认证授权，成功后返回连接对象，此对象所使用的make_request均为share_request
"""
path = []
self._share_user_uri, cont = url.rsplit('/', 1)
# 临时开关，临时使用share_request
self._share_request = True
path.append(cont)
resp = self.make_request('HEAD', path)
if resp.status == 204:
self._share_request = False
return Connection(self.username, self.api_key, _share_request=True, _share_user_uri = self._share_user_uri)
else:
self._share_request = False
return None
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
# roamin9 set the authorization conn's right uri
if self._share_request:
self.uri = self._share_user_uri
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
@type method: str
@param method: http method
@type path: list
@param path: the url's path, include [container_name], [obj_name]
@type hdrs: dict
@param hdrs: http headers
@type parms: dict
@param parms: query args
"""
if self._share_request and self._share_user_uri:
path = '/%s/%s' % \
(self._share_user_uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
else:
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
# 查询参数中的变量是固定的，为limits等字符，都为英文字符
# 但查询参数中的值有可能是unicode值，
# 因此，对于对于查询参数中的值需要进行unicode处理，使用unicode_quote()
# 这应该算一个bug，可以提交给作者
query_args = \
['%s=%s' % (unicode_quote(x),
unicode_quote(y)) for (x, y) in parms.items()]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {
# 设置了Content-Length，这样上传或下载文件时需要优化一下
'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token
}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_info(self):
"""
Return tuple for number of containers and total bytes in the account
>>> connection.get_info()
(5, 2309749)
@rtype: tuple
@return: a tuple containing the number of containers and total bytes
used by the account
"""
response = self.make_request('HEAD')
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-account-container-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-account-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return (count, size)
def _check_container_name(self, container_name):
# container名称中不能包含'/'
if not container_name or \
'/' in container_name or \
len(container_name) > consts.container_name_limit:
raise InvalidContainerName(container_name)
def create_container(self, container_name):
"""
Given a container name, returns a L{Container} item, creating a new
Container if one does not already exist.
>>> connection.create_container('new_container')
<cloudfiles.container.Container object at 0xb77d628c>
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the newly created container
"""
self._check_container_name(container_name)
response = self.make_request('PUT', [container_name])
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name)
def delete_container(self, container_name):
"""
Given a container name, delete it.
>>> connection.delete_container('old_container')
@param container_name: name of the container to delete
@type container_name: str
"""
# Container类的实例
if isinstance(container_name, Container):
container_name = container_name.name
self._check_container_name(container_name)
response = self.make_request('DELETE', [container_name])
if (response.status == 409):
raise ContainerNotEmpty(container_name)
elif (response.status == 404):
raise NoSuchContainer
elif (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
# 一旦删除了一个container，需要标记CDN的状态为关闭
#if self.cdn_enabled:
# response = self.cdn_request('POST', [container_name],
# hdrs={'X-CDN-Enabled': 'False'})
def get_all_containers(self, limit=None, marker=None, **parms):
"""
Returns a Container item result set.
>>> connection.get_all_containers()
ContainerResults: 4 containers
>>> print ', '.join([container.name for container in
connection.get_all_containers()])
new_container, old_container, pictures, music
@rtype: L{ContainerResults}
@return: an iterable set of objects representing all containers on the
account
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
return ContainerResults(self, self.list_containers_info(**parms))
def get_container(self, container_name):
"""
Return a single Container item for the given Container.
>>> connection.get_container('old_container')
<cloudfiles.container.Container object at 0xb77d628c>
>>> container = connection.get_container('old_container')
>>> container.size_used
23074
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the container
"""
self._check_container_name(container_name)
response = self.make_request('HEAD', [container_name])
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-container-object-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-container-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if response.status == 404:
raise NoSuchContainer(container_name)
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name, count, size)
#def list_public_containers(self):
# """
# Returns a list of containers that have been published to the CDN.
# >>> connection.list_public_containers()
# ['container1', 'container2', 'container3']
# @rtype: list(str)
# @return: a list of all CDN-enabled container names as strings
# """
# response = self.cdn_request('GET', [''])
# if (response.status < 200) or (response.status > 299):
# buff = response.read()
# raise ResponseError(response.status, response.reason)
# return response.read().splitlines()
def list_containers_info(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers, including object count and size.
>>> connection.list_containers_info()
[{u'count': 510, u'bytes': 2081717, u'name': u'new_container'},
{u'count': 12, u'bytes': 23074, u'name': u'old_container'},
{u'count': 0, u'bytes': 0, u'name': u'container1'},
{u'count': 0, u'bytes': 0, u'name': u'container2'},
{u'count': 0, u'bytes': 0, u'name': u'container3'},
{u'count': 3, u'bytes': 2306, u'name': u'test'}]
@rtype: list({"name":"...", "count":..., "bytes":...})
@return: a list of all container info as dictionaries with the
keys "name", "count", and "bytes"
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
parms['format'] = 'json'
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return json_loads(response.read())
def list_containers(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers.
>>> connection.list_containers()
['new_container',
'old_container',
'container1',
'container2',
'container3',
'test']
@rtype: list(str)
@return: a list of all containers names as strings
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def __getitem__(self, key):
"""
Container objects can be grabbed from a connection using index
syntax.
>>> container = conn['old_container']
>>> container.size_used
23074
@rtype: L{Container}
@return: an object representing the container
"""
return self.get_container(key)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: cdn_connect
@undocumented: http_connect
@undocumented: cdn_request
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=15, **kwargs):
"""
Accepts keyword arguments for Mosso username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword. Setting the argument
servicenet to True will make use of Rackspace servicenet network.
@type username: str
@param username: a Mosso username
@type api_key: str
@param api_key: a Mosso API key
@type servicenet: bool
@param servicenet: Use Rackspace servicenet to access Cloud Files.
@type cdn_log_retention: bool
@param cdn_log_retention: set logs retention for this cdn enabled
container.
"""
self.cdn_enabled = False
self.cdn_args = None
self.connection_args = None
self.cdn_connection = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.servicenet = kwargs.get('servicenet', False)
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
# if the environement variable RACKSPACE_SERVICENET is set (to
# anything) it will automatically set servicenet=True
if not 'servicenet' in kwargs \
and 'RACKSPACE_SERVICENET' in os.environ:
self.servicenet = True
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username, api_key, authurl=authurl,
useragent=self.user_agent, timeout=self.timeout)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.cdn_url, self.token) = self.auth.authenticate()
url = self._set_storage_url(url)
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
if self.cdn_url:
self.cdn_connect()
def _set_storage_url(self, url):
if self.servicenet:
return "https://snet-%s" % url.replace("https://", "")
return url
def cdn_connect(self):
"""
Setup the http connection instance for the CDN service.
"""
(host, port, cdn_uri, is_ssl) = parse_url(self.cdn_url)
self.cdn_connection = self.conn_class(host, port, timeout=self.timeout)
self.cdn_enabled = True
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def cdn_request(self, method, path=[], data='', hdrs=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, performs an http request against the CDN service.
"""
if not self.cdn_enabled:
raise CDNNotEnabled()
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
headers = {'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token}
if isinstance(hdrs, dict):
headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.cdn_connect()
self.cdn_connection.request(method, path, data, headers)
return self.cdn_connection.getresponse()
try:
self.cdn_connection.request(method, path, data, headers)
response = self.cdn_connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
path = '%s?%s' % (path, urlencode(parms))
headers = {'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_info(self):
"""
Return tuple for number of containers, total bytes in the account and account metadata
>>> connection.get_info()
(5, 2309749)
@rtype: tuple
@return: a tuple containing the number of containers, total bytes
used by the account and a dictionary containing account metadata
"""
response = self.make_request('HEAD')
count = size = None
metadata = {}
for hdr in response.getheaders():
if hdr[0].lower() == 'x-account-container-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-account-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
if hdr[0].lower().startswith('x-account-meta-'):
metadata[hdr[0].lower()[15:]] = hdr[1]
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return (count, size, metadata)
def update_account_metadata(self, metadata):
"""
Update account metadata
>>> metadata = {'x-account-meta-foo' : 'bar'}
>>> connection.update_account_metadata(metadata)
@param metadata: Dictionary of metadata
@type metdada: dict
"""
response = self.make_request('POST', hdrs=metadata)
response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
def _check_container_name(self, container_name):
if not container_name or \
'/' in container_name or \
len(container_name) > consts.container_name_limit:
raise InvalidContainerName(container_name)
def create_container(self, container_name, error_on_existing=False):
"""
Given a container name, returns a L{Container} item, creating a new
Container if one does not already exist.
>>> connection.create_container('new_container')
<cloudfiles.container.Container object at 0xb77d628c>
@param container_name: name of the container to create
@type container_name: str
@param error_on_existing: raise ContainerExists if container already
exists
@type error_on_existing: bool
@rtype: L{Container}
@return: an object representing the newly created container
"""
self._check_container_name(container_name)
response = self.make_request('PUT', [container_name])
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
if error_on_existing and (response.status == 202):
raise ContainerExists(container_name)
return Container(self, container_name)
def delete_container(self, container_name):
"""
Given a container name, delete it.
>>> connection.delete_container('old_container')
@param container_name: name of the container to delete
@type container_name: str
"""
if isinstance(container_name, Container):
container_name = container_name.name
self._check_container_name(container_name)
response = self.make_request('DELETE', [container_name])
response.read()
if (response.status == 409):
raise ContainerNotEmpty(container_name)
elif (response.status == 404):
raise NoSuchContainer
elif (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
if self.cdn_enabled:
response = self.cdn_request('POST', [container_name],
hdrs={'X-CDN-Enabled': 'False'})
def get_all_containers(self, limit=None, marker=None, **parms):
"""
Returns a Container item result set.
>>> connection.get_all_containers()
ContainerResults: 4 containers
>>> print ', '.join([container.name for container in
connection.get_all_containers()])
new_container, old_container, pictures, music
@rtype: L{ContainerResults}
@return: an iterable set of objects representing all containers on the
account
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
return ContainerResults(self, self.list_containers_info(**parms))
def get_container(self, container_name):
"""
Return a single Container item for the given Container.
>>> connection.get_container('old_container')
<cloudfiles.container.Container object at 0xb77d628c>
>>> container = connection.get_container('old_container')
>>> container.size_used
23074
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the container
"""
self._check_container_name(container_name)
response = self.make_request('HEAD', [container_name])
count = size = None
metadata = {}
for hdr in response.getheaders():
if hdr[0].lower() == 'x-container-object-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-container-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
if hdr[0].lower().startswith('x-container-meta-'):
metadata[hdr[0].lower()[17:]] = hdr[1]
buff = response.read()
if response.status == 404:
raise NoSuchContainer(container_name)
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name, count, size, metadata)
def list_public_containers(self):
"""
Returns a list of containers that have been published to the CDN.
>>> connection.list_public_containers()
['container1', 'container2', 'container3']
@rtype: list(str)
@return: a list of all CDN-enabled container names as strings
"""
response = self.cdn_request('GET', [''])
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def list_containers_info(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers, including object count and size.
>>> connection.list_containers_info()
[{u'count': 510, u'bytes': 2081717, u'name': u'new_container'},
{u'count': 12, u'bytes': 23074, u'name': u'old_container'},
{u'count': 0, u'bytes': 0, u'name': u'container1'},
{u'count': 0, u'bytes': 0, u'name': u'container2'},
{u'count': 0, u'bytes': 0, u'name': u'container3'},
{u'count': 3, u'bytes': 2306, u'name': u'test'}]
@rtype: list({"name":"...", "count":..., "bytes":...})
@return: a list of all container info as dictionaries with the
keys "name", "count", and "bytes"
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
parms['format'] = 'json'
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return json_loads(response.read())
def list_containers(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers.
>>> connection.list_containers()
['new_container',
'old_container',
'container1',
'container2',
'container3',
'test']
@rtype: list(str)
@return: a list of all containers names as strings
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def __getitem__(self, key):
"""
Container objects can be grabbed from a connection using index
syntax.
>>> container = conn['old_container']
>>> container.size_used
23074
@rtype: L{Container}
@return: an object representing the container
"""
return self.get_container(key)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
create container ---> PUT
delete container ---> DELETE
rename container ---> POST 没实现
set ACL ---> POST 没实现
get container ---> GET
get info ---> HEAD
list containers ---> GET 解析json数据
_authenticate ---> 认证
http_connect ---> 生成conn连接
make_request ---> 向服务端发送http请求
"""
def __init__(self, username=None, api_key=None, timeout=5, **kwargs):
"""
Accepts keyword arguments for chouti username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a chouti username, pattern is account:admin
@type api_key: str
@param api_key: a chouti password
container.
"""
self.connection_args = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.servicenet = kwargs.get('servicenet', False)
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
self.username = username
self.api_key = api_key
self._share_user_uri = kwargs.get('_share_user_uri', None)
self._share_request = kwargs.get('_share_request', False)
if kwargs.get('share_request', False):
# 产生一个专为共享请求的请求连接方法
self.make_request = self.make_share_requst
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.chouti_authurl)
if username and api_key and authurl:
# 此处的auth为Authentication类的实例
self.auth = Authentication(username,
api_key,
authurl=authurl,
useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
私有方法，开始认证
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
def authorization(self, url=None):
"""
授权功能
@type url: str
@param url: 用户接收到的共享文件的链接. url需要解析，解析出container与object
先认证授权，成功后返回连接对象，此对象所使用的make_request均为share_request
"""
path = []
self._share_user_uri, cont = url.rsplit('/', 1)
# 临时开关，临时使用share_request
self._share_request = True
path.append(cont)
resp = self.make_request('HEAD', path)
if resp.status == 204:
self._share_request = False
return Connection(self.username,
self.api_key,
_share_request=True,
_share_user_uri=self._share_user_uri)
else:
self._share_request = False
return None
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
# roamin9 set the authorization conn's right uri
if self._share_request:
self.uri = self._share_user_uri
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
@type method: str
@param method: http method
@type path: list
@param path: the url's path, include [container_name], [obj_name]
@type hdrs: dict
@param hdrs: http headers
@type parms: dict
@param parms: query args
"""
if self._share_request and self._share_user_uri:
path = '/%s/%s' % \
(self._share_user_uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
else:
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
# 查询参数中的变量是固定的，为limits等字符，都为英文字符
# 但查询参数中的值有可能是unicode值，
# 因此，对于对于查询参数中的值需要进行unicode处理，使用unicode_quote()
# 这应该算一个bug，可以提交给作者
query_args = \
['%s=%s' % (unicode_quote(x),
unicode_quote(y)) for (x, y) in parms.items()]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {
# 设置了Content-Length，这样上传或下载文件时需要优化一下
'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token
}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_info(self):
"""
Return tuple for number of containers and total bytes in the account
>>> connection.get_info()
(5, 2309749)
@rtype: tuple
@return: a tuple containing the number of containers and total bytes
used by the account
"""
response = self.make_request('HEAD')
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-account-container-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-account-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return (count, size)
def _check_container_name(self, container_name):
# container名称中不能包含'/'
if not container_name or \
'/' in container_name or \
len(container_name) > consts.container_name_limit:
raise InvalidContainerName(container_name)
def create_container(self, container_name):
"""
Given a container name, returns a L{Container} item, creating a new
Container if one does not already exist.
>>> connection.create_container('new_container')
<cloudfiles.container.Container object at 0xb77d628c>
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the newly created container
"""
self._check_container_name(container_name)
response = self.make_request('PUT', [container_name])
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name)
def delete_container(self, container_name):
"""
Given a container name, delete it.
>>> connection.delete_container('old_container')
@param container_name: name of the container to delete
@type container_name: str
"""
# Container类的实例
if isinstance(container_name, Container):
container_name = container_name.name
self._check_container_name(container_name)
response = self.make_request('DELETE', [container_name])
if (response.status == 409):
raise ContainerNotEmpty(container_name)
elif (response.status == 404):
raise NoSuchContainer
elif (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
# 一旦删除了一个container，需要标记CDN的状态为关闭
#if self.cdn_enabled:
# response = self.cdn_request('POST', [container_name],
# hdrs={'X-CDN-Enabled': 'False'})
def get_all_containers(self, limit=None, marker=None, **parms):
"""
Returns a Container item result set.
>>> connection.get_all_containers()
ContainerResults: 4 containers
>>> print ', '.join([container.name for container in
connection.get_all_containers()])
new_container, old_container, pictures, music
@rtype: L{ContainerResults}
@return: an iterable set of objects representing all containers on the
account
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
return ContainerResults(self, self.list_containers_info(**parms))
def get_container(self, container_name):
"""
Return a single Container item for the given Container.
>>> connection.get_container('old_container')
<cloudfiles.container.Container object at 0xb77d628c>
>>> container = connection.get_container('old_container')
>>> container.size_used
23074
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the container
"""
self._check_container_name(container_name)
response = self.make_request('HEAD', [container_name])
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-container-object-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-container-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if response.status == 404:
raise NoSuchContainer(container_name)
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name, count, size)
#def list_public_containers(self):
# """
# Returns a list of containers that have been published to the CDN.
# >>> connection.list_public_containers()
# ['container1', 'container2', 'container3']
# @rtype: list(str)
# @return: a list of all CDN-enabled container names as strings
# """
# response = self.cdn_request('GET', [''])
# if (response.status < 200) or (response.status > 299):
# buff = response.read()
# raise ResponseError(response.status, response.reason)
# return response.read().splitlines()
def list_containers_info(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers, including object count and size.
>>> connection.list_containers_info()
[{u'count': 510, u'bytes': 2081717, u'name': u'new_container'},
{u'count': 12, u'bytes': 23074, u'name': u'old_container'},
{u'count': 0, u'bytes': 0, u'name': u'container1'},
{u'count': 0, u'bytes': 0, u'name': u'container2'},
{u'count': 0, u'bytes': 0, u'name': u'container3'},
{u'count': 3, u'bytes': 2306, u'name': u'test'}]
@rtype: list({"name":"...", "count":..., "bytes":...})
@return: a list of all container info as dictionaries with the
keys "name", "count", and "bytes"
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
parms['format'] = 'json'
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return json_loads(response.read())
def list_containers(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers.
>>> connection.list_containers()
['new_container',
'old_container',
'container1',
'container2',
'container3',
'test']
@rtype: list(str)
@return: a list of all containers names as strings
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def __getitem__(self, key):
"""
Container objects can be grabbed from a connection using index
syntax.
>>> container = conn['old_container']
>>> container.size_used
23074
@rtype: L{Container}
@return: an object representing the container
"""
return self.get_container(key)
def main():
with open("config.json", "r") as config_file:
config = json.load(config_file)
MAPSERVER_URL = config["mapServerUrl"]
GENERATE_TOKEN_URL = config["generateTokenUrl"]
MINIMUM_ZOOM_LEVEL = config["minimumZoomLevel"]
MAXIMUM_ZOOM_LEVEL = config["maximumZoomlevel"]
USERNAME = os.getenv('TILESET_GENERATOR_USERNAME')
PASSWORD = os.getenv('TILESET_GENERATOR_PASSWORD')
TPK = config["tpk"]
XYZ = config["xyz"]
ZIP = config["zip"]
tiles_folder = pathlib.Path('tiles')
if tiles_folder.exists() and tiles_folder.is_dir():
shutil.rmtree("tiles")
os.mkdir("tiles")
authentication = Authentication(GENERATE_TOKEN_URL)
token = authentication.authenticate(USERNAME, PASSWORD)
downloader = Downloader(token, MAPSERVER_URL)
zoom_levels = f"{str(MINIMUM_ZOOM_LEVEL)}-{str(MAXIMUM_ZOOM_LEVEL)}"
for shapefile in glob.glob("shapefiles/*.shp"):
attempt = 1
success = False
print(f"\nWorking on shapefile: {shapefile}")
while attempt < 3 and success == False:
try:
downloaded_tpk_location = downloader.download(
shapefile, zoom_levels)
shapefile_tiles_folder = pathlib.Path(
downloaded_tpk_location).parents[1]
print("Extracting tiles...")
with tpkutils.TPK(downloaded_tpk_location) as tpk:
zoom_list = list(
range(MINIMUM_ZOOM_LEVEL, MAXIMUM_ZOOM_LEVEL + 1))
tpk.to_disk(f"{shapefile_tiles_folder}/xyz",
zoom=zoom_list, drop_empty=True)
print("Zipping tiles...")
shutil.make_archive(
f"{shapefile_tiles_folder}/zip/layer", 'zip', f"{shapefile_tiles_folder}/xyz")
if TPK == False:
shutil.rmtree(f"{shapefile_tiles_folder}/tpk")
print("Deleting TPK file...")
if XYZ == False:
shutil.rmtree(f"{shapefile_tiles_folder}/xyz")
print("Deleting XYZ files...")
if ZIP == False:
shutil.rmtree(f"{shapefile_tiles_folder}/zip")
print("Deleting ZIP file...")
print("Done!")
success = True
except exceptions.InvalidTokenException:
print("Token expired, generating a new one...")
token = authentication.authenticate(USERNAME, PASSWORD)
downloader = Downloader(token, MAPSERVER_URL)
continue
except Exception as exception:
print("Unexpected error: ", exception)
attempt = attempt + 1
continue
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: http_connect
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=10, **kwargs):
"""
Accepts keyword arguments for Rackspace Cloud username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Rackspace Cloud username
@type api_key: str
@param api_key: a Rackspace Cloud API key
"""
self.connection_args = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
self._total_domains = -1
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username,
api_key,
authurl=authurl,
useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
@property
def total_domains(self):
if self._total_domains == -1:
self.list_domains_info(offset=0, limit=1)
return self._total_domains
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
def convert_iso_datetime(self, dt):
"""
Convert iso8601 to datetime
"""
isoFormat = "%Y-%m-%dT%H:%M:%S.000+0000"
if type(dt) is datetime.datetime:
return dt
if dt.endswith("Z"):
dt = dt.split('Z')[0]
isoFormat = "%Y-%m-%dT%H:%M:%S"
return datetime.datetime.strptime(dt, isoFormat)
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
query_args = ""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join(
[unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = \
['%s=%s' % (quote(x),
quote(str(y))) for (x, y) in parms.items()]
elif isinstance(parms, list) and parms:
query_args = \
["%s" % x for x in parms]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {
'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token,
'Content-Type': 'application/xml'
}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
if 'PYTHON_CLOUDDNS_DEBUG' in os.environ and \
os.environ['PYTHON_CLOUDDNS_DEBUG'].strip():
import sys
url = "https://%s%s\n" % \
(self.connection_args[0],
path)
sys.stderr.write("METHOD: %s\n" % (str(method)))
sys.stderr.write("URL: %s" % (url))
sys.stderr.write("HEADERS: %s\n" % (str(headers)))
sys.stderr.write("DATA: %s\n" % (str(data)))
sys.stderr.write("curl -X '%s' -H 'X-Auth-Token: %s' %s %s" % \
(method, self.token, url, str(data)))
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_domains(self, name=None, offset=0, limit=None):
return DomainResults(self, self.list_domains_info(name, offset, limit))
def list_domains_info(self, name=None, offset=0, limit=None):
if offset != 0:
if limit is None:
raise ValueError('limit must be specified when setting offset')
elif offset % limit > 0:
raise ValueError(
'offset (%d) must be a multiple of limit (%d)' %
(offset, limit))
if limit is None:
limit = int(ceil(self.total_domains / 100.0) * 100)
domains = []
step = min(limit, 100) if limit > 0 else 1
for _offset in xrange(offset, offset + limit, step):
resp = self._list_domains_info_raw(name, _offset, step)
domains_info = json.loads(resp)
if 'totalEntries' in domains_info:
self._total_domains = domains_info['totalEntries']
domains.extend(domains_info['domains'])
return domains[:limit]
def _list_domains_info_raw(self, name, offset, limit):
parms = {'offset': offset, 'limit': limit}
if name is not None:
parms.update({'name': name})
response = self.make_request('GET', ['domains'], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
return response.read()
def get_domain(self, id=None, **dico):
if id:
dico['id'] = id
if 'name' in dico:
dico['name'] = dico['name'].lower()
domains = self.list_domains_info(name=dico.get('name', None))
for domain in domains:
for k in dico:
if k in domain and domain[k] == dico[k]:
return Domain(self, **domain)
raise UnknownDomain("Not found")
def get_domain_details(self, id=None):
"""Get details on a particular domain"""
parms = {'showRecords': 'false', 'showSubdomains': 'false'}
response = self.make_request('GET', ['domains', str(id)], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
domains = json.loads(read_output)
return Domain(self, **domains)
# Take a reponse parse it if there is asyncResponse and wait for
# it (TODO: should offer to not)
def wait_for_async_request(self, response):
if (response.status < 200) or (response.status > 299):
_output = response.read().strip()
try:
output = json.loads(_output)
except ValueError:
output = None
api_reasons = ""
if output and 'validationErrors' in output:
for msg in output['validationErrors']['messages']:
api_reasons += " (%s)" % msg
raise ResponseError(response.status, response.reason + api_reasons)
output = json.loads(response.read())
jobId = output['jobId']
while True:
response = self.make_request('GET', ['status', jobId],
parms=['showDetails=True'])
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
_output = response.read().strip()
output = json.loads(_output)
if output['status'] == 'COMPLETED':
try:
return output['response']
except KeyError:
return output
if output['status'] == 'ERROR':
if (output['error']['code'] == 409 and
output['error']['details'] == 'Domain already exists'):
raise DomainAlreadyExists
if (output['error']['code'] == 409 and output['error']
['details'].find('belongs to another owner')):
raise NotDomainOwner
raise ResponseError(output['error']['code'],
output['error']['details'])
time.sleep(1)
continue
def _domain(self, name, ttl, emailAddress, comment=""):
if not ttl >= 300:
raise Exception("Ttl is a minimun of 300 seconds")
s = '<domain name="%s" ttl="%s" emailAddress="%s" comment="%s"></domain>'
return s % (name, ttl, emailAddress, comment)
def create_domain(self, name, ttl, emailAddress, comment=""):
domain = [name, ttl, emailAddress, comment]
return self.create_domains([domain])[0]
def create_domains(self, domains):
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
ret = []
for dom in domains:
ret.append(self._domain(*dom))
xml += "\n".join(ret)
xml += "</domains>"
response = self.make_request('POST', ['domains'], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output['domains']:
ret.append(Domain(connection=self, **domain))
return ret
def delete_domain(self, domain_id):
return self.delete_domains([domain_id])
def delete_domains(self, domains_id):
ret = ["id=%s" % (i) for i in domains_id]
response = self.make_request(
'DELETE',
['domains'],
parms=ret,
)
return self.wait_for_async_request(response)
def import_domain(self, bind_zone):
"""
Allows for a bind zone file to be imported in one operation. The
bind_zone parameter can be a string or a file object.
"""
if type(bind_zone) is file:
bind_zone = bind_zone.read()
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
xml += '<domain contentType="BIND_9">'
xml += '<contents>%s</contents>' % bind_zone
xml += '</domain></domains>'
response = self.make_request('POST', ['domains', 'import'], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output['domains']:
ret.append(Domain(self, **domain))
return ret
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: cdn_connect
@undocumented: http_connect
@undocumented: cdn_request
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, **kwargs):
"""
Accepts keyword arguments for Mosso username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Mosso username
@type api_key: str
@param api_key: a Mosso API key
"""
self.cdn_enabled = False
self.cdn_args = None
self.connection_args = None
self.cdn_connection = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
socket.setdefaulttimeout = int(kwargs.get('timeout', 5))
self.auth = kwargs.has_key('auth') and kwargs['auth'] or None
self.request_id = kwargs.get('request_id', None)
# If use_cdn is set to False,
# never make cdn requests regardless of whether cdn
# is turned on for the account.
self.use_cdn = kwargs.get('use_cdn', True)
if not self.auth:
authurl = kwargs.get('authurl', consts.default_authurl)
if username and api_key and authurl:
self.auth = Authentication(username, api_key, authurl)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.cdn_url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
if self.use_cdn and self.cdn_url:
self.cdn_connect()
def cdn_connect(self):
"""
Setup the http connection instance for the CDN service.
"""
(host, port, cdn_uri, is_ssl) = parse_url(self.cdn_url)
conn_class = is_ssl and HTTPSConnection or HTTPConnection
self.cdn_connection = conn_class(host, port)
self.cdn_enabled = True
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port)
self.connection.set_debuglevel(self.debuglevel)
def cdn_request(self, method, path=[], data='', hdrs=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, performs an http request against the CDN service.
"""
if not self.cdn_enabled:
raise CDNNotEnabled()
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([quote(i) for i in path]))
headers = {
'Content-Length': len(data),
'User-Agent': consts.user_agent,
'X-Auth-Token': self.token
}
if isinstance(hdrs, dict):
headers.update(hdrs)
self._log_request(self.cdn_connection, method, path, headers)
# Send the request
self.cdn_connection.request(method, path, data, headers)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.cdn_connect()
self.cdn_connection.request(method, path, data, headers)
return self.cdn_connection.getresponse()
try:
response = self.cdn_connection.getresponse()
self._log_response(response)
except HTTPException as e:
self._log_http_exception(e)
response = retry_request()
self._log_response(response, log.error)
if response.status == 401:
self._authenticate()
response = retry_request()
self._log_response(response, log.error)
return response
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join([quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = \
['%s=%s' % (quote(x),quote(str(y))) for (x,y) in parms.items()]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {
'Content-Length': len(data),
'User-Agent': consts.user_agent,
'X-Auth-Token': self.token
}
isinstance(hdrs, dict) and headers.update(hdrs)
self._log_request(self.connection, method, path, headers)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
self._log_response(response)
except HTTPException as e:
self._log_http_exception(e)
response = retry_request()
self._log_response(response, log.error)
if response.status == 401:
self._authenticate()
response = retry_request()
self._log_response(response, log.error)
return response
def get_info(self):
"""
Return tuple for number of containers and total bytes in the account
>>> connection.get_info()
(5, 2309749)
@rtype: tuple
@return: a tuple containing the number of containers and total bytes
used by the account
"""
response = self.make_request('HEAD')
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-account-container-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-account-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return (count, size)
def _check_container_name(self, container_name):
if not container_name or \
'/' in container_name or \
len(container_name) > consts.container_name_limit:
raise InvalidContainerName(container_name)
def create_container(self, container_name):
"""
Given a container name, returns a L{Container} item, creating a new
Container if one does not already exist.
>>> connection.create_container('new_container')
<cloudfiles.container.Container object at 0xb77d628c>
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the newly created container
"""
self._check_container_name(container_name)
response = self.make_request('PUT', [container_name])
buff = response.read()
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name)
def delete_container(self, container_name):
"""
Given a container name, delete it.
>>> connection.delete_container('old_container')
@param container_name: name of the container to delete
@type container_name: str
"""
if isinstance(container_name, Container):
container_name = container_name.name
self._check_container_name(container_name)
response = self.make_request('DELETE', [container_name])
buff = response.read()
if (response.status == 409):
raise ContainerNotEmpty(container_name)
elif (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
if self.cdn_enabled:
response = self.cdn_request('POST', [container_name],
hdrs={'X-CDN-Enabled': 'False'})
def get_all_containers(self, limit=None, marker=None, **parms):
"""
Returns a Container item result set.
>>> connection.get_all_containers()
ContainerResults: 4 containers
>>> print ', '.join([container.name for container in
connection.get_all_containers()])
new_container, old_container, pictures, music
@rtype: L{ContainerResults}
@return: an iterable set of objects representing all containers on the
account
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
return ContainerResults(self, self.list_containers_info(**parms))
def get_container(self, container_name):
"""
Return a single Container item for the given Container.
>>> connection.get_container('old_container')
<cloudfiles.container.Container object at 0xb77d628c>
>>> container = connection.get_container('old_container')
>>> container.size_used
23074
@param container_name: name of the container to create
@type container_name: str
@rtype: L{Container}
@return: an object representing the container
"""
self._check_container_name(container_name)
response = self.make_request('HEAD', [container_name])
count = size = None
for hdr in response.getheaders():
if hdr[0].lower() == 'x-container-object-count':
try:
count = int(hdr[1])
except ValueError:
count = 0
if hdr[0].lower() == 'x-container-bytes-used':
try:
size = int(hdr[1])
except ValueError:
size = 0
buff = response.read()
if response.status == 404:
raise NoSuchContainer(container_name)
if (response.status < 200) or (response.status > 299):
raise ResponseError(response.status, response.reason)
return Container(self, container_name, count, size)
def list_public_containers(self):
"""
Returns a list of containers that have been published to the CDN.
>>> connection.list_public_containers()
['container1', 'container2', 'container3']
@rtype: list(str)
@return: a list of all CDN-enabled container names as strings
"""
response = self.cdn_request('GET', [''])
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def list_containers_info(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers, including object count and size.
>>> connection.list_containers_info()
[{u'count': 510, u'bytes': 2081717, u'name': u'new_container'},
{u'count': 12, u'bytes': 23074, u'name': u'old_container'},
{u'count': 0, u'bytes': 0, u'name': u'container1'},
{u'count': 0, u'bytes': 0, u'name': u'container2'},
{u'count': 0, u'bytes': 0, u'name': u'container3'},
{u'count': 3, u'bytes': 2306, u'name': u'test'}]
@rtype: list({"name":"...", "count":..., "bytes":...})
@return: a list of all container info as dictionaries with the
keys "name", "count", and "bytes"
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
parms['format'] = 'json'
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return json_loads(response.read())
def list_containers(self, limit=None, marker=None, **parms):
"""
Returns a list of Containers.
>>> connection.list_containers()
['new_container',
'old_container',
'container1',
'container2',
'container3',
'test']
@rtype: list(str)
@return: a list of all containers names as strings
@param limit: number of results to return, up to 10,000
@type limit: int
@param marker: return only results whose name is greater than "marker"
@type marker: str
"""
if limit:
parms['limit'] = limit
if marker:
parms['marker'] = marker
response = self.make_request('GET', [''], parms=parms)
if (response.status < 200) or (response.status > 299):
buff = response.read()
raise ResponseError(response.status, response.reason)
return response.read().splitlines()
def __getitem__(self, key):
"""
Container objects can be grabbed from a connection using index
syntax.
>>> container = conn['old_container']
>>> container.size_used
23074
@rtype: L{Container}
@return: an object representing the container
"""
return self.get_container(key)
# Request/Response Logging {{{
def _log_response(self, response, logfn=log.debug):
logfn('Request ID: %s, Response: status=%s; headers="%s"' %
(self.request_id, str(response.status), "; ".join(
["%s=%s" % (k, v) for (k, v) in response.getheaders()])))
def _log_request(self, connection, method, path, headers, logfn=log.debug):
host, port = connection.host, str(connection.port)
logfn(
'Request ID: %(request_id)s, %(method)s %(uri)s, headers="%(headers)s"'
% dict(request_id=self.request_id,
method=method,
uri="%s:%s%s" % (host, port, path),
headers=headers))
def _log_http_exception(self, e):
log.error('Request ID: %s, HttpException: %s' %
(self.request_id, repr(e)))
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: http_connect
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=10, **kwargs):
"""
Accepts keyword arguments for Rackspace Cloud username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Rackspace Cloud username
@type api_key: str
@param api_key: a Rackspace Cloud API key
"""
self.connection_args = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get("debuglevel", 0))
self.user_agent = kwargs.get("useragent", consts.user_agent)
self.timeout = timeout
self.auth = "auth" in kwargs and kwargs["auth"] or None
if not self.auth:
authurl = kwargs.get("authurl", consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username, api_key, authurl=authurl, useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or HTTPConnection
self.http_connect()
def convert_iso_datetime(self, dt):
"""
Convert iso8601 to datetime
"""
isoFormat = "%Y-%m-%dT%H:%M:%S.000+0000"
if type(dt) is datetime.datetime:
return dt
if dt.endswith("Z"):
dt = dt.split("Z")[0]
isoFormat = "%Y-%m-%dT%H:%M:%S"
return datetime.datetime.strptime(dt, isoFormat)
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def make_request(self, method, path=[], data="", hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
query_args = ""
path = "/%s/%s" % (self.uri.rstrip("/"), "/".join([unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = ["%s=%s" % (quote(x), quote(str(y))) for (x, y) in parms.items()]
elif isinstance(parms, list) and parms:
query_args = ["%s" % x for x in parms]
path = "%s?%s" % (path, "&".join(query_args))
headers = {
"Content-Length": str(len(data)),
"User-Agent": self.user_agent,
"X-Auth-Token": self.token,
"Content-Type": "application/xml",
}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
"""Re-connect and re-try a failed request once"""
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
if "PYTHON_CLOUDDNS_DEBUG" in os.environ and os.environ["PYTHON_CLOUDDNS_DEBUG"].strip():
import sys
url = "https://%s%s\n" % (self.connection_args[0], path)
sys.stderr.write("METHOD: %s\n" % (str(method)))
sys.stderr.write("URL: %s" % (url))
sys.stderr.write("HEADERS: %s\n" % (str(headers)))
sys.stderr.write("DATA: %s\n" % (str(data)))
sys.stderr.write("curl -X '%s' -H 'X-Auth-Token: %s' %s %s" % (method, self.token, url, str(data)))
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers["X-Auth-Token"] = self.token
response = retry_request()
return response
def get_domains(self):
return DomainResults(self, self.list_domains_info())
def list_domains_info(self, filter_by_name=None):
parms = {}
if filter_by_name:
parms = {"name": filter_by_name}
response = self.make_request("GET", ["domains"], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
return json.loads(read_output)["domains"]
def get_domain(self, id=None, **dico):
filter_by_name = ""
if id:
dico["id"] = id
if "name" in dico:
dico["name"] = dico["name"].lower()
filter_by_name = dico["name"]
domains = self.list_domains_info(filter_by_name=filter_by_name)
for domain in domains:
for k in dico:
if k in domain and domain[k] == dico[k]:
return Domain(self, **domain)
# TODO:
raise Exception("Not found")
# Take a reponse parse it if there is asyncResponse and wait for
# it (TODO: should offer to not)
def wait_for_async_request(self, response):
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
output = json.loads(response.read())
while True:
if "callbackUrl" in output:
jobId = output["jobId"]
response = self.make_request("GET", ["status", jobId])
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
_output = response.read().strip()
if not _output:
return True
output = json.loads(_output)
time.sleep(1)
continue
elif "DnsFault" in output:
raise ResponseError(output["DnsFault"]["code"], output["DnsFault"]["message"])
else:
return output
def _domain(self, name, ttl, emailAddress, comment):
if not ttl >= 300:
raise Exception("Ttl is a minimun of 300 seconds")
s = '<domain name="%s" ttl="%s" emailAddress="%s" comment="%s"></domain>'
return s % (name, ttl, emailAddress, comment)
def create_domain(self, name, ttl, emailAddress, comment=""):
domain = [name, ttl, emailAddress, comment]
return self.create_domains([domain])[0]
def create_domains(self, domains):
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
ret = []
for dom in domains:
ret.append(self._domain(*dom))
xml += "\n".join(ret)
xml += "</domains>"
response = self.make_request("POST", ["domains"], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output["domains"]:
ret.append(Domain(connection=self, **domain))
return ret
def delete_domain(self, domain_id):
return self.delete_domains([domain_id])
def delete_domains(self, domains_id):
ret = ["id=%s" % (i) for i in domains_id]
response = self.make_request("DELETE", ["domains"], parms=ret)
return self.wait_for_async_request(response)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: http_connect
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=10, **kwargs):
"""
Accepts keyword arguments for Rackspace Cloud username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Rackspace Cloud username
@type api_key: str
@param api_key: a Rackspace Cloud API key
"""
self.connection_args = None
self.connection = None
self.token = None
self.debuglevel = int(kwargs.get('debuglevel', 0))
self.user_agent = kwargs.get('useragent', consts.user_agent)
self.timeout = timeout
self.auth = 'auth' in kwargs and kwargs['auth'] or None
if not self.auth:
authurl = kwargs.get('authurl', consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username,
api_key,
authurl=authurl,
useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or \
THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or \
HTTPConnection
self.http_connect()
def convert_iso_datetime(self, dt):
"""
Convert iso8601 to datetime
"""
isoFormat = "%Y-%m-%dT%H:%M:%S.000+0000"
if type(dt) is datetime.datetime:
return dt
if dt.endswith("Z"):
dt = dt.split('Z')[0]
isoFormat = "%Y-%m-%dT%H:%M:%S"
return datetime.datetime.strptime(dt, isoFormat)
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, \
timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
def make_request(self, method, path=[], data='', hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
query_args = ""
path = '/%s/%s' % \
(self.uri.rstrip('/'), '/'.join(
[unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = \
['%s=%s' % (quote(x),
quote(str(y))) for (x, y) in parms.items()]
elif isinstance(parms, list) and parms:
query_args = \
["%s" % x for x in parms]
path = '%s?%s' % (path, '&'.join(query_args))
headers = {
'Content-Length': str(len(data)),
'User-Agent': self.user_agent,
'X-Auth-Token': self.token
}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
'''Re-connect and re-try a failed request once'''
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
if 'PYTHON_CLOUDDNS_DEBUG' in os.environ and \
os.environ['PYTHON_CLOUDDNS_DEBUG'].strip():
import sys
url = "https://%s%s\n" % \
(self.connection_args[0],
path)
sys.stderr.write("METHOD: %s\n" % (str(method)))
sys.stderr.write("URL: %s" % (url))
sys.stderr.write("HEADERS: %s\n" % (str(headers)))
sys.stderr.write("DATA: %s\n" % (str(data)))
sys.stderr.write("curl -X '%s' -H 'X-Auth-Token: %s' %s %s" % \
(method, self.token, url, str(data)))
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers['X-Auth-Token'] = self.token
response = retry_request()
return response
def get_domains(self):
return DomainResults(self, self.list_domains_info())
def list_domains_info(self, filter_by_name=None):
parms = {}
if filter_by_name:
parms = {'name': filter_by_name}
response = self.make_request('GET', ['domains'], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
return json.loads(read_output)['domains']
def get_domain(self, id=None, **dico):
filter_by_name = ""
if id:
dico['id'] = id
if 'name' in dico:
dico['name'] = dico['name'].lower()
filter_by_name = dico['name']
domains = self.list_domains_info(filter_by_name=filter_by_name)
for domain in domains:
for k in dico:
if k in domain and domain[k] == dico[k]:
return Domain(self, **domain)
#TODO:
raise Exception("Not found")
# Take a reponse parse it if there is asyncResponse and wait for
# it (TODO: should offer to not)
def wait_for_async_request(self, response):
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
output = json.loads(response.read())
jobId = output['jobId']
while True:
response = self.make_request('GET', ['status', jobId],
parms=['showDetails=True'])
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
_output = response.read().strip()
output = json.loads(_output)
if output['status'] == 'COMPLETED':
try:
return output['response']
except KeyError:
return output
if output['status'] == 'ERROR':
raise ResponseError(output['error']['code'],
output['error']['details'])
time.sleep(1)
continue
def _domain(self, name, ttl, emailAddress, comment=""):
if not ttl >= 300:
raise Exception("Ttl is a minimun of 300 seconds")
s = '<domain name="%s" ttl="%s" emailAddress="%s" comment="%s"></domain>'
return s % (name, ttl, emailAddress, comment)
def create_domain(self, name, ttl, emailAddress, comment=""):
domain = [name, ttl, emailAddress, comment]
return self.create_domains([domain])[0]
def create_domains(self, domains):
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
ret = []
for dom in domains:
ret.append(self._domain(*dom))
xml += "\n".join(ret)
xml += "</domains>"
response = self.make_request('POST', ['domains'], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output['domains']:
ret.append(Domain(connection=self, **domain))
return ret
def delete_domain(self, domain_id):
return self.delete_domains([domain_id])
def delete_domains(self, domains_id):
ret = ["id=%s" % (i) for i in domains_id]
response = self.make_request(
'DELETE',
['domains'],
parms=ret,
)
return self.wait_for_async_request(response)
class Connection(object):
"""
Manages the connection to the storage system and serves as a factory
for Container instances.
@undocumented: http_connect
@undocumented: make_request
@undocumented: _check_container_name
"""
def __init__(self, username=None, api_key=None, timeout=10, **kwargs):
"""
Accepts keyword arguments for Rackspace Cloud username and api key.
Optionally, you can omit these keywords and supply an
Authentication object using the auth keyword.
@type username: str
@param username: a Rackspace Cloud username
@type api_key: str
@param api_key: a Rackspace Cloud API key
"""
self.connection_args = None
self.connection = None
self.defaultAccountId = None
self.accountId = None
self.token = None
self.debuglevel = int(kwargs.get("debuglevel", 0))
self.user_agent = kwargs.get("useragent", consts.user_agent)
self.timeout = timeout
self.auth = "auth" in kwargs and kwargs["auth"] or None
if not self.auth:
authurl = kwargs.get("authurl", consts.us_authurl)
if username and api_key and authurl:
self.auth = Authentication(username, api_key, authurl=authurl, useragent=self.user_agent)
else:
raise TypeError("Incorrect or invalid arguments supplied")
self._authenticate()
def _authenticate(self):
"""
Authenticate and setup this instance with the values returned.
"""
(url, self.token) = self.auth.authenticate()
self.connection_args = parse_url(url)
if version_info[0] <= 2 and version_info[1] < 6:
self.conn_class = self.connection_args[3] and THTTPSConnection or THTTPConnection
else:
self.conn_class = self.connection_args[3] and HTTPSConnection or HTTPConnection
self.http_connect()
def convert_iso_datetime(self, dt):
"""
Convert iso8601 to datetime
"""
isoFormat = "%Y-%m-%dT%H:%M:%S.000+0000"
if type(dt) is datetime.datetime:
return dt
if dt.endswith("Z"):
dt = dt.split("Z")[0]
isoFormat = "%Y-%m-%dT%H:%M:%S"
return datetime.datetime.strptime(dt, isoFormat)
def http_connect(self):
"""
Setup the http connection instance.
"""
(host, port, self.uri, is_ssl) = self.connection_args
self.connection = self.conn_class(host, port=port, timeout=self.timeout)
self.connection.set_debuglevel(self.debuglevel)
self.set_account()
def make_request(self, method, path=[], data="", hdrs=None, parms=None):
"""
Given a method (i.e. GET, PUT, POST, etc), a path, data, header and
metadata dicts, and an optional dictionary of query parameters,
performs an http request.
"""
query_args = ""
path = "/%s/%s" % (self.uri.rstrip("/"), "/".join([unicode_quote(i) for i in path]))
if isinstance(parms, dict) and parms:
query_args = ["%s=%s" % (quote(x), quote(str(y))) for (x, y) in parms.items()]
elif isinstance(parms, list) and parms:
query_args = ["%s" % x for x in parms]
path = "%s?%s" % (path, "&".join(query_args))
headers = {"Content-Length": str(len(data)), "User-Agent": self.user_agent, "X-Auth-Token": self.token}
isinstance(hdrs, dict) and headers.update(hdrs)
def retry_request():
"""Re-connect and re-try a failed request once"""
self.http_connect()
self.connection.request(method, path, data, headers)
return self.connection.getresponse()
try:
if "PYTHON_CLOUDDNS_DEBUG" in os.environ and os.environ["PYTHON_CLOUDDNS_DEBUG"].strip():
import sys
url = "https://%s%s\n" % (self.connection_args[0], path)
sys.stderr.write("METHOD: %s\n" % (str(method)))
sys.stderr.write("URL: %s" % (url))
sys.stderr.write("HEADERS: %s\n" % (str(headers)))
sys.stderr.write("DATA: %s\n" % (str(data)))
sys.stderr.write("curl -X '%s' -H 'X-Auth-Token: %s' %s %s" % (method, self.token, url, str(data)))
self.connection.request(method, path, data, headers)
response = self.connection.getresponse()
except (socket.error, IOError, HTTPException):
response = retry_request()
if response.status == 401:
self._authenticate()
headers["X-Auth-Token"] = self.token
response = retry_request()
return response
def set_account(self, newAccountId=None):
"""Handles setting of accountId for accessing other clients"""
# Split out the account ID off the DNS Management URL
(baseUri, sep, oldAccountId) = self.uri.rstrip("/").rpartition("/")
if not self.defaultAccountId: # First call, set default
self.defaultAccountId = oldAccountId
if newAccountId: # Set the new accountId
self.uri = baseUri + "/" + newAccountId
self.accountId = newAccountId
else: # set back to default
# This could be a self call, but for now we will just set the two vars
# self.set_account(self.defaultAccountId)
self.uri = baseUri + "/" + self.defaultAccountId
self.accountId = self.defaultAccountId
def get_accountId(self):
return self.accountId
def get_domains(self):
return DomainResults(self, self.list_domains_info())
def list_domains_info(self, filter_by_name=None):
parms = {}
if filter_by_name:
parms = {"name": filter_by_name}
response = self.make_request("GET", ["domains"], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
return json.loads(read_output)["domains"]
def get_domain(self, id=None, **dico):
filter_by_name = ""
if id:
dico["id"] = id
if "name" in dico:
dico["name"] = dico["name"].lower()
filter_by_name = dico["name"]
domains = self.list_domains_info(filter_by_name=filter_by_name)
for domain in domains:
for k in dico:
if k in domain and domain[k] == dico[k]:
return Domain(self, **domain)
raise UnknownDomain("Not found")
def get_domain_details(self, id=None):
"""Get details on a particular domain"""
parms = {"showRecords": "false", "showSubdomains": "false"}
response = self.make_request("GET", ["domains", str(id)], parms=parms)
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
read_output = response.read()
domains = json.loads(read_output)
return Domain(self, **domains)
# Take a reponse parse it if there is asyncResponse and wait for
# it (TODO: should offer to not)
def wait_for_async_request(self, response):
if (response.status < 200) or (response.status > 299):
_output = response.read().strip()
try:
output = json.loads(_output)
except ValueError:
output = None
api_reasons = ""
if output and "validationErrors" in output:
for msg in output["validationErrors"]["messages"]:
api_reasons += " (%s)" % msg
raise ResponseError(response.status, response.reason + api_reasons)
output = json.loads(response.read())
jobId = output["jobId"]
while True:
response = self.make_request("GET", ["status", jobId], parms=["showDetails=True"])
if (response.status < 200) or (response.status > 299):
response.read()
raise ResponseError(response.status, response.reason)
_output = response.read().strip()
output = json.loads(_output)
if output["status"] == "COMPLETED":
try:
return output["response"]
except KeyError:
return output
if output["status"] == "ERROR":
if output["error"]["code"] == 409 and output["error"]["details"] == "Domain already exists":
raise DomainAlreadyExists
if output["error"]["code"] == 409 and output["error"]["details"].find("belongs to another owner"):
raise NotDomainOwner
raise ResponseError(output["error"]["code"], output["error"]["details"])
time.sleep(1)
continue
def _domain(self, name, ttl, emailAddress, comment=""):
if not ttl >= 300:
raise Exception("Ttl is a minimun of 300 seconds")
s = '<domain name="%s" ttl="%s" emailAddress="%s" comment="%s"></domain>'
return s % (name, ttl, emailAddress, comment)
def create_domain(self, name, ttl, emailAddress, comment=""):
domain = [name, ttl, emailAddress, comment]
return self.create_domains([domain])[0]
def create_domains(self, domains):
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
ret = []
for dom in domains:
ret.append(self._domain(*dom))
xml += "\n".join(ret)
xml += "</domains>"
response = self.make_request("POST", ["domains"], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output["domains"]:
ret.append(Domain(connection=self, **domain))
return ret
def delete_domain(self, domain_id):
return self.delete_domains([domain_id])
def delete_domains(self, domains_id):
ret = ["id=%s" % (i) for i in domains_id]
response = self.make_request("DELETE", ["domains"], parms=ret)
return self.wait_for_async_request(response)
def import_domain(self, bind_zone):
"""
Allows for a bind zone file to be imported in one operation. The
bind_zone parameter can be a string or a file object.
"""
if type(bind_zone) is file:
bind_zone = bind_zone.read()
xml = '<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">'
xml += '<domain contentType="BIND_9">'
xml += "<contents>%s</contents>" % bind_zone
xml += "</domain></domains>"
response = self.make_request("POST", ["domains", "import"], data=xml)
output = self.wait_for_async_request(response)
ret = []
for domain in output["domains"]:
ret.append(Domain(self, **domain))
return ret
