veewee-atlassian 0.3.11

data/lib/veewee/provider/core/box/build.rb

@@ -0,0 +1,287 @@
+module Veewee
+  module Provider
+    module Core
+      module BoxCommand
+
+        def build(options={})
+
+          if definition.nil?
+            raise Veewee::Error,"Could not find the definition. Make sure you are one level above the definitions directory when you execute the build command."
+          end
+
+          # Requires valid definition
+
+          ui.info "Building Box #{name} with Definition #{definition.name}:"
+          options.each do |name,value|
+            ui.info "- #{name} : #{value}"
+          end
+
+          # Checking regexp of postinstall include/excludes
+          validate_postinstall_regex(options)
+
+          # Check the iso file we need to build the box
+          definition.verify_iso(options)
+
+          if self.exists?
+            # check if --force option was given
+            if options['force']==true
+              self.destroy
+              self.reload
+            else
+              ui.error("you need to provide --force because the box #{name} already exists",:prefix => false)
+              raise Veewee::Error,"you need to provide --force because the box #{name} already exists"
+            end
+          end
+
+          # By now the box should have been gone, just checking again
+          if self.exists?
+            ui.error("The box should have been deleted by now. Something went terribly wrong. Sorry",:prefix => false)
+            raise Veewee::Error, "The box should have been deleted by now. Something went terribly wrong. Sorry"
+          end
+
+          self.create(options)
+
+          # Check the GUI mode required
+          env.logger.info "Provider asks the box to start: GUI enabled? #{!options['nogui']}"
+          self.up(options)
+
+          # Waiting for it to boot
+          ui.info "Waiting #{definition.boot_wait.to_i} seconds for the machine to boot"
+          sleep definition.boot_wait.to_i
+
+          # Calculate an available kickstart port
+          unless definition.kickstart_port.nil?
+            guessed_port=guess_free_port(definition.kickstart_port.to_i,7199).to_s
+            if guessed_port.to_s!=definition.kickstart_port
+              ui.warn "Changing kickstart port from #{definition.kickstart_port} to #{guessed_port}"
+              definition.kickstart_port=guessed_port.to_s
+            end
+          end
+
+          # Let fill's in the variable we need
+          boot_sequence=fill_sequence(definition.boot_cmd_sequence,{
+            :ip =>host_ip_as_seen_by_guest,
+            :port => definition.kickstart_port.to_s,
+            :name => name
+          })
+
+          # Type the boot sequence
+          Thread.new { self.console_type(boot_sequence) }
+
+          self.handle_kickstart(options)
+
+          # Wait for an ipaddress
+          # This needs to be done after the kickstart:
+          # As the dhcp request will likely occur just before the kickstart fetch
+          until !self.ip_address.nil?
+            env.logger.info "wait for Ip address"
+            sleep 2
+          end
+
+
+          if ! definition.skip_iso_transfer then
+            self.transfer_buildinfo(options)
+          end
+
+          # Filtering post install files based upon --postinstall-include and --postinstall--exclude
+          definition.postinstall_files=filter_postinstall_files(options)
+
+          self.handle_postinstall(options)
+
+          ui.success "The box #{name} was built successfully!"
+          ui.info "You can now login to the box with:"
+          if (definition.winrm_user && definition.winrm_password)
+            env.ui.info winrm_command_string
+          else
+            env.ui.info ssh_command_string
+          end
+
+          return self
+        end
+
+        def validate_postinstall_regex(options)
+          env.logger.info "Checking the postinstall excludes"
+          unless options["postinstall_exclude"].nil?
+            options["postinstall_exclude"].each do |p|
+              begin
+                r=::Regexp.new(p)
+              rescue ::RegexpError => ex
+                raise Veewee::Error ,"\nError in postinstall exclude (ruby regexp) pattern: #{p}:\n- #{ex}"
+              end
+            end
+          end
+
+          env.logger.info "Checking the postinstall includes"
+          unless options["postinstall_include"].nil?
+            options["postinstall_include"].each do |p|
+              begin
+                r=Regexp.new(p)
+              rescue RegexpError => ex
+                raise Veewee::Error ,"\nError in postinstall include (ruby regexp) pattern: #{p}:\n- #{ex}"
+              end
+            end
+          end
+        end
+
+        def filter_postinstall_files(options)
+          new_definition=definition.clone
+
+          env.logger.info "Applying the postinstall excludes"
+          unless options["postinstall_exclude"].nil?
+            options["postinstall_exclude"].each do |p|
+              env.logger.info "Exclude pattern #{p}"
+              new_definition.postinstall_files.reject! { |f| f.match(p) }
+            end
+          end
+
+          env.logger.info "Applying the postinstall includes"
+          unless options["postinstall_include"].nil?
+            options["postinstall_include"].each do |p|
+              env.logger.info "Include pattern #{p}"
+              new_definition.postinstall_files.collect! { |f| f.match(p) ? f.gsub(/^_/,""): f}
+            end
+          end
+
+          env.logger.info "filtered postinstall files:"
+          new_definition.postinstall_files.each do |p|
+            env.logger.info "- "+p
+          end
+
+          return new_definition.postinstall_files
+        end
+
+
+
+        # This will take a sequence and fill in the variables specified in the options
+        # f.i. options={:ip => "name"} will substitute "%IP%" -> "name"
+        def fill_sequence(sequence,options)
+          filled=sequence.dup
+          options.each do |key,value|
+            filled.each do |s|
+              s.gsub!("%#{key.to_s.upcase}%",value)
+            end
+          end
+          return filled
+        end
+
+        def build_info
+          [ {:filename => ".veewee_version",:content => "#{Veewee::VERSION}"}]
+        end
+
+        # This function handles all the post-install scripts
+        # It requires a definition to find all the necessary information
+        def handle_kickstart(options)
+
+          # Handling the kickstart by web
+          kickstartfiles=definition.kickstart_file
+
+          if kickstartfiles.nil? || kickstartfiles.length == 0
+            env.ui.info "Skipping webserver as no kickstartfile was specified"
+          else
+            env.ui.info "Starting a webserver #{definition.kickstart_ip}:#{definition.kickstart_port}\n"
+          end
+
+          # Check if the kickstart is an array or a single string
+          if kickstartfiles.is_a?(String)
+            # Let's turn it into an array
+            kickstartfiles=kickstartfiles.split
+          end
+
+          # For each kickstart file spinup a webserver and wait for the file to be fetched
+          unless kickstartfiles.nil?
+            kickstartfiles.each do |kickfile|
+              wait_for_http_request(kickfile,{
+                :port => definition.kickstart_port,
+                :host => definition.kickstart_ip,
+                :timeout => definition.kickstart_timeout,
+                :web_dir => definition.path
+              })
+            end
+          end
+        end
+
+        # This function handles all the post-install scripts
+        # It requires a box(to login to) and a definition(listing the postinstall files)
+        def handle_postinstall(options)
+
+          # Transfer all postinstall files
+          definition.postinstall_files.each do |postinstall_file|
+            # Filenames of postinstall_files are relative to their definition
+            filename=File.join(definition.path,postinstall_file)
+            self.copy_to_box(filename,File.basename(filename))
+            if not (definition.winrm_user && definition.winrm_password)
+              self.exec("chmod +x \"#{File.basename(filename)}\"")
+            end
+          end
+
+          # Prepare a pre_poinstall file if needed (not nil , or not empty)
+          unless definition.pre_postinstall_file.to_s.empty?
+            pre_filename=File.join(definition.path, definition.pre_postinstall_file)
+            self.copy_to_box(filename,File.basename(pre_filename))
+            if (definition.winrm_user && definition.winrm_password)
+              # not implemented on windows yet
+            else
+              self.exec("chmod +x \"#{File.basename(pre_filename)}\"")
+              # Inject the call to the real script by executing the first argument (it will be the postinstall script file name to be executed)
+              self.exec("execute=\"\\n# We must execute the script passed as the first argument\\n\\$1\" && printf \"%b\\n\" \"$execute\" >> #{File.basename(pre_filename)}")
+            end
+          end
+
+          # Now iterate over the postinstall files
+          definition.postinstall_files.each do |postinstall_file|
+            # Filenames of postinstall_files are relative to their definition
+            filename=File.join(definition.path,postinstall_file)
+
+            unless File.basename(postinstall_file).start_with?("_")
+
+              unless definition.pre_postinstall_file.to_s.empty?
+                raise 'not implemented on windows yet' if (definition.winrm_user && definition.winrm_password)
+                # Filename of pre_postinstall_file are relative to their definition
+                pre_filename=File.join(definition.path, definition.pre_postinstall_file)
+                # Upload the pre postinstall script if not already transfered
+                command = "./" + File.basename(pre_filename)
+                command = sudo(command) + " ./"+File.basename(filename)
+              else
+                if (definition.winrm_user && definition.winrm_password)
+                  # no sudo on windows, batch files only please?
+                  self.exec(File.basename(filename))
+                else
+                  self.exec(sudo("./"+File.basename(filename)))
+                end
+              end
+
+              self.exec(command)
+
+            else
+              env.logger.info "Skipping postinstallfile #{postinstall_file}"
+            end
+          end
+        end
+
+        # Transfer information provide by the Provider to the box
+        #
+        #
+        def transfer_buildinfo(options)
+          build_info.each do |info|
+            begin
+              infofile=Tempfile.open("#{info[:filename]}")
+              # Force binary mode to prevent windows from putting CR-LF end line style
+              # http://www.ruby-forum.com/topic/127453#568546
+              infofile.binmode
+              infofile.puts "#{info[:content]}"
+              infofile.rewind
+              infofile.close
+              self.copy_to_box(infofile.path,info[:filename])
+              infofile.delete
+            rescue RuntimeError => ex
+              ui.error("Error transfering file #{info[:filename]} failed, possible not enough permissions to write? #{ex}",:prefix => false)
+              raise Veewee::Error,"Error transfering file #{info[:filename]} failed, possible not enough permissions to write? #{ex}"
+            end
+          end
+        end
+
+
+      end #Module
+    end #Module
+  end #Module
+end #Module

