startapp 0.1.6

data/lib/rhc/commands/show.rb

@@ -0,0 +1,43 @@
+require 'rhc/commands/app'
+
+module RHC::Commands
+  class Show < App
+
+    summary "Show information about an application"
+    description <<-DESC
+      Display the properties of an application, including its URL, the SSH
+      connection string, and the Git remote URL.  Will also display any
+      cartridges, their scale, and any values they expose.
+
+      The '--state' option will retrieve information from each cartridge in
+      the application, which may include cartridge specific text.
+
+      The '--configuration' option will display configuration values set in
+      the application. Use 'rhc configure-app' to configure.
+
+      To see information about the individual gears within an application,
+      use '--gears', including whether they are started or stopped and their
+      SSH host strings.  Passing '--gears quota' will show the free and maximum
+      storage on each gear.
+
+      If you want to run commands against individual gears, use:
+
+        rhc ssh <app> --gears '<command>'
+
+      to run and display the output from each gear.
+
+      DESC
+    syntax "<app> [--namespace NAME]"
+    takes_application :argument => true
+    option ["--state"], "Get the current state of the cartridges in this application"
+    option ["--configuration"], "Get the current configuration values set in this application"
+    option ["--gears [quota|ssh]"], "Show information about the cartridges on each gear in this application. Pass 'quota' to see per gear disk usage and limits. Pass 'ssh' to print only the SSH connection strings of each gear."
+
+    def run(app_name)
+      self.class.superclass.instance_method(:show).bind(self).call app_name
+
+      0
+    end
+
+  end
+end

data/lib/rhc/commands/snapshot.rb

