vagrant-joyent 0.3.0

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Joyent
+    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-joyent/action/message_already_created.rb

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

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

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

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

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

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

@@ -0,0 +1,71 @@
+require "log4r"
+require 'ipaddr'
+
+module VagrantPlugins
+  module Joyent
+    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_joyent::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:joyent_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def is_linklocal(ip)
+          linklocal = IPAddr.new "169.254.0.0/16"
+          return linklocal.include?(ip)
+        end
+        
+        def is_loopback(ip)
+          loopback = IPAddr.new "127.0.0.0/8"
+          return loopback.include?(ip)
+        end
+
+        def is_private(ip)
+          block_a = IPAddr.new "10.0.0.0/8"
+          block_b = IPAddr.new "172.16.0.0/12"
+          block_c = IPAddr.new "192.168.0.0/16"
+          return (block_a.include?(ip) or block_b.include?(ip) or block_c.include?(ip))
+        end
+        
+        def read_ssh_info(joyent, machine)
+          return nil if machine.id.nil?
+          
+          # Find the machine
+          server = joyent.servers.get(machine.id)
+          if server.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 address to bootstrap
+          bootstrap_ip_addresses = server.ips.select{ |ip| ip and not(is_loopback(ip) or is_linklocal(ip)) }
+          if bootstrap_ip_addresses.count == 1
+            bootstrap_ip_address = bootstrap_ip_addresses.first
+          else
+            bootstrap_ip_address = bootstrap_ip_addresses.find{|ip| not is_private(ip)}            
+          end
+                    
+          config = machine.provider_config
+          
+          # Read the DNS info
+          return {
+            :host => bootstrap_ip_address,
+            :port => 22,
+            :private_key_path => config.keyfile,
+            :username => config.ssh_username
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require "log4r"
+
+module VagrantPlugins
+  module Joyent
+    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_joyent::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:joyent_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_state(joyent, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          server = joyent.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-joyent/action/run_instance.rb

@@ -0,0 +1,114 @@
+require "log4r"
+require 'vagrant/util/retryable'
+require 'vagrant-joyent/util/timer'
+
+module VagrantPlugins
+  module Joyent
+    module Action
+
+      # This runs the configured instance.
+      class RunInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_joyent::action::run_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          # Get the configs
+          dataset = env[:machine].provider_config.dataset
+          flavor = env[:machine].provider_config.flavor
+          node_name = env[:machine].provider_config.node_name || env[:machine].name
+          keyname = env[:machine].provider_config.joyent_keyname
+
+          # Launch!
+          env[:ui].info(I18n.t("vagrant_joyent.launching_instance"))
+          env[:ui].info(" -- Flavor: #{flavor}")
+          env[:ui].info(" -- Dataset: #{dataset}")
+          env[:ui].info(" -- Node name: #{node_name}")
+          env[:ui].info(" -- Key name: #{keyname}")
+
+          begin
+            options = {
+              :name             => node_name,
+              :dataset          => dataset,
+              :package          => flavor
+            }
+
+            server = env[:joyent_compute].servers.create(options)
+
+          rescue Fog::Compute::Joyent::NotFound => e
+            raise Errors::FogError, :message => e.message
+          rescue Fog::Compute::Joyent::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = server.id
+
+          # Wait for the instance to be ready first
+          env[:metrics]["instance_ready_time"] = Util::Timer.time do
+            env[:ui].info(I18n.t("vagrant_joyent.waiting_for_ready"))
+            retryable(:on => Fog::Errors::TimeoutError, :tries => 30) do
+              # If we're interrupted don't worry about
+              # waiting
+              next if env[:interrupted]
+
+              # Wait for the server to be ready
+              server.wait_for(2) { ready? }
+            end
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+ 
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_joyent.waiting_for_ssh"))
+              while true
+                # If we're interrupted then 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"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_joyent.ready"))
+          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-joyent/action/sync_folders.rb

@@ -0,0 +1,60 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module Joyent
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Joyent instance.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_joyent::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|
+            # 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_joyent.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",
+              "-e", "ssh -o StrictHostKeyChecking=no -p #{ssh_info[:port]} -i '#{ssh_info[:keyfile]}'",
+              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-joyent/action/terminate_instance.rb

@@ -0,0 +1,47 @@
+require "log4r"
+
+module VagrantPlugins
+  module Joyent
+    module Action
+      # This terminates the running instance.
+      class TerminateInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_joyent::action::run_instance")
+        end
+
+        def call(env)
+          server = env[:joyent_compute].servers.get(env[:machine].id)
+
+          # Destroy the server and remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_joyent.terminating"))
+
+          # Machine must be in a stopped state before it's destroyed.
+          #
+          # More info here:
+          #
+          #   https://us-west-1.api.joyentcloud.com/docs#DeleteMachine
+          #
+          server.stop
+          server.destroy
+
+          # Wait for server to be completely gone from invetory
+          while true do
+            ids = []
+            env[:joyent_compute].servers.collect.each { |s|
+              ids << s.id
+            }
+
+            unless ids.include?(env[:machine].id) then
+              break
+            end
+          end
+
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module Joyent
+    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_joyent.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-joyent/config.rb

@@ -0,0 +1,69 @@
+#: utf-8 -*-
+require "vagrant"
+
+module VagrantPlugins
+  module Joyent
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :username
+      attr_accessor :password
+      attr_accessor :keyname
+      attr_accessor :keyfile
+      attr_accessor :api_url
+      attr_accessor :dataset
+      attr_accessor :flavor
+      attr_accessor :node_name
+      attr_accessor :ssh_username
+      attr_accessor :ssl_verify_peer
+
+      def initialize(datacenter_specific=false)
+        @username    = UNSET_VALUE
+        @password    = UNSET_VALUE
+        @keyname    = UNSET_VALUE
+        @keyfile    = UNSET_VALUE
+        @api_url     = UNSET_VALUE
+        @ssl_verify_peer = UNSET_VALUE
+        @dataset            = UNSET_VALUE
+        @flavor             = UNSET_VALUE
+        @node_name          = UNSET_VALUE
+        @ssh_username       = UNSET_VALUE
+      end
+
+      #-------------------------------------------------------------------
+      # Internal methods.
+      #-------------------------------------------------------------------
+
+      def finalize!
+        # API
+        @username = nil if @username == UNSET_VALUE
+        @password = nil if @username == UNSET_VALUE
+        @keyname = nil if @keyname == UNSET_VALUE
+        @keyfile = nil if @keyfile == UNSET_VALUE
+        @api_url  = nil if @api_url  == UNSET_VALUE
+
+        # SSL
+        @ssl_verify_peer = true if @ssl_verify_peer = UNSET_VALUE
+
+        # Machines
+        @dataset = nil if @dataset == UNSET_VALUE
+        @flavor = "Small 1GB" if @instance_type == UNSET_VALUE
+        @node_name = nil if @node_name == UNSET_VALUE
+        @ssh_username = nil if @ssh_username == UNSET_VALUE
+      end
+
+      def validate(machine)
+        config = self.class.new(true)
+
+        errors = []
+        errors << I18n.t("vagrant_joyent.config.username_required") if config.username.nil?
+        errors << I18n.t("vagrant_joyent.config.keyname_required") if config.keyname.nil?
+        errors << I18n.t("vagrant_joyent.config.keyfile_required") if config.keyfile.nil?
+        errors << I18n.t("vagrant_joyent.config.api_url_required") if config.api_url.nil?
+        errors << I18n.t("vagrant_joyent.config.dataset_required") if config.dataset.nil?
+        errors << I18n.t("vagrant_joyent.config.flavor_required") if config.flavor.nil?
+        errors << I18n.t("vagrant_joyent.config.ssh_username_required") if config.ssh_username.nil?
+
+        { "Joyent Provider" => errors }
+      end
+    end
+  end
+end