gcloud 0.0.7 → 0.1.0

data/packages/gsutil/boto/boto/roboto/awsqueryservice.py

@@ -1,121 +0,0 @@
-import os
-import urlparse
-import boto
-import boto.connection
-import boto.jsonresponse
-import boto.exception
-import awsqueryrequest
-
-class NoCredentialsError(boto.exception.BotoClientError):
-
-    def __init__(self):
-        s = 'Unable to find credentials'
-        boto.exception.BotoClientError.__init__(self, s)
-
-class AWSQueryService(boto.connection.AWSQueryConnection):
-
-    Name = ''
-    Description = ''
-    APIVersion = ''
-    Authentication = 'sign-v2'
-    Path = '/'
-    Port = 443
-    Provider = 'aws'
-    EnvURL = 'AWS_URL'
-
-    Regions = []
-
-    def __init__(self, **args):
-        self.args = args
-        self.check_for_credential_file()
-        self.check_for_env_url()
-        if 'host' not in self.args:
-            if self.Regions:
-                region_name = self.args.get('region_name',
-                                            self.Regions[0]['name'])
-                for region in self.Regions:
-                    if region['name'] == region_name:
-                        self.args['host'] = region['endpoint']
-        if 'path' not in self.args:
-            self.args['path'] = self.Path
-        if 'port' not in self.args:
-            self.args['port'] = self.Port
-        try:
-            boto.connection.AWSQueryConnection.__init__(self, **self.args)
-            self.aws_response = None
-        except boto.exception.NoAuthHandlerFound:
-            raise NoCredentialsError()
-
-    def check_for_credential_file(self):
-        """
-        Checks for the existance of an AWS credential file.
-        If the environment variable AWS_CREDENTIAL_FILE is
-        set and points to a file, that file will be read and
-        will be searched credentials.
-        Note that if credentials have been explicitelypassed
-        into the class constructor, those values always take
-        precedence.
-        """
-        if 'AWS_CREDENTIAL_FILE' in os.environ:
-            path = os.environ['AWS_CREDENTIAL_FILE']
-            path = os.path.expanduser(path)
-            path = os.path.expandvars(path)
-            if os.path.isfile(path):
-                fp = open(path)
-                lines = fp.readlines()
-                fp.close()
-                for line in lines:
-                    if line[0] != '#':
-                        if '=' in line:
-                            name, value = line.split('=', 1)
-                            if name.strip() == 'AWSAccessKeyId':
-                                if 'aws_access_key_id' not in self.args:
-                                    value = value.strip()
-                                    self.args['aws_access_key_id'] = value
-                            elif name.strip() == 'AWSSecretKey':
-                                if 'aws_secret_access_key' not in self.args:
-                                    value = value.strip()
-                                    self.args['aws_secret_access_key'] = value
-            else:
-                print 'Warning: unable to read AWS_CREDENTIAL_FILE'
-
-    def check_for_env_url(self):
-        """
-        First checks to see if a url argument was explicitly passed
-        in.  If so, that will be used.  If not, it checks for the
-        existence of the environment variable specified in ENV_URL.
-        If this is set, it should contain a fully qualified URL to the
-        service you want to use.
-        Note that any values passed explicitly to the class constructor
-        will take precedence.
-        """
-        url = self.args.get('url', None)
-        if url:
-            del self.args['url']
-        if not url and self.EnvURL in os.environ:
-            url = os.environ[self.EnvURL]
-        if url:
-            rslt = urlparse.urlparse(url)
-            if 'is_secure' not in self.args:
-                if rslt.scheme == 'https':
-                    self.args['is_secure'] = True
-                else:
-                    self.args['is_secure'] = False
-
-            host = rslt.netloc
-            port = None
-            l = host.split(':')
-            if len(l) > 1:
-                host = l[0]
-                port = int(l[1])
-            if 'host' not in self.args:
-                self.args['host'] = host
-            if port and 'port' not in self.args:
-                self.args['port'] = port
-
-            if rslt.path and 'path' not in self.args:
-                self.args['path'] = rslt.path
-            
-    def _required_auth_capability(self):
-        return [self.Authentication]
-        

data/packages/gsutil/boto/boto/roboto/param.py

