vagrant-openstack-plugin-tom 0.12.0

data/lib/vagrant-openstack-plugin/action/read_state.rb

@@ -0,0 +1,39 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        NOT_CREATED_STATES = [:deleted, :soft_deleted, :building, :error].freeze
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:openstack_compute], env[:machine])
+          @app.call(env)
+        end
+
+        def read_state(openstack, machine)
+          id = machine.id || openstack.servers.all( :name => machine.name ).first.id rescue nil
+          return :not_created if id.nil?
+
+          # Find the machine using the OpenStack API.
+          server = openstack.servers.get(machine.id)
+          if server.nil? || NOT_CREATED_STATES.include?(server.state.downcase.to_sym)
+            @logger.info(I18n.t("vagrant_openstack.not_created"))
+            machine.id = nil
+            return :not_created
+          end
+
+          server.state.downcase.to_sym
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/reboot_server.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This reboots a running server, if there is one.
+      class RebootServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::reboot_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.rebooting_server"))
+
+            # TODO: Validate the fact that we get a server back from the API.
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            server.reboot('SOFT')
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/resume_server.rb

@@ -0,0 +1,31 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This starts a suspended server, if there is one.
+      class ResumeServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::resume_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.resuming_server"))
+
+            # TODO: Validate the fact that we get a server back from the API.
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            if server.state == 'PAUSED'
+              env[:openstack_compute].unpause_server(server.id)  
+            elsif server.state == 'SUSPENDED'
+              env[:openstack_compute].resume_server(server.id)  
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/suspend_server.rb

@@ -0,0 +1,27 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This deletes the running server, if there is one.
+      class SuspendServer
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::suspend_server")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.suspending_server"))
+
+            # TODO: Validate the fact that we get a server back from the API.
+            server = env[:openstack_compute].servers.get(env[:machine].id)
+            env[:openstack_compute].suspend_server(server.id)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/sync_folders.rb

@@ -0,0 +1,104 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module OpenStack
+    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_openstack::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 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_openstack.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-openstack-plugin/action/take_snapshot.rb

@@ -0,0 +1,26 @@
+require "log4r"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This reboots a running server, if there is one.
+      class TakeSnapshot
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_openstack::action::take_snapshot")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_openstack.snapshoting_server"))
+            infos = env[:openstack_compute].get_server_details(env[:machine].id)
+            env[:openstack_compute].create_image(env[:machine].id,env[:openstack_snapshot_name] || 'snapshot')
+
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/wait_for_state.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+require 'log4r'
+require 'timeout'
+
+module VagrantPlugins
+  module OpenStack
+    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_openstack::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-openstack-plugin/action/wait_for_task.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+require 'log4r'
+require 'timeout'
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout.
+      class WaitForTask
+        def initialize(app, env, task, timeout)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::wait_for_task')
+          @task = Array.new(task).flatten
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          task = get_task(env)
+
+          if @task.include?(task)
+            @logger.info("Machine already at task #{ task.to_s }")
+          else
+            @logger.info("Waiting for machine to reach task...")
+            begin
+              Timeout.timeout(@timeout) do
+                sleep 5 until @task.include?(get_task(env))
+              end
+            rescue Timeout::Error
+              env[:result] = false
+            end
+
+            @app.call(env)
+          end
+        end
+
+        def get_task(env)
+          infos = env[:openstack_compute].get_server_details(env[:machine].id)
+          infos.body['server']['OS-EXT-STS:task_state']
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/action/warn_networks.rb

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

data/lib/vagrant-openstack-plugin/command.rb

@@ -0,0 +1,70 @@
+require "vagrant"
+require "vagrant/action/builder"
+require "pathname"
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+
+      class Command < Vagrant.plugin(2, :command)
+
+        include Vagrant::Action::Builtin
+#        include VagrantPlugins::OpenStack::Action
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:snapshot) do
+            require_relative 'command/command_snapshot'
+            CommandTakeSnapshot
+          end
+        end
+
+
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the sub-commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant openstack <command> [<args>]"
+            o.separator ""
+            o.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              o.separator "     #{key}"
+            end
+
+            o.separator ""
+            o.separator "For help on any individual command run `vagrant openstack <command> -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-openstack-plugin/command/command_snapshot.rb

@@ -0,0 +1,43 @@
+require "vagrant"
+require "vagrant/action/builder"
+require "pathname"
+require "vagrant-openstack-plugin/action"
+
+
+module VagrantPlugins
+  module OpenStack
+    module Action
+      class CommandTakeSnapshot < Vagrant.plugin("2", :command)
+        include Vagrant::Action::Builtin
+
+        def execute
+          options = {:openstack_snapshot_name => 'snapshot'}
+          opts = OptionParser.new do |opts|
+            opts.banner = "Enters openstack"
+            opts.separator ""
+            opts.separator "Usage: vagrant openstack snapshot <vmname> -n <snapshotname>"
+
+
+            opts.on( '-n', '--name NAME', 'snapshotname' ) do |name|
+              options[:openstack_snapshot_name] = name
+            end
+
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+
+          return if !argv
+
+
+          with_target_vms(argv, :reverse => true) do |vm|
+            if vm.provider.to_s == VagrantPlugins::OpenStack::Provider.new(nil).to_s
+              vm.action(:take_snapshot,options)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end