pagoda 0.3.2 → 0.5.0

data/lib/pagoda/commands/auth.rb

@@ -1,149 +0,0 @@
-module Pagoda::Command
-  class Auth < Base
-    attr_accessor :credentials
-
-    def initialize(args)
-      @args = args
-      check_for_credentials
-    end
-
-
-    def client
-      @client ||= init_client
-    end
-
-    def init_client
-      client = Pagoda::Client.new(user, password)
-      client.on_warning { |message| self.display("\n#{message}\n\n") }
-      client
-    end
-
-    # just a stub; will raise if not authenticated
-    def check
-      client.app_list
-    end
-
-    def check_for_credentials
-      if option_value("-u", "--username") && option_value("-p", "--password")
-        reauthorize
-      end
-    end
-    
-    def reauthorize
-      @credentials = ask_for_credentials
-      write_credentials
-    end
-
-    def user # :nodoc:
-      get_credentials
-      @credentials[0]
-    end
-
-    def password # :nodoc:
-      get_credentials
-      @credentials[1]
-    end
-    
-    def credentials_file
-      "#{home_directory}/.pagoda/credentials"
-    end
-
-    def get_credentials # :nodoc:
-      return if @credentials
-      unless @credentials = read_credentials
-        @credentials = ask_for_credentials
-        save_credentials
-      end
-      @credentials
-    end
-
-    def read_credentials
-      File.exists?(credentials_file) and File.read(credentials_file).split("\n")
-    end
-
-    def echo_off
-      system "stty -echo"
-    end
-
-    def echo_on
-      system "stty echo"
-    end
-
-    def ask_for_credentials
-      unless username = option_value("-u", "--username")
-        username = ask "Username: "
-      end
-      unless password = option_value("-p", "--password")
-        display "Password: ", false
-        password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
-      end
-      [username, password] # return
-    end
-
-    def ask_for_password
-      echo_off
-      password = ask
-      puts
-      echo_on
-      return password
-    end
-
-    def ask_for_password_on_windows
-      require "Win32API"
-      char = nil
-      password = ''
-      
-      while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
-        break if char == 10 || char == 13 # received carriage return or newline
-        if char == 127 || char == 8 # backspace and delete
-          password.slice!(-1, 1)
-        else
-          # windows might throw a -1 at us so make sure to handle RangeError
-          (password << char.chr) rescue RangeError
-        end
-      end
-      return password
-    end
-
-    def save_credentials
-      begin
-        write_credentials
-        Pagoda::Command.run_internal('auth:check', args)
-      rescue RestClient::Unauthorized => e
-        delete_credentials
-        raise e unless retry_login?
-
-        error "Authentication failed"
-        @credentials = ask_for_credentials
-        @client = init_client
-        retry
-      rescue Exception => e
-        delete_credentials
-        raise e
-      end
-    end
-
-    def retry_login?
-      @login_attempts ||= 0
-      @login_attempts += 1
-      @login_attempts < 3
-    end
-
-    def write_credentials
-      FileUtils.mkdir_p(File.dirname(credentials_file))
-      File.open(credentials_file, 'w') do |file|
-        file.puts self.credentials
-      end
-      set_credentials_permissions
-    end
-
-    def set_credentials_permissions
-      FileUtils.chmod 0700, File.dirname(credentials_file)
-      FileUtils.chmod 0600, credentials_file
-    end
-
-    def delete_credentials
-      FileUtils.rm_f(credentials_file)
-    end
-  end
-end

data/lib/pagoda/commands/base.rb

