def run(**kwargs):
    """Calls all the functions needed to upload new template to RHEVM.
       This is called either by template_upload_all script, or by main function.

    Args:
        **kwargs: Kwargs generated from cfme_data['template_upload']['template_upload_rhevm'].
    """
    ovaname = get_ova_name(kwargs.get('image_url'))

    mgmt_sys = cfme_data['management_systems'][kwargs.get('provider')]

    rhevurl = mgmt_sys['hostname']
    rhevm_credentials = mgmt_sys['credentials']
    username = credentials[rhevm_credentials]['username']
    password = credentials[rhevm_credentials]['password']
    ssh_rhevm_creds = mgmt_sys['hosts'][0]['credentials']
    sshname = credentials[ssh_rhevm_creds]['username']
    sshpass = credentials[ssh_rhevm_creds]['password']
    rhevip = mgmt_sys['ipaddress']

    apiurl = 'https://%s:443/api' % rhevurl

    ssh_client = make_ssh_client(rhevip, sshname, sshpass)
    api = API(url=apiurl, username=username, password=password,
              insecure=True, persistent_auth=False)

    template_name = kwargs.get('template_name', None)
    if template_name is None:
        template_name = cfme_data['basic_info']['appliance_template']

    kwargs = update_params_api(api, **kwargs)

    check_kwargs(**kwargs)

    if api.templates.get(template_name) is not None:
        print "RHEVM: Found finished template with this name."
        print "RHEVM: The script will now end."
    else:
        print "RHEVM: Downloading .ova file..."
        download_ova(ssh_client, kwargs.get('image_url'))
        try:
            print "RHEVM: Templatizing .ova file..."
            template_from_ova(api, username, password, rhevip, kwargs.get('edomain'),
                              ovaname, ssh_client)
            print "RHEVM: Importing new template..."
            import_template(api, kwargs.get('edomain'), kwargs.get('sdomain'),
                            kwargs.get('cluster'))
            print "RHEVM: Making a temporary VM from new template..."
            make_vm_from_template(api, kwargs.get('cluster'))
            print "RHEVM: Adding disk to created VM..."
            add_disk_to_vm(api, kwargs.get('sdomain'), kwargs.get('disk_size'),
                           kwargs.get('disk_format'), kwargs.get('disk_interface'))
            print "RHEVM: Templatizing VM..."
            templatize_vm(api, template_name, kwargs.get('cluster'))
        finally:
            cleanup(api, kwargs.get('edomain'), ssh_client, ovaname)
            ssh_client.close()
            api.disconnect()

    print "RHEVM: Done."
Esempio n. 2
0
def conn(url, user, password):
    api = API(url=url, username=user, password=password, insecure=True)
    try:
        value = api.test()
    except:
        raise Exception("error connecting to the oVirt API")
    return api
def _initialize_api(hostname, username, password, ca, insecure):
    """
    Initialize the oVirt RESTful API
    """
    url = 'https://{hostname}/ovirt-engine/api'.format(
        hostname=hostname,
    )
    api = API(url=url,
              username=username,
              password=password,
              ca_file=ca,
              validate_cert_chain=not insecure)
    pi = api.get_product_info()
    if pi is not None:
        vrm = '%s.%s.%s' % (
            pi.get_version().get_major(),
            pi.get_version().get_minor(),
            pi.get_version().get_revision()
        )
        logging.debug("API Vendor(%s)\tAPI Version(%s)" % (
            pi.get_vendor(), vrm)
        )
    else:
        api.test(throw_exception=True)
    return api
Esempio n. 4
0
def conn(url, user, password):
    api = API(url=url, username=user, password=password, insecure=True)
    try:
        value = api.test()
    except:
        print "error connecting to the oVirt API"
        sys.exit(1)
    return api
Esempio n. 5
0
def get_connection(location):
    api = API(  url="https://" + locations.get(location, "host"),
                username=locations.get(location, "username"),
                password=locations.get(location, "password"),
                ca_file=locations.get(location, "certificate")
                )

    print "Connected to %s successfully!" % api.get_product_info().name
    return api
def main():
    URL='https://<ovirt-host>:443/api'
    USERNAME='******'
    PASSWORD='******'

    api = API(url=URL, username=USERNAME, password=PASSWORD,insecure=True)
    vm_list=api.vms.list()
    for vm in vm_list:
        print vm.name
    api.disconnect()
def main():
    url='https://vm-rhevm01.infoplus-ot.ris:443/api'
    username='******'
    password=getpass.getpass("Supply password for user %s: " % username)

    api = API(url=url, username=username, password=password,insecure=True)
    vm_list=api.vms.list()
    for vm in vm_list:
        print vm.name
    api.disconnect()
Esempio n. 8
0
def main():
	URL = 'https://192.168.1.112:443/api'
	USERNAME = '******'
	PASSWORD = '******'
	api = API(url=URL, username=USERNAME, password=PASSWORD, insecure=True)
	vm = api.vms.get(name="ubuntu14.04")
	print vm.name
	#vm_list = api.vms.list()
	#for vm in vm_list:
	#	print vm.name
	api.disconnect()
Esempio n. 9
0
def start_vm(vm_name, host_ip):
    try:
        api = API(url="https://engine167.eayun.com", username="******", password="******", ca_file="ca.crt")

        vm = api.vms.get(name=vm_name)
        try:
            vm.start(action=params.Action(vm=params.VM(host=params.Host(address=host_ip))))
            print "Started '%s'." % vm.get_name()
        except Exception as ex:
            print "Unable to start '%s': %s" % (vm.get_name(), ex)

        api.disconnect()

    except Exception as ex:
        print "Unexpected error: %s" % ex
Esempio n. 10
0
def run(**kwargs):
    ovaname = get_ova_name(kwargs.get('image_url'))

    mgmt_sys = cfme_data['management_systems'][kwargs.get('provider')]

    rhevurl = mgmt_sys['hostname']
    rhevm_credentials = mgmt_sys['credentials']
    username = credentials[rhevm_credentials]['username']
    password = credentials[rhevm_credentials]['password']
    ssh_rhevm_creds = mgmt_sys['hosts'][0]['credentials']
    sshname = credentials[ssh_rhevm_creds]['username']
    sshpass = credentials[ssh_rhevm_creds]['password']
    rhevip = mgmt_sys['ipaddress']

    apiurl = 'https://%s:443/api' % rhevurl

    ssh_client = make_ssh_client(rhevip, sshname, sshpass)
    api = API(url=apiurl, username=username, password=password,
              insecure=True, persistent_auth=False)

    template_name = kwargs.get('template_name', None)
    if template_name is None:
        template_name = cfme_data['basic_info']['cfme_template_name']

    if api.templates.get(template_name) is not None:
        print "RHEVM: Found finished template with this name."
        print "RHEVM: The script will now end."
    else:
        print "RHEVM: Downloading .ova file..."
        download_ova(ssh_client, kwargs.get('image_url'))
        print "RHEVM: Templatizing .ova file..."
        template_from_ova(api, username, password, rhevip, kwargs.get('edomain'),
                          ovaname, ssh_client)
        print "RHEVM: Importing new template..."
        import_template(api, kwargs.get('edomain'), kwargs.get('sdomain'), kwargs.get('cluster'))
        print "RHEVM: Making a temporary VM from new template..."
        make_vm_from_template(api, kwargs.get('cluster'))
        print "RHEVM: Adding disk to created VM..."
        add_disk_to_vm(api, kwargs.get('sdomain'), kwargs.get('disk_size'),
                       kwargs.get('disk_format'), kwargs.get('disk_interface'))
        print "RHEVM: Templatizing VM..."
        templatize_vm(api, template_name, kwargs.get('cluster'))
        print "RHEVM: Cleaning up..."
        cleanup(api, kwargs.get('edomain'))

    ssh_client.close()
    api.disconnect()
    print "RHEVM: Done."
Esempio n. 11
0
    def on_pass(self, button):
        self.api = API(url='https://127.0.0.1/api',
            username='******',
            password=self.w_password.edit_text.encode("ascii", "ignore"),
            insecure=True)
        if not self.api.vms.get(name=self.vm_name) == None:
            self.widget.set_popup_text("Vm named '%s' exists, please remove or rename it and try again" % self.vm_name)
            self.widget.open_pop_up()
            return

        divider = urwid.Divider("-")
        self.w_mgmt_profile = VnicProfileSelector(self.api, True, self.vnic_profile_changed_mgmt)
        self.w_int_profile = VnicProfileSelector(self.api, True, self.vnic_profile_changed_int)
        self.w_int_profile.set_ip_info(False)
        self.w_ext_profile = VnicProfileSelector(self.api, False, None)
        self.w_vm_pass = urwid.Edit(u"vm root password: "******"*")
        self.w_keystone_pass = urwid.Edit(u"keystone admin password: "******"*")
        self.widget.original_widget = urwid.Pile([
            urwid.Text(u"Deploying neutron appliance under datacenter 'Default'"),
            divider,
            urwid.Text("Choose profile for management network:"),
            self.w_mgmt_profile,
            divider,
            urwid.Text("Choose profile for internal network:"),
            self.w_int_profile,
            divider,
            urwid.Text("Choose profile for external network:"),
            self.w_ext_profile,
            divider,
            self.w_vm_pass,
            self.w_keystone_pass,
            divider,
            urwid.Button(u"OK", on_press=self.begin_deploy)
        ])
Esempio n. 12
0
 def _init_api(self):
     self.log.debug("Doing blocking acquire() on global RHEVM API connection lock")
     self.api_connections_lock.acquire()
     self.log.debug("Got global RHEVM API connection lock")
     url = self.api_details['url']
     username = self.api_details['username']
     password = self.api_details['password']
     self.api = API(url=url, username=username, password=password)
def process(api_url, username, password, cert_file=None):
    api = API(url=api_url,
              username=username,
              password=password,
              cert_file=cert_file,
              insecure=(not cert_file))
    print('Connected to %s' % api_url)

    problematic_vms = list(iter_problematic_vms(api))

    api.disconnect()

    if problematic_vms:
        print(build_search_criteria(problematic_vms, get_single_vm_criteria_by_name))
        print(build_search_criteria(problematic_vms, get_single_vm_criteria_by_id))
    else:
        print('All MAC addresses are in range')
Esempio n. 14
0
    def __init__(self, module):
        self.module = module

        user = module.params.get('user')
        password = module.params.get('password')
        server = module.params.get('server')
        port = module.params.get('port')
        insecure_api = module.params.get('insecure_api')

        url = "https://%s:%s" % (server, port)

        try:
            api = API(url=url, username=user, password=password, insecure=str(insecure_api))
            api.test()
            self.conn = api
        except:
            raise Exception("Failed to connect to RHEV-M.")
Esempio n. 15
0
def start_vms(vmObj):
logging.info('Thread to start %s', vmObj.name)
try:
vmObj.start()
#time.sleep(5)
except Exception as e:
logging.debug('Exception caught on VM ( %s) start:\n%s' % (vmObj.name, str(e)))
failedVms.append(vmObj.name)
if __name__ == "__main__":
   try:	
        api = API(url=APIURL,
              username=APIUSER,
              password=APIPASS,
              ca_file=CAFILE)
              print 'Connected to oVIRT API %s Successfully' % APIURL
              logging.info ( 'Successfully Connected to %s' % APIURL)
     try:
print ' \n I am logging in %s \n' % LOGFILENAME
vmsList = api.vms.list()
for i in vmsList:
print i.name
if i.status.state != 'up':
logging.warning('%s is not up, trying to start it' % i.name)
threadMe = Thread(target=start_vms, args=[i])
threadMe.start()
threads.append(threadMe)
     except Exception as e:
         logging.debug('Error:\n%s' % str(e))
    
     logging.warning ('No of VMs to start : %s' % len(threads))
     print 'No of VMs to start: %s' % len(threads)
     for th in threads:
logging.info ('Waiting for %s to join' % th)
th.join (30)
if not th.isAlive():
logging.info ('Thread : %s terminated' % (th.getName()))

else:
logging.debug( 'Thread : %s is still alive, you may check this task..' % (th))
logging.debug (' Below Vms failed to start with an exception:%s' % (failedVms));
     api.disconnect()


   except Exception as ex:
    logging.debug('Unexpected error: %s' % ex)
