veewee-atlassian 0.3.11

data/lib/veewee/command/vagrant/undefine.rb

@@ -0,0 +1,41 @@
+require 'optparse'
+
+module Veewee
+  module Command
+    module Vagrant
+      class Undefine < ::Vagrant::Command::Base
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Remove the definition of a basebox"
+            opts.separator ""
+            opts.separator "Usage: vagrant basebox undefine <boxname>"
+
+            opts.on("-d", "--debug", "enable debugging") do |d|
+              options['debug'] = d
+            end
+
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise ::Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          begin
+            venv=Veewee::Environment.new(options)
+            venv.ui=@env.ui
+            definition_name=argv[0]
+            venv.definitions.undefine(definition_name,options)
+            venv.ui.info("Definition '#{definition_name}' successfully removed",:prefix => false)
+          rescue Veewee::Error => ex
+            venv.ui.error(ex,:prefix => false)
+            exit -1
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/veewee/command/vagrant/up.rb

@@ -0,0 +1,44 @@
+require 'optparse'
+
+module Veewee
+  module Command
+    module Vagrant
+      class Up < ::Vagrant::Command::Base
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Starts a basebox that was built"
+            opts.separator ""
+            opts.separator "Usage: vagrant basebox up <boxname>"
+
+
+            opts.on("-n", "--nogui", "no gui") do |n|
+              options['nogui'] = n
+            end
+
+            opts.on("-d", "--debug", "enable debugging") do |d|
+              options['debug'] = d
+            end
+
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise ::Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          begin
+            venv=Veewee::Environment.new(options)
+            venv.ui=@env.ui
+            venv.providers["virtualbox"].get_box(argv[0]).up(options)
+          rescue Veewee::Error => ex
+            venv.ui.error ex
+            exit -1
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/veewee/command/vagrant/validate.rb

@@ -0,0 +1,46 @@
+require 'optparse'
+
+module Veewee
+  module Command
+    module Vagrant
+      class Validate < ::Vagrant::Command::Base
+        def execute
+          options = {
+            'tags' => %w{vagrant puppet chef virtualbox}
+          }
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Validates a box against vagrant compliancy rules"
+            opts.separator ""
+            opts.separator "Usage: vagrant basebox validate <boxname>"
+
+            opts.on("-d", "--debug", "enable debugging") do |d|
+              options['debug'] = d
+            end
+
+            opts.on("-t", "--tags vagrant,puppet,chef", Array, "tags to validate") do |t|
+              options['tags'] = t
+            end
+
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise ::Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          begin
+            venv=Veewee::Environment.new(options)
+            venv.ui=@env.ui
+            box_name=argv[0]
+            venv.providers["virtualbox"].get_box(box_name).validate_vagrant(options)
+          rescue Veewee::Error => ex
+            venv.ui.error(ex,:prefix => false)
+            exit -1
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/veewee/command/vagrant/winrm.rb

@@ -0,0 +1,39 @@
+require 'optparse'
+
+module Veewee
+  module Command
+    module Vagrant
+      class Winrm < ::Vagrant::Command::Base
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Winrm into the basebox"
+            opts.separator ""
+            opts.separator "Usage: vagrant basebox winrm <boxname> <command>"
+
+            opts.on("-d", "--debug", "enable debugging") do |d|
+              options['debug'] = d
+            end
+
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise ::Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          begin
+            venv=Veewee::Environment.new(options)
+            venv.ui=@env.ui
+            venv.providers["virtualbox"].get_box(argv[0]).winrm(argv[1])
+          rescue Veewee::Error => ex
+            venv.ui.error ex
+            exit -1
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/veewee/command/vbox.rb