@@ -1,184 +0,0 @@
-require 'iniparse'
-
-module Pagoda
-  module Command
-    class Base
-      include Pagoda::Helpers
-
-      attr_accessor :args
-      
-      def initialize(args)
-        @args = args
-      end
-      
-      def client
-        @client ||= Pagoda::Command.run_internal('auth:client', args)
-      end
-
-      def shell(cmd)
-        FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
-      end
-      
-      def app(soft_fail=false)
-        if override = option_value("-a", "--app")
-          return override
-        else
-          if name = find_app
-            return name
-          else
-            if locate_app_root
-              if extract_git_clone_url
-                return false if soft_fail
-                errors = []
-                errors << "This repo is either not launched, or not paired with a launched app"
-                errors << ""
-                errors << "To launch this app run 'pagoda launch <app-name>'"
-                errors << ""
-                errors << "To pair this project with a deployed app, run 'pagoda pair <app-name>'"
-                errors << ""
-                errors << "To see a list of currently deployed apps, run 'pagoda list'"
-                error errors
-              else
-                return false if soft_fail
-                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."
-                errors << ""
-                errors << "If you are trying to reference a specific app, try argument: -a <app-name>"
-                error errors
-              end
-            else
-              return false if soft_fail
-              errors = []
-              errors << "Unable to find git config in this directory or in any parent directory"
-              errors << ""
-              errors << "If you are trying to reference a specific app, try argument: -a <app-name>"
-              error errors
-            end
-          end
-        end
-        name
-      end
-      
-      def parse_branch
-        option_value("-b", "--branch") || find_branch
-      end
-      
-      def parse_commit
-        option_value("-c", "--commit") || find_commit
-      end
-      
-      def find_app
-        read_apps.each do |line|
-          app = line.split(" ")
-          return app[0] if app[2] == locate_app_root
-        end
-        false
-      end
-
-      def find_branch
-        begin
-          line = File.new("#{locate_app_root}/.git/HEAD").gets
-          line.strip.split(' ').last.split("/").last
-        rescue
-          nil
-        end
-      end
-      
-      def find_commit
-        begin
-          File.new("#{locate_app_root}/.git/refs/heads/#{parse_branch}").gets.strip
-        rescue 
-          nil
-        end
-      end
-      
-      def read_apps
-        return [] if !File.exists?(apps_file)
-        File.read(apps_file).split(/\n/).inject([]) {|apps, line| apps << line if line.include?("git@github.com"); apps}
-      end
-      
-      def write_app(name, git_url=nil, app_root=nil)
-        git_url = extract_git_clone_url unless git_url
-        app_root = locate_app_root unless app_root
-        FileUtils.mkdir_p(File.dirname(apps_file)) if !File.exists?(apps_file)
-        current_apps = read_apps
-        File.open(apps_file, 'w') do |file|
-          current_apps.each do |app|
-            file.puts app
-          end
-          file.puts "#{name} #{git_url} #{app_root}"
-        end
-        set_apps_file_permissions
-      end
-      alias :add_app :write_app
-      
-      def remove_app(name)
-        current_apps = read_apps
-        current_apps.delete_if do |app|
-          app.split(" ")[0] == name
-        end
-        File.open(apps_file, 'w') do |file|
-          current_apps.each do |app|
-            file.puts app
-          end
-        end
-      end
-      
-      def set_apps_file_permissions
-        FileUtils.chmod 0700, File.dirname(apps_file)
-        FileUtils.chmod 0600, apps_file
-      end
-      
-      def apps_file
-        "#{home_directory}/.pagoda/apps"
-      end
-      
-      def extract_possible_name
-        cleanup_name(extract_git_clone_url.split(":")[1].split("/")[1].split(".")[0])
-      end
-      
-      def cleanup_name(name)
-        name.gsub(/-/, '').gsub(/_/, '').gsub(/ /, '').downcase
-      end
-      
-      def extract_git_clone_url(soft=false)
-        begin
-          url = IniParse.parse( File.read("#{locate_app_root}/.git/config") )['remote "origin"']["url"]
-          raise unless url.match(/^((git@github.com:)|(.*:)|((http|https):\/\/.*github.com\/)|(git:\/\/github.com\/))(.*)\/(.*).git$/i)
-          url
-        rescue Exception => e
-          return false
-        end
-      end
-      
-      def version
-        display Client.gem_version_string
-      end
-
-      def locate_app_root(dir=Dir.pwd)
-        return dir if File.exists? "#{dir}/.git/config"
-        parent = dir.split('/')[0..-2].join('/')
-        return false if parent.empty?
-        locate_app_root(parent)
-      end
-
-      def extract_option(options, default=true)
-        values = options.is_a?(Array) ? options : [options]
-        return unless opt_index = args.select { |a| values.include? a }.first
-        opt_position = args.index(opt_index) + 1
-        if args.size > opt_position && opt_value = args[opt_position]
-          if opt_value.include?('--')
-            opt_value = nil
-          else
-            args.delete_at(opt_position)
-          end
-        end
-        opt_value ||= default
-        args.delete(opt_index)
-        block_given? ? yield(opt_value) : opt_value
-      end
-    end
-  end
-end

data/lib/pagoda/commands/db.rb

@@ -1,18 +0,0 @@
-module Pagoda::Command
-  class Db < Base
-
-    def create
-      app
-      display
-      client.app_database_create(app)
-      display "+> creating a sql database on pagodabox...", false
-      loop_transaction
-      display "+> created"
-      display
-    end
-
-
-
-
-  end
-end

