nova-dsl 0.1.1

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gem 'open4'
+gem 'awesome_print'
+gem 'rake'
+gem 'gemcutter'
+gem 'net-ssh'
+gem 'net-scp'
+
+group :development do
+  gem 'rspec'
+  gem 'metric_fu'
+end

data/Rakefile

@@ -0,0 +1,23 @@
+$:.push '.', '..', './lib', File.expand_path(File.dirname(__FILE__))
+
+require "bundler/gem_tasks"
+
+
+task :default => :test
+
+task :test => [:rspec_report, :rspec]
+
+require 'rspec'
+require 'rspec/core/rake_task'
+desc "Run rspec unit tests "
+RSpec::Core::RakeTask.new(:rspec) do |t|
+  t.rspec_opts = ["-c", "-f progress"]
+  t.pattern ='**/spec/**/*_spec.rb'
+end
+
+desc "Reporting rspec results to reports/rspec_report.html"
+RSpec::Core::RakeTask.new(:rspec_report) do |t|
+  t.rspec_opts = ["-c", "-f html", "--out reports/rspec_report.html"]
+  t.pattern ='**/spec/**/*_spec.rb'
+end
+

data/bin/nova-dsl

@@ -0,0 +1,6 @@
+#! /usr/bin/ruby
+$:.push '.'
+require "lib/version"
+
+puts 'Nova dsl has not been implemented yet '
+

data/example.sh

@@ -0,0 +1,10 @@
+#! /bin/bash
+
+nova-dsl <<EOF1
+
+provision 'my new task' do
+   image 324
+   flavor 2
+end
+
+EOF1

data/examples/nova_list.rb

@@ -0,0 +1,6 @@
+$:.push '.', '..'
+require "lib/nova-dsl"
+
+nova_list
+
+

data/examples/open4_ex.rb

@@ -0,0 +1,18 @@
+$:.push '.'
+require "common/log"
+
+require "open4"
+
+result_stdout = nil
+result_stderr = nil
+
+status = Open4::popen4("env /usr/local/bin/nova list1 ") do |pid, stdin, stdout, stderr|
+  result_stdout = stdout.read.strip
+  result_stderr = stderr.read.strip
+end
+
+puts "status: #{status.inspect}"
+puts "exitstatus : #{status.exitstatus}"
+
+puts "stdout: #{result_stdout}" if status.success?
+puts "stdout err: #{result_stderr}" unless status.success?

data/examples/simple_provision.rb

@@ -0,0 +1,10 @@
+$:.push '.', '..'
+require 'nova-dsl'
+# Internal dsl example of provisioning new vm
+
+provision "dsl-test" do
+  image 999
+  flavor 3
+  key 'gd1'
+  profile '~/scripts/c4gd.sh'
+end

data/lib/common/attribute_checker.rb

@@ -0,0 +1,10 @@
+require 'common/log'
+
+module Common
+
+  class NovaDslCommand
+    def self.inherited(clazz)
+      clazz
+    end
+  end
+end

data/lib/common/attribute_resolver.rb

