volley 0.1.0.alpha4 → 0.1.0.alpha5

data/.gitignore

@@ -8,9 +8,11 @@ InstalledFiles
 _yardoc
 coverage
 doc/
+log/
 lib/bundler/man
 pkg
 rdoc
 spec/reports
-test/*
+test/publisher
+test/project/file
 tmp

data/.rspec

@@ -0,0 +1 @@
+--format s -c

data/Gemfile

@@ -4,4 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'rake'
-gem 'templar'
+gem 'cucumber'
+gem 'rspec'
+
+gem 'awesome_print'

data/Rakefile

@@ -1,2 +1,36 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+
+$:.unshift File.expand_path("lib/")
+require 'volley'
+
+desc 'Default: run specs.'
+task :default => :test
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+                                    # Put spec opts in a file named .rspec in root
+end
+
+desc "Run Cucumber"
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w{--format pretty --no-snippets}
+end
+
+desc "Run RSpec and Cucumber tests"
+task :test do
+  begin
+    Rake::Task["spec"].invoke
+  rescue => e
+    puts "#{e.message} at #{e.backtrace.first}"
+  end
+
+  begin
+    Rake::Task["cucumber"].invoke
+  rescue => e
+    puts "#{e.message} at #{e.backtrace.first}"
+  end
+end

data/bin/volley

@@ -1,55 +1,103 @@
 #!/usr/bin/env ruby
 
 require 'rubygems'
+require 'docopt'
 require 'volley'
-require 'clamp'
+require 'awesome_print'
 
-Volley::VolleyFile.init
-STDOUT.sync = true
+DOC = <<-DOC
+Usage: volley [options] <plan> <descriptor> [argument]...
+
+<plan>
+  The plan to run.
+  reserved plan names: [versions, latest, list]
+
+<descriptor>
+  A descriptor should conform to the following format:
+    <project>[@<branch>[:<version>]]
+
+  project:  the project name.
+  branch:   the branch name.
+            Defaults to the branch currently in use,
+            must be specified for remote mode.
+  version:  the version (revision)
+            Defaults to the current revision
+            In remote mode, defaults to "latest"
+
+<argument>
+  A list of key=value pairs
+
+Options:
+  -h --help           show this help message and exit
+     --version        show version and exit
+  -d --debug          show debug output, change log level to debug
+  -c --config FILE    load additional Volleyfile [default: ~/.Volleyfile]
+  -p --primary FILE   load primary Volleyfile [default: ./Volleyfile]
+
+  -f --fork           fork process into background and exit
+  -l --log LOG        log file [default: /opt/volley/volley.log]
+  -L --level LEVEL    log level [default: debug]
+DOC
 
 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(",")}"
+  class Command
+    def initialize
+    end
+
+    def run(argv)
+      STDOUT.sync = true
+      options     = Docopt(DOC, Volley::Version::STRING)
+      debug       = options[:debug]
+      config      = options[:config]
+      primary     = options[:primary]
+      fork        = options[:fork]
+      log         = options[:log]
+      level       = options[:level]
+
+      Volley::Dsl::VolleyFile.init
+      Volley::Dsl::VolleyFile.load(config, :optional => true)
+      Volley::Dsl::VolleyFile.load(primary, :primary => true) if File.file?(primary)
+      Volley::Log.add(level.to_sym, log)
+      Volley::Log.console_debug if debug
+      Volley.config.debug = debug
+
+      kvs = argv.select { |e| e.match(/(\w+)\=(\w+)/) }
+      pos = argv.reject { |e| e.match(/(\w+)\=(\w+)/) }
+
+      plan = pos.shift
+      desc = pos.shift
+
+      raise "must specify plan" unless plan
+
+      if Volley::Dsl.project(:volley).plan?(plan)
+        # the plan is reserved
+        plan = "volley:#{plan}"
+      else
+        # the plan isn't reserved
+        raise "must specify descriptor" unless desc
+        (project, branch, version) = Volley::Descriptor.new(desc).get
+        plan = "#{project}:#{plan}"
       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)
+      if debug
+        Volley::Log.debug "## OPTIONS ##"
+        Volley::Log.debug "plan:       #{plan}"
+        Volley::Log.debug "descriptor: #{desc}"
+        Volley::Log.debug "positional: #{pos.join(",")}"
+        Volley::Log.debug "key:value:  #{kvs.join(",")}"
+      end
 
-      Volley.process(:project => project, :plan => plan, :branch => branch, :version => version, :args => args)
-    rescue Interrupt => e
-      Volley::Log.warn "Cancelled..."
+      Volley::Log.info "processing '#{plan}' plan for '#{desc}'"
+      Volley.process(:plan => plan, :descriptor => desc, :args => kvs)
     rescue => e
-      Volley::Log.error "error: #{e.message}"
-      Volley::Log.error e if debug?
-      Volley::Log.debug e
-      raise Clamp::HelpWanted, self
+      Volley::Log.error "exception: #{e.message} at #{e.backtrace.first}"
+      if debug
+        Volley::Log.error e
+      else
+        Volley::Log.debug e
+      end
     end
   end
 end
 
-Volley::Command.run
+Volley::Command.new.run(ARGV)

data/conf/common.volleyfile

@@ -1,13 +1,14 @@
 project :volley do
-  plan :init do
+  scm :base
+  plan :init, :remote => false do
     default do
-      file = File.expand_path("../init/Volleyfile", __FILE__)
+      file = File.expand_path("../../init/Volleyfile", __FILE__)
       dest = "#{Dir.pwd}/Volleyfile"
       FileUtils.copy(file, dest)
       puts "created: #{dest}"
     end
   end
-  plan :list do
+  plan :list, :remote => false do
     default do
       Volley::Dsl::Project.projects.each do |p, project|
         Volley::Log.info "project: #{p}"
@@ -18,40 +19,24 @@ project :volley do
     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
+      ap args
+      (project,branch,version) = args.descriptor.get
       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
+  plan :versions, :remote => false do
     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
+      (project, branch, version) = args.descriptor.get
 
-      if project.nil? && rawargs
-        first = rawargs.first
+      if project.nil? && argv.count
+        first = argv.first
         (p, b, v) = first.split(/\//) if first
         if p
           project = p
@@ -68,7 +53,7 @@ project :volley do
       else
         if project
           if branch
-            if version
+            if version != "latest"
               data = pub.contents(project, branch, version)
             else
               data = pub.versions(project, branch)
@@ -92,11 +77,9 @@ project :volley do
     end
   end
   plan :remote do
-    argument :version, :required => true
-
     default do
       pub = Volley::Dsl.publisher
-      (pr, br, vr) = args.version.split(/[\:\/\.]/)
+      (pr, br, vr) = args.descriptor.get
       vr ||= 'latest'
       vf = pub.volleyfile(:project => pr, :branch => br, :version => vr)
       load vf

data/features/publisher.feature

@@ -0,0 +1,45 @@
+
+# Built these tests as a starting point
+# duplicates some of the tests in spec/publisher_spec
+Feature: Publisher
+  In order to store artifacts
+  I want to be able to manage files with a publisher
+
+  Background:
+    Given I have a publisher with an empty repository
+
+  Scenario: Empty publisher
+    When I request a list of projects from the publisher
+    Then I should see an empty list
+
+  Scenario: Publish multiple artifacts
+    When I publish the artifact test/trunk/1
+    Then there should be 1 projects in the publisher
+    And the test project should have 1 branches
+    When I publish the artifact test/staging/2
+    Then there should be 1 projects in the publisher
+    And the test project should have 2 branches
+
+  Scenario: Publish and retrieve artifact
+    When I publish the artifact test/trunk/1
+    Then there should be 1 projects in the publisher
+    And the test project should have 1 branches
+    When I deploy the artifact test/trunk/1
+    Then I should not receive an exception
+
+  Scenario: Latest artifacts
+    Given I have a populated repository
+    Then the test project should have 3 branches
+    And the latest of test/trunk should be 7
+    And the latest of test/staging should be 5
+
+  Scenario: Duplicate Artifact
+    Given I have a populated repository
+    When I publish a duplicate artifact test/staging/12
+    Then I should receive an exception
+
+# TODO: make this work
+#  Scenario: Duplicate Artifact force
+#    Given I have a populated repository
+#    When I force publish a duplicate artifact test/staging/12
+#    Then I should not receive an exception

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,9 @@
+
+
+Then /^I should receive an exception$/ do
+  fail if @exception.nil?
+end
+
+Then /^I should not receive an exception$/ do
+  fail unless @exception.nil?
+end

data/features/step_definitions/publisher_steps.rb

@@ -0,0 +1,92 @@
+def publish(desc)
+  pwd = Dir.pwd
+  Dir.chdir("test/project")
+  Volley::Dsl::VolleyFile.load("Volleyfile")
+  Volley.process(:plan => "publish", :descriptor => desc)
+  Dir.chdir(pwd)
+end
+
+def deploy(desc)
+  pwd = Dir.pwd
+  Volley.process(:plan => "deploy", :descriptor => desc)
+  Dir.chdir(pwd)
+end
+
+Given /^I have a publisher with an empty repository$/ do
+  @root ||= Volley.config.project_root
+  %w{local remote}.each { |d| FileUtils.rm_rf("#@root/test/publisher/#{d}") }
+  %w{local remote}.each { |d| FileUtils.mkdir_p("#@root/test/publisher/#{d}") }
+  Volley::Dsl::VolleyFile.load("#@root/test/dsl/local_publisher.volleyfile")
+  @pub = Volley::Dsl.publisher
+end
+
+Given /^I have a populated repository$/ do
+  steps %Q{
+    When I publish the artifact test/trunk/1
+    And I publish the artifact test/staging/2
+    And I publish the artifact test/trunk/3
+    And I publish the artifact test/master/4
+    And I publish the artifact test/staging/5
+    And I publish the artifact test/trunk/7
+  }
+end
+
+When /^I request a list of projects from the publisher$/ do
+  @emptylist = @pub.projects
+end
+
+Then /^I should see an empty list$/ do
+  fail unless @emptylist.count == 0
+end
+
+When /^I publish the artifact (.*)$/ do |desc|
+  publish(desc)
+end
+
+When /^I deploy the artifact (.*)$/ do |desc|
+  begin
+    deploy(desc)
+  rescue => e
+    @exception = e
+  end
+end
+
+When /^I publish a duplicate artifact (.*)$/ do |desc|
+  steps %Q{
+    When I publish the artifact #{desc}
+  }
+  begin
+    publish(desc)
+  rescue => e
+    @exception = e
+  end
+end
+
+# TODO: make this work
+When /^I force publish a duplicate artifact (.*)$/ do |desc|
+  steps %Q{
+    When I publish the artifact #{desc}
+        }
+  begin
+    publish(desc)
+  rescue => e
+    puts "EXCEPTION"
+    @exception = e
+  end
+end
+
+Then /^there should be (.*) projects in the publisher$/ do |count|
+  list = @pub.projects
+  #puts "LIST:#{list.inspect}"
+  fail unless list.count == count.to_i
+end
+
+Then /^the (.*) project should have (.*) branches$/ do |project, count|
+  list = @pub.branches(project)
+  fail unless list.count == count.to_i
+end
+
+Then /^the latest of (.*)\/(.*) should be (.*)$/ do |project, branch, version|
+  latest = @pub.latest(project, branch)
+  fail unless latest == "#{project}/#{branch}/#{version}"
+end

data/features/support/env.rb

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path("lib/")
+
+require 'fileutils'
+require 'volley'
+
+root = Dir.pwd
+
+Volley::Log.add(:debug, "#{Dir.pwd}/log/volley.log")
+Volley::Log.console_disable
+Volley.config.project_root = root
+
+World do
+  @root = root
+end
+
+at_exit do
+  puts "cleaning up... #{root}"
+  %w{local remote}.each { |d| FileUtils.rm_rf("#{root}/test/publisher/#{d}") }
+end

data/init/Volleyfile

@@ -1,104 +1 @@
-# 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
+# TODO: write this

data/lib/volley/descriptor.rb

@@ -0,0 +1,28 @@
+
+module Volley
+  class Descriptor
+    attr_reader :project, :branch, :version
+
+    def initialize(desc="", options={})
+      @options = {
+          :partial => false,
+      }.merge(options)
+
+      if desc
+        list = desc.split(/[\@\:\.\/\\\-]/)
+        raise "error parsing descriptor: #{desc}" if (list.count < 2 || list.count > 3) && !@options[:partial]
+        (@project, @branch, @version) = list
+        @version ||= "latest"
+        raise "error parsing descriptor: #{desc}" unless (@project && @branch && @version) || @options[:partial]
+      end
+    end
+
+    def get
+      [@project, @branch, @version]
+    end
+
+    def ==(other)
+      @project == other.project && @branch == other.branch && @version == other.version
+    end
+  end
+end

data/lib/volley/dsl/action.rb

@@ -0,0 +1,31 @@
+
+module Volley
+  module Dsl
+    class Action
+      attr_reader :plan
+
+      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
+      end
+
+      def call
+        Volley::Log.debug ".. .. #@name"
+        self.instance_eval &@block if @block
+      end
+
+      delegate :project, :args, :files, :file, :attributes, :log, :arguments, :argv, :branch, :version, :action,
+               :to => :plan
+
+      def command(cmd)
+        @plan.shellout(cmd)
+      end
+    end
+  end
+end