devinstall 1.1.0 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fbc1a0725e5afda859bd39e8b8cfe23f97e22ff0
+  data.tar.gz: 55490a5aba501da261edf43b83c66d3d72dc70a8
+SHA512:
+  metadata.gz: b1fbbc6c8ab443b9cce341905d2507f884adf05bff1f47b030f5a47ec115a9622fd4ee385da61c4fcbb4cb31333b6386a030e5fe049c5e92978eaca82c7f99a5
+  data.tar.gz: 6a3a3bfb5fdcc517e2b976a6e80fcca4665d236f96e216260d5e7dfe511c7e4187ff5cf40d310639806c2763efbb405187845692e325e61149597875c75e9d40

data/.gitignore

@@ -9,7 +9,6 @@ InstalledFiles
 _yardoc
 coverage
 lib/bundler/man
-pkg
 rdoc
 spec/reports
 test/tmp

data/README.md

@@ -1,6 +1,10 @@
-# Devinstall
+# Devinstall  [![Gem Version][GV img]][Gem Version]
 
-This is a poor man automatic builder / installer / deployer for packages.
+[Gem Version]: https://rubygems.org/gems/devinstall
+
+[GV img]: https://badge.fury.io/rb/devinstall.png
+
+This is a poor man automatic package builder / installer / deployer.
 
 The build happens on a remote machine (in the future on several remote machines by package type)
 via external tools rsync and ssh.
@@ -75,6 +79,103 @@ or
 
 This will build and upload package "devinstall" to repository for dev-rh environment as defined in config.yml
 
