Пример #1
0
 def launch(self):     
     SIGINTWatcher(self.cleanup_after_kill)
     t_start = time.time()
     
     ami = self.config.get_ami()
     keypair = self.config.get_keypair()
     insttypes = self.config.get_instance_type()
     zone = self.config.get_ec2_zone()   
     
     # Parse the instance type option
     role_insttype = {}
     for ri in insttypes.split():
         role, insttype = ri.split(":")
         role_insttype[role] = insttype
     default_insttype = role_insttype["*"]
     
     log.init_logging(self.loglevel)
     
     try:
         log.debug("Connecting to EC2...")
         self.conn = create_ec2_connection()
         if self.conn == None:
             print "AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are not set."
             exit(1)
         log.debug("Connected to EC2.")
     except BotoClientError, exc:
         print "\033[1;31mERROR\033[0m - Could not connect to EC2."
         print "        Reason: %s" % exc.reason
         exit(1)
Пример #2
0
 def thread_success(self, thread):
     with self.lock:
         self.done_threads += 1
         log.debug("%s thread has finished successfully." % thread.name)
         log.debug("%i threads are done. Remaining: %s" % (self.done_threads, ",".join([t.name for t in self.threads.values() if t.status == -1])))
         for t in [th for th in self.threads.values() if th.depends == thread]:
             t.start()            
         if self.done_threads == self.num_threads:
             self.all_done.set()            
Пример #3
0
 def scp_dir(self, fromdir, todir):
     for root, dirs, files in walk(fromdir):
         todir_full = todir + "/" + root[len(fromdir):]
         try:
             self.sftp.stat(todir_full)
         except IOError, e:
             self.sftp.mkdir(todir_full)
         for f in files:
             fromfile = root + "/" + f
             tofile = todir_full + "/" + f
             self.sftp.put(fromfile, tofile)
             log.debug("scp %s -> %s:%s" % (fromfile, self.hostname, tofile))
Пример #4
0
 def thread_failure(self, thread):
     with self.lock:
         if not isinstance(thread.exception, ThreadAbortException):
             log.debug("%s thread has failed." % thread.name)
             self.abort.set()
         else:
             log.debug("%s thread is being aborted." % thread.name)
             thread.status = 2
         self.done_threads += 1
         log.debug("%i threads are done. Remaining: %s" % (self.done_threads, ",".join([t.name for t in self.threads.values() if t.status == -1])))
         if self.done_threads == self.num_threads:
             self.all_done.set()           
Пример #5
0
 def run(self, command, outf=None, errf=None, exception_on_error = True, expectnooutput=False):
     channel = self.client.get_transport().open_session()
     
     log.debug("%s - Running %s" % (self.hostname,command))
     
     if expectnooutput:
         outf = None
         errf = None
     else:
         if outf != None:
             outf = open(outf, "w")
         else:
             outf = self.default_outf
     
         if errf != None:
             errf = open(errf, "w")
         else:
             errf = self.default_errf
         
     try:
         channel.exec_command(command)
 
         if outf != None or errf != None:
             while True:
                 rl, wl, xl = select.select([channel],[],[])
                 if len(rl) > 0:
                     # Must be stdout
                     x = channel.recv(1)
                     if not x: break
                     outf.write(x)
                     outf.flush()
             
             if outf != sys.stdout:
                 outf.close()
                 
             if errf != sys.stderr:
                 outf.close()
         
         log.debug("%s - Waiting for exit status: %s" % (self.hostname,command))
         rc = channel.recv_exit_status()
         log.debug("%s - Ran %s" % (self.hostname,command))
         channel.close()
     except Exception, e:
         raise # Replace by something more meaningful
