wpcap 0.1.0

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Russell Osborne
+
+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.md

@@ -0,0 +1,67 @@
+# WPcap
+
+WPcap is a set of capistrano recipes designed to deploy wordpress instaliations to ubuntu 12.04 and up. It provides database and asset sync tasks, per deploy mysql backups, a helper appication to setup a brand new wordpress install ready to be deployed.  
+
+WPcap is opinionated, and currently reasonably narrow minded.  
+
+WPcap assumptions
+
+  * Local Macine is a Mac running MAMP
+  * Remote Server is a brand new Ubuntu Server 
+  * Passwordless access to remote server has be established (ssh keys) 
+  * Wordpress is using mysql
+
+WPcap server configuration
+
+  * nginx stable
+  * php5-fpm stable
+  * mysql > 5.5
+  * memcached
+  * varnish (Optional)
+
+## Installation
+
+Install it:
+
+    gem install wpcap
+
+## Usage
+
+Create a new projet
+  
+    wpcap create mynewproject
+
+Build a remote server
+  
+    cap deploy:install
+
+Setup a remote server for this wordpress install
+
+    cap deploy:setup
+
+Deploy your latest code to the server
+
+    cap deploy
+    
+Push Local Database and Assets to remote server
+
+    cap db:push
+    
+Pull Remote Database and Assets to local enviroment
+
+    cap db:pull
+    
+## Todo
+
+  * Covert a predone wordpress install into a wpcap style directory
+  * Do not require MAMP
+  * Allow users to customize templates by placing them in there config directory (think devise generators for views)
+  
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/wpcap

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'wpcap'
+require 'wpcap/command'
+require 'wpcap/utility'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Wpcap::Command.run(command, args)

data/lib/wpcap/command.rb

@@ -0,0 +1,64 @@
+class Wpcap::Command
+  require 'shellwords'
+  require 'wpcap/utility'
+  
+  def self.run(command, args)
+    Wpcap::Command.send(command, args)
+  end
+  
+  def self.create(args)
+    @application = args.first
+    @wp_root =  File.join( (args[1].nil? ? Dir.pwd : args[1]) , @application.to_s)
+    locale  = args[2].nil? ? "en_US" : args[2]
+    puts @wp_root
+     if File.directory? "#{@wp_root}"
+       puts "Project Folder Already Exists"
+       return
+     end
+    `mkdir -p #{@wp_root}`
+    `cd #{@wp_root} &&  mkdir app`
+
+    if File.exists? @wp_root + 'app/wp-load.php'
+      puts "This folder seems to already contain wordpress files. "
+      return
+    end
+
+    if locale != "en_US"
+      output = IO.popen( "cd #{@wp_root} && curl -s #{Shellwords.escape( 'https://api.wordpress.org/core/version-check/1.5/?locale=')}#{locale} "  )
+      download_url = output[2].gsub(".zip", ".tar.gz")
+      puts  'Downloading WordPress #{output[3]} (#{output[4]})...'
+    else
+      download_url = 'https://wordpress.org/latest.tar.gz';
+      puts 'Downloading latest WordPress (en_US)...'
+    end
+
+    `cd #{@application} && curl -f #{Shellwords.escape( download_url )} | tar xz`
+    `cd #{@application} && mv wordpress/* app`
+    `rm -rf #{@wp_root}/wordpress`
+
+    puts 'WordPress downloaded.'  
+    self.setup
+  end
+  
+  def self.setup
+    puts "Capifying your project and seting up config directories"
+    unless File.exists? "#{@wp_root}/app/wp-load.php"
+      puts "This does not Appear to be a wpcap"
+      return 
+    end
+    
+    `capify #{@wp_root}`
+    `touch #{@wp_root}/config/database.yml`
+    `rm #{@wp_root}/config/deploy.rb`
+    `cp #{File.dirname(__FILE__)}/recipes/templates/deploy.rb.erb #{@wp_root}/config/deploy.rb`
+    `mkdir -p #{@wp_root}/config/deploy`
+    `cp #{File.dirname(__FILE__)}/recipes/templates/deploy-stage.rb.erb  #{@wp_root}/config/deploy/staging.rb`
+    `cp #{File.dirname(__FILE__)}/recipes/templates/deploy-stage.rb.erb  #{@wp_root}/config/deploy/production.rb`
+    
+  end
+  
+  def self.help(cmd)
+    puts "`#{cmd}` is not a wpcap command."
+    puts "See `wpcap help` for a list of available commands."
+  end
+end

