tcr-vagrant-google 0.1.4

data/lib/vagrant-google/action/read_state.rb

@@ -0,0 +1,59 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require "log4r"
+
+module VagrantPlugins
+  module Google
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_google::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:google_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(google, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          zone = machine.provider_config.zone
+          # TODO(erjohnso): not sure why this is necessary, 'server' should be nil
+          begin
+            server = google.servers.get(machine.id, zone)
+          rescue Exception => e
+            @logger.info("TODO: this shouldn't be happening. Call should return nil")
+            @logger.info(e.message)
+            server = nil
+          end
+          if server.nil? || [:"shutting-down", :terminated].include?(server.state.to_sym)
+            # The machine can't be found
+            @logger.info("Machine '#{zone}:#{machine.id}' not found or terminated, assuming it got destroyed.")
+            machine.id = nil
+            return :not_created
+          end
+
+          # Return the state
+          return server.state.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-google/action/run_instance.rb

@@ -0,0 +1,145 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require "log4r"
+require 'vagrant/util/retryable'
+require 'vagrant-google/util/timer'
+
+module VagrantPlugins
+  module Google
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_google::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get the zone we're going to booting up in
+          zone = env[:machine].provider_config.zone
+
+          # Get the configs
+          zone_config        = env[:machine].provider_config.get_zone_config(zone)
+          image              = zone_config.image
+          name               = zone_config.name
+          machine_type       = zone_config.machine_type
+          disk_size          = zone_config.disk_size
+          network            = zone_config.network
+          metadata           = zone_config.metadata
+          tags               = zone_config.tags
+          service_accounts   = zone_config.service_accounts
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_google.launching_instance"))
+          env[:ui].info(" -- Name:      #{name}")
+          env[:ui].info(" -- Type:      #{machine_type}")
+          env[:ui].info(" -- Disk size: #{disk_size} GB")
+          env[:ui].info(" -- Image:     #{image}")
+          env[:ui].info(" -- Zone:      #{zone}") if zone
+          env[:ui].info(" -- Network:   #{network}") if network
+          env[:ui].info(" -- Metadata:  '#{metadata}'")
+          env[:ui].info(" -- Tags:      '#{tags}'")
+          env[:ui].info(" -- Scopes:    #{service_accounts}")
+          begin
+            request_start_time = Time.now().to_i
+            disk = env[:google_compute].disks.create(
+                name: name,
+                size_gb: disk_size,
+                zone_name: zone,
+                source_image: image
+            )
+            disk.wait_for { disk.ready? }
+
+            defaults = {
+              :name               => name,
+              :zone_name          => zone,
+              :machine_type       => machine_type,
+              :disk_size          => disk_size,
+              :image              => image,
+              :network            => network,
+              :metadata           => metadata,
+              :tags               => tags,
+              # Second arg to get_as_boot_disk is 'autodelete_disk', defaulting
+              # to true
+              :disks              => [disk.get_as_boot_disk(true, true)],
+              :service_accounts   => service_accounts,
+            }
+            server = env[:google_compute].servers.create(defaults)
+            @logger.info("Machine '#{zone}:#{name}' created.")
+          rescue Fog::Compute::Google::NotFound => e
+            raise
+          rescue Fog::Compute::Google::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Immediately save the name since the instance has been created
+          env[:machine].id = server.name
+          server.reload
+
+          env[:ui].info(I18n.t("vagrant_google.waiting_for_ready"))
+          begin
+            server.wait_for { ready? }
+            env[:metrics]["instance_ready_time"] = Time.now().to_i - request_start_time
+            @logger.info("Time for instance ready: #{env[:metrics]["instance_ready_time"]}")
+            env[:ui].info(I18n.t("vagrant_google.ready"))
+          rescue
+            env[:interrupted] = true
+          end
+
+          if !env[:terminated]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_google.waiting_for_ssh"))
+              while true
+                # If we're interrupted just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+                sleep 2
+              end
+            end
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+            env[:ui].info(I18n.t("vagrant_google.ready_ssh"))
+          end
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            # Undo the import
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-google/action/sync_folders.rb

@@ -0,0 +1,87 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require "log4r"
+require "vagrant/util/subprocess"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module Google
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Google instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_google::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :google)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            env[:ui].info(I18n.t("vagrant_google.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # patch from https://github.com/tmatilai/vagrant-aws/commit/4a043a96076c332220ec4ec19470c4af5597dd51
+            def ssh_key_options(ssh_info)
+              # Ensure that `private_key_path` is an Array (for Vagrant < 1.4)
+              Array(ssh_info[:private_key_path]).map { |path| "-i '#{path}' " }.join
+            end
+
+            #collect rsync excludes specified :rsync__excludes=>['path1',...] in synced_folder options
+            excludes = ['.vagrant/', *Array(data[:rsync__excludes])]
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              *excludes.map{|e|['--exclude', e]}.flatten,
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{ssh_key_options(ssh_info)}",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-google/action/terminate_instance.rb

@@ -0,0 +1,40 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require "log4r"
+
+module VagrantPlugins
+  module Google
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_google::action::terminate_instance")
+        end
+
+        def call(env)
+          server = env[:google_compute].servers.get(env[:machine].id, env[:machine].provider_config.zone)
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_google.terminating"))
+          server.destroy if not server.nil?
+          server.wait_for { not ready? }
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-google/action/timed_provision.rb

@@ -0,0 +1,34 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require "vagrant-google/util/timer"
+
+module VagrantPlugins
+  module Google
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-google/action/warn_networks.rb

@@ -0,0 +1,32 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+module VagrantPlugins
+  module Google
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_google.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-google/config.rb

@@ -0,0 +1,265 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+require "vagrant"
+
+module VagrantPlugins
+  module Google
+    class Config < Vagrant.plugin("2", :config)
+      # The Service Account Client ID Email address
+      #
+      # @return [String]
+      attr_accessor :google_client_email
+
+      # The path to the Service Account private key
+      #
+      # @return [String]
+      attr_accessor :google_key_location
+
+      # The Google Cloud Project ID (not name or number)
+      #
+      # @return [String]
+      attr_accessor :google_project_id
+
+      # The image name of the instance to use.
+      #
+      # @return [String]
+      attr_accessor :image
+
+      # The type of machine to launch, such as "n1-standard-1"
+      #
+      # @return [String]
+      attr_accessor :machine_type
+
+      # The size of disk in GB
+      #
+      # @return [Int]
+      attr_accessor :disk_size
+
+      # The user metadata string
+      #
+      # @return [Hash<String, String>]
+      attr_accessor :metadata
+
+      # The name of the instance
+      #
+      # @return [String]
+      attr_accessor :name
+
+      # The name of the network
+      #
+      # @return [String]
+      attr_accessor :network
+
+      # Tags to apply to the instance
+      #
+      # @return [Array]
+      attr_accessor :tags
+
+      # The timeout value waiting for instance ready
+      #
+      # @return [Int]
+      attr_accessor :instance_ready_timeout
+
+      # The tags for the machine.
+      # TODO(erjohnso): not supported in fog
+      #
+      # @return [Hash<String, String>]
+      #attr_accessor :tags
+
+      # The zone to launch the instance into. If nil, it will
+      # use the default us-central1-f.
+      #
+      # @return [String]
+      attr_accessor :zone
+
+      # The list of access controls for service accounts.
+      #
+      # @return [Array]
+      attr_accessor :service_accounts
+
+      def initialize(zone_specific=false)
+        @google_client_email = UNSET_VALUE
+        @google_key_location = UNSET_VALUE
+        @google_project_id   = UNSET_VALUE
+        @image               = UNSET_VALUE
+        @machine_type        = UNSET_VALUE
+        @disk_size           = UNSET_VALUE
+        @metadata            = {}
+        @name                = UNSET_VALUE
+        @network             = UNSET_VALUE
+        @tags                = []
+        @instance_ready_timeout = UNSET_VALUE
+        @zone                = UNSET_VALUE
+        @service_accounts    = UNSET_VALUE
+
+        # Internal state (prefix with __ so they aren't automatically
+        # merged)
+        @__compiled_zone_configs = {}
+        @__finalized = false
+        @__zone_config = {}
+        @__zone_specific = zone_specific
+      end
+
+      # Allows zone-specific overrides of any of the settings on this
+      # configuration object. This allows the user to override things like
+      # image and machine type name for zones. Example:
+      #
+      #     google.zone_config "us-central1-f" do |zone|
+      #       zone.image = "debian-7-wheezy-v20140926"
+      #       zone.machine_type = "n1-standard-4"
+      #     end
+      #
+      # @param [String] zone The zone name to configure.
+      # @param [Hash] attributes Direct attributes to set on the configuration
+      #   as a shortcut instead of specifying a full block.
+      # @yield [config] Yields a new Google configuration.
+      def zone_config(zone, attributes=nil, &block)
+        # Append the block to the list of zone configs for that zone.
+        # We'll evaluate these upon finalization.
+        @__zone_config[zone] ||= []
+
+        # Append a block that sets attributes if we got one
+        if attributes
+          attr_block = lambda do |config|
+            config.set_options(attributes)
+          end
+
+          @__zone_config[zone] << attr_block
+        end
+
+        # Append a block if we got one
+        @__zone_config[zone] << block if block_given?
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def merge(other)
+        super.tap do |result|
+          # Copy over the zone specific flag. "True" is retained if either
+          # has it.
+          new_zone_specific = other.instance_variable_get(:@__zone_specific)
+          result.instance_variable_set(
+            :@__zone_specific, new_zone_specific || @__zone_specific)
+
+          # Go through all the zone configs and prepend ours onto
+          # theirs.
+          new_zone_config = other.instance_variable_get(:@__zone_config)
+          @__zone_config.each do |key, value|
+            new_zone_config[key] ||= []
+            new_zone_config[key] = value + new_zone_config[key]
+          end
+
+          # Set it
+          result.instance_variable_set(:@__zone_config, new_zone_config)
+
+          # Merge in the metadata
+          result.metadata.merge!(self.metadata)
+          result.metadata.merge!(other.metadata)
+        end
+      end
+
+      def finalize!
+        # Try to get access keys from standard Google environment variables; they
+        # will default to nil if the environment variables are not present.
+        @google_client_email = ENV['GOOGLE_CLIENT_EMAIL'] if @google_client_email == UNSET_VALUE
+        @google_key_location = ENV['GOOGLE_KEY_LOCATION'] if @google_key_location == UNSET_VALUE
+        @google_project_id   = ENV['GOOGLE_PROJECT_ID'] if @google_project_id == UNSET_VALUE
+
+        # Image must be nil, since we can't default that
+        @image = "debian-7-wheezy-v20140926" if @image == UNSET_VALUE
+
+        # Default instance type is an n1-standard-1
+        @machine_type = "n1-standard-1" if @machine_type == UNSET_VALUE
+
+        # Default disk size is 10 GB
+        @disk_size = 10 if @disk_size == UNSET_VALUE
+
+        # Instance name defaults to a new datetime value (hour granularity)
+        t = Time.now
+        @name = "i-#{t.year}#{t.month.to_s.rjust(2,'0')}#{t.day.to_s.rjust(2,'0')}#{t.hour.to_s.rjust(2,'0')}" if @name == UNSET_VALUE
+
+        # Network defaults to 'default'
+        @network = "default" if @network == UNSET_VALUE
+
+        # Default zone is us-central1-f.
+        @zone = "us-central1-f" if @zone == UNSET_VALUE
+
+        # Default instance_ready_timeout
+        @instance_ready_timeout = 20 if @instance_ready_timeout == UNSET_VALUE
+
+        # Default service_accounts
+        @service_accounts = nil if @service_accounts == UNSET_VALUE
+
+        # Compile our zone specific configurations only within
+        # NON-zone-SPECIFIC configurations.
+        if !@__zone_specific
+          @__zone_config.each do |zone, blocks|
+            config = self.class.new(true).merge(self)
+
+            # Execute the configuration for each block
+            blocks.each { |b| b.call(config) }
+
+            # The zone name of the configuration always equals the
+            # zone config name:
+            config.zone = zone
+
+            # Finalize the configuration
+            config.finalize!
+
+            # Store it for retrieval
+            @__compiled_zone_configs[zone] = config
+          end
+        end
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t("vagrant_google.config.zone_required") if @zone.nil?
+
+        if @zone
+          config = get_zone_config(@zone)
+
+          errors << I18n.t("vagrant_google.config.google_project_id_required") if \
+            config.google_project_id.nil?
+          errors << I18n.t("vagrant_google.config.google_client_email_required") if \
+            config.google_client_email.nil?
+          errors << I18n.t("vagrant_google.config.google_key_location_required") if \
+            config.google_key_location.nil?
+        end
+
+        errors << I18n.t("vagrant_google.config.image_required") if config.image.nil?
+        errors << I18n.t("vagrant_google.config.name_required") if @name.nil?
+
+        { "Google Provider" => errors }
+      end
+
+      # This gets the configuration for a specific zone. It shouldn't
+      # be called by the general public and is only used internally.
+      def get_zone_config(name)
+        if !@__finalized
+          raise "Configuration must be finalized before calling this method."
+        end
+
+        # Return the compiled zone config
+        @__compiled_zone_configs[name] || self
+      end
+    end
+  end
+end