@@ -1,147 +0,0 @@
-# Copyright (c) 2010 Mitch Garnaat http://garnaat.org/
-# Copyright (c) 2010, Eucalyptus Systems, Inc.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-
-import os
-
-class Converter(object):
-    
-    @classmethod
-    def convert_string(cls, param, value):
-        # TODO: could do length validation, etc. here
-        if not isinstance(value, basestring):
-            raise ValueError
-        return value
-
-    @classmethod
-    def convert_integer(cls, param, value):
-        # TODO: could do range checking here
-        return int(value)
-        
-    @classmethod
-    def convert_boolean(cls, param, value):
-        """
-        For command line arguments, just the presence
-        of the option means True so just return True
-        """
-        return True
-        
-    @classmethod
-    def convert_file(cls, param, value):
-        if os.path.isfile(value):
-            return value
-        raise ValueError
-        
-    @classmethod
-    def convert_dir(cls, param, value):
-        if os.path.isdir(value):
-            return value
-        raise ValueError
-        
-    @classmethod
-    def convert(cls, param, value):
-        try:
-            if hasattr(cls, 'convert_'+param.ptype):
-                mthd = getattr(cls, 'convert_'+param.ptype)
-            else:
-                mthd = cls.convert_string
-            return mthd(param, value)
-        except:
-            raise ValidationException(param, '')
-        
-class Param(object):
-
-    def __init__(self, name=None, ptype='string', optional=True,
-                 short_name=None, long_name=None, doc='',
-                 metavar=None, cardinality=1, default=None,
-                 choices=None, encoder=None, request_param=True):
-        self.name = name
-        self.ptype = ptype
-        self.optional = optional
-        self.short_name = short_name
-        self.long_name = long_name
-        self.doc = doc
-        self.metavar = metavar
-        self.cardinality = cardinality
-        self.default = default
-        self.choices = choices
-        self.encoder = encoder
-        self.request_param = request_param
-
-    @property
-    def optparse_long_name(self):
-        ln = None
-        if self.long_name:
-            ln = '--%s' % self.long_name
-        return ln
-
-    @property
-    def synopsis_long_name(self):
-        ln = None
-        if self.long_name:
-            ln = '--%s' % self.long_name
-        return ln
-
-    @property
-    def getopt_long_name(self):
-        ln = None
-        if self.long_name:
-            ln = '%s' % self.long_name
-            if self.ptype != 'boolean':
-                ln += '='
-        return ln
-
-    @property
-    def optparse_short_name(self):
-        sn = None
-        if self.short_name:
-            sn = '-%s' % self.short_name
-        return sn
-
-    @property
-    def synopsis_short_name(self):
-        sn = None
-        if self.short_name:
-            sn = '-%s' % self.short_name
-        return sn
-
-    @property
-    def getopt_short_name(self):
-        sn = None
-        if self.short_name:
-            sn = '%s' % self.short_name
-            if self.ptype != 'boolean':
-                sn += ':'
-        return sn
-
-    def convert(self, value):
-        """
-        Convert a string value as received in the command line
-        tools and convert to the appropriate type of value.
-        Raise a ValidationError if the value can't be converted.
-
-        :type value: str
-        :param value: The value to convert.  This should always
-                      be a string.
-        """
-        return Converter.convert(self, value)
-
-

data/packages/gsutil/boto/boto/route53/__init__.py

@@ -1,75 +0,0 @@
-# Copyright (c) 2006-2012 Mitch Garnaat http://garnaat.org/
-# Copyright (c) 2010, Eucalyptus Systems, Inc.
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-
-# this is here for backward compatibility
-# originally, the Route53Connection class was defined here
-from connection import Route53Connection
-from boto.regioninfo import RegionInfo
-
-
-class Route53RegionInfo(RegionInfo):
-
-    def connect(self, **kw_params):
-        """
-        Connect to this Region's endpoint. Returns an connection
-        object pointing to the endpoint associated with this region.
-        You may pass any of the arguments accepted by the connection
-        class's constructor as keyword arguments and they will be
-        passed along to the connection object.
-
-        :rtype: Connection object
-        :return: The connection to this regions endpoint
-        """
-        if self.connection_cls:
-            return self.connection_cls(host=self.endpoint, **kw_params)
-
-
-def regions():
-    """
-    Get all available regions for the Route53 service.
-
-    :rtype: list
-    :return: A list of :class:`boto.regioninfo.RegionInfo` instances
-    """
-    return [Route53RegionInfo(name='universal',
-                              endpoint='route53.amazonaws.com',
-                              connection_cls=Route53Connection)
-            ]
-
-
-def connect_to_region(region_name, **kw_params):
-    """
-    Given a valid region name, return a
-    :class:`boto.route53.connection.Route53Connection`.
-
-    :type: str
-    :param region_name: The name of the region to connect to.
-
-    :rtype: :class:`boto.route53.connection.Route53Connection` or ``None``
-    :return: A connection to the given region, or None if an invalid region
-             name is given
-    """
-    for region in regions():
-        if region.name == region_name:
-            return region.connect(**kw_params)
-    return None