@@ -0,0 +1,137 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Snapshot < Base
+    summary "Save the current state of your application locally"
+    syntax "<action>"
+    description <<-DESC
+      Snapshots allow you to export the current state of your OpenShift application
+      into an archive on your local system, and then to restore it later.
+
+      The snapshot archive contains the Git repository, dumps of any attached databases,
+      and any other information that the cartridges decide to export.
+
+      WARNING: Both 'save' and 'restore' will stop the application and then restart
+      after the operation completes.
+      DESC
+    alias_action :"app snapshot", :root_command => true
+    default_action :help
+
+    summary "Save a snapshot of your app to disk"
+    syntax "<application> [--filepath FILE] [--ssh path_to_ssh_executable]"
+    takes_application :argument => true
+    option ["-f", "--filepath FILE"], "Local path to save tarball (default: ./$APPNAME.tar.gz)"
+    option ["--deployment"], "Snapshot as a deployable file which can be deployed with 'rhc deploy'"
+    option ["--ssh PATH"], "Full path to your SSH executable with additional options"
+    alias_action :"app snapshot save", :root_command => true, :deprecated => true
+    def save(app)
+      ssh = check_ssh_executable! options.ssh
+      rest_app = find_app
+
+      raise RHC::DeploymentsNotSupportedException.new if options.deployment && !rest_app.supports?("DEPLOY")
+
+      ssh_uri = URI.parse(rest_app.ssh_url)
+      filename = options.filepath ? options.filepath : "#{rest_app.name}.tar.gz"
+
+      snapshot_cmd = options.deployment ? 'gear archive-deployment' : 'snapshot'
+      ssh_cmd = "#{ssh} #{ssh_uri.user}@#{ssh_uri.host} '#{snapshot_cmd}' > #{filename}"
+      debug ssh_cmd
+
+      say "Pulling down a snapshot to #{filename}..."
+
+      begin
+        if !RHC::Helpers.windows?
+          status, output = exec(ssh_cmd)
+          if status != 0
+            debug output
+            raise RHC::SnapshotSaveException.new "Error in trying to save snapshot. You can try to save manually by running:\n#{ssh_cmd}"
+          end
+        else
+          Net::SSH.start(ssh_uri.host, ssh_uri.user) do |ssh|
+            File.open(filename, 'wb') do |file|
+              ssh.exec! "snapshot" do |channel, stream, data|
+                if stream == :stdout
+                  file.write(data)
+                else
+                  debug data
+                end
+              end
+            end
+          end
+        end
+      rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+        debug e.backtrace
+        raise RHC::SnapshotSaveException.new "Error in trying to save snapshot. You can try to save manually by running:\n#{ssh_cmd}"
+      end
+      results { say "Success" }
+      0
+    end
+
+    summary "Restores a previously saved snapshot"
+    syntax "<application> [--filepath FILE] [--ssh path_to_ssh_executable]"
+    takes_application :argument => true
+    option ["-f", "--filepath FILE"], "Local path to restore tarball"
+    option ["--ssh PATH"], "Full path to your SSH executable with additional options"
+    alias_action :"app snapshot restore", :root_command => true, :deprecated => true
+    def restore(app)
+      ssh = check_ssh_executable! options.ssh
+      rest_app = find_app
+      filename = options.filepath ? options.filepath : "#{rest_app.name}.tar.gz"
+
+      if File.exists? filename
+
+        include_git = RHC::Helpers.windows? ? true : RHC::TarGz.contains(filename, './*/git')
+        ssh_uri = URI.parse(rest_app.ssh_url)
+
+        ssh_cmd = "cat '#{filename}' | #{ssh} #{ssh_uri.user}@#{ssh_uri.host} 'restore#{include_git ? ' INCLUDE_GIT' : ''}'"
+
+        say "Restoring from snapshot #{filename}..."
+        debug ssh_cmd
+
+        begin
+          if !RHC::Helpers.windows?
+            status, output = exec(ssh_cmd)
+            if status != 0
+              debug output
+              raise RHC::SnapshotRestoreException.new "Error in trying to restore snapshot. You can try to restore manually by running:\n#{ssh_cmd}"
+            end
+          else
+            ssh = Net::SSH.start(ssh_uri.host, ssh_uri.user)
+            ssh.open_channel do |channel|
+              channel.exec("restore#{include_git ? ' INCLUDE_GIT' : ''}") do |ch, success|
+                channel.on_data do |ch, data|
+                  say data
+                end
+                channel.on_extended_data do |ch, type, data|
+                  say data
+                end
+                channel.on_close do |ch|
+                  say "Terminating..."
+                end
+                File.open(filename, 'rb') do |file|
+                  file.chunk(1024) do |chunk|
+                    channel.send_data chunk
+                  end
+                end
+                channel.eof!
+              end
+            end
+            ssh.loop
+          end
+        rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+          debug e.backtrace
+          raise RHC::SnapshotRestoreException.new "Error in trying to restore snapshot. You can try to restore manually by running:\n#{ssh_cmd}"
+        end
+
+      else
+        raise RHC::SnapshotRestoreException.new "Archive not found: #{filename}"
+      end
+      results { say "Success" }
+      0
+    end
+
+    protected
+      include RHC::SSHHelpers
+
+  end
+end

data/lib/rhc/commands/ssh.rb

@@ -0,0 +1,51 @@
+require 'rhc/commands/base'
+require 'resolv'
+require 'rhc/git_helpers'
+require 'rhc/cartridge_helpers'
+
+module RHC::Commands
+  class Ssh < Base
+    suppress_wizard
+
+    summary "SSH into the specified application"
+    description <<-DESC
+      Connect to your application using SSH.  This will connect to your primary gear
+      (the one with your Git repository and web cartridge) by default.  To SSH to
+      other gears run 'rhc show-app --gears' to get a list of their SSH hosts.
+
+      You may run a specific SSH command by passing one or more arguments, or use a
+      different SSH executable or pass options to SSH with the '--ssh' option.
+      DESC
+    syntax "[--ssh path_to_ssh_executable] [--gears] [<app> --] <command>"
+    takes_application :argument => true
+    argument :command, "Command to run in the application's SSH session", ['--command COMMAND'], :type => :list, :optional => true
+    option ["--ssh PATH"], "Path to your SSH executable or additional options"
+    option ["--gears"], "Execute this command on all gears in the app.  Requires a command."
+    option ["--limit INTEGER"], "Limit the number of simultaneous SSH connections opened with --gears (default: 5).", :type => Integer, :default => 5
+    option ["--raw"], "Output only the data returned by each host, no hostname prefix."
+    alias_action 'app ssh', :root_command => true
+    def run(_, command)
+      raise ArgumentError, "--gears requires a command" if options.gears && command.blank?
+      raise ArgumentError, "--limit must be an integer greater than zero" if options.limit && options.limit < 1
+
+      ssh = check_ssh_executable! options.ssh
+
+      if options.gears
+        run_on_gears(command.join(' '), find_app(:with_gear_groups => true))
+        0
+      else
+        rest_app = find_app
+        $stderr.puts "Connecting to #{rest_app.ssh_string.to_s} ..." unless command.present?
+
+        debug "Using user specified SSH: #{options.ssh}" if options.ssh
+
+        command_line = [ ssh.split, rest_app.ssh_string.to_s, command].flatten.compact
+        debug "Invoking Kernel.exec with #{command_line.inspect}"
+        Kernel.send(:exec, *command_line)
+      end
+    end
+
+    protected
+      include RHC::SSHHelpers
+  end
+end

