vagrant-invade 0.0.1 → 0.2.0

data/lib/vagrant-invade/action/create.rb

@@ -0,0 +1,97 @@
+module VagrantPlugins
+  module Invade
+    module Action
+
+      include Vagrant::Action::Builtin
+
+      class Create
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new('vagrant::invade::action::create')
+        end
+
+        def call(env)
+
+          # Get project root and default vagrantfile filename
+          ENV['VAGRANT_VAGRANTFILE'] ? vagrantfile_name = ENV['VAGRANT_VAGRANTFILE'] : vagrantfile_name = "Vagrantfile"
+          root_path = @env[:root_path]
+
+          # Get generated Vagrantfile from environment
+          generated_vagrantfile = @env[:invade]['vagrantfile']
+
+          # Get auto_mode from env
+          auto_mode = @env[:invade]['invade']['auto']
+
+          # Write new Vagrantfile if checksum is not equal and auto mode is enabled
+          unless check_md5_checksum(@env[:ui], root_path, vagrantfile_name, generated_vagrantfile)
+
+              # Write Vagrantfile
+              auto_mode ?
+              write_vagrantfile(@env[:ui], root_path, generated_vagrantfile, vagrantfile_name, true) :
+              write_vagrantfile(@env[:ui], root_path, generated_vagrantfile, vagrantfile_name, false)
+
+              # Reload
+              reload(@env[:ui]) if auto_mode
+          end
+        end
+
+        private
+
+        # Compare md5 strings to replace Vagrantfile
+        def check_md5_checksum(ui, root_path, vagrantfile_name, generated_vagrantfile)
+
+          require 'digest'
+
+          md5_new = Digest::MD5.hexdigest(generated_vagrantfile)
+          md5_current = Digest::MD5.file("#{root_path}/#{vagrantfile_name}").hexdigest
+
+          ui.success "[Invade] Checking Vagrantfile (#{md5_current})..."
+          (md5_new.eql? md5_current) ? md5_check = true : md5_check = false
+
+          unless md5_check
+            ui.warn "[Invade] Vagrantfile (#{md5_current}) not equal with configuration (#{md5_new})."
+            return false
+          end
+
+          ui.success "[Invade] Vagrantfile is valid."
+
+          true
+        end
+
+        def reload(ui)
+
+          # Get corrent command whether in development mode or using Vagrant for real
+          unless Vagrant.in_installer? && Vagrant.very_quiet?
+            command = 'bundle exec vagrant reload'
+          else
+            command = 'vagrant reload'
+          end
+
+          ui.warn '[Invade] Auto reload Vagrant with new Vagrantfile...'
+          sleep 2
+
+          Kernel.exec(command)
+        end
+
+        def write_vagrantfile(ui, root_path, vagrantfile, vagrantfile_name, overwrite)
+
+          overwrite ?
+          vagrantfile_path = "#{root_path}/#{vagrantfile_name}" :
+          vagrantfile_path = "#{root_path}/#{vagrantfile_name}.new"
+
+          # Write new Vagrantfile
+          open(vagrantfile_path, "w+") do |f|
+            f.puts vagrantfile
+          end
+
+          overwrite ?
+          ui.warn('[Invade] Replaced old Vagrantfile.') :
+          ui.warn("[Invade] Saved new Vagrantfile as #{root_path}/#{vagrantfile_name}.new")
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-invade/action/generate.rb

