volley 0.1.0.alpha4 → 0.1.0.alpha5

data/lib/volley/dsl/argument.rb

@@ -0,0 +1,96 @@
+module Volley
+  module Dsl
+    class Argument
+      attr_accessor :name
+      attr_accessor :value
+      attr_reader :default
+      attr_reader :convert
+      attr_reader :required
+
+      def initialize(name, options={ }, &block)
+        @name     = name.to_sym
+        @block    = block
+        @plan     = options.delete(:plan)
+        @required = options.delete(:required)
+        @default  = options.delete(:default)
+        @convert  = options.delete(:convert)
+        @convopt  = options.delete(:convert_opts) || {}
+        @choices  = options.delete(:choices)
+
+        @value    = @required ? nil : (@default || nil)
+
+        raise "plan instance must be set" unless @plan
+
+        #@plan.action "argument-#{name}", :pre do
+        #  arguments[name.to_sym].handler
+        #end
+      end
+
+      def value=(value)
+        @value = value
+        @value ||= @default unless @default.nil?
+        raise "arg '#@name' is required, but not set" if @required && @value.nil?
+        if @convert.nil?
+          if block_given?
+            @value = yield @value
+          end
+        else
+          case @convert
+            when :boolean
+              @value = boolean(@value)
+            when :descriptor
+              @value = Volley::Descriptor.new(@value, @convopt)
+            else
+              @value = @value.send(@convert)
+          end
+        end
+        raise "arg '#@name' is required, but not set (after convert)" if @required && @value.nil?
+        raise "arg '#@name' should be one of #{@choices.inspect}" if @choices && !@choices.include?(@value)
+      end
+
+      def check
+        raise "arg '#@name' is required, but not set (in check)" if @required && @value.nil?
+      end
+
+      #def handler
+      #  @value ||= @default unless @default.nil?
+      #  raise "arg '#{@name}' is required, but not set" if @required && @value.nil?
+      #  if @convert.nil?
+      #    if block_given?
+      #      @value = yield @value
+      #    end
+      #  else
+      #    case @convert
+      #      when :boolean
+      #        @value = boolean(@value)
+      #      when :descriptor
+      #        opts = @convopt || {}
+      #        @value = Volley::Descriptor.new(@value, @convopt)
+      #      else
+      #        @value = @value.send(@convert)
+      #    end
+      #  end
+      #  raise "arg '#{name}' is required, but not set (after convert)" if @required && @value.nil?
+      #  raise "arg '#{name}' should be one of #{@choices.inspect}" if @choices && !@choices.include?(@value)
+      #end
+
+      def usage
+        v = @choices || @convert || "string"
+        r = @required ? "*" : ""
+        d = @default ? "(#@default)" : ""
+        "#@name:#{v}#{r}#{d}"
+      end
+
+      def boolean(value)
+        case value.class
+          when TrueClass, FalseClass
+            return value
+          else
+            return true if value.to_s =~ /^(1|t|true|y|yes)$/
+            return false if value.to_s =~ /^(0|f|false|n|no)$/
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/volley/dsl/file.rb

@@ -0,0 +1,70 @@
+module Volley
+  module Dsl
+    module VolleyFile
+      class << self
+        def init
+          @loaded ||= { }
+
+          ["/etc/Volleyfile", "~/.Volleyfile", "../../../../conf/common.volleyfile"].each do |f|
+            load(f, :optional => true)
+          end
+        end
+
+        def load(filename, options={ })
+          file = load_file(filename)
+          raise "cannot read file #{file}" unless file || options[:optional]
+          config.volleyfile = file if options[:primary]
+          true
+        end
+
+        def unload
+          @loaded = nil
+        end
+
+        # TOP LEVEL DSL METHODS
+
+        def config
+          Volley.config
+        end
+
+        def project(name, o={ }, &block)
+          Volley::Log.debug "project: #{name}"
+          Volley::Dsl::Project.project(name, o, &block)
+        end
+
+        def publisher(name, o={ }, &block)
+          Volley::Dsl::Publisher.publisher(name, o, &block)
+        end
+
+        def log(level, dest)
+          Volley::Log.add(level, dest)
+        end
+
+        def directory(dir)
+          Volley.config.directory = dir
+        end
+
+        private
+
+        def load_file(filename)
+          @loaded   ||= { }
+          @projects ||= { }
+
+          file   = find_file(filename)
+          exists = file && File.file?(file)
+          Volley::Log.debug "LOAD: [#{exists}] #{filename} (#{file})"
+          return unless exists
+          @loaded[file] ||= instance_eval(File.read(file), file)
+          file
+        end
+
+        def find_file(filename)
+          [filename, File.expand_path(filename), File.expand_path(filename, __FILE__)].each do |f|
+            return f if File.file?(f)
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/volley/dsl/plan.rb

@@ -3,78 +3,73 @@ require 'tempfile'
 module Volley
   module Dsl
     class Plan
-      attr_accessor :rawargs
+      attr_accessor :argv
+      attr_reader :project
+      attr_reader :stages
+      attr_reader :arguments
+      attr_reader :attributes
 
       def initialize(name, o={ }, &block)
-        options = {
+        options     = {
             :name      => name,
-            :output    => false,
             :project   => nil,
+            :output    => false,
             :encrypt   => false,
+            :remote    => true,
             :pack      => true,
             :pack_type => "tgz",
         }.merge(o)
-        raise "project instance must be set" if options[:project].nil?
-        @project    = options[:project]
-        @block      = block
         @attributes = OpenStruct.new(options)
-        @args       = OpenStruct.new
-        @argdefs    = {}
-        @argdata    = {}
-        @actions    = {:pre => [], :main => [], :post => []}
+        raise "project instance must be set" if @attributes.project.nil?
+
+        @name        = name.to_sym
+        @project     = options[:project]
+        @block       = block
+        @files       = []
+        @arguments   = { }
+        @argv        = []
+        @stages      = {
+            :pre  => Volley::Dsl::Stage.new(:pre, :plan => self),
+            :main => Volley::Dsl::Stage.new(:main, :plan => self),
+            :post => Volley::Dsl::Stage.new(:post, :plan => self),
+        }
+        @stage_order = [:pre, :main, :post]
+
         instance_eval &block if block_given?
 
-        argument :branch, :required => true
-        argument :version, :default => "latest"
+        if @attributes.remote
+          argument :descriptor, :required => true, :convert => :descriptor
+        else
+          argument :descriptor, :convert => :descriptor, :convert_opts => { :partial => true }
+        end
       end
 
-      def call(options={})
-        @origargs = options[:rawargs]
-        process_arguments(options[:rawargs])
-        #instance_eval &@block
-        run_actions
-      end
+      def call(options={ })
+        Volley::Log.debug "## #{@project.name} : #@name"
+        @origargs = options[:args]
+        data      = @origargs
 
-      def full_usage
-        out = []
-        @argdefs.each do |n, arg|
-          t = arg[:convert] || "string"
-          r = arg[:required]
-          #o = "#{n}:#{t}"
-          #o = "[#{o}]" unless r
-          d = arg[:default] ? "default: #{arg[:default]}" : ""
-          o = "%15s %15s %1s %s" % [n, t, (r ? '*' : ''), d]
-          out << "#{o}"
-        end
-        out
+        process_arguments(data)
+
+        raise "descriptor must be specified" if @attributes.remote && !args.descriptor
+        #raise "cannot determine branch" unless branch
+        #raise "cannot determine version" unless version
+
+        run_actions
+        [branch, version].join(":")
       end
 
       def usage
         out = []
-        @argdefs.each do |n, arg|
-          t = arg[:convert] || "string"
-          r = arg[:required]
-          d = arg[:default] ? "#{arg[:default]}" : ""
-          v = arg[:choices] ? "[#{arg[:choices].join(",")}]" : "<#{n}>"
-          out << "#{n}:#{v}#{"*" if r}"
+        @arguments.each do |n, arg|
+          out << arg.usage
         end
         out.join(" ")
       end
 
       def run_actions(*stages)
-        stages = [*stages].flatten
-        stages = [:pre, :main, :post] if stages.count == 0
-        stages.each do |stage|
-          Volley::Log.debug "running actions[:#{stage}]:" if @actions[stage].count > 0
-          @actions[stage].each do |act|
-            Volley::Log.debug "running action: #{act[:name]}"
-            begin
-              self.instance_eval(&act[:block])
-            rescue => e
-              Volley::Log.info "error running action: #{act[:name]}: #{e.message} at #{e.backtrace.first}"
-              Volley::Log.debug e
-            end
-          end
+        @stage_order.each do |stage|
+          @stages[stage].call
         end
       end
 
@@ -84,51 +79,47 @@ module Volley
       end
 
       def args
-        @args
+        @args = OpenStruct.new(@arguments.inject({ }) { |h, e| (k, v)=e; h[k] = v.value; h })
       end
 
       def source
         @project.source or raise "SCM not configured"
       end
 
+      def remote(tf)
+        raise "remote can only be set to true or false" unless [true,false].include?(tf)
+        @attributes.remote = tf
+      end
+
+      def branch
+        (args.descriptor ? args.descriptor.branch : nil) || source.branch || nil
+      end
+
+      def version
+        v = args.descriptor ? args.descriptor.version : nil
+        if v == "latest"
+          v = source.revision || nil
+        end
+        v
+      end
+
+      def log(msg)
+        Volley::Log.info msg
+      end
+
       def load(file)
-        real = File.expand_path(file)
-        Volley::VolleyFile.load(real)
+        Volley::Dsl.file(file)
       rescue => e
         Volley::Log.error "failed to load file: #{e.message}: #{file} (#{real})"
         Volley::Log.debug e
       end
 
-      def argument(name, opts={ })
-        @argdefs[name] = opts
-        action "argument-#{name}", :pre do
-          n = name.to_sym
-          # had to make this more complex to handle valid "false" values
-          v = begin
-            if @argdata[n].nil?
-              if opts[:default].nil?
-                nil
-              else
-                opts[:default]
-              end
-            else
-              @argdata[n]
-            end
-          end
-          raise "arg '#{name}' is required, but not set" if opts[:required] && v.nil?
-          if opts[:convert]
-            if opts[:convert] == :boolean
-              v = boolean(v)
-            else
-              v = v.send(opts[:convert])
-            end
-          elsif block_given?
-            v = yield v
-          end
-          raise "arg '#{name}' is required, but not set (after convert)" if opts[:required] && v.nil?
-          @args.send("#{n}=", v)
-          @attributes.send("#{n}=", v) if opts[:attr]
-        end
+      def config
+        Volley.config
+      end
+
+      def argument(name, opts={ }, &block)
+        @arguments[name.to_sym] = Volley::Dsl::Argument.new(name, opts.merge(:plan => self), &block)
       end
 
       def output(tf=true)
@@ -141,145 +132,33 @@ module Volley
       end
 
       def action(name, stage=:main, &block)
-        n = name.to_sym
-        @actions[stage] << { :name => n, :stage => stage, :block => block }
+        @stages[stage].action(name, :plan => self, :stage => stage, &block)
+        #n = name.to_sym
+        #@actions[stage] << { :name => n, :stage => stage, :block => block }
       end
 
-      def push(&block)
-        action :files, :post do
-          list     = begin
-            case block.arity
-              when 1
-                yield @attributes.dup
-              else
-                yield
-            end
-          end
-          list     = [*list].flatten
-          notfound = list.reject { |f| File.exists?(f) }
-          raise "built files not found: #{notfound.join(",")}" unless notfound.count == 0
-          @attributes.artifact_list = list
-          @attributes.artifact_list << Volley.config.volleyfile
-        end
-
-        if @attributes.pack
-          action :pack, :post do
-            path = @attributes.pack_dir = "/var/tmp/volley-#{Time.now.to_i}-#{$$}"
-            Dir.mkdir(path)
-            dir = Dir.pwd
-
-            @attributes.artifact_list.each do |art|
-              if art =~ /^\// && art !~ /^#{dir}/
-                # file is full path and not in current directory
-                source = art
-                dest   = "#{path}/#{File.basename(art)}"
-              else
-                # file is relative path or in current directory
-                f      = art.gsub(/^#{dir}/, "").gsub(/^\//, "")
-                source = "#{dir}/#{f}"
-                dest   = "#{path}/#{f}"
-              end
-
-              begin
-                Volley::Log.debug "pack file: #{source} => #{dest}"
-                FileUtils.mkdir_p(File.dirname(dest))
-                if File.directory?(source)
-                  FileUtils.cp_r(source, dest)
-                else
-                  FileUtils.copy(source, dest)
-                end
-              rescue => e
-                raise "could not copy file #{source}: #{e.message}"
-              end
-            end
-
-            origpath = Dir.pwd
-            Dir.chdir(path)
-            case @attributes.pack_type
-              when "tgz"
-                n = "#{args.branch}-#{args.version}.tgz"
-                c = "tar cvfz #{n} *"
-                Volley::Log.debug "command:#{c}"
-                shellout(c)
-
-                @attributes.artifact = "#{path}/#{n}"
-              else
-                raise "unknown pack type '#{@attributes.pack_type}'"
-            end
-
-            Dir.chdir(origpath)
-          end
-        end
-
-        if @attributes.encrypt
-          action :encrypt, :post do
-            art = @attributes.artifact
-            key = @attributes.encrypt_key
-            cpt = "#{art}.cpt"
-
-            raise "in action encrypt: artifact file does not exist: #{art}" unless File.file?(art)
-            raise "in action encrypt: encrypted file #{cpt} already exists" if File.file?(cpt) && !@attributes.encrypt_overwrite
-            shellout("ccrypt -e --key '#{key}' #{art}")
-
-            @attributes.artifact_unencrypted = art
-            @attributes.artifact             = cpt
-          end
-        end
-
-        action :push, :post do
-          publisher = Volley::Dsl.publisher
-          publisher.push(@project.name, args.branch, args.version, @attributes.artifact)
-        end
+      def file(file)
+        @files << file
       end
 
-      def pull
-
-        dir = nil
-        pub = nil
-        file = nil
-        tgz = nil
-
-        action :download do
-          pr = @project.name
-          br = args.branch
-          ve = args.version
-
-          pub = Volley::Dsl.publisher
-          file = pub.pull(pr, br, ve)
-
-          dir = File.dirname(file)
-          Volley::Log.info "changing directory: #{dir} (#{file})"
-        end
-
-        action :unpack do
-          FileUtils.mkdir_p("#{dir}/unpack")
-          Dir.chdir("#{dir}/unpack")
-          tgz = %x{tar xvfz #{file} 2>/dev/null}
-          File.open("#{dir}/tgz.log", "w") {|f| f.write(tgz)}
+      def files(*list)
+        list = [*list].flatten
+        if @files.count > 0 && list.count > 0
+          Volley::Log.warn "overriding file list"
+          Volley::Log.debug "files: #{@files.inspect}"
+          Volley::Log.debug "new: #{list.inspect}"
         end
+        @files = list if list.count > 0
+        @files
+      end
 
-        action :run do
-          yield "#{dir}/unpack" if dir && File.directory?("#{dir}/unpack")
-        end
+      def push(&block)
+        Volley::Dsl::PushAction.new(:push_dummy, :plan => self, :stage => :main, &block)
       end
 
-      #def volley(opts={ })
-      #  o = {
-      #      :project => @project.name,
-      #      :branch  => args.branch,
-      #      :version => "latest",
-      #      :plan    => "pull",
-      #  }.merge(opts)
-      #
-      #  desc = [o[:project], o[:branch], o[:version], o[:plan]].compact.join(":")
-      #  actionname = "volley-#{desc}"
-      #  action actionname do
-      #    Volley::Log.info "VOLLEY: #{desc}"
-      #    cmd = ["volley"]
-      #    cmd << desc
-      #    shellout(cmd.join(" "), :output => true)
-      #  end
-      #end
+      def pull(&block)
+        Volley::Dsl::PullAction.new(:pull_dummy, :plan => self, :stage => :main, &block)
+      end
 
       def volley(opts={ })
         o = {
@@ -288,7 +167,8 @@ module Volley
         }.merge(opts)
 
         action "volley-#{o[:project]}-#{o[:plan]}" do
-          Volley.process(o.merge(:branch => args.branch, :version => args.version, :args => @origargs))
+          options = { :plan => "#{project}:#{plan}", :descriptor => "#{project}@#{branch}:#{version}", :args => @origargs }.merge(o)
+          Volley.process(options)
         end
       end
 
@@ -301,9 +181,9 @@ module Volley
 
       def shellout(*args)
         require "mixlib/shellout"
-        opts = args.last.is_a?(Hash) ? args.pop : {}
+        opts    = args.last.is_a?(Hash) ? args.pop : { }
         options = {
-            :output => @attributes.output,
+            :output  => @attributes.output,
             :prepend => ">> ",
         }.merge(opts)
         command = ::Mixlib::ShellOut.new(*args)
@@ -315,27 +195,22 @@ module Volley
       end
 
       private
-
-      def boolean(value)
-        case value.class
-          when TrueClass, FalseClass
-            return value
-          else
-            return true if value =~ /^(1|t|true|y|yes)$/
-            return false if value =~ /^(0|f|false|n|no)$/
-        end
-        nil
-      end
-
       def process_arguments(raw)
-        Volley::Log.debug "process arguments: #{raw.inspect}"
+        Volley::Log.debug ".. process arguments: #{raw.inspect}"
         if raw
-          kvs = raw.select{|e| e =~ /\:/}
-          raw = raw.reject{|e| e =~ /\:/}
-          Volley::Log.debug "KVS: #{kvs.inspect}"
-          Volley::Log.debug "RAW: #{raw.inspect}"
-          @rawargs = raw
-          @argdata = kvs.inject({ }) { |h, a| (k, v) = a.split(/:/); h[k.to_sym]= v; h }
+          kvs   = raw.select { |e| e =~ /\=/ }
+          raw   = raw.reject { |e| e =~ /\=/ }
+          @argv = raw
+          kvs.each do |a|
+            (k, v) = a.split(/\=/)
+            if @arguments[k.to_sym]
+              Volley::Log.debug ".. .. setting argument: #{k} = #{v}"
+              @arguments[k.to_sym].value = v
+            end
+          end
+        end
+        @arguments.each do |k, v|
+          v.check
         end
       end
     end

data/lib/volley/dsl/project.rb

@@ -8,7 +8,7 @@ module Volley
           n = name.to_sym
           @projects ||= {}
           if @projects[n]
-            #raise "defining project #{name} more than once"
+            raise "defining project #{name} more than once"
           else
             @projects[n] = new(n)
             @projects[n].instance_eval &block if block_given?
@@ -28,6 +28,10 @@ module Volley
           n = name.to_sym
           @projects.keys.include?(n)
         end
+
+        def unload
+          @projects = nil
+        end
       end
 
       attr_reader :plans
@@ -40,7 +44,11 @@ module Volley
       end
 
       def config
-        @config ||= OpenStruct.new
+        Volley.config
+      end
+
+      def log(msg)
+        Volley::Log.info msg
       end
 
       def plan(name, o={}, &block)

data/lib/volley/dsl/pull_action.rb

@@ -0,0 +1,50 @@
+
+module Volley
+  module Dsl
+    class PullAction < Action
+      def initialize(name, options={}, &block)
+        @name = name.to_sym
+        @stage = options.delete(:stage)
+        @plan = options.delete(:plan)
+        #@block = block
+        @options = {
+        }.merge(options)
+        raise "stage instance must be set" unless @stage
+        raise "plan instance must be set" unless @plan
+
+        dir  = nil
+        file = nil
+
+        @plan.action :download do
+          pr = project.name
+          br = branch
+          ve = version
+
+          pub  = Volley::Dsl.publisher
+          raise "publisher must be defined" unless pub
+          file = pub.pull(pr, br, ve)
+
+          dir = File.dirname(file)
+        end
+
+        @plan.action :unpack do
+          FileUtils.mkdir_p("#{dir}/unpack")
+          Volley::Log.info "changing directory: #{dir} (#{file})"
+          Dir.chdir("#{dir}/unpack")
+          tgz = %x{tar xvfz #{file} 2>/dev/null}
+          File.open("#{dir}/tgz.log", "w") { |f| f.write(tgz) }
+        end
+
+        @plan.action :run do
+          raise "failed to unpack: #{dir}/unpack" unless dir && File.directory?("#{dir}/unpack")
+          yield "#{dir}/unpack"
+        end
+
+        @plan.action :meta do
+          Volley.meta[project.name] = "#{args.descriptor.branch}:#{args.descriptor.version}"
+          Volley.meta.save
+        end
+      end
+    end
+  end
+end