data/lib/rhc/commands/sshkey.rb

@@ -0,0 +1,97 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Sshkey < Base
+    include RHC::SSHHelpers
+
+    summary 'Add and remove keys for Git and SSH'
+    syntax '<action>'
+    description <<-DESC
+      OpenShift uses public keys to securely access your application source
+      code and to control access to your application gears via SSH.  Your
+      account may have one or more public SSH keys associated with it, and
+      any computer with the private SSH key will be able to download code
+      from Git or SSH to the application.
+
+      Depending on your operating system, you may have to ensure that both
+      Git and the local SSH installation have access to your keys.  Running
+      the 'setup' command is any easy way to get your first key created and
+      uploaded.
+      DESC
+    default_action :list
+
+    summary 'Display all the SSH keys for your account'
+    syntax ''
+    def list
+      keys = rest_client.sshkeys.each{ |key| paragraph{ display_key(key) } }
+
+      success "You have #{keys.length} SSH keys associated with your account."
+
+      0
+    end
+
+    summary 'Show the SSH key with the given name'
+    syntax '<name>'
+    argument :name, 'SSH key to display', []
+    def show(name)
+      key = rest_client.find_key(name)
+      display_key(key)
+
+      0
+    end
+
+    summary 'Add SSH key to your account'
+    syntax '<name> <path to SSH key file>'
+    argument :name, 'Name for this key', []
+    argument :key, 'SSH public key filepath', [], :optional => true
+    option ['--confirm'], 'Bypass key validation'
+    option ['--type TYPE'], 'Provide the key type directly if no key file is given'
+    option ['--content CONTENT'], 'Provide the key content directly if no key file is given'
+    def add(name, key_path=nil)
+
+      if key_path
+        type, content, comment = ssh_key_triple_for(key_path)
+      elsif options[:type].present? and options[:content].present?
+        type = options[:type]
+        content = options[:content]
+      else
+       raise ArgumentError, "You must either provide a key file, or the key type and content"
+      end
+
+      if type == 'krb5-principal'
+        # TODO: validate krb5?
+      else
+        # validate the user input before sending it to the server
+        begin
+          Net::SSH::KeyFactory.load_data_public_key "#{type} #{content}"
+        rescue NotImplementedError, OpenSSL::PKey::PKeyError, Net::SSH::Exception => e
+          debug e.inspect
+          if options.confirm
+            warn 'The key you are uploading is not recognized.  You may not be able to authenticate to your application through Git or SSH.'
+          else
+            raise ::RHC::KeyDataInvalidException.new("File '#{key_path}' does not appear to be a recognizable key file (#{e}). You may specify the '--confirm' flag to add the key anyway.") if key_path
+            raise ::RHC::KeyDataInvalidException.new("The provided type and content does not appear to be a recognizable key (#{e}). You may specify the '--confirm' flag to add the key anyway.")
+          end
+        end
+      end
+
+      rest_client.add_key(name, content, type)
+      results { say key_path ? "SSH key #{key_path} has been added as '#{name}'" : "SSH key '#{name}' has been added" }
+
+      0
+    end
+
+    summary 'Remove SSH key from your account'
+    syntax '<name>'
+    alias_action :delete, :deprecated => true
+    argument :name, 'Name of SSH key to remove'
+    def remove(name)
+      say "Removing the key '#{name} ... "
+      rest_client.delete_key(name)
+
+      success "removed"
+
+      0
+    end
+  end
+end

