volley 0.1.0.alpha4 → 0.1.0.alpha5

data/lib/volley/dsl/push_action.rb

@@ -0,0 +1,101 @@
+
+module Volley
+  module Dsl
+    class PushAction < Action
+      def initialize(name, options={}, &block)
+        @name = name.to_sym
+        @stage = options.delete(:stage)
+        @plan = options.delete(:plan)
+        @options = {
+        }.merge(options)
+        raise "stage instance must be set" unless @stage
+        raise "plan instance must be set" unless @plan
+
+        @plan.action :files, :post do
+          raise "branch(#{branch}) and version(#{version}) must be specified" unless branch && version
+
+          list     = yield
+          list     = [*list].flatten
+          # use #exists? so it can work for directories
+          notfound = list.reject { |f| File.exists?(f) }
+          raise "built files not found: #{notfound.join(",")}" unless notfound.count == 0
+          files list
+          file Volley.config.volleyfile if Volley.config.volleyfile
+        end
+
+        if attributes.pack
+          @plan.action :pack, :post do
+            raise "branch(#{branch}) and version(#{version}) must be specified" unless branch && version
+
+            path = attributes.pack_dir = "/var/tmp/volley-%d-%d-%05d" % [Time.now.to_i, $$, rand(99999)]
+            Dir.mkdir(path)
+            dir = Dir.pwd
+
+            files.each do |art|
+              Volley::Log.debug "art:#{art}"
+              next unless 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 = "#{branch}-#{version}.tgz"
+                c = "tar cvfz #{n} *"
+                Volley::Log.debug "command:#{c}"
+                command(c)
+
+                attributes.artifact = "#{path}/#{n}"
+              else
+                raise "unknown pack type '#{attributes.pack_type}'"
+            end
+
+            Dir.chdir(origpath)
+          end
+        end
+
+        if attributes.encrypt
+          @plan.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
+
+        @plan.action :push, :post do
+          publisher = Volley::Dsl.publisher
+          publisher.push(project.name, branch, version, attributes.artifact)
+        end
+      end
+    end
+  end
+end

data/lib/volley/dsl/stage.rb

@@ -0,0 +1,40 @@
+
+module Volley
+  module Dsl
+    class Stage
+      attr_reader :actions
+      def initialize(name, options={}, &block)
+        @name = name.to_sym
+        @plan = options.delete(:plan)
+        @options = {
+        }.merge(options)
+        @actions = []
+        raise "plan instance must be set" unless @plan
+        instance_eval &block if block_given?
+      end
+
+      def call
+        Volley::Log.debug ".. #@name"
+        @actions.each do |action|
+          action.call
+        end
+      end
+
+      def add(action)
+        @actions << action
+      end
+
+      def count
+        @actions.count
+      end
+
+      def action(name, options={}, &block)
+        o = {
+            :stage => @name,
+            :plan => nil,
+        }.merge(options)
+        @actions << Volley::Dsl::Action.new(name, o, &block)
+      end
+    end
+  end
+end

data/lib/volley/dsl.rb

@@ -11,11 +11,18 @@ module Volley
         Volley::Dsl::Publisher.get
       end
 
+      def file(name)
+        return false unless name
+        Volley::Dsl::VolleyFile.load(name)
+      end
+
       def project(name)
+        return false unless name
         Volley::Dsl::Project.get(name)
       end
 
       def project?(name)
+        return false unless name
         Volley::Dsl::Project.exists?(name)
       end
 

data/lib/volley/log.rb

@@ -4,24 +4,38 @@ module Volley
   class Log
     class << self
       def init
-        @loggers = []
-        @loggers << Yell.new(STDOUT, :level => [:info,:warn], :format => Yell::NoFormat)
-        @loggers << Yell.new(STDERR, :level => [:error,:fatal], :format => Yell::NoFormat)
+        @loggers           = { }
+        @loggers["STDOUT"] = Yell.new(STDOUT, :level => [:info, :warn], :format => Yell::NoFormat)
+        @loggers["STDERR"] = Yell.new(STDERR, :level => [:error, :fatal], :format => Yell::NoFormat)
       end
 
       def add(level, dest, format=Yell::DefaultFormat)
-        if [STDOUT,STDERR].include?(dest)
-          @loggers << Yell.new(dest, :level => level, :format => format)
+        if [STDOUT, STDERR].include?(dest)
+          console_disable
+          @loggers["STDOUT"] = Yell.new(dest, :level => level, :format => format)
         else
