gcpdiag.queries.gce

 40class InstanceTemplate(models.Resource):
 41  """Represents a GCE Instance Template."""
 42
 43  _resource_data: dict
 44
 45  def __init__(self, project_id, resource_data):
 46    super().__init__(project_id=project_id)
 47    self._resource_data = resource_data
 48
 49  @property
 50  def self_link(self) -> str:
 51    return self._resource_data['selfLink']
 52
 53  @property
 54  def full_path(self) -> str:
 55    result = re.match(r'https://www.googleapis.com/compute/v1/(.*)',
 56                      self.self_link)
 57    if result:
 58      return result.group(1)
 59    else:
 60      return f'>> {self.self_link}'
 61
 62  @property
 63  def short_path(self) -> str:
 64    path = self.project_id + '/' + self.name
 65    return path
 66
 67  @property
 68  def name(self) -> str:
 69    return self._resource_data['name']
 70
 71  @property
 72  def tags(self) -> List[str]:
 73    return self._resource_data['properties'].get('tags', {}).get('items', [])
 74
 75  @property
 76  def service_account(self) -> Optional[str]:
 77    sa_list = self._resource_data['properties'].get('serviceAccounts', [])
 78    if not sa_list:
 79      return None
 80    email = sa_list[0]['email']
 81    if email == 'default':
 82      project_nr = crm.get_project(self._project_id).number
 83      return f'{project_nr}-compute@developer.gserviceaccount.com'
 84    return email
 85
 86  @property
 87  def network(self) -> network_q.Network:
 88    return network_q.get_network_from_url(
 89        self._resource_data['properties']['networkInterfaces'][0]['network'])
 90
 91  @property
 92  def subnetwork(self) -> network_q.Subnetwork:
 93    subnet_url = self._resource_data['properties']['networkInterfaces'][0][
 94        'subnetwork']
 95    return self.network.subnetworks[subnet_url]
 96
 97  def get_metadata(self, key: str) -> str:
 98    for item in self._resource_data['properties']['metadata']['items']:
 99      if item['key'] == key:
100        return item['value']
101    return ''

104class InstanceGroup(models.Resource):
105  """Represents a GCE instance group."""
106
107  _resource_data: dict
108
109  def __init__(self, project_id, resource_data):
110    super().__init__(project_id=project_id)
111    self._resource_data = resource_data
112
113  @property
114  def full_path(self) -> str:
115    result = re.match(
116        r'https://www.googleapis.com/compute/v1/(.*)',
117        self._resource_data['selfLink'],
118    )
119    if result:
120      return result.group(1)
121    else:
122      return '>> ' + self._resource_data['selfLink']
123
124  @property
125  def short_path(self) -> str:
126    path = self.project_id + '/' + self.name
127    return path
128
129  @property
130  def self_link(self) -> str:
131    return self._resource_data['selfLink']
132
133  @property
134  def name(self) -> str:
135    return self._resource_data['name']
136
137  @property
138  def named_ports(self) -> List[dict]:
139    if 'namedPorts' in self._resource_data:
140      return self._resource_data['namedPorts']
141    return []
142
143  def has_named_ports(self) -> bool:
144    if 'namedPorts' in self._resource_data:
145      return True
146    return False

