dreadpiratepj-poolparty 0.0.8

data/config/haproxy.conf

@@ -0,0 +1,29 @@
+global
+  daemon
+  maxconn       4096      # total max connections (dependent on ulimit)
+  nbproc        1         # number of processing cores
+  user          haproxy
+  chroot        /var/run/haproxy  
+  log 127.0.0.1 local0 debug
+  pidfile /var/run/haproxy.pid
+ 
+defaults
+  mode              http
+  log               global # Log to the global log
+  clitimeout 150000
+  srvtimeout 150000
+  contimeout 30000
+ 
+  option            httplog
+  option            httpclose     # disable keepalive (HAProxy does not yet support the HTTP keep-alive mode)
+  option            forwardfor    # enable insert of X-Forwarded-For headers
+  retries 3  
+  
+  balance roundrobin            # each server is used in turns, according to assigned weight
+  
+  
+  stats uri /haproxy
+  stats realm Statistics\ for\ PoolParty
+
+listen web_proxy 0.0.0.0::host_port
+  :servers

data/config/heartbeat.conf

@@ -0,0 +1,8 @@
+keepalive 2 # Time inbetween heartbeats
+deadtime 32 # wait 32 seconds before declaring dead
+warntime 16 # issue a warning halfway through
+initdead 60 # Don't boot instances between 60 seconds of each other
+auto_failback on
+use_logd yes
+
+:nodes

data/config/heartbeat_authkeys.conf

@@ -0,0 +1,2 @@
+auth 1
+1 md5 PasswordForPoolPartyClusterApplicationButItIsOnlyADefault

data/config/installers/ubuntu_install.sh

@@ -0,0 +1,77 @@
+#!/bin/sh
+
+apt-get clean && apt-get update
+
+echo 'increasing the memory for apt'
+echo 'APT::Cache-Limit "516777216";' >> /etc/apt/apt.conf.d/70debconf
+
+echo 'running ubuntu_install.sh'
+rm -rf /usr/local/src/*
+
+echo 'updating apt'
+apt-get update
+# Get the essentials
+echo 'building essentials'
+apt-get -y install build-essential
+
+echo 'Installing git'
+apt-get -y install git-core rsync
+
+# Install ruby
+echo 'Installing ruby...'
+apt-get -y install ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8
+ln -sf /usr/bin/ruby1.8 /usr/local/bin/ruby
+ln -sf /usr/bin/ri1.8 /usr/local/bin/ri
+ln -sf /usr/bin/rdoc1.8 /usr/local/bin/rdoc
+ln -sf /usr/bin/irb1.8 /usr/local/bin/irb
+
+# Install rubygems
+echo '-- Installing Rubygems'
+# if [[ ! -f /usr/local/src/rubygems-1.1.1 ]]; then
+  cd /usr/local/src
+  wget http://rubyforge.org/frs/download.php/35283/rubygems-1.1.1.tgz
+  tar -xzf rubygems-1.1.1.tgz
+  rm rubygems-1.1.1.tgz
+  cd rubygems-1.1.1  
+  ruby setup.rb --no-rdoc --no-ri
+  ln -sf /usr/bin/gem1.8 /usr/bin/gem
+# fi
+
+# Install gems
+# if [[ which pool | grep -v "bin" ]]; then
+  gem update --system
+  gem install SQS aws-s3 amazon-ec2 aska rake poolparty --no-rdoc --no-ri --no-test
+# fi
+
+# Install haproxy
+# if [[ which haproxy | grep -v "bin" ]]; then
+  apt-get -y install haproxy
+  echo 'Configuring haproxy logging'
+  sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/haproxy
+  sed -i 's/SYSLOGD=\"\"/SYSLOGD=\"-r\"/g' /etc/default/syslogd
+  echo 'local0.* /var/log/haproxy.log' >> /etc/syslog.conf && /etc/init.d/sysklogd restart
+  /etc/init.d/haproxy restart
+# fi
+# Install heartbeat
+# if [[ which heartbeat | grep -v "bin" ]]; then
+  apt-get -y install heartbeat-2
+# fi
+
+# Install monit
+# if [[ which monit | grep -v "bin" ]]; then
+  apt-get -y install monit
+  sudo mkdir /etc/monit
+  sed -i 's/startup=0/startup=1/g' /etc/default/monit
+  /etc/init.d/monit start
+# fi
+
+# Install s3fuse
+# if [[ which s3fs | grep -v "bin" ]]; then
+  apt-get install -y libcurl4-openssl-dev libxml2-dev libfuse-dev
+  cd /usr/local/src && wget http://s3fs.googlecode.com/files/s3fs-r166-source.tar.gz 
+  tar -zxf s3fs-r166-source.tar.gz
+  cd s3fs/ && make
+  mv s3fs /usr/bin
+# fi  
+
+echo ' - installed from script!'

data/config/monit.conf

@@ -0,0 +1,9 @@
+# Configuration for Monit, a monitoring tool
+set daemon 20 # Perform a check every 20 seconds
+set logfile /var/log/monit.log
+
+set httpd port 2812 and
+    use address 0.0.0.0
+    allow localhost
+
+include /etc/monit.d/*

data/config/monit/haproxy.monit.conf

@@ -0,0 +1,7 @@
+check process haproxy with pidfile /var/run/haproxy.pid
+  start program = "/usr/sbin/haproxy -f /etc/haproxy.cfg -p /var/run/haproxy.pid"
+  stop program  = "/usr/bin/killall -9 haproxy"
+  if totalmem is greater than 100.0 MB for 4 cycles then restart
+  if cpu is greater than 50% for 2 cycles then alert
+  if cpu is greater than 80% for 3 cycles then restart
+  if loadavg(5min) greater than 10 for 8 cycles then restart

data/config/nginx.conf

@@ -0,0 +1,24 @@
+user  usr usr;
+worker_processes  2;
+
+http {
+    sendfile       on;
+    tcp_nopush     on;
+
+    keepalive_timeout  65;
+    tcp_nodelay        on;
+
+    upstream fast_mongrels  { server 127.0.0.1:4567; }
+
+    server {
+        listen       80;
+        server_name  srv;
+        root        /apps/pool-party;
+     
+     location / {
+         proxy_pass http://fast_mongrels;
+         break;
+     }
+      
+  }
+}

data/config/reconfigure_instances_script.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# Reconfigure master
+:config_master
+# Start this instance's master maintain script
+:start_pool_maintain
+# Make the ha.d/resource.d
+sudo mkdir /etc/ha.d/resource.d/
+# Set this hostname as appropriate in the cloud
+:set_hostname
+# Configure heartbeat
+sudo mkdir /etc/ha.d/resource.d/
+# Start heartbeat
+/etc/init.d/heartbeat start
+# Start s3fs
+:start_s3fs
+# Configure monit
+mkdir /etc/monit.d

data/config/sample-config.yml

@@ -0,0 +1,23 @@
+:app_name: "test_app"
+:user_id: "1619-6456-1164"
+:access_key: ""
+:secret_access_key: ""
+:ami: "ami-4f7a9f26"
+:size: small
+:polling_time: "30.seconds"
+:minimum_instances: 2
+:maximum_instances: 3
+:ec2_dir: "/Users/auser/.ec2"
+:keypair: auser
+:os: ubuntu
+:host_port: 80
+:client_port: 8001
+:shared_bucket: "pool-party-app-data"
+:services: nginx
+:environment: production
+:contract_when:
+  web > 10
+  cpu < 0.2
+:expand_when:
+  cpu > 0.45
+  web < 10

data/config/scp_instances_script.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+:cloud_master_takeover
+:config_file
+:authkeys
+:ha_d
+:haresources
+:resources
+:monitrc
+:monit_d
+:haproxy
+:hosts

data/lib/core/array.rb

@@ -0,0 +1,13 @@
+=begin rdoc
+  Array extensions
+=end
+require "enumerator"
+class Array
+  # Collection with the index
+  def collect_with_index &block
+    self.enum_for(:each_with_index).collect &block
+  end
+  def runnable
+    self.join(" \n ").runnable
+  end
+end

data/lib/core/exception.rb

@@ -0,0 +1,9 @@
+=begin rdoc
+  Exception overloads
+=end
+class Exception
+  # Gives us a nice_message for exceptions
+  def nice_message(padding="")
+    "#{padding}#{message}\n#{padding}" + backtrace.join("\n#{padding}")
+  end
+end

data/lib/core/float.rb

@@ -0,0 +1,13 @@
+class Float
+  def round_to(x)
+    (self * 10**x).round.to_f / 10**x
+  end
+
+  def ceil_to(x)
+    (self * 10**x).ceil.to_f / 10**x
+  end
+
+  def floor_to(x)
+    (self * 10**x).floor.to_f / 10**x
+  end
+end

data/lib/core/hash.rb

@@ -0,0 +1,11 @@
+=begin rdoc
+  Hash extentions
+=end
+class Hash
+  def safe_merge(other_hash)
+    merge(other_hash.delete_if {|k,v| has_key?(k) })
+  end
+  def safe_merge!(other_hash)
+    merge!(other_hash.delete_if {|k,v| has_key?(k) })
+  end
+end

data/lib/core/kernel.rb

@@ -0,0 +1,12 @@
+=begin rdoc
+  Kernel overloads
+=end
+module Kernel
+  # Nice wait instead of sleep
+  def wait(time=10)
+    sleep time.is_a?(String) ? eval(time) : time
+  end
+  def as(klass_or_obj, &block)
+    block.in_context(klass_or_obj).call
+  end
+end

data/lib/core/module.rb

@@ -0,0 +1,22 @@
+# Module overloads
+class Module
+  # Gives us alias_method_chain from rails
+  def alias_method_chain(target, feature)
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    alias_method without_method, target
+    alias_method target, with_method
+
+    case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+    end
+  end
+end

data/lib/core/object.rb

@@ -0,0 +1,18 @@
+=begin rdoc
+  Basic, add an alias_method to the object class
+  Add returning to the object
+=end
+class Object
+  def alias_method(new_id, original_id)
+    original = self.method(original_id).to_proc
+    define_method(new_id){|*args| original.call(*args)}
+  end
+  def returning(receiver)
+    yield receiver
+    receiver
+  end
+  def extended(&block)
+    block.in_context(self).call
+    self
+  end
+end

data/lib/core/proc.rb

@@ -0,0 +1,15 @@
+class Proc
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self; end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+  def in_context(klass_or_obj)
+    klass_or_obj.send(:eval, self.to_ruby)
+  end
+end

data/lib/core/string.rb

@@ -0,0 +1,49 @@
+class String
+  def hasherize(format=[])
+    hash = {}
+    i = 0
+    self.split(%r{[\n|\t|\s| ]+}).collect {|a| a.strip}.each do |f|
+      break unless format[i]
+      unless f == "" || f.nil?
+        hash[format[i]] = f
+        i+=1
+      end      
+    end
+    hash
+  end
+  def ^(h={})
+    self.gsub(/:([\w]+)/) {h[$1.to_sym] if h.include?($1.to_sym)}
+  end
+  def runnable
+    self.strip.gsub(/\n/, " && ")
+  end
+  def classify
+    self.capitalize
+  end
+  def bucket_objects
+    AWS::S3::Bucket.objects(self)
+  end
+  def bucket_object(key)
+    AWS::S3::S3Object.value key, self if bucket_object_exists?(key)
+  end
+  def bucket_object_exists?(key)
+    AWS::S3::S3Object.exists? key, self
+  end
+  def store_bucket_value(key, data)
+    AWS::S3::S3Object.store key, data, self unless bucket_object_exists?(key)
+  end
+  def delete_bucket_value(key)
+    AWS::S3::S3Object.delete(key, self) if bucket_object_exists?(key)
+  end
+  def bucket_exists?
+    begin
+      AWS::S3::Bucket.find(self)
+      return true
+    rescue
+      return false
+    end        
+  end
+  def delete_bucket
+    AWS::S3::Bucket.delete(self, :force => true) if bucket_exists?
+  end
+end

data/lib/core/time.rb

@@ -0,0 +1,41 @@
+=begin rdoc
+  Based off the rails Numeric class.
+  Gives us the ability to use nice phrases such as
+  30.seconds, 5.days, etc.
+=end
+class Numeric
+  def ago(time = Time.now)
+    time - self
+  end
+  alias :until :ago
+
+  def since(time = Time.now)
+    time + self
+  end
+  alias :from_now :since
+  
+  def seconds
+    self
+  end
+  alias :second :seconds
+
+  def minutes
+    self * 60
+  end
+  alias :minute :minutes  
+
+  def hours
+    self * 60.minutes
+  end
+  alias :hour :hours
+
+  def days
+    self * 24.hours
+  end
+  alias :day :days
+
+  def weeks
+    self * 7.days
+  end
+  alias :week :weeks
+end