houcho 0.0.2 → 0.0.3

data/lib/houcho.rb

@@ -1,5 +1,44 @@
-require 'houcho/version'
+# -*- encoding: utf-8 -*-
+require 'awesome_print'
+require 'rainbow'
+require 'parallel'
+require 'systemu'
+require 'tempfile'
+require 'find'
+require 'yaml'
+require 'json'
+require 'houcho/initialize'
+require 'houcho/yamlhandle'
+require 'houcho/element'
+require 'houcho/role'
+require 'houcho/host'
+require 'houcho/spec'
+require 'houcho/spec/runner'
+require 'houcho/cloudforecast'
+require 'houcho/cloudforecast/role'
+require 'houcho/cloudforecast/host'
+require 'houcho/ci'
 
 module Houcho
-  # Your code goes here...
+  def puts_details(e, indentsize = 0, cnt = 1)
+    case e
+    when Array
+      e.sort.each.with_index(1) do |v, i|
+        (indentsize-1).times {print '   '}
+        print i != e.size ? '├─ ' : '└─ '
+        puts v
+      end
+      puts ''
+    when Hash
+      e.each do |k,v|
+        if ! indentsize.zero?
+          (indentsize).times {print '   '}
+        end
+        k = k.color(0,255,0)
+        k = '[' + k.color(219,112,147) + ']' if indentsize.zero?
+        puts k
+        puts_details(v, indentsize+1, cnt+1)
+      end
+    end
+  end
 end

data/lib/{CI.rb → houcho/ci.rb}

@@ -1,7 +1,12 @@
 require 'net/http'
 require 'uri'
 
-class CI
+module Houcho
+  module CI
+  end
+end
+
+module Houcho::CI
   class UkigumoClient
     def initialize(server, port = 80, url = "http://#{server}:#{port}")
       @ukigumo_server      = server
@@ -57,5 +62,4 @@ class CI
       end
     end
   end
-
 end

data/lib/houcho/cloudforecast.rb

@@ -0,0 +1,59 @@
+module Houcho
+  module CloudForecast
+    module_function
+
+    def load_yaml
+      yaml_file = Tempfile.new('yaml')
+      File.open(yaml_file,'a') do |t|
+        Find.find('./role/cloudforecast') do |f|
+          t.write File.read(f) if f =~ /\.yaml$/
+        end
+      end
+
+      role_hosts = {}
+      elements    = {}
+      group       = []
+      File.open(yaml_file) do |f|
+        f.each do |l|
+          if l =~ /^---/
+            if l =~ /^---\s+#(.+)$/
+              group << $1.gsub(/\s/, '_')
+            else
+              group << 'NOGROUPNAME'
+            end
+          end
+        end
+      end
+      File.open(yaml_file) do |f|
+        i=0
+        YAML.load_documents(f) do |data|
+          elements[group[i]] ||= []
+          elements[group[i]].concat data['servers']
+          i+=1
+        end
+      end
+
+      elements.each do |groupname, data|
+        current_label = 'NOCATEGORYNAME'
+
+        data.each do |d|
+          if ! d['label'].nil?
+            label = d['label'].gsub(/\s/, '_')
+            current_label = label if current_label != label
+          end
+
+          d['hosts'].map! do |host|
+            host = host.split(' ')
+            host = host.size == 1 ? host[0] : host[1]
+          end
+
+          r = groupname + '::' + current_label + '::' + d['config'].sub(/\.yaml$/, '')
+          ary = (role_hosts[r] || []) | d['hosts']
+          role_hosts[r] = ary.uniq
+        end
+      end
+
+      File.write('./role/cloudforecast.yaml', role_hosts.to_yaml)
+    end
+  end
+end

data/lib/houcho/cloudforecast/host.rb