data/lib/veewee/provider/core/box/copy.rb

@@ -0,0 +1,17 @@
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def copy_to_box(localfile,remotefile,options={})
+          raise Veewee::Error,"Box is not running" unless self.running?
+          if definition.winrm_user && definition.winrm_password # prefer winrm 
+            self.wincp(localfile,remotefile,options)
+          else
+            self.scp(localfile,remotefile,options)
+          end
+        end
+      end # Module
+    end # Module
+  end # Module
+end # Module

data/lib/veewee/provider/core/box/exec.rb

@@ -0,0 +1,53 @@
+require 'veewee/provider/core/helper/ssh'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def ssh_command_string
+         "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p #{ssh_options[:port]} -l #{definition.ssh_user} #{self.ip_address}"
+        end
+
+        def winrm_command_string
+          "knife winrm -m #{self.ip_address} -P #{winrm_options[:port]} -x #{definition.winrm_user}" +
+            " -P #{definition.winrm_password} COMMAND"
+        end
+
+        def exec(command,options={})
+          raise Veewee::Error,"Box is not running" unless self.running?
+          if definition.winrm_user && definition.winrm_password
+            begin
+              new_options=winrm_options.merge(options)
+              self.when_winrm_login_works(self.ip_address,winrm_options.merge(options)) do
+                result = self.winrm_execute(self.ip_address,command,new_options)
+                return result
+              end
+            rescue RuntimeError => ex
+              env.ui.error "Error executing command #{command} : #{ex}"
+              raise Veewee::WinrmError, ex
+            end
+          else # definition.ssh_user && definition.ssh_password
+            begin
+              new_options=ssh_options.merge(options)
+              self.when_ssh_login_works(self.ip_address,new_options) do
+                begin
+                  env.logger.info "About to execute remote command #{command} on box #{name} - #{self.ip_address} - #{new_options}"
+                  result=self.ssh_execute(self.ip_address,command,new_options)
+                  return result
+                rescue RuntimeError => ex
+                  env.ui.error "Error executing command #{command} : #{ex}"
+                  raise Veewee::SshError, ex
+                end
+              end
+            rescue Net::SSH::AuthenticationFailed => ex # may want to catch winrm auth fails as well
+              env.ui.error "Authentication failure"
+              raise Veewee::SshError, "Authentication failure\n"+ex
+            end
+          end
+
+
+        end
+      end # Module
+    end # Module
+  end # Module
+end # Module

