pagoda 0.1.0

data/.bundle/config

@@ -0,0 +1,2 @@
+--- 
+BUNDLE_DISABLE_SHARED_GEMS: "1"

data/.gitignore

@@ -0,0 +1 @@
+pagoda-*.*.*.gem

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    pagoda (0.0.1)
+      crack
+      iniparse
+      json_pure
+      rest-client
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.5)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    iniparse (1.1.4)
+    json_pure (1.5.1)
+    mime-types (1.16)
+    rest-client (1.6.1)
+      mime-types (>= 1.16)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    webmock (1.6.2)
+      addressable (>= 2.2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pagoda!
+  rspec
+  webmock

data/README

@@ -0,0 +1,3 @@
+Released under the MIT license. http://github.com/pagoda/pagoda-client
+
+Special thanks to heroku. We borrowed the initial skeleton from the heroku client gem: http://github.com/heroku/heroku

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require "rspec/core/rake_task"
+
+Bundler::GemHelper.install_tasks
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.rspec_opts = ['--colour --format progress']
+end
+
+task :default => :spec

data/bin/pagoda

@@ -0,0 +1,13 @@
+#!/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 'pagoda/client'
+require 'pagoda/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Pagoda::Command.run(command, args)

data/lib/pagoda/client.rb

@@ -0,0 +1,221 @@
+require 'pagoda/version'
+require 'rexml/document'
+require 'rest_client'
+require 'uri'
+require 'json/pure' unless {}.respond_to?(:to_json)
+
+class Pagoda::Client
+
+  attr_reader :user, :password
+
+  class << self
+    def version
+      Pagoda::VERSION
+    end
+    
+    def gem_version_string
+      "pagoda-gem/#{version}"
+    end
+  end
+  
+  def initialize(user, password)
+    @user       = user
+    @password   = password
+  end
+  
+  def app_list
+    doc = xml(get("/apps.xml").to_s)
+    doc.elements['apps'].elements.to_a('//app/').inject([]) do |list, app| 
+      list <<  {
+          :name => app.elements['name'].text,
+          :instances => app.elements['instances'].text,
+          :git_url => app.elements['git-url'].text
+        }
+    end
+  end
+  
+  def database_exists?(app, mysql_instance)
+    begin
+      response = get("/apps/#{app}/databases/#{mysql_instance}.xml")
+      true
+    rescue RestClient::ResourceNotFound => e
+      false
+    end
+    
+  end
+  
+  def app_create(name, git_url)
+    doc = xml(post("/apps.xml", {:app => {:name => name, :git_url => git_url}}).to_s)
+    doc.elements.to_a('//app/*').inject({}) do |hash, element|
+      case element.name
+        when "owner"
+          hash[:owner] = {:username => element.elements['username'].text, :email => element.elements['email'].text}
+        when "collaborators"
+          hash[:collaborators] = element.elements.to_a('//collaborator/').inject([]) do |list, collaborator|
+            list << {:username => collaborator.elements['username'].text, :email => collaborator.elements['email'].text}
+          end
+        when "transactions"
+          hash[:transactions] = element.elements.to_a('//transaction/').inject([]) do |list, transaction|
+            list << {
+                :id          => transaction.elements["id"].text,
+                :name        => transaction.elements["name"].text,
+                :description => transaction.elements["description"].text,
+                :state       => transaction.elements["state"].text,
+                :status      => transaction.elements["status"].text
+              }
+          end
+        else
+          hash[element.name.gsub(/-/, '_').to_sym] = element.text
+      end
+      hash
+    end
+  end
+  
+  def app_info(app)
+    doc = xml(get("/apps/#{app}.xml").to_s)
+    doc.elements.to_a('//app/*').inject({}) do |hash, element|
+      case element.name
+        when "owner"
+          hash[:owner] = {:username => element.elements['username'].text, :email => element.elements['email'].text}
+        when "collaborators"
+          hash[:collaborators] = element.elements.to_a('//collaborator/').inject([]) do |list, collaborator|
+            list << {:username => collaborator.elements['username'].text, :email => collaborator.elements['email'].text}
+          end
+        when "transactions"
+          hash[:transactions] = element.elements.to_a('//transaction/').inject([]) do |list, transaction|
+            list << {
+                :id          => transaction.elements["id"].text,
+                :name        => transaction.elements["name"].text,
+                :description => transaction.elements["description"].text,
+                :state       => transaction.elements["state"].text,
+                :status      => transaction.elements["status"].text
+              }
+          end
+        else
+          hash[element.name.gsub(/-/, '_').to_sym] = element.text
+      end
+      hash
+    end
+  end
+  
+  def app_update(app, updates)
+    put("/apps/#{app}.xml", {:update => updates}).to_s
+  end
+  
+  def app_destroy(app)
+    delete("/apps/#{app}.xml").to_s
+  end
+  
+  def transaction_list(app)
+    doc = xml(get("/apps/#{app}/transactions.xml").to_s)
+    doc.elements['transactions'].elements.to_a('//transaction/').inject([]) do |list, transaction| 
+      list <<  {
+          :id          => transaction.elements['id'].text,
+          :name        => transaction.elements['name'].text,
+          :description => transaction.elements['description'].text,
+          :state       => transaction.elements['state'].text,
+          :status      => transaction.elements['status'].text
+        }
+    end
+  end
+  
+  def transaction_status(app, transaction)
+    doc = xml(get("/apps/#{app}/transactions/#{transaction}.xml").to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  def rewind(app, places=1)
+    doc = xml(put("/apps/#{app}/rewind.xml", {:places => places}).to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  def fast_forward(app, places=1)
+    doc = xml(put("/apps/#{app}/fast-forward.xml", {:places => places}).to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  def rollback(app)
+    get("/apps/#{app}/rollback.xml").to_s
+  end
+  
+  def deploy_latest(app)
+    doc = xml(post("/apps/#{app}/deploy.xml").to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  def deploy(app, branch, commit)
+    doc = xml(post("/apps/#{app}/deploy.xml", {:deploy => {:branch => branch, :commit => commit}}).to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  # def deploy(app)
+  #   doc = xml(put("/apps/#{app}/deploy.xml").to_s)
+  #   doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  # end
+  
+  def scale_up(app, qty=1)
+    doc = xml(put("/apps/#{app}/scale-up.xml").to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  def scale_down(app, qty=1)
+    doc = xml(put("/apps/#{app}/scale-down.xml").to_s)
+    doc.elements.to_a('//transaction/*').inject({}) { |hash, element| hash[element.name.gsub(/-/, '_').to_sym] = element.text; hash }
+  end
+  
+  def app_databases(app)
+    doc = xml(get("/apps/#{app}/databases.xml").to_s)
+    doc.elements['databases'].elements.to_a('//database/').inject([]) {|list, instance| list <<  {:name => instance.elements['name'].text} }
+  end
+  
+  def on_warning(&blk)
+    @warning_callback = blk
+  end
+  
+  protected
+  
+  def resource(uri)
+    RestClient.proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
+    if uri =~ /^https?/
+      RestClient::Resource.new(uri, @user, @password)
+    else
+      # RestClient::Resource.new("http://127.0.0.1:3000#{uri}", @user, @password)
+      RestClient::Resource.new("https://dashboard.pagodabox.com#{uri}", @user, @password)
+    end
+  end
+
+  def get(uri, extra_headers={})
+    process(:get, uri, extra_headers)
+  end
+
+  def post(uri, payload="", extra_headers={})    
+    process(:post, uri, extra_headers, payload)
+  end
+
+  def put(uri, payload="", extra_headers={})    
+    process(:put, uri, extra_headers, payload)
+  end
+
+  def delete(uri, extra_headers={})    
+    process(:delete, uri, extra_headers)
+  end
+
+  def process(method, uri, extra_headers={}, payload=nil)
+    headers  = pagoda_headers.merge(extra_headers)
+    args     = [method, payload, headers].compact
+    response = resource(uri).send(*args)
+  end
+  
+  def pagoda_headers
+    {
+      'User-Agent'           => self.class.gem_version_string,
+      'X-Ruby-Version'       => RUBY_VERSION,
+      'X-Ruby-Platform'      => RUBY_PLATFORM,
+    }
+  end
+
+  def xml(raw)   # :nodoc:
+    REXML::Document.new(raw)
+  end
+  
+end

data/lib/pagoda/command.rb

@@ -0,0 +1,93 @@
+require 'pagoda/helpers'
+require 'pagoda/tunnel_proxy'
+require 'pagoda/commands/base'
+
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Pagoda
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+    
+    extend Pagoda::Helpers
+    
+    class << self
+      
+      def run(command, args, retries=0)
+        begin
+          run_internal 'auth:reauthorize', args.dup if retries > 0
+          run_internal(command, args.dup)
+        rescue InvalidCommand
+          error "Unknown command: #{command}. Run 'pagoda help' for usage information."
+        rescue RestClient::Unauthorized
+          if retries < 3
+            STDERR.puts "Authentication failure"
+            run(command, args, retries+1)
+          else
+            error "Authentication failure"
+          end
+        rescue RestClient::ResourceNotFound => e
+          error extract_not_found(e.http_body)
+        rescue RestClient::RequestFailed => e
+          error extract_error(e.http_body) unless e.http_code == 402 || e.http_code == 102
+        rescue RestClient::RequestTimeout
+          error "API request timed out. Please try again, or contact support@pagodagrid.com if this issue persists."
+        rescue CommandFailed => e
+          error e.message
+        rescue Interrupt => e
+          error "\n[canceled]"
+        end
+      end
+
+      def run_internal(command, args)
+        klass, method = parse(command)
+        runner = klass.new(args)
+        raise InvalidCommand unless runner.respond_to?(method)
+        runner.send(method)
+      end
+
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+          when 1
+            begin
+              return eval("Pagoda::Command::#{command.capitalize}"), :index
+            rescue NameError, NoMethodError
+              return Pagoda::Command::App, command.to_sym
+            end
+          else
+            begin
+              const = Pagoda::Command
+              command = parts.pop
+              parts.each { |part| const = const.const_get(part.capitalize) }
+              return const, command.to_sym
+            rescue NameError
+              raise InvalidCommand
+            end
+        end
+      end
+
+      def extract_not_found(body)
+        body =~ /^[\w\s]+ not found$/ ? body : "Resource not found"
+      end
+
+      def extract_error(body)
+        msg = parse_error_xml(body) || parse_error_json(body) || 'Internal server error'
+      end
+
+      def parse_error_xml(body)
+        xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+        msg = xml_errors.map { |a| a.text }.join(" / ")
+        return msg unless msg.empty?
+      rescue Exception
+      end
+      
+      def parse_error_json(body)
+        json = JSON.parse(body.to_s)
+        json['error']
+      rescue JSON::ParserError
+      end
+    end
+    
+  end
+end

data/lib/pagoda/commands/app.rb

@@ -0,0 +1,243 @@
+module Pagoda::Command
+  class App < Base
+    
+    def list
+      apps = client.app_list
+      if !apps.empty?
+        display
+        display "APPS"
+        display "//////////////////////////////////"
+        display
+        apps.each do |app|
+          display "- #{app[:name]}"
+        end
+      else
+        error ["looks like you haven't launched any apps", "type 'pagoda launch' to launch this project"]
+      end
+      display
+    end
+    
+    def create
+      if app_name = app(true)
+        error ["This project is already launched and paired to #{app_name}.", "To unpair run 'pagoda unpair'"]
+      end
+      
+      unless locate_app_root
+        error ["Unable to find git config in this directory or in any parent directory"]
+      end
+      
+      unless clone_url = extract_git_clone_url
+        errors = []
+        errors << "It appears you are using git (fantastic)."
+        errors << "However we only support git repos hosted with github."
+        errors << "Please ensure your repo is hosted with github."
+        error errors
+      end
+      
+      unless name = args.dup.shift
+        error "Please Specify an app name ie. 'pagoda launch awesomeapp'"
+      end
+      
+      display
+      display "+> Registering #{name}"
+      app = client.app_create(name, clone_url)
+      display "+> Launching...", false
+      loop_transaction(name)
+      add_app(name, clone_url)
+      display "+> #{name} launched"
+      
+      unless option_value(nil, "--latest")
+        Pagoda::Command.run_internal("app:deploy", args)
+      end
+      
+      display "-----------------------------------------------"
+      display
+      display "LIVE URL    : http://#{name}.pagodabox.com"
+      display "ADMIN PANEL : http://dashboard.pagodabox.com"
+      display
+      display "-----------------------------------------------"
+      display
+      
+    end
+    alias :launch :create
+    alias :register :create
+    
+    def destroy
+      display
+      if confirm ["Are you totally completely sure you want to delete #{app} forever and ever?", "THIS CANNOT BE UNDONE! (y/n)"]
+        display "+> Destroying #{app}"
+        client.app_destroy(app)
+        display "+> #{app} has been successfully destroyed. RIP #{app}."
+        remove_app(app)
+      end
+      display
+    end
+    alias :delete :destroy
+    
+    def info
+      display
+      info = client.app_info(app)
+      display "INFO - #{info[:name]}"
+      display "//////////////////////////////////"
+      display "name       :  #{info[:name]}"
+      display "clone_url  :  #{info[:git_url]}"
+      display  
+      display "owner"
+      display "username :  #{info[:owner][:username]}", true, 2
+      display "email    :  #{info[:owner][:email]}", true, 2
+      display  
+      display "collaborators"
+      if info[:collaborators].any?
+        info[:collaborators].each_with_index do |collaborator, index|
+          display "username :  #{collaborator[:username]}", true, 2
+          display "email    :  #{collaborator[:email]}", true, 2
+        end
+      else
+        display "(none)", true, 2
+      end
+      display
+    end
+    
+    def pair
+      
+      if app_name = app(true)
+        error ["This project is paired to #{app_name}.", "To unpair run 'pagoda unpair'"]
+      end
+      
+      unless locate_app_root
+        error ["Unable to find git config in this directory or in any parent directory"]
+      end
+      
+      unless my_repo = extract_git_clone_url
+        errors = []
+        errors << "It appears you are using git (fantastic)."
+        errors << "However we only support git repos hosted with github."
+        errors << "Please ensure your repo is hosted with github."
+        error errors
+      end
+      
+      display
+      display "+> Locating deployed app with matching git repo"
+      
+      apps = client.app_list
+      
+      matching_apps = []
+      apps.each do |a|
+        if a[:git_url] == my_repo
+          matching_apps.push a
+        end
+      end
+      
+      if matching_apps.count > 1
+        if name = app(true) || args.dup.shift
+          assign_app = nil
+          matching_apps.each do |a|
+            assign_app = a if a[:name] == name
+          end
+          if assign_app
+            display "+> Pairing this repo to deployed app - #{assign_app[:name]}"
+            pair_with_remote(assign_app)
+            display "+> Repo is now paired to '#{assign_app[:name]}'"
+            display
+          else
+            error "#{name} is not found among your launched app list"
+          end
+        else
+          errors = []
+          errors << "Multiple matches found"
+          errors << ""
+          matching_apps.each do |match|
+            errors << "-> #{match[:name]}"
+          end
+          errors << ""
+          errors << "You have more then one app that uses this repo."
+          errors << "Please specify which app you would like to pair to."
+          errors << ""
+          errors << "ex: pagoda pair #{matching_apps[0][:name]}"
+          error errors
+        end
+      elsif matching_apps.count == 1
+        match = matching_apps.first
+        display "+> Pairing this repo to deployed app - #{match[:name]}"
+        pair_with_remote match
+        display "+> Repo is now paired to '#{match[:name]}'"
+        display
+      else
+        error "Current git repo doesn't match any launched app repos"
+      end
+    end
+    
+    def unpair
+      app
+      display
+      display "+> Unpairing this repo"
+      remove_app(app)
+      display "+> Free at last!"
+      display
+    end
+    
+    def deploy
+      app
+      display
+      branch = parse_branch
+      commit = parse_commit
+      if option_value(nil, "--latest")
+        client.deploy_latest(app)
+        display "+> deploying to latest commit point on github...", false
+        loop_transaction
+        display "+> deployed"
+        display
+      else
+        client.deploy(app, branch, commit)
+        display "+> deploying to match current branch and commit...", false
+        loop_transaction
+        display "+> deployed"
+        display
+      end
+    end
+    
+    def rewind
+      app
+      display
+      transaction = client.rewind(app)
+      display "+> undo...", false
+      loop_transaction
+      display "+> done"
+      display
+    end
+    alias :rollback :rewind
+    alias :undo :rewind
+    
+    def fast_forward
+      app
+      display
+      transaction = client.fast_forward(app)
+      display "+> redo...", false
+      loop_transaction
+      display "+> done"
+      display
+    end
+    alias :fastforward :fast_forward
+    alias :forward :fast_forward
+    alias :redo :fast_forward
+
+    protected
+    
+    def pair_with_remote(app)
+      my_app_list = read_apps
+      current_root = locate_app_root
+      in_list = false
+      my_app_list.each do |app_str|
+        app_arr = app_str.split(" ")
+        if app[:git_url] == app_arr[1] && app[:name] == app_arr[0] || app_arr[2] == current_root
+          in_list = true
+        end
+      end
+      unless in_list
+        add_app app[:name]
+      end
+    end
+    
+    
+  end
+end