mamiya 0.0.1.alpha2

data/lib/mamiya/cli/client.rb

@@ -0,0 +1,172 @@
+require 'mamiya/cli'
+
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'json'
+require 'thor'
+
+module Mamiya
+  class CLI < Thor
+    class Client < Thor
+      class_option :master, aliases: '-u', type: :string
+      class_option :application, aliases: %w(-a --app), type: :string
+
+      desc "list-applications", "list applications"
+      def list_applications
+        puts master_get('/packages')["applications"]
+      end
+
+      desc "list-packages", "list-packages"
+      def list_packages
+        puts master_get("/packages/#{application}")["packages"]
+      end
+
+      desc "show-package", "show package meta data"
+      method_option :format, aliases: %w(-f), type: :string, default: 'pp'
+      def show_package(package)
+        meta =  master_get("/packages/#{application}/#{package}")
+
+        case options[:format]
+        when 'pp'
+          require 'pp'
+          pp meta
+        when 'json'
+          require 'json'
+          puts meta.to_json
+        when 'yaml'
+          require 'yaml'
+          puts meta.to_yaml
+        end
+      end
+
+      desc "list-agents", 'list agents'
+      def list_agents
+        payload = master_get("/agents")
+
+        agents = payload["agents"].keys
+
+        agents.each do |agent|
+          puts "#{agent}\talive"
+        end
+        payload["failed_agents"].each do |agent|
+          puts "#{agent}\tfailed"
+        end
+      end
+
+      desc "show-agent AGENT", 'Show agent'
+      method_option :format, aliases: %w(-f), type: :string, default: 'pp'
+      def show_agent(agent)
+        agent = master_get("/agents/#{agent}")
+
+        case options[:format]
+        when 'pp'
+          require 'pp'
+          pp agent
+        when 'json'
+          require 'json'
+          puts agent.to_json
+        when 'yaml'
+          require 'yaml'
+          puts agent.to_yaml
+        end
+      end
+
+      desc "show-distribution package", "Show package distribution status"
+      method_option :format, aliases: %w(-f), type: :string, default: 'text'
+      method_option :verbose, aliases: %w(-v), type: :boolean
+      def show_distribution(package)
+        dist = master_get("/packages/#{application}/#{package}/distribution")
+
+        case options[:format]
+        when 'json'
+          require 'json'
+          puts dist.to_json
+          return
+
+        when 'yaml'
+          require 'yaml'
+          puts dist.to_yaml
+          return
+        end
+
+        total = dist['distributed_count'] + dist['not_distributed_count']
+        puts <<-EOF
+Distribution status of #{application}/#{package}
+
+ratio (distributed:total-agents):    #{"%.1f" % ((dist['distributed_count']/total.to_f)*100)}%
+number of agents have package:       #{dist['distributed_count']}
+number of agents don't have package: #{dist['not_distributed_count']}
+        EOF
+
+        if options[:verbose]
+          puts ""
+          dist['not_distributed'].each do |name|
+            puts "#{name}\tnot_distributed"
+          end
+          dist['distributed'].each do |name|
+            puts "#{name}\tdistributed"
+          end
+        end
+      end
+
+      desc "distribute package", "order distributing package to agents"
+      def distribute(package)
+        p master_post("/packages/#{application}/#{package}/distribute")
+      end
+
+      desc "refresh", "order refreshing agent status"
+      def refresh
+        p master_post('/agents/refresh')
+      end
+
+      desc "deploy PACKAGE", "Run distribute->prepare->finalize"
+      def deploy
+      end
+
+      desc "rollback", "Switch back to previous release then finalize"
+      def rollback
+      end
+
+      private
+
+      def fatal!(msg)
+        $stderr.puts msg
+        exit 1
+      end
+
+      def application
+        options[:application] or fatal!('specify application')
+      end
+
+      def master_get(path)
+        master_http.start do |http|
+          JSON.parse http.get(path).tap(&:value).body
+        end
+      end
+
+      def master_post(path, data='')
+        master_http.start do |http|
+          response = http.post(path, data).tap(&:value)
+          response.code == '204' ? true : JSON.parse(response.tap(&:value).body)
+        end
+      end
+
+      def master_http
+        url = master_url
+        Net::HTTP.new(url.host, url.port).tap do |http|
+          http.use_ssl = true if url.scheme == 'https'
+        end
+      end
+
+      def master_url
+        url = ENV["MAMIYA_MASTER_URL"] || options[:master]
+        fatal! 'specify master URL via --master(-u) option or $MAMIYA_MASTER_URL' unless url
+        URI.parse(url)
+      end
+    end
+
+   desc "client", "client for master"
+   subcommand "client", Client
+  end
+end

