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

   1 #!/usr/bin/env python
   2
   3 from __future__ import absolute_import, print_function
   4
   5 import functools
   6 import json
   7 import time
   8
   9 import libcloud.compute.providers as cloud_provider
  10 import libcloud.compute.types as cloud_types
  11
  12 from . import BaseComputeNodeDriver
  13 from .. import arvados_node_fqdn, arvados_timestamp, ARVADOS_TIMEFMT
  14
  15 class ComputeNodeDriver(BaseComputeNodeDriver):
  16     """Compute node driver wrapper for GCE
  17
  18     This translates cloud driver requests to GCE's specific parameters.
  19     """
  20     DEFAULT_DRIVER = cloud_provider.get_driver(cloud_types.Provider.GCE)
  21     SEARCH_CACHE = {}
  22
  23     def __init__(self, auth_kwargs, list_kwargs, create_kwargs,
  24                  driver_class=DEFAULT_DRIVER):
  25         list_kwargs = list_kwargs.copy()
  26         tags_str = list_kwargs.pop('tags', '')
  27         if not tags_str.strip():
  28             self.node_tags = frozenset()
  29         else:
  30             self.node_tags = frozenset(t.strip() for t in tags_str.split(','))
  31         create_kwargs = create_kwargs.copy()
  32         create_kwargs.setdefault('external_ip', None)
  33         create_kwargs.setdefault('ex_metadata', {})
  34         super(ComputeNodeDriver, self).__init__(
  35             auth_kwargs, list_kwargs, create_kwargs,
  36             driver_class)
  37
  38     @staticmethod
  39     def _name_key(cloud_object):
  40         return cloud_object.name
  41
  42     def _init_image(self, image_name):
  43         return 'image', self.search_for(
  44             image_name, 'list_images', self._name_key)
  45
  46     def _init_location(self, location_name):
  47         return 'location', self.search_for(
  48             location_name, 'list_locations', self._name_key)
  49
  50     def _init_network(self, network_name):
  51         return 'ex_network', self.search_for(
  52             network_name, 'ex_list_networks', self._name_key)
  53
  54     def _init_service_accounts(self, service_accounts_str):
  55         return 'ex_service_accounts', json.loads(service_accounts_str)
  56
  57     def _init_ssh_key(self, filename):
  58         # SSH keys are delivered to GCE nodes via ex_metadata: see
  59         # http://stackoverflow.com/questions/26752617/creating-sshkeys-for-gce-instance-using-libcloud
  60         with open(filename) as ssh_file:
  61             self.create_kwargs['ex_metadata']['sshKeys'] = (
  62                 'root:' + ssh_file.read().strip())
  63
  64     def list_sizes(self):
  65         return super(ComputeNodeDriver, self).list_sizes(
  66             self.create_kwargs['location'])
  67
  68     def arvados_create_kwargs(self, arvados_node):
  69         cluster_id, _, node_id = arvados_node['uuid'].split('-')
  70         result = {'name': 'compute-{}-{}'.format(node_id, cluster_id),
  71                   'ex_metadata': self.create_kwargs['ex_metadata'].copy(),
  72                   'ex_tags': list(self.node_tags)}
  73         result['ex_metadata']['arv-ping-url'] = self._make_ping_url(
  74             arvados_node)
  75         result['ex_metadata']['booted_at'] = time.strftime(ARVADOS_TIMEFMT,
  76                                                            time.gmtime())
  77         result['ex_metadata']['hostname'] = arvados_node_fqdn(arvados_node)
  78         return result
  79
  80     def list_nodes(self):
  81         # The GCE libcloud driver only supports filtering node lists by zone.
  82         # Do our own filtering based on tag list.
  83         return [node for node in
  84                 super(ComputeNodeDriver, self).list_nodes()
  85                 if self.node_tags.issubset(node.extra.get('tags', []))]
  86
  87     def destroy_node(self, cloud_node):
  88         return super(ComputeNodeDriver, self).destroy_node(
  89             cloud_node, destroy_boot_disk=True)
  90
  91     @classmethod
  92     def _find_metadata(cls, metadata_items, key):
  93         # Given a list of two-item metadata dictonaries, return the one with
  94         # the named key.  Raise KeyError if not found.
  95         try:
  96             return next(data_dict for data_dict in metadata_items
  97                         if data_dict.get('key') == key)
  98         except StopIteration:
  99             raise KeyError(key)
 100
 101     @classmethod
 102     def _get_metadata(cls, metadata_items, key, *default):
 103         try:
 104             return cls._find_metadata(metadata_items, key)['value']
 105         except KeyError:
 106             if default:
 107                 return default[0]
 108             raise
 109
 110     def sync_node(self, cloud_node, arvados_node):
 111         hostname = arvados_node_fqdn(arvados_node)
 112         metadata_req = cloud_node.extra['metadata'].copy()
 113         metadata_items = metadata_req.setdefault('items', [])
 114         try:
 115             self._find_metadata(metadata_items, 'hostname')['value'] = hostname
 116         except KeyError:
 117             metadata_items.append({'key': 'hostname', 'value': hostname})
 118         response = self.real.connection.async_request(
 119             '/zones/{}/instances/{}/setMetadata'.format(
 120                 cloud_node.extra['zone'].name, cloud_node.name),
 121             method='POST', data=metadata_req)
 122         if not response.success():
 123             raise Exception("setMetadata error: {}".format(response.error))
 124
 125     @classmethod
 126     def node_start_time(cls, node):
 127         try:
 128             return arvados_timestamp(cls._get_metadata(
 129                     node.extra['metadata']['items'], 'booted_at'))
 130         except KeyError:
 131             return 0