Esempio n. 16
0
def stop_vm(vm_name):
   try:
      api = API(url="https://engine167.eayun.com",
                username="******",
                password="******",
                ca_file="ca.crt")

      vm = api.vms.get(name=vm_name)
      try:
         vm.stop()
         print "Stoped '%s'." % vm.get_name()
      except Exception as ex:
         print "Unable to stop '%s': %s" % (vm.get_name(), ex)

      api.disconnect()

   except Exception as ex:
      print "Unexpected error: %s" % ex
Esempio n. 17
0
    def __init__(self, hostname, username, password, **kwargs):
        # generate URL from hostname

        if 'port' in kwargs:
            url = 'https://%s:%s/api' % (hostname, kwargs['port'])
        else:
            url = 'https://%s/api' % hostname

        self.api = API(url=url, username=username, password=password, insecure=True)
Esempio n. 18
0
    def __init__(self, hostname='localhost', username='******', password='******'):
        """ Initialize RHEVMSystem """
        # sanitize hostname
        if not hostname.startswith('https://'):
            hostname = 'https://%s' % hostname
        if not hostname.endswith('/api'):
            hostname = '%s/api' % hostname

        self.api = API(url=hostname, username=username, password=password, insecure=True)
Esempio n. 19
0
def conn(url, username, password, ca_file):
    """ define connection RHEV-M api"""
    try:
        api = API(url=url,
                  username=username,
                  password=password,
                  ca_file=ca_file)
        return api
    except Exception as ex:
        print "Unexpected error: %s" % ex
Esempio n. 20
0
def connect():
    url = 'http://localhost:8080/ovirt-engine/api'
    username = '******'
    password = '******'

    print 'Connecting to', url, 'as', username
    api = API(url=url, username=username, password=password)

    print 'Connected'
    return api
 def connect(self, args):
     try:
         self._api = API(args.url,
                         args.username,
                         args.password,
                         insecure=True)
     except Exception, e:
         print "Failed to connect to: %s" % args.url
         print e
         sys.exit(1)
Esempio n. 22
0
def rhevm_create_api(url, username, password):
    """Creates rhevm api endpoint.

    Args:
        url: URL to rhevm provider
        username: username used to log in into rhevm
        password: password used to log in into rhevm
    """
    apiurl = 'https://%s:443/api' % url
    return API(url=apiurl, username=username, password=password, insecure=True,
               persistent_auth=False)
Esempio n. 23
0
 def connect(self):
     """Connect to oVirt/RHEV API"""
     try:
         self.api = API(url=self.url,
                        username=self.user,
                        password=self.password,
                        insecure='True')
         return self.api
     except RequestError as err:
         print("Error: {} Reason: {}".format(err.status, err.reason))
         exit(1)
Esempio n. 24
0
 def login(self, username, password):
     global api
     try:
         api = API(url=self.baseUrl,
                   username=username,
                   password=password,
                   filter=True)
     except RequestError as reqErr:
         return False, "Login error"
     except ConnectionError as conErr:
         return False, "Bad URL"
     return True, ''
Esempio n. 25
0
    def __entrypoint(self):
        try:
            url = 'https://rhevserver.com'
            api = API(url=url,
                      username=self._username,
                      password=self._password,
                      ca_file='ca.crt')

            return api

        except Exception as ex:
            print('Error: %s' % ex)
Esempio n. 26
0
    def _get_connection(self):
        #open a connection to the rest api
        connection = None
        try:
            connection = API(url='http://localhost:8080',
                             username='******',
                             password='******')
        except BaseException as ex:
            #letting the external proxy know there was an error
            print >> sys.stderr, ex
            return None

        return connection
    def _get_connection(self):
        #open a connection to the rest api
        connection = None
        try:
            connection = API(url='http://host:port',
                             username='******',
                             password='')
        except BaseException as ex:
            #letting the external proxy know there was an error
            print >> sys.stderr, ex
            return None

        return connection
Esempio n. 28
0
def initAPI():
    global controller
    logging.debug("Initiating the API object")

    URL = API_OBJECT_PATH % (controller.CONF["HOST_FQDN"],
                             controller.CONF["HTTPS_PORT"])
    USERNAME = '******'
    try:
        controller.CONF["API_OBJECT"] = API(
            url=URL, username=USERNAME, password=controller.CONF['AUTH_PASS'])
    except:
        logging.error(traceback.format_exc())
        raise Exception(ERROR_CREATE_API_OBJECT)
def connect():
    api_url = "https://manager/ovirt-engine/api"
    api_user = "******"
    api_password = "******"
    api_ca = "/path/to/my.cer"

    try:
        api = API(url=api_url,
                  username=api_user,
                  password=api_password,
                  ca_file=api_ca)
        return api
    except Exception as e:
        sys.exit("api connection failed: %s" % e)
Esempio n. 30
0
    def __init__(self,
                 url,
                 cluster_name,
                 ca_file,
                 username=None,
                 password=None,
                 kerberos=None,
                 verbose=0,
                 **kwargs):
        super(RHEVM, self).__init__()

        self.url = url
        self.username = username
        self.password = password
        self.cluster = cluster_name
        self.ca_file = ca_file
        self.kerberos = kerberos
        self.verbose = verbose
        self.debug = verbose > 1

        if self.kerberos:
            if self.verbose:
                show("Using Kerberos authentication")
            self.api = API(url=self.url,
                           kerberos=True,
                           ca_file=self.ca_file,
                           filter=True,
                           debug=self.debug)
        else:
            if self.verbose:
                show("Using username and password: %s" % self.username)
            self.api = API(url=self.url,
                           username=self.username,
                           password=self.password,
                           ca_file=self.ca_file,
                           debug=self.debug)
Esempio n. 31
0
def start_vm(vm_name, host_ip):
   try:
      api = API(url="https://engine167.eayun.com",
                username="******",
                password="******",
                ca_file="ca.crt")

      vm = api.vms.get(name=vm_name)
      try:
         vm.start(
               action = params.Action(
                  vm = params.VM(
                     host = params.Host(address = host_ip)
                     )
                  )
               )
         print "Started '%s'." % vm.get_name()
      except Exception as ex:
         print "Unable to start '%s': %s" % (vm.get_name(), ex)

      api.disconnect()

   except Exception as ex:
      print "Unexpected error: %s" % ex
Esempio n. 32
0
def get_engine_api():
    api = None
    eac_data = ta_info_xml.get_engine_api_conf()
    if eac_data == {}:
        return
    try:
        #         print eac_data['url'], eac_data['username'], eac_data['password'], eac_data['ca_file']
        api = API(url=eac_data['url'],
                  username=eac_data['username'],
                  password=eac_data['password'],
                  ca_file=eac_data['ca_file'])
    except Exception as e:
        pass

    return api
Esempio n. 33
0
 def login(self, url, username, password, ca_file):
     global api
     try:
         api = API(url=url,
                   username=username,
                   password=password,
                   ca_file=ca_file)
     except RequestError as reqErr:
         return False, "Login error"
     except ConnectionError as conErr:
         return False, "Bad URL"
     except NoCertificatesError as certErr:
         return False, "SSL error. Use 'http(s)://'"
     except Exception as e:
         return False, str(e)
     return True, ''
Esempio n. 34
0
def ovirt_create_storage(module):

    name = module.params['name']
    datacenter = module.params['datacenter']
    host = module.params['host']
    path = module.params['path']
    type = module.params['type']
    storage_type = module.params['storage_type']
    storage_url = module.params['storage_url']
    username = module.params['username']
    password = module.params['password']
    url = module.params['url']

    try:
        api = API(url=url,
                  username=username,
                  password=password,
                  insecure=True,
                  session_timeout=60)
    except Exception as ex:
        module.fail_json(msg='could not connect to ovirt api')

    isoParams = params.StorageDomain(
        name=name,
        data_center=api.datacenters.get(datacenter),
        type_=storage_type,
        host=api.hosts.get(host),
        storage=params.Storage(
            type_=type,
            address=storage_url,
            path=path,
        ))

    if api.datacenters.get(datacenter).storagedomains.get(name):
        module.exit_json(changed=False)

    if module.check_mode:
        module.exit_json(changed=True)

    try:
        sd = api.storagedomains.add(isoParams)
        api.datacenters.get(datacenter).storagedomains.add(
            api.storagedomains.get(name))
    except Exception as ex:
        module.fail_json(msg='Adding storage domain failed' + str(ex))

    module.exit_json(changed=True)
Esempio n. 35
0
def waitfor_api(module):
    
    username = module.params['username']
    password = module.params['password']
    url = module.params['url']
    max_tries = module.params['max_tries']
    time_out = module.params['time_out']
    
    while max_tries>0:
        try:
            api = API(url=url,username=username,password=password,insecure=True,timeout=0)
            module.exit_json(changed=False)
        except Exception as ex:
            sleep(time_out)
            max_tries -= 1
    
    module.fail_json(msg='ovirt api timed out')
def main(argv=None):

    # setup connection
    engine_api = API(url=engine_url,
                     username="******",
                     password=password, insecure=True)

    print "Starting smoke testing"
    rhevh = approve(engine_api, node_name)
    print "Host approved"

    create_nfs_storage(engine_api, rhevh, 'data')
    print "Data storage created"

    create_nfs_storage(engine_api, rhevh, 'export')
    print "Export storage created"

    subprocess.check_call(
        ["rhevm-image-uploader",
         "--insecure",
         "-u",
         "admin@internal",
         "-p",
         password,
         "-e",
         "export",
         "upload",
         testvm])

    print "Uploaded VMs"

    test_vm = import_vm(engine_api, testvm)
    print "Vm imported"

    start = datetime.datetime.now()
    test_vm.start()
    while test_vm.status.state != 'up':
        if (datetime.datetime.now() - start).seconds > 600:
            print "\033[1m Error: \033[0m start fail"
            raise RuntimeError("Cant start imported VM")
        time.sleep(5)
        test_vm = test_vm.update()

    print "All success"
    return 0
Esempio n. 37
0
 def connect_engine( self ): 
     '''Connect ovirt-engine, default connect local ovirt-engine
     api = API(url="https://128.224.165.209:443/api", \
             username="******", \
             password="******", \
             ca_file="/etc/pki/ovirt-engine/ca.pem")
     '''
     try:
         self.api = API(url=self.ovirt_dict['URL'],
                    username=self.ovirt_dict['USERINFOS'][0][0],
                    password=self.ovirt_dict['USERINFOS'][0][1],
                    ca_file=self.ovirt_dict['CA_FILE'])
         print 'Connect ovirt-engine successfully'
         self.ovirt_dict['CONNECTION'] = True
     except Exception as e:
         print 'Connect ovirt-engine failed:\n%s' % (str(e))
         self.ovirt_dict['CONNECTION'] = False
         return False
Esempio n. 38
0
def apilogin(url,
             username,
             password,
             insecure=True,
             persistent_auth=True,
             session_timeout=36000):
    api = None

    try:
        api = API(url=url,
                  username=username,
                  password=password,
                  insecure=insecure,
                  persistent_auth=persistent_auth,
                  session_timeout=session_timeout)
    except:
        print "Error while logging in with supplied credentials, please check and try again"
        sys.exit(1)

    return api
Esempio n. 39
0
def discover(URL, USERNAME, PASSWORD):
    from ovirtsdk.api import API
    from ovirtsdk.xml import params

    api = API(url=URL, username=USERNAME, password=PASSWORD, insecure=True)
    vm_list = api.vms.list()
    number_of_vms = len(vm_list)
    counter = 1
    result = '{\n\t"data":[\n'
    for vm in vm_list:
        if counter < number_of_vms:
            result += '\t\t{ "{#VMNAME}":"%s%s%s" },\n' % (vm_prefix, vm.name,
                                                           vm_suffix)
        else:
            result += '\t\t{ "{#VMNAME}":"%s%s%s" }\n' % (vm_prefix, vm.name,
                                                          vm_suffix)
        counter += 1
    result += '\t]\n}'
    create_dict(api, vm_list)
    return result
Esempio n. 40
0
def apilogin(url, username, password, insecure=True, persistent_auth=True, session_timeout=36000):
    """
    @param url: URL for RHEV-M  / Ovirt
    @param username: username to use
    @param password: password for username
    @param insecure: if True, do not validate SSL cert
    @param persistent_auth: Use persistent authentication
    @param session_timeout: Session timeout for non-persistent authentication
    @return:
    """
    api = None

    try:
        api = API(url=url, username=username, password=password, insecure=insecure, persistent_auth=persistent_auth,
                  session_timeout=session_timeout)
    except:
        print("Error while logging in with supplied credentials, please check and try again")
        sys.exit(1)

    return api
