rails-infrastructure 0.1.0

data/lib/infrastructure/constants.rb

@@ -0,0 +1,5 @@
+class Infrastructure
+
+  VERSION = '0.1.0'
+
+end

data/lib/infrastructure/databases.rb

@@ -0,0 +1,117 @@
+class Infrastructure
+  class Databases
+
+    include Configurable
+
+    attr_reader :orm, :environment
+    attr_reader :global_defaults, :system
+
+    def initialize(orm, environment)
+      @orm = orm
+      @environment = environment.to_sym
+      @global_defaults = {}
+      @environment_defaults = {}
+      @system = {}
+      callback :after_configure, -> { merge_defaults }
+      callback :after_assignment, -> (key, value) { merge_defaults }
+    end
+
+    def merge_defaults
+      @global_defaults = @global_defaults.merge(configuration.fetch(:defaults) || {})
+      configuration.delete :defaults
+      @system = @system.merge(configuration.fetch(:system) || {}).merge @global_defaults
+      configuration.delete :system
+      configuration.each do |environment, configs|
+        @environment_defaults[environment] ||= Hash.new
+        @environment_defaults[environment] = @environment_defaults[environment].merge(configs.fetch(:defaults) || {})
+        configs.delete :defaults
+        configs.each do |id, config|
+          config.assign :database, "#{environment}_#{id}" unless config.fetch :database
+          config.assign :id, id.to_s unless config.fetch(:id) == id.to_s
+          @environment_defaults[environment].each { |k,v| config.assign k, v unless config.fetch k }
+          @global_defaults.each { |k,v| config.assign k, v unless config.fetch k }
+        end
+      end
+    end
+
+    def available?(id)
+      available.include? database(id)
+    end
+
+    def available
+      connection.execute("SELECT datname FROM pg_database").map { |result| result['datname'] }
+    end
+
+    def connection
+      orm.connection
+    end
+
+    def tables
+      connection.tables
+    end
+
+    def environment_configs(environment = environment)
+      fetch(environment) || raise(ArgumentError, "database configurations for environment #{environment} are not configured")
+    end
+    alias_method :configs, :environment_configs
+
+    def environment_database(id)
+      config(id)[:database]
+    end
+    alias_method :database, :environment_database
+
+    def environment_defaults(environment = environment)
+      @environment_defaults[environment] ||= Hash.new
+    end
+    alias_method :defaults, :environment_defaults
+
+    def environment_config(id)
+      if id.is_a?(String) || id.is_a?(Symbol)
+        id = id.to_sym
+        if config = configs.fetch(id)
+          return config.to_h 
+        end
+        if id.to_s == defaults[:id]
+          if config = configs.fetch(defaults[:id])
+            return config.to_h
+          else
+            raise ArgumentError, "default database #{defaults[:id]} in environment #{environment} is not configured"
+          end
+        end
+        return system if id == :system
+      elsif id.is_a? Hash
+        return id
+      end
+      raise ArgumentError, "database configuration for #{id} in environment #{environment} is not configured"
+    end
+    alias_method :config, :environment_config
+
+    def drop(id)
+      connection.drop_database database(id)
+    end
+
+    def create(id)
+      connection.create_database database(id)
+    end
+
+    def connect(id)
+      orm.establish_connection config(id)
+    end
+
+    def connect!(id)
+      begin
+        connect id
+      rescue StandardError
+        connect system
+        create id
+        connect id
+      end
+    end
+
+    def databases(environment = environment)
+      configs(environment).map { |id, configs| configs[:database] }.compact.uniq.sort
+    end
+
+  end
+end
+

data/lib/infrastructure/environment.rb

@@ -0,0 +1,16 @@
+class Infrastructure
+  class Environment
+
+    include Configurable
+
+    %w( production development test ).each do |environment|
+      define_method "#{environment}?", -> { to_s == environment }
+    end
+
+    def to_s
+      configuration.fetch(:environment).to_s
+    end
+
+  end
+end
+

data/lib/infrastructure/path.rb

@@ -0,0 +1,7 @@
+class Infrastructure
+  class Path
+
+    include Configurable
+
+  end
+end

data/lib/infrastructure/railtie.rb