-          @loggers << Yell.new(:datefile, dest, :level => level, :format => format,
-                               :keep => 7, :symlink_original_filename => true)
+          @loggers.delete(dest) if @loggers[dest]
+          FileUtils.mkdir_p(File.dirname(dest))
+          @loggers[dest] = Yell.new(:datefile, dest,
+                                    :level => level, :format => format,
+                                    :keep  => 7, :symlink_original_filename => true)
         end
       end
 
+      def console_disable
+        %w{STDOUT STDERR}.each { |s| @loggers.delete(s) }
+      end
+
+      def console_debug
+        console_disable
+        @loggers["STDOUT"] = Yell.new(STDOUT, :level => [:debug, :info, :warn], :format => Yell::NoFormat)
+        @loggers["STDERR"] = Yell.new(STDERR, :level => [:error, :fatal], :format => Yell::NoFormat)
+      end
+
       %w{debug info warn error fatal}.each do |method_name|
         class_eval(<<-METHOD_DEFN, __FILE__, __LINE__)
           def #{method_name}(msg=nil, &block)
-            @loggers.each {|l| l.#{method_name}(msg, &block) }
+            @loggers.each {|k, l| l.#{method_name}(msg, &block) }
           end
         METHOD_DEFN
       end

data/lib/volley/meta.rb

@@ -0,0 +1,24 @@
+
+module Volley
+  class Meta
+    def initialize(file="#{Volley.config.directory}/meta.yaml")
+      Volley::Log.info "meta: #{file}"
+      @file = file
+      raise "file does not exist" unless File.file?(@file)
+      @data = YAML.load_file(@file)
+      Volley::Log.info "#{@data.inspect}"
+    end
+
+    def [](project)
+      @data[project.to_sym]
+    end
+
+    def []=(project, version)
+      @data[project.to_sym] = version
+    end
+
+    def save
+      File.open(@file, "w") {|f| f.write(@data.to_yaml)}
+    end
+  end
+end

data/lib/volley/publisher/amazons3.rb

@@ -5,112 +5,91 @@ module Volley
     class Amazons3 < Base
       attr_accessor :key, :secret
 
-      def files
-        hash = {:desc => {}, :all => {}, :latest => {}}
-        @connection.directories.get(@bucket).files.collect{|e| e.key}.each do |e|
-          (pr, br, vr) = e.split(/\//)
-          hash[:desc][pr] ||= {}
-          hash[:desc][pr][br] ||= {}
-          hash[:desc][pr][br][vr] ||= []
-          hash[:desc][pr][br][vr] << e
-          hash[:all] ||= {}
-          hash[:latest] ||= {}
-          v = "#{pr}/#{br}/#{vr}"
-          hash[:latest]["#{pr}/#{br}"] ||= latest(pr, br)
-          hash[:all][v] = hash["latest"] == v
-        end
-        #ap hash
-        hash
-      end
-
-      def all
-        files[:all]
-      end
-
       def projects
-        data = files
-        data[:desc].keys
-        #files.collect{|e| e.split(/\//).first }.uniq
+        files[:desc].keys
       rescue => e
         Volley::Log.warn "error getting project list from publisher: #{e.message} at #{e.backtrace.first}"
         []
       end
 
       def branches(pr)
-        puts "branches for #{pr}"
         files[:desc][pr].keys
-        #files.select{|e| e.split(/\//).first == pr}.collect{|e| e.split(/\//)[1]}
       rescue => e
         Volley::Log.warn "error getting branch list from publisher: #{e.message}"
         []
       end
 
-      def versions(pr,br)
+      def versions(pr, br)
         files[:desc][pr][br].keys
-        #raise "not implemented"
       rescue => e
         Volley::Log.warn "error getting version list from publisher: #{e.message}"
         []
       end
 
       def contents(pr, br, vr)
-        files[:desc][pr][br][vr]
+        files[:desc][pr][br][vr].map {|e| e.gsub("#{pr}/#{br}/#{vr}/","")}
+      rescue => e
+        Volley::Log.warn "error getting contents list from publisher: #{e.message}"
+        []
       end
 
-      def latest(pr, br)
-        @project = pr
-        @branch = br
-        f = @connection.directories.get(@bucket).files.get("#{branch}/latest")
-        f.body
+      def exists?(project, branch, version)
+        !files[:desc][project][branch][version].nil? rescue false
+      end
+
+      def delete_project(project)
+        Volley::Log.info "delete_project #{project}"
+        dir = @connection.directories.get(@bucket)
+        dir.files.select{|e| e.key =~ /^#{project}\//}.each do |f|
+          Volley::Log.info "- #{f.key}"
+          f.destroy
+        end
+        true
+      rescue => e
+        Volley::Log.error "error deleting project: #{e.message} at #{e.backtrace.first}"
+        Volley::Log.debug e
+        false
       end
 
-      private
+      protected
 
       def load_configuration
         @key       = requires(:aws_access_key_id)
         @secret    = requires(:aws_secret_access_key)
         @bucket    = requires(:bucket)
-        @local     = requires(:local)
-        @debug     = optional(:debug, false)
-        @encrypted = optional(:encrypted, false)
         connect
       end
 
-      def remote_file
-        "#@branch-#@version.tgz#{".cpt" if @encrypted}"
+      def push_file(dir, file, contents)
+        file = File.basename(file)
+        dest = "#{dir}/#{file}"
+        #log "-> #@bucket/#{path}"
+        f = root.files.create(:key => dest, :body => contents, :public => true)
+        log "=> #{f.public_url.gsub("%2F", "/")}"
+        dest
       end
 
-      def push_file(name, dir, contents)
-        Volley::Log.info ".. #{name}"
-        file = File.basename(name)
-        path = "#{dir}/#{file}"
-        Volley::Log.info ".. -> s3:#@bucket/#{path}"
-        @dir        ||= @connection.directories.create({ :key => @bucket })
-        s3f         = @dir.files.create(
-            :key    => "#{path}",
-            :body   => contents,
-            :public => true
-        )
-        Volley::Log.info ".. => #{s3f.public_url.gsub("%2F", "/")}"
-        "#{path}"
-      end
+      def pull_file(dir, file, localdir=nil)
+        remote = "#{dir}/#{file}"
+        f = root.files.get(remote)
+        raise ArtifactMissing, "missing: #{remote}" unless f
 
-      def pull_file(name, dir, ldir=nil)
-        Volley::Log.info ".. <- s3:#@bucket/#{dir}/#{name}"
-        if ldir
-          FileUtils.mkdir_p(ldir)
-        end
-        f           = @connection.directories.get(@bucket).files.get("#{dir}/#{name}")
-        contents    = f.body
-        if ldir
-          lfile = "#{ldir}/#{name}"
-          File.open(lfile, "w") { |lf| lf.write(contents) }
-          Volley::Log.info ".. <= #{lfile}"
+        contents = f.body
+
+        if localdir
+          FileUtils.mkdir_p(localdir)
+          local = "#{localdir}/#{file}"
+          log "<= #{local}"
+          File.open(local, "w") { |lf| lf.write(contents) }
         else
           contents
         end
       end
 
+      def root
+        @root ||= @connection.directories.create({ :key => @bucket })
+      end
+
       def connect
         @connection ||= Fog::Storage.new(
             :provider              => "AWS",
@@ -118,6 +97,28 @@ module Volley
             :aws_secret_access_key => @secret,
         )
       end
+
+      def files
+        hash = {:desc => {}, :all => {}, :latest => {}}
+        @connection.directories.get(@bucket).files.collect{|e| e.key}.each do |e|
+          (pr, br, vr) = e.split(/\//)
+          hash[:desc][pr] ||= {}
+          hash[:desc][pr][br] ||= {}
+          hash[:desc][pr][br][vr] ||= []
+          hash[:desc][pr][br][vr] << e
+          hash[:all] ||= {}
+          hash[:latest] ||= {}
+          v = "#{pr}/#{br}/#{vr}"
+          hash[:latest]["#{pr}/#{br}"] ||= latest(pr, br)
+          hash[:all][v] = hash["latest"] == v
+        end
+        #ap hash
+        hash
+      end
+
+      def all
+        files[:all]
+      end
     end
   end
 end

data/lib/volley/publisher/base.rb

@@ -5,6 +5,12 @@ module Volley
         @options = {
             :overwrite => false,
         }.merge(options)
+
+        @debug     = optional(:debug, false)
+        @encrypted = optional(:encrypted, false)
+        @local     = optional(:local, Volley.config.directory)
+        @loglevel  = @debug ? :info : :debug
+
         load_configuration
       end
 
@@ -12,73 +18,81 @@ module Volley
         raise "not implemented"
       end
 
-      def volleyfile(desc={ })
-        @project = desc[:project]
-        @branch  = desc[:branch]
-        @version = desc[:version] && desc[:version] != 'latest' ? desc[:version] : get_latest(@project, @branch)
-        contents = pull_file("Volleyfile", version)
-        dest     = @options[:destination] || "/tmp/Volleyfile-#{Time.now.to_i}-#{$$}"
+      def branches(project)
+        raise "not implemented"
+      end
+
+      def versions(project, branch)
+        raise "not implemented"
+      end
+
+      def exists?(project, branch, version)
+        raise "not implemented"
+      end
+
+      def contents(project, branch, version)
+        raise "not implemented"
+      end
+
+      def delete_project(project)
+        raise "not implemented"
+      end
+
+      def latest(project, branch)
+        v = pull_file(dir(project,branch), "latest")
+        "#{project}/#{branch}/#{v}"
+      end
+
+      def volleyfile(project, branch, version="latest")
+        contents = pull_file(dir(project,branch,version), "Volleyfile")
+
+        dest     = "#{@options[:local]}/Volleyfile-#{Time.now.to_i}-#{$$}"
         raise "File #{dest} already exists" if File.exists?(dest)
-        Volley::Log.debug("saving Volleyfile: #{dest}")
+
+        log "saving Volleyfile: #{dest}"
         File.open(dest, "w") { |f| f.write(contents) }
         dest
       end
 
-      def push(project, br, ver, localfiles)
-        @project = project
-        @branch  = br
-        @version = ver
+      def push(project, branch, version, localfiles)
+        raise ArtifactExists, "the artifact already exists" if exists?(project, branch, version)
 
         localfiles = [*localfiles].flatten
-        Volley::Log.info ".. pushing:" if @debug
+        log "^^ #{me}#push"
 
+        dir = dir(project, branch, version)
         localfiles.each do |localfile|
-          Volley::Log.info ".. .. #{localfile}" if @debug
-          push_file(localfile, version, File.open(localfile))
+          push_file(dir, localfile, File.open(localfile))
         end
-        push_file("latest", branch, version)
-        push_file("Volleyfile", version, File.open(Volley.config.volleyfile))
-      end
-
-      def pull(project, branch, ver="latest")
-        @project = project
-        @branch  = branch
-        @version = ver
 
-        if @version == "latest"
-          @version = get_latest(@project, @branch)
+        if Volley.config.volleyfile && File.file?(Volley.config.volleyfile)
+          push_file(dir, "Volleyfile", File.open(Volley.config.volleyfile))
         end
 
-        Volley::Log.info "remote: #{version}" if @debug
-        Volley::Log.info "remote_file: #{remote_file}" if @debug
-        pull_file(remote_file, version, "#@local/#{version}")
+        push_file(dir(project, branch), "latest", version)
 
-        "#@local/#{version}/#{remote_file}"
+        true
       end
 
-      def get_latest(project, branch)
-        cur       = pull_file("latest", "#{project}/#{branch}")
-        (p, n, v) = cur.split(/\//)
-        v
-      end
+      def pull(project, branch, version="latest")
+        dir = dir(project, branch, version)
+        file = remote_file(branch, version)
 
-      private
-      def me
-        self.class.name.split("::").last
-      end
+        log "vv #{me}#pull"
+        pull_file(dir, file, "#@local/#{dir}")
 
-      def branch
-        "#@project/#@branch"
+        "#@local/#{dir}/#{file}"
       end
 
-      def version
-        "#{branch}/#@version"
+      protected
+
+      def me
+        self.class.name.split("::").last
       end
 
       def requires(name)
         v = get_option(name)
         if v.nil?
-          #ap @options
           raise "Publisher #{me} requires option #{name}"
         end
         v
@@ -97,6 +111,31 @@ module Volley
         n = name.to_sym
         Volley.config.send(n)
       end
+
+
+
+      def push_file(dir, name, contents)
+        raise "not implemented"
+      end
+
+      def pull_file(dir, name, localdir=nil)
+        raise "not implemented"
+      end
+
+      def remote_file(branch, version)
+        version = version == 'latest' ? get_latest(project, branch) : version
+        "#{branch}-#{version}.tgz#{".cpt" if @encrypted}"
+      end
+
+      def dir(project, branch, version=nil)
+        version = version == 'latest' ? get_latest(project, branch) : version
+        [project, branch, version].compact.join("/")
+      end
+
+      def log(msg)
+        Volley::Log.send(@loglevel, msg)
+      end
+
     end
   end
 end

data/lib/volley/publisher/exceptions.rb

@@ -0,0 +1,7 @@
+
+module Volley
+  module Publisher
+    class ArtifactExists < StandardError; end
+    class ArtifactMissing < StandardError; end
+  end
+end