pagoda 0.1.0

data/lib/pagoda/commands/auth.rb

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,184 @@
+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:.+\.git$/)
+          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/help.rb

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,49 @@
+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/helpers.rb

@@ -0,0 +1,127 @@
+require 'crack'
+
+module Pagoda
+  module Helpers
+    INDENT = "  "
+    
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+
+    def display(msg="", newline=true, level=1)
+      indent = build_indent(level)
+      if newline
+        puts("#{indent}#{msg}")
+      else
+        print("#{indent}#{msg}")
+        STDOUT.flush
+      end
+    end
+    
+    def option_value(short_hand = nil, long_hand = nil)
+      match = false
+      value = nil
+      
+      if short_hand
+        if args.include?(short_hand)
+          value = args[args.index(short_hand) + 1]
+          match = true
+        end
+      end
+      if long_hand && !match
+        if match = args.grep(/#{long_hand}.*/).first
+          if match.include? "="
+            value = match.split("=").last
+          else
+            value = true
+          end
+        end
+      end
+      
+      value
+    end
+
+    def format_date(date)
+      date = Time.parse(date) if date.is_a?(String)
+      date.strftime("%Y-%m-%d %H:%M %Z")
+    end
+
+    def ask(message=nil, level=1)
+      display("#{message}", false, level) if message
+      gets.strip
+    end
+    
+    def confirm(message="Are you sure you wish to continue? (y/n)?", level=1)
+      return true if args.include? "-f"
+      case message
+      when Array
+        count = message.length
+        iteration = 0
+        message.each do |m|
+          if iteration == count - 1
+            display("#{m} ", false, level)
+          else
+            display("#{m} ", true, level)
+          end
+          iteration += 1
+        end
+      when String
+        display("#{message} ", false, level)
+      end
+      ask.downcase == 'y'
+    end
+
+    def error(msg, exit=true, level=1)
+      indent = build_indent(level)
+      STDERR.puts
+      case msg
+      when Array
+        STDERR.puts("#{indent}** Error:")
+        msg.each do |m|
+          STDERR.puts("#{indent}** #{m}")
+        end
+      when String
+        STDERR.puts("#{indent}** Error: #{msg}")
+      end
+      STDERR.puts
+      exit 1 if exit
+    end
+    
+    def loop_transaction(app_name = nil)
+      finished = false
+      until finished
+        display ".", false, 0
+        sleep 1
+        if client.app_info(app_name || app)[:transactions].count < 1
+          finished = true
+          display
+        end
+      end
+    end
+    
+    def build_indent(level=1)
+      indent = ""
+      level.times do
+        indent += INDENT
+      end
+      indent
+    end
+    
+  end
+end
+
+unless String.method_defined?(:shellescape)
+  class String
+    def shellescape
+      empty? ? "''" : gsub(/([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\\\\1').gsub(/\n/, "'\n'")
+    end
+  end
+end