rails-infrastructure 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae39560352b96bff043a01081b3f177ef773939a
+  data.tar.gz: c047a2e92b7238608c753f7854bac01fcba115e6
+SHA512:
+  metadata.gz: 78f4f9ee3fedc2482bc7ac0f5aca68d8896c75785b837a3187559681cffdbb1d9b27c7d2ffe6e0e4c4f8a45b12448e942fdccc9455fd708992d05955909bf85b
+  data.tar.gz: c3f63bece8638110c4045238aef75ec528fb710c113b9d7c3bd0f5f325023e8e2b9711084193122fe75fb17f7e943a9948aeacf2b7b590e36417221e52c53d9a

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-gemset

@@ -0,0 +1 @@
+infrastructure

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p247

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-infrastructure.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Griffith Chaffee
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,80 @@
+= Rails::Infrastructure
+
+This gem provides several much needed enhancements to the rails framework
+
+1. Multi database support and management
+2. Environment management 
+3. Version managment
+4. Path managment
+5. Server management
+6. Useful configuration module mixin
+7. Rails configuration constant
+
+= Getting Started
+
+    # Gemfile
+    gem 'rails-infrastructure'
+
+Copy examples into config directory
+
+    # example layout
+    config/infrastructure.yml
+    config/infrastructure/version.yml
+    config/infrastructure/environment.yml
+    config/infrastructure/server.yml
+    config/infrastructure/servers/unicorn.yml.erb
+    ...
+
+== Muli Database Support
+
+    Infrastructure::Databases
+
+This class provides all the required functions for connecting and working with multiple databases through ActiveRecord. There several rake tasks preconfigured to replace their rails countarparts.
+
+    rake database:create[id]            # Create database if it does not exist
+    rake database:drop[id,force]        # Drop database if exists
+    rake database:migrate[id,version]   # Migrate database
+    rake database:reset[id,force]       # Drop, create, then migrate database
+    rake database:reset:seed[force]     # Reset then seed database
+    rake database:rollback[id,version]  # Rollback database
+    rake database:seed[id]              # Seed database
+    rake databases:create               # Create all databases that dont exist
+    rake databases:drop[force]          # Drop all databases that exist
+    rake databases:migrate[version]     # Migrate all databases
+    rake databases:reset[force]         # Drop, create, migrate all databases
+    rake databases:reset:seed[force]    # Reset then seed all databases
+    rake databases:rollback[version]    # Rollback all databases
+    rake databases:seed[force]          # Seed all databases
+
+== Environment Management
+
+    Infrastructure::Environment
+
+    rake environment:current            # display current environment
+    rake environment:development        # Change to development environment
+    rake environment:production         # Change to production environment
+    rake environment:test               # Change to test environment
+
+== Version Management
+
+    Infrastructure::Version
+
+    rake version:bump:major             # Bump major version
+    rake version:bump:minor             # Bump minor version
+    rake version:bump:tiny              # Bump tiny version
+    rake version:current                # display current version
+
+== Server Management
+
+    Infrastructure::Server
+
+    rake server:unicorn:kill            # Kill unicorn server
+    rake server:unicorn:restart         # Restart unicorn server
+    rake server:unicorn:start           # Start unicorn server
+    rake server:unicorn:stop            # Stop unicorn server
+    rake server:unicorn:tail            # Tail unicorn server log file
+
+== Path Management
+
+    Infrastructure::Path
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end

data/examples/infrastructure/databases.yml

@@ -0,0 +1,29 @@
+---
+system:
+  database: postgres
+
+defaults:
+  adapter: postgresql
+  encoding: unicode
+  username: root
+  password: toor
+  pool: 5
+  host: localhost
+
+test: 
+  defaults:
+    id: test
+  test: {}
+
+development:
+  defaults:
+    id: dev1
+  dev1: {}
+  dev2: {}
+
+production:
+  defaults:
+    id: demo
+  demo: {}
+  best: {}
+  other: {}