data/lib/mamiya/config.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+require 'mamiya/storages'
+
+module Mamiya
+  class Config
+    def self.load(file)
+      self.new YAML.load_file(file)
+    end
+
+    def initialize(config_hash = {})
+      @config = symbolize_keys_in(config_hash)
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    def []=(key, value)
+      @config[key] = value
+    end
+
+    def storage_class
+      self[:storage] && Storages.find(self[:storage][:type])
+    end
+
+    def deploy_to_for_app(app)
+      # TODO: test
+      app = app.to_sym
+
+      if self[:apps] && self[:applications][app]
+        Pathname.new(self[:applications][app][:deploy_to])
+      end
+    end
+
+    def releases_path_for_app(app)
+      # TODO: test
+      deploy_to_for_app(app).join('releases')
+    end
+
+    private
+
+    def symbolize_keys_in(hash)
+      Hash[hash.map { |k, v|
+        case v
+        when Hash
+          v = symbolize_keys_in(v)
+        when Array
+          if v.find { |_| _.kind_of?(Hash) }
+            v = v.map { |_| _.kind_of?(Hash) ? symbolize_keys_in(_) : _ }
+          end
+        end
+
+        [k.to_sym, v]
+      }]
+    end
+  end
+end

data/lib/mamiya/dsl.rb

@@ -0,0 +1,192 @@
+require 'mamiya/util/label_matcher'
+require 'thread'
+
+module Mamiya
+  class DSL
+    class TaskNotDefinedError < Exception; end
+    class HelperNotFound < Exception; end
+
+    ##
+    # Creates new DSL environment.
+    def initialize
+      @variables = {}
+      @tasks = {}
+      @hooks = {}
+      @eval_lock = Mutex.new
+      @use_lock = Mutex.new
+    end
+
+    attr_reader :hooks, :tasks
+
+    ##
+    # Returns Hash of default setting variables.
+    def self.defaults
+      @defaults ||= {}
+    end
+
+    def self.define_variable_accessor(name) # :nodoc:
+      k = name.to_sym
+      return if self.instance_methods.include?(k)
+
+      define_method(k) { @variables[k] || self.class.defaults[k] }
+    end
+
+    ##
+    # Sets default value +value+ for variable name +key+.
+    # Values set by this method will available for all instances of same class.
+    def self.set_default(key, value)
+      k = key.to_sym
+      defaults[k] = value
+      self.define_variable_accessor(k)
+    end
+
+    ##
+    # Add hook point with name +name+.
+    # This defines method with same name in class to call and define hooks.
+    def self.add_hook(name, attributes={})
+      define_method(name) do |*args, &block|
+        @hooks[name] ||= []
+
+        if block
+          hook_name = args.shift if args.first.kind_of?(String)
+          options = args.pop if args.last.kind_of?(Hash)
+
+          hook = {block: block, options: options || {}, name: hook_name}
+          case args.first
+          when :overwrite
+            @hooks[name] = [hook]
+          when :prepend
+            @hooks[name][0,0] = [hook]
+          else
+            @hooks[name] << hook
+          end
+
+        else
+          matcher = Mamiya::Util::LabelMatcher::Simple.new(args)
+          Proc.new { |*args|
+            filtered_hooks = @hooks[name].reject { |hook|
+              options = hook[:options]
+
+              (options[:only]   && !matcher.match?(*options[:only]  )) ||
+              (options[:except] &&  matcher.match?(*options[:except]))
+            }
+
+            if attributes[:chain]
+              init = args.shift
+              filtered_hooks.inject(init) do |result, hook|
+                hook[:block].call(result, *args)
+              end
+            else
+              filtered_hooks.each do |hook|
+                hook[:block].call *args
+              end
+            end
+          }
+        end
+      end
+    end
+
+    ##
+    # :call-seq:
+    #   evaluate!(string [, filename [, lineno]])
+    #   evaluate! { block }
+    #
+    # Evaluates given string or block in DSL environment.
+    def evaluate!(str = nil, filename = nil, lineno = nil, &block)
+      @eval_lock.synchronize {
+        begin
+          if block_given?
+            self.instance_eval(&block)
+          elsif str
+            @file = filename if filename
+
+            if str && filename && lineno
+              self.instance_eval(str, filename, lineno)
+            elsif str && filename
+              self.instance_eval(str, filename)
+            elsif str
+              self.instance_eval(str)
+            end
+          end
+        ensure
+          @file = nil
+        end
+      }
+      self
+    end
+
+    ##
+    # Evaluates specified file +file+ in DSL environment.
+    def load!(file)
+      evaluate! File.read(file), file, 1
+    end
+
+    ##
+    # (DSL) Find file using +name+ from current +load_path+ then load.
+    # +options+ will be available as variable +options+ in loaded file.
+    def use(name, options={})
+      helper_file = find_helper_file(name)
+      raise HelperNotFound unless helper_file
+
+      @use_lock.lock unless @use_lock.owned? # to avoid lock recursively
+
+      @_options = options
+      self.instance_eval File.read(helper_file).prepend("options = @_options; @_options = nil;\n"), helper_file, 1
+
+    ensure
+      @_options = nil
+      @use_lock.unlock if @use_lock.owned?
+    end
+
+    ##
+    # (DSL) Set value +value+ for variable named +key+.
+    def set(key, value)
+      k = key.to_sym
+      self.class.define_variable_accessor(key) unless self.methods.include?(k)
+      @variables[k] = value
+    end
+
+    ##
+    # (DSL) Set value +value+ for variable named +key+ unless value is present for the variable.
+    def set_default(key, value)
+      k = key.to_sym
+      return @variables[k] if @variables.key?(k)
+      set(k, value)
+    end
+
+    ##
+    # (DSL) Define task named +name+ with given block.
+    def task(name, &block)
+      @tasks[name] = block
+    end
+
+    ##
+    # (DSL) Invoke task named +name+.
+    def invoke(name)
+      raise TaskNotDefinedError unless @tasks[name]
+      self.instance_eval &@tasks[name]
+    end
+
+    ##
+    # Returns current load path used by +use+ method.
+    def load_path
+      (@variables[:load_path] ||= []) +
+        [
+          "#{__dir__}/helpers",
+          *(@file ? ["#{File.dirname(@file)}/helpers"] : [])
+        ]
+    end
+
+    private
+
+    def find_helper_file(name) # :nodoc:
+      load_path.find do |_| # Using find to return nil when not found
+        path = File.join(_, "#{name}.rb")
+        break path if File.exists?(path)
+      end
+    end
+
+    # TODO: hook call context methods
+    #https://gist.github.com/sorah/9263951
+  end
+end

