vagrant-vmpooler 0.1.1 → 0.1.2

data/lib/vagrant-vmpooler/action/resume_server.rb

@@ -0,0 +1,25 @@
+require "log4r"
+
+module VagrantPlugins
+  module Vmpooler
+    module Action
+      # This starts a suspended server, if there is one.
+      class ResumeServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vmpooler::action::resume_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_vmpooler.resuming_server"))
+
+            # raise "not implemented"
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/action/setup_rsync.rb

@@ -0,0 +1,40 @@
+
+module VagrantPlugins
+  module Vmpooler
+    module Action
+      class SetupRsync
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant_vmpooler::action::setup_rsync")
+        end
+
+        def determine_packman(os_flavor)
+          if os_flavor =~ /centos|fedora|redhat/i
+            cmd_install_rsync = "yum install rsync.x86_64 -y"
+          elsif os_flavor =~ /debian|ubuntu/i
+            cmd_install_rsync = "apt-get install rsync -y"
+          else
+            cmd_install_rsync = nil
+          end
+
+          cmd_install_rsync
+        end
+
+        def call(env)
+          ssh_info = env[:machine].ssh_info
+          os_flavor = env[:machine].provider_config.os
+          cmd_install_rsync = determine_packman(os_flavor)
+
+          if cmd_install_rsync
+            env[:ui].info(I18n.t("vagrant_vmpooler.install_rsync"))
+            env[:machine].communicate.execute(cmd_install_rsync, :error_check => true)
+          else
+            env[:ui].warn(I18n.t("vagrant_vmpooler.no_install_rsync"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/action/suspend_server.rb

@@ -0,0 +1,24 @@
+require "log4r"
+
+module VagrantPlugins
+  module Vmpooler
+    module Action
+      # This deletes the running server, if there is one.
+      class SuspendServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vmpooler::action::suspend_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_vmpooler.suspending_server"))
+
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module Vmpooler
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # remote instance.
+      class SyncFolders
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vmpooler::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
+            if data[:disabled]
+              @logger.info "Not syncing disabled folder: #{data[:hostpath]} => #{data[:guestpath]}"
+              next
+            end
+
+            unless Vagrant::Util::Which.which('rsync')
+              @logger.info "please install rsync locally first"
+              break
+            end
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            # rsync interprets paths with colons as remote locations.
+            # "cygdrive" path for cygwin on windows.
+            if Vagrant::Util::Platform.windows?
+              hostpath = Vagrant::Util::Subprocess.execute("cygpath", "-u", "-a", hostpath).stdout.chomp
+            end
+            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_vmpooler.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            # Use sudo only when it is necessary
+            cmd_mkdir = "mkdir -p '#{guestpath}'"
+            cmd_chown = "chown #{ssh_info[:username]} '#{guestpath}'"
+            if env[:machine].communicate.execute(cmd_mkdir, :error_check => false) != 0 then
+              env[:machine].communicate.sudo(cmd_mkdir)
+            end
+            if env[:machine].communicate.execute(cmd_chown, :error_check => false) != 0 then
+              env[:machine].communicate.sudo(cmd_chown)
+            end
+
+            #collect rsync excludes specified :rsync_excludes=>['path1',...] in synced_folder options
+            excludes = ['.vagrant/', 'Vagrantfile', *Array(data[:rsync_excludes])].uniq
+
+            # Rsync over to the guest path using the SSH info
+            if env[:machine].config.ssh.proxy_command
+              proxy_cmd = "-o ProxyCommand='#{env[:machine].config.ssh.proxy_command}'"
+            else
+              proxy_cmd = ''
+            end
+
+            # poor workaround for poor ipv6 handling of rsync
+            if ssh_info[:host].include? ':'
+              user_at_host = "[#{ssh_info[:username]}@#{ssh_info[:host]}]"
+            else
+              user_at_host = ssh_info[:username] + "@" + ssh_info[:host]
+            end
+
+            command = [
+              'rsync', '--verbose', '--archive', '-z', '--delete',
+              *excludes.map{|e|['--exclude', e]}.flatten,
+              '-e', "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{proxy_cmd} #{ssh_key_options(ssh_info)}",
+              hostpath,
+              user_at_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
+
+        private
+
+        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
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/action/take_snapshot.rb

@@ -0,0 +1,35 @@
+require "log4r"
+
+module VagrantPlugins
+  module Vmpooler
+    module Action
+      # This reboots a running server, if there is one.
+      class TakeSnapshot
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_vmpooler::action::take_snapshot")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_vmpooler.snapshoting_server"))
+            # make api call to snapshot server
+            provider_config = env[:machine].provider_config
+
+            token = provider_config.token
+            url = provider_config.url
+            verbose = provider_config.verbose
+            hostname = env[:machine].id
+            response = Pooler.snapshot(verbose, url, hostname, token)
+            if response['ok'] == false
+              env[:ui].info(I81n.t("vagrant_vmpooler.errors.failed_snapshot"))
+              env[:ui].info(response)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/action/wait_for_state.rb

@@ -0,0 +1,38 @@
+require 'log4r'
+require 'timeout'
+
+module VagrantPlugins
+  module Vmpooler
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout.
+      class WaitForState
+        def initialize(app, env, state, timeout)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_vmpooler::action::wait_for_state')
+          @state = Array.new(state).flatten
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          state = env[:machine].state.id.to_sym
+
+          if @state.include?(state)
+            @logger.info("Machine already at status #{ state.to_s }")
+          else
+            @logger.info("Waiting for machine to reach state...")
+            begin
+              Timeout.timeout(@timeout) do
+                sleep 2 until @state.include?(env[:machine].state.id)
+              end
+            rescue Timeout::Error
+              env[:result] = false
+            end
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/config.rb

@@ -0,0 +1,100 @@
+require 'vagrant'
+require 'yaml'
+
+module VagrantPlugins
+  module Vmpooler
+    class Config < Vagrant.plugin("2", :config)
+      # The token used to obtain vms
+      #
+      # @return [String]
+      attr_accessor :token
+
+      # The url to your vmpooler installation
+      #
+      # @return [String]
+      attr_accessor :url
+
+      # Whether or not to run vmfloaty
+      # commands in verbose mode
+      #
+      # @return [Boolean]
+      attr_accessor :verbose
+
+      # The type of operatingsystem to
+      # get from the pooler
+      #
+      # @return [String]
+      attr_accessor :os
+
+      # The password to use to log
+      # into the vmpooler machine
+      #
+      # @return [String]
+      attr_accessor :password
+
+      # How long the vm should stay
+      # active for
+      #
+      # @return [Integer]
+      attr_accessor :ttl
+
+      # Increases default disk space by
+      # this size
+      #
+      # @return [Integer]
+      attr_accessor :disk
+
+      #attr_accessor :user
+
+      # ----------------
+      # Internal methods
+      # ----------------
+
+      def read_config
+        conf_file = {}
+        begin
+          conf_file = YAML.load_file("#{Dir.home}/.vmfloaty.yml")
+        rescue
+          # vagrant debug?
+        end
+        conf_file
+      end
+
+      def finalize!
+        conf_file = read_config
+
+        if conf_file['token']
+          @token = conf_file['token']
+        else
+          @token = nil
+        end
+
+        if conf_file['url']
+          @url = conf_file['url']
+        else
+          @url = nil
+        end
+
+        @verbose = false if @verbose == UNSET_VALUE
+        @os = nil if @os == UNSET_VALUE
+        @ttl = nil if @ttl == UNSET_VALUE
+        @disk = nil if @disk == UNSET_VALUE
+        @password = nil if @password == UNSET_VALUE
+      end
+
+      # ----------------
+      # Provider methods
+      # ----------------
+
+      def initialize(verbose=false)
+        @token = UNSET_VALUE
+        @url = UNSET_VALUE
+        @verbose = UNSET_VALUE
+        @os = UNSET_VALUE
+        @ttl = UNSET_VALUE
+        @disk = UNSET_VALUE
+        @password = UNSET_VALUE
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/errors.rb

@@ -0,0 +1,31 @@
+require 'vagrant'
+
+module VagrantPlugins
+  module Vmpooler
+    module Errors
+      class VagrantVmpoolerErrors < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_vmpooler.errors")
+      end
+
+      class NoURLError < VagrantVmpoolerErrors
+        error_key(:vmpooler_url_error)
+      end
+
+      class NoOSError < VagrantVmpoolerErrors
+        error_key(:no_os_error)
+      end
+
+      class FailedRequest < VagrantVmpoolerErrors
+        error_key(:bad_request)
+      end
+
+      class RsyncError < VagrantVmpoolerErrors
+        error_key(:rsync_error)
+      end
+
+      class RsyncError < VagrantVmpoolerErrors
+        error_key(:install_rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/plugin.rb

@@ -0,0 +1,30 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant vmpooler plugin must be run within Vagrant."
+end
+
+module VagrantPlugins
+  module Vmpooler
+    class Plugin < Vagrant.plugin("2")
+      name "Vmpooler"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in vmpooler.
+      DESC
+
+      config(:vmpooler, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:vmpooler, parallel:true) do
+        Vmpooler.init_i18n
+        Vmpooler.init_logging
+
+        require_relative 'provider'
+        Provider
+      end
+    end
+  end
+end

data/lib/vagrant-vmpooler/provider.rb

@@ -0,0 +1,55 @@
+require "vagrant"
+
+require "vagrant-vmpooler/action"
+
+module VagrantPlugins
+  module Vmpooler
+    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
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info")
+        env[:machine_ssh_info]
+      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_vmpooler.states.short_#{state_id}")
+        long  = I18n.t("vagrant_vmpooler.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = "new"
+        if !@machine.id.nil?
+          id = @machine.id
+        end
+
+        "Vmpooler (#{id})"
+      end
+    end
+  end
+end