@@ -0,0 +1,23 @@
+module Houcho
+  module CloudForecast::Host
+    @cfdata = YamlHandle::Loader.new('./role/cloudforecast.yaml').data
+
+    module_function
+
+    def roles(host)
+      @cfdata.select {|cfrole, cfhosts|cfhosts.include?(host)}.keys
+    end
+
+    def hosts(role)
+      @cfdata[role] || []
+    end
+
+    def details(host)
+      CloudForecast::Role.details(roles(host))
+    end
+
+    def all
+      @cfdata.values.flatten.uniq
+    end
+  end
+end

data/lib/houcho/cloudforecast/role.rb

@@ -0,0 +1,24 @@
+module Houcho
+  module CloudForecast
+    class Role
+      @elements = YamlHandle::Editor.new('./role/cf_roles.yaml')
+      extend Element
+
+      def self.details(cfroles)
+        result = {}
+        cfroles.each do |cfrole|
+          hosts = CloudForecast::Host.hosts(cfrole)
+          if ! hosts.empty?
+            result[cfrole] = {}
+            result[cfrole]['host'] = hosts
+          end
+        end
+        result
+      end
+
+      def self.all
+        YamlHandle::Loader.new('./role/cloudforecast.yaml').data.keys
+      end
+    end
+  end
+end

data/lib/houcho/element.rb

@@ -0,0 +1,74 @@
+module Houcho
+  module Element
+
+    def elements(index = nil)
+      if index
+        (@elements.data[index]||[]).uniq
+      else
+        @elements.data.values.flatten.uniq
+      end
+    end
+
+
+    def attach(elements, roles)
+      invalid_roles = []
+      roles.each do |role|
+        index = Role.index(role)
+        if ! index
+          invalid_roles << role
+          next
+        end
+
+        @elements.data[index] ||= []
+        @elements.data[index] = (@elements.data[index] + elements).sort.uniq
+      end
+
+      @elements.save_to_file
+      abort("role(#{invalid_roles.join(',')}) does not exist") if ! invalid_roles.size.zero?
+    end
+
+
+    def detach(elements, roles)
+      invalid_roles = []
+      roles.each do |role|
+        index = Role.index(role)
+        if ! index
+          invalid_roles << role
+          next
+        end
+
+        @elements.data[index] -= elements
+      end
+
+      @elements.save_to_file
+      abort("role(#{invalid_roles.join(',')}) does not exist") if ! invalid_roles.size.zero?
+    end
+
+
+    def attached?(index, element)
+      return false if ! @elements.data.has_key?(index)
+      @elements.data[index].include?(element)
+    end
+
+
+    def has_data?(index)
+      return false if ! @elements.data.has_key?(index)
+      @elements.data[index].size != 0
+    end
+
+
+    def indexes(element)
+      return [] if ! @elements.data.values.flatten.include?(element)
+      @elements.data.select {|index, elems|elems.include?(element)}.keys
+    end
+
+
+    def details(elements)
+      result = {}
+      elements.each do |element|
+        result[element] = { 'role' => self.indexes(element).map {|index|Role.name(index)} }
+      end
+      result
+    end
+  end
+end

data/lib/houcho/host.rb

@@ -0,0 +1,22 @@
+module Houcho
+  class Host
+    @elements = YamlHandle::Editor.new('./role/hosts.yaml')
+    extend Element
+
+    def self.details(hosts)
+      result  = {}
+
+      hosts.each do |host|
+        roles = self.indexes(host).map {|index|Role.name(index)}
+        cfroles = CloudForecast::Host.roles(host)
+
+        result[host]         = {}
+        result[host]['role'] = roles   if ! roles.empty?
+        result[host]['cf']   = cfroles if ! cfroles.empty?
+
+        result.delete(host) if result[host].keys.empty?
+      end
+      result
+    end
+  end
+end

data/lib/houcho/initialize.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+
+module Houcho
+  module Initialize
+    templates = File.expand_path("#{File.dirname(__FILE__)}/../../templates")
+
+    %W{conf role spec}.each do |d|
+      FileUtils.cp_r("#{templates}/#{d}", d) if ! Dir.exist?(d)
+    end
+
+    File.symlink('./conf/rspec.conf', './.rspec') if ! File.exists? '.rspec'
+
+    `git init; git add .; git commit -a -m 'initialized houcho repository'` if ! Dir.exist?('.git')
+  end
+end

