services/nodemanager/arvnodeman/computenode/driver/gce.py

   1 #!/usr/bin/env python
   2 # Copyright (C) The Arvados Authors. All rights reserved.
   3 #
   4 # SPDX-License-Identifier: AGPL-3.0
   5
   6 from __future__ import absolute_import, print_function
   7
   8 import functools
   9 import json
  10 import time
  11
  12 import libcloud.compute.providers as cloud_provider
  13 import libcloud.compute.types as cloud_types
  14
  15 from . import BaseComputeNodeDriver
  16 from .. import arvados_node_fqdn, arvados_timestamp, ARVADOS_TIMEFMT
  17
  18 class ComputeNodeDriver(BaseComputeNodeDriver):
  19     """Compute node driver wrapper for GCE
  20
  21     This translates cloud driver requests to GCE's specific parameters.
  22     """
  23     DEFAULT_DRIVER = cloud_provider.get_driver(cloud_types.Provider.GCE)
  24     SEARCH_CACHE = {}
  25
  26     def __init__(self, auth_kwargs, list_kwargs, create_kwargs,
  27                  driver_class=DEFAULT_DRIVER):
  28         list_kwargs = list_kwargs.copy()
  29         tags_str = list_kwargs.pop('tags', '')
  30         if not tags_str.strip():
  31             self.node_tags = frozenset()
  32         else:
  33             self.node_tags = frozenset(t.strip() for t in tags_str.split(','))
  34         create_kwargs = create_kwargs.copy()
  35         create_kwargs.setdefault('external_ip', None)
  36         create_kwargs.setdefault('ex_metadata', {})
  37         self._project = auth_kwargs.get("project")
  38         super(ComputeNodeDriver, self).__init__(
  39             auth_kwargs, list_kwargs, create_kwargs,
  40             driver_class)
  41         self._sizes_by_id = {sz.id: sz for sz in self.sizes.itervalues()}
  42         self._disktype_links = {dt.name: self._object_link(dt)
  43                                 for dt in self.real.ex_list_disktypes()}
  44
  45     @staticmethod
  46     def _object_link(cloud_object):
  47         return cloud_object.extra.get('selfLink')
  48
  49     def _init_image(self, image_name):
  50         return 'image', self.search_for(
  51             image_name, 'list_images', self._name_key, ex_project=self._project)
  52
  53     def _init_network(self, network_name):
  54         return 'ex_network', self.search_for(
  55             network_name, 'ex_list_networks', self._name_key)
  56
  57     def _init_service_accounts(self, service_accounts_str):
  58         return 'ex_service_accounts', json.loads(service_accounts_str)
  59
  60     def _init_ssh_key(self, filename):
  61         # SSH keys are delivered to GCE nodes via ex_metadata: see
  62         # http://stackoverflow.com/questions/26752617/creating-sshkeys-for-gce-instance-using-libcloud
  63         with open(filename) as ssh_file:
  64             self.create_kwargs['ex_metadata']['sshKeys'] = (
  65                 'root:' + ssh_file.read().strip())
  66
  67     def create_cloud_name(self, arvados_node):
  68         uuid_parts = arvados_node['uuid'].split('-', 2)
  69         return 'compute-{parts[2]}-{parts[0]}'.format(parts=uuid_parts)
  70
  71     def arvados_create_kwargs(self, size, arvados_node):
  72         name = self.create_cloud_name(arvados_node)
  73
  74         if size.scratch > 375000:
  75             self._logger.warning("Requested %d MB scratch space, but GCE driver currently only supports attaching a single 375 GB disk.", size.scratch)
  76
  77         disks = [
  78             {'autoDelete': True,
  79              'boot': True,
  80              'deviceName': name,
  81              'initializeParams':
  82                  {'diskName': name,
  83                   'diskType': self._disktype_links['pd-standard'],
  84                   'sourceImage': self._object_link(self.create_kwargs['image']),
  85                   },
  86              'type': 'PERSISTENT',
  87              },
  88             {'autoDelete': True,
  89              'boot': False,
  90              # Boot images rely on this device name to find the SSD.
  91              # Any change must be coordinated in the image.
  92              'deviceName': 'tmp',
  93              'initializeParams':
  94                  {'diskType': self._disktype_links['local-ssd'],
  95                   },
  96              'type': 'SCRATCH',
  97              },
  98             ]
  99         result = {'name': name,
 100                   'ex_metadata': self.create_kwargs['ex_metadata'].copy(),
 101                   'ex_tags': list(self.node_tags),
 102                   'ex_disks_gce_struct': disks,
 103                   }
 104         result['ex_metadata'].update({
 105             'arvados_node_size': size.id,
 106             'arv-ping-url': self._make_ping_url(arvados_node),
 107             'booted_at': time.strftime(ARVADOS_TIMEFMT, time.gmtime()),
 108             'hostname': arvados_node_fqdn(arvados_node),
 109         })
 110         return result
 111
 112     def list_nodes(self):
 113         # The GCE libcloud driver only supports filtering node lists by zone.
 114         # Do our own filtering based on tag list.
 115         nodelist = [node for node in
 116                     super(ComputeNodeDriver, self).list_nodes()
 117                     if self.node_tags.issubset(node.extra.get('tags', []))]
 118         for node in nodelist:
 119             # As of 0.18, the libcloud GCE driver sets node.size to the size's name.
 120             # It's supposed to be the actual size object.  Check that it's not,
 121             # and monkeypatch the results when that's the case.
 122             if not hasattr(node.size, 'id'):
 123                 node.size = self._sizes_by_id[node.size]
 124             # Get arvados-assigned cloud size id
 125             node.extra['arvados_node_size'] = node.extra.get('metadata', {}).get('arvados_node_size')
 126         return nodelist
 127
 128     @classmethod
 129     def _find_metadata(cls, metadata_items, key):
 130         # Given a list of two-item metadata dictonaries, return the one with
 131         # the named key.  Raise KeyError if not found.
 132         try:
 133             return next(data_dict for data_dict in metadata_items
 134                         if data_dict.get('key') == key)
 135         except StopIteration:
 136             raise KeyError(key)
 137
 138     @classmethod
 139     def _get_metadata(cls, metadata_items, key, *default):
 140         try:
 141             return cls._find_metadata(metadata_items, key)['value']
 142         except KeyError:
 143             if default:
 144                 return default[0]
 145             raise
 146
 147     def sync_node(self, cloud_node, arvados_node):
 148         # Update the cloud node record to ensure we have the correct metadata
 149         # fingerprint.
 150         cloud_node = self.real.ex_get_node(cloud_node.name, cloud_node.extra['zone'])
 151
 152         # We can't store the FQDN on the name attribute or anything like it,
 153         # because (a) names are static throughout the node's life (so FQDN
 154         # isn't available because we don't know it at node creation time) and
 155         # (b) it can't contain dots.  Instead stash it in metadata.
 156         hostname = arvados_node_fqdn(arvados_node)
 157         metadata_req = cloud_node.extra['metadata'].copy()
 158         metadata_items = metadata_req.setdefault('items', [])
 159         try:
 160             self._find_metadata(metadata_items, 'hostname')['value'] = hostname
 161         except KeyError:
 162             metadata_items.append({'key': 'hostname', 'value': hostname})
 163
 164         self.real.ex_set_node_metadata(cloud_node, metadata_items)
 165
 166     @classmethod
 167     def node_fqdn(cls, node):
 168         # See sync_node comment.
 169         return cls._get_metadata(node.extra['metadata'].get('items', []),
 170                                  'hostname', '')
 171
 172     @classmethod
 173     def node_start_time(cls, node):
 174         try:
 175             return arvados_timestamp(cls._get_metadata(
 176                     node.extra['metadata']['items'], 'booted_at'))
 177         except KeyError:
 178             return 0
 179
 180     @classmethod
 181     def node_id(cls, node):
 182         return node.id