ridoku 0.1.0

data/lib/ridoku/log.rb

@@ -0,0 +1,77 @@
+#
+# Command: log
+#
+
+require 'ridoku/base'
+
+module Ridoku
+  register :log
+
+  class Log < Base
+    attr_accessor :environment
+    
+    def run      
+      command = Base.config[:command]
+      sub_command = (command.length > 0 && command[1]) || nil
+
+      case sub_command
+      when 'unicorn', nil
+        unicorn_log
+      when 'nginx'
+        nginx_log
+      when 'all'
+        all_logs
+      else
+        print_log_help
+      end
+    end
+
+    protected
+
+    def unicorn_log_command
+      Base.fetch_app
+
+      lines = "#{Base.config[:lines] || 250}"
+      dir = "/srv/www/#{Base.app[:shortname]}/shared/log"
+      "for f in #{dir}/*.log; do echo "\
+      "#{$stdout.colorize("Log #{lines}: $f; "\
+      "echo #{'=' * 80}", [:bold])};"\
+      "tail -#{lines} $f; echo; done"
+    end
+
+    def line_break(title)
+      "#{'=' * 80}\n==== #{title}\n#{'=' * 80}\n"
+    end
+
+    def unicorn_log
+      $stdout.puts $stdout.colorize(line_break('Unicorn Logs'), [:bold, :green])
+      system(Ridoku::Run.command(unicorn_log_command, false))
+    end
+
+    def nginx_log
+      $stdout.puts $stdout.colorize(line_break('Nginx Logs'), [:bold, :green])
+      system(Ridoku::Run.command('tail -1000 /var/log/nginx/error.log'))
+    end
+
+    def all_logs
+      nginx_log
+      unicorn_log
+    end
+
+
+    def print_log_help
+      $stderr.puts <<-EOF
+Command: log
+
+Log the specified command on an instance:
+  log[:unicorn] print unicorn logs for the specified app and instance
+  log:nginx     print nginx logs for the specified app and instance
+  log:all       print all logs for specified instance and app to commandline
+
+examples:
+  $ ridoku log --mukujara
+    
+    EOF
+    end
+  end
+end

data/lib/ridoku/maintenance.rb

@@ -0,0 +1,76 @@
+#
+# Command: maintenance
+#
+
+require 'ridoku/base'
+
+module Ridoku
+  register :maintenance
+
+  class Maintenance < Base
+    attr_accessor :app
+
+    def run
+      clist = Base.config[:command]
+      command = clist.shift
+      sub_command = clist.shift
+
+      case sub_command
+      when 'on'
+        maintenance(true)
+      when 'off'
+        maintenance(false)
+      when 'status', nil
+        status
+      else
+        print_maintenance_help
+      end
+    end
+
+    protected
+
+    def maintenance(maint)
+      Base.fetch_stack
+      Base.fetch_app
+
+      Base.custom_json['deploy'][Base.app[:shortname]]['maintenance'] = maint
+      Base.save_stack
+
+      Ridoku::Cook.cook_recipe_on_layers('deploy::maintenance', ['rails-app'],
+        deploy: {
+          Base.app[:shortname] => {
+            application_type: 'rails'
+          }
+        }
+      )
+      status
+    end
+
+    def status
+      Base.fetch_stack
+      Base.fetch_app
+
+      $stdout.print 'Maintenance: '
+
+      app_json = Base.custom_json['deploy'][Base.app[:shortname]]
+
+      if app_json.key?('maintenance')
+        maint = (app_json['maintenance'] == true)
+        $stdout.puts $stdout.colorize((maint ? 'on' : 'off'),
+          [:bold, (maint ? :red : :green)])
+      else
+        $stdout.puts $stdout.colorize('off', :green)
+      end
+    end
+
+    def print_maintenance_help
+      $stderr.puts <<-EOF
+Command: maintenance
+
+Set maintenance mode on the specific applications:
+  maintenance:on   Turn on maintenance mode for all application instances.
+  maintenance:off  Turn off maintenance mode for all application instances.
+EOF
+    end
+  end
+end

data/lib/ridoku/packages.rb