data/lib/veewee/provider/core/box/floppy.rb

@@ -0,0 +1,32 @@
+module Veewee
+  module Provider
+    module Core
+      module BoxCommand
+        def create_floppy(floppy_filename)
+          # Todo Check for java
+          # Todo check output of commands
+          # Todo allow for .erb templates
+
+          # Check for floppy
+          unless definition.floppy_files.nil?
+            require 'tmpdir'
+            temp_dir=Dir.mktmpdir
+            definition.floppy_files.each do |filename|
+              full_filename=full_filename=File.join(definition.path,filename)
+              FileUtils.cp("#{full_filename}","#{temp_dir}")
+            end
+            javacode_dir=File.expand_path(File.join(__FILE__,'..','..','..','..','..','java'))
+            floppy_file=File.join(definition.path,floppy_filename)
+            if File.exists?(floppy_file)
+              env.logger.info "Removing previous floppy file"
+              FileUtils.rm(floppy_file)
+            end
+            command="java -jar #{javacode_dir}/dir2floppy.jar \"#{temp_dir}\" \"#{floppy_file}\""
+            shell_exec("#{command}")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/veewee/provider/core/box/halt.rb

@@ -0,0 +1,28 @@
+require 'veewee/provider/core/helper/ssh'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def halt(options={})
+          if self.running?
+            if options["force"]==true
+              self.poweroff
+            else
+              if definition.winrm_user && definition.winrm_password # prefer winrm 
+                self.exec("#{definition.shutdown_cmd}")
+              else
+                self.exec("echo '#{definition.shutdown_cmd}' > /tmp/shutdown.sh")
+                self.exec("chmod +x /tmp/shutdown.sh")
+                self.exec(sudo("/tmp/shutdown.sh"))
+              end
+            end
+          else
+            raise Veewee::Error,"Box is not running"
+          end
+        end
+
+      end # Module
+    end # Module
+  end # Module
+end # Module

data/lib/veewee/provider/core/box/issh.rb

@@ -0,0 +1,15 @@
+require 'veewee/provider/core/helper/ssh'
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def issh(command=nil,options={})
+          self.ssh(command,options.merge({:interactive => true}))
+        end
+
+      end # Module
+    end # Module
+  end # Module
+end # Module
+

data/lib/veewee/provider/core/box/poweroff.rb

@@ -0,0 +1,12 @@
+module Veewee
+  module Provider
+    module  Core
+      module BoxCommand
+
+        def poweroff(options={})
+        end
+
+      end # Module
+    end # Module
+  end # Module
+end # Module