veewee 0.2.3 → 0.3.0.alpha1

data/lib/veewee/config/builders.rb

@@ -0,0 +1,36 @@
+require 'veewee/config/component'
+require 'ostruct'
+
+module Veewee
+  class Config
+
+    class Builders
+      def initialize(env)
+        @env=env
+        @builders=Hash.new
+      end
+
+      def [](name)
+             return @builders[name] if @builders.has_key?(name)
+
+             begin
+               # Now that we know the actual builder, we can check if the builder has this type of component
+               require_path='veewee/builder/'+name.to_s.downcase+"/builder"
+               require require_path
+
+               # Now we can create the real builder
+               real_builder=Object.const_get("Veewee").const_get("Builder").const_get(name.to_s.capitalize).const_get("Builder").new(name,{},@env)
+             rescue ::Veewee::Error => e
+                raise
+             rescue Error => e
+               env.ui.error "Error loading builder with #{name},#{$!}"
+             end
+      end
+
+      def length
+        @builders.length
+      end
+
+    end
+  end
+end #Module Veewee

data/lib/veewee/config/collection.rb

@@ -0,0 +1,82 @@
+require 'veewee/config/component'
+require 'ostruct'
+
+module Veewee
+  class Config
+    class Collection
+
+      attr_accessor :components
+      attr_accessor :type
+      attr_accessor :config
+
+      attr_reader   :env
+
+      def initialize(type,config)
+        @type=type
+        @components=Hash.new
+        @providers=config.providers
+        @config=config
+        @env=config.env
+      end
+
+      def define(name)
+        # We do this for vagrant syntax
+        # Depending on type, we create a variable of that type
+        # f.i. component_stub.vm or component_stub.lb
+        component_stub=OpenStruct.new
+        component_stub.send("#{@type}=",::Veewee::Config::Component.new(config))
+
+        env.logger.info("config collection"){ "First pass of reading the config"}
+        # Now we can 'execute' the config file using our stub component
+        # For guessing the provider type
+        yield component_stub
+
+        env.logger.debug("config collection"){ "Stubs collection type #{@type} is loaded"}
+
+        # After processing we extract the component again
+        component=component_stub.send("#{@type}")
+        provider=@providers[component.provider.to_s]
+
+        env.logger.debug("config collection"){ "We get here"}
+
+        abort "Provider #{component.provider.to_s} does not (yet) exist" if provider.nil?
+        real_component=provider.get_component(@type.capitalize,env)
+        begin
+
+          # And repeat the same process with a real component
+          env.logger.debug("config collection"){ "Component of #{@type}"}
+
+          component_stub.send("#{@type}=",real_component)
+
+          yield component_stub
+          # After processing we extract the component again
+          component=component_stub.send("#{@type}")
+          # And we set the name
+          component.name=name
+
+          # We set the provider for this component
+          component.provider=provider
+
+          # And register this component with the provider
+          # if it is a vm, we add to the hash vms
+          # if it is an ip, we add it to the hash ips
+          provider_collection=provider.instance_variable_get("@#{@type}s")
+          provider_collection[name]=component
+
+          # And we also add it to the global config element
+          # So we can have all components of a similar type in one place
+          config_collection=@config.instance_variable_get("@#{@type}s")
+          config_collection[name]=component
+
+          # Now we can ask the component to validate itself
+          #component_stub.validate
+          components[name.to_s]=component
+
+        rescue Error => e
+          env.ui.error "Error loading component with #{name} of type #{@type} for provider #{component.provider.type}"
+        end
+      end
+
+    end
+  end
+end #Module Veewee

data/lib/veewee/config/component.rb

@@ -0,0 +1,19 @@
+module Veewee
+  class Config
+    class Component
+
+      attr_accessor :provider
+      
+      attr_reader   :env
+
+      def initialize(config)
+        @env=config.env
+      end
+
+      def method_missing(m, *args, &block)  
+#         env.ui.info "There's no method called #{m} here -- please try again."  
+       end
+             
+    end
+  end
+end #Module Veewee

data/lib/veewee/config/definition.rb

@@ -0,0 +1,44 @@
+require 'veewee/config/component'
+require 'veewee/definition'
+
+require 'ostruct'
+
+module Veewee
+  class Config
+    class Definition
+
+      attr_accessor :components
+      attr_reader :env
+
+      def initialize(config)
+        @env=config.env
+        @components=Hash.new
+      end
+      
+      # Currently not used, this is in case we will specify the a definition in the Veeweefile
+      # This is for future needs
+      def define(name)
+        # Depending on type, we create a variable of that type
+        definition_stub=OpenStruct.new
+
+        begin        
+        # Get a real definition object
+        real_definition=::Veewee::Definition.new(name,env)
+        rescue Error => e
+          env.ui.error "Error loading provider with #{name},#{$!}"
+        end
+        
+        definition_stub.definition=real_definition
+
+        env.logger.debug("config definition"){ "Start defining definition"}
+
+        yield definition_stub
+
+        env.logger.debug("config definition"){ "End defining definition #{definition_stub.definition.name}"}
+
+        components[name.to_s]=definition_stub.definition
+      end
+
+    end
+  end
+end #Module Veewee