data/examples/infrastructure/environment.yml

@@ -0,0 +1,2 @@
+---
+environment: development

data/examples/infrastructure/server.yml

@@ -0,0 +1,9 @@
+---
+defaults:
+  daemonize: true
+  port: 8080
+  interface: 0.0.0.0
+  kill_signal: TERM
+
+servers:
+- unicorn

data/examples/infrastructure/servers/unicorn.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../../../application', __FILE__)
+
+config = Inf.server.unicorn
+
+# workers
+worker_processes config.workers
+ 
+# worker response timeout
+timeout config.timeout
+ 
+# iisten on interface
+listen "#{config.interface}:#{config.port}", backlog: config.backlog
+# listen on socket
+listen config.socket_file, backlog: config.backlog
+# pid file
+pid config.pid_file
+
+# logs
+stderr_path = config.log_file
+stdout_path = config.log_file
+logger = Logger.new config.log_file
+logger logger
+
+# general
+check_client_connection false
+preload_app true
+
+if GC.respond_to?(:copy_on_write_friendly=)
+  GC.copy_on_write_friendly = true
+end
+
+before_fork do |server, worker|
+  ActiveRecord::Base.connection.disconnect!
+  old_pid_file = config.pid_file + '.oldbin'
+  if File.exists? old_pid_file
+    begin
+      Process.kill 'QUIT', File.read(old_pid_file).strip.to_i
+    rescue Errno::ENOENT, Errno::ESRCH
+    end
+  end
+end
+ 
+after_fork do |server, worker|
+  ActiveRecord::Base.establish_connection
+  begin
+    uid, gid = Process.euid, Process.egid
+    user config.user, config.group
+    target_uid = Etc.getpwnam(config.user).uid
+    target_gid = Etc.getgrnam(config.group).gid
+    worker.tmp.chown target_uid, target_gid
+    if uid != target_uid || gid != target_gid
+      Process.initgroups config.user, target_gid
+      Process::GID.change_privilege target_gid
+      Process::UID.change_privilege target_uid
+    end
+  rescue ArgumentError => error
+    if error.message.include? "can't find user"
+      unless Rails.env.production?
+        logger.info { "Could not change to user/group #{config.user}:#{config.group} but ignoring because environment is not production" }
+      else
+        logger.fatal { "Could not change to user/group #{config.user}:#{config.group}" }
+        Process.kill 'QUIT', server.pid.to_i
+      end
+    else
+      logger.fatal { "#{error.class}: #{error.message}\n" + error.backtrace.join("\n") }
+      Process.kill 'QUIT', server.pid.to_i
+    end
+  end
+end

data/examples/infrastructure/servers/unicorn.yml.erb

@@ -0,0 +1,13 @@
+---
+config_file: <%= Inf.path.rails.infrastructure_servers_dir + '/unicorn.rb' %>
+socket_file: <%= Inf.path.rails.tmp_sockets_dir + '/unicorn.sock' %>
+pid_file: <%= Inf.path.rails.tmp_pids_dir + '/unicorn.pid' %>
+log_file: <%= Inf.path.rails.log_dir + "/unicorn.#{Inf.environment.to_s}.log" %>
+workers: <%= Inf.environment.production? ? 16 : 4 %>
+user: unicorn
+group: unicorn
+timeout: 15
+backlog: 1024
+stop: kill
+stop_signal: QUIT
+start: unicorn_rails -c <%= Inf.path.rails.infrastructure_servers_dir + '/unicorn.rb' %> -D

data/examples/infrastructure/version.yml

@@ -0,0 +1,2 @@
+---
+version: 2.1.3

data/examples/infrastructure.yml

@@ -0,0 +1,11 @@
+---
+domain: my-domain.com
+fruits:
+- Apple
+- Blueberry
+- Grape
+regex:
+  key: /\A[a-z0-9][a-z0-9_]+[a-z0-9]\z/
+validation:
+  format:
+    message: is not in the correct format

