houcho 0.0.6 → 0.0.8

data/lib/houcho/cli/role.rb

@@ -0,0 +1,69 @@
+require "thor"
+require "houcho/role"
+
+module Houcho
+  module CLI
+    class Role < Thor
+      namespace :role
+
+      @@r = Houcho::Role.new
+
+      desc 'create [role1 role2 role3...]', 'cretate role'
+      def create(*args)
+        Houcho::CLI::Main.empty_args(self, shell, __method__) if args.empty?
+        @@r.create(args)
+      rescue Houcho::RoleExistenceException => e
+        puts e.message
+        exit!
+      end
+
+      desc 'delete [role1 role2 role3...]', 'delete a role'
+      def delete(*args)
+        Houcho::CLI::Main.empty_args(self, shell, __method__) if args.empty?
+        @@r.delete(args)
+      rescue SQLite3::ConstraintException => e
+        puts e.message
+        exit!
+      end
+
+      desc 'rename [exist role] [name]', 'rename a role'
+      def rename(exist_role, name)
+        @@r.rename(exist_role, name)
+      rescue SQLite3::ConstraintException, SQLite3::SQLException => e
+        puts e.message
+        exit!
+      end
+
+      desc 'details [role1 role2...]', 'show details about role'
+      def details(*args)
+        Houcho::CLI::Main.empty_args(self, shell, __method__) if args.empty?
+        Houcho::CLI::Main.puts_details(@@r.details(args))
+      end
+
+      desc 'list', 'show all of roles'
+      def list
+        puts @@r.list.join("\n")
+      end
+
+      desc 'exec (role1 role2..) [options]', 'run role'
+      option :exclude_hosts, :type => :array, :desc => '--exclude-hosts host1 host2 host3...'
+      option :dry_run, :type => :boolean, :default => false, :desc => 'show commands that may exexute'
+      def exec(*args)
+        Houcho::CLI::Main.empty_args(self, shell, __method__) if args.empty?
+        runner = Houcho::Spec::Runner.new
+
+        begin
+          exit! unless runner.execute_role(
+            args,
+            (options[:exclude_hosts] || []),
+            options[:dry_run],
+            true #output to console
+          )
+        rescue Houcho::SpecFileException => e
+          puts e.message
+          exit!
+        end
+      end
+    end
+  end
+end

data/lib/houcho/cli/spec.rb

@@ -0,0 +1,103 @@
+require 'thor'
+require 'houcho/spec'
+require 'houcho/spec/runner'
+
+module Houcho
+  module CLI
+    class Spec < Thor
+      namespace :spec
+
+      @@s = Houcho::Spec.new
+
+      desc 'list', 'show all of spec list'
+      def list
+        puts @@s.list.sort.join("\n")
+      end
+
+
+      desc 'attach [spec1 spec2 spec3...] --roles [role1 role2...]', 'attach spec to role'
+      option :roles, :type => :array, :required => true, :desc => 'specify the roles separated by spaces.'
+      def attach(*args)
+        @@s.attach(args, options[:roles])
+      rescue RoleExistenceException, SpecFileException, SQLite3::ConstraintException => e
+        puts e.message
+        exit!
+      end
+
+
+      desc 'detach [spec1 spec2 spec3...]', 'detach spec from spec'
+      option :roles, :type => :array, :required => true, :desc => 'specify the roles separated by spaces.'
+      def detach(*args)
+        @@s.detach(args, options[:roles])
+      rescue RoleExistenceException, SQLite3::ConstraintException => e
+        puts e.message
+        exit!
+      end
+
+
+      desc "rename [from] [to]", "rename spec file"
+      def rename(from, to)
+        @@s.rename(from, to)
+      rescue SpecFileException => e
+        puts e.message
+        exit!
+      end
+
+
+      desc "delete [spec1 spec2 spec3...]", "delete spec file from houcho repository."
+      option :force, :aliases => "-f", :type => :boolean, :desc => "delete spec force together with attachment."
+      def delete(*args)
+        if options[:force]
+          @@s.delete_file!(args)
+        else
+          @@s.delete_file(args)
+        end
+      rescue SpecFileException => e
+        puts e.message
+        exit!
+      end
+
+
+      desc 'details [spec1 spec2 spec3...]', 'show details about spec'
+      def details(*args)
+        Houcho::CLI::Main.puts_details(@@s.details(args))
+      end
+
+
+      desc 'check [spec1 spec2...]', 'run the spec sampled appropriately to the associated host'
+      option :samples, :type => :numeric, :default => 5, :desc => 'number of sample hosts'
+      def check(*args)
+        Houcho::CLI::Main.empty_args(self, shell, __method__) if args.empty?
+        runner = Houcho::Spec::Runner.new
+
+        begin
+          exit! unless runner.check(args, options[:samples], false, true)
+        rescue SpecFileException => e
+          puts e.message
+          exit!
+        end
+      end
+
+
+      desc 'exec [spec1 spec2..]', 'run spec'
+      option :hosts,   :type => :array,   :desc => '--hosts host1 host2 host3...', :required => true
+      option :dry_run, :type => :boolean, :default => false, :desc => 'show commands that may exexute'
+      def exec(*args)
+        Houcho::CLI::Main.empty_args(self, shell, __method__) if args.empty?
+        runner = Houcho::Spec::Runner.new
+
+        begin
+          exit! unless runner.execute_manually(
+            options[:hosts],
+            args,
+            options[:dry_run],
+            true #output to console
+          )
+        rescue Houcho::SpecFileException => e
+          puts e.message
+          exit!
+        end
+      end
+    end
+  end
+end

