volley 0.1.0.alpha1

data/lib/volley/dsl/project.rb

@@ -0,0 +1,94 @@
+
+module Volley
+  module Dsl
+    class Project
+      class << self
+        attr_reader :projects
+        def project(name, o={}, &block)
+          n = name.to_sym
+          @projects ||= {}
+          if @projects[n]
+            #raise "defining project #{name} more than once"
+          else
+            @projects[n] = new(n)
+            @projects[n].instance_eval &block if block_given?
+          end
+          @projects[n]
+        end
+
+        def get(name)
+          @projects[name.to_sym]
+        end
+
+        def config
+          Volley.config
+        end
+
+        def exists?(name)
+          n = name.to_sym
+          @projects.keys.include?(n)
+        end
+      end
+
+      attr_reader :plans
+      attr_reader :name
+      attr_reader :source
+
+      def initialize(name)
+        @name = name
+        @plans = {}
+      end
+
+      def config
+        @config ||= OpenStruct.new
+      end
+
+      def plan(name, o={}, &block)
+        n = name.to_sym
+        options = {
+            :project => self
+        }.merge(o)
+        if block_given?
+          @plans[n] ||= Volley::Dsl::Plan.new(name, options, &block)
+        end
+        @plans[n]
+      end
+
+      def plan?(name)
+        n = name.to_sym
+        @plans.keys.include?(n)
+      end
+
+      def scm(name, o={}, &block)
+        n = name.to_s
+        require "volley/scm/#{n}"
+        klass = "Volley::Scm::#{n.camelize}".constantize
+        @source = klass.new(o)
+      end
+
+      #def encrypt(tf, o={})
+      #  options = {
+      #      :enabled => tf,
+      #      :overwrite => false,
+      #      :key => "",
+      #  }.merge(o)
+      #  config.encrypt = OpenStruct.new(options)
+      #
+      #  key = config.encrypt.key
+      #  if File.file?(key)
+      #    key = File.read(key).chomp
+      #  end
+      #
+      #  config.encrypt.key = key
+      #end
+      #
+      #def pack(tf, o={})
+      #  options = {
+      #      :enabled => tf,
+      #      :type => "tgz",
+      #  }.merge(o)
+      #  config.pack = OpenStruct.new(options)
+      #end
+    end
+  end
+end

data/lib/volley/dsl/publisher.rb

@@ -0,0 +1,25 @@
+
+module Volley
+  module Dsl
+    class Publisher
+      class << self
+        def publisher(name, o={}, &block)
+          n = name.to_sym
+
+          if @publisher
+            raise "only one publisher can be defined at a time"
+          else
+            klass = "Volley::Publisher::#{name.to_s.camelize}"
+            Volley::Log.info "loading publisher: #{name} (#{klass})" if Volley.config.debug
+            require "volley/publisher/#{name}"
+            @publisher = klass.constantize.new(o)
+          end
+        end
+
+        def get
+          @publisher
+        end
+      end
+    end
+  end
+end

data/lib/volley/dsl.rb

@@ -0,0 +1,27 @@
+d = "#{File.dirname(__FILE__)}/dsl/*"
+Dir[d].select{|e| e =~ /\.rb$/}.each do |file|
+  f = file.gsub(/\.rb$/, '')
+  require f
+end
+
+module Volley
+  module Dsl
+    class << self
+      def publisher
+        Volley::Dsl::Publisher.get
+      end
+
+      def project(name)
+        Volley::Dsl::Project.get(name)
+      end
+
+      def project?(name)
+        Volley::Dsl::Project.exists?(name)
+      end
+
+      def projects
+        Volley::Dsl::Project.projects
+      end
+    end
+  end
+end

data/lib/volley/log.rb

@@ -0,0 +1,31 @@
+require "yell"
+
+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)
+      end
+
+      def add(level, dest, format=Yell::DefaultFormat)
+        if [STDOUT,STDERR].include?(dest)
+          @loggers << Yell.new(dest, :level => level, :format => format)
+        else
+          @loggers << Yell.new(:datefile, dest, :level => level, :format => format,
+                               :keep => 7, :symlink_original_filename => true)
+        end
+      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) }
+          end
+        METHOD_DEFN
+      end
+    end
+  end
+end
+Volley::Log.init

data/lib/volley/publisher/amazons3.rb

@@ -0,0 +1,123 @@
+require 'fog'
+
+module Volley
+  module Publisher
+    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
+      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)
+        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]
+      end
+
+      def latest(pr, br)
+        @project = pr
+        @branch = br
+        f = @connection.directories.get(@bucket).files.get("#{branch}/latest")
+        f.body
+      end
+
+      private
+
+      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}"
+      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(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}"
+        else
+          contents
+        end
+      end
+
+      def connect
+        @connection ||= Fog::Storage.new(
+            :provider              => "AWS",
+            :aws_access_key_id     => @key,
+            :aws_secret_access_key => @secret,
+        )
+      end
+    end
+  end
+end

