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 get_configuration(server, username, password, skipVerification):
session = get_unverified_session() if skipVerification else None
if not session:
session = requests.Session()
host_url = "https://{}/api".format(server)
sec_ctx = create_user_password_security_context(username, password)
session_svc = Session(
StubConfigurationFactory.new_std_configuration(
get_requests_connector(
session=session,
url=host_url,
provider_filter_chain=[
LegacySecurityContextFilter(security_context=sec_ctx)
])))
session_id = session_svc.create()
print("Session ID : ", session_id)
sec_ctx = create_session_security_context(session_id)
stub_config = StubConfigurationFactory.new_std_configuration(
get_requests_connector(
session=session,
url=host_url,
provider_filter_chain=[
LegacySecurityContextFilter(security_context=sec_ctx)
]))
return stub_config
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
stub_config = get_configuration(args.server, args.username,
args.password, session)
self.list_cluster = Clusters(stub_config)
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 run(self):
"""
Converges the external PSC into the Management Node without shutting
down the Platform Services Controller.
"""
session = get_unverified_session() if self.skipverification else None
sec_ctx = create_user_password_security_context(
self.username, self.password)
# TODO The following line to be deleted when API is changed to
# @Release type. As of now this is only for testing
app_ctx = ApplicationContext({SHOW_UNRELEASED_APIS: "True"})
connector = get_requests_connector(
session=session,
msg_protocol='json',
url='https://{0}:5480/api'.format(self.server),
provider_filter_chain=[
LegacySecurityContextFilter(
security_context=sec_ctx)])
connector.set_application_context(app_ctx)
stub_config = StubConfigurationFactory.new_std_configuration(connector)
deployment_type = DeploymentType(stub_config)
"""
Running convergence task precheck.
Remove the line ", only_precheck = True" to perform convergence.
"""
convergence_task = deployment_type.convert_to_vcsa_embedded_task(
DeploymentType.ConvergenceSpec(DeploymentType.PscInfo(
sso_admin_username=self.sso_admin_username,
sso_admin_password=self.sso_admin_password),
only_precheck=True))
print('Converge operation started with task ID: \n{0}'.format(
convergence_task.get_task_id()))
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 __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 run(self):
"""
Decommissions a PSC node from a Management Node
"""
session = get_unverified_session() if self.skipverification else None
sec_ctx = create_user_password_security_context(
self.username, self.password)
# TODO The following line to be deleted when API is changed to
# @Release type. As of now this is only for testing
app_ctx = ApplicationContext({SHOW_UNRELEASED_APIS: "True"})
connector = get_requests_connector(session=session,
msg_protocol='json',
url='https://{0}:5480/api'.format(
self.server))
connector.set_security_context(sec_ctx)
connector.set_application_context(app_ctx)
stub_config = StubConfigurationFactory.new_std_configuration(connector)
pscs_obj = Pscs(stub_config)
"""
Running decommission task precheck.
Remove the line ", only_precheck = True" to perform decommission.
"""
decommission_task = pscs_obj.decommission_task(
self.psc_hostname,
Pscs.DecommissionSpec(sso_admin_username=self.sso_admin_username,
sso_admin_password=self.sso_admin_password),
only_precheck=True)
print('Decommission operation started with task ID: \n%s',
decommission_task.get_task_id())
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 __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
stub_config = get_configuration(args.server, args.username,
args.password, args.skipverification)
self.pending_client = Pending(stub_config)
self.precheck_client = PrecheckReport(stub_config)
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):
parser = sample_cli.build_arg_parser()
args = sample_util.process_cli_args(parser.parse_args())
session = get_unverified_session() if args.skipverification else None
stub_config = get_configuration(
args.server, args.username, args.password,
session)
self.product_client = ProductCatalog(stub_config)
self.associated_products_client = AssociatedProducts(stub_config)
def __init__(self):
parser = sample_cli.build_arg_parser()
parser.add_argument('-f', '--file_name',
help='Provide csv report file name.')
args = sample_util.process_cli_args(parser.parse_args())
self.csv_report = args.file_name
session = get_unverified_session() if args.skipverification else None
stub_config = get_configuration(
args.server, args.username, args.password,
session)
self.report_client = Reports(stub_config)
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 __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 __init__(self):
parser = sample_cli.build_arg_parser()
parser.add_argument(
'--cluster',
required=True,
help='The MoID of the Supervisor Cluster to query.')
args = sample_util.process_cli_args(parser.parse_args())
session = get_unverified_session() if args.skipverification else None
stub_config = get_configuration(args.server, args.username,
args.password, session)
self.cluster_supervisor_services = ClusterSupervisorServices(
stub_config)
self.versions = Versions(stub_config)
self.cluster = args.cluster
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 __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):
parser = sample_cli.build_arg_parser()
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
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 _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)
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 __init__(self):
parser = sample_cli.build_arg_parser()
parser.add_argument(
'--item',
required=True,
action='store',
choices=['memory', 'cpu', 'storage'],
help='Specify the name of health item to view the messages')
args = sample_util.process_cli_args(parser.parse_args())
self.item = args.item
# Connect to vAPI services
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 _setup(self):
# Required arguments
self.datacenter_name = self.args.datacentername
self.resource_pool_name = self.args.resourcepoolname
self.item_name = self.args.itemname
# Optional arguments
self.vm_name = (self.args.vmname
if self.args.vmname else rand('checked-out-vm-'))
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)
def run(self):
print('\n\n#### Example: Login to vCenter server with '
'embedded Platform Services Controller')
# Since the platform services controller is embedded, the sso server
# is the same as the vCenter server.
sso_url = 'https://{}/sts/STSService'.format(self.args.server)
print('\nStep 1: Connect to the Single Sign-On URL and '
'retrieve the SAML bearer token.')
authenticator = sso.SsoAuthenticator(sso_url)
context = None
if self.args.skipverification:
context = get_unverified_context()
bearer_token = authenticator.get_bearer_saml_assertion(
self.args.username,
self.args.password,
delegatable=True,
ssl_context=context)
session = get_unverified_session(
) if self.args.skipverification else None
# Connect to vSphere client
client = create_vsphere_client(server=self.args.server,
bearer_token=bearer_token,
session=session)
# Create and Delete TagCategory to Verify connection is successful
print('\nStep 3: Creating and Deleting Tag Category...\n')
create_spec = client.tagging.Category.CreateSpec()
create_spec.name = 'TestTag_embeded_psc_sso_workflow'
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):
parser = sample_cli.build_arg_parser()
parser.add_argument('-x',
'--win_password',
action='store',
help='windows admin password to be customized')
args = sample_util.process_cli_args(parser.parse_args())
if args.win_password:
self.win_password = args.win_password
else:
self.win_password = None
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
# get customization config
self.config = configparser.ConfigParser()
self.linCfgPath = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'linSpec.cfg')
self.winCfgPath = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'winSpec.cfg')
self.specsAdded = []
def _setup(self):
self.datastore_name = self.args.datastorename
self.cluster_name = self.args.clustername
self.folder_name = self.args.foldername
self.datacenter_name = self.args.datacentername
self.servicemanager = self.get_service_manager()
self.datastore_id = get_datastore_id(
service_manager=self.servicemanager,
datastore_name=self.datastore_name)
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)
self.folder_id = get_folder(self.vsphere_client, self.datacenter_name,
self.folder_name)
self.storage_backings = self.helper.create_storage_backings(
self.servicemanager, self.datastore_name)
cluster_obj = get_obj(self.servicemanager.content,
[vim.ClusterComputeResource], self.cluster_name)
self.resource_pool_id = cluster_obj.resourcePool._GetMoId()
parser.add_argument('--vc',
dest='vcenter_server',
help='VCenter hostname or IP')
parser.add_argument('--subject_token',
dest='subject_token',
help='Subject/Access token')
parser.add_argument('--actor_token', dest='actor_token', help='Actor/ID token')
parser.add_argument('--skipverification',
action='store_true',
help='Skip Server Certificate Verification')
args = parser.parse_args()
session = requests.session()
if args.skipverification:
session = get_unverified_session()
stub_config = StubConfigurationFactory.new_std_configuration(
get_requests_connector(session=session,
url=HTTP_ENDPOINT.format(args.vcenter_server)))
# create oauth security context for authentication
oauth_security_context = create_oauth_security_context(args.subject_token)
stub_config.connector.set_security_context(oauth_security_context)
token_exchange = TokenExchange(stub_config)
exchange_spec = token_exchange.ExchangeSpec(
grant_type=token_exchange.TOKEN_EXCHANGE_GRANT,
subject_token_type=token_exchange.ACCESS_TOKEN_TYPE,
actor_token_type=token_exchange.ID_TOKEN_TYPE,
requested_token_type=token_exchange.SAML2_TOKEN_TYPE,