@@ -0,0 +1,93 @@
+#
+# Command: packages
+# Description: List/Modify the current apps configuration.
+#  packages - lists the key value pairs
+#  packages:add PACKAGE [...]
+#  packages:delete KEY
+#
+
+require 'ridoku/base'
+
+module Ridoku
+  register :packages
+
+  class Packages < Base
+
+    def run
+      command = Base.config[:command]
+      sub_command = (command.length > 0 && command[1]) || nil
+
+      case sub_command
+      when 'list', nil
+        list
+      when 'set', 'add'
+        set
+      when 'delete', 'remove', 'rm'
+        delete
+      else
+        print_package_help
+      end
+    end
+
+    protected
+
+    def print_package_help
+      $stderr.puts <<-EOF
+Command: packages
+
+List/Modify the current layer's package dependencies.
+   packages        lists the key value pairs
+   packages:set    PACKAGE [...]
+   packages:delete PACKAGE [...]
+
+#{$stderr.colorize('Warning:', [:bold, :red])} Currently, this is limited by Opsworks to 10 packages.
+      EOF
+    end
+
+    def list
+      Base.fetch_layer(Base.config[:layer] || 'rails-app')
+
+      if Base.layers.length == 0
+        $stdout.puts 'No Layers Selected!'
+
+      else
+        max = 0
+        Base.layers.each do |layer|
+          short = $stdout.colorize(layer[:shortname], :bold)
+          max = short.length if max < short.length
+        end
+        
+        Base.layers.each do |layer|
+          fmt = "%#{max}s"
+          shortname = sprintf(fmt, $stdout.colorize(layer[:shortname], :bold))
+          $stdout.puts "[#{shortname}] #{layer[:name]}: " +
+            "#{$stdout.colorize('No Packages Selected', :red) if
+              layer[:packages].length == 0}"
+          layer[:packages].each do |pack|
+            $stdout.puts "  #{$stdout.colorize(pack, :green)}"
+          end
+        end
+      end
+    end
+
+    def set
+      Base.fetch_layer(Base.config[:layer] || 'rails-app')
+
+      ARGV.each do |package|
+        # $stdout.puts "#{update && 'Updating' || 'Adding'}: #{key} as '#{value}'"
+      end
+
+      # Base.save_layer(layer, :packages)
+    end
+
+    def delete
+      Base.fetch_layer(Base.config[:layer] || 'rails-app')
+
+      ARGV.each do |package|
+        # $stdout.puts "Deleting key: #{key}, '#{value}'"
+      end
+      
+      # Base.save_layer(layer, :packages)
+    end
+  end
+end

data/lib/ridoku/rails_defaults.rb

@@ -0,0 +1,160 @@
+
+require 'ridoku/defaults'
+
+module Ridoku
+  class RailsDefaults < ClassProperties
+    def initialize
+      super
+
+      self.warnings = {}.tap do |warn|
+        warn[:app_source] = <<-EOA
+    The App Source is the repository which you wish to pull your application
+    from.  'Type' should be 'git','subversion', etc.  'Url' should be the
+    'git@github:user/repo' url (or appropriate repository URL).  'SSH Key'
+    should be a Private key associated with the repository you pull from.
+EOA
+
+        warn[:domains] = <<-EOB
+    Domains this server should respond to (used for the HTTP server config).
+    Separate each domain with a ':' or '|'.
+EOB
+      end
+
+      self.required = {
+        stack: {
+          service_role_arn: :string,
+          default_instance_profile_arn: :string,
+          # attributes: Color: ?,
+          custom_cookbooks_source: { ssh_key: :optional }
+        },
+        layer: {
+          loadbalance: {
+            attributes: { 
+              haproxy_stats_password: :string,
+              haproxy_stats_user: :string
+            }
+          },
+          application: {},
+          database: {}
+        },
+        app: {
+          name: :string,
+          shortname: :string,
+          type: :string,
+          app_source: {
+            type: :string,
+            url: :string,
+            ssh_key: :optional
+          },
+          domains: :array,
+          attributes: {
+            rails_env: :string
+          }
+        }
+      }
+
+      self.default = {
+        stack: {
+          name: 'Ridoku-Rails',
+          region: 'us-west-1',
+          default_os: 'Ubuntu 12.04 LTS',
+          hostname_theme: 'Legendary_creatures_from_Japan',
+          default_availability_zone: 'us-west-1a',
+          custom_json: '',
+          configuration_manager: {
+            name: 'Chef',
+            version: '11.4'
+          },
+          use_custom_cookbooks:true,
+          custom_cookbooks_source: {
+            type: 'git',
+            url: 'git@github.com:zv1n/ridoku-cookbooks.git',
+            revision: 'stable'
+          },
+          default_root_device_type: 'instance-store'
+        },
+
+        layer: [
+          loadbalance: {
+            standard: true,
+            updates: true,
+            type:'lb',
+            attributes: {
+              enable_haproxy_stats: 'true',
+              haproxy_health_check_method: 'OPTIONS',
+              haproxy_health_check_url: '/',
+              haproxy_stats_url: '/haproxy?stats',
+            },
+            auto_assign_elastic_ips: true,
+            auto_assign_public_ips: true
+          },
+          application: {
+            standard: true,
+            updates: true,
+            type:'rails-app',
+            attributes: {
+              bundler_version: '1.3.5',
+              manage_bundler: 'true',
+              rails_stack: 'nginx_unicorn',
+              ruby_version:'1.9.3',
+              rubygems_version:'2.1.5'
+            },
+            packages: [
+              'imagemagick',
+              'libmagickwand-dev',
+              'nodejs',
+              'postgresql-common',
+              'libpgsql-ruby'
+            ],
+            auto_assign_elastic_ips: false,
+            auto_assign_public_ips: true,
+            custom_recipes:{
+              configure: ['postgresql::ruby']
+            }
+          },
+          database: {
+            type: 'custom',
+            name: 'Ridoku-Postgres',
+            shortname: 'ridoku-postgres',
+            attributes: {
+            },
+            auto_assign_elastic_ips: true,
+            auto_assign_public_ips: true,
+            custom_security_group_ids: ['Ridoku-PostgreSQL-Server'],
+            custom_recipes:{
+              setup: ['postgresql::ec2_server'],
+              configure: [],
+              deploy: [],
+              undeploy: [],
+              shutdown: []
+            },
+            instance: {
+              root_device_type: 'ebs-backed'
+            }
+          }
+        ],
+
+        app: {
+          app_source: {
+            type: 'git',
+            revision: 'master'
+          },
+          enable_ssl: false,
+          attributes:{
+            auto_bundle_on_deploy: true,
+            document_root: 'public'
+          },
+        },
+
+        instance: {
+          instance_type: 'm1.small',
+          os: 'Ubuntu 12.04 LTS',
+          availability_zone: 'us-west-1a',
+          architecture: 'x86_64',
+          root_device_type: 'instance-store',
+          install_updates_on_boot: true
+        }
+      }
+    end
+  end
+end