data/lib/infrastructure/configurable.rb

@@ -0,0 +1,51 @@
+class Infrastructure
+  module Configurable
+
+    def self.included(base)
+      base.extend Forwardable
+      base.send :def_delegators, :configuration, :assign, :fetch, :configure, :each
+      base.send :def_delegators, :configuration, :load_config, :load_config_if_exists, :save_config
+    end
+
+    def configuration
+      @configuration ||= Configuration.new self
+    end
+    
+    def callback(key, *params, &block)
+      callbacks[key] << block if block
+      callbacks[key] += Array(params)
+    end
+
+    def callbacks
+      @callbacks ||= { 
+        before_configure: [],
+        after_configure: [],
+        before_assignment: [ 
+          -> (key, value) { configuration_accessor key unless respond_to? key }
+        ],
+        after_assignment: []
+      }
+    end
+
+    def configuration_accessor(key)
+      self.class.send(:define_method, key) { configuration.send(key) }
+    end
+
+    def before_assignment(*params)
+      callbacks[:before_assignment].each { |block| block.call *params }
+    end
+
+    def after_assignment(*params)
+      callbacks[:after_assignment].each { |block| block.call *params }
+    end
+
+    def before_configure(*params)
+      callbacks[:before_configure].each { |block| block.call *params }
+    end
+
+    def after_configure(*params)
+      callbacks[:after_configure].each { |block| block.call *params }
+    end
+
+  end
+end

data/lib/infrastructure/configuration.rb

@@ -0,0 +1,93 @@
+class Infrastructure
+  class Configuration
+    attr_reader :attributes
+
+    def initialize(base, config = {})
+      @base = base
+      @attributes = Hash.new
+      assign config
+    end
+
+    def configure(&block)
+      raise "configure expects a block" unless block
+      before_configure
+      instance_eval &block
+      after_configure
+    end
+
+    def config
+      self
+    end
+
+    def load_config_if_exists(path_to_config_file, &block)
+      if File.exists? path_to_config_file
+       load_config path_to_config_file, &block
+      end
+    end
+
+    def load_config(path_to_config_file, &block)
+      assign YAML.load(ERB.new(File.read(path_to_config_file)).result)
+      block.call if block
+    end
+
+    def save_config(path_to_config_file)
+      File.open(path_to_config_file, 'w') do |file| 
+        file.write to_h(stringify_keys: true).to_yaml
+      end
+    end
+
+    def to_h(params = {})
+      attributes = @attributes.dup
+      if params[:stringify_keys]
+        attributes.keys.each { |key| attributes[key.to_s] = attributes.delete(key) unless key.is_a?(String) }
+        attributes.each { |key, value| attributes[key] = value.to_h(params) if value.is_a? Configuration }
+      else
+        attributes.each { |key, value| attributes[key] = value.to_h(params) if value.is_a? Configuration }
+      end
+    end
+
+    def fetch(key)
+      @attributes[key.to_sym]
+    end
+
+    def before_configure(*params)
+      @base.before_configure *params
+    end
+
+    def after_configure(*params)
+      @base.after_configure *params
+    end
+
+    def before_assignment(*params)
+      @base.before_assignment *params
+    end
+
+    def after_assignment(*params)
+      @base.after_assignment *params
+    end
+
+    def assign(key, value = nil)
+      if key.is_a?(Hash)
+        key.each { |k,v| assign k, v }
+      else
+        key = key.to_sym
+        before_assignment key, value
+        @attributes[key] = value.is_a?(Hash) ? Configuration.new(self, value) : value
+        after_assignment key, value
+      end
+    end
+
+    def method_missing(method, *params, &block)
+      if @attributes.keys.include? method
+        fetch method
+      elsif method.to_s.end_with? '='
+        assign method.to_s[0..-2], params.first
+      elsif @attributes.respond_to? method
+        @attributes.send method, *params, &block
+      else
+        super
+      end
+    end
+
+  end
+end