Esempio n. 41
0
    def api(self, dc):
        """
        Create an oVirt API instance for a requested datacenter

        :param dc: datacenter
        :type dc: str
        :rtype: ovirtsdk.api.API
        """
        kwargs = {
            'password': self.config.get(dc, OVIRT_PASSWORD),
            'url': self.config.get(dc, OVIRT_URL),
            'username': self.config.get(dc, OVIRT_USERNAME),
        }

        if self.config.has_option(dc, OVIRT_CA):
            kwargs['ca_file'] = self.config.get(dc, OVIRT_CA)

        if self.config.has_option(dc, OVIRT_API_INSECURE):
            kwargs['insecure'] = bool(self.config.get(dc, OVIRT_API_INSECURE))

        return API(**kwargs)
Esempio n. 42
0
def connect(ovirt_api_url, ovirt_username, ovirt_password, cinder_username,
            cinder_password, cinder_project, cinder_auth_url, ceph_conf_file,
            ceph_client, ceph_pool):
    VERSION = params.Version(major='4', minor='0')
    ovirt_api = API(url=ovirt_api_url,
                    username=ovirt_username,
                    password=ovirt_password,
                    insecure=True)

    cinder_api = client.Client(cinder_username,
                               cinder_password,
                               cinder_project,
                               cinder_auth_url,
                               service_type="volume")

    ceph_api = rados.Rados(conffile=ceph_conf_file,
                           name="client.{}".format(ceph_client))
    ceph_api.connect()
    ceph_api_ioctx = ceph_api.open_ioctx(ceph_pool)

    return ovirt_api, cinder_api, ceph_api, ceph_api_ioctx
Esempio n. 43
0
    def ovirt_get_vms(self, url, user, passw, ssl_insecure):
        '''
        using sdk to attack ovirt api and getting all the vms to be classfied
        '''
        api = API(url=url, username=user, password=passw, insecure=ssl_insecure)
        logging.info('nodes found:')
        for vm in api.vms.list():
            vnode = {}
            name = vm.get_name()
            group = self.classify_vm(name)
            vnode[group] = {}
            guestinfo = vm.get_guest_info()
            if guestinfo is not None and guestinfo.get_ips() is not None:
                for element in guestinfo.get_ips().get_ip():
                    ip = element.get_address()
            else:
                ip = ['']

            logging.info(vnode)
            vnode[group]['nodes'] = '{}-{}'.format(name, ip[0])

            self.vnodes.append(vnode)
Esempio n. 44
0
from ovirtsdk.api import API
from ovirtsdk.xml import params

VERSION = params.Version(major='3', minor='5')

URL = 'https://rhevm.example.com/ovirt-engine/api'
CA = '/etc/pki/ovirt-engine/ca.pem'
USERNAME = '******'
PASSWORD = '******'

HOST_NAME = 'rhevh1'
PM_ADDRESS = '192.168.101.11'

try:
        api = API(url=URL, username=USERNAME, password=PASSWORD, ca_file=CA)
        print "Connected to %s successfully!" % api.get_product_info().name

except Exception as err:
        print "Connection failed: %s" % err

try:
    host = api.hosts.get(HOST_NAME)
    pm = host.get_power_management()
    pm.set_type('ilo')
    pm.set_enabled(True)
    pm.set_address(PM_ADDRESS)
    pm.set_username('root')
    pm.set_password('Secret')
    host.update()
Esempio n. 45
0
disks['datadg_002'] = disk
disk = {}
disk['size'] = '6'
disks['recodg_001'] = disk
disks['recodg_002'] = disk
disk = {}
disk['size'] = '4'
disks['systemdg_001'] = disk
disks['systemdg_002'] = disk
disks['systemdg_003'] = disk
disks['systemdg_004'] = disk
disk = None

apiurl = "https://" + ovirt_host + "/api"
api = API(url=apiurl,
          username='******',
          password='******',
          insecure=True)

for disk in disks:
    print "Creating disk '%s' with size '%sGB'" % (disk, disks[disk]['size'])
    api.vms.get(guest_name).disks.add(
        params.Disk(storage_domains=params.StorageDomains(
            storage_domain=[api.storagedomains.get(datastore)]),
                    size=int(disks[disk]['size']) * 1024 * 1024 * 1024,
                    status=None,
                    interface='virtio',
                    format='raw',
                    sparse=False,
                    bootable=False,
                    shareable=True,
                    alias=guest_name + '_' + disk))
def ovirtConnect(url, username, password):
    """Connect to hostname oVirt server using user/password"""
    api = API(url=url, username=username, password=password, insecure=True)
    return api
Esempio n. 47
0
class RHEVMSystem(MgmtSystemAPIBase):
    """
    Client to RHEVM API

    This class piggy backs off ovirtsdk.

    Benefits of ovirtsdk:
    - Don't need intimite knowledge w/ RHEVM api itself.
    Detriments of ovirtsdk:
    - Response to most quaries are returned as an object rather than a string.
      This makes it harder to do simple stuff like getting the status of a vm.
    - Because of this, it makes listing VMs based on **kwargs impossible
      since ovirtsdk relies on re class to find matches.

    I.E. List out VM with this name (positive case)
      Ideal: self.api.vms.list(name='test_vm')
      Underneath the hood:
        - ovirtsdk fetches list of all vms [ovirtsdk.infrastructure.brokers.VM
          object, ...]
        - ovirtsdk then tries to filter the result using re.
          - tries to look for 'name' attr in ovirtsdk.infrastructure.brokers.VM
            object
          - found name attribute, in this case, the type of the value of the
            attribute is string.
          - match() succeed in comparing the value to 'test_vm'

    I.E. List out VM with that's powered on (negative case)
      Ideal: self.api.vms.list(status='up')
      Underneath the hood:
        - '^same step as above except^'
            - found status attribute, in this case, the type of the value of
              the attribute is ovirtsdk.xml.params.Status
            - match() failed because class is compared to string 'up'

     This problem should be attributed to how RHEVM api was designed rather
     than how ovirtsdk handles RHEVM api responses.

    - Obj. are not updated after action calls.
      - I.E.
        vm = api.vms.get(name='test_vm')
        vm.status.get_state() # returns 'down'
        vm.start()
        # wait a few mins
        vm.status.get_state() # returns 'down'; wtf?

        vm = api.vms.get(name='test_vm')
        vm.status.get_state() # returns 'up'
    """

    def __init__(self, hostname='localhost', username='******', password='******'):
        """ Initialize RHEVMSystem """
        # sanitize hostname
        if not hostname.startswith('https://'):
            hostname = 'https://%s' % hostname
        if not hostname.endswith('/api'):
            hostname = '%s/api' % hostname

        self.api = API(url=hostname, username=username, password=password, insecure=True)

    def _get_vm(self, vm_name=None):
        """ RHEVMSystem implementation in _get_vm. """
        if vm_name is None:
            raise Exception('Could not find a VM named %s.' % vm_name)
        else:
            vm = self.api.vms.get(name=vm_name)
            if vm is None:
                raise Exception('Could not find a VM named %s.' % vm_name)
            return vm

    def start_vm(self, vm_name=None):
        """ RHEVMSystem implementation of start_vm. """
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'up':
            raise Exception('Could not start %s because it\'s already running.' % vm_name)
        else:
            ack = vm.start()
            if ack.get_status().get_state() == 'complete':
                return True
        return False

    def stop_vm(self, vm_name):
        """ RHEVMSystem implementation of stop_vm. """
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'down':
            raise Exception('Could not stop %s because it\'s not running.' % vm_name)
        else:
            ack = vm.stop()
            if ack.get_status().get_state() == 'complete':
                return True
        return False

    def delete_vm(self, vm_name):
        """ RHEVMSystem implementation of delete_vm. """
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'up':
            raise Exception('Could not delete %s because it\'s still running.' % vm_name)
        else:
            ack = vm.delete()
            if ack.get_status().get_state() == '':
                return True
        return False

    def create_vm(self, vm_name):
        """ RHEVMSystem implementation of create_vm. """
        #Unfortunately, there are not enough smurf slaves in the village to build this functionality yet.
        pass

    def restart_vm(self, vm_name):
        """ RHEVMSystem implementation of restart_vm. """
        if not self.stop_vm(vm_name):
            return False
        else:
            return self.start_vm(vm_name)

    def list_vm(self, **kwargs):
        """ RHEVMSystem implementation of list_vm. """
        # list vm based on kwargs can be buggy
        # i.e. you can't return a list of powered on vm
        # but you can return a vm w/ a matched name
        vm_list = self.api.vms.list(**kwargs)
        return [vm.name for vm in vm_list]

    def info(self):
        """ RHEVMSystem implementation of info. """
        # and we got nothing!
        pass

    def disconnect(self):
        """ RHEVMSystem implementation of disconnect. """
        self.api.disconnect()

    def vm_status(self, vm_name=None):
        """ RHEVMSystem implementation of vm_status. """
        state = self._get_vm(vm_name).get_status().get_state()
        print "vm " + vm_name + " status is " + state
        return state

    def is_vm_running(self, vm_name):
        """ RHEVMSystem implementation of is_vm_running. """
        state = self.vm_status(vm_name)
        return "up" == state

    def is_vm_stopped(self, vm_name):
        """ RHEVMSystem implementation of is_vm_stopped. """
        state = self.vm_status(vm_name)
        return "down" == state

    def is_vm_suspended(self, vm_name):
        """ RHEVMSystem implementation of is_vm_suspended. """
        state = self.vm_status(vm_name)
        return "suspended" == state

    def suspend_vm(self, vm_name):
        """ RHEVMSystem implementation of suspend_vm. """
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'down':
            raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
        else:
            ack = vm.suspend()
            return ack.get_status().get_state() == 'complete'
Esempio n. 48
0
    try:
        #force off
        #vmObj.stop()
        #graceful shutdown - http://website-humblec.rhcloud.com/ovirt-shutdownstop-start-virtual-machines-vms-ovirt-dc-automatically-using-python-sdk/#comment-253
        vmObj.shutdown()
        #time.sleep(5)
    except Exception as e:
        logging.debug('Exception caught on VM ( %s) stop:\n%s' %
                      (vmObj.name, str(e)))
        failedVms.append(vmObj.name)


if __name__ == "__main__":
    try:
        api = API(url=APIURL,
                  username=APIUSER,
                  password=APIPASS,
                  ca_file=CAFILE)
        print 'Connected to RHEVM API  %s Successfully' % APIURL
        logging.info('Successfully Connected to %s' % APIURL)
        try:
            print ' \n I am logging in %s \n' % LOGFILENAME
            vmsList = api.vms.list()
            for i in vmsList:
                print i.name
                if i.status.state != 'down':
                    logging.warning('%s is not down, trying to stop it' %
                                    i.name)
                    threadMe = Thread(target=start_vms, args=[i])
                    threadMe.start()
                    threads.append(threadMe)
        except Exception as e:
