def _SetInstanceMetadata(self, client, instance, new_metadata): """Sets the project metadata to the new metadata.""" errors = [] # API wants just the zone name, not the full URL zone = instance.zone.split('/')[-1] client.MakeRequests(requests=[ (client.apitools_client.instances, 'SetMetadata', client.messages.ComputeInstancesSetMetadataRequest( instance=instance.name, metadata=new_metadata, project=properties.VALUES.core.project.Get(required=True), zone=zone)) ], errors_to_collect=errors) if errors: utils.RaiseToolException( errors, error_message='Could not add SSH key to instance metadata:')
def GetTargetPool(self): """Fetches the target pool resource.""" errors = [] objects = list( request_helper.MakeRequests(requests=[ (self.service, 'Get', self.messages.ComputeTargetPoolsGetRequest( project=self.project, region=self.target_pool_ref.region, targetPool=self.target_pool_ref.Name())) ], http=self.http, batch_url=self.batch_url, errors=errors)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch target pool:') return objects[0]
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) ref = self.TARGET_SSL_PROXY_ARG.ResolveAsResource( args, holder.resources) client = holder.client.apitools_client messages = holder.client.messages request = messages.ComputeTargetSslProxiesGetRequest( project=ref.project, targetSslProxy=ref.Name()) errors = [] resources = holder.client.MakeRequests( [(client.targetSslProxies, 'Get', request)], errors) if errors: utils.RaiseToolException(errors) return resources[0]
def GetInstance(self, instance_ref): """Fetch an instance based on the given instance_ref.""" request = (self.compute.instances, 'Get', self.messages.ComputeInstancesGetRequest( instance=instance_ref.Name(), project=instance_ref.project, zone=instance_ref.zone)) errors = [] objects = list( request_helper.MakeRequests(requests=[request], http=self.http, batch_url=self.batch_url, errors=errors)) if errors: utils.RaiseToolException(errors, error_message='Could not fetch instance:') return objects[0]
def MakeRequests(self, requests, errors_to_collect=None, progress_tracker=None, followup_overrides=None): """Sends given request in batch mode.""" errors = errors_to_collect if errors_to_collect is not None else [] objects = list( request_helper.MakeRequests(requests=requests, http=self._client.http, batch_url=self._batch_url, errors=errors, progress_tracker=progress_tracker, followup_overrides=followup_overrides)) if errors_to_collect is None and errors: utils.RaiseToolException(errors, error_message='Could not fetch resource:') return objects
def GetBackendService(self, _): """Fetches the backend service resource.""" errors = [] objects = list( request_helper.MakeRequests(requests=[ (self.service, 'Get', self.messages.ComputeBackendServicesGetRequest( project=self.project, backendService=self.backend_service_ref.Name())) ], http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch backend service:') return objects[0]
def Run(self, args): if not (args.proxy_header or args.backend_service): raise exceptions.ToolException( 'You must specify at least one of [--backend-service] or ' '[--proxy-header].') holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) requests = [] target_tcp_proxy_ref = self.TARGET_TCP_PROXY_ARG.ResolveAsResource( args, holder.resources) client = holder.client.apitools_client messages = holder.client.messages if args.backend_service: backend_service_ref = self.BACKEND_SERVICE_ARG.ResolveAsResource( args, holder.resources) requests.append( (client.targetTcpProxies, 'SetBackendService', messages.ComputeTargetTcpProxiesSetBackendServiceRequest( project=target_tcp_proxy_ref.project, targetTcpProxy=target_tcp_proxy_ref.Name(), targetTcpProxiesSetBackendServiceRequest=( messages.TargetTcpProxiesSetBackendServiceRequest( service=backend_service_ref.SelfLink()))))) if args.proxy_header: proxy_header = (messages.TargetTcpProxiesSetProxyHeaderRequest. ProxyHeaderValueValuesEnum(args.proxy_header)) requests.append( (client.targetTcpProxies, 'SetProxyHeader', messages.ComputeTargetTcpProxiesSetProxyHeaderRequest( project=target_tcp_proxy_ref.project, targetTcpProxy=target_tcp_proxy_ref.Name(), targetTcpProxiesSetProxyHeaderRequest=( messages.TargetTcpProxiesSetProxyHeaderRequest( proxyHeader=proxy_header))))) errors = [] resources = holder.client.MakeRequests(requests, errors) if errors: utils.RaiseToolException(errors) return resources
def Run(self, args): """Retrieves response with instance in the instance group.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client group_ref = ( instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_ARG.ResolveAsResource( args, holder.resources, default_scope=compute_scope.ScopeEnum.ZONE, scope_lister=flags.GetDefaultScopeLister(client))) if args.regexp: # Regexp interprested as RE2 by Instance Group API filter_expr = 'instance eq {0}'.format(args.regexp) else: filter_expr = None if group_ref.Collection() == 'compute.instanceGroups': service = client.apitools_client.instanceGroups request = client.messages.ComputeInstanceGroupsListInstancesRequest( instanceGroup=group_ref.Name(), instanceGroupsListInstancesRequest=( client.messages.InstanceGroupsListInstancesRequest()), zone=group_ref.zone, filter=filter_expr, project=group_ref.project) else: service = client.apitools_client.regionInstanceGroups request = client.messages.ComputeRegionInstanceGroupsListInstancesRequest( instanceGroup=group_ref.Name(), regionInstanceGroupsListInstancesRequest=( client.messages.RegionInstanceGroupsListInstancesRequest()), region=group_ref.region, filter=filter_expr, project=group_ref.project) errors = [] results = client.MakeRequests( requests=[(service, 'ListInstances', request)], errors_to_collect=errors) if errors: utils.RaiseToolException(errors) return instance_groups_utils.UnwrapResponse(results, 'items')
def Run(self, args): cleared_fields = [] (service, method, request) = self.CreateRequest(args, cleared_fields) errors = [] with self.compute_client.apitools_client.IncludeFields(cleared_fields): resources = list( request_helper.MakeRequests(requests=[(service, method, request)], http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) resources = lister.ProcessResults( resources=resources, field_selector=property_selector.PropertySelector( properties=None, transformations=self.transformations)) if errors: utils.RaiseToolException(errors) return resources
def GetAddress(self, address_ref): """Returns the address resource corresponding to the given reference.""" errors = [] res = list( request_helper.MakeRequests(requests=[ (self.compute.addresses, 'Get', self.messages.ComputeAddressesGetRequest( address=address_ref.Name(), project=address_ref.project, region=address_ref.region)) ], http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch address resource:') return res[0]
def Run(self, args): start = time_utils.CurrentTimeSec() group_ref = self.CreateGroupReference(args) while True: responses, errors = self._GetResources(group_ref) if errors: utils.RaiseToolException(errors) if wait_info.IsGroupStable(responses[0]): break log.out.Print(wait_info.CreateWaitText(responses[0])) time_utils.Sleep(WaitUntilStable._TIME_BETWEEN_POLLS_SEC) if args.timeout and time_utils.CurrentTimeSec( ) - start > args.timeout: raise utils.TimeoutError( 'Timeout while waiting for group to become ' 'stable.') log.out.Print('Group is stable')
def _CreateResource(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) backend_service_ref = self.BACKEND_SERVICE_ARG.ResolveAsResource( args, holder.resources) target_ssl_proxy_ref = self.TARGET_SSL_PROXY_ARG.ResolveAsResource( args, holder.resources) ssl_cert_refs = self.SSL_CERTIFICATES_ARG.ResolveAsResource( args, holder.resources) client = holder.client.apitools_client messages = holder.client.messages if args.proxy_header: proxy_header = messages.TargetSslProxy.ProxyHeaderValueValuesEnum( args.proxy_header) else: proxy_header = ( messages.TargetSslProxy.ProxyHeaderValueValuesEnum.NONE) target_ssl_proxy = messages.TargetSslProxy( description=args.description, name=target_ssl_proxy_ref.Name(), proxyHeader=proxy_header, service=backend_service_ref.SelfLink(), sslCertificates=[ref.SelfLink() for ref in ssl_cert_refs]) if args.ssl_policy: target_ssl_proxy.sslPolicy = self.SSL_POLICY_ARG.ResolveAsResource( args, holder.resources).SelfLink() request = messages.ComputeTargetSslProxiesInsertRequest( project=target_ssl_proxy_ref.project, targetSslProxy=target_ssl_proxy) errors = [] resources = holder.client.MakeRequests( [(client.targetSslProxies, 'Insert', request)], errors) if errors: utils.RaiseToolException(errors) return resources
def _GetSerialPortOutput(self, port=4): """Returns the serial port output for self.instance_ref.""" request = (self.compute.instances, 'GetSerialPortOutput', self.messages.ComputeInstancesGetSerialPortOutputRequest( instance=self.ref.Name(), project=self.project, port=port, zone=self.ref.zone)) errors = [] objects = list( request_helper.MakeRequests(requests=[request], http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch serial port output:') return objects[0].contents
def GetProject(self): """Returns the project object.""" errors = [] objects = list(request_helper.MakeRequests( requests=[(self.compute.projects, 'Get', self.messages.ComputeProjectsGetRequest( project=properties.VALUES.core.project.Get( required=True), ))], http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch project resource:') return objects[0]
def GetInstances(self, refs): """Fetches instance objects corresponding to the given references.""" instance_get_requests = [] for ref in refs: request_protobuf = self.messages.ComputeInstancesGetRequest( instance=ref.Name(), zone=ref.zone, project=ref.project) instance_get_requests.append( (self.service, 'Get', request_protobuf)) errors = [] instances = list( request_helper.MakeRequests(requests=instance_get_requests, http=self.http, batch_url=self.batch_url, errors=errors)) if errors: utils.RaiseToolException( errors, error_message='Failed to fetch some instances:') return instances
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client resources = holder.resources igm_ref = (instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG. ResolveAsResource)( args, resources, scope_lister=compute_flags.GetDefaultScopeLister(client), ) if igm_ref.Collection() == 'compute.instanceGroupManagers': service = client.apitools_client.instanceGroupManagers request = (client.messages. ComputeInstanceGroupManagersListPerInstanceConfigsRequest)( instanceGroupManager=igm_ref.Name(), project=igm_ref.project, zone=igm_ref.zone, ) elif igm_ref.Collection() == 'compute.regionInstanceGroupManagers': service = client.apitools_client.regionInstanceGroupManagers request = ( client.messages. ComputeRegionInstanceGroupManagersListPerInstanceConfigsRequest)( instanceGroupManager=igm_ref.Name(), project=igm_ref.project, region=igm_ref.region, ) errors = [] results = list( request_helper.MakeRequests( requests=[(service, 'ListPerInstanceConfigs', request)], http=client.apitools_client.http, batch_url=client.batch_url, errors=errors)) if errors: utils.RaiseToolException(errors) return instance_groups_utils.UnwrapResponse(results, 'items')
def Run(self, args): holder = base_classes.ComputeUserAccountsApiHolder(self.ReleaseTrack()) client = holder.client user_refs = [ holder.resources.Parse( user, params={'project': properties.VALUES.core.project.GetOrFail}, collection='clouduseraccounts.users') for user in args.members ] group_refs = [ holder.resources.Parse( group, params={'project': properties.VALUES.core.project.GetOrFail}, collection='clouduseraccounts.groups') for group in args.names ] requests = [] for group_ref in group_refs: for user_ref in user_refs: remove_member = client.MESSAGES_MODULE.GroupsRemoveMemberRequest( users=[user_ref.SelfLink()]) request = (client.MESSAGES_MODULE. ClouduseraccountsGroupsRemoveMemberRequest( project=group_ref.project, groupsRemoveMemberRequest=remove_member, groupName=group_ref.Name())) requests.append((client.groups, 'RemoveMember', request)) errors = [] responses = list( request_helper.MakeRequests( requests=requests, http=client.http, batch_url='https://www.googleapis.com/batch/', errors=errors)) if errors: utils.RaiseToolException(errors, error_message='Could not fetch resource:') return responses
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) refs = self._BACKEND_SERVICE_ARG.ResolveAsResource( args, holder.resources, default_scope=backend_services_utils.GetDefaultScope()) utils.PromptForDeletion(refs) requests = [] for ref in refs: backend_service = client.BackendService( ref, compute_client=holder.client) requests.extend(backend_service.Delete(only_generate_request=True)) errors = [] resources = holder.client.MakeRequests(requests, errors) if errors: utils.RaiseToolException(errors) return resources
def Run(self, args): """Issues requests necessary to wait until stable on a MIG.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client start = time_util.CurrentTimeSec() group_ref = self.CreateGroupReference(client, holder.resources, args) while True: responses, errors = self._GetResources(client, group_ref) if errors: utils.RaiseToolException(errors) if wait_info.IsGroupStable(responses[0]): break log.out.Print(wait_info.CreateWaitText(responses[0])) time_util.Sleep(WaitUntilStable._TIME_BETWEEN_POLLS_SEC) if args.timeout and time_util.CurrentTimeSec() - start > args.timeout: raise utils.TimeoutError('Timeout while waiting for group to become ' 'stable.') log.out.Print('Group is stable')
def Run(self, args): """Retrieves response with instance in the instance group.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client group_ref = (instance_groups_flags. MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.ResolveAsResource( args, holder.resources, default_scope=compute_scope.ScopeEnum.ZONE, scope_lister=flags.GetDefaultScopeLister(client))) if hasattr(group_ref, 'zone'): service = client.apitools_client.instanceGroupManagers request = (client.messages. ComputeInstanceGroupManagersListManagedInstancesRequest( instanceGroupManager=group_ref.Name(), zone=group_ref.zone, project=group_ref.project)) elif hasattr(group_ref, 'region'): service = client.apitools_client.regionInstanceGroupManagers request = ( client.messages. ComputeRegionInstanceGroupManagersListManagedInstancesRequest( instanceGroupManager=group_ref.Name(), region=group_ref.region, project=group_ref.project)) errors = [] results = list( request_helper.MakeRequests(requests=[ (service, 'ListManagedInstances', request) ], http=client.apitools_client.http, batch_url=client.batch_url, errors=errors)) if errors: utils.RaiseToolException(errors) return instance_groups_utils.UnwrapResponse(results, 'managedInstances')
def _MakeRequests(client, requests, is_async): """Helper for making asynchronous or synchronous peering creation requests.""" if is_async: responses, errors = batch_helper.MakeRequests( requests=requests, http=client.apitools_client.http, batch_url=client.batch_url) if not errors: for operation in responses: log.status.write('Creating network peering for [{0}]\n'.format( operation.targetLink)) log.status.write('Monitor its progress at [{0}]\n'.format( operation.selfLink)) else: utils.RaiseToolException(errors) else: # We want to run through the generator that MakeRequests returns in order # to actually make the requests. responses = client.MakeRequests(requests) return responses
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) cua_holder = base_classes.ComputeUserAccountsApiHolder( self.ReleaseTrack()) client = holder.client request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources) errors = [] for item in lister.GetGlobalResourcesDicts( service=cua_holder.client.users, project=list(request_data.scope_set)[0].project, filter_expr=request_data.filter, http=client.apitools_client.http, batch_url='https://www.googleapis.com/batch/', errors=errors): yield item if errors: utils.RaiseToolException(errors)
def Run(self, args): """Returns a list of TargetPoolInstanceHealth objects.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client target_pool_ref = self.TARGET_POOL_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(client)) target_pool = self.GetTargetPool(client, target_pool_ref) instances = target_pool.instances # If the target pool has no instances, we should return an empty # list. if not instances: return requests = [] for instance in instances: request_message = client.messages.ComputeTargetPoolsGetHealthRequest( instanceReference=client.messages.InstanceReference( instance=instance), project=target_pool_ref.project, region=target_pool_ref.region, targetPool=target_pool_ref.Name()) requests.append((client.apitools_client.targetPools, 'GetHealth', request_message)) errors = [] resources = client.MakeRequests( requests=requests, errors_to_collect=errors) for resource in resources: yield resource if errors: utils.RaiseToolException( errors, error_message='Could not get health for some targets:')
def Run(self, args): """Retrieves response with instance in the instance group.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client # Note: only zonal resources parsed here. group_ref = holder.resources.Parse( args.name, params={ 'project': properties.VALUES.core.project.GetOrFail, 'zone': args.zone }, collection='compute.instanceGroups') if args.regexp: filter_expr = 'instance eq {0}'.format(args.regexp) else: filter_expr = None request = client.messages.ComputeInstanceGroupsListInstancesRequest( instanceGroup=group_ref.Name(), instanceGroupsListInstancesRequest=( client.messages.InstanceGroupsListInstancesRequest()), zone=group_ref.zone, filter=filter_expr, project=group_ref.project) errors = [] results = list( request_helper.MakeRequests(requests=[ (client.apitools_client.instanceGroups, 'ListInstances', request) ], http=client.apitools_client.http, batch_url=client.batch_url, errors=errors)) if errors: utils.RaiseToolException(errors) return instance_groups_utils.UnwrapResponse(results, 'items')
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) refs = self.TARGET_TCP_PROXY_ARG.ResolveAsResource( args, holder.resources) utils.PromptForDeletion(refs) client = holder.client.apitools_client messages = holder.client.messages requests = [] for ref in refs: requests.append((client.targetTcpProxies, 'Delete', messages.ComputeTargetTcpProxiesDeleteRequest( project=ref.project, targetTcpProxy=ref.Name()))) errors = [] resources = holder.client.MakeRequests(requests, errors) if errors: utils.RaiseToolException(errors) return resources
def Run(self, args): instance_ref = self.CreateZonalReference(args.name, args.zone) request = (self.compute.instances, 'GetSerialPortOutput', self.messages.ComputeInstancesGetSerialPortOutputRequest( instance=instance_ref.Name(), project=self.project, port=args.port, zone=instance_ref.zone)) errors = [] objects = list( request_helper.MakeRequests(requests=[request], http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch serial port output:') return objects[0].contents
def Run(self, args): request_protobufs = self.CreateRequests(args) requests = [] for request in request_protobufs: requests.append((self.service, self.method, request)) errors = [] if args.async: resources, new_errors = batch_helper.MakeRequests( requests=requests, http=self.http, batch_url=self.batch_url) if not new_errors: for invalidation_operation in resources: log.status.write('Invalidation pending for [{0}]\n'.format( invalidation_operation.targetLink)) log.status.write('Monitor its progress at [{0}]\n'.format( invalidation_operation.selfLink)) errors.extend(new_errors) else: # We want to run through the generator that MakeRequests returns in order # to actually make the requests. resources = list(request_helper.MakeRequests( requests=requests, http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None)) resources = lister.ProcessResults( resources=resources, field_selector=property_selector.PropertySelector( properties=None, transformations=self.transformations)) if errors: utils.RaiseToolException(errors) return resources
def Run(self, args): """Issues requests necessary for adding users.""" holder = base_classes.ComputeUserAccountsApiHolder(self.ReleaseTrack()) client = holder.client owner = args.owner if not owner: owner = gaia.GetAuthenticatedGaiaEmail(client.http) name = args.name if not name: name = gaia.MapGaiaEmailToDefaultAccountName(owner) user_ref = holder.resources.Parse( name, params={'project': properties.VALUES.core.project.GetOrFail}, collection='clouduseraccounts.users') user = client.MESSAGES_MODULE.User( name=user_ref.Name(), description=args.description, owner=owner, ) request = client.MESSAGES_MODULE.ClouduseraccountsUsersInsertRequest( project=user_ref.project, user=user) errors = [] responses = list( request_helper.MakeRequests( requests=[(client.users, 'Insert', request)], http=client.http, batch_url='https://www.googleapis.com/batch/', errors=errors)) if errors: utils.RaiseToolException( errors, error_message='Could not fetch resource:') return responses
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) backend_service_ref = self.BACKEND_SERVICE_ARG.ResolveAsResource( args, holder.resources) target_tcp_proxy_ref = self.TARGET_TCP_PROXY_ARG.ResolveAsResource( args, holder.resources) client = holder.client.apitools_client messages = holder.client.messages if args.proxy_header: proxy_header = messages.TargetTcpProxy.ProxyHeaderValueValuesEnum( args.proxy_header) else: proxy_header = ( messages.TargetTcpProxy.ProxyHeaderValueValuesEnum.NONE) target_tcp_proxy = messages.TargetTcpProxy( description=args.description, name=target_tcp_proxy_ref.Name(), proxyHeader=proxy_header, service=backend_service_ref.SelfLink()) if args.proxy_bind is not None: target_tcp_proxy.proxyBind = args.proxy_bind request = messages.ComputeTargetTcpProxiesInsertRequest( project=target_tcp_proxy_ref.project, targetTcpProxy=target_tcp_proxy) errors = [] resources = holder.client.MakeRequests( [(client.targetTcpProxies, 'Insert', request)], errors) if errors: utils.RaiseToolException(errors) return resources
def Run(self, args): """Returns a list of TargetPoolInstanceHealth objects.""" self.target_pool_ref = self.TARGET_POOL_ARG.ResolveAsResource( args, self.resources, scope_lister=compute_flags.GetDefaultScopeLister( self.compute_client, self.project)) target_pool = self.GetTargetPool() instances = target_pool.instances # If the target pool has no instances, we should return an empty # list. if not instances: return requests = [] for instance in instances: request_message = self.messages.ComputeTargetPoolsGetHealthRequest( instanceReference=self.messages.InstanceReference( instance=instance), project=self.project, region=self.target_pool_ref.region, targetPool=self.target_pool_ref.Name()) requests.append((self.service, 'GetHealth', request_message)) errors = [] resources = request_helper.MakeRequests(requests=requests, http=self.http, batch_url=self.batch_url, errors=errors, custom_get_requests=None) for resource in resources: yield resource if errors: utils.RaiseToolException( errors, error_message='Could not get health for some targets:')