Added boto/ to depot_tools/third_party

third_party/boto/mashups/server.py

+# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
+#
+# 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.
+
+"""
+High-level abstraction of an EC2 server
+"""
+import boto
+import boto.utils
+from boto.mashups.iobject import IObject
+from boto.pyami.config import Config, BotoConfigPath
+from boto.mashups.interactive import interactive_shell
+from boto.sdb.db.model import Model
+from boto.sdb.db.property import StringProperty
+import os
+import StringIO
+
+
+class ServerSet(list):
+
+    def __getattr__(self, name):
+        results = []
+        is_callable = False
+        for server in self:
+            try:
+                val = getattr(server, name)
+                if callable(val):
+                    is_callable = True
+                results.append(val)
+            except:
+                results.append(None)
+        if is_callable:
+            self.map_list = results
+            return self.map
+        return results
+
+    def map(self, *args):
+        results = []
+        for fn in self.map_list:
+            results.append(fn(*args))
+        return results
+
+class Server(Model):
+
+    @property
+    def ec2(self):
+        if self._ec2 is None:
+            self._ec2 = boto.connect_ec2()
+        return self._ec2
+
+    @classmethod
+    def Inventory(cls):
+        """
+        Returns a list of Server instances, one for each Server object
+        persisted in the db
+        """
+        l = ServerSet()
+        rs = cls.find()
+        for server in rs:
+            l.append(server)
+        return l
+
+    @classmethod
+    def Register(cls, name, instance_id, description=''):
+        s = cls()
+        s.name = name
+        s.instance_id = instance_id
+        s.description = description
+        s.save()
+        return s
+
+    def __init__(self, id=None, **kw):
+        Model.__init__(self, id, **kw)
+        self._reservation = None
+        self._instance = None
+        self._ssh_client = None
+        self._pkey = None
+        self._config = None
+        self._ec2 = None
+
+    name = StringProperty(unique=True, verbose_name="Name")
+    instance_id = StringProperty(verbose_name="Instance ID")
+    config_uri = StringProperty()
+    ami_id = StringProperty(verbose_name="AMI ID")
+    zone = StringProperty(verbose_name="Availability Zone")
+    security_group = StringProperty(verbose_name="Security Group", default="default")
+    key_name = StringProperty(verbose_name="Key Name")
+    elastic_ip = StringProperty(verbose_name="Elastic IP")
+    instance_type = StringProperty(verbose_name="Instance Type")
+    description = StringProperty(verbose_name="Description")
+    log = StringProperty()
+
+    def setReadOnly(self, value):
+        raise AttributeError
+
+    def getInstance(self):
+        if not self._instance:
+            if self.instance_id:
+                try:
+                    rs = self.ec2.get_all_instances([self.instance_id])
+                except:
+                    return None
+                if len(rs) > 0:
+                    self._reservation = rs[0]
+                    self._instance = self._reservation.instances[0]
+        return self._instance
+
+    instance = property(getInstance, setReadOnly, None, 'The Instance for the server')
+    
+    def getAMI(self):
+        if self.instance:
+            return self.instance.image_id
+
+    ami = property(getAMI, setReadOnly, None, 'The AMI for the server')
+    
+    def getStatus(self):
+        if self.instance:
+            self.instance.update()
+            return self.instance.state
+
+    status = property(getStatus, setReadOnly, None,
+                      'The status of the server')
+    
+    def getHostname(self):
+        if self.instance:
+            return self.instance.public_dns_name
+
+    hostname = property(getHostname, setReadOnly, None,
+                        'The public DNS name of the server')
+
+    def getPrivateHostname(self):
+        if self.instance:
+            return self.instance.private_dns_name
+
+    private_hostname = property(getPrivateHostname, setReadOnly, None,
+                                'The private DNS name of the server')
+
+    def getLaunchTime(self):
+        if self.instance:
+            return self.instance.launch_time
+
+    launch_time = property(getLaunchTime, setReadOnly, None,
+                           'The time the Server was started')
+
+    def getConsoleOutput(self):
+        if self.instance:
+            return self.instance.get_console_output()
+
+    console_output = property(getConsoleOutput, setReadOnly, None,
+                              'Retrieve the console output for server')
+
+    def getGroups(self):
+        if self._reservation:
+            return self._reservation.groups
+        else:
+            return None
+
+    groups = property(getGroups, setReadOnly, None,
+                      'The Security Groups controlling access to this server')
+
+    def getConfig(self):
+        if not self._config:
+            remote_file = BotoConfigPath
+            local_file = '%s.ini' % self.instance.id
+            self.get_file(remote_file, local_file)
+            self._config = Config(local_file)
+        return self._config
+
+    def setConfig(self, config):
+        local_file = '%s.ini' % self.instance.id
+        fp = open(local_file)
+        config.write(fp)
+        fp.close()
+        self.put_file(local_file, BotoConfigPath)
+        self._config = config
+
+    config = property(getConfig, setConfig, None,
+                      'The instance data for this server')
+
+    def set_config(self, config):
+        """
+        Set SDB based config
+        """
+        self._config = config
+        self._config.dump_to_sdb("botoConfigs", self.id)
+
+    def load_config(self):
+        self._config = Config(do_load=False)
+        self._config.load_from_sdb("botoConfigs", self.id)
+
+    def stop(self):
+        if self.instance:
+            self.instance.stop()
+
+    def start(self):
+        self.stop()
+        ec2 = boto.connect_ec2()
+        ami = ec2.get_all_images(image_ids = [str(self.ami_id)])[0]
+        groups = ec2.get_all_security_groups(groupnames=[str(self.security_group)])
+        if not self._config:
+            self.load_config()
+        if not self._config.has_section("Credentials"):
+            self._config.add_section("Credentials")
+            self._config.set("Credentials", "aws_access_key_id", ec2.aws_access_key_id)
+            self._config.set("Credentials", "aws_secret_access_key", ec2.aws_secret_access_key)
+
+        if not self._config.has_section("Pyami"):
+            self._config.add_section("Pyami")
+
+        if self._manager.domain:
+            self._config.set('Pyami', 'server_sdb_domain', self._manager.domain.name)
+            self._config.set("Pyami", 'server_sdb_name', self.name)
+
+        cfg = StringIO.StringIO()
+        self._config.write(cfg)
+        cfg = cfg.getvalue()
+        r = ami.run(min_count=1,
+                    max_count=1,
+                    key_name=self.key_name,
+                    security_groups = groups,
+                    instance_type = self.instance_type,
+                    placement = self.zone,
+                    user_data = cfg)
+        i = r.instances[0]
+        self.instance_id = i.id
+        self.put()
+        if self.elastic_ip:
+            ec2.associate_address(self.instance_id, self.elastic_ip)
+
+    def reboot(self):
+        if self.instance:
+            self.instance.reboot()
+
+    def get_ssh_client(self, key_file=None, host_key_file='~/.ssh/known_hosts',
+                       uname='root'):
+        import paramiko
+        if not self.instance:
+            print 'No instance yet!'
+            return
+        if not self._ssh_client:
+            if not key_file:
+                iobject = IObject()
+                key_file = iobject.get_filename('Path to OpenSSH Key file')
+            self._pkey = paramiko.RSAKey.from_private_key_file(key_file)
+            self._ssh_client = paramiko.SSHClient()
+            self._ssh_client.load_system_host_keys()
+            self._ssh_client.load_host_keys(os.path.expanduser(host_key_file))
+            self._ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            self._ssh_client.connect(self.instance.public_dns_name,
+                                     username=uname, pkey=self._pkey)
+        return self._ssh_client
+
+    def get_file(self, remotepath, localpath):
+        ssh_client = self.get_ssh_client()
+        sftp_client = ssh_client.open_sftp()
+        sftp_client.get(remotepath, localpath)
+
+    def put_file(self, localpath, remotepath):
+        ssh_client = self.get_ssh_client()
+        sftp_client = ssh_client.open_sftp()
+        sftp_client.put(localpath, remotepath)
+
+    def listdir(self, remotepath):
+        ssh_client = self.get_ssh_client()
+        sftp_client = ssh_client.open_sftp()
+        return sftp_client.listdir(remotepath)
+
+    def shell(self, key_file=None):
+        ssh_client = self.get_ssh_client(key_file)
+        channel = ssh_client.invoke_shell()
+        interactive_shell(channel)
+
+    def bundle_image(self, prefix, key_file, cert_file, size):
+        print 'bundling image...'
+        print '\tcopying cert and pk over to /mnt directory on server'
+        ssh_client = self.get_ssh_client()
+        sftp_client = ssh_client.open_sftp()
+        path, name = os.path.split(key_file)
+        remote_key_file = '/mnt/%s' % name
+        self.put_file(key_file, remote_key_file)
+        path, name = os.path.split(cert_file)
+        remote_cert_file = '/mnt/%s' % name
+        self.put_file(cert_file, remote_cert_file)
+        print '\tdeleting %s' % BotoConfigPath
+        # delete the metadata.ini file if it exists
+        try:
+            sftp_client.remove(BotoConfigPath)
+        except:
+            pass
+        command = 'sudo ec2-bundle-vol '
+        command += '-c %s -k %s ' % (remote_cert_file, remote_key_file)
+        command += '-u %s ' % self._reservation.owner_id
+        command += '-p %s ' % prefix
+        command += '-s %d ' % size
+        command += '-d /mnt '
+        if self.instance.instance_type == 'm1.small' or self.instance_type == 'c1.medium':
+            command += '-r i386'
+        else:
+            command += '-r x86_64'
+        print '\t%s' % command
+        t = ssh_client.exec_command(command)
+        response = t[1].read()
+        print '\t%s' % response
+        print '\t%s' % t[2].read()
+        print '...complete!'
+
+    def upload_bundle(self, bucket, prefix):
+        print 'uploading bundle...'
+        command = 'ec2-upload-bundle '
+        command += '-m /mnt/%s.manifest.xml ' % prefix
+        command += '-b %s ' % bucket
+        command += '-a %s ' % self.ec2.aws_access_key_id
+        command += '-s %s ' % self.ec2.aws_secret_access_key
+        print '\t%s' % command
+        ssh_client = self.get_ssh_client()
+        t = ssh_client.exec_command(command)
+        response = t[1].read()
+        print '\t%s' % response
+        print '\t%s' % t[2].read()
+        print '...complete!'
+
+    def create_image(self, bucket=None, prefix=None, key_file=None, cert_file=None, size=None):
+        iobject = IObject()
+        if not bucket:
+            bucket = iobject.get_string('Name of S3 bucket')
+        if not prefix:
+            prefix = iobject.get_string('Prefix for AMI file')
+        if not key_file:
+            key_file = iobject.get_filename('Path to RSA private key file')
+        if not cert_file:
+            cert_file = iobject.get_filename('Path to RSA public cert file')
+        if not size:
+            size = iobject.get_int('Size (in MB) of bundled image')
+        self.bundle_image(prefix, key_file, cert_file, size)
+        self.upload_bundle(bucket, prefix)
+        print 'registering image...'
+        self.image_id = self.ec2.register_image('%s/%s.manifest.xml' % (bucket, prefix))
+        return self.image_id
+
+    def attach_volume(self, volume, device="/dev/sdp"):
+        """
+        Attach an EBS volume to this server
+
+        :param volume: EBS Volume to attach
+        :type volume: boto.ec2.volume.Volume
+
+        :param device: Device to attach to (default to /dev/sdp)
+        :type device: string
+        """
+        if hasattr(volume, "id"):
+            volume_id = volume.id
+        else:
+            volume_id = volume
+        return self.ec2.attach_volume(volume_id=volume_id, instance_id=self.instance_id, device=device)
+
+    def detach_volume(self, volume):
+        """
+        Detach an EBS volume from this server
+
+        :param volume: EBS Volume to detach
+        :type volume: boto.ec2.volume.Volume
+        """
+        if hasattr(volume, "id"):
+            volume_id = volume.id
+        else:
+            volume_id = volume
+        return self.ec2.detach_volume(volume_id=volume_id, instance_id=self.instance_id)
+
+    def install_package(self, package_name):
+        print 'installing %s...' % package_name
+        command = 'yum -y install %s' % package_name
+        print '\t%s' % command
+        ssh_client = self.get_ssh_client()
+        t = ssh_client.exec_command(command)
+        response = t[1].read()
+        print '\t%s' % response
+        print '\t%s' % t[2].read()
+        print '...complete!'