Esempio n. 49
0
class TabNeutron(Tab):

    def __init__(self, main_loop):
        self.main_loop = main_loop
        self.name = u"Neutron Deploy"
        self.vm_name = "NeutronAppliance"
        self.widget = SimplePopupLauncher(self.get_pass())

    def get_pass(self):
        self.w_password = urwid.Edit(u"Please enter admin@internal password to procceed: ", mask="*")
        return urwid.Columns([
            ('weight', 4, self.w_password),
            ('weight', 1, urwid.Button(u"GO", on_press=self.on_pass))
        ])

    def on_pass(self, button):
        self.api = API(url='https://127.0.0.1/api',
            username='******',
            password=self.w_password.edit_text.encode("ascii", "ignore"),
            insecure=True)
        if not self.api.vms.get(name=self.vm_name) == None:
            self.widget.set_popup_text("Vm named '%s' exists, please remove or rename it and try again" % self.vm_name)
            self.widget.open_pop_up()
            return

        divider = urwid.Divider("-")
        self.w_mgmt_profile = VnicProfileSelector(self.api, True, self.vnic_profile_changed_mgmt)
        self.w_int_profile = VnicProfileSelector(self.api, True, self.vnic_profile_changed_int)
        self.w_int_profile.set_ip_info(False)
        self.w_ext_profile = VnicProfileSelector(self.api, False, None)
        self.w_vm_pass = urwid.Edit(u"vm root password: "******"*")
        self.w_keystone_pass = urwid.Edit(u"keystone admin password: "******"*")
        self.widget.original_widget = urwid.Pile([
            urwid.Text(u"Deploying neutron appliance under datacenter 'Default'"),
            divider,
            urwid.Text("Choose profile for management network:"),
            self.w_mgmt_profile,
            divider,
            urwid.Text("Choose profile for internal network:"),
            self.w_int_profile,
            divider,
            urwid.Text("Choose profile for external network:"),
            self.w_ext_profile,
            divider,
            self.w_vm_pass,
            self.w_keystone_pass,
            divider,
            urwid.Button(u"OK", on_press=self.begin_deploy)
        ])

    def vnic_profile_changed_mgmt(self, button, selected):
        if selected:
            if self.w_mgmt_profile.get_vnic_profile_id_by_name(button.get_label()) == self.w_int_profile.get_vnic_profile_id():
                self.w_int_profile.set_ip_info(False)
            else:
                self.w_int_profile.set_ip_info(True)

    def vnic_profile_changed_int(self, button, selected):
        if selected:
            if self.w_mgmt_profile.get_vnic_profile_id() == self.w_int_profile.get_vnic_profile_id_by_name(button.get_label()):
                self.w_int_profile.set_ip_info(False)
            else:
                self.w_int_profile.set_ip_info(True)

    def begin_deploy(self, button):
        conf_widget = self.widget.original_widget
        self.output = urwid.Text("")
        widget = urwid.BoxAdapter(urwid.Frame(
            header=urwid.Text("Setup output:"),
            body=urwid.Filler(self.output, valign="bottom"),
            footer=urwid.Button("percentage"),
            focus_part="header"), 20)
        widget.set_focus("footer")
        self.widget.original_widget = widget

        self.log(u"Detecting ip conflicts...")
        conflict = True
        conflict_ip = self.w_mgmt_profile.w_ip.edit_text
        if os.system("arping %s -w 10" % conflict_ip):
            conflict = False
        elif not self.mgmt_int_same():
            conflict_ip = self.w_int_profile.w_ip.edit_text
            if os.system("arping %s -w 10" % conflict_ip):
                conflict = False
        if conflict:
            self.widget.set_popup_text("IP address %s is already used, please configure a unused IP address." % conflict_ip)
            self.widget.open_pop_up()
            self.widget.original_widget = conf_widget
            return

        self.log(u"Begin neutron appliance deploy")
        self.add_vm()
        self.add_external_provider()
        self.configure_uiplugin()
        self.configure_httpd()
        self.log(u"Neutron appliance deploy finished, please REFRESH your webadmin page")
        self.api.disconnect()

    def log(self, text):
        self.output.set_text(self.output.text + text + "\n")
        self.main_loop.draw_screen()

    def mgmt_int_same(self):
        return self.w_mgmt_profile.get_vnic_profile_id() == self.w_int_profile.get_vnic_profile_id()

    def add_vm(self):
        mgmt_int_same = self.mgmt_int_same()
        template_name = "Neutron_Appliance_Template"
        nics = []
        nics.append(params.NIC(
            name="eth0",
            boot_protocol="STATIC",
            on_boot=True,
            network=params.Network(
                ip=params.IP(
                    address=self.w_mgmt_profile.w_ip.edit_text,
                    netmask=self.w_mgmt_profile.w_netmask.edit_text,
                    gateway=self.w_mgmt_profile.w_gateway.edit_text,
                )
            )
        ))
        if not mgmt_int_same:
            nics.append(params.NIC(
                name="eth2",
                boot_protocol="STATIC",
                on_boot=True,
                network=params.Network(
                    ip=params.IP(
                        address=self.w_int_profile.w_ip.edit_text,
                        netmask=self.w_int_profile.w_netmask.edit_text,
                        gateway=self.w_int_profile.w_gateway.edit_text,
                    )
                )
            ))
        nics.append(params.NIC(
            name="eth1",
            boot_protocol="NONE",
            on_boot=True,
        ))
        vm=params.VM(
            name=self.vm_name,
            cluster=self.api.clusters.get(name="Default"),
            template=self.api.templates.get(name=template_name),
        )
        self.log(u"Adding neutron vm")
        self.api.vms.add(vm)
        self.log(u"Neutron vm added successflly")
        self.api.vms.get(self.vm_name).nics.add(params.NIC(
            name='eth0',
            vnic_profile=params.VnicProfile(id=self.w_mgmt_profile.get_vnic_profile_id()),
            interface='virtio'
        ))
        self.log("NIC 'eth0' added to neutron vm as management network")
        self.api.vms.get(self.vm_name).nics.add(params.NIC(
            name='eth1',
            vnic_profile=params.VnicProfile(id=self.w_ext_profile.get_vnic_profile_id()),
            interface='virtio'
        ))
        self.log("NIC 'eth1' added to neutron vm as external network")
        if not mgmt_int_same:
            self.api.vms.get(self.vm_name).nics.add(params.NIC(
                name='eth2',
                vnic_profile=params.VnicProfile(id=self.w_int_profile.get_vnic_profile_id()),
                interface='virtio'
            ))
            self.log("NIC 'eth2' added to neutron vm as internal network")

        cloud_init_content = """runcmd:
 - sed -i 's/ServerAlias 127.0.0.1/ServerAlias %s/' /etc/httpd/conf.d/15-horizon_vhost.conf
 - sed -i 's/local_ip =127.0.0.1/local_ip = %s/' /etc/neutron/plugins/openvswitch/ovs_neutron_plugin.ini
 - sed -i 's/#CSRF_COOKIE_SECURE/CSRF_COOKIE_SECURE/' /etc/openstack-dashboard/local_settings
 - sed -i 's/#SESSION_COOKIE_SECURE/SESSION_COOKIE_SECURE/' /etc/openstack-dashboard/local_settings
 - service httpd restart
 - mysql neutron --execute="delete from ml2_gre_endpoints where ip_address='127.0.0.1'"
 - service neutron-openvswitch-agent restart
 - chkconfig cloud-init off
 - source /root/keystonerc_admin
 - keystone user-password-update --pass %s admin
 - sed -i '/^export OS_PASSWORD/c\export OS_PASSWORD=%s' /root/keystonerc_admin""" % (
                self.w_mgmt_profile.w_ip.edit_text,
                self.w_mgmt_profile.w_ip.edit_text if mgmt_int_same else self.w_int_profile.w_ip.edit_text,
                self.w_keystone_pass.edit_text,
                self.w_keystone_pass.edit_text,
            )

        initialization=params.Initialization(
            cloud_init=params.CloudInit(
                host=params.Host(address="localhost"),
                regenerate_ssh_keys=True,
                users=params.Users(
                    user=[params.User(user_name="root", password=self.w_vm_pass.edit_text)]
                    ),
                network_configuration=params.NetworkConfiguration(
                    nics=params.Nics(nic=nics)
                ),
                files=params.Files(
                    file=[params.File(name="/tmp/setup", type_="PLAINTEXT", content=cloud_init_content,)]
                )
            )
        )
        self.log("Wait for vm to be created...")
        created = False
        while not created:
            time.sleep(10)
            if "down" == self.api.vms.get(name=self.vm_name).status.state:
                created = True
        self.log("Starting vm...")
        vm = self.api.vms.get(name=self.vm_name)
        vm.start(
            action=params.Action(
                use_cloud_init=True,
                vm=params.VM(
                    initialization=initialization
                )
            )
        )

    def add_external_provider(self):
        external_provider_name = "neutron-appliance"
        if not self.api.openstacknetworkproviders.get(name=external_provider_name) == None:
            self.log("Removing existing external provider: %s ..." % external_provider_name)
            self.api.openstacknetworkproviders.get(name=external_provider_name).delete()
        self.log(u"Adding external provider...")
        agent_configuration = params.AgentConfiguration(
            network_mappings='vmnet:br-tun',
            broker_type='rabbit_mq',
            address=self.w_mgmt_profile.w_ip.edit_text,
            port=5672,
            username='******',
            password='******',
        )
        self.api.openstacknetworkproviders.add(params.OpenStackNetworkProvider(
            name=external_provider_name,
            description='auto created by eayunos',
            url='http://%s:9696' % self.w_mgmt_profile.w_ip.edit_text,
            requires_authentication=True,
            username='******',
            password=self.w_password.edit_text.encode("ascii", "ignore"),
            authentication_url='http://%s:5000/v2.0/' % self.w_mgmt_profile.w_ip.edit_text,
            tenant_name='admin',
            plugin_type='OPEN_VSWITCH',
            agent_configuration=agent_configuration,
        ))
        self.log(u"External provider added successfully")

    def configure_uiplugin(self):
        os.system("ln -nsf /usr/share/neutron-uiplugin/neutron-resources /usr/share/ovirt-engine/ui-plugins/neutron-resources")
        os.system("ln -nsf /usr/share/neutron-uiplugin/neutron.json /usr/share/ovirt-engine/ui-plugins/neutron.json")
        self.log("Neutron uiplugin configured")

    def configure_httpd(self):
        content = """ProxyPass "/dashboard" "http://{IP}/dashboard"
ProxyPassReverse "/dashboard" "http://{IP}/dashboard"
ProxyPass "/static" "http://{IP}/static"
ProxyPassReverse "/static" "http://{IP}/static"
""".replace("{IP}", self.w_mgmt_profile.w_ip.edit_text)
        with open("/etc/httpd/conf.d/z-neutron.conf", "w") as f:
            f.write(content)
        self.log("Restarting httpd service")
        os.system("service httpd restart")
        self.log("Httpd reverse proxy configured")
Esempio n. 50
0
#!/usr/bin/python
from ovirtsdk.api import API
from ovirtsdk.xml import params
import time
import sys

USERNAME = '******'
PASSWORD = '******'
URL = 'https://localhost/api'

api = API(URL, username=USERNAME, password=PASSWORD, insecure=True)

student_vms = api.vms.list(query="*")
avail = api.storagedomains.get(
    name="Sys_11").get_available() / 1024 / 1024 / 1024

for j in student_vms:
    if j.name == "Win7-teacher1":
        pass
    else:
        try:
            print j.name
            console_user = j.sessions.list()[0]
            if (console_user.get_console_user() != True) and (avail <= 20):
                j.stop()
        except:
            pass