data/packages/gsutil/boto/boto/route53/connection.py

@@ -1,403 +0,0 @@
-# Copyright (c) 2006-2010 Mitch Garnaat http://garnaat.org/
-# Copyright (c) 2010, Eucalyptus Systems, Inc.
-# Copyright (c) 2011 Blue Pines Technologies LLC, Brad Carleton
-# www.bluepines.org
-# Copyright (c) 2012 42 Lines Inc., Jim Browne
-#
-# Permission is hereby granted, free of charge, to any person obtaining a
-# copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish, dis-
-# tribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the fol-
-# lowing conditions:
-#
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
-# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
-
-import xml.sax
-import uuid
-import urllib
-import boto
-from boto.connection import AWSAuthConnection
-from boto import handler
-from boto.route53.record import ResourceRecordSets
-from boto.route53.zone import Zone
-import boto.jsonresponse
-import exception
-
-HZXML = """<?xml version="1.0" encoding="UTF-8"?>
-<CreateHostedZoneRequest xmlns="%(xmlns)s">
-  <Name>%(name)s</Name>
-  <CallerReference>%(caller_ref)s</CallerReference>
-  <HostedZoneConfig>
-    <Comment>%(comment)s</Comment>
-  </HostedZoneConfig>
-</CreateHostedZoneRequest>"""
-        
-#boto.set_stream_logger('dns')
-
-
-class Route53Connection(AWSAuthConnection):
-    DefaultHost = 'route53.amazonaws.com'
-    """The default Route53 API endpoint to connect to."""
-
-    Version = '2012-02-29'
-    """Route53 API version."""
-
-    XMLNameSpace = 'https://route53.amazonaws.com/doc/2012-02-29/'
-    """XML schema for this Route53 API version."""
-
-    def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,
-                 port=None, proxy=None, proxy_port=None,
-                 host=DefaultHost, debug=0, security_token=None,
-                 validate_certs=True):
-        AWSAuthConnection.__init__(self, host,
-                                   aws_access_key_id, aws_secret_access_key,
-                                   True, port, proxy, proxy_port, debug=debug,
-                                   security_token=security_token,
-                                   validate_certs=validate_certs)
-
-    def _required_auth_capability(self):
-        return ['route53']
-
-    def make_request(self, action, path, headers=None, data='', params=None):
-        if params:
-            pairs = []
-            for key, val in params.iteritems():
-                if val is None:
-                    continue
-                pairs.append(key + '=' + urllib.quote(str(val)))
-            path += '?' + '&'.join(pairs)
-        return AWSAuthConnection.make_request(self, action, path,
-                                              headers, data)
-
-    # Hosted Zones
-
-    def get_all_hosted_zones(self, start_marker=None, zone_list=None):
-        """
-        Returns a Python data structure with information about all
-        Hosted Zones defined for the AWS account.
-
-        :param int start_marker: start marker to pass when fetching additional
-            results after a truncated list
-        :param list zone_list: a HostedZones list to prepend to results
-        """
-        params = {}
-        if start_marker:
-            params = {'marker': start_marker}
-        response = self.make_request('GET', '/%s/hostedzone' % self.Version,
-                params=params)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status >= 300:
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        e = boto.jsonresponse.Element(list_marker='HostedZones',
-                                      item_marker=('HostedZone',))
-        h = boto.jsonresponse.XmlHandler(e, None)
-        h.parse(body)
-        if zone_list:
-            e['ListHostedZonesResponse']['HostedZones'].extend(zone_list)
-        while 'NextMarker' in e['ListHostedZonesResponse']:
-            next_marker = e['ListHostedZonesResponse']['NextMarker']
-            zone_list = e['ListHostedZonesResponse']['HostedZones']
-            e = self.get_all_hosted_zones(next_marker, zone_list)
-        return e
-
-    def get_hosted_zone(self, hosted_zone_id):
-        """
-        Get detailed information about a particular Hosted Zone.
-        
-        :type hosted_zone_id: str
-        :param hosted_zone_id: The unique identifier for the Hosted Zone
-
-        """
-        uri = '/%s/hostedzone/%s' % (self.Version, hosted_zone_id)
-        response = self.make_request('GET', uri)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status >= 300:
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        e = boto.jsonresponse.Element(list_marker='NameServers',
-                                      item_marker=('NameServer',))
-        h = boto.jsonresponse.XmlHandler(e, None)
-        h.parse(body)
-        return e
-
-    def get_hosted_zone_by_name(self, hosted_zone_name):
-        """
-        Get detailed information about a particular Hosted Zone.
-
-        :type hosted_zone_name: str
-        :param hosted_zone_name: The fully qualified domain name for the Hosted
-            Zone
-
-        """
-        if hosted_zone_name[-1] != '.':
-            hosted_zone_name += '.'
-        all_hosted_zones = self.get_all_hosted_zones()
-        for zone in all_hosted_zones['ListHostedZonesResponse']['HostedZones']:
-            #check that they gave us the FQDN for their zone
-            if zone['Name'] == hosted_zone_name:
-                return self.get_hosted_zone(zone['Id'].split('/')[-1])
-
-    def create_hosted_zone(self, domain_name, caller_ref=None, comment=''):
-        """
-        Create a new Hosted Zone.  Returns a Python data structure with
-        information about the newly created Hosted Zone.
-        
-        :type domain_name: str
-        :param domain_name: The name of the domain. This should be a
-            fully-specified domain, and should end with a final period
-            as the last label indication.  If you omit the final period,
-            Amazon Route 53 assumes the domain is relative to the root.
-            This is the name you have registered with your DNS registrar.
-            It is also the name you will delegate from your registrar to
-            the Amazon Route 53 delegation servers returned in
-            response to this request.A list of strings with the image
-            IDs wanted.
-
-        :type caller_ref: str
-        :param caller_ref: A unique string that identifies the request
-            and that allows failed CreateHostedZone requests to be retried
-            without the risk of executing the operation twice.  If you don't
-            provide a value for this, boto will generate a Type 4 UUID and
-            use that.
-
-        :type comment: str
-        :param comment: Any comments you want to include about the hosted      
-            zone.
-
-        """
-        if caller_ref is None:
-            caller_ref = str(uuid.uuid4())
-        params = {'name': domain_name,
-                  'caller_ref': caller_ref,
-                  'comment': comment,
-                  'xmlns': self.XMLNameSpace}
-        xml_body = HZXML % params
-        uri = '/%s/hostedzone' % self.Version
-        response = self.make_request('POST', uri,
-                                     {'Content-Type': 'text/xml'}, xml_body)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status == 201:
-            e = boto.jsonresponse.Element(list_marker='NameServers',
-                                          item_marker=('NameServer',))
-            h = boto.jsonresponse.XmlHandler(e, None)
-            h.parse(body)
-            return e
-        else:
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        
-    def delete_hosted_zone(self, hosted_zone_id):
-        uri = '/%s/hostedzone/%s' % (self.Version, hosted_zone_id)
-        response = self.make_request('DELETE', uri)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status not in (200, 204):
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        e = boto.jsonresponse.Element()
-        h = boto.jsonresponse.XmlHandler(e, None)
-        h.parse(body)
-        return e
-
-    # Resource Record Sets
-
-    def get_all_rrsets(self, hosted_zone_id, type=None,
-                       name=None, identifier=None, maxitems=None):
-        """
-        Retrieve the Resource Record Sets defined for this Hosted Zone.
-        Returns the raw XML data returned by the Route53 call.
-        
-        :type hosted_zone_id: str
-        :param hosted_zone_id: The unique identifier for the Hosted Zone
-
-        :type type: str
-        :param type: The type of resource record set to begin the record
-            listing from.  Valid choices are:
-
-                * A
-                * AAAA
-                * CNAME
-                * MX
-                * NS
-                * PTR
-                * SOA
-                * SPF
-                * SRV
-                * TXT
-
-            Valid values for weighted resource record sets:
-
-                * A
-                * AAAA
-                * CNAME
-                * TXT
-
-            Valid values for Zone Apex Aliases:
-
-                * A
-                * AAAA
-
-        :type name: str
-        :param name: The first name in the lexicographic ordering of domain
-                     names to be retrieved
-
-        :type identifier: str
-        :param identifier: In a hosted zone that includes weighted resource
-            record sets (multiple resource record sets with the same DNS
-            name and type that are differentiated only by SetIdentifier),
-            if results were truncated for a given DNS name and type,
-            the value of SetIdentifier for the next resource record
-            set that has the current DNS name and type
-
-        :type maxitems: int
-        :param maxitems: The maximum number of records
-
-        """
-        params = {'type': type, 'name': name,
-                  'Identifier': identifier, 'maxitems': maxitems}
-        uri = '/%s/hostedzone/%s/rrset' % (self.Version, hosted_zone_id)
-        response = self.make_request('GET', uri, params=params)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status >= 300:
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        rs = ResourceRecordSets(connection=self, hosted_zone_id=hosted_zone_id)
-        h = handler.XmlHandler(rs, self)
-        xml.sax.parseString(body, h)
-        return rs
-
-    def change_rrsets(self, hosted_zone_id, xml_body):
-        """
-        Create or change the authoritative DNS information for this
-        Hosted Zone.
-        Returns a Python data structure with information about the set of
-        changes, including the Change ID.
-
-        :type hosted_zone_id: str
-        :param hosted_zone_id: The unique identifier for the Hosted Zone
-
-        :type xml_body: str
-        :param xml_body: The list of changes to be made, defined in the
-            XML schema defined by the Route53 service.
-
-        """
-        uri = '/%s/hostedzone/%s/rrset' % (self.Version, hosted_zone_id)
-        response = self.make_request('POST', uri,
-                                     {'Content-Type': 'text/xml'},
-                                     xml_body)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status >= 300:
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        e = boto.jsonresponse.Element()
-        h = boto.jsonresponse.XmlHandler(e, None)
-        h.parse(body)
-        return e
-
-    def get_change(self, change_id):
-        """
-        Get information about a proposed set of changes, as submitted
-        by the change_rrsets method.
-        Returns a Python data structure with status information about the
-        changes.
-
-        :type change_id: str
-        :param change_id: The unique identifier for the set of changes.
-            This ID is returned in the response to the change_rrsets method.
-
-        """
-        uri = '/%s/change/%s' % (self.Version, change_id)
-        response = self.make_request('GET', uri)
-        body = response.read()
-        boto.log.debug(body)
-        if response.status >= 300:
-            raise exception.DNSServerError(response.status,
-                                           response.reason,
-                                           body)
-        e = boto.jsonresponse.Element()
-        h = boto.jsonresponse.XmlHandler(e, None)
-        h.parse(body)
-        return e
-
-    def create_zone(self, name):
-        """
-        Create a new Hosted Zone.  Returns a Zone object for the newly
-        created Hosted Zone.
-
-        :type name: str
-        :param name: The name of the domain. This should be a
-            fully-specified domain, and should end with a final period
-            as the last label indication.  If you omit the final period,
-            Amazon Route 53 assumes the domain is relative to the root.
-            This is the name you have registered with your DNS registrar.
-            It is also the name you will delegate from your registrar to
-            the Amazon Route 53 delegation servers returned in
-            response to this request.
-        """
-        zone = self.create_hosted_zone(name)
-        return Zone(self, zone['CreateHostedZoneResponse']['HostedZone'])
-
-    def get_zone(self, name):
-        """
-        Returns a Zone object for the specified Hosted Zone.
-
-        :param name: The name of the domain. This should be a
-            fully-specified domain, and should end with a final period
-            as the last label indication.
-        """
-        name = self._make_qualified(name)
-        for zone in self.get_zones():
-            if name == zone.name:
-                return zone
-
-    def get_zones(self):
-        """
-        Returns a list of Zone objects, one for each of the Hosted
-        Zones defined for the AWS account.
-        """
-        zones = self.get_all_hosted_zones()
-        return [Zone(self, zone) for zone in
-                zones['ListHostedZonesResponse']['HostedZones']]
-
-    def _make_qualified(self, value):
-        """
-        Ensure passed domain names end in a period (.) character.
-        This will usually make a domain fully qualified.
-        """
-        if type(value) in [list, tuple, set]:
-            new_list = []
-            for record in value:
-                if record and not record[-1] == '.':
-                    new_list.append("%s." % record)
-                else:
-                    new_list.append(record)
-            return new_list
-        else:
-            value = value.strip()
-            if value and not value[-1] == '.':
-                value = "%s." % value
-            return value