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,