Esempio n. 51
0
class RHEVMHelper(object):

    api_connections_lock = BoundedSemaphore()

    def __init__(self, url, username, password):
        self.log = logging.getLogger('%s.%s' % (__name__, self.__class__.__name__))
        # The SDK allows only a single active connection object to be created, regardless of whether 
        # or not multiple RHEVM servers are being accessed.  For now we need to have a global lock,
        # create a connection object before each batch of API interactions and then disconnect it.
        self.api_details = { 'url':url, 'username':username, 'password':password }

    # TODO: When this limitation in the ovirt SDK is removed, get rid of these
    def _init_api(self):
        self.log.debug("Doing blocking acquire() on global RHEVM API connection lock")
        self.api_connections_lock.acquire()
        self.log.debug("Got global RHEVM API connection lock")
        url = self.api_details['url']
        username = self.api_details['username']
        password = self.api_details['password']
        self.api = API(url=url, username=username, password=password, insecure=True)

    def _disconnect_api(self):
        try:
            self.log.debug("Attempting API disconnect")
            if hasattr(self, 'api') and self.api is not None:
                self.api.disconnect()
            else:
                self.log.debug("API connection was not initialized.  Will not attempt to disconnect.")
        finally:
            # Must always do this
            self.log.debug("Releasing global RHEVM API connection lock")
            self.api_connections_lock.release()

    # These are the only two genuinley public methods
    # What we create is a VM template

    def import_template(self, image_filename, nfs_host, nfs_path, nfs_dir, cluster,
                        ovf_name = None, ovf_desc = None):
        if not ovf_desc:
            self.ovf_desc = "Imported by Image Factory"
        else:
            self.ovf_desc = ovf_desc
        self.log.debug("Preparing for RHEVM template import of image file (%s)" % (image_filename))

        # API lock protected action
        try: 
            self._init_api()
            self.init_vm_import(image_filename, nfs_host, nfs_path, nfs_dir, cluster)
        finally:
            self._disconnect_api()

        self.ovf_name = ovf_name
        self.log.debug("Staging files")
        self.stage_files()
        self.log.debug("Moving files to final export domain location")
        self.move_files()
        self.ovf_pkg.delete()
        self.log.debug("Executing import")

        # API lock protected action
        try:
            self._init_api()
            self.execute_import()
        finally:
            self._disconnect_api()

        return str(self.ovf_pkg.tpl_uuid)

    def delete_template(self, template_uuid):
        template = self.api.templates.get(id=template_uuid)
        if template:
            template.delete()
            return True
        else:
            return False

    # Begin Nuts and Bolts

    # We don't want to run seteuid() in our main process as it will globally change the UID/GID for everything
    # OTOH, we need to be root to access our image files and temp files
    # We use stdin and Popen's preexec_fn via the helper functions below to deal with this
    def become_nfs_user(self):
        os.setegid(NFSGID)
        os.seteuid(NFSUID)

    def copy_as_nfs_user(self, sourcefile, destfile):
        self.log.debug("Copying (%s) to (%s) as nfsuser" % (sourcefile, destfile))
        f = open(sourcefile,"r")
        (stdout, stderr, retcode) = subprocess_check_output([ 'dd', 'of=%s' % (destfile), 'bs=4k' ], stdin=f, preexec_fn=self.become_nfs_user)
        f.close()

    def copy_dir_as_nfs_user(self, sourcefile, destfile):
        self.log.debug("Copying directory (%s) to (%s) as nfsuser" % (sourcefile, destfile))
        (stdout, stderr, retcode) = subprocess_check_output([ 'cp', '-r', '%s' % (sourcefile), '%s' % (destfile)], preexec_fn=self.become_nfs_user)

    def move_as_nfs_user(self, sourcefile, destfile):
        self.log.debug("Moving (%s) to (%s) as nfsuser" % (sourcefile, destfile))
        (stdout, stderr, retcode) = subprocess_check_output([ 'mv', '%s' % (sourcefile), '%s' % (destfile)], preexec_fn=self.become_nfs_user)

    def mkdir_as_nfs_user(self, directory):
        self.log.debug("Making directory (%s) as nfsuser" % (directory))
        (stdout, stderr, retcode) = subprocess_check_output([ 'mkdir', '%s' % (directory)], preexec_fn=self.become_nfs_user)

    def rm_rf_as_nfs_user(self, directory):
        self.log.debug("Recursive remove of dir (%s) as nfsuser" % (directory))
        (stdout, stderr, retcode) = subprocess_check_output([ 'rm', '-rf', '%s' % (directory)], preexec_fn=self.become_nfs_user)

    def get_storage_domain(self, nfs_host, nfs_path):
        # Find the storage domain that matches the nfs details given
        sds = self.api.storagedomains.list()
        for sd in sds:
            if sd.get_type() == "export":
                self.log.debug("Export domain: (%s)" % (sd.get_name()))
                stor = sd.get_storage()
                if (stor.get_address() == nfs_host) and (stor.get_path() == nfs_path):
                    self.log.debug("This is the right domain (%s)" % (sd.get_id()))
                    return sd
        return None

    def get_pool_id(self, sd_uuid):
        # Get datacenter for a given storage domain UUID
        # This is the UUID that becomes the "StoragePoolID" in our OVF XML
        # TODO: The storagedomain object has a get_data_center() method that doesn't seem to work
        #       Find out why
        dcs =  self.api.datacenters.list()
        for dc in dcs:
            self.log.debug("Looking for our storage domain (%s) in data center (%s)" % (sd_uuid, dc.get_id()))
            sd = dc.storagedomains.get(id=sd_uuid)
            if sd: 
                self.log.debug("This is the right datacenter (%s)" % (dc.get_id()))
                return dc
        return None

    def get_cluster_by_dc(self, poolid):
        # If we have been passed "_any_" as the cluster name, we pick the first cluster that
        # matches our datacenter/pool ID
        clusters = self.api.clusters.list()

        for cluster in clusters:
            dc_id = None
            if cluster.get_data_center():
                dc_id = cluster.get_data_center().get_id()
            self.log.debug("Checking cluster (%s) with name (%s) with data center (%s)" % (cluster.get_id(), cluster.get_name(), dc_id))
            if dc_id == poolid:
                return cluster
        self.log.debug("Cannot find cluster for dc (%s)" % (poolid))
        return None

    def get_cluster_by_name(self, name):
        # If we have been passed a specific cluster name, we need to find that specific cluster
        clusters = self.api.clusters.list()
        for cluster in clusters:
            self.log.debug("Checking cluster (%s) with name (%s)" % (cluster.get_id(), cluster.get_name()))
            if cluster.get_name() == name:
                return cluster
        self.log.debug("Cannot find cluster named (%s)" % (name))
        return None


    def init_vm_import(self, image_filename, nfs_host, nfs_path, nfs_dir, cluster):
        # Prepare for the import of a VM
        self.image_filename = image_filename
        self.nfs_host = nfs_host
        self.nfs_path = nfs_path
        self.nfs_dir = nfs_dir

        # Sets some values used when creating XML and meta files
        self.storage_domain_object = self.get_storage_domain(nfs_host, nfs_path)
        if self.storage_domain_object:
            self.storage_domain = self.storage_domain_object.get_id()
        else:
            raise Exception("Cannot find storage domain matching NFS details given")

        self.dc_object = self.get_pool_id(self.storage_domain)
        if self.dc_object:
            # Our StoragePoolID is the UUID of the DC containing our storage domain
            self.pool_id=self.dc_object.get_id()
        else:
            raise Exception("Cannot find datacenter for our storage domain")

        if cluster == '_any_':
            self.cluster_object = self.get_cluster_by_dc(self.pool_id)
        else:
            self.cluster_object = self.get_cluster_by_name(cluster)
        if self.cluster_object:
            self.cluster = self.cluster_object.get_id()
        else:
            raise Exception("Cannot find cluster (%s)" % (cluster))

    def stage_files(self):
        # Called after init to copy files to staging location

        # This is the base dir of the export domain
        self.export_domain_dir = self.nfs_dir + "/" + self.storage_domain
        if not os.path.isdir(self.export_domain_dir):
            raise Exception("Cannot find expected export domain directory (%s) at local mount point (%s)" % (self.nfs_dir, self.storage_domain))

        self.ovf_pkg = RHEVOVFPackage(disk=self.image_filename,
                                      ovf_name=self.ovf_name,
                                      ovf_desc=self.ovf_desc)
        self.ovf_pkg.sync()

    def move_files(self):
        self.final_image_dir = "%s/images/%s" % (self.export_domain_dir, str(self.ovf_pkg.img_uuid))
        self.final_ovf_dir = "%s/master/vms/%s" % (self.export_domain_dir, str(self.ovf_pkg.tpl_uuid))

        self.copy_dir_as_nfs_user(self.ovf_pkg.image_dir, self.final_image_dir)
        self.copy_dir_as_nfs_user(self.ovf_pkg.ovf_dir, self.final_ovf_dir)

    def remove_export_template(self):
        self.rm_rf_as_nfs_user(self.final_image_dir)
        self.rm_rf_as_nfs_user(self.final_ovf_dir)       

    def execute_import(self):
        # We import to the master storage domain of the datacenter of which our export domain is a member
        # Got it?
        action = params.Action()
        sds = self.dc_object.storagedomains.list()
        for sd in sds:
            if sd.get_master():
                action.storage_domain=sd
        if not action.storage_domain:
            raise Exception("Could not find master storage domain for datacenter ID (%s)" % (self.dc_object.get_id()))
        action.cluster = self.cluster_object

        # At this point our freshly copied in files are discoverable via the tpl_uuid in our export domain
        template = self.storage_domain_object.templates.get(id=str(self.ovf_pkg.tpl_uuid))
        if template:
            template.import_template(action=action)
            real_template = self.api.templates.get(id=str(self.ovf_pkg.tpl_uuid))
            # Wait 5 minutes for an import to finish
            self.log.debug("Waiting for template import to complete")
            for i in range(30):
                self.log.debug("Waited %d - state (%s)" % (i*10, real_template.get_status().get_state()))
                if real_template.get_status().get_state() != 'locked':
                    break
                real_template = real_template.update()
                sleep(10)
            self.log.debug("Deleting export domain files")
            self.remove_export_template() 
            final_state = real_template.get_status().get_state()
            if final_state == 'ok':
                self.log.debug("Template import completed successfully")
                return
            elif final_state == 'locked':
                raise Exception("Timed out waiting for template import to finish")
            else:
                raise Exception("Template import ended in unknown state (%s)" % (final_state))
Esempio n. 52
0
class RHEVMSystem(MgmtSystemAPIBase):
    """
    Client to RHEVM API

    This class piggy backs off ovirtsdk.

    Benefits of ovirtsdk:
    - Don't need intimite knowledge w/ RHEVM api itself.
    Detriments of ovirtsdk:
    - Response to most quaries are returned as an object rather than a string.
      This makes it harder to do simple stuff like getting the status of a vm.
    - Because of this, it makes listing VMs based on **kwargs impossible
      since ovirtsdk relies on re class to find matches.

    E.G. List out VM with this name (positive case)
      Ideal: self.api.vms.list(name='test_vm')
      Underneath the hood:
        - ovirtsdk fetches list of all vms [ovirtsdk.infrastructure.brokers.VM
          object, ...]
        - ovirtsdk then tries to filter the result using re.
          - tries to look for 'name' attr in ovirtsdk.infrastructure.brokers.VM
            object
          - found name attribute, in this case, the type of the value of the
            attribute is string.
          - match() succeed in comparing the value to 'test_vm'

    E.G. List out VM with that's powered on (negative case)
      Ideal: self.api.vms.list(status='up')
      Underneath the hood:
        - '^same step as above except^'
            - found status attribute, in this case, the type of the value of
              the attribute is ovirtsdk.xml.params.Status
            - match() failed because class is compared to string 'up'

     This problem should be attributed to how RHEVM api was designed rather
     than how ovirtsdk handles RHEVM api responses.

    - Obj. are not updated after action calls.
      - E.G.
        vm = api.vms.get(name='test_vm')
        vm.status.get_state() # returns 'down'
        vm.start()
        # wait a few mins
        vm.status.get_state() # returns 'down'; wtf?

        vm = api.vms.get(name='test_vm')
        vm.status.get_state() # returns 'up'
    """

    _stats_available = {
        'num_vm': lambda self: len(self.list_vm()),
        'num_host': lambda self: len(self.list_host()),
        'num_cluster': lambda self: len(self.list_cluster()),
        'num_template': lambda self: len(self.list_template()),
        'num_datastore': lambda self: len(self.list_datastore()),
    }

    def __init__(self, hostname, username, password, **kwargs):
        # generate URL from hostname

        if 'port' in kwargs:
            url = 'https://%s:%s/api' % (hostname, kwargs['port'])
        else:
            url = 'https://%s/api' % hostname

        self.api = API(url=url, username=username, password=password, insecure=True)

    def _get_vm(self, vm_name=None):
        if vm_name is None:
            raise Exception('Could not find a VM named %s.' % vm_name)
        else:
            vm = self.api.vms.get(name=vm_name)
            if vm is None:
                raise Exception('Could not find a VM named %s.' % vm_name)
            return vm

    def get_ip_address(self, vm_name):
        vm = self._get_vm(vm_name)
        return vm.get_guest_info().get_ips().get_ip()[0].get_address()

    def does_vm_exist(self, name):
        try:
            self._get_vm(name)
            return True
        except Exception:
            return False

    def start_vm(self, vm_name=None):
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'up':
            return True
        else:
            ack = vm.start()
            if ack.get_status().get_state() == 'complete':
                return True
        return False

    def stop_vm(self, vm_name):
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'down':
            return True
        else:
            ack = vm.stop()
            if ack.get_status().get_state() == 'complete':
                return True
        return False

    def delete_vm(self, vm_name):
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'up':
            self.stop_vm(vm_name)
        ack = vm.delete()
        if ack == '':
            return True
        else:
            return False

    def create_vm(self, vm_name):
        raise NotImplementedError('This function has not yet been implemented.')
    # Heres the code but don't have a need and no time to test it to get it right
    #   including for inclusion later
    #
    # def create_vm(self, vm_name, *args, **kwargs):
    #     MB = 1024 * 1024
    #     try:
    #         self.api.vms.add(
    #             params.VM(
    #                 name=vm_name,
    #                 memory=kwargs['memory_in_mb'] * MB,
    #                 cluster=self.api.clusters.get(kwargs['cluster_name']),
    #                 template=self.api.templates.get('Blank')))
    #         print 'VM created'
    #         self.api.vms.get(vm_name).nics.add(params.NIC(name='eth0',
    #             network=params.Network(name='ovirtmgmt'), interface='virtio'))
    #         print 'NIC added to VM'
    #         self.api.vms.get(vm_name).disks.add(params.Disk(
    #             storage_domains=params.StorageDomains(
    #                 storage_domain=[self.api.storagedomains.get(kwargs['storage_domain'])],
    #                 size=512 * MB,
    #                 status=None,
    #                 interface='virtio',
    #                 format='cow',
    #                 sparse=True,
    #                 bootable=True)))
    #         print 'Disk added to VM'
    #         print 'Waiting for VM to reach Down status'
    #         while self.api.vms.get(vm_name).status.state != 'down':
    #             time.sleep(1)
    #     except Exception as e:
    #         print 'Failed to create VM with disk and NIC\n%s' % str(e)

    def restart_vm(self, vm_name):
        if not self.stop_vm(vm_name):
            return False
        else:
            return self.start_vm(vm_name)

    def list_vm(self, **kwargs):
        # list vm based on kwargs can be buggy
        # i.e. you can't return a list of powered on vm
        # but you can return a vm w/ a matched name
        vm_list = self.api.vms.list(**kwargs)
        return [vm.name for vm in vm_list]

    def list_host(self, **kwargs):
        host_list = self.api.hosts.list(**kwargs)
        return [host.name for host in host_list]

    def list_datastore(self, **kwargs):
        datastore_list = self.api.storagedomains.list(**kwargs)
        return [ds.name for ds in datastore_list if ds.get_status() is None]

    def list_cluster(self, **kwargs):
        cluster_list = self.api.clusters.list(**kwargs)
        return [cluster.name for cluster in cluster_list]

    def list_template(self, **kwargs):
        '''
        CFME ignores the 'Blank' template, so we do too
        '''
        template_list = self.api.templates.list(**kwargs)
        return [template.name for template in template_list if template.name != "Blank"]

    def list_flavor(self):
        raise NotImplementedError('This function is not supported on this platform.')

    def info(self):
        # and we got nothing!
        pass

    def disconnect(self):
        self.api.disconnect()

    def vm_status(self, vm_name=None):
        state = self._get_vm(vm_name).get_status().get_state()
        return state

    def is_vm_running(self, vm_name):
        state = self.vm_status(vm_name)
        return "up" == state

    def is_vm_stopped(self, vm_name):
        state = self.vm_status(vm_name)
        return "down" == state

    def is_vm_suspended(self, vm_name):
        state = self.vm_status(vm_name)
        return "suspended" == state

    def suspend_vm(self, vm_name):
        vm = self._get_vm(vm_name)
        if vm.status.get_state() == 'down':
            raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
        else:
            ack = vm.suspend()
            return ack.get_status().get_state() == 'complete'

    def clone_vm(self, source_name, vm_name):
        raise NotImplementedError('This function has not yet been implemented.')

    def deploy_template(self, template, *args, **kwargs):
        self.api.vms.add(params.VM(
            name=kwargs['vm_name'],
            cluster=self.api.clusters.get(kwargs['cluster_name']),
            template=self.api.templates.get(template)))
        while self.api.vms.get(kwargs['vm_name']).status.state != 'down':
            time.sleep(5)
        self.start_vm(kwargs['vm_name'])
        while not self.is_vm_running(kwargs['vm_name']):
            time.sleep(5)
        return kwargs['vm_name']
