pagoda 0.3.2 → 0.5.0

data/lib/pagoda/client.rb

@@ -1,225 +0,0 @@
-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_database_create(app)
-    response = post("/apps/#{app}/databases.xml", {:mysql_instance => {:ram => 10}})
-  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

@@ -1,96 +0,0 @@
-require 'pagoda/helpers'
-require 'pagoda/tunnel_proxy'
-require 'pagoda/commands/base'
-require 'pagoda/commands/auth'
-require 'pagoda/commands/app'
-require 'pagoda/commands/db'
-require 'pagoda/commands/help'
-require 'pagoda/commands/tunnel'
-
-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

@@ -1,247 +0,0 @@
-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
-      
-      if option_value(nil, "--with-mysql")
-        Pagoda::Command.run_internal("db:create", 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 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