data/lib/ridoku/run.rb

@@ -0,0 +1,137 @@
+#
+# Command: run
+#
+
+require 'ridoku/base'
+
+module Ridoku
+  register :run
+
+  class Run < Base
+    attr_accessor :environment
+    
+    def run      
+      command = Base.config[:command]
+      sub_command = (command.length > 0 && command[1]) || nil
+
+      case sub_command
+      when 'command', nil
+        run_command
+      when 'shell'
+        shell
+      else
+        print_run_help
+      end
+    end
+
+    protected
+
+    class << self
+      def create_ssh_path(instance = nil)
+        Base.fetch_instance
+        Base.fetch_account
+
+        instance ||= Base.select_instances(Base.config[:instances]).first
+
+        unless instance
+          $stderr.puts 'Unable to find a valid instance.'
+          print_run_help
+          exit 1
+        end
+
+        username = Base.account[:user][:user_name].gsub(/[.]/, '')
+        "#{username}@#{instance[:elastic_ip] || instance[:public_ip]}"
+      end
+
+      def command(command = nil, relative_command = true)
+        Base.fetch_app
+        Base.fetch_permissions
+        
+        Base.fetch_stack
+        
+        # stupid fucking escaping bullshit
+        # So, ruby escapes, so does bash, so does ssh
+        # (all interpreter layers)
+        # Sooo, we have to have an OMFG ridiculous number of backslashes...
+        # to escape one mother fucking value.
+
+        # TODO: The entire 'run' system is fucked.  Rethink it.
+        command.gsub!(/\$/, '\\'*14 + '$') if command
+
+        environment =
+          Base.custom_json['deploy'][Base.app[:shortname]]['app_env']
+
+        fail Ridoku::NoSshAccess.new unless
+          Base.permissions[:permissions].first[:allow_ssh]
+        
+        if Base.permissions[:permissions].first[:allow_sudo]
+          prefix = "sudo su #{Base.config[:shell_user] || 'root'} -c "
+        else
+          prefix = ''
+        end
+
+        environ = environment.map do |key, val|
+          "#{key}='#{val}'"
+        end.join(' ')
+
+        dir = "/srv/www/#{Base.app[:shortname]}/current"
+        chdir = "cd #{dir}"
+        path = "PATH=/usr/local/bin:#{dir}/script/:${PATH}"
+        network_path = create_ssh_path
+
+        relative = relative_command ? '/usr/bin/env' : ''
+
+        bash_command = (command && "-c \\\\\\\"#{chdir} && #{relative} #{command}\\\\\\\"") || ''
+
+        ssh_command = [
+          "-t #{network_path}",
+          %Q("#{prefix} \\"#{environ} #{path} bash #{bash_command}\\"")
+        ]
+
+        ssh_command.unshift("-i #{Base.config[:ssh_key]}") if
+          Base.config[:ssh_key]
+
+        ssh_command.unshift("/usr/bin/env ssh").join(' ')
+      end
+    end
+
+    def shell
+      command = Ridoku::Run.command
+
+      Base.if_debug? do
+        $stdout.puts 'Running shell with command:'
+        $stdout.puts command
+      end
+
+      exec command
+    end
+
+    def run_command
+      command = Ridoku::Run.command(ARGV.join(' '))
+
+      Base.if_debug? do
+        $stdout.puts 'Running command:'
+        $stdout.puts command
+      end
+
+      exec command
+    end
+
+    def print_run_help
+      $stderr.puts <<-EOF
+  Command: run
+
+  Run the specified command on an instance:
+    run[:command] run a command (over ssh) in the release directory
+    run:shell     ssh to the specified instance
+      --instance  specify the instance (max: 1)
+      --user      ssh as user (default: root; optionally: <AWS Username>,
+                    or deploy)
+
+  examples:
+    $ run:shell
+    mukujara$
+    EOF
+    end
+  end
+end