veewee 0.2.3 → 0.3.0.alpha1

data/lib/veewee/builder/core/builder.rb

@@ -0,0 +1,90 @@
+require 'veewee/util/tcp'
+require 'veewee/util/web'
+require 'veewee/util/ssh'
+require 'veewee/util/shell'
+
+
+require 'veewee/builder/core/builder/build.rb'
+require 'veewee/builder/core/builder/iso.rb'
+
+module Veewee
+  module Builder
+    module Core
+      class Builder
+
+        attr_accessor :env
+        attr_accessor :options
+
+        attr_accessor :type
+        attr_accessor :name
+
+        include ::Veewee::Builder::Core::BuilderCommand
+        include ::Veewee::Util::Tcp
+        include ::Veewee::Util::Web
+        include ::Veewee::Util::Ssh
+        include ::Veewee::Util::Shell
+
+        def initialize(name,options,env)
+
+          @env=env
+          @name=name
+          @options=options
+          @type=self.class.to_s.split("::")[-2]
+          check_requirements
+        end
+
+        def get_definition(name)
+          env.logger.info("fetching definition #{name}")
+          definition=env.get_definition(name)
+          return definition
+        end
+
+        def get_box(name)
+          begin
+            require_path='veewee/builder/'+type.to_s.downcase+"/box.rb"
+            require require_path
+
+            # Get a real box object from the builder
+            box=Object.const_get("Veewee").const_get("Builder").const_get(type.to_s.capitalize).const_get("Box").new(name,env)
+          rescue Error => ex
+            env.ui.error "Could not instante the box #{name} with provider #{type} ,#{ex}"
+          end
+        end
+
+        def self.available?
+          begin
+            self.check_requirements
+            return true
+          rescue Error
+            return false
+          end
+        end
+
+        def gem_available?(gemname)
+            env.logger.info "Checking for gem #{gemname}"
+            available=false
+            begin
+              available=true unless Gem::Specification::find_by_name("#{gemname}").nil?
+            rescue Gem::LoadError
+              env.logger.info "Error loading gem #{gemname}"
+              available=false
+            rescue
+              env.logger.info "Falling back to old syntax for #{gemname}"
+              available=Gem.available?("#{gemname}")
+              env.logger.info "Old syntax #{gemname}.available? #{available}"
+            end
+            return available
+        end
+
+        def gems_available?(names)
+          names.each do |gemname|
+            return false if !gem_available?(gemname)
+          end
+          return true
+        end
+
+      end #End Class
+
+    end #End Module
+  end #End Module
+end #End Module

data/lib/veewee/builder/core/builder/build.rb

