cappy-taffy 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cappy-taffy.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/cappy-taffy.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cappy-taffy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cappy-taffy"
+  s.version     = Cappy::Taffy::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Eric Boehs"]
+  s.email       = ["ericboehs@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Capistrano task to pull production database to local using taps}
+  s.description = %q{Cappy Taffy is based on cap taffy which uses the heroku gem to generate the database and taps urls; this gem however does not depend on the heroku gem.}
+
+  s.rubyforge_project = "cappy-taffy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/cappy-taffy.rb

@@ -0,0 +1,5 @@
+module Cappy
+  module Taffy
+    # Your code goes here...
+  end
+end

data/lib/cappy-taffy/db.rb

@@ -0,0 +1,125 @@
+require 'rubygems'
+begin
+  gem 'taps', '>= 0.2.8'
+rescue LoadError
+  error "Install the Taps gem to use db commands."
+end
+
+require File.join(File.dirname(__FILE__), 'parse')
+require 'digest/sha1'
+
+module CappyTaffy::Db
+  extend self
+
+  # Detects the local database url for +env+.
+  def local_database_url(env)
+    # return "" unless File.exists?(Dir.pwd + '/config/database.yml')
+    # db_config = YAML.load(File.read(Dir.pwd + '/config/database.yml'))
+
+    CappyTaffy::Parse.database_url(env)
+  end
+
+  # The default server port the Taps server is started on.
+  def default_server_port
+    5000
+  end
+
+  # Gets the taps host from the config
+  def taps_host
+    return YAML.load(File.read(Dir.pwd + '/config/database.yml'))['production']['taps_host']
+  end
+
+  # Generates the remote url used by Taps push/pull.
+  def remote_taps_url(options={})
+    host = options[:taps_host] || taps_host
+    port = options[:port] || default_server_port
+
+    url = CappyTaffy::Parse.uri_hash_to_url(
+      'username' => options[:login], 
+      'password' => options[:password], 
+      'host'     => host, 
+      'port'     => port, 
+      'scheme'   => 'http', 
+      'path'     => ''
+    )
+
+    return url.sub(/\/$/, '')
+  end
+
+  # Generates a temporary password to be used for the Taps server command.
+  def tmp_pass(user)
+    pass = YAML.load(File.read(Dir.pwd + '/config/database.yml'))['production']['taps_pass']
+    pass = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{user}--") unless pass
+    
+    return pass
+  end
+
+  def run(instance, options = {})
+    remote_taps_url = CappyTaffy::Db.remote_taps_url(options)
+    exec("taps #{options[:direction]} #{options[:local_database_url]} #{remote_taps_url}")
+  end
+end
+
+Capistrano::Configuration.instance.load do
+  namespace :db do
+    task :detect, :roles => :app do
+      @remote_taps_url = CappyTaffy::Db.remote_taps_url
+      @local_database_url = CappyTaffy::Db.local_database_url('development')
+    end
+
+    desc <<-DESC
+      Push a local database into the app's remote database.
+      
+      Performs push from local development database to remote production database.
+      Opens a Taps server on port 5000. (Ensure port is opened on the remote server).
+      
+        # alternately, specify a different port
+        cap db:push -s taps_port=4321
+        
+      For the security conscious:
+      
+        # use ssh local forwarding (ensure [port] is available on both endpoints)
+        ssh -N -L[port]:127.0.0.1:[port] [user]@[remote-server]
+        
+        # then push locally
+        cap db:push -s taps_port=[port] -s local=true
+    DESC
+    # task :push do      
+    #   detect
+    # 
+    #   login = fetch(:user)
+    #   password = CappyTaffy::Db.tmp_pass(login)
+    #   
+    #   logger = Capistrano::Logger.new
+    #   logger.important "Auto-detected remote database: #{@remote_taps_url}" if @remote_taps_url != ''
+    #   logger.important "Auto-detected local database: #{@local_database_url}" if @local_database_url != ''
+    # 
+    #   options = {:direction => "push",:remote_taps_url => @remote_taps_url, :login => login, :password => password, :local_database_url => @local_database_url, :port => variables[:taps_port]}
+    # 
+    #   CappyTaffy::Db.run(self, options)
+    # end
+
+    desc <<-DESC
+      Pull the app's database into a local database.
+      
+      Performs pull from remote production database to local development database.
+              
+      # alternately, specify a different port (default 5000)
+      cap db:pull -s taps_port=4321
+    DESC
+    task :pull do
+      detect
+
+      login = fetch(:user)
+      password = CappyTaffy::Db.tmp_pass(login)
+      
+      logger = Capistrano::Logger.new
+      logger.important "Auto-detected remote database: #{@remote_taps_url}" if @remote_taps_url != ''
+      logger.important "Auto-detected local database: #{@local_database_url}" if @local_database_url != ''
+
+      options = {:direction => "pull",:remote_taps_url => @remote_taps_url, :login => login, :password => password, :local_database_url => @local_database_url, :port => variables[:taps_port]}
+
+      CappyTaffy::Db.run(self, options)
+    end
+  end
+end

data/lib/cappy-taffy/parse.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'yaml'
+require 'uri'
+
+module CappyTaffy
+  class Parse
+    class << self
+      attr_accessor :instance
+
+      # Modified from :parse_database_yml in heroku/command/db.rb
+      def database_url(environment=nil)
+        cwd = Dir.pwd
+        #TODO: Remove static cwd
+        # cwd = '/Users/ericboehs/Dropbox/Projects/Digimedia/digistore_new/administrators'
+
+        return "" unless File.exists?(cwd + '/config/database.yml')
+
+        unless environment
+          environment = ENV['RAILS_ENV'] || ENV['MERB_ENV'] || ENV['RACK_ENV']
+          environment = 'development' if environment.nil? or environment.empty?
+        end
+
+        conf = YAML.load(File.read(cwd + '/config/database.yml'))[environment]
+        case conf['adapter']
+        when 'sqlite3'
+          return "sqlite://#{conf['database']}"
+        when 'postgresql'
+          uri_hash = conf_to_uri_hash(conf)
+          uri_hash['scheme'] = 'postgres'
+          return uri_hash_to_url(uri_hash)
+        else
+          return uri_hash_to_url(conf_to_uri_hash(conf))
+        end
+      rescue Exception => ex
+        puts "Error parsing database.yml: #{ex.message}"
+        puts ex.backtrace
+        ""
+      end
+
+      # Part of heroku/command/db.rb
+      def conf_to_uri_hash(conf)
+        uri = {}
+        uri['scheme'] = conf['adapter']
+        uri['username'] = conf['user'] || conf['username']
+        uri['password'] = conf['password']
+        uri['host'] = conf['host'] || conf['hostname']
+        uri['port'] = conf['port']
+        uri['path'] = conf['database']
+
+        conf['encoding'] = 'utf8' if conf['encoding'] == 'unicode' or conf['encoding'].nil?
+        uri['query'] = "encoding=#{conf['encoding']}"
+
+        uri
+      end
+
+      # Part of heroku/command/db.rb
+      def userinfo_from_uri(uri)
+        username = uri['username'].to_s
+        password = uri['password'].to_s
+        return nil if username == ''
+
+        userinfo  = ""
+        userinfo << username
+        userinfo << ":" << password if password.length > 0
+        userinfo
+      end
+
+      # Part of heroku/command/db.rb
+      def uri_hash_to_url(uri)
+        uri_parts = {
+          :scheme   => uri['scheme'],
+          :userinfo => userinfo_from_uri(uri),
+          :password => uri['password'],
+          :host     => uri['host'] || '127.0.0.1',
+          :port     => uri['port'],
+          :path     => "/%s" % uri['path'],
+          :query    => uri['query'],
+        }
+
+        URI::Generic.build(uri_parts).to_s
+      end      
+    end
+  end
+end

data/lib/cappy-taffy/version.rb

@@ -0,0 +1,5 @@
+module Cappy
+  module Taffy
+    VERSION = "1.0.0"
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: cappy-taffy
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Eric Boehs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-31 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Cappy Taffy is based on cap taffy which uses the heroku gem to generate the database and taps urls; this gem however does not depend on the heroku gem.
+email: 
+- ericboehs@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- cappy-taffy.gemspec
+- lib/cappy-taffy.rb
+- lib/cappy-taffy/db.rb
+- lib/cappy-taffy/parse.rb
+- lib/cappy-taffy/version.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cappy-taffy
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Capistrano task to pull production database to local using taps
+test_files: []
+