Esempio n. 53
0
class RHEVMHelper(object):

    api_connections_lock = BoundedSemaphore()

    def __init__(self, url, username, password):
        self.log = logging.getLogger('%s.%s' % (__name__, self.__class__.__name__))
        # The SDK allows only a single active connection object to be created, regardless of whether 
        # or not multiple RHEVM servers are being accessed.  For now we need to have a global lock,
        # create a connection object before each batch of API interactions and then disconnect it.
        self.api_details = { 'url':url, 'username':username, 'password':password }

    # TODO: When this limitation in the ovirt SDK is removed, get rid of these
    def _init_api(self):
        self.log.debug("Doing blocking acquire() on global RHEVM API connection lock")
        self.api_connections_lock.acquire()
        self.log.debug("Got global RHEVM API connection lock")
        url = self.api_details['url']
        username = self.api_details['username']
        password = self.api_details['password']
        self.api = API(url=url, username=username, password=password)

    def _disconnect_api(self):
        self.api.disconnect()
        self.log.debug("Releasing global RHEVM API connection lock")
        self.api_connections_lock.release()

    # These are the only two genuinley public methods
    # What we create is a VM template

    def import_template(self, image_filename, nfs_host, nfs_path, nfs_dir, cluster,
                        ovf_name = None, ovf_desc = None):
        if not ovf_desc:
            self.ovf_desc = "Imported by Image Factory"
        else:
            self.ovf_desc = ovf_desc
        self.log.debug("Preparing for RHEVM template import of image file (%s)" % (image_filename))

        # API lock protected action
        try: 
            self._init_api()
            self.init_vm_import(image_filename, nfs_host, nfs_path, nfs_dir, cluster)
        finally:
            self._disconnect_api()

        if not ovf_name:
            self.ovf_name=str(self.tpl_uuid)
        else:
            self.ovf_name = ovf_name
        self.log.debug("Staging files")
        self.stage_files()
        self.log.debug("Moving files to final export domain location")
        self.move_files()
        self.log.debug("Executing import")

        # API lock protected action
        try:
            self._init_api()
            self.execute_import()
        finally:
            self._disconnect_api()

        return str(self.tpl_uuid)

    def delete_template(self, template_uuid):
        template = self.api.templates.get(id=template_uuid)
        if template:
            template.delete()
            return True
        else:
            return False

    # Begin Nuts and Bolts

    # We don't want to run seteuid() in our main process as it will globally change the UID/GID for everything
    # OTOH, we need to be root to access our image files and temp files
    # We use stdin and Popen's preexec_fn via the helper functions below to deal with this
    def become_nfs_user(self):
        os.setegid(NFSGID)
        os.seteuid(NFSUID)

    def copy_as_nfs_user(self, sourcefile, destfile):
        self.log.debug("Copying (%s) to (%s) as nfsuser" % (sourcefile, destfile))
        f = open(sourcefile,"r")
        (stdout, stderr, retcode) = subprocess_check_output([ 'dd', 'of=%s' % (destfile), 'bs=4k' ], stdin=f, preexec_fn=self.become_nfs_user)
        f.close()

    def move_as_nfs_user(self, sourcefile, destfile):
        self.log.debug("Moving (%s) to (%s) as nfsuser" % (sourcefile, destfile))
        (stdout, stderr, retcode) = subprocess_check_output([ 'mv', '%s' % (sourcefile), '%s' % (destfile)], preexec_fn=self.become_nfs_user)

    def mkdir_as_nfs_user(self, directory):
        self.log.debug("Making directory (%s) as nfsuser" % (directory))
        (stdout, stderr, retcode) = subprocess_check_output([ 'mkdir', '%s' % (directory)], preexec_fn=self.become_nfs_user)

    def rm_rf_as_nfs_user(self, directory):
        self.log.debug("Recursive remove of dir (%s) as nfsuser" % (directory))
        (stdout, stderr, retcode) = subprocess_check_output([ 'rm', '-rf', '%s' % (directory)], preexec_fn=self.become_nfs_user)

    def get_storage_domain(self, nfs_host, nfs_path):
        # Find the storage domain that matches the nfs details given
        sds = self.api.storagedomains.list()
        for sd in sds:
            if sd.get_type() == "export":
                self.log.debug("Export domain: (%s)" % (sd.get_name()))
                stor = sd.get_storage()
                if (stor.get_address() == nfs_host) and (stor.get_path() == nfs_path):
                    self.log.debug("This is the right domain (%s)" % (sd.get_id()))
                    return sd
        return None

    def get_pool_id(self, sd_uuid):
        # Get datacenter for a given storage domain UUID
        # This is the UUID that becomes the "StoragePoolID" in our OVF XML
        # TODO: The storagedomain object has a get_data_center() method that doesn't seem to work
        #       Find out why
        dcs =  self.api.datacenters.list()
        for dc in dcs:
            self.log.debug("Looking for our storage domain (%s) in data center (%s)" % (sd_uuid, dc.get_id()))
            sd = dc.storagedomains.get(id=sd_uuid)
            if sd: 
                self.log.debug("This is the right datacenter (%s)" % (dc.get_id()))
                return dc
        return None

    def get_cluster_by_dc(self, poolid):
        # If we have been passed "_any_" as the cluster name, we pick the first cluster that
        # matches our datacenter/pool ID
        clusters = self.api.clusters.list()

        for cluster in clusters:
            dc_id = None
            if cluster.get_data_center():
                dc_id = cluster.get_data_center().get_id()
            self.log.debug("Checking cluster (%s) with name (%s) with data center (%s)" % (cluster.get_id(), cluster.get_name(), dc_id))
            if dc_id == poolid:
                return cluster
        self.log.debug("Cannot find cluster for dc (%s)" % (poolid))
        return None

    def get_cluster_by_name(self, name):
        # If we have been passed a specific cluster name, we need to find that specific cluster
        clusters = self.api.clusters.list()
        for cluster in clusters:
            self.log.debug("Checking cluster (%s) with name (%s)" % (cluster.get_id(), cluster.get_name()))
            if cluster.get_name() == name:
                return cluster
        self.log.debug("Cannot find cluster named (%s)" % (name))
        return None


    def check_qcow_size(self, filename):
        # Detect if an image is in qcow format
        # If it is, return the size of the underlying disk image
        # If it isn't, return none

        # For interested parties, this is the QCOW header struct in C
        # struct qcow_header {
        #    uint32_t magic; 
        #    uint32_t version;
        #    uint64_t backing_file_offset;
        #    uint32_t backing_file_size;
        #    uint32_t cluster_bits;
        #    uint64_t size; /* in bytes */
        #    uint32_t crypt_method;
        #    uint32_t l1_size;
        #    uint64_t l1_table_offset;
        #    uint64_t refcount_table_offset;
        #    uint32_t refcount_table_clusters;
        #    uint32_t nb_snapshots;
        #    uint64_t snapshots_offset;
        # };

        # And in Python struct format string-ese
        qcow_struct=">IIQIIQIIQQIIQ" # > means big-endian
        qcow_magic = 0x514649FB # 'Q' 'F' 'I' 0xFB

        f = open(filename,"r")
        pack = f.read(struct.calcsize(qcow_struct))
        f.close()

        unpack = struct.unpack(qcow_struct, pack)

        if unpack[0] == qcow_magic:
            return unpack[5]
        else:
            return None

    def init_vm_import(self, image_filename, nfs_host, nfs_path, nfs_dir, cluster):
        # Prepare for the import of a VM
        self.image_filename = image_filename
        self.nfs_host = nfs_host
        self.nfs_path = nfs_path
        self.nfs_dir = nfs_dir

        # Sets some values used when creating XML and meta files
        self.storage_domain_object = self.get_storage_domain(nfs_host, nfs_path)
        if self.storage_domain_object:
            self.storage_domain = self.storage_domain_object.get_id()
        else:
            raise Exception("Cannot find storage domain matching NFS details given")

        self.dc_object = self.get_pool_id(self.storage_domain)
        if self.dc_object:
            # Our StoragePoolID is the UUID of the DC containing our storage domain
            self.pool_id=self.dc_object.get_id()
        else:
            raise Exception("Cannot find datacenter for our storage domain")

        if cluster == '_any_':
            self.cluster_object = self.get_cluster_by_dc(self.pool_id)
        else:
            self.cluster_object = self.get_cluster_by_name(cluster)
        if self.cluster_object:
            self.cluster = self.cluster_object.get_id()
        else:
            raise Exception("Cannot find cluster (%s)" % (cluster))

        # Volume size is the qcow_size if the image is qcow
        # or the raw disk image size if not
        self.qcow_size = self.check_qcow_size(image_filename)
        if self.qcow_size:
            self.vol_size=self.qcow_size
        else:
            statb = os.stat(image_filename)
            self.vol_size = statb[stat.ST_SIZE]

        # We need these three unique identifiers when generating XML and the meta file
        self.img_uuid = uuid.uuid4()
        self.vol_uuid = uuid.uuid4()
        self.tpl_uuid = uuid.uuid4()

        # Set this once to use in both the OVF XML and the meta file
        self.raw_create_time = time.time()
        self.create_time = time.gmtime(self.raw_create_time)

    def stage_files(self):
        # Called after init to copy files to staging location

        # This is the base dir of the export domain
        self.export_domain_dir = self.nfs_dir + "/" + self.storage_domain
        if not os.path.isdir(self.export_domain_dir):
            raise Exception("Cannot find expected export domain directory (%s) at local mount point (%s)" % (self.nfs_dir, self.storage_domain))

        # Make distinct tempdir for OVF stuff
        self.ovftmpdir=self.export_domain_dir + "/" + "imgfac." + str(self.tpl_uuid)
        self.mkdir_as_nfs_user(self.ovftmpdir)

        # Add the OVF file
        self.ovfdest = self.ovftmpdir + "/" + str(self.tpl_uuid) + ".ovf"
        ovf_file_object = NamedTemporaryFile()
        et = self.generate_ovf_xml()
        et.write(ovf_file_object)
        ovf_file_object.flush()
        self.copy_as_nfs_user(ovf_file_object.name, self.ovfdest)
        ovf_file_object.close()

        # Make our own temporary subdir for the image file itself
        self.imgtmpdir=self.export_domain_dir + "/" + "imgfac." + str(self.img_uuid)
        self.mkdir_as_nfs_user(self.imgtmpdir)
        
        # Add the meta file for the image
        self.imgdest = self.imgtmpdir + "/" + str(self.vol_uuid)
        self.imgmetadest = self.imgdest + ".meta"
        meta_file_object = NamedTemporaryFile()
        meta_file_object.write(self.generate_meta_file())
        meta_file_object.flush()
        self.copy_as_nfs_user(meta_file_object.name, self.imgmetadest)
        meta_file_object.close()

        # Copy the big image file last 
        self.copy_as_nfs_user(self.image_filename, self.imgdest)

    def move_files(self):
        self.final_image_dir = "%s/images/%s" % (self.export_domain_dir, str(self.img_uuid))
        self.final_ovf_dir = "%s/master/vms/%s" % (self.export_domain_dir, str(self.tpl_uuid))

        self.move_as_nfs_user(self.imgtmpdir, self.final_image_dir)
        self.move_as_nfs_user(self.ovftmpdir, self.final_ovf_dir)

    def remove_export_template(self):
        self.rm_rf_as_nfs_user(self.final_image_dir)
        self.rm_rf_as_nfs_user(self.final_ovf_dir)       

    def execute_import(self):
        # We import to the master storage domain of the datacenter of which our export domain is a member
        # Got it?
        action = params.Action()
        sds = self.dc_object.storagedomains.list()
        for sd in sds:
            if sd.get_master():
                action.storage_domain=sd
        if not action.storage_domain:
            raise Exception("Could not find master storage domain for datacenter ID (%s)" % (self.dc_object.get_id()))
        action.cluster = self.cluster_object

        # At this point our freshly copied in files are discoverable via the tpl_uuid in our export domain
        template = self.storage_domain_object.templates.get(id=str(self.tpl_uuid))
        if template:
            template.import_template(action=action)
            real_template = self.api.templates.get(id=str(self.tpl_uuid))
            # Wait 5 minutes for an import to finish
            self.log.debug("Waiting for template import to complete")
            for i in range(30):
                self.log.debug("Waited %d - state (%s)" % (i*10, real_template.get_status().get_state()))
                if real_template.get_status().get_state() != 'locked':
                    break
                real_template = real_template.update()
                sleep(10)
            self.log.debug("Deleting export domain files")
            self.remove_export_template() 
            final_state = real_template.get_status().get_state()
            if final_state == 'ok':
                self.log.debug("Template import completed successfully")
                return
            elif final_state == 'locked':
                raise Exception("Timed out waiting for template import to finish")
            else:
                raise Exception("Template import ended in unknown state (%s)" % (final_state))

    def generate_meta_file(self):
        metafile=""

        metafile += "DOMAIN=" + self.storage_domain + "\n"
        # saved template has VOLTYPE=SHARED
        metafile += "VOLTYPE=LEAF\n"
        metafile += "CTIME=" + str(int(self.raw_create_time)) + "\n"
        # saved template has FORMAT=COW
        if self.qcow_size:
            metafile += "FORMAT=COW\n"
        else:
            metafile += "FORMAT=RAW\n"
        metafile += "IMAGE=" + str(self.img_uuid) + "\n"
        metafile += "DISKTYPE=1\n"
        metafile += "PUUID=00000000-0000-0000-0000-000000000000\n"
        metafile += "LEGALITY=LEGAL\n"
        metafile += "MTIME=" + str(int(self.raw_create_time)) + "\n"
        metafile += "POOL_UUID=" + self.pool_id + "\n"
        # assuming 1KB alignment
        metafile += "SIZE=" + str(self.vol_size/512) + "\n"
        metafile += "TYPE=SPARSE\n"
        metafile += "DESCRIPTION=Uploaded by Image Factory\n"
        metafile += "EOF\n"

        return metafile
 
    def generate_ovf_xml(self):
        etroot = ElementTree.Element('ovf:Envelope')
        etroot.set('xmlns:ovf', "http://schemas.dmtf.org/ovf/envelope/1/")
        etroot.set('xmlns:rasd', "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
        etroot.set('xmlns:vssd', "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData")
        etroot.set('xmlns:xsi', "http://www.w3.org/2001/XMLSchema-instance")
        etroot.set('ovf:version', "0.9")

        etref = ElementTree.Element('References')

        etfile = ElementTree.Element('File')
        etfile.set('ovf:href', str(self.img_uuid)+'/'+str(self.vol_uuid))
        etfile.set('ovf:id', str(self.vol_uuid))
        etfile.set('ovf:size', str(self.vol_size))
        # TODO: Bulk this up a bit
        etfile.set('ovf:description', self.ovf_name)
        etref.append(etfile)

        etroot.append(etref)

        etsec = ElementTree.Element('Section')
        etsec.set('xsi:type', "ovf:NetworkSection_Type")
        ete = ElementTree.Element('Info')
        ete.text = "List of Networks"
        etsec.append(ete)
        # dummy section, even though we have Ethernet defined below
        etroot.append(etsec)

        etsec = ElementTree.Element('Section')
        etsec.set('xsi:type', "ovf:DiskSection_Type")

        etdisk = ElementTree.Element('Disk')
        etdisk.set('ovf:diskId', str(self.vol_uuid))
        vol_size_str = str((self.vol_size + (1024*1024*1024) - 1) / (1024*1024*1024))
        etdisk.set('ovf:size', vol_size_str)
        etdisk.set('ovf:vm_snapshot_id', '00000000-0000-0000-0000-000000000000')
        etdisk.set('ovf:actual_size', vol_size_str)
        etdisk.set('ovf:format', 'http://www.vmware.com/specifications/vmdk.html#sparse')
        etdisk.set('ovf:parentRef', '')
        # XXX ovf:vm_snapshot_id
        etdisk.set('ovf:fileRef', str(self.img_uuid)+'/'+str(self.vol_uuid))
        # XXX ovf:format ("usually url to the specification")
        if self.qcow_size:
            etdisk.set('ovf:volume-type', "Sparse")
            etdisk.set('ovf:volume-format', "COW")
        else:
            etdisk.set('ovf:volume-type', "Preallocated")
            etdisk.set('ovf:volume-format', "RAW")
        etdisk.set('ovf:disk-interface', "VirtIO")
        etdisk.set('ovf:disk-type', "System")
        etdisk.set('ovf:boot', "true")
        etdisk.set('ovf:wipe-after-delete', "false")
        etsec.append(etdisk)

        etroot.append(etsec)

        etcon = ElementTree.Element('Content')
        etcon.set('xsi:type', "ovf:VirtualSystem_Type")
        etcon.set('ovf:id', "out")

        ete = ElementTree.Element('Name')
        ete.text = self.ovf_name
        etcon.append(ete)

        ete = ElementTree.Element('TemplateId')
        ete.text = str(self.tpl_uuid)
        etcon.append(ete)

        # spec also has 'TemplateName'

        ete = ElementTree.Element('Description')
        ete.text = self.ovf_desc
        etcon.append(ete)

        ete = ElementTree.Element('Domain')
        # AD domain, not in use right now
        # ete.text = 
        etcon.append(ete)

        ete = ElementTree.Element('CreationDate')
        ete.text = time.strftime("%Y/%m/%d %H:%M:%S", self.create_time)
        etcon.append(ete)

        ete = ElementTree.Element('TimeZone')
        # ete.text = 
        etcon.append(ete)

        ete = ElementTree.Element('IsAutoSuspend')
        ete.text = "false"
        etcon.append(ete)

        ete = ElementTree.Element('VmType')
        ete.text = "1"
        etcon.append(ete)

        ete = ElementTree.Element('default_display_type')
        # vnc = 0, gxl = 1
        ete.text = "0"
        etcon.append(ete)

        ete = ElementTree.Element('default_boot_sequence')
        # C=0,   DC=1,  N=2, CDN=3, CND=4, DCN=5, DNC=6, NCD=7,
        # NDC=8, CD=9, D=10, CN=11, DN=12, NC=13, ND=14
        # (C - HardDisk, D - CDROM, N - Network)
        ete.text = "1"
        etcon.append(ete)

        etsec = ElementTree.Element('Section')
        etsec.set('xsi:type', "ovf:OperatingSystemSection_Type")
        etsec.set('ovf:id', str(self.tpl_uuid))
        etsec.set('ovf:required', "false")

        ete = ElementTree.Element('Info')
        ete.text = "Guest OS"
        etsec.append(ete)

        ete = ElementTree.Element('Description')
        # This is rigid, must be "Other", "OtherLinux", "RHEL6", or such
        ete.text = "OtherLinux"
        etsec.append(ete)

        etcon.append(etsec)

        etsec = ElementTree.Element('Section')
        etsec.set('xsi:type', "ovf:VirtualHardwareSection_Type")

        ete = ElementTree.Element('Info')
        ete.text = "1 CPU, 512 Memory"
        etsec.append(ete)

        etsys = ElementTree.Element('System')
        # This is probably wrong, needs actual type.
        ete = ElementTree.Element('vssd:VirtualSystemType')
        ete.text = "RHEVM 4.6.0.163"
        etsys.append(ete)
        etsec.append(etsys)

        etitem = ElementTree.Element('Item')

        ete = ElementTree.Element('rasd:Caption')
        ete.text = "1 virtual CPU"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:Description')
        ete.text = "Number of virtual CPU"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:InstanceId')
        ete.text = "1"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ResourceType')
        ete.text = "3"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:num_of_sockets')
        ete.text = "1"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:cpu_per_socket')
        ete.text = "1"
        etitem.append(ete)

        etsec.append(etitem)

        etitem = ElementTree.Element('Item')

        ete = ElementTree.Element('rasd:Caption')
        ete.text = "512 MB of memory"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:Description')
        ete.text = "Memory Size"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:InstanceId')
        ete.text = "2"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ResourceType')
        ete.text = "4"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:AllocationUnits')
        ete.text = "MegaBytes"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:VirtualQuantity')
        ete.text = "512"
        etitem.append(ete)

        etsec.append(etitem)

        etitem = ElementTree.Element('Item')

        ete = ElementTree.Element('rasd:Caption')
        ete.text = "Drive 1"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:InstanceId')
        ete.text = str(self.vol_uuid)
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ResourceType')
        ete.text = "17"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:HostResource')
        ete.text = str(self.img_uuid)+'/'+str(self.vol_uuid)
        etitem.append(ete)

        ete = ElementTree.Element('rasd:Parent')
        ete.text = "00000000-0000-0000-0000-000000000000"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:Template')
        ete.text = "00000000-0000-0000-0000-000000000000"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ApplicationList')
        # List of installed applications, separated by comma
        etitem.append(ete)

        # This corresponds to ID of volgroup in host where snapshot was taken.
        # Obviously we have nothing like it.
        ete = ElementTree.Element('rasd:StorageId')
        # "Storage Domain Id"
        ete.text = "00000000-0000-0000-0000-000000000000"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:StoragePoolId')
        ete.text = self.pool_id
        etitem.append(ete)

        ete = ElementTree.Element('rasd:CreationDate')
        ete.text = time.strftime("%Y/%m/%d %H:%M:%S", self.create_time)
        etitem.append(ete)

        ete = ElementTree.Element('rasd:LastModified')
        ete.text = time.strftime("%Y/%m/%d %H:%M:%S", self.create_time)
        etitem.append(ete)

        etsec.append(etitem)

        etitem = ElementTree.Element('Item')

        ete = ElementTree.Element('rasd:Caption')
        ete.text = "Ethernet 0 rhevm"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:InstanceId')
        ete.text = "3"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ResourceType')
        ete.text = "10"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ResourceSubType')
        # e1000 = 2, pv = 3
        ete.text = "3"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:Connection')
        ete.text = "rhevm"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:Name')
        ete.text = "eth0"
        etitem.append(ete)

        # also allowed is "MACAddress"

        ete = ElementTree.Element('rasd:speed')
        ete.text = "1000"
        etitem.append(ete)

        etsec.append(etitem)

        etitem = ElementTree.Element('Item')

        ete = ElementTree.Element('rasd:Caption')
        ete.text = "Graphics"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:InstanceId')
        # doc says "6", reality is "5"
        ete.text = "5"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:ResourceType')
        ete.text = "20"
        etitem.append(ete)

        ete = ElementTree.Element('rasd:VirtualQuantity')
        ete.text = "1"
        etitem.append(ete)

        etsec.append(etitem)

        etcon.append(etsec)

        etroot.append(etcon)

        et = ElementTree.ElementTree(etroot)
        return et
logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(levelname)s %(message)s',
                    filename=LOGFILENAME,
                    filemode='w')