@@ -0,0 +1,250 @@
+module Veewee
+  module Builder
+    module Core
+      module BuilderCommand
+
+        def build(definition_name,box_name,options)
+
+          definition=get_definition(definition_name)
+
+          if definition.nil?
+            env.ui.error "The definition #{definition_name} does not exist. Sorry"
+            exit -1
+          end
+
+          # If no box_name was given, let's give the box the same name as the definition
+          if box_name.nil?
+            box_name=definition_name
+          end
+
+          env.ui.info "Building #{definition_name} #{box_name} #{options}"
+
+          # Check the iso file we need to build the box
+          verify_iso(definition,options)
+
+          box=get_box(box_name)
+
+          if box.exists?
+            # check if --force option was given
+            if options[:force]==true
+              box.destroy
+              box.reload
+            else
+              env.ui.error "you need to provide --force because the box #{box_name} already exists"
+              exit -1
+            end
+          end
+
+          # By now the box should have been gone, just checking again
+          if box.exists?
+            env.ui.error "The box should have been deleted by now. Something went terribly wrong. Sorry"
+            exit -1
+          end
+
+          # By now the machine if it existed, should have been shutdown
+          # The last thing to check is if the power we are supposed to ssh to, is still open
+
+
+          #          if is_tcp_port_open?(box.ip_address, ssh_options(definition)[:port])
+          #            env.ui.info "Hmm, the  #{box.ip_address}:#{ssh_options(definition)[:port]} is open. And we shut down?"
+          #            exit -1
+          #          end
+
+          # Filtering post install files based upon --postinstall-include and --postinstall--exclude
+          definition.postinstall_files=filter_postinstall_files(definition,options)
+
+          box.create(definition)
+
+          # Check the GUI mode required
+          env.logger.info "Builder asks the box to start: GUI enabled? #{!options[:nogui]}"
+          gui_enabled=options[:nogui]==true ? false : true
+          box.start(gui_enabled)
+
+          # Waiting for it to boot
+          env.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
+          guessed_port=guess_free_port(definition.kickstart_port.to_i,7199).to_s
+          if guessed_port.to_s!=definition.kickstart_port
+            env.ui.warn "Changing kickstart port from #{definition.kickstart_port} to #{guessed_port}"
+            definition.kickstart_port=guessed_port.to_s
+          end
+
+          # Let fill's in the variable we need
+          boot_sequence=fill_sequence(definition.boot_cmd_sequence,{
+            :ip =>get_local_ip,
+            :port => definition.kickstart_port.to_s,
+            :name => box.name
+          })
+
+          box.console_type(boot_sequence)
+
+          until !box.ip_address.nil?
+            env.logger.info "wait for Ip addres"
+            sleep 2
+          end
+
+          handle_kickstart(definition)
+
+          transfer_buildinfo(box,definition)
+
+          handle_postinstall(box,definition)
+
+          env.ui.confirm "The box #{box_name} was build succesfully!"
+          env.ui.info "You can now login to the box with:"
+          env.ui.info "\nssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p #{ssh_options(definition)[:port]} -l #{definition.ssh_user} #{box.ip_address}"
+
+          return box
+        end
+
+        def filter_postinstall_files(definition,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.collect! { |f| f.match(p) ? f.gsub(/^/,"_"): f}
+            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(definition)
+
+          # 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"
+          end
+
+          env.ui.info "Starting a webserver #{definition.kickstart_ip}:#{definition.kickstart_port}\n"
+
+          # 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(box,definition)
+
+          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)=~/^_/
+              begin
+                when_ssh_login_works(box.ip_address,ssh_options(definition).merge({:timeout => definition.postinstall_timeout.to_i})) do
+                  begin
+                    env.logger.info "About to transfer #{filename} to the box #{box.name} - #{box.ip_address} - #{ssh_options(definition)}"
+                    ssh_transfer_file(box.ip_address,filename,File.basename(filename),ssh_options(definition))
+                  rescue RuntimeError => ex
+                    env.ui.error "error transfering file #{File.basename(filename)}, possible not enough permissions to write? #{ex}"
+                    exit -1
+                  end
+                  command=definition.sudo_cmd
+                  newcommand=command.gsub(/%p/,"#{definition.ssh_password}")
+                  newcommand.gsub!(/%u/,"#{definition.ssh_user}")
+                  newcommand.gsub!(/%f/,"#{postinstall_file}")
+                  begin
+                    ssh_exec(box.ip_address,"#{newcommand}",ssh_options(definition))
+                  rescue RuntimeError => ex
+                    env.ui.error "Error executing the command #{newcommand}: #{ex}"
+                    exit -1
+                  end
+                end
+              rescue Net::SSH::AuthenticationFailed
+                env.ui.error "Authentication failure"
+                exit -1
+              end
+            else
+              env.logger.info "Skipping postinstallfile #{postinstall_file}"
+            end
+          end
+        end
+
+
+        # Transfer information provide by the builder to the box
+        #
+        #
+        def transfer_buildinfo(box,definition)
+          begin
+            when_ssh_login_works(box.ip_address,ssh_options(definition).merge({:timeout => definition.postinstall_timeout.to_i})) do
+              build_info.each do |info|
+                begin
+                  infofile=Tempfile.open("#{info[:filename]}")
+                  infofile.puts "#{info[:content]}"
+                  infofile.rewind
+                  env.logger.info "About to transfer buildinfo #{info[:content]} into #{info[:filename]} to the box #{box.name} - #{box.ip_address} - #{ssh_options(definition)}"
+                  ssh_transfer_file(box.ip_address,infofile.path,info[:filename],ssh_options(definition))
+                  infofile.close
+                  infofile.delete
+                rescue RuntimeError => ex
+                  env.ui.error "Error transfering file #{info[:filename]} failed, possible not enough permissions to write? #{ex}"
+                  exit -1
+                end
+              end
+            end
+          rescue Net::SSH::AuthenticationFailed
+            env.ui.error "Authentication failure"
+            exit -1
+          end
+
+        end
+
+      end #Module
+    end #Module
+  end #Module
+end #Module