data/lib/veewee/config/ostypes.yml

@@ -0,0 +1,165 @@
+--- 
+Other: 
+  :fusion: other
+  :kvm:
+  :vbox: Other
+Other: 
+  :fusion: other-64
+  :kvm:
+  :vbox: Other
+FreeBSD: 
+  :fusion: freeBSD
+  :kvm:
+  :vbox: FreeBSD
+FreeBSD_64: 
+  :fusion: FreeBSD_64
+  :kvm:
+  :vbox: FreeBSD-64
+Oracle: 
+  :fusion: oraclelinux
+  :kvm:
+  :vbox: Oracle
+Oracle_64: 
+  :fusion: oraclelinux-64
+  :kvm:
+  :vbox: Oracle_64
+Debian: 
+  :fusion: debian5
+  :kvm:
+  :vbox: Debian
+Debian_64: 
+  :fusion: debian5-64
+  :kvm:
+  :vbox: Debian_64
+Gentoo: 
+  :fusion: other26xlinux
+  :kvm:
+  :vbox: Gentoo
+Gentoo_64: 
+  :fusion: other26xlinux-64
+  :kvm:
+  :vbox: Gentoo_64
+Linux22: 
+  :fusion: linux
+  :kvm:
+  :vbox: Linux22
+Linux24: 
+  :fusion: other24xlinux
+  :kvm:
+  :vbox: Linux24
+Linux24_64: 
+  :fusion: other24xlinux-64
+  :kvm:
+  :vbox: Linux24_64
+Linux26: 
+  :fusion: other26xlinux
+  :kvm:
+  :vbox: Linux26
+Linux26_64: 
+  :fusion: other26xlinux-64
+  :kvm:
+  :vbox: Linux26_64
+RedHat: 
+  :fusion: RedHat
+  :kvm:
+  :vbox: RedHat
+RedHat_64: 
+  :fusion: RedHat_64
+  :kvm:
+  :vbox: RedHat_64
+Centos: 
+  :fusion: centos
+  :kvm:
+  :vbox: RedHat
+Centos_64: 
+  :fusion: centos-64
+  :kvm:
+  :vbox: RedHat_64
+ArchLinux: 
+  :fusion: other26xlinux
+  :kvm:
+  :vbox: ArchLinux
+ArchLinux_64: 
+  :fusion: other26xlinux-64
+  :kvm:
+  :vbox: ArchLinux_64
+OpenSUSE: 
+  :fusion: opensuse
+  :kvm:
+  :vbox: OpenSUSE
+OpenSUSE_64: 
+  :fusion: opensuse-64
+  :kvm:
+  :vbox: OpenSUSE_64
+SUSE: 
+  :fusion: suse
+  :kvm:
+  :vbox: OpenSUSE
+SUSE_64: 
+  :fusion: suse-64
+  :kvm:
+  :vbox: OpenSUSE_64
+Fedora: 
+  :fusion: fedora
+  :kvm:
+  :vbox: Fedora
+Fedora_64: 
+  :fusion: fedora-64
+  :kvm:
+  :vbox: Fedora_64
+Ubuntu: 
+  :fusion: ubuntu
+  :kvm:
+  :vbox: Ubuntu
+Ubuntu_64: 
+  :fusion: ubuntu-64
+  :kvm:
+  :vbox: Ubuntu_64
+Linux: 
+  :fusion: linux
+  :kvm:
+  :vbox: Linux
+Solaris: 
+  :fusion: solaris10
+  :kvm:
+  :vbox: Solaris
+Solaris_64: 
+  :fusion: solaris10-64
+  :kvm:
+  :vbox: Solaris_64
+Solaris9: 
+  :fusion: solaris
+  :kvm:
+  :vbox: Solaris
+Solaris7: 
+  :fusion: solaris7
+  :kvm:
+  :vbox: Solaris
+Solaris8: 
+  :fusion: solaris8
+  :kvm:
+  :vbox: Solaris
+OpenSolaris: 
+  :fusion: solaris10
+  :kvm:
+  :vbox: OpenSolaris
+OpenSolaris_64: 
+  :fusion: solaris-64
+  :kvm:
+  :vbox: OpenSolaris_64
+OpenBSD: 
+  :fusion: other
+  :kvm:
+  :vbox: OpenBSD
+OpenBSD_64: 
+  :fusion: other-64
+  :kvm:
+  :vbox: OpenBSD_64
+NetBSD: 
+  :fusion: other
+  :kvm:
+  :vbox: NetBSD
+NetBSD_64: 
+  :fusion: other-64
+  :kvm:
+  :vbox: NetBSD_64

data/lib/veewee/config/veewee.rb