data/lib/volley/publisher/base.rb

@@ -0,0 +1,102 @@
+module Volley
+  module Publisher
+    class Base
+      def initialize(options={ })
+        @options = {
+            :overwrite => false,
+        }.merge(options)
+        load_configuration
+      end
+
+      def projects
+        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}-#{$$}"
+        raise "File #{dest} already exists" if File.exists?(dest)
+        Volley::Log.debug("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
+
+        localfiles = [*localfiles].flatten
+        Volley::Log.info ".. pushing:" if @debug
+
+        localfiles.each do |localfile|
+          Volley::Log.info ".. .. #{localfile}" if @debug
+          push_file(localfile, version, 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)
+        end
+
+        Volley::Log.info "remote: #{version}" if @debug
+        Volley::Log.info "remote_file: #{remote_file}" if @debug
+        pull_file(remote_file, version, "#@local/#{version}")
+
+        "#@local/#{version}/#{remote_file}"
+      end
+
+      def get_latest(project, branch)
+        cur       = pull_file("latest", "#{project}/#{branch}")
+        (p, n, v) = cur.split(/\//)
+        v
+      end
+
+      private
+      def me
+        self.class.name.split("::").last
+      end
+
+      def branch
+        "#@project/#@branch"
+      end
+
+      def version
+        "#{branch}/#@version"
+      end
+
+      def requires(name)
+        v = get_option(name)
+        if v.nil?
+          #ap @options
+          raise "Publisher #{me} requires option #{name}"
+        end
+        v
+      end
+
+      def optional(name, default)
+        get_option(name) || default
+      end
+
+      def get_option(name)
+        n = name.to_sym
+        @options[n]
+      end
+
+      def get_config(name)
+        n = name.to_sym
+        Volley.config.send(n)
+      end
+    end
+  end
+end

data/lib/volley/publisher/local.rb

@@ -0,0 +1,61 @@
+module Volley
+  module Publisher
+    class Local < Base
+
+      def projects
+        puts "#@directory"
+        Dir["#@directory/*"].map {|e| e.gsub(/#@directory\//,"")}
+      end
+
+      def branches(pr)
+        Dir["#@directory/#{pr}/*"].map {|e| e.gsub(/#@directory\/#{pr}\//,"")}
+      end
+
+      def versions(pr, br)
+        Dir["#@directory/#{pr}/#{br}/*"].map {|e| e.gsub(/#@directory\/#{pr}\/#{br}\//,"")}
+      end
+
+      private
+
+      def load_configuration
+        @directory = requires(:directory)
+        @local     = requires(:local)
+        @debug     = optional(:debug, false)
+      end
+
+      def remote_file
+        "#@branch-#@version.tgz#{".cpt" if @encrypted}"
+      end
+
+      def push_file(local, path, content = nil)
+        Volley::Log.debug "content=#{content.inspect}"
+        local = File.basename(local) if local =~ /^\//
+        dest = "#@directory/#{path}"
+        file = "#{dest}/#{local}"
+        Volley::Log.info".. -> #{dest}"
+        FileUtils.mkdir_p(File.dirname(file))
+        content = content.read if content.is_a?(File)
+        if content
+          File.open(file, "w") { |f| f.write(content) }
+        else
+          FileUtils.copy(local, file)
+        end
+        Volley::Log.info".. => #{file}"
+      end
+
+      def pull_file(file, path, ldir=nil)
+        remote = "#@directory/#{path}"
+        Volley::Log.info".. <- #{remote}/#{file}"
+        if ldir
+          FileUtils.mkdir_p(ldir)
+        end
+        if ldir
+          Volley::Log.info".. <= #@local/#{path}/#{file}"
+          FileUtils.copy("#{remote}/#{file}", "#@local/#{path}")
+        else
+          File.open("#{remote}/#{file}") { |f| f.read }
+        end
+      end
+    end
+  end
+end

data/lib/volley/scm/base.rb

@@ -0,0 +1,8 @@
+
+module Volley
+  module Scm
+    class Base
+
+    end
+  end
+end

data/lib/volley/scm/git.rb

@@ -0,0 +1,31 @@
+require 'volley/scm/base'
+
+module Volley
+  module Scm
+    class Git < Base
+      def initialize(opt={ })
+        @options = {
+            :update => false
+        }.merge(opt)
+      end
+
+      def branch
+        @branch ||= `git branch`.lines.select {|e| e =~ /^\*/}.first.chomp.split[1]
+      rescue => e
+        Volley::Log.error "git: could not get branch: #{e.message}"
+        Volley::Log.debug e
+      end
+
+      def revision
+        @revision ||= `git log --format='%h' --max-count=1`.chomp
+      end
+
+      def update
+        @options.delete(:update)
+        up = %x{git pull --rebase}
+        @branch = nil
+        @revision = nil
+      end
+    end
+  end
+end

data/lib/volley/scm/subversion.rb

@@ -0,0 +1,45 @@
+require 'volley/scm/base'
+
+module Volley
+  module Scm
+    class Subversion < Base
+      def initialize(opt={ })
+        @options = {
+            :update => false
+        }.merge(opt)
+      end
+
+      def data
+        @data ||= begin
+          update if @options[:update]
+          YAML::load(%x{svn info})
+        end
+      end
+
+      def branch
+        @branch ||= begin
+          if data["URL"] =~ /\/trunk/
+            "trunk"
+          elsif  data["URL"] =~ /\/branches\//
+            m = data["URL"].match(/\/branches\/([^\/]+)\/*/)
+            m[1]
+          else
+            nil
+          end
+        end
+      end
+
+      def revision
+        @revision ||= begin
+          data["Revision"]
+        end
+      end
+
+      def update
+        @options.delete(:update)
+        up = %x{svn update}
+        @data = nil
+      end
+    end
+  end
+end

data/lib/volley/version.rb

@@ -0,0 +1,10 @@
+unless defined?(Volley::Version)
+  module Volley
+    module Version
+      MAJOR  = 0
+      MINOR  = 1
+      TINY   = 0
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/lib/volley/volley_file.rb

@@ -0,0 +1,45 @@
+module Volley
+  module VolleyFile
+    class << self
+      def init
+        @loaded = {}
+        ["~/.Volleyfile", "/etc/Volleyfile", "../../../conf/common.volleyfile"].each do |f|
+          file = File.expand_path(f, __FILE__)
+          @loaded[file] ||= load(file, :optional => true)
+        end
+      end
+
+      def load(filename, options={ })
+        Volley::Log.debug "LOAD: #{filename} #{options.inspect}"
+        @projects ||= { }
+        file      = File.expand_path(filename)
+        config.volleyfile = file if options[:primary]
+
+        if File.file?(file)
+          @loaded[file] ||= instance_eval(File.read(file), file)
+        else
+          raise "cannot read file" unless options[:optional]
+        end
+      end
+
+      def config
+        Volley.config
+      end
+
+      # TOP LEVEL DSL METHODS
+
+      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
+    end
+  end
+end

data/lib/volley.rb

@@ -0,0 +1,58 @@
+require "awesome_print"
+require "ostruct"
+require "active_support/all"
+
+require "volley/version"
+require "volley/config"
+require "volley/log"
+require "volley/volley_file"
+require "volley/publisher/base"
+
+require "volley/dsl"
+
+module Volley
+  class << self
+    def process(opts)
+      project = opts[:project]
+      plan    = opts[:plan]
+      branch  = opts[:branch]
+      version = opts[:version]
+      args    = opts[:args]
+
+      begin
+        if Volley::Dsl.project?(project)
+          # we have the project locally
+          pr = Volley::Dsl.project(project)
+          if pr.plan?(plan)
+            # plan is defined
+            pl = pr.plan(plan)
+            pl.call(:rawargs => args)
+          else
+            # plan is not defined
+            raise "could not find plan #{plan} in project #{project}"
+          end
+        else
+          # we dont have the project locally, search the publisher
+          pub = Volley::Dsl.publisher
+          if pub
+            if pub.projects.include?(project)
+              vf = pub.volleyfile(opts)
+              puts "VF:#{vf}"
+            else
+              raise "project #{project} does not exist in configured publisher #{pub.class}"
+            end
+          else
+            raise "project #{project} does not exist locally, and no publisher is configured."
+          end
+        end
+      rescue => e
+        Volley::Log.error "error while processing: #{e.message}"
+        Volley::Log.debug e
+      end
+
+      #if Volley.config.debug
+      #  ap Volley::Dsl::Project.projects
+      #end
+    end
+  end
+end

data/volley.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/volley/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Shawn Catanzarite"]
+  gem.email         = ["scatanzarite@gmail.com"]
+  gem.description   = %q{PubSub Deployment tool}
+  gem.summary       = %q{PubSub Deployment tool}
+  gem.homepage      = "http://github.com/shawncatz/volley"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "volley"
+  gem.require_paths = ["lib"]
+  gem.version       = "#{Volley::Version::STRING}.alpha1"
+
+  gem.add_dependency "clamp"
+  gem.add_dependency "fog"
+  gem.add_dependency "activesupport"
+  gem.add_dependency "mixlib-shellout"
+  gem.add_dependency "yell"
+end