chef-provisioning-google 0.1.0

data/lib/chef/provisioning/driver_init/google.rb

@@ -0,0 +1,3 @@
+require "chef/provisioning/google_driver/driver.rb"
+
+Chef::Provisioning.register_driver_class("google", Chef::Provisioning::GoogleDriver::Driver)

data/lib/chef/provisioning/google_driver.rb

@@ -0,0 +1,5 @@
+require "chef/provisioning"
+require "chef/provisioning/google_driver/driver"
+
+require "chef/resource/google_key_pair"
+require "chef/provider/google_key_pair"

data/lib/chef/provisioning/google_driver/client/global_operations.rb

@@ -0,0 +1,18 @@
+require_relative "operations_base"
+
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+        # Wraps a GlobalOperations service of the GCE API.
+        class GlobalOperations < OperationsBase
+
+          def operations_service
+            compute.global_operations
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/google_base.rb

@@ -0,0 +1,72 @@
+require "ffi_yajl"
+require_relative "google_compute_error"
+require_relative "operation"
+
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+        class GoogleBase
+          # TODO make these configurable and find a good place where to put them.
+          TRIES = 30
+          SLEEP_SECONDS = 5
+
+          NOT_FOUND = 404
+          OK = 200
+
+          attr_reader :google, :project, :zone
+
+          def initialize(google, project, zone)
+            @google = google
+            @project = project
+            @zone = zone
+          end
+
+          def make_request(method, parameters = nil, body = nil)
+            response = google.execute(
+              api_method: method,
+              parameters: default_parameters.merge(parameters || {}),
+              body_object: body
+            )
+            {
+              status: response.response.status,
+              body: FFI_Yajl::Parser.parse(response.response.body,
+                                           symbolize_keys: true),
+            }
+          end
+
+          def compute
+            @compute ||= google.discovered_api("compute")
+          end
+
+          def default_parameters
+            { project: project, zone: zone }
+          end
+
+          # Takes the response of an API call and if the response contains an error,
+          # it raises an error. If the response was successful, it returns an
+          # operation.
+          def operation_response(response)
+            raise_if_error(response)
+            Operation.new(response)
+          end
+
+          # Takes a response of an API call and returns true iff this has status not
+          # found.
+          def is_not_found?(response)
+            response[:status] == NOT_FOUND
+          end
+
+          # Takes a response of an API call and raises an error if the call was
+          # unsuccessful.
+          def raise_if_error(response)
+            # TODO Display warnings in some way.
+            if response[:status] != OK || response[:body][:error]
+              raise GoogleComputeError, response
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/google_compute_error.rb

@@ -0,0 +1,16 @@
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+        class GoogleComputeError < StandardError
+
+          def initialize(result)
+            #TODO better error formatting
+            super(result)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/instance.rb

@@ -0,0 +1,64 @@
+require_relative "google_compute_error"
+
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+
+        # Wraps a response of an instances.get request to the GCE API and provides
+        # access to information about the instance.
+        class Instance
+          def initialize(response)
+            @response = response
+          end
+
+          def name
+            @response[:body][:name]
+          end
+
+          def id
+            @response[:body][:id]
+          end
+
+          def status
+            @response[:body][:status]
+          end
+
+          def terminated?
+            status == "TERMINATED"
+          end
+
+          def running?
+            status == "RUNNING"
+          end
+
+          def stopping?
+            status == "STOPPING"
+          end
+
+          def stopped?
+            status == "STOPPED"
+          end
+
+          # TODO right now we assume the host has a accessConfig which is public
+          # https://cloud.google.com/compute/docs/reference/latest/instances#resource
+          def determine_remote_host
+            interfaces = @response[:body][:networkInterfaces]
+            interfaces.each do |i|
+              if i.key?(:accessConfigs)
+                i[:accessConfigs].each do |a|
+                  if a.key?(:natIP)
+                    return a[:natIP]
+                  end
+                end
+              end
+            end
+            raise GoogleComputeError, "Server #{name} has no private or public IP address!"
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/instances.rb

@@ -0,0 +1,98 @@
+require_relative "google_base"
+require_relative "instance"
+require_relative "google_compute_error"
+require "retryable"
+
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+        # Wraps an Instances service of the GCE API.
+        class Instances < GoogleBase
+
+          # Retrieves the instance with the given name.
+          # If the instance doesn't exist, returns nil.
+          def get(name)
+            response = make_request(
+              compute.instances.get,
+              { instance: name }
+            )
+            return nil if is_not_found?(response)
+            raise_if_error(response)
+            Instance.new(response)
+          end
+
+          def create(options = {})
+            response = make_request(
+              compute.instances.insert,
+              nil,
+              options
+            )
+            operation_response(response)
+          end
+
+          def delete(name)
+            response = make_request(
+              compute.instances.delete,
+              { instance: name }
+            )
+            operation_response(response)
+          end
+
+          def start(name)
+            response = make_request(
+              compute.instances.start,
+              { instance: name }
+            )
+            operation_response(response)
+          end
+
+          def stop(name)
+            response = make_request(
+              compute.instances.stop,
+              { instance: name }
+            )
+            operation_response(response)
+          end
+
+          # This returns the minimum set of options needed to create a Google
+          # instance.  It adds required options (like name) to the object.
+          # https://cloud.google.com/compute/docs/instances#startinstanceapi
+          def default_create_options(name)
+            {
+              machineType: "zones/#{zone}/machineTypes/f1-micro",
+              name: name,
+              disks: [{
+                deviceName: name,
+                autoDelete: true,
+                boot: true,
+                initializeParams: {
+                  sourceImage: "projects/ubuntu-os-cloud/global/images/ubuntu-1404-trusty-v20150316",
+                },
+                type: "PERSISTENT",
+              }],
+              networkInterfaces: [{
+                network: "global/networks/default",
+                name: "nic0",
+                accessConfigs: [{
+                  type: "ONE_TO_ONE_NAT",
+                  name: "External NAT",
+                }],
+              }],
+            }
+          end
+
+          def wait_for_status(action_handler, instance, status)
+            Retryable.retryable(tries: TRIES, sleep: SLEEP_SECONDS, matching: /reach status/) do |retries, exception|
+              action_handler.report_progress("  waited #{retries * SLEEP_SECONDS}/#{TRIES * SLEEP_SECONDS}s for instance #{instance.name} to become #{status}")
+              instance = get(instance.name)
+              raise GoogleComputeError, "Instance #{instance.name} didn't reach status #{status} yet." unless instance.status == status
+              instance
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/metadata.rb

