vagrant-tiktalik 0.0.1

data/lib/vagrant-tiktalik/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class IsCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/message_already_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      class MessageAlreadyCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_tiktalik.already_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/message_not_created.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      class MessageNotCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_tiktalik.not_created"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_tiktalik.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/power_off.rb

@@ -0,0 +1,31 @@
+require "log4r"
+
+require "tiktalik"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      class PowerOff
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_tiktalik::action::power_off")
+          @config = env[:machine].provider_config
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_tiktalik.powering_off"))
+
+          t = Tiktalik
+          t.api_key = @config.api_key
+          t.api_secret_key = @config.api_secret
+
+          i = Tiktalik::Computing::Instance
+          instance = i.find env[:machine].id
+          instance.stop
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/power_on.rb

@@ -0,0 +1,33 @@
+require "log4r"
+
+require "tiktalik"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      class PowerOn
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_tiktalik::action::power_on")
+          @config = env[:machine].provider_config
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_tiktalik.powering_on"))
+
+          t = Tiktalik
+          t.api_key = @config.api_key
+          t.api_secret_key = @config.api_secret
+
+          i = Tiktalik::Computing::Instance
+          instance = i.find env[:machine].id
+          instance.start
+
+          env[:machine].id = instance.uuid
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-tiktalik/action/read_ssh_info.rb

@@ -0,0 +1,53 @@
+require "log4r"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      # This action reads the SSH info for the machine and puts it into the
+      # `:machine_ssh_info` key in the environment.
+      class ReadSSHInfo
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_tiktalik::action::read_ssh_info")
+          @config = env[:machine].provider_config
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(machine)
+          return nil if machine.id.nil?
+
+          t = Tiktalik
+          t.api_key = @config.api_key
+          t.api_secret_key = @config.api_secret
+
+          i = Tiktalik::Computing::Instance
+          instance = i.find machine.id
+
+          if instance.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          ip = nil
+          instance.interfaces.each do |iface|
+            ip = iface.ip if iface.network.public == true
+          end
+
+          # Read the DNS info
+          return {
+            :host => ip,
+            :port => 22,
+            :username => "root"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require "log4r"
+require 'time'
+
+require "tiktalik"
+#require "tiktalik/computing/instance"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    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_tiktalik::action::read_state")
+          @config = env[:machine].provider_config
+        end
+
+        def call(env)
+          t = Tiktalik
+          t.api_key = @config.api_key
+          t.api_secret_key = @config.api_secret
+
+          env[:machine_state_id] = :not_created
+
+          hostname = env[:machine].config.vm.hostname || env[:machine].name
+
+          i = Tiktalik::Computing::Instance
+          instances = i.all
+          instances.each do |instance|
+            if instance.hostname == hostname.to_s
+              env[:machine].id = instance.uuid if env[:machine].id.nil?
+              case instance.state
+                when 12
+                  if instance.running
+                    env[:machine_state_id] = :running
+                  else
+                    env[:machine_state_id] = :stopped
+                  end
+                else
+                  env[:machine_state_id] = :pending
+              end
+              break
+            end
+          end
+
+          @app.call(env)
+        end
+
+        #def read_state(env)
+        #  return :not_created if machine.id.nil?
+        #
+        #  # Find the machine
+        #  server = aws.servers.get(machine.id)
+        #  if server.nil? || [:"shutting-down", :terminated].include?(server.state.to_sym)
+        #    # The machine can't be found
+        #    @logger.info("Machine 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-tiktalik/action/run_instance.rb

@@ -0,0 +1,133 @@
+require "log4r"
+require 'vagrant/util/retryable'
+require 'vagrant-tiktalik/util/timer'
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_tiktalik::action::run_instance")
+          @config = env[:machine].provider_config
+        end
+
+        def call(env)
+          image = @config.image
+          hostname = env[:machine].config.vm.hostname || env[:machine].name
+          size = @config.size
+          ssh_key = @config.ssh_key
+
+          # If there is no keypair then warn the user
+          #if !keypair
+          #  env[:ui].warn(I18n.t("vagrant_tiktalik.launch_no_keypair"))
+          #end
+
+          # If there is a subnet ID then warn the user
+          #if subnet_id
+          #  env[:ui].warn(I18n.t("vagrant_tiktalik.launch_vpc_warning"))
+          #end
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_tiktalik.launching_instance"))
+          env[:ui].info(" -- Image: #{image}")
+          env[:ui].info(" -- Hostname: #{hostname}")
+          env[:ui].info(" -- Size: #{size}")
+          env[:ui].info(" -- SSH key: #{ssh_key}")
+
+          #env[:ui].info(" -- Security Groups: #{security_groups.inspect}") if !security_groups.empty?
+
+          t = Tiktalik
+          t.api_key = @config.api_key
+          t.api_secret_key = @config.api_secret
+
+          begin
+            networks = []
+
+            n = Tiktalik::Computing::Network
+            n.all.each do |network|
+              (networks.push network.uuid.to_s) if network.public
+              break if network.public
+            end
+
+            env[:ui].info(" -- Networks: #{networks}")
+
+            options = {
+              :image_uuid => image,
+              :hostname => hostname,
+              :size => size,
+              :"networks[]" => networks,
+              :ssh_key => ssh_key
+            }
+
+            #if !security_groups.empty?
+            #  security_group_key = options[:subnet_id].nil? ? :groups : :security_group_ids
+            #  options[security_group_key] = security_groups
+            #end
+
+            i = Tiktalik::Computing::Instance
+            instance = i.create options
+          rescue Exception => e
+            raise e
+          #  # Invalid subnet doesn't have its own error so we catch and
+          #  # check the error message here.
+          #  if e.message =~ /subnet ID/
+          #    raise Errors::FogError,
+          #      :message => "Subnet ID not found: #{subnet_id}"
+          #  end
+          #
+          #  raise
+          #rescue Fog::Compute::TiktalikVagrant::Error => e
+          #  raise Errors::FogError, :message => e.message
+          end
+
+          ## Immediately save the ID since it is created at this point.
+          env[:machine].id = instance.uuid
+
+          env[:ui].info(I18n.t("vagrant_tiktalik.waiting_for_ready"))
+
+          ## Wait for the instance to be ready first
+          retryable(:tries => 120, :sleep => 10) do
+            next if env[:interrupted]
+            result = i.find instance.uuid
+            yield result if block_given?
+            raise 'not ready' if result.state != 12 || !result.running
+          end
+
+          env[:ui].info(I18n.t("vagrant_tiktalik.waiting_for_ssh"))
+
+          # waiting for ssh to start up and server ssh keys to generate
+          retryable(:tries => 120, :sleep => 10) do
+            next if env[:interrupted]
+            raise 'not ready' if !env[:machine].communicate.ready?
+          end
+
+          # Ready and booted!
+          env[:ui].info(I18n.t("vagrant_tiktalik.ready"))
+
+          @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-tiktalik/action/sync_folders.rb

@@ -0,0 +1,67 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module TiktalikVagrant
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Tiktalik instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_tiktalik::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, :aws)
+
+            # 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_tiktalik.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}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+              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