+## The config file
+
+In order to set all the variables and to define commands to do when building or installing you need a configuration file.
+
+The said config file have simple YAML structure and should define the folowing parameters:
+
+    local:    
+      folder:
+      temp:
+
+The folder where the source/prepackaged files are on the local (developer) machine (`:folder`) and the
+temporary folder where the generated packages will be downloades
+
+    build:
+      folder: 
+      command:
+      provider:
+      type:
+      arch:
+      target:
+      env:
+
+In order:
+
+  - the folder where the sources should be copied (might be ignored by some provider_plugins)
+
+  - The command used to build the package (like `make package` or `dpkg-buildpackage`)
+
+  - The provider for the build machine (like the `local` machine or another machine
+  accessible only by SSH - `ssh` 
+
+  - the package type ( `deb`ian, `rpm`, ...)
+
+  - the architecture (might be ignored by some package_plugins)
+
+  - and the folder where the package builder will put the builded packages
+
+  - env define an environment (lyke `prod` or `QA`) for which the package will be built / installed
+
+Unlike the other parameters env is optional 
+  
+    install:
+      folder:
+      command:
+      provider:
+      type:
+      arch:
+      env:		
+    repos:
+      folder:
+      provider:
+      type:
+      arch:
+      env:
+    tests:
+      folder:
+      command:
+      provider
+      env:
+              
+The parameters have the same meaning as for `build:`
+ `repos` reffers to the package repository
+ `tests` is optional (DON'T do this) and no tests will be performend if it's missing
+
+    defaults:
+      type:
+      env:
+              
+The default `type` and `env` if you don't use command-line switches
+
+
+The order in which the parameters will be searched is:
+
+  - local
+
+Like:
+
+    packages:
+      <package_name>:
+        <type>:
+          <section>:  # like build: or install:
+            <env>:
+              <parameter>: <value>
+            
+              
+  - or global:
+
+Like
+
+      <section>:
+        <env>:
+          <parameter>: value
+
+The parameters speciffied per package have priority over the global ones
+
+In any case `env` is optional
+
 ## Contributing
 
 1. Fork it

data/bin/pkg-tool

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-require 'rubygems'
 require 'bundler/setup'
 require 'devinstall'
 

data/devinstall.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = Devinstall::VERSION
   spec.authors       = ['Dragos Boca']
   spec.email         = %w(dboca@mail.com)
-  spec.description   = %q{remote builder and installer}
+  spec.description   = %q{OS package builder and installer}
   spec.summary       = %q{Copy the source files to a build host, build the packages and install builded packages}
   spec.homepage      = 'http://github.com/dboca/devinstall'
   spec.license       = 'MIT'

data/doc/example.yml

@@ -19,6 +19,7 @@ tests:
   dev: 
     machine: dboca.dev.local
     folder: rs
+    target: rs ## this is a new addition
     user: dboca
     command: "cd %f && make devtest"
 local:
@@ -34,18 +35,19 @@ build:
 # arch is the architecture for the generated package (like amd64 or i686)
 # provider can be ssh or local (in the future vagrant and openstack)
 # note: the ssh in provider have nothing to do with ssh command in base
-  provider: ssh
+  provider: local
   user: dboca
   host: vm-dboca.dev.local
   folder: rs
   target: rs
   arch: all
+  type: deb
 install:
 # host - dev/prod deploy and install host
 # user - for scp / ssh / rsync  (defaults to base[user])
 # environment - live/qa/dev/...
   dev:
-    provider: ssh  
+    provider: ssh  ## Not implemented but compulsory for build, install, repos, tests
     user: dboca
     host:
       - server1.lan
@@ -63,14 +65,17 @@ repos:
     type: deb
 packages:
   devinstall:
-# might contain all the sections above (local, build, install, repos)
-# type and build_command are mandatory
+# might contain all the sections above (local, build, install, repos, tests)
+# type:build:command and  type:install:command are mandatory
 # in build_command the folowing expansions are made:
 #  %f build[folder]
 #  %t build[target]
 #  %p package (current package)
 #  %T type (deb, rpm, tar.gz ,...)
+#  %a only make sense for install and is the installed file
     deb:
       build:
         command: "cd %f/%p && dpkg-buildpackage"
+      install:
+        command: "dpkg -i %a"
 

data/lib/devinstall/cli.rb

@@ -1,4 +1,4 @@
-require 'devinstall/pkg'
+require 'devinstall/package'
 require 'getopt/long'
 require 'devinstall/settings'
 require 'commander/import'
@@ -37,7 +37,7 @@ module Cli
       env = options.env ? options.env.to_sym : config.defaults(:env)
 
       args.each do |p|
-        pk=Devinstall::Pkg.new(p, type, env)
+        pk=Devinstall::Package.new(p, type, env)
         pk.build
       end
     end
@@ -51,7 +51,7 @@ module Cli
       env = options.env ? options.env.to_sym : config.defaults(:env)
 
       args.each do |p|
-        pk=Devinstall::Pkg.new(p, type, env)
+        pk=Devinstall::Package.new(p, type, env)
         pk.build
         pk.install
       end
@@ -66,7 +66,7 @@ module Cli
       env = options.env ? options.env.to_sym : config.defaults(:env)
 
       args.each do |p|
-        pk=Devinstall::Pkg.new(p, type, env)
+        pk=Devinstall::Package.new(p, type, env)
         pk.run_tests
       end
     end
@@ -80,7 +80,7 @@ module Cli
       env = options.env ? options.env.to_sym : config.defaults(:env)
 
       args.each do |p|
-        pk=Devinstall::Pkg.new(p, type, env)
+        pk=Devinstall::Package.new(p, type, env)
         pk.build
         pk.run_tests
         pk.upload
@@ -90,5 +90,3 @@ module Cli
 
 end
 
-__END__
-

data/lib/devinstall/package.rb

@@ -0,0 +1,87 @@
+require 'devinstall/version'
+require 'devinstall/deep_symbolize'
+require 'devinstall/utils'
+require 'devinstall/settings'
+require 'devinstall/provider'
+require 'pp'
+
+module Devinstall
+  class UndeffError < RuntimeError;
+  end
+
+
+  class Package
+    include Utils
+
+    #noinspection RubyResolve
+    def load_package_plugin(type)
+      require "devinstall/pkg/pkg_#{type.to_s}"
+      self.singleton_class.send(:include, Kernel.const_get("Pkg").const_get("#{type.to_s.capitalize}"))
+    end
+
+    def initialize(pkg, type, env)
+      @package, @type, @env = pkg, type, env
+      load_package_plugin(type)
+    end
+
+    def upload(pkg=@package, type=@type, env=@env)
+      uploader = Provider.new(pkg, type, env, :repos)
+      info = get_info(pkg, type, env)
+      info[:to_upload].each do |target|
+        puts "Uploading #{target.to_s}"
+        uploader.put_file(info[:files][target].to_s)
+      end
+    rescue KeyNotDefinedError => e
+      puts e.message
+      raise "Error uploading #{pkg}"
+    end
+
+    def build(pkg=@package, type=@type, env=@env)
+      puts "Building package #{pkg} type #{type}"
+      info = get_info(pkg, type, env)
+      builder = Provider.new(pkg, type, env, :build)
+      builder.copy_sources
+      builder.do_action
+      info[:files].each do |target, file|
+        puts "Receiving target #{target.to_s} for #{file.to_s}"
+        builder.get_file(file)
+      end
+    rescue KeyNotDefinedError => e
+      puts e.message
+      raise "Error uploading #{pkg}"
+    end
+
+    def install(pkg=@package, type=@type, env=@env)
+      puts "Installing #{pkg} in #{env} environment."
+      installer = Provider.new(pkg, type, env, :install)
+      info = get_info(pkg, type, env)
+      info[:to_install].each do |target| # upload each file to all targets
+        installer.put_file(info[:files][target])
+        installer.do_action(info[:files][target])
+      end
+    rescue KeyNotDefinedError => e
+      puts e.message
+      raise "Error uploading #{pkg}"
+    end
+
+    def run_tests(pkg=@package, type=@type, env=@env)
+      config=Settings.instance
+      # check if we have the test section in the configuration file
+      unless config.respond_to? :tests
+        puts 'No test section in the config file.'
+        puts 'Skipping tests'
+        return
+      end
+      puts 'Running all tests'
+      puts 'This will take some time and you have no output'
+      tester = Provider.new(pkg, type, env, :tests)
+      tester.copy_sources
+      tester.do_action
+    rescue KeyNotDefinedError => e
+      puts e.message
+      raise "Error uploading #{pkg}"
+    end
+
+  end
+end
+

data/lib/devinstall/pkg/pkg_deb.rb

@@ -0,0 +1,31 @@
+require 'devinstall/utils'
+
+module Pkg
+  module Deb
+#  @type=:deb
+    include Utils
+
+    def get_info(pkg, type, env)
+      config=Devinstall::Settings.instance
+      folder=config.local(:folder, pkg: pkg, type: type, env: env)
+      deb_changelog = File.expand_path "#{folder}/#{pkg}/debian/changelog"
+      unless File.exists? deb_changelog
+        exit! "No 'debian/changelog' found in specified :local:folder (#{folder})"
+      end
+      package_version = File.open(deb_changelog, 'r') { |f| f.gets.chomp.sub(/^.*\((.*)\).*$/, '\1') }
+      p_name = "#{pkg}_#{package_version}"
+      arch = config.build(pkg: pkg, type: type, env: env)[:arch]
+      {version: package_version,
+       files:
+           {deb: "#{p_name}_#{arch}.deb",
+            tgz: "#{p_name}.tar.gz",
+            dsc: "#{p_name}.dsc",
+            chg: "#{p_name}_amd64.changes"},
+       to_install: [:deb],
+       to_upload: [:deb, :tgz, :dsc, :chg]
+      }
+    rescue IOError => e
+      exit! "IO Error while opening #{deb_changelog}\n Aborting \n #{e.message}"
+    end
+  end
+end

data/lib/devinstall/provider/provider_ssh.rb

@@ -0,0 +1,49 @@
+require 'devinstall/utils'
+require 'devinstall/settings'
+
+module Provider
+  module Ssh
+    include Utils
+
+    SETTINGS = {
+        build:   [:user, :host],
+        install: [:user, :host],
+        tests:   [:user, :host],
+        repos:   [:user, :host],
+        ssh:     [:ssh, :scp, :rsync, :sudo]
+    }
+
+    def upload_sources(cfg, src, dst)
+      config =Devinstall::Settings.instance
+      rsync  = config.ssh(:rsync)
+      source = src[-1]=='/' ? src : "#{src}/"       # source folder(we add / because we are using rsync)
+      dest   = "#{cfg[:user]}@#{cfg[:host]}:#{dst}" # cfg should provide user and host
+      command("#{rsync} #{source} #{dest}")
+    end
+
+    def download_file(cfg, file, local)
+      config=Devinstall::Settings.instance
+      rsync = config.ssh(:rsync) # should be config.provider[:ssh][:rsync]
+      command("#{rsync} -az #{cfg[:user]}@#{cfg[:host]}:#{cfg[:target]}/#{file.to_s} #{local}")
+    end
+
+    def upload_file(cfg, file, local)
+      config=Devinstall::Settings.instance
+      scp   = config.ssh(:scp) # should be config.provider[:ssh][:scp]
+      hosts = Array === cfg[:host] ? cfg[:host] : [cfg[:host]]
+      hosts.each do |host|
+        command("#{scp} #{local}/#{file} #{cfg[:user]}@#{host}:#{cfg[:folder]}")
+      end
+    end
+
+    def exec_command(cfg, command)
+      config=Devinstall::Settings.instance
+      ssh   = config.ssh(:ssh) # should be config.provider[:ssh][:scp]
+      hosts = Array === cfg[:host] ? cfg[:host] : [cfg[:host]]
+      hosts.each do |host|
+        command("#{ssh} #{cfg[:user]}@#{host} \"#{command}\"")
+      end
+    end
+
+  end
+end

data/lib/devinstall/provider.rb

@@ -0,0 +1,53 @@
+module Devinstall
+  class Provider
+
+    #noinspection RubyResolve
+    def initialize(pkg, type, env, action=nil)
+      providers={build: :build, install: :install, upload: :repos, run_tests: :tests}
+      @pkg, @type, @env = (pkg.to_sym rescue pkg), (type.to_sym rescue type), (env.to_sym rescue env)
+      @action           = action || providers[caller_locations(1, 1)[0].label.to_sym] # that's realy stupid!
+      provider          = Settings.instance.send(action, :provider, pkg: pkg, type: type, env: env)
+      require "devinstall/provider/provider_#{provider}"
+      self.singleton_class.send(:include, Kernel.const_get('Provider').const_get("#{provider.capitalize}"))
+      provider_settings=Kernel.const_get('Provider').const_get("#{provider.capitalize}")::SETTINGS
+      Settings.instance.register_provider(provider.to_sym, provider_settings)
+      ObjectSpace.define_finalizer(self, Proc.new{Settings.instance.unregister_provider(provider)})
+    end
+
+    def copy_sources # that's upload sources
+      config = Settings.instance
+      remote = config.send(@action, :folder, pkg: @pkg, type: @type, env: @env)
+      local  = File.expand_path config.local(:folder, pkg: @pkg, type: @type, env: @env)
+      cfg    = config.send(@action, pkg: @pkg, type: @type, env: @env)
+      upload_sources(cfg, local, remote)
+    end
+
+    def get_file(file)
+      config = Settings.instance
+      local  = File.expand_path config.local(:temp, pkg: @pkg, type: @type, env: @env)
+      cfg    = config.send(@action, pkg: @pkg, type: @type, env: @env)
+      download_file(cfg, file, local)
+    end
+
+    def put_file(file)
+      config = Settings.instance
+      local  = File.expand_path config.local(:temp, pkg: @pkg, type: @type, env: @env)
+      cfg    = config.send(@action, pkg: @pkg, type: @type, env: @env)
+      upload_file(cfg, file, local)
+    end
+
+    def do_action(to=nil)
+      config  = Settings.instance
+      cfg     =config.send(@action, pkg: @pkg, type: @type, env: @env)
+      command = cfg[:command].
+          gsub('%f', cfg[:folder]).
+          gsub('%p', @pkg.to_s).
+          gsub('%T', @type.to_s)
+      command = command.gsub('%t', cfg[:target]) if cfg.has_key? :target
+      command = command.gsub('%a', to) unless to.nil?
+
+      exec_command(cfg, command)
+    end
+
+  end
+end

data/lib/devinstall/settings.rb

@@ -8,65 +8,55 @@ class Hash
 end
 
 
-
 module Devinstall
 
-class KeyNotDefinedError < RuntimeError;end
-class UnknownKeyError < RuntimeError;end
+  class KeyNotDefinedError < RuntimeError
+  end
+  class UnknownKeyError < RuntimeError
+  end
 
   class Settings
     include Singleton
 
-    FILES = []
-    SETTINGS = {}
-    MDEFS={
-        local: [:folder, :temp],
-        build: [:user, :host, :folder, :target, :arch, :command, :provider],
-        install: [:user, :host, :folder, :type, :arch, :provider],
-        tests: [:machine, :folder, :user, :command, :provider],
-        repos: [:user, :host, :folder, :type, :arch]
+    FILES     = []
+    SETTINGS  = {}
+    MDEFS     = {
+        local:    [:folder, :temp],
+        build:    [:folder, :command, :provider, :type, :arch, :target],
+        install:  [:folder, :command, :provider, :type, :arch],
+        tests:    [:folder, :command, :provider],
+        repos:    [:folder, :provider, :type, :arch],
+        defaults: [:type, :env]
     }
-
+    PROVIDERS = {}
     class Action
       include Enumerable
 
-      def initialize(set, sect, pkg, type, env)
-        @set=set
-        @sect=sect
-        @pkg=pkg
-        @type=type
-        @env=env
+      def initialize(m, pkg, type, env)
+        @method, @pkg, @type, @env = (m.to_sym rescue m), (pkg.to_sym rescue pkg), (type.to_sym rescue type), (env.to_sym rescue env)
       end
 
-      def valid?
-        config = Settings.instance
-        return false unless Settings::MDEFS.has_key? @sect
-        Settings::MDEFS[@sect].inject (true) do |res, k|
-          res and config.respond_to? @sect and config.send(@sect, k, pkg: @pkg, type: @type, env: @env)
-        end
-      rescue KeyNotDefinedError => e
-        puts e.message
-        puts e.backtrace if $verbose
-        return false
+      def has_key?(key)
+        Settings.instance.send(@method, key, pkg: @pkg, type: @type, env: @env) rescue false
       end
 
       def [](key)
-        Settings.instance.send(@sect, key, pkg: @pkg, type: @type, env: @env)
+        Settings.instance.send(@method, key, pkg: @pkg, type: @type, env: @env)
       end
 
       def each
         config=Settings.instance
-        Settings::MDEFS[@sect].each do |key|
-          yield(key, config.send(@sect, key, pkg: @pkg, type: @type, env: @env)) if block_given?
+        Settings::MDEFS[@method].each do |key|
+          yield(key, config.send(@method, key, pkg: @pkg, type: @type, env: @env)) if block_given?
         end
       end
-    end  ## Class Action
+    end ## Class Action
 
     def load! (filename)
       if File.exist?(File.expand_path(filename))
         unless FILES.include? filename
           FILES << filename
-          data = YAML::load_file(filename).deep_symbolize
+          data   = YAML::load_file(filename).deep_symbolize
           merger = proc do |_, v1, v2|
             Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
           end
@@ -75,40 +65,33 @@ class UnknownKeyError < RuntimeError;end
       end
     end
 
-    def defaults(key=nil)
-      return SETTINGS.has_key? :defaults if key.nil?
-      raise UnknownKeyError, "Unknowwn key: '#{key}'" unless [:package, :type, :env, :providers].include? key
-      return nil unless key_chain(:defaults, key)
-      SETTINGS[:defaults][key].to_sym or raise KeyNotDefinedError, "Undefined key :default:#{key.to_s}"
+    def method_missing (method, *args)
+      raise UnknownKeyError, "Undefined section '#{method}'" unless method_defined? method
+      key  = (args.shift or {})
+      rest = (Hash === key) ? key : (args.shift or {})
+      pkg = rest[:pkg]
+      if pkg.nil?
+       raise UnknownKeyError, "Unknown key #{key}" unless key_defined? method,key
+       return SETTINGS[method][key] rescue raise "#{method}: Package must be defined"
+      end
+      type = rest[:type] || defaults(:type)
+      env  = rest[:env] || defaults(:env)
+      return Action.new(method, pkg, type, env) if Hash === key
+      raise UnknownKeyError, "Unknown key #{key}" unless key_defined? method,key
+      global_or_local(method, key, pkg, type, env) or
+          raise KeyNotDefinedError, "Undefined key '#{method}:#{key}' or alternate for ['#{pkg}' '#{type}' '#{env}']"
     end
 
-    def base(key=nil)
-      return SETTINGS.has_key? :base if key.nil?
-      raise UnknownKeyError, "Unknown key: '#{key}'" unless [:rsync, :ssh, :sudo, :scp].include? key
-      return nil unless key_chain(:base, key)
-      SETTINGS[:base][key] or raise KeyNotDefinedError, "Undefined key :base:#{key.to_s}"
+    def respond_to_missing?(method, _)
+      method_defined? method
     end
 
-    def method_missing (m, *args)
-      raise UnknownKeyError, "Undefined section '#{m}'" unless MDEFS.has_key? m
-      key=(args.shift or {})
-      if Hash === key
-        pkg = key[:pkg] or raise 'package must be defined'
-        type = (key[:type] or defaults(:type))
-        env = (key[:env] or defaults(:env))
-        return Action.new(SETTINGS, m, pkg, type, env)
-      end
-      rest=(args.shift or {})
-      (pkg = rest[:pkg]) or raise 'package must be defined'
-      type = (rest[:type] or defaults(:type))
-      env = (rest[:env] or defaults(:env))
-      pkg=pkg.to_sym
-      raise UnknownKeyError, "Unknown key #{key}" unless MDEFS[m].include? key
-      global_or_local(m, key, pkg, type, env) or raise KeyNotDefinedError, "Undefined key '#{m}:#{key}' or alternate for ['#{pkg}' '#{type}' '#{env}']"
+    def register_provider(provider, methods)
+      PROVIDERS[provider]=methods
     end
 
-    def respond_to_missing?(method, _)
-      MDEFS.has_key? method and SETTINGS.has_key? method
+    def unregister_provider(provider)
+      PROVIDERS.delete(provider)
     end
 
     private
@@ -117,8 +100,8 @@ class UnknownKeyError < RuntimeError;end
       res=SETTINGS
       keys.each do |key|
         next if key.nil?
-        return nil unless res.has_key? key
-        res=res[key]
+        return nil unless res.has_key? key.to_sym
+        res=res[key.to_sym]
       end
       res
     end
@@ -130,6 +113,20 @@ class UnknownKeyError < RuntimeError;end
           key_chain(section, key)
     end
 
+    def key_defined?(method, key)
+      method, key = (method.to_sym rescue method), (key.to_sym rescue key)
+      method_defined? method and
+      (MDEFS[method].include? key rescue false) or
+          PROVIDERS.inject(false){|res,(_,v)| res or (v[method].include? key rescue false)}
+    end
+
+    def method_defined?(method)
+      method = (method.to_sym rescue method)
+      (MDEFS.has_key?(method) or
+          PROVIDERS.inject(false){|res,(k,_)| res or PROVIDERS[k].has_key? method}) and
+          SETTINGS.has_key? method
+    end
+
   end
 end
 

data/lib/devinstall/version.rb

@@ -1,3 +1,3 @@
 module Devinstall
-  VERSION = '1.1.0' # Working!
+  VERSION = '1.2.0' # Working!
 end

data/lib/devinstall.rb

@@ -2,6 +2,7 @@ require 'devinstall/version'
 require 'devinstall/deep_symbolize'
 require 'devinstall/utils'
 require 'devinstall/settings'
-require 'devinstall/pkg'
+require 'devinstall/package'
 require 'devinstall/cli'
+require 'devinstall/provider'
 

data/spec/pkg_spec.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'devinstall'
+
+describe 'Packages' do
+  config=Devinstall::Settings.instance
+  config.load! './doc/example.yml' ## use defaults for type and env
+
+  package=:devinstall
+  type=:deb
+  env=nil
+
+  it 'should include the correct file' do
+    pk=Devinstall::Package.new(package, type, env)
+    expect(pk.singleton_class.include?(Pkg::Deb)).to be_true
+  end
+end

data/spec/provider_spec.rb

@@ -0,0 +1,14 @@
+require 'rspec'
+require 'devinstall'
+
+describe 'Provider' do
+  before do
+  @package, @type, @env, @action = :devinstall, :deb, :dev, :install
+#  config=Devinstall::Settings.instance
+  end
+
+  it 'should load the correct (Provider::Ssh) plugin' do
+    provider = Devinstall::Provider.new(@package, @type, @env, @action)
+    expect(provider.singleton_class.include? Provider::Ssh).to be_true
+  end
+end

data/spec/settings_spec.rb

@@ -10,6 +10,8 @@ describe 'Settings' do
   type=:deb
   env=nil
 
+  $verbose=true
+
   it 'should load an existig file' do
     expect(config.load!('doc/example.yml')).to be_true
   end
@@ -20,56 +22,59 @@ describe 'Settings' do
 
   it 'should load at init' do
     expect(config).to be_an_instance_of(Devinstall::Settings)
-    [:defaults, :base, :local, :build, :install, :tests, :repos].each do |p|
+    [:defaults, :local, :build, :install, :tests, :repos].each do |p|
       expect(config.respond_to? p).to be_true
     end # all sections loaded!
   end
 
-  it 'should have defaults' do
-    expect(config.defaults).to be_true
-  end
-
-  it 'should produce validators when hashes are given' do
-    expect(config.build(type:'deb', env:'dev', pkg:package)).to be_an_instance_of(Devinstall::Settings::Action)
+  it 'should have a method defaults' do
+    expect(config.respond_to? :defaults).to be_true
   end
 
-  it 'should produce validators when partial hashes are given' do
-    expect(config.build(pkg:package)).to be_an_instance_of(Devinstall::Settings::Action)
+  it 'the method "defaults" should have only one argument' do
+    expect(config.defaults(:type)).to eq "deb"
   end
 
-  it 'should validate correct data' do
-    expect(rr=config.build(pkg:package, type:type, env:env)).to be_an_instance_of(Devinstall::Settings::Action)
-    expect(rr.valid?).to be_true
+  it 'should instantiate a new "Action" when hashes are given' do
+    expect(config.build(type:'deb', env:'dev', pkg:package)).to be_an_instance_of(Devinstall::Settings::Action)
   end
 
-  it 'should not validate incorrect data' do
-    expect(rr=config.build(pkg:package, type: :rpm, env:env)).to be_an_instance_of(Devinstall::Settings::Action)
-    expect(rr.valid?).to be_false
+  it 'should instantiata a new "Action" when partial hashes are given' do
+    expect(config.build(pkg:package)).to be_an_instance_of(Devinstall::Settings::Action)
   end
 
-  it 'should raise errors for unknown keys' do
+  it 'should raise "UnknownKeys" errors for unknown keys' do
     expect{config.defaults :none}.to raise_error(Devinstall::UnknownKeyError)
   end
 
-  it 'should raise errors for undefined keys' do
+  it 'should raise "KeyNotDefinedError" errors for undefined keys' do
     expect{config.tests(:provider, pkg:package)}.to raise_error(Devinstall::KeyNotDefinedError)
   end
 
-  it 'should produce a value if aok' do
-    expect(config.build(:user, pkg:package)).to eq('dboca')
+  it 'should produce a value if all arguments are valid' do
+    expect(config.build(:command, pkg:package)).to eq('cd %f/%p && dpkg-buildpackage')
   end
+end
+describe "Action" do
+  config=Devinstall::Settings.instance
+  config.load! './doc/example.yml' ## use defaults for type and env
+
+  package=:devinstall
+  type=:deb
+  env=nil
 
-  it 'validator should have a [] method' do
+  $verbose=true
+
+  it 'should have a [] method' do
     rr=config.build(pkg:package, type:type, env:env)
-    expect(rr[:user]).to eq('dboca')
+    expect(rr[:target]).to eq('rs')
   end
 
   it 'should enumerate all defined values' do
     ar=[]
-    config.build(pkg:package, type:type, env:env).each do |k,v|
-       ar << k
+    config.build(pkg:package, type:type, env:env).each do |k,_|
+      ar << k
     end
-    expect(ar).to eql([:user, :host, :folder, :target, :arch, :command, :provider])
+    expect(ar.sort == [:folder, :command, :provider, :type, :arch, :target].sort ).to be_true
   end
-
 end

metadata

@@ -1,97 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: devinstall
 version: !ruby/object:Gem::Version
-  version: 1.1.0
-  prerelease: 
+  version: 1.2.0
 platform: ruby
 authors:
 - Dragos Boca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-03 00:00:00.000000000 Z
+date: 2013-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: getopt
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: commander
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: remote builder and installer
+description: OS package builder and installer
 email:
 - dboca@mail.com
 executables:
@@ -111,36 +100,42 @@ files:
 - lib/devinstall.rb
 - lib/devinstall/cli.rb
 - lib/devinstall/deep_symbolize.rb
-- lib/devinstall/pkg.rb
+- lib/devinstall/package.rb
+- lib/devinstall/pkg/pkg_deb.rb
+- lib/devinstall/provider.rb
+- lib/devinstall/provider/provider_ssh.rb
 - lib/devinstall/settings.rb
 - lib/devinstall/utils.rb
 - lib/devinstall/version.rb
+- spec/pkg_spec.rb
+- spec/provider_spec.rb
 - spec/settings_spec.rb
 homepage: http://github.com/dboca/devinstall
 licenses:
 - MIT
+metadata: {}
 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: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Copy the source files to a build host, build the packages and install builded
   packages
 test_files:
+- spec/pkg_spec.rb
+- spec/provider_spec.rb
 - spec/settings_spec.rb

data/lib/devinstall/pkg.rb

@@ -1,178 +0,0 @@
-require 'devinstall/version'
-require 'devinstall/deep_symbolize'
-require 'devinstall/utils'
-require 'devinstall/settings'
-require 'pp'
-
-module Devinstall
-  class UndeffError < RuntimeError; end
-
-  class Pkg
-    include Utils
-
-    def get_version(pkg, type, env)
-      config=Settings.instance
-      folder=config.local(:folder, pkg:pkg, type:type, env:env)
-      case type
-        when :deb
-          begin
-            deb_changelog = File.expand_path "#{folder}/#{pkg}/debian/changelog"
-            unless File.exists? deb_changelog
-              exit! <<-eos
-                No 'debian/changelog' found in specified :local:folder (#{folder})
-                Please check your config file
-              eos
-            end
-            @_package_version[:deb] = File.open(deb_changelog, 'r') { |f| f.gets.chomp.sub(/^.*\((.*)\).*$/, '\1') }
-          rescue IOError => e
-            exit! <<-eos
-              IO Error while opening #{deb_changelog}
-              Aborting \n #{e}
-            eos
-          end
-        else
-          raise UndeffError, "TODO package type #{type}"
-      end
-    end
-
-    # @param [String] package
-    def initialize(package, type, env)
-      config=Settings.instance #class variable,first thing!
-      @type=type
-      @env=env
-      @package = package 
-      @_package_version = {} # versions for types:
-      @package_files = {}
-      arch = config.build(pkg:package, type:type, env:env)[:arch]
-      p_name = "#{@package}_#{get_version(package, type, env)}"
-      @package_files[:deb] = {deb: "#{p_name}_#{arch}.deb",
-                              tgz: "#{p_name}.tar.gz",
-                              dsc: "#{p_name}.dsc",
-                              chg: "#{p_name}_amd64.changes"}
-    end
-
-    def upload(pkg=@package, type=@type, env=@env)
-      config = Settings.instance
-      scp = config.base(:scp)
-      repo = config.repos(pkg:pkg, type:type, env:env)
-      local = config.local(pkg:pkg, type:type, env:env)
-
-      @package_files[type].each do |p, f|
-        puts "Uploading #{f}\t\t[#{p}] to #{repo[:host]}"
-        command("#{scp} #{local[:temp]}/#{f} #{repo[:user]}@#{repo[:host]}:#{repo[:folder]}")
-      end
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotDefinedError => e
-      puts e.message
-      exit! ''
-    end
-
-    def build(pkg=@package, type=@type, env=@env)
-      config = Settings.instance
-      puts "Building package #{pkg} type #{type}"
-      build = config.build(pkg:pkg, type:type, env:env)
-      local = config.local(pkg:pkg, type:type, env:env)
-      raise 'Invaild build configuration' unless build.valid?
-
-      ssh   = config.base(:ssh)
-      rsync = config.base(:rsync)
-      local_folder = File.expand_path local[:folder]
-      local_temp   = File.expand_path local[:temp]
-
-      build_command = build[:command].gsub('%f', build[:folder]).
-          gsub('%t', build[:target]).
-          gsub('%p', pkg.to_s).
-          gsub('%T', type.to_s)
-
-      upload_sources("#{local_folder}/", "#{build[:user]}@#{build[:host]}:#{build[:folder]}")
-      command("#{ssh} #{build[:user]}@#{build[:host]} \"#{build_command}\"")
-      @package_files[type].each do |p, t|
-        puts "Receiving target #{p.to_s} for #{t.to_s}"
-        command("#{rsync} -az #{build[:user]}@#{build[:host]}:#{build[:target]}/#{t} #{local_temp}")
-      end
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotDefinedError => e
-      puts e.message
-      exit! ''
-    end
-
-    def install(pkg=@package, type=@type, env=@env)
-      config=Settings.instance
-      puts "Installing #{pkg} in #{env} environment."
-      install=config.install(pkg:pkg, type:type, env:env)
-      temp  =config.local(pkg:pkg, type:type, env:env)[:temp]
-
-      sudo = config.base(:sudo)
-      scp  = config.base(:scp)
-
-      install[:host] = [install[:host]] unless Array === install[:host]
-      case type
-        when :deb
-          install[:host].each do |host|
-            command("#{scp} #{temp}/#{@package_files[type][:deb]} #{install[:user]}@#{host}:#{install[:folder]}")
-            command("#{sudo} #{install[:user]}@#{host} /usr/bin/dpkg -i #{install[:folder]}/#{@package_files[type][:deb]}")
-          end
-        else
-          exit! "unknown package type '#{type.to_s}'"
-      end
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotDefinedError => e
-      puts e.message
-      exit! ''
-    end
-
-    def run_tests(pkg=@package, type=@type, env=@env)
-      config=Settings.instance
-      # check if we have the test section in the configuration file
-      unless config.respond_to? :tests
-        puts 'No test section in the config file.'
-        puts 'Skipping tests'
-        return
-      end
-      # for tests we will use almost the same setup as for build
-      test  = config.tests(pkg:pkg, type:type, env:env)
-      local = config.local(pkg:pkg, type:type, env:env)
-      build = config.build(pkg:pkg, type:type, env:env)
-
-      ssh = config.base(:ssh)
-      # replace "variables" in commands
-      command = test[:command].
-          gsub('%f', test[:folder]).# %f is the folder where the sources are rsync-ed
-          gsub('%t', build[:target]).# %t is the folder where the build places the result
-          gsub('%p', pkg.to_s) # %p is the package name
-      # take the sources from the local folder
-      local_folder = File.expand_path local[:folder]
-      # upload them to the test machine
-      upload_sources("#{local_folder}/", "#{test[:user]}@#{test[:machine]}:#{test[:folder]}")
-      puts 'Running all tests'
-      puts 'This will take some time and you have no output'
-      command("#{ssh} #{test[:user]}@#{test[:machine]} \"#{command}\"")
-    rescue CommandError => e
-      puts e.verbose_message
-      exit! ''
-    rescue KeyNotDefinedError => e
-      puts e.message
-      exit! ''
-    end
-
-    def upload_sources (source, dest)
-      config=Settings.instance
-      rsync = config.base(:rsync)
-      command("#{rsync} -az #{source} #{dest}")
-    end
-  rescue CommandError => e
-    puts e.verbose_message
-    exit! ''
-  rescue KeyNotDefinedError => e
-    puts e.message
-    exit! ''
-  end
-
-end
-