server_settings 0.1.0

data/lib/server_settings/capistrano.rb

@@ -0,0 +1,23 @@
+require 'server_settings'
+
+module Capistrano
+  module ServersGroup
+    def self.extend(configuration)
+      configuration.load do
+        Capistrano::Configuration.instance.load do
+          def load_servers(pattern)
+            ServerSettings.load_config_dir(pattern)
+            ServerSettings.each_role do |role, hosts|
+              role role.to_sym, *hosts.map(&:host)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Capistrano::ServersGroup.extend(Capistrano::Configuration.instance)
+end
+

data/lib/server_settings/database.rb

@@ -0,0 +1,29 @@
+class ServerSettings
+  class Database
+    attr_accessor :name, :group, :master, :backup, :slaves, :settings
+    def initialize(name, group)
+      @name = name
+      @group = group
+    end
+
+    def config(role)
+      host = send(role)
+      case host
+      when Array
+        host.map { |h| settings.merge(:host => h) }
+      when String
+        settings.merge(:host => host)
+      else
+        nil
+      end
+    end
+
+    def host
+      @master
+    end
+
+    def has_slave?
+      !! @slaves and not @slaves.empty?
+    end
+  end
+end

data/lib/server_settings/database_config.rb

@@ -0,0 +1,46 @@
+class ServerSettings
+  class DatabaseConfig
+    def self.slave_name(name, idx)
+      name + "_slave#{idx}"
+    end
+
+    def self.generate_database_config(db_role, with_slave:true)
+      configuration = {}
+      return configuration unless ServerSettings.databases
+
+      ServerSettings.databases.each do |db|
+        next unless db.config(db_role)
+
+        role_db_config = db.config(db_role)
+        stringify_keys!(role_db_config) if defined? Rails
+
+        if db.name == "default"
+          if defined? Rails
+            configuration[Rails.env] = role_db_config
+          else
+            configuration.merge!(role_db_config)
+          end
+        elsif db.group
+          configuration[db.group] ||= {}
+          configuration[db.group][db.name] = role_db_config
+        else
+          configuration[db.name] = role_db_config
+        end
+
+        if with_slave && db.has_slave?
+          db.config(:slaves).each.with_index(1) do |config, idx|
+            # スレーブのバックアップホストは、マスターのバックアップホストと同じにする
+            config[:host] = db.backup if db_role == :backup
+            stringify_keys!(config) if defined? Rails
+            configuration[slave_name(db.name, idx)] = config
+          end
+        end
+      end
+      configuration
+    end
+
+    def self.stringify_keys!(config)
+      config.keys.each { |key| config[key.to_s] = config.delete(key) }
+    end
+  end
+end

data/lib/server_settings/host.rb

@@ -0,0 +1,16 @@
+class ServerSettings
+
+  class Host
+    attr_accessor :host, :port
+    def initialize(host,port)
+      @host = host
+      @port = port
+    end
+
+    def self.parse(host_line)
+      host, port = host_line.split(/:/)
+      self.new(host,port)
+    end
+  end
+
+end

data/lib/server_settings/host_collection.rb

@@ -0,0 +1,31 @@
+class ServerSettings
+
+  class HostCollection < Array
+    def initialize(hosts, role_config)
+      @role_config = role_config
+      unless hosts.kind_of?(Array)
+        raise InvalidHosts, "hosts: #{hosts} is not array"
+      end
+
+      hosts.each do |host_exp|
+        self.push Host.parse(host_exp)
+      end
+    end
+
+    def with_format(format)
+      self.map do |host|
+        replacemap = @role_config
+        replacemap['%host'] = host.host
+        replacemap['%port'] = host.port if host.port
+        replacemap.inject(format) do |string, mapping|
+          string.gsub(*mapping)
+        end
+      end
+    end
+
+    # Errors
+    class InvalidHosts < StandardError ; end
+
+  end
+
+end

data/lib/server_settings/railtie.rb

@@ -0,0 +1,10 @@
+class ServerSettings
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "server_settings/tasks/db.rake"
+    end
+    config.before_configuration do
+      ServerSettings.load_config_dir("#{Rails.root}/config/servers/#{Rails.env}/*.yml")
+    end
+  end
+end

data/lib/server_settings/role.rb

@@ -0,0 +1,42 @@
+class ServerSettings
+
+  class Role
+    attr_reader :name, :config
+
+    def initialize(role, config)
+      @name = role
+      @config = load(config)
+    end
+
+    def load(config)
+      role_options = config.keys.select{|s| s != "hosts"}
+      @settings = Hash[*role_options.map do |option_name|
+                         [ "%#{option_name}", config[option_name].to_s]
+                       end.flatten]
+      if config.has_key?("hosts")
+        config["hosts"]= HostCollection.new(config["hosts"], @settings)
+      end
+      config
+    end
+
+    def hosts
+      @config["hosts"] if @config.has_key?("hosts")
+    end
+
+    def host
+      hosts.first
+    end
+
+    def method_missing(name, *args, &block)
+      key = name.to_s
+      return nil unless @config.has_key? key
+      @config[key]
+    end
+
+    def with_format(format)
+      hosts.with_format(format)
+    end
+
+  end
+
+end

data/lib/server_settings/role_db.rb

@@ -0,0 +1,59 @@
+class ServerSettings
+
+  class RoleDB < Role
+    include Enumerable
+
+    def databases
+      @config.keys.select { |a| a.kind_of?(String) }
+    end
+
+    def build_db(name, config, group = nil)
+      db = Database.new(name, group)
+      db.master = config[:master]
+      db.backup = config[:backup]
+      db.slaves = config[:slaves]
+      db.settings = config_params(config)
+      return db
+    end
+
+    def find(db_name)
+      select { |s| s.name == db_name }.first
+    end
+
+    def each
+      default_db = build_db("default", @config)
+      yield default_db
+
+      databases.each do |db_name|
+        config = @config[db_name]
+
+        if config && config.has_key?(:master)
+          db = build_db(db_name, config)
+          db.settings = default_db.settings.merge(db.settings)
+          yield db
+
+        else # this is group section
+          group_name = db_name
+          config.map do |nest_db_name, nest_config|
+            db = build_db(nest_db_name, nest_config, group_name)
+            db.settings = default_db.settings.merge(db.settings)
+            yield db
+          end
+        end
+      end
+    end
+
+    def hosts
+      find_all
+    end
+
+    def config_params(config)
+      exclude_settings = [ :master, :backup, :slaves ]
+      config_keys = config.keys.select do |s|
+        s.is_a?(Symbol) and not exclude_settings.include?(s)
+      end
+      Hash[*config_keys.map {|s| [s, config[s]] }.flatten]
+    end
+
+  end
+end

data/lib/server_settings/tasks.rb

@@ -0,0 +1,9 @@
+class ServerSettings
+  module Task
+    def self.load_rake
+      spec = Gem::Specification.find_by_name "server_settings"
+      load "#{spec.gem_dir}/lib/server_settings/tasks/db.rake"
+    end
+  end
+end
+ServerSettings::Task.load_rake

data/lib/server_settings/tasks/db.rake

@@ -0,0 +1,98 @@
+namespace :server_settings do
+  namespace :db do
+    namespace :create do
+      require "colorize"
+
+      def build_new_db_configs
+        ServerSettings::DatabaseConfig.generate_database_config(:master).each_with_object([]) do |(_, config), new_db_configs|
+          client = Mysql2::Client.new(username: config["username"], password: config["password"], host: config["host"])
+          if client.query("SHOW DATABASES LIKE '#{ config['database'] }'").to_a.blank?
+            new_db_configs << [config, client]
+          else
+            client.close
+          end
+        end
+      end
+
+      def show_new_databases(new_db_configs)
+        if new_db_configs.blank?
+          puts "There is no new databases."
+        else
+          new_db_configs.each do |config, _|
+            puts format("* %-15s: new database '%s'", config["host"], config["database"]).colorize(:green)
+          end
+        end
+      end
+
+      def close_connections(new_db_configs)
+        new_db_configs.each { |_, client| client.close }
+      end
+
+      def confirm_and_execute(prompt, &block)
+        print "#{ prompt } (yes/N): "
+        if $stdin.gets.strip == "yes"
+          block.call
+        else
+          puts "Operation canceled."
+        end
+      end
+
+      def perform_show_status(new_db_configs)
+        show_new_databases(new_db_configs)
+        close_connections(new_db_configs)
+      end
+
+      def perform_create_databases(new_db_configs)
+        show_new_databases(new_db_configs)
+        confirm_and_execute "Are you sure you want to execute above?" do
+          new_db_configs.each do |config, client|
+            command = "CREATE DATABASE IF NOT EXISTS #{ config['database'] }"
+            puts "Executing '#{ command }' on #{ config['host'] }"
+            client.query(command)
+          end
+        end
+      ensure
+        close_connections(new_db_configs)
+      end
+
+      desc "Show status of new databases not created yet"
+      task :status => :environment do
+        new_db_configs = build_new_db_configs
+        perform_show_status(new_db_configs)
+      end
+
+      desc "Confirm and execute CREATE DATABASE for each new database"
+      task :execute => :environment do
+        new_db_configs = build_new_db_configs
+        next if new_db_configs.blank?
+        perform_create_databases(new_db_configs)
+      end
+    end
+
+    desc "Confirm and execute Drop DATABASE for all database"
+    task :drop => :environment do
+      all_db_configs = build_all_db_configs
+      next if all_db_configs.blank?
+      perform_drop_databases(all_db_configs)
+    end
+
+    def build_all_db_configs
+      ServerSettings::DatabaseConfig.generate_database_config(:master).each_with_object([]) do |(_, config), all_db_configs|
+        client = Mysql2::Client.new(username: config["username"], password: config["password"], host: config["host"])
+        all_db_configs << [config, client]
+      end
+    end
+
+    def perform_drop_databases(all_db_configs)
+      confirm_and_execute "Are you sure you want to execute above?" do
+        all_db_configs.each do |config, client|
+          command = "DROP DATABASE IF EXISTS #{ config['database'] }"
+          puts "Executing '#{ command }' on #{ config['host'] }"
+          client.query(command)
+        end
+      end
+    ensure
+      close_connections(all_db_configs)
+    end
+  end
+end

data/lib/server_settings/version.rb

@@ -0,0 +1,3 @@
+class ServerSettings
+  VERSION = "0.1.0"
+end

data/server_settings.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'server_settings/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "server_settings"
+  spec.version       = ServerSettings::VERSION
+  spec.authors       = ["Osamu MATSUMOTO", "Contributers"]
+  spec.email         = ["osamu.matsumoto@gmail.com"]
+  spec.summary       = %q{Server Configuration logic}
+  spec.description   = %q{Server Configuration logic for any where}
+  spec.homepage      = "https://github.com/monsterstrike/server_settings"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "colorize"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/spec/lib/server_settings/database_config_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'server_settings'
+
+describe "ServerSettings::DatabaseConfig" do
+  let (:config1) do
+          yaml_text = <<-EOF
+---
+databases: &default
+  :adapter: mysql2
+  :encoding: utf8
+  :reconnect: true
+  :database: server_settings
+  :pool: 5
+  :username: monsterstrike
+  :password: monsterstrike
+  :master: localhost
+  user:
+    <<: *default
+    :database: server_settings_user
+  has_slave:
+    <<: *default
+    :database: server_settings_has_slave
+    :slaves: [ localhost ]
+  archive:
+    archive_me:
+      <<: *default
+  has_backup:
+    <<: *default
+    :backup: 'backup.com'
+  no_backup:
+    <<: *default
+EOF
+  end
+  before do
+    filepath = "config.yml"
+    allow(IO).to receive(:read).with(filepath).and_return(config1)
+    allow(File).to receive(:mtime).with(filepath).and_return(Time.now)
+    ServerSettings.load_config("config.yml")
+  end
+  after do
+    ServerSettings.destroy
+  end
+  describe ".slave_name" do
+    it { expect(ServerSettings::DatabaseConfig.slave_name("hoge", 1)).to eq "hoge_slave1" }
+  end
+  describe ".generate_database_config" do
+    context "check configuration" do
+      let(:database_config) { database_config = ServerSettings::DatabaseConfig.generate_database_config(:master) }
+      it "contain `user` key" do
+        expect(database_config["user"].class).to eq Hash
+      end
+      context "when has slave" do
+        it "contain slave key" do
+          expect(database_config["has_slave_slave1"].class).to eq Hash
+        end
+      end
+      context "when has group" do
+        it "create nest configuration" do
+          expect(database_config["archive"]["archive_me"].class).to eq Hash
+        end
+      end
+      context "when no slaves options" do
+        it "does not exist slave key" do
+          no_slave_config = ServerSettings::DatabaseConfig.generate_database_config(:master, with_slave: false)
+          expect(no_slave_config.has_key? "has_slave_slave1").to be false
+        end
+      end
+      context "when use backup role" do
+        let(:backup_config) { ServerSettings::DatabaseConfig.generate_database_config :backup }
+        it "change host to backup" do
+          expect(backup_config["has_backup"][:host]).to eq "backup.com"
+        end
+        it "does not set key, when not set backup" do
+          expect(backup_config.has_key? "no_backup").to eq false
+        end
+      end
+    end
+    context "when use rails" do
+      before do
+        module Rails
+          def self.env
+          end
+        end
+        allow(Rails).to receive(:env).and_return("test")
+      end
+      it "contain environment key" do
+        database_config = ServerSettings::DatabaseConfig.generate_database_config(:master)
+        expect(database_config["test"]).not_to eq nil
+      end
+      it "returns configs with string keys" do
+        database_config = ServerSettings::DatabaseConfig.generate_database_config(:master)
+        expect(database_config["user"].keys.all? { |k| k.is_a? String }).to be true
+        expect(database_config["has_slave_slave1"].keys.all? { |k| k.is_a? String }).to be true
+      end
+    end
+  end
+end