data/lib/rhc/commands/start.rb

@@ -0,0 +1,17 @@
+require 'rhc/commands/app'
+
+module RHC::Commands
+  class Start < App
+
+    summary "Start the application"
+    syntax "<app> [--namespace NAME]"
+    takes_application :argument => true
+
+    def run(app)
+      self.class.superclass.instance_method(:start).bind(self).call app
+
+      0
+    end
+
+  end
+end

data/lib/rhc/commands/stop.rb

@@ -0,0 +1,17 @@
+require 'rhc/commands/app'
+
+module RHC::Commands
+  class Stop < App
+
+    summary "Stop the application"
+    syntax "<app> [--namespace NAME]"
+    takes_application :argument => true
+
+    def run(app)
+      self.class.superclass.instance_method(:stop).bind(self).call app
+
+      0
+    end
+
+  end
+end

data/lib/rhc/commands/tail.rb

@@ -0,0 +1,47 @@
+require 'rhc/commands/base'
+require 'rhc/config'
+require 'rhc/ssh_helpers'
+
+module RHC::Commands
+  class Tail < Base
+    include RHC::SSHHelpers
+
+    summary "Tail the logs of an application"
+    syntax "<application>"
+    takes_application :argument => true
+    option ["-o", "--opts options"], "Options to pass to the server-side (linux based) tail command (applicable to tail command only) (-f is implicit.  See the linux tail man page full list of options.) (Ex: --opts '-n 100')"
+    option ["-f", "--files files"], "File glob relative to app (default <application_name>/logs/*) (optional)"
+    option ["-g", "--gear ID"], "Tail only a specific gear"
+    #option ["-c", "--cartridge name"], "Tail only a specific cartridge"
+    alias_action :"app tail", :root_command => true, :deprecated => true
+    def run(app_name)
+      rest_app = find_app(:include => :cartridges)
+      ssh_url = options.gear ? rest_app.gear_ssh_url(options.gear) : rest_app.ssh_url
+
+      tail('*', URI(ssh_url), options)
+
+      0
+    end
+
+    private
+      #Application log file tailing
+      def tail(cartridge_name, ssh_url, options)
+        debug "Tail in progress for cartridge #{cartridge_name}"
+
+        host = ssh_url.host
+        uuid = ssh_url.user
+
+        file_glob = options.files ? options.files : "#{cartridge_name}/log*/*"
+        remote_cmd = "tail#{options.opts ? ' --opts ' + Base64::encode64(options.opts).chomp : ''} #{file_glob}"
+        ssh_cmd = "ssh -t #{uuid}@#{host} '#{remote_cmd}'"
+        begin
+          #Use ssh -t to tail the logs
+          debug ssh_cmd
+          ssh_ruby(host, uuid, remote_cmd, false, true)
+        rescue
+          warn "You can tail this application directly with:\n#{ssh_cmd}"
+          raise
+        end
+      end
+  end
+end

data/lib/rhc/commands/threaddump.rb

@@ -0,0 +1,14 @@
+require 'rhc/commands/base'
+module RHC::Commands
+  class Threaddump < Base
+    summary "Trigger a thread dump for JBoss and Ruby apps"
+    syntax "<application>"
+    takes_application :argument => true
+    def run(app)
+      rest_app = find_app
+      rest_app.threaddump.messages.each { |m| say m }
+
+      0
+    end
+  end
+end

data/lib/rhc/commands/tidy.rb

@@ -0,0 +1,17 @@
+require 'rhc/commands/app'
+
+module RHC::Commands
+  class Tidy < App
+
+    summary "Clean out the application's logs and tmp directories and tidy up the git repo on the server"
+    syntax "<app> [--namespace NAME]"
+    takes_application :argument => true
+
+    def run(app)
+      self.class.superclass.instance_method(:tidy).bind(self).call app
+
+      0
+    end
+
+  end
+end