data/lib/pagoda/commands/help.rb

@@ -1,100 +0,0 @@
-module Pagoda::Command
-  class Help < Base
-    def index
-      display %{
-Pagoda
-
-NAME
-     pagoda -- command line utility for pagodabox.com
-
-SYNOPSIS
-     pagoda [command] [parameters]
-
-DESCRIPTION
-
-     If no operands are given, we will attempt to pull data from the current
-     directory. If more than one operand is given, non-directory operands are
-     displayed first.
-
-     The following options are available:
-
-COMMANDS
-
-    list          # list your apps
-    deploy        # Deploy your current state to pagoda
-    launch <name> # create (register) a new app
-    info          # display info about an app
-    destroy       # remove app
-    rollback      # rollback app
-    tunnel        # create a tunnel to your database on pagoda
-
-
-PARAMETERS
-
-     ---------------------------
-     GLOBAL :
-     ---------------------------
-     -a <name> | --app=<name>
-           Set the application name (Only necessary when not in repo dir).
-
-     -u <username> | --username=<username>
-           When set, will not attempt to save your username. Also over-rides
-           any saved username.
-
-     -p <password> | --password=<password>
-           When set, will not attempt to save your password. Also over-rides
-           any saved password.
-
-     -f
-           Executes all commands without confirmation request.
-
-     ---------------------------
-     DEPLOYING - pagoda deploy :
-     ---------------------------
-     -b <branch> | --branch=<branch>
-           Specify the branch name. By default uses the branch
-           your local repo is on.
-
-     -c <commit> | --commit=<commit>
-           Specify the commit id. By default uses the commit HEAD is set to.
-
-     --latest
-           Will attempt to deploy to the latest commit on github rather than
-           your local repo's current commit.
-
-     ---------------------------
-     TUNNELING - pagoda tunnel :
-     ---------------------------
-
-     -t <type> | --type=<type>
-           Specify the tunnel type. (ex:mysql)
-
-     -n <instance> | --name=<instance>
-           Specify the instance name you want to operate on used for
-           database instance
-
-
-EXAMPLES
-     launch an application on pagoda from inside the clone folder:
-     (must be done inside your repo folder)
-         pagoda launch <app name>
-
-     list your applications:
-
-         pagoda list
-
-     create tunnel to your database:
-     (must be inside your repo folder or specify app)
-
-         pagoda tunnel -a <app name> -t mysql -n <database name>
-
-     destroy an application:
-     (must be inside your repo folder or specify app)
-
-         pagoda destroy
-
-        
-      }
-    end
-  end
-end

data/lib/pagoda/commands/tunnel.rb

@@ -1,49 +0,0 @@
-module Pagoda::Command
-  class Tunnel < Auth
-
-    def index
-      app
-      type = option_value("-t", "--type") || 'mysql'
-      Pagoda::Command.run_internal("tunnel:#{type}", args)
-    end
-
-    def mysql
-      instance_name = option_value("-n", "--name")
-      unless instance_name
-        # try to find mysql instances here
-        dbs = client.app_databases(app)
-        if dbs.length == 0
-          errors = []
-          errors << "It looks like you don't have any MySQL instances for #{app}"
-          errors << "Feel free to add one in the admin panel (10 MB Free)"
-          error errors
-        elsif dbs.length == 1  
-          instance_name = dbs.first[:name]
-        else
-          errors = []
-          errors << "Multiple MySQL instances found"
-          errors << ""
-          dbs.each do |instance|
-            errors << "-> #{instance[:name]}"
-          end
-          errors << ""
-          errors << "Please specify which instance you would like to use."
-          errors << ""
-          errors << "ex: pagoda tunnel -n #{dbs[0][:name]}"
-          error errors
-        end
-      end
-      display
-      display "+> Authenticating Database Ownership"
-      
-      if client.database_exists?(app, instance_name)
-        Pagoda::TunnelProxy.new(:mysql, user, password, app, instance_name).start
-      else
-        errors = []
-        errors << "Security exception -"
-        errors << "Either the MySQL instance doesn't exist or you are unauthorized"
-        error errors
-      end
-    end
-  end
-end

data/lib/pagoda/tunnel_proxy.rb