149class ManagedInstanceGroup(models.Resource):
150  """Represents a GCE managed instance group."""
151
152  _resource_data: dict
153  _region: Optional[str]
154
155  def __init__(self, project_id, resource_data):
156    super().__init__(project_id=project_id)
157    self._resource_data = resource_data
158    self._region = None
159
160  @property
161  def full_path(self) -> str:
162    result = re.match(
163        r'https://www.googleapis.com/compute/v1/(.*)',
164        self._resource_data['selfLink'],
165    )
166    if result:
167      return result.group(1)
168    else:
169      return '>> ' + self._resource_data['selfLink']
170
171  @property
172  def short_path(self) -> str:
173    path = self.project_id + '/' + self.name
174    return path
175
176  def is_gke(self) -> bool:
177    """Is this managed instance group part of a GKE cluster?
178
179    Note that the results are based on heuristics (the mig name),
180    which is not ideal.
181
182    Returns:
183        bool: True if this managed instance group is part of a GKE cluster.
184    """
185
186    # gke- is normal GKE, gk3- is GKE autopilot
187    return self.name.startswith('gke-') or self.name.startswith('gk3-')
188
189  @property
190  def self_link(self) -> str:
191    return self._resource_data['selfLink']
192
193  @property
194  def name(self) -> str:
195    return self._resource_data['name']
196
197  @property
198  def region(self) -> str:
199    if self._region is None:
200      if 'region' in self._resource_data:
201        m = re.search(r'/regions/([^/]+)$', self._resource_data['region'])
202        if not m:
203          raise RuntimeError("can't determine region of mig %s (%s)" %
204                             (self.name, self._resource_data['region']))
205        self._region = m.group(1)
206      elif 'zone' in self._resource_data:
207        m = re.search(r'/zones/([^/]+)$', self._resource_data['zone'])
208        if not m:
209          raise RuntimeError("can't determine region of mig %s (%s)" %
210                             (self.name, self._resource_data['region']))
211        zone = m.group(1)
212        self._region = utils.zone_region(zone)
213      else:
214        raise RuntimeError(
215            f"can't determine region of mig {self.name}, both region and zone"
216            " aren't set!")
217    return self._region
218
219  @property
220  def zone(self) -> Optional[str]:
221    if 'zone' in self._resource_data:
222      m = re.search(r'/zones/([^/]+)$', self._resource_data['zone'])
223      if not m:
224        raise RuntimeError("can't determine zone of mig %s (%s)" %
225                           (self.name, self._resource_data['zone']))
226      return m.group(1)
227    return None
228
229  def count_no_action_instances(self) -> int:
230    """number of instances in the mig that are running and have no scheduled actions."""
231    return self._resource_data['currentActions']['none']
232
233  def is_instance_member(self, project_id: str, region: str,
234                         instance_name: str):
235    """Given the project_id, region and instance name, is it a member of this MIG?"""
236    return (self.project_id == project_id and self.region == region and
237            instance_name.startswith(self._resource_data['baseInstanceName']))
238
239  @property
240  def template(self) -> InstanceTemplate:
241    if 'instanceTemplate' not in self._resource_data:
242      raise RuntimeError('instanceTemplate not set for MIG {self.name}')
243
244    m = re.match(
245        r'https://www.googleapis.com/compute/v1/(.*)',
246        self._resource_data['instanceTemplate'],
247    )
248
249    if not m:
250      raise RuntimeError("can't parse instanceTemplate: %s" %
251                         self._resource_data['instanceTemplate'])
252    template_self_link = m.group(1)
253    templates = get_instance_templates(self.project_id)
254    if template_self_link not in templates:
255      raise RuntimeError(
256          f'instanceTemplate {template_self_link} for MIG {self.name} not found'
257      )
258    return templates[template_self_link]
259
260  @property
261  def version_target_reached(self) -> bool:
262    return get_path(self._resource_data,
263                    ('status', 'versionTarget', 'isReached'))
264
265  def get(self, path: str, default: Any = None) -> Any:
266    """Gets a value from resource_data using a dot-separated path."""
267    return get_path(self._resource_data,
268                    tuple(path.split('.')),
269                    default=default)

272class Autoscaler(models.Resource):
273  """Represents a GCE Autoscaler."""
274
275  _resource_data: dict
276
277  def __init__(self, project_id, resource_data):
278    super().__init__(project_id=project_id)
279    self._resource_data = resource_data
280
281  @property
282  def self_link(self) -> str:
283    return self._resource_data['selfLink']
284
285  @property
286  def full_path(self) -> str:
287    result = re.match(r'https://www.googleapis.com/compute/v1/(.*)',
288                      self.self_link)
289    if result:
290      return result.group(1)
291    else:
292      return f'>> {self.self_link}'
293
294  @property
295  def name(self) -> str:
296    return self._resource_data['name']
297
298  def get(self, path: str, default: Any = None) -> Any:
299    """Gets a value from resource_data using a dot-separated path."""
300    return get_path(self._resource_data,
301                    tuple(path.split('.')),
302                    default=default)

305class SerialPortOutput:
306  """Represents the full Serial Port Output (/dev/ttyS0 or COM1) of an instance.
307
308  contents is the full 1MB of the instance.
309  """
310
311  _project_id: str
312  _instance_id: str
313  _contents: List[str]
314
315  def __init__(self, project_id, instance_id, contents):
316    self._project_id = project_id
317    self._instance_id = instance_id
318    self._contents = contents
319
320  @property
321  def contents(self) -> List[str]:
322    return self._contents
323
324  @property
325  def instance_id(self) -> str:
326    return self._instance_id