@@ -0,0 +1,68 @@
+unless defined? ::Inf
+  ::Inf = Infrastructure.new
+end
+
+class Infrastructure
+  class Railtie < Rails::Railtie
+
+    config.before_configuration do |app|
+
+      Inf.build :path, Path
+      Inf.path.assign :rails, Hash.new
+      Inf.path.rails.configure do
+        assign :root, Dir.pwd
+        Dir.glob("#{root}/*").select { |f| File.directory? f }.each do |dir|
+          dir = File.basename(dir)
+          assign "#{dir}_dir", root + "/#{dir}"
+          Dir.glob("#{root}/#{dir}/*").select { |f| File.directory? f }.each do |sub_dir|
+            sub_dir = File.basename(sub_dir)
+            assign "#{dir}_#{sub_dir}_dir", root + "/#{dir}/#{sub_dir}"
+          end
+        end
+        Dir.glob("#{root}/config/infrastructure/*").select { |f| File.directory? f }.each do |dir|
+          dir = File.basename(dir)
+          assign "infrastructure_#{dir}_dir", root + "/config/infrastructure/#{dir}"
+        end
+      end
+
+      Inf.load_config_if_exists Inf.path.rails.config_dir + '/infrastructure.yml'
+      Inf.load_config_if_exists Inf.path.rails.config_dir + '/infrastructure.yml.erb'
+
+      Inf.build :environment, Environment
+      Inf.environment.load_config_if_exists Inf.path.rails.config_infrastructure_dir + '/environment.yml' do
+        ENV['RAILS_ENV'] = Inf.environment.to_s
+        Rails.env = Inf.environment.to_s
+        rake_tasks { load 'tasks/environment.rake' }
+      end
+
+      Inf.build :version, Version
+      Inf.version.load_config_if_exists Inf.path.rails.config_infrastructure_dir + '/version.yml' do
+        rake_tasks { load 'tasks/version.rake' }
+      end
+      
+      Inf.build :server, Server
+      Inf.server.load_config_if_exists Inf.path.rails.config_infrastructure_dir + '/server.yml' do
+        rake_tasks { load 'tasks/server.rake' }
+        Inf.server.servers.each do |server|
+          Inf.server.assign server, Hash.new
+          Inf.server.fetch(server).assign Inf.server.fetch(:defaults).to_h
+          %w( .yml .yml.erb ).each do |extension|
+            Inf.server.fetch(server).load_config_if_exists Inf.path.rails.infrastructure_servers_dir + "/#{server}" + extension
+          end
+        end
+      end
+
+    end
+
+    config.before_initialize do
+      Inf.build :databases, Databases, ActiveRecord::Base, Rails.env
+      Inf.databases.load_config_if_exists Inf.path.rails.config_infrastructure_dir + '/databases.yml' do
+        ENV['DATABASE_URL'] = Inf.databases.environment_defaults[:id]
+        Rails::Application::Configuration.send(:define_method, :database_configuration) { Inf.databases.environment_configs }
+        ActiveRecord::Migration.verbose = false
+        rake_tasks { load 'tasks/databases.rake' }
+      end
+    end
+
+  end
+end

data/lib/infrastructure/server.rb

@@ -0,0 +1,7 @@
+class Infrastructure
+  class Server
+
+    include Configurable
+
+  end
+end

data/lib/infrastructure/version.rb

@@ -0,0 +1,23 @@
+class Infrastructure
+
+  class Version
+
+    include Configurable
+
+    def update_version(i, value = nil)
+      array_version = configuration.version.split('.')
+      array_version[i] = value || (array_version[i] || 0).to_i + 1
+      assign :version, array_version.join('.')
+    end
+
+    %w( major minor tiny ).each_with_index do |version, index|
+      define_method "bump_#{version}", -> { update_version index  }
+    end
+
+    def to_s
+      version.to_s
+    end
+
+  end
+end
+

data/lib/infrastructure.rb

@@ -0,0 +1,25 @@
+require 'forwardable'
+require 'erb'
+require 'yaml'
+
+require 'colored'
+
+require 'infrastructure/constants'
+require 'infrastructure/configurable'
+require 'infrastructure/configuration'
+require 'infrastructure/environment'
+require 'infrastructure/version'
+require 'infrastructure/path'
+require 'infrastructure/databases'
+require 'infrastructure/server'
+
+class Infrastructure
+
+  include Configurable
+
+  def build(key, model, *params)
+    model = model.constantize if model.is_a? String
+    assign key, model.new(*params)
+  end
+
+end

data/lib/rails-infrastructure.rb

@@ -0,0 +1,2 @@
+require 'infrastructure' 
+require 'infrastructure/railtie' if defined? Rails

data/lib/tasks/databases.rake

