volley 0.1.0.alpha1

data/.gitignore

@@ -0,0 +1,16 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/*
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in volley.gemspec
+gemspec
+
+gem 'rake'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Shawn Catanzarite
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Volley
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'volley'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install volley
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/volley

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'volley'
+require 'clamp'
+
+Volley::VolleyFile.init
+STDOUT.sync = true
+
+module Volley
+  class Command < Clamp::Command
+    option %w{-c --config}, "CONFIG", "configuration file", :default => "~/.Volleyfile"
+    option %w{-p --primary}, "PRIMARY", "primary configuration file", :default => "./Volleyfile"
+    option %w{-d --debug}, :flag, "set debug flag"
+    option %w{-f --fork}, :flag, "fork process into background"
+
+    parameter "DESCRIPTOR", "volley descriptor, follows the format: project:plan[@branch[:version]]"
+    parameter "[ARG] ...", "additional arguments passed to plan of the form: key:value"
+
+    def execute
+      Volley::VolleyFile.load(config, :optional => true)
+      Volley::VolleyFile.load(primary, :primary => true) if File.file?(primary)
+      Volley.config.debug = debug?
+
+      (project, plan, branch, version) = descriptor.split(/[:\@]/)
+      project = "volley" if project.nil? || project.blank?
+
+      args = arg_list
+      args << "branch:#{branch}" if branch
+      args << "version:#{version}" if version
+
+      if debug?
+        puts "project:   #{project}"
+        puts "plan:      #{plan}"
+        puts "branch:    #{branch}"
+        puts "version:   #{version}"
+        puts "args_list: #{args.join(",")}"
+      end
+
+      #raise "you must specify project (#{project}): [#{Volley::Dsl.projects.keys.join(',')}]" unless project && Volley::Dsl.project(project)
+      #raise "you must specify plan: #{project} [#{Volley::Dsl::Project.project(project).plans.keys.join(", ")}]" unless plan && Volley::Dsl::Project.project(project).plan(plan)
+
+      Volley.process(:project => project, :plan => plan, :branch => branch, :version => version, :args => args)
+    rescue Interrupt => e
+      Volley::Log.warn "Cancelled..."
+    rescue => e
+      Volley::Log.error "error: #{e.message}"
+      Volley::Log.error e if debug?
+      Volley::Log.debug e
+      raise Clamp::HelpWanted, self
+    end
+  end
+end
+
+Volley::Command.run

data/conf/common.volleyfile

@@ -0,0 +1,106 @@
+project :volley do
+  plan :init do
+    default do
+      file = File.expand_path("../init/Volleyfile", __FILE__)
+      dest = "#{Dir.pwd}/Volleyfile"
+      FileUtils.copy(file, dest)
+      puts "created: #{dest}"
+    end
+  end
+  plan :list do
+    default do
+      Volley::Dsl::Project.projects.each do |p, project|
+        Volley::Log.info "project: #{p}"
+        project.plans.each do |pl, plan|
+          Volley::Log.info ".. #{pl} #{plan.usage}"
+        end
+      end
+    end
+  end
+  plan :latest do
+    argument :project #, :required => true
+    argument :branch #, :required => true
+    default do
+      project = args.project
+      branch  = args.branch
+
+      if project.nil? && rawargs
+        first = rawargs.first
+        (p, b) = first.split(/\//) if first
+        if p
+          project = p
+          branch  = b
+        end
+      end
+      raise "project and branch must be specified" unless project && branch
+
+      pub = Volley::Dsl.publisher
+      puts pub.latest(project, branch)
+    end
+  end
+  plan :versions do
+    argument :project
+    argument :branch
+    argument :version
+    argument :all, :convert => :boolean, :default => false
+    argument :output, :default => "list", :convert => :to_sym, :choices => ["json", "xml", "list"]
+
+    default do
+      project = args.project
+      branch  = args.branch
+      version = args.version
+
+      if project.nil? && rawargs
+        first = rawargs.first
+        (p, b, v) = first.split(/\//) if first
+        if p
+          project = p
+          branch  = b
+          version = v
+        end
+      end
+
+      pub  = Volley::Dsl.publisher
+      data = []
+      if args.all
+        data = pub.all.keys.reject {|e| e =~ /latest$/}
+        data.each { |k, v| puts "%2s %s" % [v, k] }
+      else
+        if project
+          if branch
+            if version
+              data = pub.contents(project, branch, version)
+            else
+              data = pub.versions(project, branch)
+            end
+          else
+            data = pub.branches(project)
+          end
+        else
+          data = pub.projects
+        end
+
+        case args.output
+          when :json
+            puts data.to_json
+          when :xml
+            puts data.to_xml
+          else
+            data.each { |e| puts e }
+        end
+      end
+    end
+  end
+  plan :remote do
+    argument :version, :required => true
+
+    default do
+      pub = Volley::Dsl.publisher
+      (pr, br, vr) = args.version.split(/[\:\/\.]/)
+      vr ||= 'latest'
+      vf = pub.volleyfile(:project => pr, :branch => br, :version => vr)
+      load vf
+      volley :project => "volley", :plan => "list"
+    end
+  end
+end

data/init/Volleyfile

@@ -0,0 +1,104 @@
+# TODO: implement source control framework
+# Source Control - access to source control information from within actions
+#   scm :svn
+# or
+#   scm :git
+#
+# Configuring one of these, enables you to use source control
+# information inside actions:
+# action :name do
+#   args.branch = source.branch
+#   args.version = source.revision
+# end
+
+project :myproject do
+  plan :push do
+    # Encryption allows you to share artifact files on public data stores.
+    #
+    # encryption is turned off by default
+    #   encrypt false
+    # to enable encryption you must supply a keyfile
+    #   encrypt true, :key => "/path/to/keyfile"
+    # or supply a key directly
+    #   encrypt true, :key => "this is the key"
+
+    # Command output is disabled by default
+    #   output false
+    # setting this to true, will display output
+    # from all commands that are run as part
+    # of the plan
+    #   output true
+
+    # Arguments are captured from the command line
+    # in key:value pairs.
+    #
+    # By specifying the following:
+    #   argument :branch
+    # You will then have access to args.branch within your plan's actions
+    #
+    # Argument options
+    #   :default      set the default value for the argument
+    #   :convert      convert the value received from the command line (see below)
+    #   :required     raise an error if this argument is not specified
+    #
+    # Convert Option:
+    #   :convert => :boolean
+    #   :convert => :to_s
+    #   :convert => :to_i
+    # Boolean is a custom conversion, all others are delegated to the string class
+    #
+
+    # Actions
+    # Actions are executed in order that they are defined in.
+    #
+    # Generally you will use action wrappers (like: build and push)
+    #
+    # The build action is a specialized action that *requires*
+    # the return value of the block to be the list of files to add
+    # to the artifact.
+    #
+    # build do |attr|
+    #   # run build commands
+    #   ["target/something.war"]
+    # end
+    #
+    # By default, the build action will also configure the 'pack' action
+    # (which handles creating the final combined artifact) and the 'encrypt'
+    # action, if encryption is enabled.
+    #
+    # The 'push' action is a shortcut to Publish the artifact to a data store.
+    #   push :publisher
+    # Volley includes the Amazon S3 publisher.
+    #   push :amazons3
+    #
+    # You also have the ability to add actions directly:
+    #
+    # action :name do
+    #   # do something
+    # end
+
+    build do |attr|
+      clean    = args.clean ? "clean" : ""
+
+      # to run commands inside of actions, use the shellout method
+      # this is a wrapper around Mixlib::Shellout
+      shellout("rake #{clean} build")
+
+      # the 'branch' argument is generally set to the branch name.
+      # by using the ||= operator here, we can also set the 'branch' argument on the command line.
+      args.branch    ||= source.branch
+      # the 'version' argument is generally set to the source control revision number.
+      # by using the ||= operator here, we can also set the 'branch' argument on the command line.
+      args.version ||= source.revision
+
+      final = "target/awesome.war"
+      [final]
+    end
+
+    push :amazons3
+  end
+
+  plan :deploy do
+    pull :amazons3
+  end
+end

data/lib/volley/config.rb

@@ -0,0 +1,8 @@
+
+module Volley
+  class << self
+    def config
+      @config ||= OpenStruct.new({})
+    end
+  end
+end

data/lib/volley/dsl/plan.rb

@@ -0,0 +1,339 @@
+require 'tempfile'
+
+module Volley
+  module Dsl
+    class Plan
+      attr_accessor :rawargs
+
+      def initialize(name, o={ }, &block)
+        options = {
+            :name      => name,
+            :output    => false,
+            :project   => nil,
+            :encrypt   => false,
+            :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 => []}
+        instance_eval &block if block_given?
+      end
+
+      def call(options={})
+        process_arguments(options[:rawargs])
+        #instance_eval &@block
+        run_actions
+      end
+
+      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
+      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}"
+        end
+        out.join(" ")
+      end
+
+      def run_actions(*stages)
+        stages = [*stages].flatten
+        stages = [:pre, :main, :post] if stages.count == 0
+        #ap Volley.config if Volley.config.debug
+        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]}"
+            #ap act if Volley.config.debug
+            self.instance_eval(&act[:block])
+          end
+        end
+        #ap self if Volley.config.debug
+      end
+
+      def method_missing(n, *args)
+        Volley::Log.warn "** plan DSL does not support method: #{n} #{args.join(',')}"
+        raise "not supported"
+      end
+
+      def args
+        @args
+      end
+
+      def source
+        @project.source or raise "SCM not configured"
+      end
+
+      def load(file)
+        real = File.expand_path(file)
+        Volley::VolleyFile.load(real)
+      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
+      end
+
+      def output(tf=true)
+        @attributes.output = tf
+        argument :output, :attr => true, :default => tf, :convert => :boolean
+      end
+
+      def default(&block)
+        action(:default, :main, &block)
+      end
+
+      def action(name, stage=:main, &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
+      end
+
+      def pull
+        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})"
+          cmd = "volley run #{pr}:#{plan} branch:#{branch} #{arg_list.join(' ')}"
+
+          Volley::Log.info "command: #{cmd}"
+          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)}
+        end
+      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 volley(opts={ })
+        o = {
+            :project => @project.name,
+            #:branch  => args.branch,
+            #:version => "latest",
+            :plan    => "pull",
+        }.merge(opts)
+
+        pr = o[:project]
+        pl = o[:plan]
+
+        action "volley-#{pr}-#{pl}" do
+          plan = Volley::Dsl.project(pr).plan(pl)
+          plan.call(:rawargs => @rawargs)
+        end
+
+        #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 command(*args)
+        name = args.join(" ").parameterize.to_sym
+        action name do
+          shellout(*args)
+        end
+      end
+
+      def shellout(*args)
+        require "mixlib/shellout"
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        options = {
+            :output => @attributes.output,
+            :prepend => ">> ",
+        }.merge(opts)
+        command = ::Mixlib::ShellOut.new(*args)
+        command.run_command
+        command.stdout.lines.each { |l| Volley::Log.info "#{options[:prepend]}#{l}" } if options[:output] && command.stdout
+        command.stderr.lines.each { |l| Volley::Log.info "#{options[:prepend]}#{l}" } if options[:output] && command.stderr
+        command.error!
+        { :out => command.stdout, :err => command.stderr }
+      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)
+        if raw
+          kvs = raw.select{|e| e =~ /\:/}
+          raw = raw.reject{|e| e =~ /\:/}
+          @rawargs = raw
+          @argdata = kvs.inject({ }) { |h, a| (k, v) = a.split(/:/); h[k.to_sym]= v; h }
+        end
+      end
+    end
+  end
+end