data/lib/wpcap/recipes/base.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'railsless-deploy'
+require 'capistrano/ext/multistage'
+
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+  
+  def template(from, to)
+    erb = File.read(File.expand_path("../templates/#{from}", __FILE__))
+    put ERB.new(erb).result(binding), to
+  end
+
+  def set_default(name, *args, &block)
+    set(name, *args, &block) unless exists?(name)
+  end
+
+  def random_password(size = 8)
+    chars = (('a'..'z').to_a + ('0'..'9').to_a) - %w(i o 0 1 l 0)
+    (1..size).collect{|a| chars[rand(chars.size)] }.join
+  end
+
+  def run_with_tty(server, cmd)
+    # looks like total pizdets
+    command = []
+    command += %W( ssh -t #{gateway} -l #{self[:gateway_user] || self[:user]} ) if     self[:gateway]
+    command += %W( ssh -t )
+    command += %W( -p #{server.port}) if server.port
+    command += %W( -l #{user} #{server.host} )
+    command += %W( cd #{current_path} )
+    # have to escape this once if running via double ssh
+    command += [self[:gateway] ? '\&\&' : '&&']
+    command += Array(cmd)
+    system * command
+  end
+
+  default_run_options[:pty] = true
+  ssh_options[:forward_agent] = true
+  set :use_sudo , false
+ 
+  namespace :deploy do
+    desc "Install everything onto the server"
+    task :install do
+      run "#{sudo} apt-get -y update"
+      run "#{sudo} apt-get -y install git debconf-utils python-software-properties"
+    end
+  end
+end

data/lib/wpcap/recipes/check.rb

@@ -0,0 +1,19 @@
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+namespace :check do
+  desc "Make sure local git is in sync with remote."
+  task :revision, roles: :web do
+    unless `git rev-parse HEAD` == `git rev-parse origin/#{branch}`
+      puts "WARNING: HEAD is not the same as origin/#{branch}"
+      puts "Run `git push` to sync changes."
+      exit
+    end
+  end
+  before "deploy", "check:revision"
+  before "deploy:migrations", "check:revision"
+  before "deploy:cold", "check:revision"
+end
+end

data/lib/wpcap/recipes/memcached.rb

@@ -0,0 +1,30 @@
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+set_default :memcached_memory_limit, 256
+
+namespace :memcached do
+  desc "Install Memcached"
+  task :install, roles: :app do
+    run "#{sudo} apt-get install memcached"
+  end
+  after "deploy:install", "memcached:install"
+
+  desc "Setup Memcached"
+  task :setup, roles: :app do
+    template "memcached.erb", "/tmp/memcached.conf"
+    run "#{sudo} mv /tmp/memcached.conf /etc/memcached.conf"
+    restart
+  end
+  after "deploy:setup", "memcached:setup"
+
+  %w[start stop restart].each do |command|
+    desc "#{command} Memcached"
+    task command, roles: :app do
+      run "service memcached #{command}"
+    end
+  end
+end
+end

data/lib/wpcap/recipes/mysql.rb

@@ -0,0 +1,230 @@
+require 'erb'
+require 'yaml'
+require 'wpcap'
+require 'wpcap/utility'
+
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+  namespace :db do
+    namespace :mysql do
+      desc "Install Mysql Database Server"
+      task :install_server, roles: :db do
+        create_yaml
+        prepare_env
+        run "#{sudo}  apt-get -y update"
+        run "#{sudo} echo 'mysql-server-5.5 mysql-server/root_password password #{db_priv_pass}' | #{sudo} debconf-set-selections"
+        run "#{sudo} echo 'mysql-server-5.5 mysql-server/root_password_again password #{db_priv_pass}' | #{sudo} debconf-set-selections"
+        run "#{sudo} apt-get -y install mysql-server"
+      end
+      after "deploy:install", "db:mysql:install_server"
+      
+      desc "Install Mysql Database Client Bindings"
+      task :install_client, roles: :web do
+        run "#{sudo} apt-get -y update"
+        run "#{sudo} apt-get -y install mysql-client"
+      end
+      after "deploy:install", "db:mysql:install_client"
+
+      desc <<-EOF
+      Performs a compressed database dump. \
+      WARNING: This locks your tables for the duration of the mysqldump.
+      Don't run it madly!
+      EOF
+      task :dump, :roles => :db, :only => { :primary => true } do
+      
+        prepare_env
+        run "mkdir -p #{backups_path}"
+        filename = "db_backup.#{Time.now.utc.to_i}.sql.bz2"
+        filepath = "#{backups_path}/#{filename}"
+        on_rollback { run "rm #{filepath}" }
+        run "mysqldump --user=#{db_username} -p --host=#{db_host} #{db_database} | bzip2 -z9 > #{filepath}" do |ch, stream, out|
+          ch.send_data "#{db_password}\n" if out =~ /^Enter password:/
+          puts out
+        end     
+      end
+
+      desc "Restores the database from the latest compressed dump"
+      task :restore_most_recent, :roles => :db, :only => { :primary => true } do
+        prepare_env
+        run "bzcat #{most_recent_backup} | mysql --user=#{db_username} -p --host=#{db_host} #{db_database}" do |ch, stream, out|
+          ch.send_data "#{db_password}\n" if out =~ /^Enter password:/
+          puts out
+        end
+      end
+    
+      desc "Restores the database from the latest downloaded compressed dump"
+      task :local_restore do
+        prepare_env(:development)
+        run_locally "bzcat #{local_dump} | #{local_mysql_path}mysql --user=#{db_username} -p#{db_password} #{db_database}" 
+        run_locally "rm #{local_dump}"
+      end
+    
+      desc "Downloads the compressed database dump to this machine"
+      task :fetch_dump, :roles => :db, :only => { :primary => true } do
+        prepare_env
+        run_locally "touch #{local_dump}"
+        download most_recent_backup, local_dump, :via => :scp
+      end
+    
+      desc "Uploads the compressed database dump to the remote server"
+      task :push_dump, :roles => :db, :only => { :primary => true } do
+        prepare_env(:development)
+        run_locally "#{local_mysql_path}mysqldump --user #{db_username} --password=#{db_password} #{db_database} | bzip2 -z9 > #{local_dump}"
+        run "mkdir -p #{backups_path}"
+        filename = "local_upload.#{Time.now.to_f}.sql.bz2"
+        filepath = "#{backups_path}/#{filename}"
+        upload "#{local_dump}" , "#{filepath}"
+      end
+    
+      desc "Push the Local DB to Remote Server"
+      task :push, :roles => :db do
+        prepare_env
+        push_dump
+        restore_most_recent
+        run_locally "rm #{local_dump}"
+      end
+    
+      desc "Pull the Remote DB to Local"
+      task :pull, :roles => :db do
+        prepare_env
+        dump
+        fetch_dump
+        local_restore
+      end
+    
+      desc "Create MySQL database and user for this stage using database.yml values"
+      task :create, :roles => :db, :only => { :primary => true } do
+        prepare_env
+        create_db_if_missing
+      end 
+    
+      desc "Create MySQL database and user for this stage using database.yml values on your local machine"
+      task :create_local_db do
+        prepare_env
+        create_db_if_missing("development")
+      end 
+    
+      desc "Load the DB enviroment from the app server"
+      task :prepare_enviroment do    
+        prepare_env
+      end
+    
+      desc "Remote dbconsole" 
+      task :dbconsole, :roles => :app do
+        prepare_env
+        server = find_servers(:roles => [:db]).first
+        run_with_tty server, %W( mysql --user=#{db_username} -password#{db_password} --host=#{db_host} #{db_database} )
+      end
+    
+      desc "Create database.yml in shared path with settings for current stage and test env"
+      task :create_yaml do  
+        prepare_env  
+        template_path = "#{shared_path}/config/database.yml"
+      
+        unless db_config[rails_env]
+          set :db_priv_pass, random_password(16)
+          set :db_username, "#{application.split(".").first}_#{stage}"
+          set :db_database, "#{application.split(".").first}_#{stage}"
+          set :db_password, random_password(16)
+          run "mkdir -p #{shared_path}/config"
+          template "mysql.yml.erb", template_path
+          server_yaml = capture "cat #{template_path}"
+          server_mysql_config_yaml = YAML.load(server_yaml)
+          update_db_config(server_mysql_config_yaml)
+        end
+      end
+    
+      def db_config
+        @db_config ||= fetch_db_config
+      end
+    
+      def fetch_db_config
+        YAML.load(File.open("config/database.yml"))
+      end
+    
+      # Sets database variables from remote database.yaml
+      def prepare_env(rails_env = stage)
+        abort "No Database Configuratons Found" if !db_config 
+        
+        rails_env = rails_env.to_s     
+        set(:local_dump)      { "/tmp/#{application}.sql.bz2" }
+
+        if db_config[rails_env]
+          set(:db_priv_user) { db_config[rails_env]["priv_username"].nil? ?  db_config[rails_env]["username"] : db_config[rails_env]["priv_username"] }
+          set(:db_priv_pass) { db_config[rails_env]["priv_password"].nil? ?  db_config[rails_env]["password"] : db_config[rails_env]["priv_password"] }
+          set(:db_host) { db_config[rails_env]["host"] }
+          set(:db_database) { db_config[rails_env]["database"] }
+          set(:db_username) { db_config[rails_env]["username"] }
+          set(:db_password) { db_config[rails_env]["password"] }
+          set(:db_encoding) { db_config[rails_env]["encoding"] }
+          set(:db_prefix) { db_config[rails_env]["prefix"].nil? ?  db_config["development"]["prefix"] : db_config[rails_env]["prefix"] }         
+        else
+          Wpcap::Utility.error "No Database Configuration for #{rails_env} Found" 
+          abort
+        end
+      
+      end
+    
+      def update_db_config(hash_to_save)
+        database_yaml = db_config.merge(hash_to_save)
+        print "Saving Database Config file to local Repo"
+        File.open('config/database.yml', 'w') do |f|
+          f.puts YAML::dump(database_yaml).sub("---","").split("\n").map(&:rstrip).join("\n").strip
+        end
+      end
+    
+      def most_recent_backup
+        most_recent_sql = capture "cd #{backups_path}; ls -lrt | awk '{ f=$NF }; END{ print f }'"
+        return "#{backups_path}/#{most_recent_sql}".strip
+      end
+    
+      def database_exits?(environment = stage)
+        exists = false
+        databases = run_mysql_command("show databases;", environment)
+        exists = exists || databases.include?(db_database)
+        exists
+      end
+    
+      def create_db_if_missing(environment = stage)
+        unless database_exits?(environment)
+          sql = <<-SQL
+          CREATE DATABASE #{db_database};
+          GRANT ALL PRIVILEGES ON #{db_database}.* TO #{db_username}@#{db_host} IDENTIFIED BY '#{db_password}';
+          SQL
+        
+          run_mysql_command(sql, environment)
+        else
+          print "databases exists -- skipping"
+        end
+      end
+    
+      def run_mysql_command(sql, environment = stage)
+        environment = environment.to_s
+        prepare_env(environment)
+      
+        db_username = db_priv_user 
+        db_password = db_priv_pass
+        output = ""
+        if environment == "development"
+          output = run_locally "#{local_mysql_path}mysql --user=#{db_username} -p#{db_password}  --execute=\"#{sql}\"" 
+        else
+          run "mysql --user=#{db_username} --password --execute=\"#{sql}\"" do |channel, stream, data|
+            if data =~ /^Enter password:/
+              channel.send_data "#{db_password}\n" 
+            end
+            output += data
+          end
+        end
+        return output
+      end
+      before "db:mysql:push", "db:mysql:create"
+      before "db:mysql:pull", "db:mysql:create_local_db"
+      after "deploy:update_code" , "db:mysql:prepare_enviroment"
+      after "deploy:setup", "db:mysql:create"
+      before :deploy, 'db:mysql:dump' 
+    end
+  end
+end

data/lib/wpcap/recipes/nginx.rb

@@ -0,0 +1,34 @@
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+  namespace :nginx do
+    desc "Install latest stable release of nginx"
+    task :install, roles: :web do
+      run "#{sudo} add-apt-repository ppa:nginx/stable -y"
+      run "#{sudo} apt-get -y update"
+      run "#{sudo} apt-get -y install nginx"
+    end
+    after "deploy:install", "nginx:install"
+
+    desc "Setup nginx configuration for this application"
+    task :setup, roles: :web do
+      template "nginx_php.erb", "/tmp/nginx_conf"
+      run "#{sudo} mv /tmp/nginx_conf /etc/nginx/sites-enabled/#{application}"
+      run "#{sudo} rm -f /etc/nginx/sites-enabled/default"
+      run "mkdir -p #{shared_path}/logs"
+      run "#{sudo} touch #{shared_path}/logs/access.log"
+      run "#{sudo} touch #{shared_path}/logs/error.log"
+      restart
+    end
+    after "deploy:setup", "nginx:setup"
+  
+    %w[start stop restart].each do |command|
+      desc "#{command} nginx"
+      task command, roles: :web do
+        run "#{sudo} service nginx #{command}"
+      end
+    end
+  end
+end

data/lib/wpcap/recipes/php.rb

@@ -0,0 +1,48 @@
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+  
+  namespace :php do
+    desc "Install the latest relase of PHP and PHP-FPM"
+    task :install, roles: :app do
+      run "#{sudo} add-apt-repository ppa:ondrej/php5 -y"
+      run "#{sudo} apt-get -y update"
+      run "#{sudo} apt-get -y install php5 php5-fpm php5-mysql php5-memcache php-apc"
+    end
+    after "deploy:install", "php:install"
+  
+    desc "Setup php and php fpm configuration for this application"
+    task :setup, roles: :web do
+      template "php-fpm.conf.erb", "/tmp/php_fpm_conf"
+      run "#{sudo} mv /tmp/php_fpm_conf /etc/php5/fpm/php-fpm.conf"
+
+      template "php.ini.erb", "/tmp/php_ini"
+      run "#{sudo} mv /tmp/php_ini /etc/php5/fpm/php.ini"
+    
+      restart
+    end
+    after "deploy:setup", "php:setup"
+  
+    namespace :apc do
+      desc "Disable the APC administrative panel"
+      task :disable, :roles => :web, :except => { :no_release => true } do
+        run "rm #{current_path}/app/apc.php"
+      end
+
+      desc "Enable the APC administrative panel"
+      task :enable, :roles => :web, :except => { :no_release => true } do
+        run "ln -s /usr/local/lib/php/apc.php #{current_path}/app/apc.php"
+      end
+    end
+  
+    %w[start stop restart].each do |command|
+      desc "#{command} php5-fpm"
+      task command, roles: :web do
+        run "#{sudo} service php5-fpm #{command}"
+      end
+    end
+    after "deploy", "php:restart"
+  end
+end

data/lib/wpcap/recipes/server.rb

@@ -0,0 +1,31 @@
+configuration = Capistrano::Configuration.respond_to?(:instance) ?
+Capistrano::Configuration.instance(:must_exist) :
+Capistrano.configuration(:must_exist)
+
+configuration.load do
+  namespace :servers do
+    desc "Update Servers"
+    task :update do
+      run "#{sudo} apt-get update -y"
+      run "#{sudo} apt-get upgrade -y"
+    end
+  
+    desc "Restart Servers"
+    task :restart do
+      run "#{sudo} reboot"
+    end
+  
+    %w[access error].each do |log|
+      desc "Tail #{log} log"
+      task "#{log}_log", roles: :web do
+        run "tail -f #{shared_path}/logs/error.log" do |channel, stream, data|
+          trap("INT") { puts 'Interupted'; exit 0; } 
+          puts  # for an extra line break before the host name
+          puts "#{channel[:host]}: #{data}" 
+          break if stream == :err
+        end
+      end
+    end
+  
+  end
+end

data/lib/wpcap/recipes/templates/deploy-stage.rb.erb

@@ -0,0 +1,10 @@
+# Deploy WordPress site using Capistrano
+#
+# Usage:
+# cap production deploy:setup
+# cap production deploy
+
+set :user, "root"
+set :application_url, "your full url here includeing the protocol (https/http)"
+server "your server address or url here", :web, :app, :db, primary: true
+