data/lib/houcho/cli.rb

@@ -0,0 +1,52 @@
+require "thor"
+require "rainbow"
+require "houcho/repository"
+
+module Houcho::CLI
+  class Main < Thor
+    if File.exist?("#{Houcho::Config::APPROOT}/houcho.db")
+      require "houcho/cli/role"
+      require "houcho/cli/spec"
+      require "houcho/cli/host"
+      require "houcho/cli/outerrole"
+      require "houcho/cli/attribute"
+      register(Houcho::CLI::Role, "role", "role [create|delete|rename|list|details|exec]", "operation of roles")
+      register(Houcho::CLI::Host, "host", "host [attach|detach|list|details]", "operation of hosts")
+      register(Houcho::CLI::Spec, "spec", "spec [attach|detach|list|details|rename|delete|exec|check]", "operation of specs")
+      register(Houcho::CLI::OuterRole, "outerrole", "outerrole [attach|detach|list|details|load]", "operation of outer roles")
+      register(Houcho::CLI::Attribute, "attr", "attr [set|get|delete]", "operation of attribute")
+    end
+
+    desc "init","set houcho repository on directory set environment variable HOUCHO_ROOT"
+    def init
+      Houcho::Repository.init
+    end
+
+    def self.empty_args(klass, chell, mesod)
+      klass.class.task_help(chell, mesod)
+      exit
+    end
+
+    def self.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 != 0
+            (indentsize).times {print '   '}
+          end
+          title = k.to_s.color(0,255,0)
+          title = '[' + k.to_s.color(219,112,147) + ']' if indentsize == 0
+          puts title
+          puts_details(v, indentsize+1, cnt+1)
+        end
+      end
+    end
+  end
+end

data/lib/houcho/config.rb

@@ -0,0 +1,28 @@
+require "yaml"
+
+module Houcho
+  module Config
+    APPROOT = ENV["HOUCHO_ROOT"] ? ENV["HOUCHO_ROOT"] : "/etc/houcho"
+
+    SPECDIR = "#{APPROOT}/spec"
+    SCRIPTDIR = "#{APPROOT}/script"
+
+    OUTERROLESOURCEDIR = "#{APPROOT}/outerrole"
+    CFYAMLDIR = "#{OUTERROLESOURCEDIR}/cloudforecast"
+
+    LOGDIR = "#{APPROOT}/log"
+    SPECLOG = "#{LOGDIR}/serverspec.log"
+
+    FILE = "#{Houcho::Config::APPROOT}/houcho.conf"
+    begin
+      conf = YAML.load_file(FILE)
+    rescue
+    end
+    if conf
+      UKIGUMO = conf["ukigumo"]
+      IKACHAN = conf["ikachan"]
+      GIT = conf["git"]
+      RSPEC = conf["rspec"]
+    end
+  end
+end

data/lib/houcho/database.rb