@@ -0,0 +1,21 @@
+module Veewee
+  class Config
+    class Veewee
+
+      attr_reader :env
+
+      def initialize(config)
+        @env=config.env
+        env.logger.info("Initializing veewee config object")
+      end
+
+      def method_missing(m, *args, &block)
+        @env.send(m, *args)
+      end
+
+    end #Class
+  end #Module
+end #Module
+
+
+

data/lib/veewee/definition.rb

@@ -0,0 +1,130 @@
+require 'ostruct'
+
+module Veewee
+  class Definition
+
+    attr_accessor :name
+    attr_accessor :env
+
+    attr_accessor :cpu_count,:memory_size,:iso_file
+    attr_accessor :disk_size, :disk_format
+
+    attr_accessor :os_typ_id
+
+    attr_accessor :boot_wait,:boot_cmd_sequence
+
+    attr_accessor :kickstart_port,:kickstart_ip,:kickstart_timeout, :kickstart_file
+
+    attr_accessor :ssh_login_timeout, :ssh_user , :ssh_password, :ssh_key, :ssh_host_port, :ssh_guest_port
+
+    attr_accessor :sudo_cmd
+    attr_accessor :shutdown_cmd
+
+    attr_accessor :postinstall_files, :postinstall_timeout
+
+    attr_accessor :floppy_files
+
+    attr_accessor :path
+
+    attr_accessor :os_type_id,:use_hw_virt_ext,:use_pae,:hostiocache
+
+    attr_accessor :iso_dowload_timeout, :iso_src,:iso_md5 ,:iso_download_instructions
+
+    def initialize(name,env)
+
+      @name=name
+      @env=env
+
+      # Default is 1 CPU + 256 Mem of memory
+      @cpu_count='1' ; @memory_size='256';
+
+      # Default there is no ISO file mounted
+      @iso_file = nil, @iso_src = nil ; @iso_md5 = nil ; @iso_download_timeout=1000 ; @iso_download_instructions = nil
+
+      # Default is no floppy mounted
+      @floppy_files = nil
+
+      # Default there are no post install files
+      @postinstall_files=[]; @postinstall_timeout = 10000;
+
+      @iso_file=""
+      @disk_size = '10240'; @disk_format = 'VDI'
+
+      #        :hostiocache => 'off' ,
+      #        :os_type_id => 'Ubuntu',
+      #        :boot_wait => "10", :boot_cmd_sequence => [ "boot"],
+      #        :kickstart_port => "7122", :kickstart_ip => "127.0.0.1", :kickstart_timeout => 10000,#
+      #        :ssh_login_timeout => "10000", :ssh_user => "vagrant", :ssh_password => "vagrant",:ssh_key => "",
+      #        :ssh_host_port => "2222", :ssh_guest_port => "22", :sudo_cmd => "echo '%p'|sudo -S sh '%f'",
+      #       :shutdown_cmd => "shutdown -h now",
+      #        :kickstart_file => nil,
+
+    end
+
+
+    def method_missing(m, *args, &block)
+      env.logger.info "There's no attribute #{m} defined for builder #{@name}-- ignoring it"
+    end
+
+    def declare(options)
+      options.each do |key, value|
+        instance_variable_set("@#{key}".to_sym, options[key])
+        env.logger.info("definition") { " - #{key} : #{options[key]}" }
+      end
+      verify_ostype
+
+    end
+
+    # Loading a definition
+    def self.load(name,env)
+
+      dir=env.get_definition_paths[name]
+
+      if dir.nil?
+        env.ui.error "Error loading definition."
+        env.ui.error "could not find the directory of definition #{name}"
+        exit -1
+
+      end
+
+      veewee_definition=Veewee::Definition.new(name,env)
+      veewee_definition.path=dir
+
+      definition_file=File.join(dir,"definition.rb")
+      if File.exists?(definition_file)
+        definition_content=File.read(definition_file)
+
+        definition_content.gsub!("Veewee::Session.declare","veewee_definition.declare")
+        definition_content.gsub!("Veewee::Definition.declare","veewee_definition.declare")
+
+        env.logger.info(definition_content)
+
+        begin
+          cwd=FileUtils.pwd
+          FileUtils.cd(dir)
+          self.instance_eval(definition_content)
+          env.logger.info("Setting definition path for definition #{name} to #{File.dirname(definition_file)}")
+          FileUtils.cd(cwd)
+        rescue NameError => ex
+          env.ui.error("NameError reading definition from file #{definition_file} #{ex}")
+        rescue Exception => ex
+          env.ui.error("Error in the definition from file #{definition_file}\n#{ex}")
+          exit -1
+        end
+      else
+        env.logger.info "#{definition_file} not found"
+      end
+      veewee_definition
+    end
+
+    def verify_ostype
+
+      unless env.config.ostypes.has_key?(@os_type_id)
+        raise "The ostype: #{@os_type_id} is not available"
+      end
+
+    end
+
+
+  end #End Class
+end #End Module