Пример #6
0
    def run2(self):
        node = self.node
        instance = self.instance
        
        log.info("Setting up instance %s. Hostname: %s" % (instance.id, instance.public_dns_name), node)

        if self.launcher.config.has_snap():
            log.debug("Creating Chef volume.", node)
            vol = self.launcher.conn.create_volume(1, instance.placement, self.launcher.config.get_snap())
            log.debug("Created Chef volume %s. Attaching." % vol.id, node)
            vol.attach(instance.id, '/dev/sdh')
            log.debug("Chef volume attached. Waiting for it to become in-use.", node)
            self.launcher.wait_state(vol, "in-use")
            log.debug("Volume is in-use", node)
    
            self.launcher.vols.append(vol)

        self.check_continue()

        if self.launcher.loglevel in (0,1):
            ssh_out = None
            ssh_err = None
        elif self.launcher.loglevel == 2:
            ssh_out = sys.stdout
            ssh_err = sys.stderr

        log.debug("Establishing SSH connection", node)
        ssh = SSH("ubuntu", instance.public_dns_name, self.launcher.config.get_keyfile(), ssh_out, ssh_err)
        ssh.open()
        log.debug("SSH connection established", node)

        self.check_continue()
        
        if self.launcher.config.has_snap():
            log.debug("Mounting Chef volume", node)
            ssh.run("sudo mount -t ext3 /dev/sdh /chef", expectnooutput=True)
        
        # Upload host file and update hostname
        log.debug("Uploading host file and updating hostname", node)
        ssh.scp("%s/hosts_ec2" % self.launcher.generated_dir,
                "/chef/cookbooks/demogrid/files/default/hosts")             
        ssh.run("sudo cp /chef/cookbooks/demogrid/files/default/hosts /etc/hosts", expectnooutput=True)
        ssh.run("sudo bash -c \"echo %s > /etc/hostname\"" % node.hostname, expectnooutput=True)
        ssh.run("sudo /etc/init.d/hostname restart")
        
        self.check_continue()
        
        # Upload topology file
        log.debug("Uploading topology file", node)
        ssh.scp("%s/topology_ec2.rb" % self.launcher.generated_dir,
                "/chef/cookbooks/demogrid/attributes/topology.rb")             
        
        # Copy certificates
        log.debug("Copying certificates", node)
        ssh.scp_dir("%s/certs" % self.launcher.generated_dir, 
                    "/chef/cookbooks/demogrid/files/default/")
        
        self.check_continue()

        if self.launcher.loglevel == 0:
            print "   \033[1;37m%s\033[0m: Basic setup is done. Installing Grid software now." % node.hostname.split(".")[0]
        
        # Run chef
        log.debug("Running chef", node)
        ssh.scp("%s/lib/ec2/chef.conf" % self.launcher.demogrid_dir,
                "/tmp/chef.conf")        
        
        ssh.run("echo '{ \"run_list\": \"role[%s]\" }' > /tmp/chef.json" % node.role, expectnooutput=True)

        ssh.run("sudo chef-solo -c /tmp/chef.conf -j /tmp/chef.json")    

        self.check_continue()

        # The Chef recipes will overwrite the hostname, so
        # we need to set it again.
        ssh.run("sudo bash -c \"echo %s > /etc/hostname\"" % node.hostname, expectnooutput=True)
        ssh.run("sudo /etc/init.d/hostname restart")
        
        if self.launcher.config.has_snap():
            ssh.run("sudo umount /chef", expectnooutput=True)
            vol.detach()
            self.launcher.wait_state(vol, "available")        
            vol.delete()
            
            self.launcher.vols.remove(vol)
        
        ssh.run("sudo update-rc.d nis enable")     

        log.info("Configuration done.", node)
        
        if self.launcher.loglevel == 0:
            print "   \033[1;37m%s\033[0m is ready." % node.hostname.split(".")[0]
Пример #7
0
            log.debug("Connecting to EC2...")
            self.conn = create_ec2_connection()
            if self.conn == None:
                print "AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are not set."
                exit(1)
            log.debug("Connected to EC2.")
        except BotoClientError, exc:
            print "\033[1;31mERROR\033[0m - Could not connect to EC2."
            print "        Reason: %s" % exc.reason
            exit(1)
        except Exception, exc:
            self.handle_unexpected_exception(exc)
            
        
        # Load topology
        log.debug("Loading topology file...")
        f = open ("%s/topology.dat" % self.generated_dir, "r")
        topology = load(f)
        f.close()
        log.debug("Loaded topology file")

        if self.config.get_ec2_access_type() == "public":
            topology.global_attributes["ec2_public"] = "true"
        else:
            topology.global_attributes["ec2_public"] = "false"

        nodes = topology.get_nodes()
        num_instances = len(nodes)
        
        nodes_by_role = {}
        for n in nodes:
Пример #8
0
        else:
            return rc
    

        
        
    def scp(self, fromf, tof):
        try:
            self.sftp.put(fromf, tof)
        except Exception, e:
            traceback.print_exc()
            try:
                self.close()
            except:
                pass
        log.debug("scp %s -> %s:%s" % (fromf, self.hostname, tof))
        
    def scp_dir(self, fromdir, todir):
        for root, dirs, files in walk(fromdir):
            todir_full = todir + "/" + root[len(fromdir):]
            try:
                self.sftp.stat(todir_full)
            except IOError, e:
                self.sftp.mkdir(todir_full)
            for f in files:
                fromfile = root + "/" + f
                tofile = todir_full + "/" + f
                self.sftp.put(fromfile, tofile)
                log.debug("scp %s -> %s:%s" % (fromfile, self.hostname, tofile))