data/lib/mamiya/helpers/git.rb

@@ -0,0 +1,75 @@
+require 'time'
+
+set_default :git_remote, 'origin'
+set_default :commit, "#{self.git_remote}/HEAD"
+
+def git_ignored_files
+  git_clean_out = `git clean -ndx`.lines
+  prefix = /^Would (?:remove|skip repository) /
+
+  if git_clean_out.any? { |_| prefix !~ _ }
+    puts git_clean_out
+    raise "`git clean -ndx` doesn't return line starting with 'Would remove' or 'Would skip'"
+  end
+
+  excludes = git_clean_out.grep(prefix).map{ |_| _.sub(prefix, '').chomp }
+  if package_under
+    excludes.grep(/^#{Regexp.escape(package_under)}/).map{ |_| _.sub(/^#{Regexp.escape(package_under)}\/?/, '') }
+  else
+    excludes
+  end
+end
+
+def git_head
+  git_show = `git show --pretty=fuller -s`
+  commit, comment = git_show.split(/\n\n/, 2)
+
+  {
+    commit: commit.match(/^commit (.+)$/)[1],
+    author: commit.match(/^Author:\s*(?<name>.+?) <(?<email>.+?)>$/).
+      tap {|match| break Hash[match.names.map {|name| [name.to_sym, match[name]] }] },
+    author_date: Time.parse(commit.match(/^AuthorDate:\s*(.+)$/)[1]),
+    committer: commit.match(/^Commit:\s*(?<name>.+?) <(?<email>.+?)>$/).
+      tap {|match| break Hash[match.names.map {|name| [name.to_sym, match[name]] }] },
+    commit_date: Time.parse(commit.match(/^CommitDate:\s*(.+)$/)[1]),
+  }
+end
+
+prepare_build do |update|
+  logger = self.logger['git']
+
+  if !update && !self.repository
+    logger.warn 'Skipping cloning repository because script.repository not set'
+  elsif !update
+    run "git", "clone", self.repository, self.build_from
+  end
+
+  Dir.chdir(self.build_from) do
+    logger.info Dir.pwd
+    run "git", "fetch", self.git_remote
+    run "git", "remote", "prune", self.git_remote, allow_failure: true
+    run "git", "fetch", "--tags", self.git_remote
+
+    run "git", "reset", "--hard", self.commit
+  end
+end
+
+if options[:exclude_git_clean_targets]
+  build(:prepend) do
+    set :exclude_from_package, exclude_from_package + git_ignored_files()
+  end
+end
+
+options[:add_commit_hash_to_package_name] = true unless options.key?(:add_commit_hash_to_package_name)
+if options[:add_commit_hash_to_package_name]
+  package_name do |candidate|
+    candidate + [git_head[:commit]]
+  end
+end
+
+options[:include_head_commit_to_meta] = true unless options.key?(:include_head_commit_to_meta)
+if options[:include_head_commit_to_meta]
+  package_meta do |candidate|
+    candidate.merge(git: git_head())
+  end
+end