data/lib/houcho/role.rb

@@ -0,0 +1,121 @@
+module Houcho
+  module Role
+    @roles = YamlHandle::Editor.new('./role/roles.yaml')
+
+    module_function
+
+    def create(role, exists = [])
+      target = role.shift
+
+      if self.index(target)
+        exists << target
+      else
+        @roles.data[(@roles.data.keys.max||0) + 1] = target
+      end
+
+      if role.size == 0
+        @roles.save_to_file
+        abort("role(#{exists.join(',')}) already exist.") if exists.size != 0
+      else
+        self.create(role, exists)
+      end
+    end
+
+
+    def delete(role, errors = {exists:[], hosts:[], specs:[], cf:[]})
+      target = role.shift
+      index  = self.index(target)
+      del    = true
+
+      if ! index
+        errors[:exists] << target; del = false
+      end
+      if Host.has_data?(index)
+        errors[:hosts] << target if Host.has_data?(index); del = false
+      end
+      if Spec.has_data?(index)
+        errors[:specs] << target if Spec.has_data?(index); del = false
+      end
+      if CloudForecast::Role.has_data?(index)
+        errors[:cf] << target if CloudForecast::Role.has_data?(index); del = false
+      end
+
+      @roles.data.delete(index) if del
+
+      if role.size.zero?
+        @roles.save_to_file
+        e =  []
+        e << "role(#{errors[:exists].join(',')}) does not exist" if ! errors[:exists].size.zero?
+        e << "detach host from #{errors[:hosts].join(',')} before delete" if ! errors[:hosts].size.zero?
+        e << "detach spec from #{errors[:specs].join(',')} before delete" if ! errors[:specs].size.zero?
+        e << "detach cloudforecast's role from #{errors[:cf].join(',')} before delete" if ! errors[:cf].size.zero?
+        abort("#{e.join(', ')}.") if ! e.size.zero?
+      else
+        self.delete(role, errors)
+      end
+    end
+
+
+    def rename(role, name)
+      index = self.index(role)
+      abort("#{role} does not exist") if ! index
+      abort("#{name} already exist") if self.index(name)
+
+      @roles.data[index] = name
+      @roles.save_to_file
+    end
+
+
+    def all
+      YamlHandle::Loader.new('./role/roles.yaml').data.values.sort
+    end
+
+
+    def details(roles)
+      result = {}
+
+      # too lengthy implementation... I think necessary to change...
+      roles = roles.map do |role|
+        if self.index(role)
+          role
+        else
+          self.indexes_regexp(Regexp.new(role)).map {|index|self.name(index)}
+        end
+      end.flatten.sort.uniq
+
+      roles.each do |role|
+        index = self.index(role)
+        next if ! index
+
+        hosts   = Host.elements(index)
+        specs   = Spec.elements(index)
+        cfroles = CloudForecast::Role.elements(index)
+        cfhosts = CloudForecast::Role.details(cfroles)
+
+        r         = {}
+        r['host'] = hosts   if ! hosts.empty?
+        r['spec'] = specs   if ! specs.empty?
+        r['cf']   = cfhosts if ! cfhosts.empty?
+
+        result[role] = r
+      end
+
+      result
+    end
+
+
+    def index(role)
+      @roles.data.invert[role]
+    end
+
+
+    def indexes_regexp(role)
+      @roles.data.select {|index, rolename| rolename =~ role }.keys
+    end
+
+
+    def name(index)
+      @roles.data[index]
+    end
+  end
+end

data/lib/houcho/spec.rb

@@ -0,0 +1,6 @@
+module Houcho
+  class Spec
+    @elements = YamlHandle::Editor.new('./role/specs.yaml')
+    extend Element
+  end
+end