@@ -0,0 +1,112 @@
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+
+        # Wraps a response of a projects.get request to the GCE API and provides
+        # access to metadata like SSH keys. It can also be modified and passed
+        # back to the projects client which will set the new metadata by sending
+        # a projects.set_common_instance_metadata request to the GCE API.
+        class Metadata
+          def initialize(response)
+            metadata = response[:body][:commonInstanceMetadata]
+            @fingerprint = metadata[:fingerprint]
+            @items = metadata[:items].dup || []
+            sort_items!
+            @changed = false
+          end
+
+          attr_reader :fingerprint, :items
+
+          # Returns true iff the metadata has been changed since it has been retrieved
+          # from GCE.
+          def changed?
+            @changed
+          end
+
+          # Note that the returned object should not be modified directly.
+          # Instead, set_ssh_key or delete_ssh_key should be used.
+          def ssh_keys
+            @ssh_keys ||= parse_keys(get_metadata_item(SSH_KEYS))
+          end
+
+          # Ensure the list of keys stored in GCE contains the provided key.  If
+          # the provided key already exists it will be updated
+          # TODO: This will need to be updated later with user accounts:
+          # see https://cloud.google.com/compute/docs/access/user-accounts/
+          def ensure_key(username, local_key)
+            ssh_keys << [username, local_key]
+            set_metadata_item(SSH_KEYS, serialize_keys(ssh_keys))
+          end
+
+          # Deletes an ssh key by value, i.e. by the SSH key.
+          def delete_ssh_key(value)
+            ssh_keys.reject! { |k, v| v == value }
+            set_metadata_item(SSH_KEYS, serialize_keys(ssh_keys))
+          end
+
+          # We store the mapping of resource name to key value in GCE so we can tell
+          # if a key has changed.
+          # Note that the returned object should not be modified directly.
+          # Instead, set_ssh_mapping or delete_ssh_mapping should be used.
+          def ssh_mappings
+            @ssh_mappings ||= Hash[parse_keys(get_metadata_item(SSH_MAPPINGS))]
+          end
+
+          def set_ssh_mapping(name, local_key)
+            # TODO what if users change the name of the resource but not the key
+            # should we remove the old entry from both mappings?
+            ssh_mappings[name] = local_key
+            set_metadata_item(SSH_MAPPINGS, serialize_keys(ssh_mappings))
+          end
+
+          def delete_ssh_mapping(name)
+            ssh_mappings.delete(name)
+            set_metadata_item(SSH_MAPPINGS, serialize_keys(ssh_mappings))
+          end
+
+          private
+
+          def set_metadata_item(key, value)
+            @items.delete_if { |m| m[:key] == key }
+            @items << { key: key,  value: value }
+            sort_items!
+            @changed = true
+          end
+
+          def sort_items!
+            @items.sort_by! { |a| a[:key] }
+          end
+
+          # Gets one metadata item with the given key.
+          def get_metadata_item(key)
+            @items.find { |item| item[:key] == key }[:value]
+          end
+
+          SSH_KEYS = "sshKeys"
+          SSH_MAPPINGS = "chef-provisioning-google_ssh-mappings"
+          KEY_VALUE_SEPARATOR = ":"
+          ITEM_SEPARATOR = "\n"
+
+          # Serializes SSH keys or SSH key mappings into a string.
+          # This works both for a hash map or an array of pairs.
+          def serialize_keys(keys)
+            keys.map { |e| e.join(KEY_VALUE_SEPARATOR) }.join(ITEM_SEPARATOR)
+          end
+
+          # Parses SSH keys or SSH key mappings from a string.
+          # This returns an array of pairs. If a hash_map is needed, Hash[] can be
+          # called on the result.
+          def parse_keys(keys_string)
+            return [] if keys_string.nil?
+            keys_string.split(ITEM_SEPARATOR).map do |line|
+              line.split(KEY_VALUE_SEPARATOR, 2)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/operation.rb

@@ -0,0 +1,23 @@
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+        class Operation
+
+          def initialize(response)
+            @response = response
+          end
+
+          def name
+            @response[:body][:name]
+          end
+
+          def done?
+            @response[:body][:status] == "DONE"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/chef/provisioning/google_driver/client/operations_base.rb

@@ -0,0 +1,44 @@
+require_relative "google_base"
+require_relative "operation"
+require_relative "google_compute_error"
+require "retryable"
+
+class Chef
+  module Provisioning
+    module GoogleDriver
+      module Client
+        class OperationsBase < GoogleBase
+
+          # The operations service that should be used,
+          # i.e. global_operations or zone_operations.
+          def operations_service
+            raise NotImplementedError
+          end
+
+          def get(operation)
+            response = make_request(
+              operations_service.get,
+              { operation: operation.name }
+            )
+            operation_response(response)
+          end
+
+          def wait_for_done(action_handler, operation)
+            Retryable.retryable(:tries => TRIES, :sleep => SLEEP_SECONDS, :matching => /not be completed/) do |retries, exception|
+              # TODO the operation name isn't useful output
+              action_handler.report_progress("  waited #{retries * SLEEP_SECONDS}/#{TRIES * SLEEP_SECONDS}s for operation #{operation.name} to complete")
+              # TODO it is really awesome that there are 3 types of operations, and the only way of telling
+              # which is which is to parse the full `:selfLink` from the response body.  Update this method
+              # to take the full operation response from Google so it can tell which operation endpoint
+              # to hit
+              response_operation = get(operation)
+              raise GoogleComputeError, "Operation #{operation.name} could not be completed." unless response_operation.done?
+              response_operation
+            end
+          end
+
+        end
+      end
+    end
+  end
+end