@@ -0,0 +1,171 @@
+module Veewee
+  module Command
+    class Vbox< Veewee::Command::GroupBase
+
+      register "vbox", "Subcommand for VirtualBox"
+      desc "build [BOX_NAME]", "Build box"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the build"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      method_option :auto,:type => :boolean , :default => false, :aliases => "-a", :desc => "auto answers"
+      method_option :checksum , :type => :boolean , :default => false, :desc => "verify checksum"
+      method_option :redirectconsole,:type => :boolean , :default => false, :aliases => "-r", :desc => "redirects console output"
+      method_option :postinstall_include, :type => :array, :default => [], :aliases => "-i", :desc => "ruby regexp of postinstall filenames to additionally include"
+      method_option :postinstall_exclude, :type => :array, :default => [], :aliases => "-e", :desc => "ruby regexp of postinstall filenames to exclude"
+      def build(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).build(options)
+      end
+
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the destroy" 
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "destroy [BOXNAME]", "Destroys the basebox that was built"
+      def destroy(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).destroy(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "force the shutdown" 
+      desc "halt [BOXNAME]", "Activates a shutdown on the basebox"
+      def halt(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).halt(options)
+      end
+
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :nogui,:type => :boolean , :default => false, :aliases => "-n", :desc => "no gui"
+      desc "up [BOXNAME]", "Starts a Box"
+      def up(box_name)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).up(options)
+      end
+
+      desc "ssh [BOXNAME] [COMMAND]", "Interactive ssh login"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ssh(box_name,command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).issh(command)
+      end
+
+
+      desc "winrm [BOXNAME] [COMMAND]", "Execute command via winrm"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def winrm(box_name,command=nil)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).winrm(command,{:exitcode => "*"})
+      end
+
+      desc "copy [BOXNAME] [SRC] [DST]", "Copy a file to the VM"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def copy(box_name,src,dst)
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.providers["virtualbox"].get_box(box_name).copy_to_box(src,dst)
+      end
+
+
+      desc "define [BOXNAME] [TEMPLATE]", "Define a new basebox starting from a template"
+      method_option :force,:type => :boolean , :default => false, :aliases => "-f", :desc => "overwrite the definition"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def define(definition_name, template_name)
+        begin
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.definitions.define(definition_name,template_name,options)
+        env.ui.info "The basebox '#{definition_name}' has been successfully created from the template '#{template_name}'"
+        env.ui.info "You can now edit the definition files stored in definitions/#{definition_name} or build the box with:"
+        env.ui.info "veewee vbox build '#{definition_name}'"
+        rescue Error => ex
+          env.ui.error("#{ex}",:prefix => false)
+          exit -1
+        end
+      end
+
+      desc "undefine [BOXNAME]", "Removes the definition of a basebox "
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def undefine(definition_name)
+        env.ui.info  "Removing definition #{definition_name}", :prefix => false
+        begin
+          venv=Veewee::Environment.new(options)
+          venv.ui=env.ui
+          venv.definitions.undefine(definition_name,options)
+          env.ui.info "Definition #{definition_name} successfully removed" , :prefix => false
+        rescue Error => ex
+          env.ui.error("#{ex}",:prefix => false)
+          exit -1
+        end
+      end
+
+      desc "ostypes", "List the available Operating System types"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def ostypes
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.ostypes.each do |name|
+           env.ui.info "- #{name}"
+        end
+      end
+
+      desc "templates", "List the currently available templates"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def templates
+        env.ui.info "The following templates are available:",:prefix => false
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.templates.each do |name,template|
+          env.ui.info "veewee vbox define '<box_name>' '#{name}'",:prefix => false
+        end
+      end
+
+      desc "list", "Lists all defined boxes"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      def list
+        env.ui.info "The following local definitions are available:",:prefix => false
+        venv=Veewee::Environment.new(options)
+        venv.ui=env.ui
+        venv.definitions.each do |name,definition|
+          env.ui.info "- #{name}",:prefix => false
+        end
+      end
+
+      desc "validate [NAME]", "Validates a box against vagrant compliancy rules"
+      method_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      method_option :tags, :type => :array , :default => %w{vagrant virtualbox puppet chef}, :aliases => "-t", :desc => "tags to validate"
+      def validate(box_name)
+        begin
+        venv=Veewee::Environment.new(options)
+        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
+
+        venv.providers["virtualbox"].get_box(box_name).validate_vagrant(options)
+        rescue Veewee::Error => ex
+          venv.ui.error(ex, :prefix => false)
+          exit -1
+        end
+      end
+
+      desc "screenshot [NAME] [PNGFILENAME]", "Takes a screenshot of the box"
+      def screenshot(box_name,pngfilename)
+        begin
+        venv=Veewee::Environment.new(options)
+        venv.ui = ::Veewee::UI::Shell.new(venv, shell)
+
+        venv.providers["virtualbox"].get_box(box_name).screenshot(pngfilename,options)
+        rescue Veewee::Error => ex
+          venv.ui.error(ex, :prefix => false)
+          exit -1
+        end
+      end
+
+
+    end
+
+  end
+end

data/lib/veewee/command/version.rb

@@ -0,0 +1,13 @@
+module Veewee
+  module Command
+    class VersionCommand < Base
+
+      register "version", "Prints the Veewee version information"
+      def execute
+        env.ui.info "Version : #{Veewee::VERSION} - use at your own risk"
+      end
+
+    end
+
+  end
+end

data/lib/veewee/config.rb

@@ -0,0 +1,61 @@
+require 'veewee/config/veewee'
+require 'veewee/config/collection'
+
+require 'fileutils'
+
+module Veewee
+  class Config
+
+    attr_accessor :veewee
+    attr_reader :env
+
+    def initialize(options)
+      @env = options[:env]
+
+      # Initialize with defaults
+      @veewee = ::Veewee::Config::Veewee.new(self)
+
+    end
+
+    def define()
+      config = OpenStruct.new
+
+      # Expose the veewee config
+      config.veewee = @veewee
+
+      # Process config file
+      yield config
+
+    end
+
+    # We put a long name to not clash with any function in the Veewee file itself
+    def load_veewee_config()
+      veewee_configurator = self
+      begin
+        filename = File.join(Dir.pwd, "Veeweefile")
+        if File.exists?(filename)
+          veeweefile = File.read(filename)
+          veeweefile["Veewee::Config.run"] = "veewee_configurator.define"
+          #        http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+          instance_eval(veeweefile)
+        else
+          env.logger.info "No configfile found"
+        end
+      rescue LoadError => e
+        env.ui.error "An error occurred"
+        env.ui.error e.message
+      rescue NoMethodError => e
+        env.ui.error "Some method got an error in the configfile - Sorry"
+        env.ui.error $!
+        env.ui.error e.message
+        raise Veewee::Error "Some method got an error in the configfile - Sorry"
+      rescue Error => e
+        env.ui.error "Error processing configfile - Sorry"
+        env.ui.error e.message
+        raise Veewee::Error "Error processing configfile - Sorry"
+      end
+      return self
+    end
+
+  end #End Class
+end #End Module

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