vagrant-registration 0.0.17 → 0.0.18

data/vagrant-registration-0.0.17/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler/gem_tasks'
+require 'yard'
+
+# Documentation
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', 'plugins/**/*.rb']
+  t.options = []
+  t.stats_options = ['--list-undoc']
+end
+
+task :clean do
+  `rm -rf pkg`
+end
+
+# Compare latest release with current git head
+require 'rubygems/comparator'
+task compare: [:clean, :build] do
+  git_version = VagrantPlugins::Registration::VERSION
+  options = {}
+  options[:output] = 'pkg'
+  options[:keep_all] = true
+  comparator = Gem::Comparator.new(options)
+  comparator.compare_versions('vagrant-registration', ['_', git_version])
+  comparator.print_results
+end

data/vagrant-registration-0.0.17/Vagrantfile

@@ -0,0 +1,44 @@
+# BEING USED FOR TESTING, REMOVE BEFORE RELEASE
+#
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure('2') do |config|
+  # Example configuration of new VM..
+  config.vm.define :default do |vagrant_host|
+    # Box name
+    vagrant_host.vm.box = 'rhel-7.0'
+    
+    # Domain Specific Options
+    vagrant_host.vm.provider :libvirt do |domain|
+      domain.memory = 2048
+      domain.cpus = 1
+    end
+
+    config.vm.synced_folder './', '/vagrant', type: 'rsync'
+
+#    vagrant_host.vm.network :private_network,
+#        :libvirt__network_name => 'either_nat'
+
+  end
+  
+  # config.vm.provision "ansible" do |ansible|
+  #   ansible.playbook = "playbook.yml"
+  #   ansible.extra_vars = "vagrant-config.yml"
+  # end
+
+  # config.vm.provision "ansible" do |ansible|
+  #   ansible.playbook = "playbook.yml"
+  #   ansible.extra_vars = "vagrant-config.yml"
+  #   ansible.sudo = "true"
+  # end
+  
+  # Options for libvirt vagrant provider.
+  config.vm.provider :libvirt do |libvirt|
+    libvirt.driver = 'kvm'
+    libvirt.connect_via_ssh = false
+    libvirt.username = 'root'
+    libvirt.storage_pool_name = 'mnt_vms'
+  end
+end
+

data/vagrant-registration-0.0.17/lib/vagrant-registration.rb

@@ -0,0 +1,21 @@
+require "pathname"
+
+require "vagrant-registration/plugin"
+
+module VagrantPlugins
+  module Registration
+    lib_path = Pathname.new(File.expand_path("../vagrant-registration", __FILE__))
+    autoload :Action, lib_path.join("action")
+    #autoload :Errors, lib_path.join("errors")
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+
+    # Temporally load the extra capability files for Red Hat
+    load(File.join(self.source_root, 'plugins/guests/redhat/plugin.rb'))
+  end
+end

data/vagrant-registration-0.0.17/lib/vagrant-registration/action.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins
+  module Registration
+    module Action
+
+      def self.action_register
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Register
+        end
+      end
+
+      def self.action_unregister
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Unregister
+        end
+      end
+
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :Register, action_root.join("register")
+      autoload :Unregister, action_root.join("unregister")
+    end
+  end
+end

data/vagrant-registration-0.0.17/lib/vagrant-registration/action/register.rb

@@ -0,0 +1,113 @@
+require "log4r"
+
+module VagrantPlugins
+  module Registration
+    module Action
+      # This registers the guest if the guest plugin supports it
+      class Register
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_registration::action::register")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          # Configuration from Vagrantfile
+          config = env[:machine].config.registration
+          machine = env[:machine]
+          guest = env[:machine].guest
+
+          if capabilities_provided?(guest) && manager_installed?(guest) && !config.skip
+            env[:ui].info("Registering box with vagrant-registration...")
+
+            unless credentials_provided? machine
+              @logger.debug("Credentials for registration not provided")
+
+              # Offer to register ATM or skip
+              register_now = env[:ui].ask("Would you like to register the system now (default: yes)? [y|n] ")
+
+              if register_now == 'n'
+                config.skip = true
+              else
+                config = register_on_screen(machine, env[:ui])
+              end
+            end
+            guest.capability(:registration_register) unless config.skip
+          end
+
+          @logger.debug("Registration is skipped due to the configuration") if config.skip
+        end
+
+        private
+
+        # Check if registration capabilities are available
+        def capabilities_provided?(guest)
+          if guest.capability?(:registration_register) && guest.capability?(:registration_manager_installed)
+            true
+          else
+            @logger.debug("Registration is skipped due to the missing guest capability")
+            false
+          end
+        end
+
+        # Check if selected registration manager is installed
+        def manager_installed?(guest)
+          if guest.capability(:registration_manager_installed)
+            true
+          else
+            @logger.debug("Registration manager not found on guest")
+            false
+          end
+        end
+
+        # Fetch required credentials for selected manager
+        def credentials_required(machine)
+          if machine.guest.capability?(:registration_credentials)
+            machine.guest.capability(:registration_credentials)
+          else
+            []
+          end
+        end
+
+        # Secret options for selected manager
+        def secrets(machine)
+          if machine.guest.capability?(:registration_secrets)
+            machine.guest.capability(:registration_secrets)
+          else
+            []
+          end
+        end
+
+        # Check if required credentials has been provided in Vagrantfile
+        #
+        # Checks if at least one of the registration options is able to
+        # register.
+        def credentials_provided?(machine)
+          provided = true
+          credentials_required(machine).each do |registration_option|
+            provided = true
+            registration_option.each do |value|
+              provided = false unless machine.config.registration.send value
+            end
+            break if provided
+          end
+          provided ? true : false
+        end
+
+        # Ask user on required credentials and return them,
+        # skip options that are provided by Vagrantfile
+        def register_on_screen(machine, ui)
+          credentials_required(machine)[0].each do |option|
+            unless machine.config.registration.send(option)
+              echo = !(secrets(machine).include? option)
+              response = ui.ask("#{option}: ", echo: echo)
+              machine.config.registration.send("#{option.to_s}=".to_sym, response)
+            end
+          end
+          machine.config.registration
+        end
+      end
+    end
+  end
+end

data/vagrant-registration-0.0.17/lib/vagrant-registration/action/unregister.rb

@@ -0,0 +1,56 @@
+require "log4r"
+
+module VagrantPlugins
+  module Registration
+    module Action
+      # This unregisters the guest if the guest has registration capability
+      class Unregister
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_registration::action::unregister")
+        end
+
+        def call(env)
+          config = env[:machine].config.registration
+          guest = env[:machine].guest
+
+          if capabilities_provided?(guest) && manager_installed?(guest) && !config.skip
+            env[:ui].info("Unregistering box with vagrant-registration...")
+            guest.capability(:registration_unregister)
+          end
+
+          @logger.debug("Unregistration is skipped due to the configuration") if config.skip
+          @app.call(env)
+
+        # Guest might not be available after halting, so log the exception and continue
+        rescue => e
+          @logger.info(e)
+          @logger.debug("Guest is not available, ignore unregistration")
+          @app.call(env)
+        end
+
+        private
+
+        # Check if registration capabilities are available
+        def capabilities_provided?(guest)
+          if guest.capability?(:registration_unregister) && guest.capability?(:registration_manager_installed)
+            true
+          else
+            @logger.debug("Unregistration is skipped due to the missing guest capability")
+            false
+          end
+        end
+
+        # Check if selected registration manager is installed
+        def manager_installed?(guest)
+          if guest.capability(:registration_manager_installed)
+            true
+          else
+            @logger.debug("Registration manager not found on guest")
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/vagrant-registration-0.0.17/lib/vagrant-registration/config.rb

@@ -0,0 +1,39 @@
+require "vagrant"
+require "ostruct"
+
+module VagrantPlugins
+  module Registration
+    class Config < Vagrant.plugin("2", :config)
+      def initialize(region_specific=false)
+        @conf = UNSET_VALUE
+        @logger = Log4r::Logger.new("vagrant_registration::config")
+      end
+
+      def finalize!
+        get_config
+        @conf.skip = false unless @conf.skip
+        @logger.info "Final registration configuration: #{@conf.inspect}"
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        get_config
+        command = "@conf.#{method_sym} #{adjust_arguments(arguments)}"
+        @logger.info "Evaluating registration configuration: #{command}"
+        eval command
+      end
+
+      private
+
+        # Don't set @conf to OpenStruct in initialize
+        # to preserve config hierarchy
+        def get_config
+          @conf = OpenStruct.new if @conf == UNSET_VALUE
+        end
+
+        def adjust_arguments(args)
+          return '' if args.size < 1
+          args.map{|a| a.is_a?(String) ? "'#{a}'" : a}.join(',')
+        end
+    end
+  end
+end

data/vagrant-registration-0.0.17/lib/vagrant-registration/plugin.rb

@@ -0,0 +1,74 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The vagrant-registration 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 RHEL plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module Registration
+    class Plugin < Vagrant.plugin("2")
+      class << self
+        def register(hook)
+          setup_logging
+          hook.after(::Vagrant::Action::Builtin::SyncedFolders,
+                     VagrantPlugins::Registration::Action.action_register)
+        end
+
+        def unregister(hook)
+          setup_logging
+          hook.prepend(VagrantPlugins::Registration::Action.action_unregister)
+        end
+      end
+
+      name "Registration"
+      description <<-DESC
+      This plugin adds register and unregister functionality to Vagrant Guests that
+      support the capability
+      DESC
+
+      action_hook(:registration_register, :machine_action_up, &method(:register))
+      action_hook(:registration_register, :machine_action_provision, &method(:register))
+      action_hook(:registration_unregister, :machine_action_halt, &method(:unregister))
+      action_hook(:registration_unregister, :machine_action_destroy, &method(:unregister))
+
+      config(:registration) do
+        setup_logging
+        require_relative 'config'
+        Config
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is
+      # for loggers prepended with 'vagrant_registration'
+      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_registration')
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/vagrant-registration-0.0.17/lib/vagrant-registration/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Registration
+    VERSION = "0.0.17"
+  end
+end

data/vagrant-registration-0.0.17/plugins/guests/redhat/cap/registration.rb

@@ -0,0 +1,72 @@
+module VagrantPlugins
+  module GuestRedHat
+    module Cap
+      # This provides registration capabilities for vagrant-registration
+      #
+      # As we might support more registration options (managers), this
+      # just calls the capabilities of the selected registration manager
+      # (from config.registration.manager).
+      class Registration
+        # Register the given machine
+        def self.registration_register(machine)
+          cap = "#{self.registration_manager(machine).to_s}_register".to_sym
+          if machine.guest.capability?(cap)
+            machine.guest.capability(cap, machine.config.registration)
+          else
+            false
+          end
+        end
+
+        # Unregister the given machine
+        def self.registration_unregister(machine)
+          cap = "#{self.registration_manager(machine).to_s}_unregister".to_sym
+          if machine.guest.capability?(cap)
+            machine.guest.capability(cap)
+          else
+            false
+          end
+        end
+
+        # Check that the machine has the selected registration manager installed
+        def self.registration_manager_installed(machine)
+          cap = "#{self.registration_manager(machine).to_s}".to_sym
+          if machine.guest.capability?(cap)
+            machine.guest.capability(cap)
+          else
+            false
+          end
+        end
+
+        # Required configuration options of the registration manager
+        #
+        # This is array of arrays of all possible registration combinations.
+        # First one is the default used in interactive mode.
+        #
+        # e.g. [[:username, :password]]
+        def self.registration_credentials(machine)
+          cap = "#{self.registration_manager(machine).to_s}_credentials".to_sym
+          if machine.guest.capability?(cap)
+            machine.guest.capability(cap)
+          else
+            []
+          end
+        end
+
+        # Return secret options for the registration manager
+        def self.registration_secrets(machine)
+          cap = "#{self.registration_manager(machine).to_s}_secrets".to_sym
+          if machine.guest.capability?(cap)
+            machine.guest.capability(cap)
+          else
+            []
+          end
+        end
+
+        # Return selected registration manager or default
+        def self.registration_manager(machine)
+          (machine.config.registration.manager || 'subscription_manager').to_sym
+        end
+      end
+    end
+  end
+end