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/(.*)', self.self_link)
 56    if result:
 57      return result.group(1)
 58    else:
 59      return f'>> {self.self_link}'
 60
 61  @property
 62  def short_path(self) -> str:
 63    path = self.project_id + '/' + self.name
 64    return path
 65
 66  @property
 67  def name(self) -> str:
 68    return self._resource_data['name']
 69
 70  @property
 71  def tags(self) -> List[str]:
 72    return self._resource_data['properties'].get('tags', {}).get('items', [])
 73
 74  @property
 75  def service_account(self) -> Optional[str]:
 76    sa_list = self._resource_data['properties'].get('serviceAccounts', [])
 77    if not sa_list:
 78      return None
 79    email = sa_list[0]['email']
 80    if email == 'default':
 81      project_nr = crm.get_project(self._project_id).number
 82      return f'{project_nr}-compute@developer.gserviceaccount.com'
 83    return email
 84
 85  @property
 86  def network(self) -> network_q.Network:
 87    return network_q.get_network_from_url(
 88      self._resource_data['properties']['networkInterfaces'][0]['network']
 89    )
 90
 91  @property
 92  def subnetwork(self) -> network_q.Subnetwork:
 93    subnet_url = self._resource_data['properties']['networkInterfaces'][0]['subnetwork']
 94    return self.network.subnetworks[subnet_url]
 95
 96  def get_metadata(self, key: str) -> str:
 97    for item in self._resource_data['properties']['metadata']['items']:
 98      if item['key'] == key:
 99        return item['value']
100    return ''

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

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

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

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