@@ -0,0 +1,95 @@
+module VagrantPlugins
+  module Invade
+    module Action
+
+      include Vagrant::Action::Builtin
+
+      class Generate
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new('vagrant::invade::action::generate')
+        end
+
+        def call(env)
+
+          # Define invade config
+          config = @env[:invade]
+
+          # Iterate over each machine configuration
+          machines = config['machines']
+
+          unless machines == nil
+
+            part = Hash.new
+            definition = Hash.new
+
+            machines.each_with_index do |(machine, section), index|
+
+              # VM
+              unless section['vm'] == nil
+                part['vm'] = Generator::Section::VM.new(machine, section['vm']).generate
+              end
+
+              # NETWORK
+              unless section['network'] == nil
+                part['network'] = ''
+
+                section['network'].each do |type, data|
+                  part['network'].concat(Generator::Section::Network.new(machine, type, data).generate)
+                end
+              end
+
+              # PROVIDER
+              unless section['provider'] == nil
+                part['provider'] = ''
+
+                section['provider'].each do |type, data|
+                  parts = Generator::Section::Provider.new(machine, type, data).generate
+                  part['provider'].concat(parts)
+                end
+              end
+
+              # SYNCED FOLDER
+              unless section['synced_folder'] == nil
+                part['synced_folder'] = ''
+
+                section['synced_folder'].each do |type, data|
+                  parts = Generator::Section::SyncedFolder.new(machine, type, data).generate
+                  part['synced_folder'].concat(parts)
+                end
+              end
+
+              unless section['provision'] == nil
+                part['provision'] = ''
+
+                section['provision'].each do |type, data|
+                  parts = Generator::Section::Provision.new(machine, type, data).generate
+                  part['provision'].concat(parts)
+                end
+              end
+
+              # # SSH
+              # unless section['ssh'] == nil
+              #   part['ssh'] = Generator::Section::SSH.new(machine, section['ssh']).generate
+              # end
+
+              # Add as definition
+              definition[machine] = Generator::Definition.new(machine, part).generate
+            end
+
+            # Finally generate Vagrantfile from generated definitions and add it to Vagrant environment
+            @env[:invade]['vagrantfile'] = Generator::Vagrantfile.new(env, definition).generate
+
+            # Finally done with generating. Delete machines from Vagrant environment
+            @env[:invade].delete("machines")
+
+            @app.call(env)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-invade/action/validate.rb

