more changes.

Author: Chmouel Boudjnah

clouddns/authentication.py

@@ -65,7 +65,6 @@ def authenticate(self):
         two-tuple containing the storage system URL and session token.
         """
         conn = self.conn_class(self.host, self.port, timeout=self.timeout)
-        #conn = self.conn_class(self.host, self.port)
         conn.request('GET', '/' + self.uri, headers=self.headers)
         response = conn.getresponse()
         response.read()

clouddns/connection.py

@@ -10,16 +10,16 @@
 import  os
 import  socket
 import  consts
+import  time
 from Queue  import Queue, Empty, Full
 from errors import ResponseError
 from httplib   import HTTPSConnection, HTTPConnection, HTTPException
 from sys    import version_info
-from time   import time
 from urllib import quote
 
 from utils  import unicode_quote, parse_url, \
  THTTPConnection, THTTPSConnection
-from domain import DomainResults
+from domain import DomainResults, Domain
 from authentication import Authentication
 from    fjson     import json_loads
 # Because HTTPResponse objects *have* to have read() called on them
@@ -134,25 +134,70 @@ def retry_request():
             response = retry_request()
         return response
 
-    def get_all_domains(self, limit=None, marker=None, **parms):
-        if limit:
-            parms['limit'] = limit
-        if marker:
-            parms['marker'] = marker
-        return DomainResults(self, self.list_domains_info(**parms))
-
-    def list_domains_info(self, limit=None, marker=None, **parms):
-        if limit:
-            parms['limit'] = limit
-        if marker:
-            parms['marker'] = marker
-        parms['format'] = 'json'
-        response = self.make_request('GET', ['domains'], parms=parms)
+    def get_domains(self):
+        return DomainResults(self, self.list_domains_info())
+
+    def list_domains_info(self):
+        response = self.make_request('GET', ['domains'])
         if (response.status < 200) or (response.status > 299):
             response.read()
             raise ResponseError(response.status, response.reason)
         return json_loads(response.read())['domains']['domain']
 
+    #TODO
+    def get_domain(self, domain_id):
+        pass
+
+    # Take a reponse parse it if there is asyncResponse and wait for
+    # it
+    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 'asyncResponse' in output:
+                jobId = output['asyncResponse']['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
+
+    #TODO: We make it syncronous here, we should offer async as well
+    #      unlike API does (choice).
+    def create_domain(self, name, ttl, emailAddress):
+        if not ttl >= 300:
+            raise Exception("Ttl is a minimun of 300 seconds")
+        xml = """<domains xmlns="http://docs.rackspacecloud.com/dns/api/v1.0">
+    <domain name="%(name)s" ttl="%(ttl)s" emailAddress="%(emailAddress)s">
+    </domain>
+</domains>
+""" % locals()
+        response = self.make_request('POST', ['domains'], data=xml)
+        output = self.wait_for_async_request(response)
+
+        if 'domains' in output:
+            domain = output["domains"]["domain"]
+            return Domain(**domain[0])
+        else:
+            raise Exception("This should not happen")
+
+    def delete_domain(self, domain_id, deleteSubdomains=False):
+        response = self.make_request('DELETE', ['domains', domain_id])
+        return self.wait_for_async_request(response)
+
 
 class ConnectionPool(Queue):
     """
@@ -192,7 +237,7 @@ def put(self, connobj):
         @type connobj: L{Connection}
         """
         try:
-            Queue.put(self, (time(), connobj), block=0)
+            Queue.put(self, (time.time(), connobj), block=0)
         except Full:
             del connobj
 # vim:set ai sw=4 ts=4 tw=0 expandtab:

clouddns/domain.py

@@ -29,7 +29,13 @@ def __set_name(self, name):
     name = property(fget=lambda self: self._name, fset=__set_name,
         doc="the name of the domain (read-only)")
 
-    def __init__(self, connection=None, name=None, id=None, accountId=None):
+    def __init__(self, connection=None,
+                 name=None,
+                 id=None,
+                 accountId=None,
+                 ttl=None,
+                 emailAddress=None,
+                 ):
         """
         Domains will rarely if ever need to be instantiated directly by the
         user.
@@ -39,29 +45,29 @@ def __init__(self, connection=None, name=None, id=None, accountId=None):
         L{list_domains<Connection.list_domains>} and
         other methods on a valid Connection object.
         """
-        self.name = name
         self.conn = connection
+        self.name = name
         self.id = id
         self.accountId = accountId
+        self.ttl = ttl
+        self.emailAddress = emailAddress
 
-    def create_record(self, record_name):
-        pass
+    def get_record(self, record_id):
+        records = self.list_records_info()
+        for rec in  records:
+            if rec['id'] == record_id:
+                return Record(self, record=rec)
+
+        #TODO: Exceptions
+        raise Exception("Not found")
 
     def get_records(self):
         return RecordResults(self, self.list_records_info())
 
-    def get_record(self, record_id):
-        return Record(self, record_id=record_id)
-
-    #TODO: filtering
     def list_records_info(self):
         resp = self._list_records_raw()
         return json_loads(resp)['records']['record']
 
-    def list_records(self):
-        records = self._list_records_raw()
-        print records
-
     def _list_records_raw(self):
         """
         Returns a chunk list of records
@@ -79,6 +85,9 @@ def __getitem__(self, key):
     def __str__(self):
         return self.name
 
+    def create_record(self, record_name):
+        pass
+
     def delete_record(self, record_name):
         pass
 
@@ -101,8 +110,8 @@ def __getitem__(self, key):
                          self._domains[key]['accountId'])
 
     def __getslice__(self, i, j):
-        return [Domain(self.conn, k['name'], k['count'], \
-                              k['size']) for k in self._domains[i:j]]
+        return [Domain(self.conn, k['name'], k['id'], \
+                              k['accountId']) for k in self._domains[i:j]]
 
     def __contains__(self, item):
         return item in self._names
@@ -113,17 +122,3 @@ def __repr__(self):
 
     def __len__(self):
         return len(self._domains)
-
-    def index(self, value, *args):
-        """
-        returns an integer for the first index of value
-        """
-        return self._names.index(value, *args)
-
-    def count(self, value):
-        """
-        returns the number of occurrences of value
-        """
-        return self._names.count(value)
-
-# vim:set ai sw=4 ts=4 tw=0 expandtab: