示例#1
0
    def copy_lab_source(self, vm_id, lab_repo_name, git_clone_loc):

        directories = git_clone_loc.split("/")
        labs_dir = directories[-2]
        src_dir = None
        if base_config.ADS_ON_CONTAINER:
            src_dir = "%s%s%s%s%s%s" % (base_config.VM_ROOT_DIR,
                                        base_config.ADS_SERVER_VM_ID,
                                        base_config.VM_DEST_DIR, labs_dir,
                                        "/", lab_repo_name)
        else:
            src_dir = "%s%s%s%s" % (base_config.VM_DEST_DIR, labs_dir,
                                    "/", lab_repo_name)

        dest_dir = "%s%s%s" % (base_config.VM_ROOT_DIR, vm_id,
                               base_config.VM_DEST_DIR + "labs")

        logger.debug("vm_id = %s, src_dir=%s, dest_dir=%s" %
                     (vm_id, src_dir, dest_dir))

        try:
            return self.copy_files(src_dir, dest_dir)
        except Exception, e:
            logger.error("ERROR = %s" % str(e))
            return False
示例#2
0
    def destroy_vm(self, vm_id):
        vm_id = self.validate_vm_id(vm_id)
        try:

            command = (r'ssh -o "%s" %s "%s stop %s"' %
                       (base_config.NO_STRICT_CHECKING,
                        base_config.BASE_IP_ADDRESS,
                        VZCTL, vm_id))
            logger.debug("BridgeVZAdapter: destroy_vm(): stop command = %s" %
                         command)
            (ret_code, output) = execute_command(command)

            if ret_code == 0:
                command = (r'ssh -o "%s" %s "%s destroy %s"' %
                           (base_config.NO_STRICT_CHECKING,
                            base_config.BASE_IP_ADDRESS,
                            VZCTL, vm_id))
                logger.debug("BridgeVZAdapter: destroy_vm(): destroy command = \
                             %s" % command)
                (ret_code, output) = execute_command(command)
                if ret_code == 0:
                    return "Success"
        except Exception, e:
            logger.error("Error destroying VM: " + str(e))
            return "Failed to destroy VM: " + str(e)
示例#3
0
 def copy_public_key(self, vm_id):
     
     try:
         public_key_file = ("%s%s%s%s" %
                            (base_config.VM_ROOT_DIR,
                             base_config.ADS_SERVER_VM_ID,
                             base_config.VM_DEST_DIR, ".ssh/id_rsa.pub"))
         
         authorized_key_file = ("%s%s%s%s" %
                                (base_config.VM_ROOT_DIR, vm_id,
                                 base_config.VM_DEST_DIR,
                                 ".ssh/authorized_keys"))
         
         logger.debug("public key location = %s, authorized key location = %s" %
                      (public_key_file, authorized_key_file))
         command = (r'ssh -o "%s" %s "%s %s > %s"' %
                    (base_config.NO_STRICT_CHECKING,
                     base_config.BASE_IP_ADDRESS,
                     "/bin/cat", public_key_file, authorized_key_file))
         logger.debug("command to cpy the public key = %s" % command)
         (ret_code, output) = execute_command(command)
         return True
     except Exception, e:
         logger.error("ERROR = %s" % str(e))
         return False
示例#4
0
    def get_instance(self, vm_id):
        logger.debug("AWSAdapter: get_instance(): vm_id: %s" % (vm_id))

        reservations = self.connection.get_all_instances(instance_ids=[vm_id])
        instance = reservations[0].instances[0]

        return instance
示例#5
0
 def construct_repo_name(self, lab_src_url):
     # sample lab_src_url: [email protected]:vlead/ovpl.git
     logger.debug("lab_src_url: %s" % lab_src_url)
     repo = lab_src_url.split('/')[-1]
     repo_name = (repo[:-4] if repo[-4:] == ".git" else repo)
     logger.debug("repo_name: %s" % repo_name)
     return str(repo_name)
示例#6
0
def create_record(lab_src_url=None, c=None):
    logger.debug("Test case insert_record")
    if c is None:
        c = Controller()
        if lab_src_url is None:
            lab_src_url = \
                "https://github.com/Virtual-Labs/computer-programming-iiith.git"
    revision_tag = None
    lab_id = "cse04"
    current_user = "******"
    vmpool_id = 1
    vm_description = "LINUXAdapter"
    adapter_ip = "http://localhost"
    adapter_port = "8000"
    create_path = "/api/1.0/vm/create"
    destroy_path = "/api/1.0/vm/destroy"
    vm_id = "123"
    vm_ip = "10.12.13.114"
    vm_port = "8089"
    try:
        vm_pool = VMPool(vmpool_id, vm_description, adapter_ip,
                         adapter_port, create_path, destroy_path)
        c.lab_spec = c.labmgr.get_lab_reqs(lab_src_url, revision_tag)
        logger.debug("returned from lab_manager and the controller's lab_spec = %s"
                     % c.lab_spec)
        c.update_lab_spec(lab_id, lab_src_url, revision_tag)
        record = vm_pool.construct_state(c.lab_spec, vm_id,
                                         vm_ip, vm_port)
        c.deploy_record.record = record
        c.update_deploy_record(current_user)
        logger.debug("deploy_record = %s" % c.deploy_record.record)
        logger.debug("ID = %s" % c.deploy_record.record['id'])
        return c.deploy_record
    except Exception, e:
        logger.debug("Error inserting record, error is %s" % str(e))
示例#7
0
 def add_vm_pool(self, vm_pool_id, vm_description, adapter_ip,
                 adapter_port, create_path, destroy_path):
     logger.debug("VMPoolManager: add_vm_pool(); %s, %s, %s, %s, %s, %s" %
                  (vm_pool_id, vm_description, adapter_ip,
                   adapter_port, create_path, destroy_path))
     self.vmpools.append(VMPool(vm_pool_id, vm_description,
                         adapter_ip, adapter_port,
                         create_path, destroy_path))
示例#8
0
 def test_find_os_template():
     os = "ubuntu"
     os_version = "12"
     try:
         template = find_os_template(os, os_version)
         logger.debug("Returned template = %s" % template)
     except Exception, e:
         logger.debug("Exception = %s" % str(e))
示例#9
0
 def test_get_lab_reqs():
     lab_src_url = "https://github.com/Virtual-Labs/computer-programming-iiith.git"
     labmgr = LabManager()
     try:
         lab_spec = labmgr.get_lab_reqs(lab_src_url, version=None)
         logger.debug("Lab spec: %s" % str(lab_spec))
     except Exception, e:
         logger.error("Test failed with error: " + str(e))
示例#10
0
    def create_vm(self, lab_spec, vm_id=""):
        logger.debug("centos_openvz_adapter: create_vm()")
        """If no vm_id is specified, it is computed using the last two
        segments"""
        """of an available IP address; vm_spec is an object """
        if vm_id == "":
            ip_address = base_adapter.find_available_ip()
            m = re.match(r'[0-9]+.[0-9]+.([0-9]+).([0-9]+)', ip_address)
            if m is not None:
                vm_id = str((int(m.group(1) + m.group(2))))
                # vm_id = m.group(1) + m.group(2)
        else:
            ip_address = None
            vm_id = self.validate_vm_id(vm_id)

        (vm_create_args, vm_set_args) = self.construct_vzctl_args(lab_spec)

        logger.debug("centos_openvz_adapter: create_vm(): ip = %s, vm_id = %s, \
                     vm_create_args = %s, vm_set_args = %s" %
                     (ip_address, vm_id, vm_create_args, vm_set_args))

        try:
            command = (r'ssh -o "%s" %s "%s create %s %s"' %
                       (base_config.NO_STRICT_CHECKING,
                        base_config.BASE_IP_ADDRESS,
                        VZCTL, vm_id, vm_create_args))
            logger.debug("centos_openvz_adapter: create_vm(): create command = %s" %
                         command)
            (ret_code, output) = execute_command(command)

            if ret_code == 0:

                command = (r'ssh -o "%s" %s "%s start %s"' %
                           (base_config.NO_STRICT_CHECKING,
                            base_config.BASE_IP_ADDRESS,
                            VZCTL, vm_id))
                logger.debug("centos_openvz_adapter: create_vm():start command = %s" %
                             command)
                (ret_code, output) = execute_command(command)

                if ret_code == 0:

                    command = (r'ssh -o "%s" %s "%s set %s %s"' %
                               (base_config.NO_STRICT_CHECKING,
                                base_config.BASE_IP_ADDRESS,
                                VZCTL, vm_id, vm_set_args))
                    logger.debug("centos_openvz_adapter:create_vm():set command=%s" %
                                 command)
                    (ret_code, output) = execute_command(command)

                    if ret_code == 0:
                        return (True, vm_id)

        except Exception, e:
            logger.error("Error creating VM: " + str(e))
            # raise e
            return (False, -1)
示例#11
0
    def get_vm_ip(self, vm_id):
        logger.debug("AWSAdapter: get_vm_ip(): vm_id: %s" % (vm_id))

        instance = self.get_instance(vm_id)

        logger.debug("AWSAdapter: IP address of the instance is: %s" %
                     instance.private_ip_address)

        return instance.private_ip_address
示例#12
0
文件: controller.py 项目: vlead/ovpl
 def update_lab_spec(self, lab_id, lab_src_url, revision_tag):
     self.lab_spec['lab']['description']['id'] = \
         self.lab_spec['lab_id'] = lab_id
     self.lab_spec['lab']['lab_src_url'] = lab_src_url
     self.lab_spec['lab']['lab_repo_name'] = \
         self.git.construct_repo_name(lab_src_url)
     self.lab_spec['lab']['revision_tag'] = revision_tag
     self.lab_spec['lab']['runtime_requirements']['hosting'] = 'dedicated'
     logger.debug("lab_repo_name: %s" %
                  (self.lab_spec['lab']['lab_repo_name']))
示例#13
0
 def reset_repo(self, repo_name):
     repo = self.git_clone_loc + repo_name
     reset_cmd = "git --git-dir=%s/.git --work-tree=%s reset --hard" % (repo, repo)
     logger.debug("reset cmd: %s" % reset_cmd)
     try:
         (ret_code, output) = execute_command(reset_cmd)
         logger.debug("reset repo successful")
     except Exception, e:
         logger.error("Error Resetting the repository: " + str(e))
         raise e
示例#14
0
 def clone_repo(self, lab_src_url, repo_name):
     clone_cmd = "git clone %s %s%s" % (lab_src_url, self.git_clone_loc,
                                        repo_name)
     logger.debug(clone_cmd)
     try:
         (ret_code, output) = execute_command(clone_cmd)
         logger.debug("Clone repo successful")
     except Exception, e:
         logger.error("Error Cloning the repository: " + str(e))
         raise e
示例#15
0
 def get_lab_spec(self, repo_name):
     spec_file_path = self.get_spec_path(repo_name) + self.lab_spec_file
     logger.debug("spec_file_path: %s" % spec_file_path)
     if not os.path.exists(spec_file_path):
         logger.error("Lab spec file not found")
         raise LabSpecInvalid("Lab spec file not found")
     try:
         return json.loads(open(spec_file_path).read())
     except Exception, e:
         logger.error("Lab spec JSON invalid: " + str(e))
示例#16
0
 def pull_repo(self, repo_name):
     repo = self.git_clone_loc + repo_name
     pull_cmd = "git --git-dir=%s/.git --work-tree=%s pull" % (repo, repo)
     logger.debug("pull cmd: %s" % pull_cmd)
     try:
         (ret_code, output) = execute_command(pull_cmd)
         logger.debug("Pull repo successful")
     except Exception, e:
         logger.error("Error Pulling the repository: " + str(e))
         raise e
示例#17
0
def find_os_template(os, os_version, supported_images):
    """
    Find a suitable os image from the list of supported images from
    the given OS and OS version. If a suitable OS is not found, raise
    appropriate Exception
    """
    logger.debug("OS = %s and OS_VERSION = %s" % (os, os_version))
    logger.debug("Supported images = %s" % supported_images)

    if os == "" or os_version == "":
        msg = "No OS or Version specified"
        logger.error(msg)
        raise OSNotFound(msg)

    # sanitize input
    os = os.strip().upper()
    os_version = os_version.strip()

    if os == 'UBUNTU' and os_version == '12':
        os_version = '12.04'

    if os == 'UBUNTU' and os_version == '13':
        os_version = '13.04'

    if os == 'UBUNTU' and os_version == '14':
        os_version = '14.04'
    
    if os == 'CENTOS' and os_version == '6':
        os_version = '6.9'

    # filter the supported image list by the os and the by the version
    all_versions_of_os = filter(lambda x: x['os'] == os, supported_images)
    logger.debug("List of all the supported versions of OS = %s is %s" %
                 (os, all_versions_of_os))
    if all_versions_of_os:
        chosen_template = filter(lambda x: x['version'] ==
                                 os_version, all_versions_of_os)
        logger.debug("The image supported for OS = %s, Version = %s is %s" %
                     (os, os_version, chosen_template))
    else:
        msg = "OS = %s is not supported" % os
        logger.error(msg)
        raise OSNotFound(msg)

    if not chosen_template or not len(chosen_template):
        msg = "Version = %s is not supported" % os_version
        logger.error(msg)
        raise OSNotFound(msg)

    # chose the item; there should be only one.
    chosen_template = chosen_template[0]

    logger.debug("Choosen image: %s; based on input OS: %s, version: %s" %
                 (chosen_template, os, os_version))
    return chosen_template['id']
示例#18
0
 def checkout_version(self, repo_name, version=None):
     repo = self.git_clone_loc + repo_name
     if version is None:
         version = "master"
     checkout_cmd = "git --git-dir=%s/.git --work-tree=%s checkout %s" % (repo, repo, version)
     try:
         (ret_code, output) = execute_command(checkout_cmd)
         logger.debug("Checkout repo successful")
     except Exception, e:
         logger.error("Error checking out the repository: " + str(e))
         raise e
示例#19
0
文件: controller.py 项目: vlead/ovpl
 def update_deploy_record(self, current_user):
     logger.debug("current user is %s" % current_user)
     self.deploy_record.record['lab_history']['deployed_by'] = current_user
     self.deploy_record.record['lab_history']['released_by'] = 'dummy'
     self.deploy_record.record['lab_history']['released_on'] = \
         datetime.utcnow()
     # This is a hack, just to avoid duplicate records.
     self.deploy_record.record['id'] = \
         self.lab_spec['lab']['lab_src_url'] + str(datetime.utcnow())
     logger.debug("Lab deployed by %s" %
                  self.deploy_record.record['lab_history']['deployed_by'])
示例#20
0
 def restart_vm(self, vm_id):
     vm_id = self.validate_vm_id(vm_id)
     try:
         command = (r'ssh -o "%s" %s "%s restart %s"' %
                    (base_config.NO_STRICT_CHECKING,
                     base_config.BASE_IP_ADDRESS,
                     VZCTL, vm_id))
         logger.debug("BridgeVZAdapter: restart_vm(): restart command = %s"
                      % command)
         (ret_code, output) = execute_command(command)
     except Exception, e:
         raise e
示例#21
0
 def get_used_pools(self, lab_id):
     used_pools = []
     logger.debug("VMPoolManager: get_used_pools()")
     deployment_record = self.state.get_record(lab_id)
     logger.debug("Deployment Record = %s" % deployment_record)
     if deployment_record is not None:
         # Currently there is only pool where the lab is deployed
         used_pools.append(deployment_record['vmpool_info']['vmpool_id'])
         return used_pools
     else:
         logger.error("No record found with the lab id = %s" % lab_id)
         raise RecordNotFoundError(lab_id)
示例#22
0
文件: vm_pool.py 项目: ksripathi/ovpl
 def construct_state(self, lab_spec, vm_id, vm_ip, vm_port):
     deploy_record = Record().record
     logger.debug("before setting record = %s" % deploy_record)
     deploy_record["lab_spec"] = lab_spec
     deploy_record["vm_info"]["vm_id"] = vm_id
     deploy_record["vm_info"]["vm_ip"] = vm_ip
     deploy_record["vm_info"]["vm_port"] = vm_port
     deploy_record["vmpool_info"]["vmpool_id"] = self.vmpool_id
     deploy_record["vmpool_info"]["vm_description"] = self.vm_description
     deploy_record["vmpool_info"]["adapter_ip"] = self.adapter_ip
     deploy_record["vmpool_info"]["adapter_port"] = self.adapter_port
     logger.debug("after setting record = %s" % deploy_record)
     return deploy_record
示例#23
0
    def init_vm(self, vm_id, lab_repo_name):
        logger.debug("BridgeVZAdapter: init_vm(): vm_id = %s" % vm_id)
        success = True
        success = success and self.copy_public_key(vm_id)
        success = success and self.copy_ovpl_source(vm_id)
        success = success and self.copy_lab_source(vm_id, lab_repo_name,
                                              self.git.get_git_clone_loc())
        success = success and self.start_vm_manager(vm_id)
        response = {"vm_id": vm_id, "vm_ip": IP_ADDRESS, "vm_port": base_config.VM_MANAGER_PORT}
                            
        # check if the VMManager service came up and running..
        logger.debug("Ensuring VMManager service is running on VM %s" %
                     response['vm_ip'])
        vmmgr_port = int(base_config.VM_MANAGER_PORT)
        success = base_adapter.wait_for_service(response['vm_ip'], vmmgr_port,
                                                self.time_before_next_retry,
                                                config.TIMEOUT)
        
        if not success:
            logger.debug("Could not reach VMManager after %s secs!! Aborting." %
                         config.TIMEOUT)
            return (success, response)

        logger.debug("centos_openvz_adapter: init_vm(): success = %s, response = %s" %
                     (success, response))
       
        return (success, response)
示例#24
0
 def create_vm_id(self, vm_id):
     """If no vm_id is specified, it is computed using the last two segments"""
     """of an available IP address; vm_spec is an object """
     logger.debug("create_vm_id(): vm_id = %s" % vm_id)
     if vm_id == "":
         global IP_ADDRESS
         IP_ADDRESS = base_adapter.find_available_ip()
         m = re.match(r'[0-9]+.[0-9]+.([0-9]+).([0-9]+)', IP_ADDRESS)
         if m is not None:
             vm_id = str((int(m.group(1) + m.group(2))))
         else:
             vm_id = self.validate_vm_id(vm_id)
     logger.debug("create_vm_id(): vm_id = %s" % vm_id)
     return vm_id
示例#25
0
文件: controller.py 项目: vlead/ovpl
 def register_lab(self, lab_id, ip_address):
     service_host = base_config.SERVICE_HOST
     service_name = "hosting_service"
     service_action = "register"
     command = 'ssh  %s %s %s %s %s' % \
               (service_host, service_name, service_action, lab_id,
                ip_address)
     logger.debug("Hook's service command =  %s" %
                  command)
     (ret_code, output) = execute_command(command)
     if ret_code == 0:
         domain_name = lab_id + "." +  get_adapter_hostname()
         logger.debug("FQDN of lab is  =  %s" %
                      domain_name)
         return domain_name
示例#26
0
    def stop_vm(self, vm_id):
        vm_id = self.validate_vm_id(vm_id)
        try:
            command = (r'ssh -o "%s" %s "%s stop %s"' %
                       (base_config.NO_STRICT_CHECKING,
                        base_config.BASE_IP_ADDRESS,
                        VZCTL, vm_id))
            logger.debug("centos_openvz_adapter: stop_vm(): command = %s" %
                         command)
            (ret_code, output) = execute_command(command)
            return "Success"

        except Exception, e:
            logger.error("Error stopping VM: " + str(e))
            return "Failed to stop VM: " + str(e)
示例#27
0
def is_service_up(vm_ip, port):
        logger.debug("base_adapter: is_service_up(): VM IP: %s" % vm_ip)
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            logger.debug("base_adapter: trying to connect to port: %s of: %s" %
                         (port, vm_ip))
            s.connect((vm_ip, port))
            logger.debug("base_adapter: VM %s: port: %s is up.." % (vm_ip, port))
            return True
        except socket.error as e:
            logger.debug("base_adapter: VM %s: Error connecting to port: %s: %s" %
                         (vm_ip, port, e))
            logger.debug("base_adapter: retrying to reach port %s.." % port)
            s.close()
            return False
示例#28
0
    def _copy_lab_source(self, ip_addr, lab_repo_name):
        src_dir = str(self.git.git_clone_loc) + "/" + lab_repo_name

        dest_dir = "{0}@{1}:{2}labs/".format(self.VM_USER, ip_addr,
                                             base_config.VM_DEST_DIR)

        logger.debug("ip_address = %s, src_dir=%s, dest_dir=%s" %
                     (ip_addr, src_dir, dest_dir))

        try:
            return self._copy_files(src_dir, dest_dir)
        except Exception, e:
            logger.error("ERROR = %s" % str(e))
            print 'ERROR= %s' % (str(e))
            return False
示例#29
0
def execute_command(cmd):
    logger.debug("command: %s" % cmd)
    return_code = -1
    output = None
    try:
        output = subprocess.check_output(cmd, shell=True)
        return_code = 0
    except subprocess.CalledProcessError as cpe:
        logger.error("Called Process Error Message: %s" % cpe.output)
        raise cpe
    except OSError as ose:
        logger.error("OSError: %s" % ose.output)
        raise ose

    return (return_code, output)
示例#30
0
 def copy_ovpl_source(self, vm_id):
     
     src_dir = "%s%s%s" % (base_config.VM_ROOT_DIR,
                           base_config.ADS_SERVER_VM_ID,
                           base_adapter.OVPL_DIR_PATH)
     dest_dir = "%s%s%s" % (base_config.VM_ROOT_DIR, vm_id,
                            base_config.VM_DEST_DIR)
     logger.debug("vm_id = %s, src_dir=%s, dest_dir=%s"
                  % (vm_id, src_dir, dest_dir))
     
     try:
         return self.copy_files(str(src_dir), str(dest_dir))
     except Exception, e:
         logger.error("ERROR = %s" % str(e))
         return False
示例#31
0
        c = Controller()
        # log the user who is deploying the lab..
        logger.debug("Lab Deployment: deployed by: %s, lab id: %s, URL: %s" %
                     (post_data['current_user'],
                      post_data['lab_id'],
                      post_data['lab_src_url']))
        
        self.write(c.test_lab(post_data['current_user'], post_data['lab_id'],
                              post_data['lab_src_url'],
                              post_data.get('version', None)))


if __name__ == "__main__":
    env = EnvSetUp.Instance()
    config_spec = env.get_config_spec()
    tornado.options.parse_command_line()
    app = tornado.web.Application(
        handlers=[
            (r"/", MainHandler)
        ],
        template_path=os.path.join(os.path.dirname(__file__), "templates"),
        static_path=os.path.join(os.path.dirname(__file__), "static"),
        cookie_secret=config_spec["CONTROLLER_CONFIG"]["COOKIE_SECRET"],
        debug=True)

    http_server = tornado.httpserver.HTTPServer(app)
    options.port = config_spec["CONTROLLER_CONFIG"]["SERVER_PORT"]
    logger.debug("ControllerServer: It will run on port : " + str(options.port))
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()