@@ -1,130 +0,0 @@
-require "socket"
-require 'openssl'  
-
-module Pagoda
-  class TunnelProxy
-    include Pagoda::Helpers
-    
-    def initialize(type, user, pass, app, instance)
-      @type     = type
-      @user     = user
-      @pass     = pass
-      @app      = app
-      @instance = instance 
-    end
-    
-    def start
-      
-      [:INT, :TERM].each do |sig|
-        Signal.trap(sig) do
-          display "Tunnel Closed."
-          display "-----------------------------------------------"
-          display
-          exit
-        end
-      end
-      
-      local_port   = 3307
-      remote_host = "www.pagodabox.com"
-      remote_port = 3306
-
-      max_threads     = 20
-      threads         = []
-
-      chunk           = 4096*4096
-
-      #puts "start TCP server"
-      display "+> Opening Tunnel"
-      bound = false
-      until bound
-        begin
-          proxy_server = TCPServer.new('0.0.0.0', local_port)
-          bound = true
-        rescue Errno::EADDRINUSE
-          local_port += 1
-        end
-      end
-      
-      display
-      display "Tunnel Established!  Accepting connections on :"
-      display "-----------------------------------------------"
-      display
-      display "HOST : 127.0.0.1 (or localhost)", true, 2
-      display "PORT : #{local_port}", true, 2
-      display "USER : (found in pagodabox dashboard)", true, 2
-      display "PASS : (found in pagodabox dashboard)", true, 2
-      display
-      display "-----------------------------------------------"
-      display "(note : ctrl-c To close this tunnel)"
-      
-      loop do
-
-        #puts "start a new thread for every client connection"
-        threads << Thread.new(proxy_server.accept) do |client_socket|
-
-          begin
-            # puts "client connection"
-            begin
-              server_socket         = TCPSocket.new(remote_host, remote_port)
-              ssl_context           = OpenSSL::SSL::SSLContext.new()  
-              ssl_socket            = OpenSSL::SSL::SSLSocket.new(server_socket, ssl_context)  
-              ssl_socket.sync_close = true  
-              ssl_socket.connect
-            rescue Errno::ECONNREFUSED
-              # puts "connection refused"
-              client_socket.close
-              raise
-            end
-
-            # puts "authenticate"
-            if ssl_socket.readpartial(chunk) == "auth"
-              # puts "authentication"
-              ssl_socket.write "auth=#{@user}:#{@pass}:#{@app}:#{@instance}" 
-              if ssl_socket.readpartial(chunk) == "success"
-                # puts "successful connection"
-              else
-                # puts "failed connection"
-              end
-            else
-              # puts "danger will robbinson! abort!"
-            end
-
-            loop do
-              # puts "wait for data on either socket"
-              (ready_sockets, dummy, dummy) = IO.select([client_socket, ssl_socket])
-
-              # puts "full duplex connection until data stream ends"
-              begin
-                ready_sockets.each do |socket|
-                  data = socket.readpartial(chunk)
-                  if socket == client_socket
-                    #puts "read from client and write to server"
-                    ssl_socket.write data
-                    ssl_socket.flush
-                  else
-                    #puts "read from server and write to client."
-                    client_socket.write data
-                    client_socket.flush
-                  end
-                end
-              rescue EOFError
-                break
-              end
-            end
-
-          rescue StandardError => error
-          end
-          client_socket.close rescue StandardError
-          ssl_socket.close rescue StandardError
-        end
-
-        #puts "clean up the dead threads, and wait until we have available threads"
-        threads = threads.select { |thread| thread.alive? ? true : (thread.join; false) }
-        while threads.size >= max_threads
-          sleep 1
-          threads = threads.select { |thread| thread.alive? ? true : (thread.join; false) }
-        end
-      end
-    end
-  end
-end

data/lib/pagoda/version.rb

@@ -1,3 +0,0 @@
-module Pagoda
-  VERSION = "0.3.2"
-end

data/lib/pagoda.rb

@@ -1,3 +0,0 @@
-module Pagoda
-  
-end

data/spec/base.rb

@@ -1,21 +0,0 @@
-require 'webmock/rspec'
-
-require 'pagoda/command'
-require 'pagoda/commands/base'
-
-Dir["#{File.dirname(__FILE__)}/../lib/pagoda/commands/*"].each { |c| require c }
-
-include WebMock::API
-
-def stub_api_request(method, path)
-  stub_request(method, "http://www.pagodabox.com#{path}")
-end
-
-def prepare_command(klass)
-  command = klass.new(['--app', 'myapp'])
-  command.stub!(:args).and_return([])
-  command.stub!(:display)
-  command.stub!(:pagoda).and_return(mock('pagoda client', :host => 'pagoda.com'))
-  command.stub!(:extract_app).and_return('myapp')
-  command
-end