data/lib/houcho/spec/runner.rb

@@ -0,0 +1,116 @@
+module Houcho
+  module Spec::Runner
+    module_function
+
+    def prepare(roles, ex_hosts, hosts, specs)
+      runlist        = {}
+      spec_not_exist = []
+
+      spec_check = Proc.new do |specs|
+        p = specs.map {|spec|'spec/' + spec + '_spec.rb'}.partition {|spes|File.exist?(spes)}
+        spec_not_exist += p[1].map {|e|e.sub(/^spec\//,'').sub(/_spec.rb$/,'')}
+        p[0]
+      end
+
+      Role.details(roles).each do |role, detail|
+        r         = {}
+        r['spec'] = spec_check.call(detail['spec']||[])
+        r['host'] = detail['host']||[]
+
+        (detail['cf']||{}).each do |cfrole, value|
+          r['host'] += value['host']
+        end
+        r['host'] -= ex_hosts
+
+        runlist[role] = r
+      end
+
+      m         = {}
+      m['host'] = hosts
+      m['spec'] = spec_check.call(specs)
+
+      runlist[:'run manually'] = m if m != {}
+
+      if ! spec_not_exist.empty?
+        $houcho_fail = true
+        puts "spec(#{spec_not_exist.join(',')}) file not exist in ./spec directory."
+      end
+      runlist
+    end
+
+
+    def exec(roles, ex_hosts, hosts, specs, ci = {}, dryrun = nil)
+      self.prepare(roles, ex_hosts, hosts, specs).each do |role, v|
+        next if v['spec'].empty?
+        command = "parallel_rspec #{v['spec'].sort.uniq.join(' ')}"
+
+        if dryrun
+          v['host'].each do |host| 
+            puts "TARGET_HOST=#{host} #{command}"
+          end
+          next
+        end
+
+        v['host'].each do |host|
+          ENV['TARGET_HOST'] = host
+          result = systemu command
+          puts result[1].scan(/\d* examples?, \d* failures?\n/).first.chomp + "\t#{host}, #{command}\n"
+
+          post_result(result, role, host, command, ci) if ci != {}
+          $houcho_fail = true if result[0] != 0
+        end
+      end
+    end
+
+
+    def post_result(result, role, host, command, ci)
+      conf = YAML.load_file('conf/houcho.conf')
+      result_status = result[0] == 0 ? 1 : 2
+
+      if ci[:ukigumo]
+        ukigumo_report = CI::UkigumoClient.new(conf['ukigumo']['host'], conf['ukigumo']['port']).post({
+          :status   => result_status,
+          :project  => role,
+          :branch   => host.gsub(/\./, '-'),
+          :repo     => conf['git']['uri'],
+          :revision => `git log spec/| grep '^commit' | head -1 | awk '{print $2}'`.chomp,
+          :vc_log   => command,
+          :body     => result[1],
+        })
+      end
+
+      if ci[:ikachan] && result_status != 1
+        message  = "[serverspec fail]\`TARGET_HOST=#{host} #{command}\` "
+        message += JSON.parse(ukigumo_report)['report']['url'] if ukigumo_report
+        CI::IkachanClient.new(
+          conf['ikachan']['channel'],
+          conf['ikachan']['host'],
+          conf['ikachan']['port']
+        ).post(message)
+      end
+    end
+
+
+    def check(specs, host_count)
+      specs = specs.flatten
+
+      specs.each do |spec|
+        hosts   = []
+        indexes = Spec.indexes(spec)
+
+        if indexes.empty?
+          puts "#{spec} has not attached to any roles"
+          next
+        end
+
+        indexes.each do |index|
+          hosts += Host.elements(index)
+          CloudForecast::Role.elements(index).each do |cfrole|
+            hosts += CloudForecast::Host(cfrole)
+          end
+        end
+        hosts.sample(host_count).each {|host| exec([], [], [host], [spec])}
+      end
+    end
+  end
+end