vagrant-managed-servers 0.1.0

data/lib/vagrant-managed-servers/action/message_not_reachable.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module ManagedServers
+    module Action
+      class MessageNotReachable
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_managed_servers.host_not_reachable"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/action/read_state.rb

@@ -0,0 +1,84 @@
+require "log4r"
+
+module VagrantPlugins
+  module ManagedServers
+    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_managed_servers::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:machine])
+          @app.call(env)
+        end
+
+        def read_state(machine)
+          return :not_created if machine.id.nil?
+
+          ip_address = machine.id
+=begin
+          if machine.communicate.ready?
+            @logger.info "#{ip_address} is reachable and SSH login OK"
+            return :reachable
+          else
+            if ssh_port_open? ip_address
+              @logger.info "#{ip_address} is reachable, SSH port open (but login failed)"
+              return :reachable
+            else 
+              if is_pingable? ip_address
+                @logger.info "#{ip_address} is pingable (but SSH failed)"
+                return :reachable
+              end
+            end
+          end
+
+          # host is not reachable at all...
+          return :not_reachable
+=end
+
+          return machine.communicate.ready? ? :running : :not_reachable
+        end
+
+
+        def is_pingable?(ip)
+          if Vagrant::Util::Platform.windows?
+            system("ping -n 1 #{ip}")
+          else
+            system("ping -q -c 1 #{ip}")
+          end
+        end
+
+        def ssh_port_open?(ip)
+          is_port_open?(ip, 22)
+        end
+
+        #
+        # borrowed from http://stackoverflow.com/a/3473208/2388971
+        #
+        def is_port_open?(ip, port)
+          require 'socket'
+          s = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+          sa = Socket.sockaddr_in(port, ip)
+          begin
+            s.connect_nonblock(sa)
+          rescue Errno::EINPROGRESS
+            if IO.select(nil, [s], nil, 1)
+              begin
+                s.connect_nonblock(sa)
+              rescue Errno::EISCONN
+                return true
+              rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+                return false
+              end
+            end
+          end
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/action/sync_folders.rb

@@ -0,0 +1,85 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+require "vagrant/util/scoped_hash_override"
+
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module ManagedServers
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # AWS instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_managed_servers::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]
+
+            unless Vagrant::Util::Which.which('rsync')
+              env[:ui].warn(I18n.t('vagrant_managed_servers.rsync_not_found_warning'))
+              break
+            end
+
+            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 !~ /\/$/
+
+            # on windows rsync.exe requires cygdrive-style paths
+            if Vagrant::Util::Platform.windows?
+              hostpath = hostpath.gsub(/^(\w):/) { "/cygdrive/#{$1}" }
+            end
+
+            env[:ui].info(I18n.t("vagrant_managed_servers.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}"]
+
+            # we need to fix permissions when using rsync.exe on windows, see
+            # http://stackoverflow.com/questions/5798807/rsync-permission-denied-created-directories-have-no-permissions
+            if Vagrant::Util::Platform.windows?
+              command.insert(1, "--chmod", "ugo=rwX")
+            end
+
+            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-managed-servers/action/unlink_server.rb

@@ -0,0 +1,30 @@
+require "log4r"
+
+module VagrantPlugins
+  module ManagedServers
+    module Action
+      # "unlink" vagrant and the managed server
+      class UnlinkServer
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_managed_servers::action::unlink_server")
+        end
+
+        def call(env)
+
+          server = env[:machine].id
+
+          # "Unlink" 
+          env[:ui].info(I18n.t("vagrant_managed_servers.unlinking_server", :host => server))
+          env[:ui].info(" -- Server: #{server}")
+
+          # set machine id to nil
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/action/warn_networks.rb

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

data/lib/vagrant-managed-servers/config.rb

@@ -0,0 +1,28 @@
+require "vagrant"
+
+module VagrantPlugins
+  module ManagedServers
+    class Config < Vagrant.plugin("2", :config)
+      
+      # The IP address or hostname of the managed server.
+      #
+      # @return [String]
+      attr_accessor :server
+
+      def initialize()
+        @server      = UNSET_VALUE
+      end
+
+      def finalize!
+        # server must be nil, since we can't default that
+        @server = nil if @server == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+        errors << I18n.t("vagrant_managed_servers.config.server_required") if @server.nil?
+        { "ManagedServers Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/errors.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module ManagedServers
+    module Errors
+      class VagrantManagedServersError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_managed_servers.errors")
+      end
+
+      class ManagedServersServerNotReachable < VagrantManagedServersError
+        error_key(:server_not_reachable)
+      end
+
+      class RsyncError < VagrantManagedServersError
+        error_key(:rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/plugin.rb

@@ -0,0 +1,72 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant ManagedServers plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant ManagedServers plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module ManagedServers
+    class Plugin < Vagrant.plugin("2")
+      name "ManagedServers"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to interact with managed servers.
+      DESC
+
+      config(:managed, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:managed, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", ManagedServers.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_managed_servers")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/provider.rb

@@ -0,0 +1,51 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module ManagedServers
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # Returns the SSH info for accessing the managed server.
+      def ssh_info
+        return {
+          :host => @machine.provider_config.server,
+          :port => 22
+        }
+      end
+
+      def state
+
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state")
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_managed_servers.states.short_#{state_id}")
+        long  = I18n.t("vagrant_managed_servers.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "n/a" : @machine.id
+        "ManagedServers (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/util/timer.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ManagedServers
+    module Util
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-managed-servers/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module ManagedServers
+    VERSION = "0.1.0"
+  end
+end

data/locales/en.yml

@@ -0,0 +1,45 @@
+en:
+  vagrant_managed_servers:
+    host_not_reachable: |-
+      The host specified in `config.managed.server` is not reachable.
+    warn_networks: |-
+      Warning! The ManagedServers provider doesn't support any of the Vagrant
+      high-level network configurations (`config.vm.network`). They
+      will be silently ignored.
+    rsync_not_found_warning: |-
+      Warning! Folder sync disabled because the rsync binary is missing.
+      Make sure rsync is installed and the binary can be found in the PATH.
+    rsync_folder: |-
+      Rsyncing folder: %{hostpath} => %{guestpath}
+    linking_server: |-
+      Linking vagrant with managed server %{host}
+    unlinking_server: |-
+      Unlinking vagrant from managed server %{host}
+    states:
+      short_not_reachable: |-
+        not reachable
+      long_not_reachable: |-
+        The managed server is not reachable. Check if the `config.managed.server` is correct.
+      short_running: |-
+        running
+      long_running: |-
+        The managed server is running. To ssh into this machine, you can run
+        `vagrant ssh`. To provision the machine, you can run `vagrant provision`.
+    config:
+      server_required: |-
+        The IP or hostname of the server must be configured via "server"
+      private_key_missing: |-
+        The specified private key could not be found
+    errors:
+      rsync_error: |-
+        There was an error when attemping to rsync a shared folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+
+
+
+
+