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)