data/lib/veewee/builder/core/builder/iso.rb

@@ -0,0 +1,120 @@
+module Veewee
+  module Builder
+    module Core
+      module BuilderCommand
+
+        require 'open-uri'
+        require 'progressbar'
+        require 'highline/import'
+        require 'digest/md5'
+
+        def download_progress(url,localfile)
+          pbar = nil
+          URI.parse(url).open(
+            :content_length_proc => lambda {|t|
+            if t && 0 < t
+              pbar = ProgressBar.new("Fetching file", t)
+              pbar.file_transfer_mode
+            end
+          },
+            :progress_proc => lambda {|s|
+            pbar.set s if pbar
+          }) { |src|
+            open("#{localfile}","wb") { |dst|
+              dst.write(src.read)
+            }
+          }
+        end
+
+        # Compute hash code
+        def hashsum(filename)
+          checksum=Digest::MD5.new
+          buflen=1024
+          open(filename, "r") do |io|
+            counter = 0
+            while (!io.eof)
+              readBuf = io.readpartial(buflen)
+              env.ui.info('.',{:new_line => false}) if ((counter+=1) % 20000 == 0)
+              checksum.update(readBuf)
+            end
+          end
+          return checksum.hexdigest
+        end
+
+
+        def verify_iso(definition,options)
+          filename=definition.iso_file
+          full_path=File.join(env.config.veewee.iso_dir,filename)
+
+          if File.exists?(full_path)
+            env.ui.info ""
+            env.ui.info "The isofile #{filename} already exists."
+          else
+
+            path1=Pathname.new(full_path)
+            path2=Pathname.new(Dir.pwd)
+            rel_path=path1.relative_path_from(path2).to_s
+
+            env.ui.info ""
+            env.ui.info "We did not find an isofile in <currentdir>/iso. \n\nThe definition provided the following download information:"
+            unless "#{definition.iso_src}"==""
+              env.ui.info "- Download url: #{definition.iso_src}"
+            end
+            env.ui.info "- Md5 Checksum: #{definition.iso_md5}"
+            env.ui.info "#{definition.iso_download_instructions}"
+            env.ui.info ""
+
+            if definition.iso_src == ""
+              env.ui.info "Please follow the instructions above:"
+              env.ui.info "- to get the ISO"
+              env.ui.info" - put it in <currentdir>/iso"
+              env.ui.info "- then re-run the command"
+              env.ui.info ""
+              exit -1
+            else
+              answer=nil
+              answer="yes" if options["auto"]==true
+              env.logger.info "Auto download enabled?#{answer} #{!options['auto'].nil?}"
+              if answer.nil?
+                answer=env.ui.ask("Download? (Yes/No)") {|q| q.default="No"}
+              end
+
+              if answer.downcase == "yes"
+                if !File.exists?(env.config.veewee.iso_dir)
+                  env.ui.info "Creating an iso directory"
+                  FileUtils.mkdir(env.config.veewee.iso_dir)
+                end
+                begin
+                  download_progress(definition.iso_src,full_path)
+                rescue OpenURI::HTTPError => ex
+                  env.ui.error "There was an error downloading #{definition.iso_src}:"
+                  env.ui.error "#{ex}"
+                  exit -1
+                end
+              else
+                env.ui.info "You have selected manual download: "
+                env.ui.info "curl -C - -L '#{definition.iso_src}' -o '#{rel_path}'"
+                env.ui.info "md5 '#{rel_path}' "
+                env.ui.info ""
+                exit
+              end
+
+              env.ui.info "Verifying md5 checksum : #{definition.iso_md5}"
+              file_md5=hashsum(full_path)
+
+              unless file_md5==definition.iso_md5
+                env.ui.error "The MD5 checksums for file #{filename } do not match: "
+                env.ui.error "- #{file_md5} (current) vs #{definition.iso_md5} (specified)"
+                exit -1
+              end
+
+            end
+
+          end
+
+        end
+      end #Module
+
+    end #Module
+  end #Module
+end #Module