329class Instance(models.Resource):
330  """Represents a GCE instance."""
331
332  _resource_data: dict
333  _region: Optional[str]
334
335  def __init__(self, project_id, resource_data):
336    super().__init__(project_id=project_id)
337    self._resource_data = resource_data
338    self._metadata_dict = None
339    self._region = None
340
341  @property
342  def id(self) -> str:
343    return self._resource_data['id']
344
345  @property
346  def name(self) -> str:
347    return self._resource_data['name']
348
349  @property
350  def full_path(self) -> str:
351    result = re.match(
352        r'https://www.googleapis.com/compute/v1/(.*)',
353        self._resource_data['selfLink'],
354    )
355    if result:
356      return result.group(1)
357    else:
358      return '>> ' + self._resource_data['selfLink']
359
360  @property
361  def short_path(self) -> str:
362    # Note: instance names must be unique per project,
363    # so no need to add the zone.
364    path = self.project_id + '/' + self.name
365    return path
366
367  @property
368  def creation_timestamp(self) -> datetime:
369    """VM creation time, as a *naive* `datetime` object."""
370    return (datetime.fromisoformat(
371        self._resource_data['creationTimestamp']).astimezone(
372            timezone.utc).replace(tzinfo=None))
373
374  @property
375  def region(self) -> str:
376    if self._region is None:
377      if 'zone' in self._resource_data:
378        m = re.search(r'/zones/([^/]+)$', self._resource_data['zone'])
379        if not m:
380          raise RuntimeError("can't determine region of instance %s (%s)" %
381                             (self.name, self._resource_data['region']))
382        zone = m.group(1)
383        self._region = utils.zone_region(zone)
384      else:
385        raise RuntimeError(
386            f"can't determine region of instance {self.name}, zone isn't set!")
387    return self._region
388
389  @property
390  def zone(self) -> str:
391    zone_uri = self._resource_data['zone']
392    m = re.search(r'/zones/([^/]+)$', zone_uri)
393    if m:
394      return m.group(1)
395    else:
396      raise RuntimeError(f"can't determine zone of instance {self.name}")
397
398  @property
399  def disks(self) -> List[dict]:
400    if 'disks' in self._resource_data:
401      return self._resource_data['disks']
402    return []
403
404  @property
405  def boot_disk_licenses(self) -> List[str]:
406    """Returns license names associated with boot disk."""
407    for disk in self.disks:
408      if disk.get('boot'):
409        return [
410            l.partition('/global/licenses/')[2]
411            for l in disk.get('licenses', [])
412        ]
413    return []
414
415  @property
416  def guest_os_features(self) -> List[str]:
417    """Returns guestOsFeatures types associated with boot disk."""
418    for disk in self.disks:
419      if disk.get('boot'):
420        return [f['type'] for f in disk.get('guestOsFeatures', [])]
421    return []
422
423  @property
424  def startrestricted(self) -> bool:
425    return self._resource_data['startRestricted']
426
427  def laststarttimestamp(self) -> str:
428    return self._resource_data['lastStartTimestamp']
429
430  def laststoptimestamp(self) -> str:
431    if 'lastStopTimestamp' in self._resource_data:
432      return self._resource_data['lastStopTimestamp']
433    return ''
434
435  def is_serial_port_logging_enabled(self) -> bool:
436    value = self.get_metadata('serial-port-logging-enable')
437    return bool(value and value.upper() in POSITIVE_BOOL_VALUES)
438
439  def is_oslogin_enabled(self) -> bool:
440    value = self.get_metadata('enable-oslogin')
441    return bool(value and value.upper() in POSITIVE_BOOL_VALUES)
442
443  def is_metadata_enabled(self, metadata_name) -> bool:
444    """Use to check for common boolean metadata value"""
445    value = self.get_metadata(metadata_name)
446    return bool(value and value.upper() in POSITIVE_BOOL_VALUES)
447
448  def has_label(self, label) -> bool:
449    return label in self.labels
450
451  def is_dataproc_instance(self) -> bool:
452    return self.has_label(DATAPROC_LABEL)
453
454  def is_gke_node(self) -> bool:
455    return self.has_label(GKE_LABEL)
456
457  @property
458  def is_preemptible_vm(self) -> bool:
459    return ('scheduling' in self._resource_data and
460            'preemptible' in self._resource_data['scheduling'] and
461            self._resource_data['scheduling']['preemptible'])
462
463  def min_cpu_platform(self) -> str:
464    if 'minCpuPlatform' in self._resource_data:
465      return self._resource_data['minCpuPlatform']
466    return 'None'
467
468  @property
469  def created_by_mig(self) -> bool:
470    """Return bool indicating if the instance part of a mig.
471
472    MIG which were part of MIG however have been removed or terminated will
473    return True.
474    """
475    created_by = self.get_metadata('created-by')
476    if created_by is None:
477      return False
478
479    created_by_match = re.match(
480        r'projects/([^/]+)/((?:regions|zones)/[^/]+/instanceGroupManagers/[^/]+)$',
481        created_by,
482    )
483    if not created_by_match:
484      return False
485    return True
486
487  def is_windows_machine(self) -> bool:
488    if 'disks' in self._resource_data:
489      disks = next(iter(self._resource_data['disks']))
490      if 'guestOsFeatures' in disks:
491        if 'WINDOWS' in [t['type'] for t in iter(disks['guestOsFeatures'])]:
492          return True
493    return False
494
495  def is_public_machine(self) -> bool:
496    if 'networkInterfaces' in self._resource_data:
497      return 'natIP' in str(self._resource_data['networkInterfaces'])
498    return False
499
500  def machine_type(self):
501    if 'machineType' in self._resource_data:
502      # return self._resource_data['machineType']
503      machine_type_uri = self._resource_data['machineType']
504      mt = re.search(r'/machineTypes/([^/]+)$', machine_type_uri)
505      if mt:
506        return mt.group(1)
507      else:
508        raise RuntimeError(
509            f"can't determine machineType of instance {self.name}")
510    return None
511
512  def check_license(self, licenses: List[str]) -> bool:
513    """Checks that a license is contained in a given license list."""
514    if 'disks' in self._resource_data:
515      for disk in self._resource_data['disks']:
516        if 'license' in str(disk):
517          for license_ in licenses:
518            for attached_license in disk['licenses']:
519              if license_ == attached_license.partition('/global/licenses/')[2]:
520                return True
521    return False
522
523  def get_boot_disk_image(self) -> str:
524    """Get VM's boot disk image."""
525    boot_disk_image: str = ''
526    for disk in self.disks:
527      if disk.get('boot', False):
528        disk_source = disk.get('source', '')
529        m = re.search(r'/disks/([^/]+)$', disk_source)
530        if not m:
531          raise RuntimeError(f"can't determine name of boot disk {disk_source}")
532        disk_name = m.group(1)
533        gce_disk: Disk = get_disk(self.project_id,
534                                  zone=self.zone,
535                                  disk_name=disk_name)
536        return gce_disk.source_image
537    return boot_disk_image
538
539  @property
540  def is_sole_tenant_vm(self) -> bool:
541    return bool('nodeAffinities' in self._resource_data['scheduling'])
542
543  @property
544  def network(self) -> network_q.Network:
545    # 'https://www.googleapis.com/compute/v1/projects/gcpdiag-gce1-aaaa/global/networks/default'
546    network_string = self._resource_data['networkInterfaces'][0]['network']
547    m = re.match(r'^.+/projects/([^/]+)/global/networks/([^/]+)$',
548                 network_string)
549    if not m:
550      raise RuntimeError("can't parse network string: %s" % network_string)
551    return network_q.get_network(m.group(1),
552                                 m.group(2),
553                                 context=models.Context(project_id=m.group(1)))
554
555  @property
556  def network_ips(self) -> List[network_q.IPv4AddrOrIPv6Addr]:
557    return [
558        ipaddress.ip_address(nic['networkIP'])
559        for nic in self._resource_data['networkInterfaces']
560    ]
561
562  @property
563  def get_network_interfaces(self):
564    return self._resource_data['networkInterfaces']
565
566  @property
567  def subnetworks(self) -> List[network_q.Subnetwork]:
568    subnetworks = []
569    for nic in self._resource_data['networkInterfaces']:
570      subnetworks.append(network_q.get_subnetwork_from_url(nic['subnetwork']))
571    return subnetworks
572
573  @property
574  def routes(self) -> List[network_q.Route]:
575    routes = []
576    for nic in self._resource_data['networkInterfaces']:
577      for route in network_q.get_routes(self.project_id):
578        if nic['network'] == route.network:
579          if route.tags == []:
580            routes.append(route)
581            continue
582          else:
583            temp = [x for x in self.tags if x in route.tags]
584            if len(temp) > 0:
585              routes.append(route)
586    return routes
587
588  def get_network_ip_for_instance_interface(
589      self, network: str) -> Optional[network_q.IPv4NetOrIPv6Net]:
590    """Get the network ip for a nic given a network name."""
591    for nic in self._resource_data['networkInterfaces']:
592      if nic.get('network') == network:
593        return ipaddress.ip_network(nic.get('networkIP'))
594    return None
595
596  def secure_boot_enabled(self) -> bool:
597    if 'shieldedInstanceConfig' in self._resource_data:
598      return self._resource_data['shieldedInstanceConfig']['enableSecureBoot']
599    return False
600
601  @property
602  def access_scopes(self) -> List[str]:
603    if 'serviceAccounts' in self._resource_data:
604      saccts = self._resource_data['serviceAccounts']
605      if isinstance(saccts, list) and len(saccts) >= 1:
606        return saccts[0].get('scopes', [])
607    return []
608
609  @property
610  def service_account(self) -> Optional[str]:
611    if 'serviceAccounts' in self._resource_data:
612      saccts = self._resource_data['serviceAccounts']
613      if isinstance(saccts, list) and len(saccts) >= 1:
614        return saccts[0]['email']
615    return None
616
617  @property
618  def tags(self) -> List[str]:
619    if 'tags' in self._resource_data:
620      if 'items' in self._resource_data['tags']:
621        return self._resource_data['tags']['items']
622    return []
623
624  def get_metadata(self, key: str) -> str:
625    if not self._metadata_dict:
626      self._metadata_dict = {}
627      if ('metadata' in self._resource_data and
628          'items' in self._resource_data['metadata']):
629        for item in self._resource_data['metadata']['items']:
630          if 'key' in item and 'value' in item:
631            self._metadata_dict[item['key']] = item['value']
632    project_metadata = get_project_metadata(self.project_id)
633    return self._metadata_dict.get(key, project_metadata.get(key))
634
635  @property
636  def status(self) -> str:
637    """VM Status."""
638    return self._resource_data.get('status', None)
639
640  @property
641  def is_running(self) -> bool:
642    """VM Status is indicated as running."""
643    return self._resource_data.get('status', False) == 'RUNNING'
644
645  @property
646  def network_interface_count(self) -> int:
647    """Returns the number of network interfaces attached to the instance."""
648    return len(self._resource_data.get('networkInterfaces', []))
649
650  @property  # type: ignore
651  @caching.cached_api_call(in_memory=True)
652  def mig(self) -> ManagedInstanceGroup:
653    """Return ManagedInstanceGroup that owns this instance.
654
655    Throws AttributeError in case it isn't MIG-managed.
656    """
657
658    created_by = self.get_metadata('created-by')
659    if created_by is None:
660      raise AttributeError(f'instance {self.id} is not managed by a mig')
661
662    # Example created-by:
663    # pylint: disable=line-too-long
664    # "projects/12340002/zones/europe-west4-a/instanceGroupManagers/gke-gke1-default-pool-e5e20a34-grp"
665    # (note how it uses a project number and not a project id...)
666    created_by_match = re.match(
667        r'projects/([^/]+)/((?:regions|zones)/[^/]+/instanceGroupManagers/[^/]+)$',
668        created_by,
669    )
670    if not created_by_match:
671      raise AttributeError(f'instance {self.id} is not managed by a mig'
672                           f' (created-by={created_by})')
673    project = crm.get_project(created_by_match.group(1))
674
675    mig_self_link = ('https://www.googleapis.com/compute/v1/'
676                     f'projects/{project.id}/{created_by_match.group(2)}')
677
678    # Try to find a matching mig.
679    context = models.Context(project_id=self.project_id)
680    all_migs = list(get_managed_instance_groups(context).values()) + list(
681        get_region_managed_instance_groups(context).values())
682
683    for mig in all_migs:
684      if mig.self_link == mig_self_link:
685        return mig
686
687    raise AttributeError(f'MIG not found for instance {self.id}. '
688                         f'Created by: {created_by}')
689
690  @property
691  def labels(self) -> dict:
692    return self._resource_data.get('labels', {})