@@ -0,0 +1,156 @@
+module VagrantPlugins
+  module Invade
+    module Action
+
+      include Vagrant::Action::Builtin
+
+      class Validate
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @logger = Log4r::Logger.new('vagrant::invade::action::validate')
+        end
+
+        def call(env)
+
+          config = env[:invade]
+
+          Validator.set_env(@env)
+          Validator.set_invade(@env)
+
+          ###############################################################
+          # Validate the settings and set default variables if needed
+          ###############################################################
+
+          # INVADE
+          config['invade'] = Validator::Invade.new(env, config['invade']).validate
+
+          # Iterate over each machine configuration
+          machines = config['machines']
+          unless machines == nil
+            machines.each_with_index do |(machine, sections), index|
+
+              # VM
+              unless sections['vm'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating VM configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['vm'] = Validator::VM.new(env, sections['vm']).validate
+              end
+
+              # NETWORK
+              unless sections['network'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating network configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['network'].each do |type, network|
+                  @env[:ui].info("\tNetwork: #{type}")
+                  case type
+                  when 'private', 'private_network', 'privatenetwork', 'private-network'
+                    network = Validator::Network::PrivateNetwork.new(env, network).validate
+                  when 'forwarded', 'forwarded_port', 'forwarded-port', 'forwardedport', 'port'
+                    network = Validator::Network::ForwardedPort.new(@machine_name, network).validate
+                  when 'public', 'puplic_network', 'publicnetwork', 'public-network'
+                    network = Validator::Network::PublicNetwork.new(@machine_name, network).validate
+                  else
+                    raise StandardError, "Network type unknown or not set. Please check the network configuration."
+                  end
+                end
+              end
+
+              # PROVIDER
+              unless sections['provider'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating provider configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['provider'].each do |type, provider|
+                  @env[:ui].info("\tProvider: #{type}")
+                  case type
+                  when 'virtualbox'
+                    provider = Validator::Provider::VirtualBox.new(env, provider).validate
+                  when 'vmware'
+                    provider = Validator::Provider::VMware.new(env, provider).validate
+                  else
+                    raise StandardError, "Provider unknown or not set. Please check configuration file."
+                  end
+                end
+              end
+
+              # SYNCED FOLDER
+              unless sections['synced_folder'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating synced folder configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['synced_folder'].each do |type, sf|
+                  @env[:ui].info("\tSynced Folder: #{type}")
+                  case type
+                  when 'nfs'
+                    sf = Validator::SyncedFolder::NFS.new(env, sf).validate
+                  when 'vb'
+                    sf = Validator::SyncedFolder::VB.new(env, sf).validate
+                  else
+                    raise StandardError, "Synced Folder type unknown or not set. Please check configuration file."
+                  end
+                end
+              end
+
+              # PROVISION
+              unless sections['provision'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating provision configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['provision'].each do |type, provision|
+                  @env[:ui].info("\tProvision: #{type}")
+                  case type
+                  when 'shell'
+                    provision = Validator::Provision::Shell.new(env, provision).validate
+                  when 'puppet'
+                    provision = Validator::Provision::Puppet.new(env, provision).validate
+                  else
+                    raise StandardError, "Provision type unknown or not set. Please check configuration file."
+                  end
+                end
+              end
+
+              # SSH
+              unless sections['ssh'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating SSH configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['ssh'] = Validator::SSH.new(env, sections['ssh']).validate
+              end
+
+              unless sections['plugin'] == nil
+                @env[:ui].info("\n[Invade] #{machine.upcase}: Validating plugin configuration...")
+                sleep 1 unless @env[:invade_command_quiet]
+
+                sections['plugin'].each do |type, plugin|
+                  @env[:ui].info("\tPlugin: #{type}")
+                  case type
+                  when 'hostmanager'
+                    plugin = Validator::Plugin::HostManager.new(env, plugin).validate
+                  when 'winnfsd'
+                    plugin = Validator::Plugin::WinNFSd.new(env, plugin).validate
+                  else
+                    raise StandardError, "Plugin type unknown or not set. Please check configuration file."
+                  end
+                end
+              end
+
+            end
+          end
+
+          if Validator::VALIDATION_ERRORS > 0
+            @env[:ui].warn('[Invade] Configuration has validation warnings. Use debug mode to see details.')
+          else
+            @env[:ui].success('[Invade] Configuration validated successfully.')
+          end
+
+          @app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-invade/action.rb

@@ -0,0 +1,34 @@
+require 'pathname'
+require 'vagrant/action/builder'
+
+module VagrantPlugins
+  module Invade
+    module Action
+
+      # This middleware sequence will only validate the invade configuration file
+      def self.validate
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use Config
+          builder.use Validate
+        end
+      end
+
+      # This middleware sequence will validate and build the Vagrantfile
+      def self.build
+        Vagrant::Action::Builder.new.tap do |builder|
+          builder.use Config
+          builder.use Validate
+          builder.use Generate
+          builder.use Create
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :Config, action_root.join("config")
+      autoload :Validate, action_root.join("validate")
+      autoload :Generate, action_root.join("generate")
+      autoload :Create, action_root.join("create")
+    end
+  end
+end

data/lib/vagrant-invade/builder/definition.rb

@@ -0,0 +1,43 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+
+      require 'erubis'
+
+      class Definition
+
+        attr_reader :result
+        attr_accessor :definition_data
+
+        def initialize(machine_name, definition_data, result: nil)
+          @machine_name = machine_name
+          @definition_data  = definition_data
+          @result   = result
+        end
+
+        def build
+          b = binding
+          template_file = "#{TEMPLATE_PATH}/definition.erb"
+
+          begin
+
+            # Machine name
+            machine_name = @machine_name
+
+            # Data to build definition entry
+            vm = @definition_data['vm']
+            network = @definition_data['network']
+            provider = @definition_data['provider']
+            synced_folder = @definition_data['synced_folder']
+            # provision = @definition_data['provision']
+
+            eruby = Erubis::Eruby.new(File.read(template_file))
+            @result = eruby.result b
+          rescue TypeError, SyntaxError, SystemCallError => e
+            raise(e)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/network/forwarded_port.rb

@@ -0,0 +1,47 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Network
+        require 'erubis'
+
+        class ForwardedPort
+
+          attr_reader :result
+          attr_accessor :machine_name, :forwarded_port_data
+
+          def initialize(machine_name, forwarded_port_data, result: nil)
+            @machine_name = machine_name
+            @forwarded_port_data  = forwarded_port_data
+            @result   = result
+          end
+
+          def build
+            b = binding
+            template_file = "#{TEMPLATE_PATH}/network/forwarded_port.erb"
+
+            begin
+
+              # Get machine name
+              machine_name = @machine_name
+
+              # Values for network section
+              ip = @forwarded_port_data['ip']
+              dhcp = @forwarded_port_data['dhcp']
+              guest = @forwarded_port_data['guest']
+              guest_ip = @forwarded_port_data['guest_ip']
+              host = @forwarded_port_data['host']
+              host_ip = @forwarded_port_data['host_ip']
+              protocol = @forwarded_port_data['protocol']
+              auto_correct = @forwarded_port_data['auto_correct']
+
+              eruby = Erubis::Eruby.new(File.read(template_file))
+              @result = eruby.result b
+            rescue TypeError, SyntaxError, SystemCallError => e
+              raise(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/network/private_network.rb

@@ -0,0 +1,41 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Network
+        require 'erubis'
+
+        class PrivateNetwork
+
+          attr_reader :result
+          attr_accessor :machine_name, :private_network_data
+
+          def initialize(machine_name, private_network_data, result: nil)
+            @machine_name = machine_name
+            @private_network_data = private_network_data
+            @result = result
+          end
+
+          def build
+            b = binding
+            template_file = "#{TEMPLATE_PATH}/network/private_network.erb"
+
+            begin
+              # Get machine name
+              machine_name = @machine_name
+
+              # Values for network section
+              ip = @private_network_data['ip']
+              ip ? dhcp = nil : dhcp = @private_network_data['dhcp']
+              auto_config = @private_network_data['auto_config']
+
+              eruby = Erubis::Eruby.new(File.read(template_file))
+              @result = eruby.result b
+            rescue TypeError, SyntaxError, SystemCallError => e
+              raise(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/network/public_network.rb

@@ -0,0 +1,43 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Network
+        require 'erubis'
+
+        class PublicNetwork
+
+          attr_reader :result
+          attr_accessor :machine_name, :public_network_data
+
+          def initialize(machine_name, public_network_data, result: nil)
+            @machine_name = machine_name
+            @public_network_data = public_network_data
+            @result = result
+          end
+
+          def build
+            b = binding
+            template_file = "#{TEMPLATE_PATH}/network/public_network.erb"
+
+            begin
+
+              # Get machine name
+              machine_name = @machine_name
+
+              # Values for network section
+              ip = @public_network_data['ip']
+              dhcp = @public_network_data['dhcp']
+              bridge = @public_network_data['bridge']
+              auto_config = @public_network_data['auto_config']
+
+              eruby = Erubis::Eruby.new(File.read(template_file))
+              @result = eruby.result b
+            rescue StandardError => e
+              raise(e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/network.rb

@@ -0,0 +1,13 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Network
+
+        autoload :ForwardedPort, 'vagrant-invade/builder/network/forwarded_port.rb'
+        autoload :PrivateNetwork, 'vagrant-invade/builder/network/private_network.rb'
+        autoload :PublicNetwork, 'vagrant-invade/builder/network/public_network.rb'
+
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/provider/virtualbox.rb

@@ -0,0 +1,47 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Provider
+
+        require 'erubis'
+
+        class VirtualBox
+
+          attr_reader :result
+          attr_accessor :machine_name, :virtualbox_data
+
+          def initialize(machine_name, virtualbox_data, result: nil)
+            @machine_name = machine_name
+            @virtualbox_data  = virtualbox_data
+            @result   = result
+          end
+
+          def build
+            b = binding
+            template_file = "#{TEMPLATE_PATH}/provider/virtualbox.erb"
+
+            begin
+
+              # Get machine name
+              machine_name = @machine_name
+
+              # Values for provider section
+              @virtualbox_data['name'] ? name = @virtualbox_data['name'] : name = @machine_name
+              type = @virtualbox_data['type']
+              cpus = @virtualbox_data['cores']
+              memory = @virtualbox_data['memory']
+              nicspeed = @virtualbox_data['nicspeed']
+              natdns = @virtualbox_data['natdns']
+
+              eruby = Erubis::Eruby.new(File.read(template_file))
+              @result = eruby.result b
+            rescue TypeError, SyntaxError, SystemCallError => e
+              raise(e)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/provider/vmware.rb

@@ -0,0 +1,44 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Provider
+
+        require 'erubis'
+
+        class VMware
+
+          attr_reader :result
+          attr_accessor :machine_name, :vmware_data
+
+          def initialize(machine_name, vmware_data, result: nil)
+            @machine_name = machine_name
+            @vmware_data  = vmware_data
+            @result   = result
+          end
+
+          def build
+            b = binding
+            template_file = "#{TEMPLATE_PATH}/provider/vmware.erb"
+
+            begin
+
+              # Get machine name
+              machine_name = @machine_name
+
+              # Values for provider section
+              @vmware_data['name'] ? name = @vmware_data['name'] : name = @machine_name
+              cpus = @vmware_data['cores']
+              memory  = @vmware_data['memory']
+
+              eruby = Erubis::Eruby.new(File.read(template_file))
+              @result = eruby.result b
+            rescue TypeError, SyntaxError, SystemCallError => e
+              raise(e)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-invade/builder/provider.rb

@@ -0,0 +1,12 @@
+module VagrantPlugins
+  module Invade
+    module Builder
+      module Provider
+
+        autoload :VirtualBox, 'vagrant-invade/builder/provider/virtualbox.rb'
+        autoload :VMware, 'vagrant-invade/builder/provider/vmware.rb'
+
+      end
+    end
+  end
+end