def test_simple_request_serializer(self):
def request_matcher(r1, r2):
soap_msg = ('<soapenv:Body>'
'<RetrieveServiceContent xmlns="urn:vim25">'
'<_this type="ServiceInstance">'
'ServiceInstance'
'</_this>'
'</RetrieveServiceContent>'
'</soapenv:Body>')
if soap_msg in r1.body:
return True
raise SystemError('serialization error occurred')
my_vcr = vcr.VCR()
my_vcr.register_matcher('request_matcher', request_matcher)
with my_vcr.use_cassette(
'test_simple_request_serializer.yaml',
cassette_library_dir=tests.fixtures_path,
record_mode='none',
match_on=['request_matcher']) as cass:
host = 'vcsa'
port = 443
stub = SoapStubAdapter(host, port)
si = vim.ServiceInstance("ServiceInstance", stub)
content = si.RetrieveContent()
self.assertTrue(content is not None)
self.assertTrue(
'<_this type="ServiceInstance">ServiceInstance</_this>'
in cass.requests[0].body)
def __init__(self, server, username, password):
self.server = server
self.username = username
self.password = password
self.SI = None
requests.packages.urllib3.disable_warnings()
self.context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
self.context.verify_mode = ssl.CERT_NONE
try:
smart_stub = connect.SmartStubAdapter(host=self.server,
sslContext=self.context,
connectionPoolTimeout=0)
session_stub = connect.VimSessionOrientedStub(smart_stub,
connect.VimSessionOrientedStub.makeUserLoginMethod(self.username,
self.password))
self.SI = vim.ServiceInstance('ServiceInstance', session_stub)
except Exception as exc:
raise vCenterException(exc)
else:
atexit.register(connect.Disconnect, self.SI)
if not self.SI:
vCenterException("Unable to connect to host with supplied info.")
def _get_service_instance(self):
"""
Gets the service instance
Returns:
vim.ServiceInstance: Service Instance for Host
"""
try:
smart_stub = SmartStubAdapter(
host=self._host,
port=int(self._port),
sslContext=self.sslContext,
connectionPoolTimeout=0,
)
session_stub = VimSessionOrientedStub(
smart_stub,
VimSessionOrientedStub.makeUserLoginMethod(
self._user, self._password),
)
service_instance = vim.ServiceInstance("ServiceInstance",
session_stub)
# Ensure connection to server is closed on program exit
atexit.register(Disconnect, service_instance)
return service_instance
except vmodl.MethodFault as error:
logger.error(f"Caught vmodl fault : {error.msg}")
raise
def _get_file_manager(self):
if not self._file_manager:
soap_stub = self._datacenter_mo._stub
service_instance = vim.ServiceInstance('ServiceInstance',
soap_stub)
self._file_manager = service_instance.content.fileManager
return self._file_manager
def test_find_a_host(self, mock_si):
"""
Verify that find a host calls the right sub functions
"""
test_si = vim.ServiceInstance()
test_si.content.searchIndex.FindAllByDnsName.return_value = ['thehost']
self.assertEqual(find_host(test_si, 'thehost'), 'thehost')
test_si.content.searchIndex.FindAllByDnsName.assert_called_once()
def WaitForTask(task,
raiseOnError=True,
si=None,
pc=None,
onProgressUpdate=None):
"""
Wait for task to complete.
@type raiseOnError : bool
@param raiseOnError : Any exception thrown is thrown up to the caller
if raiseOnError is set to true.
@type si : ManagedObjectReference to a ServiceInstance.
@param si : ServiceInstance to use. If None, use the
information from the task.
@type pc : ManagedObjectReference to a PropertyCollector.
@param pc : Property collector to use. If None, get it from
the ServiceInstance.
@type onProgressUpdate : callable
@param onProgressUpdate : Callable to call with task progress updates.
For example::
def OnTaskProgressUpdate(task, percentDone):
print 'Task %s is %d%% complete.' % (task, percentDone)
"""
if si is None:
si = vim.ServiceInstance("ServiceInstance", task._stub)
if pc is None:
pc = si.content.propertyCollector
progressUpdater = ProgressUpdater(task, onProgressUpdate)
progressUpdater.Update('created')
filter = CreateFilter(pc, task)
version, state = None, None
# Loop looking for updates till the state moves to a completed state.
while state not in (vim.TaskInfo.State.success, vim.TaskInfo.State.error):
try:
version, state = GetTaskStatus(task, version, pc)
progressUpdater.UpdateIfNeeded()
except vmodl.fault.ManagedObjectNotFound as e:
print("Task object has been deleted: %s" % e.obj)
break
filter.Destroy()
if state == "error":
progressUpdater.Update('error: %s' % str(task.info.error))
if raiseOnError:
raise task.info.error
else:
print("Task reported error: " + str(task.info.error))
else:
progressUpdater.Update('completed')
return state
def __init__(self,
hostname: str,
username: str,
password: str,
datacenter: str = None,
cluster: str = None,
port: int = 443):
""" Create a VcCluster instance """
# Instance variables
self.hostname = hostname
self.username = username
self.password = password
self.port = port
# Instance parameters
self.ssl_context = unverified_ssl_context()
self.timeout = 0
try:
# Connect using a session oriented connection
# Ref. https://github.com/vmware/pyvmomi/issues/347
self.si = None
credentials = VimSessionOrientedStub.makeUserLoginMethod(self.username, self.password)
smart_stub = SmartStubAdapter(host=self.hostname,
port=self.port,
sslContext=self.ssl_context,
connectionPoolTimeout=self.timeout)
self.session_stub = VimSessionOrientedStub(smart_stub, credentials)
self.si = vim.ServiceInstance('ServiceInstance', self.session_stub)
if not self.si:
msg = f'Could not connect to the specified host using the specified username and password'
raise ValueError(msg)
except socket.gaierror as e:
msg = f'Connection: failed ({e.strerror})'
raise ValueError(msg)
except IOError as e:
raise e
except Exception as e:
raise e
self.host_type = self.si.content.about.apiType
if self.host_type != 'VirtualCenter':
raise ValueError(f'Host is not a vCenter: {self.host_type}')
self.api_version = self.si.content.about.apiVersion
if int(self.api_version.split('.')[0]) < 6:
raise RuntimeError(f'API version less than 6.0.0 is not supported: {self.api_version}')
# Get objects
self.datacenter = self.__get_datacenter(name=datacenter)
self.cluster = self.__get_cluster(name=cluster)
self.hosts = self.get_cluster_hosts()
def __RetrieveContent(host, port, adapter, version, path, keyFile, certFile,
thumbprint, sslContext, connectionPoolTimeout=CONNECTION_POOL_IDLE_TIMEOUT_SEC):
"""
Retrieve service instance for connection.
@param host: Which host to connect to.
@type host: string
@param port: Port
@type port: int
@param adapter: Adapter
@type adapter: string
@param version: Version
@type version: string
@param path: Path
@type path: string
@param keyFile: ssl key file path
@type keyFile: string
@param certFile: ssl cert file path
@type certFile: string
@param connectionPoolTimeout: Timeout in secs for idle connections to close, specify negative numbers for never
closing the connections
@type connectionPoolTimeout: int
"""
# XXX remove the adapter and service arguments once dependent code is fixed
if adapter != "SOAP":
raise ValueError(adapter)
# Create the SOAP stub adapter
stub = SoapStubAdapter(host, port, version=version, path=path,
certKeyFile=keyFile, certFile=certFile,
thumbprint=thumbprint, sslContext=sslContext,
connectionPoolTimeout=connectionPoolTimeout)
# Get Service instance
si = vim.ServiceInstance("ServiceInstance", stub)
content = None
try:
content = si.RetrieveContent()
except vmodl.MethodFault:
raise
except ParserError:
raise
except Exception as e:
# NOTE (hartsock): preserve the traceback for diagnostics
# pulling and preserving the traceback makes diagnosing connection
# failures easier since the fault will also include where inside the
# library the fault occurred. Without the traceback we have no idea
# why the connection failed beyond the message string.
(type, value, traceback) = sys.exc_info()
if traceback:
fault = vim.fault.HostConnectFault(msg=str(e))
reraise(vim.fault.HostConnectFault, fault, traceback)
else:
raise vim.fault.HostConnectFault(msg=str(e))
return content, si, stub
def connect_ticket(self, host, ticket):
if ticket:
try:
stub = connect.SoapStubAdapter(host, HOSTD_PORT, VIM_NAMESPACE)
self._si = vim.ServiceInstance("ServiceInstance", stub)
self._si.RetrieveContent().sessionManager.CloneSession(ticket)
self._post_connect()
except httplib.HTTPException as http_exception:
self._logger.info("Failed to login hostd with ticket: %s" % http_exception)
raise AcquireCredentialsException(http_exception)
def test_fail_find_a_host(self, mock_si):
"""
Verify that find a host calls the right sub functions,
and fails with an exception
"""
test_si = vim.ServiceInstance()
test_si.content.searchIndex.FindAllByDnsName.return_value = []
with self.assertRaises(Exception,
msg="Exception not raised \
on failure to find host"):
find_host(test_si, 'thehost')
test_si.content.searchIndex.FindAllByDnsName.assert_called_once()
def ConnectToVC(vchost, vcport, vcuser, vcpassword):
si = SmartConnectNoSSL(host=vchost,
user=vcuser,
pwd=vcpassword,
port=vcport)
stub = VimSessionOrientedStub(
si._stub,
VimSessionOrientedStub.makeUserLoginMethod(vcuser, vcpassword))
si = vim.ServiceInstance("ServiceInstance", stub)
atexit.register(Disconnect, si)
return si
def connect(host, user, password):
stub = pyVmomi.SoapStubAdapter(
host=host,
port=443,
version='vim.version.version6',
path='/sdk',
certKeyFile=None,
certFile=None)
si = vim.ServiceInstance("ServiceInstance", stub)
content = si.RetrieveContent()
content.sessionManager.Login(user, password, None)
return si
def get_service_instance(self):
# create a connection to hostd.
request = ServiceTicketRequest(ServiceType.VIM)
response = self.host_client.get_service_ticket(request)
self.assertEqual(response.result, ServiceTicketResultCode.OK)
hostd_port = 443
vim_namespace = "vim25/5.0"
stub = SoapStubAdapter(self.server, hostd_port, vim_namespace)
si = vim.ServiceInstance("ServiceInstance", stub)
si.RetrieveContent().sessionManager.CloneSession(response.vim_ticket)
connect.SetSi(si)
return si
def connectToVimEndpoint(host,
username,
password,
version='vim.version.version6'):
"""
Get a service instance
"""
context = None
ssl._create_default_https_context = ssl._create_unverified_context
stub = SoapStubAdapter(host=host, path="/sdk", poolSize=0, version=version)
si = vim.ServiceInstance('ServiceInstance', stub)
content = si.content
logging.info(str([username, password]))
content.sessionManager.Login(userName=username, password=password)
return si, content
def test_canary_test(self, mock_sleep, mock_vmotion,
mock_fh, mock_go, mock_vm, mock_si, mock_hs):
"""
Verify that canary calls cause vmotions to be called for
"""
test_si = vim.ServiceInstance()
test_vm = vim.VirtualMachine()
mock_go.return_value = test_vm
host = vim.HostSystem()
host.name = 'Foo'
mock_fh.return_value = host
canary_test(test_si, ['host1', 'host2'], 'vmname', False)
test_si.RetrieveContent.assert_called_once()
self.assertEqual(mock_vmotion.call_count, 2,
"Two vmotions should occur")
def __Login(host, port, user, pwd, service, adapter, version, path, keyFile,
certFile):
"""
Private method that performs the actual Connect and returns a
connected service instance object.
@param host: Which host to connect to.
@type host: string
@param port: Port
@type port: int
@param user: User
@type user: string
@param pwd: Password
@type pwd: string
@param service: Service
@type service: string
@param adapter: Adapter
@type adapter: string
@param version: Version
@type version: string
@param path: Path
@type path: string
@param keyFile: ssl key file path
@type keyFile: string
@param certFile: ssl cert file path
@type certFile: string
"""
# XXX remove the adapter and service arguments once dependent code is fixed
if adapter != "SOAP":
raise ValueError(adapter)
# Create the SOAP stub adapter
stub = SoapStubAdapter(host,
port,
version=version,
path=path,
certKeyFile=keyFile,
certFile=certFile)
# Get Service instance
si = vim.ServiceInstance("ServiceInstance", stub)
try:
content = si.RetrieveContent()
except vmodl.MethodFault:
raise
except Exception, e:
raise vim.fault.HostConnectFault(msg=str(e))
def _doLogin(soapStub):
import sso
cert = soapStub.schemeArgs['cert_file']
key = soapStub.schemeArgs['key_file']
authenticator = sso.SsoAuthenticator(sts_url=stsUrl,
sts_cert=stsCert)
samlAssertion = authenticator.get_bearer_saml_assertion(
username, password, cert, key)
si = vim.ServiceInstance("ServiceInstance", soapStub)
sm = si.content.sessionManager
if not sm.currentSession:
try:
soapStub.samlToken = samlAssertion
si.content.sessionManager.LoginByToken()
finally:
soapStub.samlToken = None
def _base_serialize_test(self, soap_creator, request_matcher):
my_vcr = vcr.VCR()
my_vcr.register_matcher('request_matcher', request_matcher)
with my_vcr.use_cassette(
'test_simple_request_serializer.yaml',
cassette_library_dir=tests.fixtures_path,
record_mode='none',
match_on=['request_matcher']) as cass:
stub = soap_creator()
si = vim.ServiceInstance("ServiceInstance", stub)
content = si.RetrieveContent()
self.assertTrue(content is not None)
self.assertTrue(
'<_this type="ServiceInstance">ServiceInstance</_this>'
in cass.requests[0].body.decode("utf-8"))
def get_service_instance_from_managed_object(mo_ref, name='<unnamed>'):
'''
Retrieves the service instance from a managed object.
me_ref
Reference to a managed object (of type vim.ManagedEntity).
name
Name of managed object. This field is optional.
'''
if not name:
name = mo_ref.name
log.trace('[{0}] Retrieving service instance from managed object'
''.format(name))
si = vim.ServiceInstance('ServiceInstance')
si._stub = mo_ref._stub
return si
def test_canary_test_vmname(self, mock_sleep, mock_vmotion, mock_fh,
mock_go, mock_vm, mock_si, mock_hs):
"""
Given a canary VM name, vmotions get called for.
"""
test_si = vim.ServiceInstance()
test_vm = vim.VirtualMachine()
test_vm.guest.ipAddress = None
test_vm.name = "Bob"
mock_go.return_value = test_vm
host = vim.HostSystem()
host.name = 'Foo'
mock_fh.return_value = host
canary_test(test_si, ['host1', 'host2'], test_vm.name, False)
test_si.RetrieveContent.assert_called_once()
self.assertEqual(mock_vmotion.call_count, 2,
"Two vmotions should occur")
mock_vmotion.assert_called_with(test_vm, host, test_vm.name, False)
def connect(host, user, password, verify=True):
if verify:
context = None
else:
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_NONE
stub = pyVmomi.SoapStubAdapter(
host=host,
port=443,
version='vim.version.version6',
path='/sdk',
sslContext=context)
si = vim.ServiceInstance("ServiceInstance", stub)
content = si.RetrieveContent()
content.sessionManager.Login(user, password, None)
return si
def test_canary_test_failure(self, mock_sleep, mock_vmotion, mock_fh,
mock_go, mock_vm, mock_si, mock_hs):
"""
Verify that if an exception occurs, that
a) the vmotion was asked for, and
b) an exception happens
"""
test_si = vim.ServiceInstance()
test_vm = vim.VirtualMachine()
mock_go.return_value = test_vm
host = vim.HostSystem()
host.name = 'Foo'
mock_fh.return_value = host
canarytest.vsphere_tools.do_a_vmotion.side_effect = Exception(
'vmotion raised an exception Failed')
with self.assertRaises(Exception):
canary_test(test_si, ['host1', 'host2'], 'vmname', False)
test_si.RetrieveContent.assert_called_once()
self.assertEqual(mock_vmotion.call_count, 1,
"One vmotions should occur, raising the exception")
def _connect(self):
print("Connecting to %s as %s" %
(self._vm_host["name"],
self._request["host_authentication"]["username"]))
smart_stub = SmartStubAdapter(
host=self._vm_host["name"],
port=443,
sslContext=ssl._create_unverified_context(),
connectionPoolTimeout=0)
self._session_stub = VimSessionOrientedStub(
smart_stub,
VimSessionOrientedStub.makeUserLoginMethod(
self._request["host_authentication"]["username"],
self._request["host_authentication"]["password"]))
si = vim.ServiceInstance('ServiceInstance', self._session_stub)
if not si:
raise Exception("Could not connect to %s" % self._vm_host["name"])
return si
def _doLogin(soapStub):
import sso
cert = soapStub.schemeArgs['cert_file']
key = soapStub.schemeArgs['key_file']
authenticator = sso.SsoAuthenticator(sts_url=stsUrl,
sts_cert=stsCert)
samlAssertion = authenticator.get_hok_saml_assertion(cert, key)
def _requestModifier(request):
return sso.add_saml_context(request, samlAssertion, key)
si = vim.ServiceInstance("ServiceInstance", soapStub)
sm = si.content.sessionManager
if not sm.currentSession:
with soapStub.requestModifier(_requestModifier):
try:
soapStub.samlToken = samlAssertion
si.content.sessionManager.LoginByToken()
finally:
soapStub.samlToken = None
def _SmartSessionOrientedConnect(host, username, password):
"""Create a new session oriented stub that will
automatically login when used.
"""
# create a smart stub that will connect using the latest known
# VIM version
stub = SmartStubAdapter(host, sslContext=ssl._create_unverified_context())
# login with username and password
loginMethod = VimSessionOrientedStub.makeUserLoginMethod(
username, password)
# and make the stub session oriented
sessOrientedStub = VimSessionOrientedStub(stub,
loginMethod,
retryDelay=0.5,
retryCount=20)
si = vim.ServiceInstance("ServiceInstance", sessOrientedStub)
return si
def _connect(self):
# https://github.com/vmware/pyvmomi/issues/347#issuecomment-297591340
smart_stub = SmartStubAdapter(
host=self._request[
self._side]["authentication"]["host"]["hostname"],
port=443,
sslContext=ssl._create_unverified_context(),
connectionPoolTimeout=0)
session_stub = VimSessionOrientedStub(
smart_stub,
VimSessionOrientedStub.makeUserLoginMethod(
self._request[
self._side]["authentication"]["host"]["username"],
self._request[self._side]["authentication"]["host"]
["password"],
))
conn = vim.ServiceInstance('ServiceInstance', session_stub)
if not conn:
raise Exception("Could not connect to vCenter")
return conn
def GetManagedPropertyValuesPC(self, obj):
PropertyCollector = vmodl.query.PropertyCollector
filterSpec = PropertyCollector.FilterSpec(
objectSet=[PropertyCollector.ObjectSpec(obj=obj, skip=False)],
propSet=[
PropertyCollector.PropertySpec(all=True, type=obj.__class__)
],
)
si = vim.ServiceInstance(self.serviceInstanceId, obj._stub)
pc = si.RetrieveContent().GetPropertyCollector()
props = []
for content in pc.RetrieveContents([filterSpec]):
props.extend([(dp.name, dp.val) for dp in content.propSet])
# Raise an exception if any of the missing properties
# were caused by authentication failures
authFailures = [
mp.fault for mp in content.missingSet
if self.auth.IsNotAuthenticatedFault(mp.fault)
]
if authFailures:
raise authFailures[0]
props.extend([(mp.path, '<i>%s</i>' % str(mp.fault))
for mp in content.missingSet])
return props
def _service_instance(self):
stub = SoapStubAdapter("localhost", HOSTD_PORT)
return vim.ServiceInstance("ServiceInstance", stub)
print "Enter HostIP RootPassword CertPath KeyPath"
print "Incorrect set of arguments passed."
sys.exit()
host_ip = sys.argv[1]
root_password = sys.argv[2]
cert_path = sys.argv[3]
key_path = sys.argv[4]
print "Apply Certificate: %s, %s, %s" % (host_ip, cert_path, key_path)
print "Connecting to hostd CertificateManager"
ssl._create_default_https_context = ssl._create_unverified_context
stub = pyVmomi.SoapStubAdapter(host=host_ip,
version="vim.version.version10",
path="/sdk")
si = vim.ServiceInstance("ServiceInstance", stub)
content = si.RetrieveServiceContent()
content.sessionManager.Login("root", root_password)
cert_manager = vim.host.CertificateManager('ha-certificate-manager', stub)
print "Loading certificate from file"
cert = open(cert_path, 'r').read()
print "Installing certificate"
dName = '/CN=%s' % host_ip
csr = cert_manager.GenerateCertificateSigningRequestByDn(dName)
cert_manager.InstallServerCertificate(cert=cert)
print "Replacing private key /etc/vmware/ssl/rui.key"
shutil.copyfile(key_path, "/etc/vmware/ssl/rui.key")
print "Notifying affected services"
def _doLogin(soapStub):
si = vim.ServiceInstance("ServiceInstance", soapStub)
sm = si.content.sessionManager
if not sm.currentSession:
si.content.sessionManager.LoginExtensionByCertificate(extensionKey)