@@ -0,0 +1,22 @@
+require 'common/log'
+
+
+#Habdles unknown method calls with arguments as variable sets
+
+module Common
+  module DefaultAttributeResolver
+
+    def method_missing (name, *args, &script)
+      if args[0].nil?
+        LOGGER.warn("Attribute '#{name}' is missing, no parameters specified when calling '#{name}'
+                      at #{self.class} instance, I'm gonna return 'nil'")
+        nil
+      else
+        LOGGER.debug("Method '#{name}' missing, set new @#{name}: @#{name}=#{args[0]}")
+        instance_variable_set("@#{name}".to_sym, args[0])
+        self.class.send(:define_method, name, proc { instance_variable_get("@#{name}") })
+      end
+    end
+
+  end
+end

data/lib/common/helpers.rb

@@ -0,0 +1,63 @@
+  $:.push '.', '..', '../..'
+require 'common/log'
+require 'open4'
+
+
+module Common
+
+  # Wraps out the system calls, accepted only 0 results, otherwise NovaCallError raised
+  # @param block [Proc] system call 'system' or whateveg
+  # @return [Object] console output of the call within block
+  def self.system_call(args ={}, &block)
+
+    type_checker args[:source], String
+    src = "source #{args[:source]} && " unless args[:source].nil?
+    src ||= ''
+
+    result = []
+    ok_count = 0
+    fail_count = 0
+
+    if block.nil?
+      LOGGER.error("'system_call_checker' has received empty block, raising Runtime EX ")
+      raise "Empty block has been given to 'system_call_checker'"
+    end
+
+    block_commands = yield
+    block_commands = block_commands.split("\n").map { |x| x.strip }
+
+    result_stdout = nil
+    result_stderr = nil
+    proc_pid = nil
+    block_commands.each do |cmd|
+      composite = src + cmd
+      status = Open4::popen4(composite) do |pid, stdin, stdout, stderr|
+        LOGGER.debug("Command '#{composite}' is running as pid: #{pid} ")
+        proc_pid = pid
+        result_stdout = stdout.read.strip
+        result_stderr = stderr.read.strip
+      end
+
+      LOGGER.debug("Process #{proc_pid} finished, code: #{status.exitstatus}")
+      if status.success?; ok_count+=1 else fail_count+=1 end
+      LOGGER.error("#{result_stderr}") unless status.success?
+
+
+      cmd_result = {}
+      cmd_result[:status] = status.exitstatus
+      cmd_result[:out] = status.success? ? result_stdout : result_stderr
+
+      result << cmd_result
+    end
+    LOGGER.debug("#{result.size} commands executed, ok: #{ok_count}, failed: #{fail_count}")
+
+    result
+  end
+
+  def self.type_checker(value, clazz)
+    return value if value.nil?
+    raise TypeError.new("Waiting #{clazz} class but received #{value.class} ") unless value.is_a?(clazz)
+    value
+  end
+
+end

data/lib/common/log.rb

@@ -0,0 +1,100 @@
+require "logger"
+require "singleton"
+
+module Common
+
+  #Logger singleton wrapper for the project
+  class Log
+
+    include Singleton
+
+    @@default_cfg = {
+        :level => Logger::DEBUG,
+        :device => STDOUT,
+        :formatter => "%Y-%m-%dT%H:%M:%S "
+    }
+
+    @@cfg = {}
+
+    @@configured = false
+
+    class << self
+
+      def configure(log_cfg = {})
+          @@cfg = @@default_cfg.merge(log_cfg)
+          @@configured = true
+      end
+
+      def new
+        super
+      end
+
+    end
+
+    def initialize
+      reinitialize @@default_cfg.merge(@@cfg)
+    end
+
+    def logger
+      @logger
+    end
+
+    def debug(message=nil, *opts, &block)
+      add(Logger::DEBUG, message, nil, opts, &block)
+    end
+
+    def info(message=nil, *opts, &block)
+      add(Logger::INFO, message, nil, opts, &block)
+    end
+
+    def warn(message=nil, *opts, &block)
+      add(Logger::WARN, message, nil, opts, &block)
+    end
+
+    def error(message=nil, *opts, &block)
+      add(Logger::ERROR, message, nil, opts, &block)
+    end
+
+    def fatal(message=nil, *opts, &block)
+      add(Logger::FATAL, message, nil, opts, &block)
+    end
+
+    def unknown(message=nil, *opts, &block)
+      add(Logger::UNKNOWN, message, nil, opts, &block)
+    end
+
+    def add(severity, message, progname, opts = {}, &block)
+      message ||= ''
+      raise "You can only pass String or Exception classes as a logger message, you have pass #{message.class}" unless (message.is_a?(String)) || (message.is_a?(Exception))
+      progname||=""
+      progname[0,0] = ("[%s] " % caller[1]) if opts.include? :line
+      use_trace  = opts.include? :trace
+      if (message.is_a?(Exception))
+        message = "Exception: #{message.class}: #{message.message}"
+        message += ", trace: #{message.backtrace}" if use_trace
+      end
+      if !message.nil? and block_given?
+        message<<" "<< (yield).to_s
+      end
+      @logger.add(severity, message, progname)
+    end
+
+    def debug?; @logger.debug? end
+    def info?; @logger.info? end
+    def level=(val);@logger.level= val end
+
+    def reinitialize(cfg)
+      @logger = Logger.new(cfg[:device])
+      @logger.level= cfg[:level]
+      @logger.datetime_format= cfg[:formatter]
+    end
+
+    def configure(log_cfg = {})
+          @@cfg = @@default_cfg.merge(log_cfg)
+          @@configured = true
+          reinitialize @@cfg
+    end
+  end
+end
+
+LOGGER = Common::Log.instance

data/lib/nova/commands/nova_list.rb

@@ -0,0 +1,28 @@
+$:.push '.'
+require 'common/log'
+require 'nova/utils/nova_error'
+require 'common/attribute_resolver'
+require 'nova/wrapper/nova_console_wrapper'
+
+class << self
+  def nova_list(&script)
+    NovaDsl::NovaList.new(&script).run
+  end
+end
+
+module NovaDsl
+  class NovaList
+
+    include NovaDsl::NovaConsoleWrapper
+
+    def initialize(&script)
+      LOGGER.debug ("Initiating new nova list")
+    end
+
+    def run
+      container = nova_list
+      LOGGER.debug("Returning container size: #{container.size}")
+    end
+
+  end
+end

data/lib/nova/commands/nova_provision.rb

@@ -0,0 +1,54 @@
+$:.push '.'
+require 'common/log'
+require 'nova/utils/nova_error'
+require 'common/attribute_resolver'
+require 'nova/wrapper/nova_console_wrapper'
+
+
+class << self
+  def provision(name, &script)
+    NovaDsl::Provision.new(name, &script).run
+  end
+end
+
+module NovaDsl
+
+  class Provision
+
+    include Common::DefaultAttributeResolver, NovaDsl::NovaConsoleWrapper
+
+    attr_accessor :name
+
+    def initialize(name, &script)
+      LOGGER.info("New vm provision, name '#{name}'")
+      raise DslMissParameter.new("Missing vm name argument while processing provisioning ") if name.nil?
+      raise DslMissBody.new("Missing body do...end while processing provisioning") unless block_given?
+      @name = name
+      instance_eval &script
+      self
+    end
+
+    def run
+      nova_provision(provision_manifest)
+    end
+
+    def provision_manifest
+      LOGGER.debug("Checking provision manifest")
+      vars = self.instance_variables
+      raise DslMissParameter.new("Missing missing parameter 'name'") unless vars.include?(:@name)
+      raise DslMissParameter.new("Missing missing parameter 'image'") unless vars.include?(:@image)
+      raise DslMissParameter.new("Missing missing parameter 'flavor'") unless vars.include?(:@flavor)
+      raise DslMissParameter.new("Missing missing parameter 'key_name'") unless vars.include?(:@key)
+
+      res = {:name => @name, :image => @image, :flavor => @flavor, :key => @key}
+      res.merge!(:source => @profile) unless @profile.nil?
+      LOGGER.debug("Configuring provision configuration: #{res}")
+      res
+    end
+
+    def to_s
+      "Provision new vm: #{name}, flavor: #{@flavor}, image #{@image} "
+    end
+
+  end
+end

data/lib/nova/utils/nova_error.rb

@@ -0,0 +1,9 @@
+module NovaDsl
+
+  class DslSyntaxError < Exception; end
+    class DslMissParameter < DslSyntaxError; end
+    class DslMissBody < DslSyntaxError; end
+
+  class NovaCallError < Exception; end
+    class NovaProvisionError < NovaCallError; end
+end

data/lib/nova/utils/nova_vm.rb

@@ -0,0 +1,91 @@
+$:.push '.'
+require 'common/log'
+require 'common/helpers'
+
+module NovaDsl
+
+  #Class NovaVm represents Nova Virtual Machine information
+  class NovaVm
+    ACTIVE = 'ACTIVE'
+    QUEUED = 'QUEUED'
+
+    attr_accessor :id, :name, :status, :ip
+
+    def initialize(id, name, ip = nil, status = nil)
+      LOGGER.debug("New NovaVm cerated: id: #{id}, name: #{name}, ip:#{ip}, status: #{status}")
+      @id = id
+      @name = name
+      @ip = ip
+      @status = status
+    end
+
+    def self.fabric(configs = { })
+      LOGGER.debug("Fabric new NovaVm class with properties #{configs.inspect}")
+      Common::type_checker configs, Hash
+
+    end
+
+  end
+
+  class NovaVmsContainer
+
+    attr_accessor :vms
+
+    def initialize(vms_array = [])
+      Common::type_checker vms_array, Array
+      vms_array.each { |v| Common::type_checker v, NovaDsl::NovaVm }
+      @vms = vms_array
+    end
+
+    def [](index)
+      raise IndexError("Index #{index} is too large ") unless index < @vms.size
+      @vms[index]
+    end
+
+    def <<(vm)
+      if vm.is_a? NovaDsl::NovaVm;
+        @vms << vm
+      end
+      if vm.is_a? Array;
+        @vms += vm
+      end
+    end
+
+    def merge!(container)
+      Common::type_checker container, NovaVmsContainer
+      @vms |= container.vms
+      self
+    end
+
+    def merge(container)
+      Common::type_checker container, NovaVmsContainer
+      NovaVmsContainer.new( @vms|container.vms )
+    end
+
+    def size
+      @vms.size
+    end
+
+    def find_by_id(id)
+      Common::type_checker id, Fixnum
+      @vms.select { |v| v.id.eql?(id) }
+    end
+
+    def find_by_ip(ip)
+      Common::type_checker ip, Fixnum
+      @vms.select { |v| v.ip.eql?(ip) }
+    end
+
+    def find_by_name(name)
+      Common::type_checker name, String
+      @vms.select { |v| v.name.eql?(name) }
+    end
+
+    def find_by_status(status)
+      Common::type_checker status, String
+      @vms.select { |v| v.status.eql?(status) }
+    end
+
+  end
+
+end

data/lib/nova/wrapper/nova_console_wrapper.rb

@@ -0,0 +1,66 @@
+$:.push '.'
+require 'common/log'
+require 'common/helpers'
+require 'nova/utils/nova_error'
+require 'nova/wrapper/nova_stdout_parser'
+require 'nova/utils/nova_vm'
+
+module NovaDsl
+
+  module NovaConsoleWrapper
+
+    include NovaDsl::NovaStdoutParser
+
+    def nova_provision(configs = {})
+      LOGGER.debug("Call 'nova boot' with parameters :#{configs.inspect}")
+      raise NovaDsl::DslMissParameter.new("Missing 'name' attribute when calling provision at wrapper") if configs[:name].nil?
+      Common::
+          raise NovaDsl::DslMissParameter.new("Missing 'image' attribute when calling provision at wrapper") if configs[:image].nil?
+      raise NovaDsl::DslMissParameter.new("Missing 'flavor' attribute when
+                                           calling provision at wrapper") if configs[:flavor].nil?
+      raise NovaDsl::DslMissParameter.new("Missing 'key' attribute when calling provision at wrapper") if configs[:key].nil?
+
+      configs[:security_groups] ||= %w(default)
+
+      configs[:source] ||= ''
+
+      Common::system_call(:source => configs[:source]){
+        "/usr/local/bin/nova boot --image #{configs[:image]} --flavor #{configs[:flavor]} --key_name #{configs[:key]} --security_groups #{configs[:security_groups]*','} #{configs[:name]}"
+
+      }
+    end
+
+    def nova_list
+      LOGGER.debug("Call 'nova list' ")
+      results = Common::system_call(:source => '~/scripts/x25novaDEV.sh') {
+        "/usr/local/bin/nova list"
+      }
+
+      vms = NovaDsl::NovaVmsContainer.new
+
+      results.each do |result|
+        if result[:status].eql?(0)
+        vms.merge!(parse_nova_list_stdout result[:out])
+        else
+          LOGGER.debug("Skipping command stdout parsing because exitstatus is #{result[:status]}")
+        end
+      end
+      vms
+    end
+
+    def nova_delete
+
+    end
+
+    def nova_image_list
+
+    end
+
+    def nova_flavor_list
+
+    end
+
+
+  end
+
+end

data/lib/nova/wrapper/nova_stdout_parser.rb

@@ -0,0 +1,59 @@
+$:.push '.'
+require 'common/log'
+require 'common/helpers'
+require 'nova/utils/nova_error'
+require 'nova/utils/nova_vm'
+
+module NovaDsl
+
+  module NovaStdoutParser
+
+    #Searches ip in the word, that ENDS by ip.
+    #Ex: s="fo_my_vm_bar_435.as.341 = 10.3.4.5"
+    #The result: s[IP_SEARCHER=~s, s.length] results in `10.3.4.5`
+    #TODO: It should supports multiple ips such as: 'private=10.35.9.40, 50.56.54.87'
+    IP_SEARCHER=/[a-zA-Z0-9]*(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
+
+    def parse_nova_list_stdout(stdout)
+      LOGGER.debug("Parsing stdout, size: #{stdout.size}")
+      Common::type_checker stdout, String
+
+      initial_strings = stdout.split("\n")
+      LOGGER.debug("Parsing #{initial_strings.size} lines, assuming first three should be a headers and other stuff")
+
+      vms = NovaDsl::NovaVmsContainer.new
+
+      initial_strings.each_with_index do |line, index|
+        columns = line.split("|").map { |s| s.strip }
+        if index >=3 && columns.size.eql?(5)
+          id = columns[1].to_i
+          name = columns[2].to_s
+          status = columns[3].capitalize
+          ip = columns[4][IP_SEARCHER=~columns[4], columns[4].size]
+
+          vms << NovaDsl::NovaVm.new(id, name, ip, status)
+        end
+      end
+      vms
+    end
+
+    def parse_nova_show_stdout(stdout)
+      LOGGER.debug("Parsing nova stdout")
+      Common::type_checker stdout, String
+
+      initial_strings = stdout.split("\n")
+      LOGGER.debug("Creating key-value info instance")
+
+      initial_strings.each_with_index do |line, index|
+        columns = line.split('|').map { |s| s.strip }
+        if index >= 3 && columns.size.eql?(5)
+
+        end
+      end
+
+    end
+  end
+
+end
+
+

data/lib/nova-dsl.rb

@@ -0,0 +1,7 @@
+$:.push '.', '..', File.expand_path("lib", __FILE__)
+
+require 'common/log'
+require 'nova/commands/nova_provision'
+require 'nova/commands/nova_list'
+
+

data/lib/version.rb

@@ -0,0 +1,3 @@
+module NovaDsl
+  VERSION = '0.1.1'
+end

data/nova-dsl.gemspec

@@ -0,0 +1,24 @@
+$:.push "."
+$:.push File.expand_path("../lib", __FILE__)
+require "lib/version"
+Gem::Specification.new do |s|
+  s.name        = "nova-dsl"
+  s.version     = NovaDsl::VERSION
+  s.authors     = ["gapcoder"]
+  s.email       = ["vlaskinvlad@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Dsl wrapper for python nova-client}
+  s.description = %q{Call this from a line nova-client}
+
+  s.rubyforge_project = "nova-dsl"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.bindir = 'bin'
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/nova_wrapper_spec.rb

@@ -0,0 +1,46 @@
+$:.push '.'
+
+require 'rspec'
+
+require 'nova/wrapper/nova_console_wrapper'
+
+
+describe NovaDsl::NovaConsoleWrapper do
+
+  include NovaDsl::NovaConsoleWrapper
+
+  before :each do
+    @name = 'foo_vm'
+    @flavor = 3
+    @image = 543
+    @key = 'gd_test.key'
+    @security_groups = ['default', 'allowall', 'apache']
+
+  end
+
+  it "should be able to provision vm" do
+    pending
+    nova_provision({ }).should raise_error
+  end
+
+  it "should raise error when accepting nil args"
+
+  it "should get list of provisioned vms"
+
+  it "should get flavor list"
+
+  it "should get image list"
+
+  it "should get instance info"
+
+  it "should delete vm by it's id"
+
+  it "should register additional names in dns"
+
+  it "should be able to check vm ping is ok"
+
+  it "should check vm port 22 is accessible"
+
+  it "should check vm is accessible by ssh"
+
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: nova-dsl
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- gapcoder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-10 00:00:00.000000000 Z
+dependencies: []
+description: Call this from a line nova-client
+email:
+- vlaskinvlad@gmail.com
+executables:
+- nova-dsl
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README
+- Rakefile
+- bin/nova-dsl
+- example.sh
+- examples/nova_list.rb
+- examples/open4_ex.rb
+- examples/simple_provision.rb
+- lib/common/attribute_checker.rb
+- lib/common/attribute_resolver.rb
+- lib/common/helpers.rb
+- lib/common/log.rb
+- lib/nova-dsl.rb
+- lib/nova/commands/nova_list.rb
+- lib/nova/commands/nova_provision.rb
+- lib/nova/utils/nova_error.rb
+- lib/nova/utils/nova_vm.rb
+- lib/nova/wrapper/nova_console_wrapper.rb
+- lib/nova/wrapper/nova_stdout_parser.rb
+- lib/version.rb
+- nova-dsl.gemspec
+- spec/nova_wrapper_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: nova-dsl
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Dsl wrapper for python nova-client
+test_files:
+- spec/nova_wrapper_spec.rb
+has_rdoc: