def __init__(self, h, po, nt, u, p): try: if nt: session = requests.session() session.verify = False urllib3.disable_warnings( urllib3.exceptions.InsecureRequestWarning) self.connection = connect.SmartConnectNoSSL(host=h, user=u, pwd=p, port=int(po)) self.client = create_vsphere_client(server=h, username=u, password=p, session=session) else: session = requests.session() self.connection = connect.SmartConnect(host=h, user=u, pwd=p, port=int(po)) self.client = create_vsphere_client(server=h, username=u, password=p, session=session) self.content = self.connection.RetrieveContent() self.tag_association = self.client.tagging.TagAssociation self.tag_svc = self.client.tagging.Tag self.cat_svc = self.client.tagging.Category print('Connection Success') except vmodl.MethodFault as error: print("Caught vmodl fault : " + error.msg) return -1
def connect_to_vsphere_client(self): """ Connect to vSphere API Client with Username and Password """ username = self.params.get('username') password = self.params.get('password') hostname = self.params.get('hostname') session = requests.Session() session.verify = self.params.get('validate_certs') if not all([hostname, username, password]): self.module.fail_json( msg= "Missing one of the following : hostname, username, password." " Please read the documentation for more information.") client = create_vsphere_client(server=hostname, username=username, password=password, session=session) if client is None: self.module.fail_json(msg="Failed to login to %s" % hostname) return client
def get(self): address = request.args.get('a') username = request.args.get('u') password = request.args.get('p') datacenter = request.args.get('d') info = { 'address': address, 'username': username, 'password': password, 'datacenter': datacenter } # Create connection to VCenter try: # Disable certification verify session = requests.session() session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # Create connection vc = create_vsphere_client(server=address, username=username, password=password, session=session) except requests.exceptions.ConnectionError: return 'Failed to connect', 404 dc = vc.vcenter.Datacenter.list() out = {} i = 1 for obj in dc: out.update( { str(i): obj.name } ) i +=1 return out, 200
def loadhostStatus(): try: session = requests.session() # Disable cert verification for demo purpose. # This is not recommended in a production environment. session.verify = False # Disable the secure connection warning for demo purpose. # This is not recommended in a production environment. urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # Connect to a vCenter Server using username and password vsphere_client = create_vsphere_client( server='192.168.214.245', username='******', password='******', session=session) # List all VMs inside the vCenter Server # print vsphere_client.vcenter.Host.list() hosts = vsphere_client.vcenter.Host.list() for host in hosts: global host_info host_info = host_info + str(host) + "\n" except Exception, e: print e
def setup(context=None): global vm_name, client, service_instance, cleardata if context: # Run sample suite via setup script client = context.client vm_name = testbed.config['VM_NAME_DEFAULT'] service_instance = context.service_instance else: # Run sample in standalone mode server, username, password, cleardata, skip_verification, vm_name = \ parse_cli_args_vm(testbed.config['VM_NAME_DEFAULT']) session = get_unverified_session() if skip_verification else None # Connect to vSphere client client = create_vsphere_client(server=server, username=username, password=password, session=session) context = None if skip_verification: context = get_unverified_context() service_instance = SmartConnect(host=server, user=username, pwd=password, sslContext=context) atexit.register(Disconnect, service_instance)
def login(params): # pragma: no cover full_url, url, port, user_name, password = parse_params(params) # Preparations for SDKs connections s = ssl.SSLContext(ssl.PROTOCOL_TLS) s.verify_mode = ssl.CERT_NONE session = requests.session() session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) # Connect to Vsphere automation sdk using username and password vsphere_client = create_vsphere_client(server=full_url, username=user_name, password=password, session=session) # Connect to a vCenter Server using username and password try: si = SmartConnect(host=url, user=user_name, pwd=password, port=port) except Exception: si = SmartConnect(host=url, user=user_name, pwd=password, port=port, sslContext=s) return si, vsphere_client
def __init__(self, client=None, placement_spec=None, standard_network=None, distributed_network=None): self.client = client self.placement_spec = placement_spec self.standard_network = standard_network self.distributed_network = distributed_network self.vm_name = testbed.config['VM_NAME_EXHAUSTIVE'] self.cleardata = None # Execute the sample in standalone mode. if not self.client: parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) if args.vm_name: self.vm_name = args.vm_name self.cleardata = args.cleardata session = get_unverified_session( ) if args.skipverification else None self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def __init__(self): # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification parser = sample_cli.build_arg_parser() # Add your custom input arguments parser.add_argument('-n', '--vm_name', action='store', default='Sample_Default_VM_for_Simple_Testbed', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) self.vm_name = args.vm_name self.cleardata = args.cleardata # Skip server cert verification if needed. # This is not recommended in production code. session = get_unverified_session() if args.skipverification else None # Connect to vSphere client self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def _login_vapi(self): """ Login to vCenter API using REST call Returns: connection object """ session = requests.Session() session.verify = self.validate_certs if not self.validate_certs: # Disable warning shown at stdout requests.packages.urllib3.disable_warnings() server = self.hostname if self.port: server += ":" + str(self.port) client = create_vsphere_client( server=server, username=self.username, password=self.password, session=session, ) if client is None: raise AnsibleError("Failed to login to %s using %s" % (server, self.username)) return client
def login(self): """Login to vCenter.""" self.vsphere_client = create_vsphere_client( server=self.vcenter_ip, username=self.vcenter_username, password=self.vcenter_password, session=self.session)
def run(self): print('\n\n#### Example: Login to vCenter server with ' 'Valid Cert Verification') # Create a requests session and load the CA cert session = requests.session() session.verify = self.args.cert_path # Connect to VAPI client = create_vsphere_client(server=self.args.server, username=self.args.username, password=self.args.password, session=session) # List Tag Categories to verify the connection is successful print('\nStep 3: Listing the Tag Categories...\n') create_spec = client.tagging.Category.CreateSpec() create_spec.name = 'TestTag_connect_with_cert' create_spec.description = 'TestTagDesc' create_spec.cardinality = CategoryModel.Cardinality.MULTIPLE create_spec.associable_types = set() category_id = client.tagging.Category.create(create_spec) assert category_id is not None print('Tag category created; Id: {0}\n'.format(category_id)) # Delete TagCategory client.tagging.Category.delete(category_id)
def __init__(self, client=None, placement_spec=None, cpu=4, memory=4, cap=30, vm_name=None): self.client = client self.placement_spec = placement_spec self.vm_name = vm_name self.cleardata = None self.cpu = cpu self.memory = memory * 1024 self.cap = cap * 1024 * 1024 * 1024 # Execute the sample in standalone mode. if not self.client: parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--vm_name', action='store', help='Name of the testing vm') args = sample_util.process_cli_args(parser.parse_args()) if args.vm_name: self.vm_name = args.vm_name self.cleardata = args.cleardata session = get_unverified_session( ) if args.skipverification else None self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def main(): session = get_unverified_session() client = create_vsphere_client(server='192.168.111.101', username='******', password='******', session=session) create_basic_vm = CreateBasicVM(client=client, vm_name='test1000')
def __init__(self): parser = sample_cli.build_arg_parser() parser.add_argument('--resourcepoolname', default='Compute-ResourcePool', help='The name of the resource pool to be used.') parser.add_argument('--libitemname', required=True, help='The name of the library item to deploy.' 'The library item should contain an OVF package.') args = sample_util.process_cli_args(parser.parse_args()) self.vm_id = None self.vm_name = 'deployed-vm-' + str(generate_random_uuid()) self.lib_item_name = args.libitemname self.resourcepoolname = args.resourcepoolname self.cleardata = args.cleardata # Connect to vAPI Endpoint on vCenter Server self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password)
def _login_vapi(self): """ Login to vCenter API using REST call Returns: connection object """ session = requests.Session() session.verify = self.validate_certs if not self.validate_certs: # Disable warning shown at stdout requests.packages.urllib3.disable_warnings() server = self.hostname if self.port: server += ":" + str(self.port) client, err = None, None try: client = create_vsphere_client( server=server, username=self.username, password=self.password, session=session, ) except Exception as error: err = error if client is None: msg = "Failed to login to %s using %s" % (server, self.username) if err: msg += " due to : %s" % to_native(err) raise AnsibleError(msg) return client
def __init__(self): parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) session = get_unverified_session() if args.skipverification else None self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def get_vsphere_vms(vc_host): session = requests.session() session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) vsphere_client = create_vsphere_client(server=vc_host, username=vc_username, password=vc_userpass, session=session) vms = vsphere_client.vcenter.VM.list() return vms
def __init__(self): server, username, password, self.cleardata, \ skip_verification, self.vm_name = \ parse_cli_args_vm(testbed.config['VM_NAME_DEFAULT']) session = get_unverified_session() if skip_verification else None self.vsphere_client = create_vsphere_client(server=server, username=username, password=password, session=session)
def __init__(self): self.policy_id = None self.vm_id = None self.vm_info = None # Create argument parser for standard inputs: # server, username, password, cleanup and skipverification. parser = sample_cli.build_arg_parser() parser.add_argument('-n', '--name', required=True, help='Name of the policy') parser.add_argument('-d', '--description', required=False, help='Description for the policy', default='Sample policy description') parser.add_argument('-vn', '--vmname', required=True, help='Name of the virtual machine') parser.add_argument('-hn', '--hostname', required=True, help='Name of the host') parser.add_argument('-vt', '--vmtag', required=True, help='Tag name to attach to the virtual machine') parser.add_argument('-ht', '--hosttag', required=True, help='Tag name to attach to the host') # Parse the arguments. args = sample_util.process_cli_args(parser.parse_args()) self.vm_name = args.vmname self.vm_tag_name = args.vmtag self.host_name = args.hostname self.host_tag_name = args.hosttag self.policy_name = args.name self.policy_desc = args.description self.cleardata = args.cleardata # Skip server cert verification if needed. # This is not recommended in production code. session = get_unverified_session() if args.skipverification else None # Connect to vSphere client. self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def get_vm_list(request): session = requests.session() session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) vsphere_client = create_vsphere_client(server='10.12.0.3', username='******', password='******', session=session) vm_lists = vsphere_client.vcenter.VM.list() save_vm(vm_lists) return HttpResponse(vm_lists)
def __init__(self): self.metadata = None self.userdata = None self.parser = sample_cli.build_arg_parser() self.args = sample_util.process_cli_args(self.parser.parse_args()) self.session =\ get_unverified_session() if self.args.skipverification else None self.client = create_vsphere_client(server=self.args.server, username=self.args.username, password=self.args.password, session=self.session) self.specs_svc = self.client.vcenter.guest.CustomizationSpecs
def setup(context=None): global client, service_instance, cleardata if context: # Run sample suite via setup script vm_name = testbed.config['VM_NAME_DEFAULT'] client = context.client service_instance = context.service_instance else: # Run sample in standalone mode server, username, password, cleardata, skip_verification, vm_name = \ parse_cli_args_vm(testbed.config['VM_NAME_DEFAULT']) session = get_unverified_session() if skip_verification else None # Connect to vSphere client client = create_vsphere_client(server=server, username=username, password=password, session=session) # Connect to VIM API Endpoint on vCenter system context = None if skip_verification: context = get_unverified_context() service_instance = SmartConnect(host=server, user=username, pwd=password, sslContext=context) atexit.register(Disconnect, service_instance) global vm, datacenter_name, datastore_name global datastore_mo, datacenter_mo, datastore_root_path vm = get_vm(client, vm_name) if not vm: raise Exception('Sample requires an existing vm with name ({}). ' 'Please create the vm first.'.format(vm_name)) print("Using VM '{}' ({}) for Disk Sample".format(vm_name, vm)) # Get the datacenter and datastore managed objects to be able to create and # delete VMDKs, which are backings for a VM Disk. datacenter_name = testbed.config['VM_DATACENTER_NAME'] datastore_name = testbed.config['VM_DATASTORE_NAME'] datastore_mo = get_datastore_mo(client, service_instance._stub, datacenter_name, datastore_name) datacenter_mo = get_datacenter_for_datastore(datastore_mo) # The datastore_root_path is path in the datastore where the additional # VMDK files will be created for this sample. datastore_root_path = testbed.config['DISK_DATASTORE_ROOT_PATH']
def main(argv): # Disable certification verify session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) serverAdd = '' username = '' password = '' VM = '' datacenter = '' try: opts, args = getopt.getopt(argv,"ha:u:p:v:d:",["address=","username="******"password="******"VM=","datacenter="]) except getopt.GetoptError: print ('usage: gettoken.py -a <vcenter_address> -u <username> -p <password> -v <VM_name> -d <datacenter_name>') sys.exit(2) for opt, arg in opts: if (opt == '-h'): print ("usage: gettoken.py -a <vcenter_address> -u <username> -p <password> -v <VM_name> -d <datacenter_name>") sys.exit() elif opt in ("-a","--address"): serverAdd = arg elif opt in ("-u","--username"): username = arg elif opt in ("-p","--password"): password = arg elif opt in ("-v","--VM"): VM = arg elif opt in ("-d","--datacenter"): datacenter = arg # vCenter connection vc = create_vsphere_client(server=serverAdd, username=username, password=password, session=session) # Datacenter search dcSummary = vc.vcenter.Datacenter.list(vc.vcenter.Datacenter.FilterSpec(names={datacenter})) vmNames = {VM,} if dcSummary == []: print ("Datacenter not found") sys.exit(2) vmDatacenters = {dcSummary[0].datacenter,} # VM search Spec = vc.vcenter.vm.console.Tickets.CreateSpec(vc.vcenter.vm.console.Tickets.Type('VMRC')) vmSummary = vc.vcenter.VM.list(vc.vcenter.VM.FilterSpec(names=vmNames,datacenters=vmDatacenters)) if vmSummary == []: # Если ответ пустой - вывод ошибки print ('VM not found!') sys.exit(2) # Ticket generation and exit vmid = vmSummary[0].vm ticket = vc.vcenter.vm.console.Tickets.create(vmid,Spec) print (ticket.ticket) sys.exit()
def __init__(self): # Create argument parser for standard inputs: # server, username, password and skipverification parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) # Skip server cert verification if needed. # This is not recommended in production code. session = get_unverified_session() if args.skipverification else None # Connect to vSphere client self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def __init__(self): args = sample_util.process_cli_args(parser.parse_args()) self.interval = int(args.interval) self.expiration = int(args.expiration) stub_config = get_configuration(args.server, args.username, args.password, args.skipverification) self.acq_specs_client = AcqSpecs(stub_config) self.data_client = Data(stub_config) session = get_unverified_session() if args.skipverification else None self.vsphere_client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session)
def __init__(self): parser = sample_cli.build_arg_parser() args = sample_util.process_cli_args(parser.parse_args()) session = get_unverified_session() if args.skipverification else None self.client = create_vsphere_client(server=args.server, username=args.username, password=args.password, session=session) self.specs_svc = self.client.vcenter.guest.CustomizationSpecs filePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'sample_import.json') with open(filePath, 'r') as f: self.jsonDataRaw = f.read() self.specName = 'defaultCustSpec01' self.specsAdded = []
def create_vm_api(request): datacenter_name = 'BlueKing' vm_folder_name = 'test' datastore_name = 'esxi-1-hdd' # session = get_unverified_session() session = requests.session() session.verify = False urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) client = create_vsphere_client(server='10.12.33.9', username='******', password='******', session=session) # client = create_vsphere_client(server='10.12.0.3', # username=r'*****@*****.**', # password=r'p@ssw0rd', # session=session) placement_spec = get_placement_spec_for_resource_pool( client, datacenter_name, vm_folder_name, datastore_name) rec_data = json.loads(request.body.decode('utf-8'), strict=False) guest_os = "WINDOWS_9" vm_name = rec_data['name'] memory = Memory.UpdateSpec(size_mib=int(rec_data['memory']) * 1024) disk = Disk.CreateSpec(new_vmdk=Disk.VmdkCreateSpec( capacity=int(rec_data['disk']) * 1024 * 1024 * 1024)) vm_create_spec = VM.CreateSpec(name=vm_name, guest_os=guest_os, memory=memory, disks=[disk], placement=placement_spec) vm = client.vcenter.VM.create(vm_create_spec) print("create_default_vm: Created VM '{}' ({})".format(vm_name, vm)) vm_info = client.vcenter.VM.get(vm) if (vm_info): return JsonResponse({ 'code': 200, 'data': "create_default_vm: Created VM '{}' ({})".format(vm_name, vm) }) else: return JsonResponse({'code': 500, 'message': "error"})
def connect_to_vsphere_client(self): """ Connect to vSphere API Client with Username and Password """ username = self.params.get('username') password = self.params.get('password') hostname = self.params.get('hostname') port = self.params.get('port') session = requests.Session() session.verify = self.params.get('validate_certs') protocol = self.params.get('protocol') proxy_host = self.params.get('proxy_host') proxy_port = self.params.get('proxy_port') if all([protocol, proxy_host, proxy_port]): proxies = { protocol: "{0}://{1}:{2}".format(protocol, proxy_host, proxy_port) } session.proxies.update(proxies) if not all([hostname, username, password]): self.module.fail_json( msg= "Missing one of the following : hostname, username, password." " Please read the documentation for more information.") msg = "Failed to connect to vCenter or ESXi API at %s:%s" % (hostname, port) try: client = create_vsphere_client(server="%s:%s" % (hostname, port), username=username, password=password, session=session) except requests.exceptions.SSLError as ssl_exc: msg += " due to SSL verification failure" self.module.fail_json(msg="%s : %s" % (msg, to_native(ssl_exc))) except Exception as generic_exc: self.module.fail_json(msg="%s : %s" % (msg, to_native(generic_exc))) if client is None: self.module.fail_json(msg="Failed to login to %s" % hostname) return client
def setup(context=None): global vm, vm_name, client, cleardata if context: # Run sample suite via setup script client = context.client vm_name = testbed.config['VM_NAME_DEFAULT'] else: # Run sample in standalone mode server, username, password, cleardata, skip_verification, vm_name = \ parse_cli_args_vm(testbed.config['VM_NAME_DEFAULT']) session = get_unverified_session() if skip_verification else None # Connect to vSphere client client = create_vsphere_client(server=server, username=username, password=password, session=session)
def _setup(self): self.datastore_name = self.args.datastorename assert self.datastore_name is not None self.vm_name = self.args.vmname assert self.vm_name is not None self.servicemanager = self.get_service_manager() self.client = ClsApiClient(self.servicemanager) self.helper = ClsApiHelper(self.client, self.skip_verification) session = get_unverified_session() if self.skip_verification else None self.vsphere_client = create_vsphere_client(server=self.server, username=self.username, password=self.password, session=session)