@@ -0,0 +1,99 @@
+require "sqlite3"
+require "houcho/config"
+
+module Houcho
+  class Database
+    attr_reader :handle
+
+    def initialize
+      @handle = SQLite3::Database.new("#{Houcho::Config::APPROOT}/houcho.db")
+      @handle.execute("PRAGMA foreign_keys = ON")
+    end
+
+    def create_tables
+      @handle.execute_batch <<-SQL
+        CREATE TABLE IF NOT EXISTS role (
+          id INTEGER NOT NULL PRIMARY KEY,
+          name VARCHAR NOT NULL UNIQUE
+        );
+
+        CREATE TABLE IF NOT EXISTS host (
+          id INTEGER NOT NULL PRIMARY KEY,
+          name VARCHAR NOT NULL UNIQUE
+        );
+
+        CREATE TABLE IF NOT EXISTS role_host (
+          role_id INTEGER NOT NULL,
+          host_id INTEGER NOT NULL,
+          UNIQUE(role_id, host_id),
+          FOREIGN KEY (role_id) REFERENCES role (id) ON DELETE RESTRICT,
+          FOREIGN KEY (host_id) REFERENCES host (id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE IF NOT EXISTS serverspec (
+          id INTEGER NOT NULL PRIMARY KEY,
+          name VARCHAR NOT NULL UNIQUE
+        );
+
+        CREATE TABLE IF NOT EXISTS role_serverspec (
+          role_id INTEGER NOT NULL,
+          serverspec_id INTEGER NOT NULL,
+          UNIQUE(role_id, serverspec_id),
+          FOREIGN KEY (role_id) REFERENCES role (id) ON DELETE RESTRICT,
+          FOREIGN KEY (serverspec_id) REFERENCES serverspec (id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE IF NOT EXISTS script (
+          id INTEGER NOT NULL PRIMARY KEY,
+          name VARCHAR NOT NULL UNIQUE
+        );
+
+        CREATE TABLE IF NOT EXISTS role_script (
+          role_id INTEGER NOT NULL,
+          script_id INTEGER NOT NULL,
+          UNIQUE(role_id, script_id),
+          FOREIGN KEY (role_id) REFERENCES role (id) ON DELETE RESTRICT,
+          FOREIGN KEY (script_id) REFERENCES script (id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE IF NOT EXISTS outerrole (
+          id INTEGER NOT NULL PRIMARY KEY,
+          name VARCHAR NOT NULL UNIQUE,
+          data_source VARCHAR NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS outerrole_host (
+          outerrole_id INTEGER NOT NULL,
+          host_id INTEGER NOT NULL,
+          UNIQUE(outerrole_id, host_id),
+          FOREIGN KEY (outerrole_id) REFERENCES outerrole (id) ON DELETE RESTRICT,
+          FOREIGN KEY (host_id) REFERENCES host (id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE IF NOT EXISTS role_outerrole (
+          role_id INTEGER NOT NULL,
+          outerrole_id INTEGER NOT NULL,
+          UNIQUE(role_id, outerrole_id),
+          FOREIGN KEY (role_id) REFERENCES role (id) ON DELETE RESTRICT,
+          FOREIGN KEY (outerrole_id) REFERENCES outerrole (id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE IF NOT EXISTS attribute (
+          id INTEGER NOT NULL PRIMARY KEY,
+          name VARCHAR NOT NULL UNIQUE
+        );
+
+        CREATE TABLE IF NOT EXISTS attribute_value (
+          id INTEGER NOT NULL PRIMARY KEY,
+          attr_id INTEGER NOT NULL,
+          element_type INTEGER NOT NULL,
+          element_id INTEGER NOT NULL,
+          value VARCHAR NOT NULL,
+          COMMENT "element_type => {0:role, 1:outerrole, 2:host}",
+          UNIQUE(attr_id, element_type, element_id),
+          FOREIGN KEY (attr_id) REFERENCES attribute (id) ON DELETE RESTRICT
+        );
+      SQL
+    end
+  end
+end

data/lib/houcho/element.rb

@@ -1,80 +1,109 @@
+require 'houcho/role'
+require "houcho/database"
+
 module Houcho
-  module Element
+  class Element
+    def initialize(type)
+      @db = Houcho::Database.new.handle
+      @role = Houcho::Role.new
+      @type = type
+    end
 
-    def elements(index = nil)
-      if index
-        (@elements.data[index]||[]).uniq
-      else
-        @elements.data.values.flatten.uniq
-      end
+
+    def id(name)
+      @db.execute("SELECT id FROM #{@type} WHERE name = '#{name}'").flatten.first
     end
 
 
-    def attach(elements, roles)
-      elements = [elements] if elements.class == String
-      roles    = [roles]    if roles.class    == String
+    def list(role_id = nil)
+      sql = "SELECT T1.name FROM #{@type} T1"
+      sql += " JOIN role_#{@type} T2 ON T1.id = T2.#{@type}_id WHERE T2.role_id = #{role_id}" if role_id
 
-      invalid_roles = []
-      roles.each do |role|
-        index = Role.index(role)
-        if ! index
-          invalid_roles << role
-          next
-        end
+      @db.execute(sql).flatten
+    end
 
-        @elements.data[index] ||= []
-        @elements.data[index] = (@elements.data[index] + elements).sort.uniq
+
+    def details(elements)
+      elements = elements.is_a?(Array) ? elements : [elements]
+      result = {}
+
+      elements.each do |element|
+        roles = @db.execute("
+          SELECT role.name
+          FROM role, #{@type}, role_#{@type}
+          WHERE role_#{@type}.#{@type}_id = #{@type}.id
+          AND role_#{@type}.role_id = role.id
+          AND #{@type}.name = ?
+        ", element).flatten.sort.uniq
+
+        result[element] = { "role" => roles }
       end
 
-      @elements.save_to_file
-      raise("role(#{invalid_roles.join(',')}) does not exist") if ! invalid_roles.size.zero?
+      result
     end
 
 
-    def detach(elements, roles)
-      elements = [elements] if elements.class == String
-      roles    = [roles]    if roles.class    == String
+    def attach(elements, roles)
+      elements = [elements] unless elements.is_a?(Array)
+      roles = [roles] unless roles.is_a?(Array)
 
-      invalid_roles = []
       roles.each do |role|
-        index = Role.index(role)
-        if ! index
-          invalid_roles << role
-          next
-        end
+        role_id = @role.id(role)
+        raise RoleExistenceException, "role does not exist - #{role}" unless role_id
 
-        @elements.data[index] -= elements
-      end
+        @db.transaction do
 
-      @elements.save_to_file
-      raise("role(#{invalid_roles.join(',')}) does not exist") if ! invalid_roles.size.zero?
-    end
+        elements.each do |element|
+          @db.execute("INSERT INTO #{@type}(name) VALUES(?)", element) unless id(element)
 
+          begin
+            @db.execute("INSERT INTO role_#{@type} VALUES(?,?)", role_id, id(element))
+          rescue SQLite3::ConstraintException
+            next
+          end
+        end
 
-    def attached?(index, element)
-      return false if ! @elements.data.has_key?(index)
-      @elements.data[index].include?(element)
+        end #end of transaction
+      end
     end
 
 
-    def has_data?(index)
-      return false if ! @elements.data.has_key?(index)
-      @elements.data[index].size != 0
+    def detach_from_all(elements)
+      roles = []
+      details(elements).each do |e, r|
+        roles = roles.concat(r["role"]||[]).uniq
+      end
+
+      detach(elements, roles)
     end
 
 
-    def indexes(element)
-      return [] if ! @elements.data.values.flatten.include?(element)
-      @elements.data.select {|index, elems|elems.include?(element)}.keys
-    end
+    def detach(elements, roles)
+      elements = [elements] unless elements.is_a?(Array)
+      roles = [roles] unless roles.is_a?(Array)
 
+      roles.each do |role|
+        role_id = @role.id(role)
+        raise RoleExistenceException, "role does not exist - #{role}" if role_id.nil?
+
+        @db.transaction do
+
+        elements.each do |element|
+          @db.execute(
+            "DELETE FROM role_#{@type} WHERE role_id = ? AND #{@type}_id = ?",
+            role_id,
+            id(element)
+          )
+
+          begin
+            @db.execute("DELETE FROM #{@type} WHERE name = ?", element)
+          rescue SQLite3::ConstraintException, "foreign key constraint failed"
+            next
+          end
+        end
 
-    def details(elements)
-      result = {}
-      elements.each do |element|
-        result[element] = { 'role' => self.indexes(element).map {|index|Role.name(index)} }
+        end #end of transaction
       end
-      result
     end
   end
 end

data/lib/houcho/host.rb

@@ -1,22 +1,43 @@
+require "houcho/element"
+require "houcho/attribute"
+
 module Houcho
-  class Host
-    @elements = YamlHandle::Editor.new('./role/hosts.yaml')
-    extend Element
+  class HostExistenceException < Exception; end
+
+  class Host < Element
+    include Houcho::Attribute
+
+    def initialize
+      super("host")
+      @type_id = 2
+    end
 
-    def self.details(hosts)
+    def details(hosts)
+      hosts = hosts.is_a?(Array) ? hosts : [hosts]
       result  = {}
 
       hosts.each do |host|
-        roles = self.indexes(host).map {|index|Role.name(index)}
-        cfroles = CloudForecast::Host.new.roles(host)
+        roles = super(host)[host]["role"]
+        outerroles = @db.execute("
+          SELECT role.name
+          FROM outerrole role, outerrole_host oh
+          WHERE role.id = oh.outerrole_id
+          AND oh.host_id = ?
+        ", id(host)).flatten.sort.uniq
 
-        result[host]         = {}
-        result[host]['role'] = roles   if ! roles.empty?
-        result[host]['cf']   = cfroles if ! cfroles.empty?
+        result[host] = {}
+        result[host]["role"] = roles if ! roles.empty?
+        result[host]["outer role"] = outerroles if ! outerroles.empty?
 
         result.delete(host) if result[host].keys.empty?
       end
+
       result
     end
+
+    private
+    def raise_target_does_not_exist(target)
+      raise HostExistenceException, "host does not exist - #{target}"
+    end
   end
 end

data/lib/houcho/outerrole/cloudforecast.rb

@@ -0,0 +1,94 @@
+require "houcho/config"
+require "houcho/database"
+require "yaml"
+
+module Houcho
+
+class OuterRole
+  class CloudForecast; end
+  class << CloudForecast
+    def load
+      cfdir = Houcho::Config::CFYAMLDIR
+
+      Dir::entries(cfdir).each do |file|
+        next if file !~ /\.yaml$/
+        yaml = "#{cfdir}/#{file}"
+        group = load_group(yaml)
+        cfrole = create_cf_role(yaml, group)
+
+        save_cf_role(cfrole)
+      end
+    end
+
+
+    private
+    def load_group(yaml)
+      group = []
+
+      File.open(yaml).each_line do |line|
+        next unless line =~ /^---/
+        if line =~ /^---\s+#(?<group>.+)\n/
+          group << $~[:group].gsub(/\s+/, "_")
+        else
+          group << "NOGROUP"
+        end
+      end
+
+      group
+    end
+
+
+    def create_cf_role(yaml, group)
+      cfrole = {}
+
+      YAML.load_stream(File.open(yaml)).each_with_index do |doc, i|
+        label = "NOLABEL"
+
+        doc["servers"].each do |servers|
+          label = servers["label"].gsub(/\s+/, '_') if servers["label"]
+          outerrole = "#{group[i]}::#{label}::#{servers["config"].sub(/\.yaml$/, "")}"
+          hosts = servers["hosts"].map { |host| host.split(/\s+/)[1] }
+
+          cfrole[outerrole] = hosts
+        end
+      end
+
+      cfrole
+    end
+
+
+    def save_cf_role(cfrole)
+      db = Houcho::Database.new.handle
+      db.transaction do
+
+      cfrole.each do |outerrole, hosts|
+        begin
+          db.execute("INSERT INTO outerrole(name, data_source) VALUES(?,?)", outerrole, "CloudForecast")
+        rescue SQLite3::ConstraintException, "column name is not unique"
+        ensure
+          outerrole_id = db.execute("SELECT id FROM outerrole WHERE name = ?", outerrole).flatten.first
+        end
+
+        hosts.each do |host|
+          begin
+            db.execute("INSERT INTO host(name) VALUES(?)", host)
+          rescue SQLite3::ConstraintException, "column name is not unique"
+          ensure
+            begin
+              db.execute(
+                "INSERT INTO outerrole_host(outerrole_id, host_id) VALUES(?,?)",
+                outerrole_id,
+                db.execute("SELECT id FROM host WHERE name = ?", host).flatten.first
+              )
+            rescue SQLite3::ConstraintException, "column name is not unique"
+            end
+          end
+        end
+      end
+
+      end #end of transaction
+    end
+  end
+end
+
+end