def start_vms(vmObj):
	logging.info('Thread to start %s', vmObj.name)
	try:
		vmObj.start()
		#time.sleep(5)
	except Exception as e:
		logging.debug('Exception caught on VM ( %s) start:\n%s' % (vmObj.name, str(e)))
		failedVms.append(vmObj.name)
if __name__ == "__main__":
   try:	
        api = API(url=APIURL,
              username=APIUSER,
              password=APIPASS,
              ca_file=CAFILE)
              print 'Connected to RHEVM API  %s Successfully' % APIURL
              logging.info ( 'Successfully Connected to %s' % APIURL)
    	try: 
		print ' \n I am logging in %s \n' % LOGFILENAME
		vmsList = api.vms.list()
	 	for i in vmsList:
			print i.name
			if i.status.state != 'up':
				logging.warning('%s is not up, trying to start it' % i.name)
				threadMe = Thread(target=start_vms, args=[i])
				threadMe.start()
				threads.append(threadMe)
    	except Exception as e:
        	logging.debug('Error:\n%s' % str(e))
Esempio n. 55
0
class ovirt_test( object ):
    """An instance represents ovirt test.
    """
    def __init__ ( self, test_dict = {} ):
        '''Constructor for ovirt_test.
        self.ovirt_dict = {}
        self.ovirt_dict['URL'] = url
        self.ovirt_dict['VERSION'] = params.Version(major='3', minor='0')
        self.ovirt_dict['CA_FILE'] = "/etc/pki/ovirt-engine/ca.pem"
        self.ovirt_dict['USERINFO'] = {}
        self.ovirt_dict['USERINFO']['NAME'] = 'admin@internal'
        self.ovirt_dict['USERINFO']['PASSWORD'] = '******' 

        self.ovirt_dict['DATACENTERS'] = [(name,type,cluster,storage,network),(name,...), ...] 
        network = [(name,type),(name, ...), ...]
        storage = [(name,type,addr,path),(name, ...), ...]
        cluster = [(name,type,hosts,vms,volumes),(name, ...), ...]
        hosts   = [(name,address),(name, ...), ...]
        volumes = [(name,type),(name, ...), ...]
        vms     = [(name,type,ostype,display,nics,disks),(name, ...), ...]
        nics    = [(name,type,network),(name, ...), ...]
        disks   = [(name,type,size,storage),(name, ...), ...] '''

        global iCLUSTERS
        global iSTORAGES
        global iHOSTS
        iCLUSTERS = 2
        iSTORAGES = 3
        iHOSTS = 2

        self.ovirt_dict = {}
        self.ovirt_dict['URL'] = test_dict['URL']
        self.ovirt_dict['VERSION'] = test_dict['VERSION']
        self.ovirt_dict['CA_FILE'] = test_dict['CA_FILE']
        self.ovirt_dict['USERINFOS'] = []
        self.ovirt_dict['USERINFOS'].append(test_dict['USERINFOS'][0])
        self.ovirt_dict['CONNECTION'] = False
        self.ovirt_dict['DATACENTERS'] = []
        self.ovirt_dict['CLUSTERS'] = []
        self.ovirt_dict['HOSTS'] = []
        self.ovirt_dict['STORAGES'] = []
        self.ovirt_dict['VMS'] = []
        self.ovirt_dict['NICS'] = []
        self.ovirt_dict['DISKS'] = []

    def connect_engine( self ): 
        '''Connect ovirt-engine, default connect local ovirt-engine
        api = API(url="https://128.224.165.209:443/api", \
                username="******", \
                password="******", \
                ca_file="/etc/pki/ovirt-engine/ca.pem")
        '''
        try:
            self.api = API(url=self.ovirt_dict['URL'],
                       username=self.ovirt_dict['USERINFOS'][0][0],
                       password=self.ovirt_dict['USERINFOS'][0][1],
                       ca_file=self.ovirt_dict['CA_FILE'])
            print 'Connect ovirt-engine successfully'
            self.ovirt_dict['CONNECTION'] = True
        except Exception as e:
            print 'Connect ovirt-engine failed:\n%s' % (str(e))
            self.ovirt_dict['CONNECTION'] = False
            return False

    def disconnect( self ): 
        '''Disconnect ovirt-engine'''
        try:
            if self.api.disconnect() == None:
                print 'Disconnect ovirt-engine successfully'
                self.ovirt_dict['CONNECTION'] = False
        except Exception as e:
            print 'Disconnect ovirt-engine failed:\n%s' % (str(e))
            self.ovirt_dict['CONNECTION'] = 1
            return False

    def check_item( self, group , item_name, Other = 'None' ): 
        '''Check the item(item_name) exist in group'''
        try:
            index = 0
            length = len(group)
            for index in range(0,length):
                if group[index][0] == item_name:
                    if Other != 'None' and group[index][1] == Other:
                        return index
                    return index
            if index + 1 >= length:
                return None
        except Exception as e:
            print 'Check %s failed:\n%s' % (item_name,str(e))
            return None

    def add_user( self, UserInfo = ('admin@internal','admin') ): 
        '''add a new user'''
        try:
            self.ovirt_dict['USERINFOS'].append(UserInfo)
        except Exception as e:
            print 'Add new user failed:\n%s' % (str(e))
            return False

    def change_user( self, UserInfo = ('admin@internal','admin') ): 
        '''change username and password'''
        try:
            length = len(self.ovirt_dict['USERINFOS'])
            for i in range(0,length):
                if self.ovirt_dict['USERINFOS'][i][0] == UserInfo[0]:
                    tempUser = self.ovirt_dict['USERINFOS'][i]
                    self.ovirt_dict['USERINFOS'].remove(tempUser)
                    self.ovirt_dict['USERINFOS'].insert(i,UserInfo)
                    Found = 1
                    break
                else:
                    Found = 0
            if Found == 0:
                print 'Change user information failed'
                return False
        except Exception as e:
            print 'Change user information failed:\n%s' % (str(e))
            return False

    def printInstanceInfo( self ): 
        ''''change username and password'''
        print self.ovirt_dict

    def print_summary(self, summary):
        lenth = len(summary)
        print ' \n' + '#'*10 + ' ' + summary + ' ' + '#'*(40-lenth) + ' \n'