@@ -0,0 +1,148 @@
+def forced?(params = {})
+  @forced = true if params[:force] == 'force'
+  @forced == true
+end
+
+def exit_if_production(params = {})
+  if Rails.env.production? && ! forced?(params)
+    puts 'This task must be forced in production environment ('.yellow + 'rake <task>[force]'.red + ')'.yellow
+    exit!
+  end
+end
+
+module Rake
+  class Task
+    def self.reinvoke(*params, &block)
+      invoke(*params, &block)
+      reenable()
+    end
+  end
+end
+
+namespace :database do
+
+  desc "Create database if it does not exist"
+  task :create, :id do |name, params|
+    puts 'Creating: ' + params[:id].to_s.green
+    Inf.databases.connect :super
+    Inf.databases.create params[:id] if ! Inf.databases.available? params[:id]
+  end
+
+  desc "Drop database if exists"
+  task :drop, :id, :force do |name, params|
+    exit_if_production params
+    puts 'Dropping: ' + params[:id].to_s.green
+    Inf.databases.connect :super
+    Inf.databases.drop params[:id] if Inf.databases.available? params[:id]
+  end
+
+  desc "Migrate database"
+  task :migrate, :id, :version do |name, params|
+    puts 'Migrating: ' + params[:id].to_s.green
+    Inf.databases.connect params[:id]
+    ActiveRecord::Base.logger.level = Logger::INFO
+    current_version = ActiveRecord::Migrator.current_version
+    target_version = (params[:version] || ActiveRecord::Migrator.last_version).to_i
+    ActiveRecord::Migrator.migrate ActiveRecord::Migrator.migrations_paths, target_version
+    ActiveRecord::Migrator.migrations(ActiveRecord::Migrator.migrations_paths).each do |migration|
+      if target_version < current_version
+        puts "Rollbacked: - #{migration.version} - #{migration.name.green} - #{migration.filename}" if migration.version >= target_version && migration.version < current_version
+      else
+        puts "Migrated: - #{migration.version} - #{migration.name.green} - #{migration.filename}" if migration.version > current_version && migration.version <= target_version
+      end
+    end
+  end
+
+  desc "Rollback database"
+  task :rollback, :id, :version do |name, params|
+    puts 'Rollbacking: ' + params[:id].to_s.green
+    Inf.databases.connect params[:id]
+    ActiveRecord::Base.logger.level = Logger::INFO
+    current_version = ActiveRecord::Migrator.current_version
+    all_versions = ActiveRecord::Migrator.get_all_versions
+    previous_index = all_versions.index(current_version) - 1
+    previous_index = 0 if previous_index < 0
+    previous_version = all_versions[previous_index]
+    target_version = (params[:version] || previous_version).to_i
+    ActiveRecord::Migrator.migrate ActiveRecord::Migrator.migrations_paths, target_version
+    ActiveRecord::Migrator.migrations(ActiveRecord::Migrator.migrations_paths).each do |migration|
+      if target_version < current_version
+        puts "Rollbacked: - #{migration.version} - #{migration.name.green} - #{migration.filename}" if migration.version >= target_version && migration.version < current_version
+      else
+        puts "Migrated: - #{migration.version} - #{migration.name.green} - #{migration.filename}" if migration.version > current_version && migration.version <= target_version
+      end
+    end
+  end
+
+  desc "Seed database"
+  task :seed, :id do |name, params|
+    exit_if_production params
+    puts 'Seeding: ' + params[:id].to_s.green
+    Inf.databases.connect params[:id]
+    Rake::Task['database:migrate'].reinvoke params[:id]
+    load Inf.path.rails.db_dir + 'seeds.rb'
+  end
+
+  desc "Drop, create, then migrate database"
+  task :reset, :id, :force do |name, params|
+    exit_if_production params
+    Rake::Task['database:drop'].reinvoke params[:id]
+    Rake::Task['database:create'].reinvoke params[:id]
+    Rake::Task['database:migrate'].reinvoke params[:id]
+  end
+
+  namespace :reset do
+    desc "Reset then seed database"
+    task :seed, :force do |name, params|
+      exit_if_production params
+      Rake::Task['databases:reset'].reinvoke params[:id], params
+      Rake::Task['databases:seed'].reinvoke params[:id]
+    end
+  end
+
+end
+
+namespace :databases do
+
+  desc "Create all databases that dont exist"
+  task :create do
+    Inf.databases.configs.each { |id, config| Rake::Task['database:create'].reinvoke id }
+  end
+
+  desc "Drop all databases that exist"
+  task :drop, :force do |name, params|
+    exit_if_production params
+    Inf.databases.configs.each { |id, config| Rake::Task['database:drop'].reinvoke id }
+  end
+
+  desc "Migrate all databases"
+  task :migrate, :version do |name, params|
+    Inf.databases.configs.each { |id, config| Rake::Task['database:migrate'].reinvoke id, params[:version] }
+  end
+
+  desc "Rollback all databases"
+  task :rollback, :version do |name, params|
+    Inf.databases.configs.each { |id, config| Rake::Task['database:rollback'].reinvoke id }
+  end
+  
+  desc "Drop, create, migrate all databases"
+  task :reset, :force do |name, params|
+    exit_if_production params
+    Inf.databases.configs.each { |id, config| Rake::Task['database:reset'].reinvoke id }
+  end
+
+  desc "Seed all databases"
+  task :seed, :force do |name, params|
+    exit_if_production params
+    Inf.databases.configs.each { |id, config| Rake::Task['database:seed'].reinvoke id }
+  end
+
+  namespace :reset do
+    desc "Reset then seed all databases"
+    task :seed, :force do |name, params|
+      exit_if_production params
+      Inf.databases.configs.each { |id, config| Rake::Task['database:seed'].reinvoke id, params[:force] }
+    end
+  end
+
+end

data/lib/tasks/environment.rake

@@ -0,0 +1,19 @@
+namespace :environment do
+
+  desc 'display current environment'
+  task :current do
+    puts 'Environment: ' + Inf.environment.to_s.green
+  end
+  
+  def set_environment_and_save(environment)
+    Inf.environment.assign :environment, environment
+    Inf.environment.configuration.save_config Inf.path.rails.config_infrastructure_dir + '/environment.yml'
+    Rake::Task['environment:current'].invoke
+  end
+
+  %w( test development production ).each do |environment|
+    desc "Change to #{environment} environment"
+    task(environment.to_sym) { set_environment_and_save environment }
+  end 
+  
+end