Esempio n. 56
0
if config.rhevmconfig["host"] == "":
    print "No RHEV-M hostname was specified."
    error()
elif config.rhevmconfig["user"] == "":
    print "No user name was specified."
    error()
elif config.rhevmconfig["passwd"] == "":
    print "Enter password for user %s:" % (config.rhevmconfig['user'])
    config.rhevmconfig['passwd'] = getpass()

# Connect to RHEV-M
if config.vmconfig["quiet"] == False:
    print "Connecting to RHEV-M %s..." % (config.rhevmconfig['host'])
api = API(url=config.rhevmconfig["host"],
          username=config.rhevmconfig["user"],
          password=config.rhevmconfig["passwd"],
          insecure=True)
if config.vmconfig["quiet"] == False:
    print "Connection established"
    print ""

if config.vmname != "":
    vm = vm(config.vmname, config.vmconfig, api)
if command == "start":
    vm.start()
elif command == "stop":
    vm.stop()
elif command == "console":
    vm.console(config.rhevmconfig)
elif command == "migrate":
    vm.migrate()
Esempio n. 57
0
 p.add_option("-t", "--vm-template", action="store", type="string", dest="vm_template",
              help="provide template name. eg: -a create -n vm01 -t tpl01 -c cluster01")
 p.add_option("-p", "--vm-password", action="store", type="string", dest="vm_password",
              help="-a init -p password_of_vm -i vm_nic_info")
 p.add_option("-i", "--vm-nic-info", action="store", type="string", dest="vm_nic_info",
              help='nic info: "name_of_nic, ip_address, net_mask, gateway". '
                   'eg: -a init -n vm01 -p 123456 -i "eth0, 10.0.100.101, 255.255.255.0, 10.0.100.1"')
 p.add_option("-L", "--vm-list", action="store", type="string", dest="vm_list",
              help='a list of vms. eg: -a stop-list -L "vm01, vm02, vm03"')
 p.set_defaults(action='list',
                vm_cluster='C01',
                vm_template='tpl-m1')
 opt, args = p.parse_args()
 oe_conn = None
 try:
     oe_conn = API(url=OE_URL, username=OE_USERNAME, password=OE_PASSWORD, ca_file=OE_CA_FILE)
     if opt.action == 'list':
         vm_list(oe_conn)
     elif opt.action == 'start':
         vm_start(oe_conn, opt.vm_name)
     elif opt.action == 'stop':
         vm_stop(oe_conn, opt.vm_name)
     elif opt.action == 'delete':
         vm_delete(oe_conn, opt.vm_name)
     elif opt.action == 'create':
         vm_create_from_tpl(oe_conn, opt.vm_name, opt.vm_template, opt.vm_cluster)
     elif opt.action == 'init':
         vm_run_once(oe_conn, opt.vm_name, opt.vm_password, opt.vm_nic_info)
     elif opt.action == 'start-list':
         for vm in opt.vm_list.replace(' ', '').split(','):
             print('[I] try to start vm: {0}'.format(vm))
Esempio n. 58
0
6.	from time import sleep  
7.	  
8.	  
9.	VERSION = params.Version(major='3', minor='0')  
10.	 ##change to fit your host   
11.	URL =           input(' enter ip address, example: 'https://192.168.1.1:8443/api')  
12.	USERNAME =      input('Enter username, example: [email protected] ')  
13.	PASSWORD =      input('Enter your password)   
14.	  
15.	DC_NAME =       input('Enter name of your datacenter')  
16.	CLUSTER_NAME =  input('cluster name')  
17.	HOST_NAME =     input('input host name')  
18.	STORAGE_NAME =  input('input storage name')  
19.	VM_NAME =       input('enter VM name')  
20.	  
21.	api = API(url=URL, username=USERNAME, password=PASSWORD)30  
22.	try:  
23.	    if api.hosts.add(params.Host(name=HOST_NAME, address=HOST_ADDRESS, cluster=api.clusters.get(CLUSTER_NAME), root_password=ROOT_PASSWORD)):  
24.	      
25.	        print 'Host was installed successfully'  
26.	        print 'Waiting for host to reach the Up status'  
27.	        while api.hosts.get(HOST_NAME).status.state != 'up':  
28.	            sleep(1)  
29.	        print "Host is up"  
30.	except Exception as e:  
31.	    print 'Failed to install Host:\n%s' % str(e)  
32.	  
33.	   
34.	def connectToHost(host,host_user,host_pw):  
35.	    apiurl="https://"+host+"/api" #change for your host  
36.	    #insecure -> skips SSL check  
Esempio n. 59
0
 def __init__(self, *args, **kw):
     _API.__init__(self, *args, **kw)
     self.vms = VMs(self.id)