cabal 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1911f5bc4c94b10fa7b62a071ae93dfdcbd66eec
-  data.tar.gz: 6d118c1dbecf0394f7197ca0a1c350ef09b2ee73
+  metadata.gz: 54c08e765a34142602ac7933207bd41adb423cbf
+  data.tar.gz: d66b1d6dab67a5d5c91be6732a7e00551cf499ba
 SHA512:
-  metadata.gz: 4777b7b6b3881852f0bdb365e35316f889e73e0ff86ba821d37fb8a178c401e87c56e6f3e6d3dc7ff3f5dfa0a497b6f22a9994597399000de31fdb5ae7abe8a9
-  data.tar.gz: e9a2f6cd1155d03a5c394b5ab2b6ff3d451fb1005d840325785cdfada262be305bffbcfb7ff7555e78ee8a8a1bc14bfff5886687a233134e56c6d68ee5fc5f99
+  metadata.gz: 6684c86512ddafaf29c7eb002dc87de2262f9c6e6a2b4bc3656cc3ba0a73acb4399485b0e8a17e8fb464300b56ff05ad4d4d2512ced8066b7d070ea142582060
+  data.tar.gz: e33cdbf4db6a8dc8fde6d86bb2093aa6c8e8e1b6596c96a8bebaaaee7f7a8655ba2a92a00b390db8a865eb492c03a3b5408258a2272ff13a3c21bd0830104be5

data/.travis.yml

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
   - 2.2.2
+

data/README.md

@@ -10,13 +10,13 @@ Cabal is a simple system for SSH key distribution and consumption. This is a CLI
 
 ## Usage ##
 
-To get started, you'll need to create `.cabal.yml` in your user's home directory, and you'll need to provide at least the URL of your Cabal::API. If you plan to use the `ssh` command to connect to a server that has an authorized Cabal key, you'll also need to specify your access key and secret key:
+To get started, you'll need to create `.cabal.yml` in your user's home directory, and you'll need to provide at least the URL of your Cabal::API. If you plan to use the `ssh` command to connect to a server that has an authorized Cabal key, you'll also need to specify your access token and secret token (provided by your Cabal::API administrator):
 
 ```yaml
 ---
 :url: http://your-cabal-hostname/path/to/the/api
-:access_key: your-access-key
-:secret_key: your-secret-key
+:access_key: your-access-token
+:secret_key: your-secret-token
 ```
 
 ### Getting Help ###
@@ -24,38 +24,43 @@ To get started, you'll need to create `.cabal.yml` in your user's home directory
 The `cabal` application provides some nicely-formatted help on the command line. To access the help, provided that you've created your `~/.cabal.yml`, run the following:
 
 ```
-cabal help
+cabal --help
 ```
 
 That will output something like this:
 
 ```
 NAME
-    cabal - An interface to the Cabal API
+  cabal - An interface to the Cabal API
 
 SYNOPSIS
-    cabal [global options] command [command options] [arguments...]
+  cabal command
 
-VERSION
-    0.2.0
-
-GLOBAL OPTIONS
-    --help    - Show this message
-    --version - Display the program version
+OPTIONS
+  -h, --help - Shows this message
 
 COMMANDS
-    help - Shows a list of commands or help for one command
-    key  - Get the public key for a cluster
-    ssh  - Connect to a node on a cluster
+  key - Get the public key for a cluster
+  ssh - Connect to a node on a cluster
 ```
 
-To get help on a specific command, you can `cabal help command` (ie `cabal help key`).
+To get help on a specific command, you can `cabal command --help` (ie `cabal key --help`).
 
-### Getting A Public Key ###
+### Listing Known Clusters ###
+
+***To learn more, check out `cabal list --help`***
+
+This is a privileged call, so you need an access key and a secret key in your configuration file.
 
-***To learn more, check out `cabal help key`***
+To get a list of the clusters that Cabal knows about, you'd do the following:
 
-This is an unprivileged call, so you won't actually need an access key or a secret key. This is more for somebody that wants to use the cabal cli utility to rather than curl or the like to grab a public key from the API to install as an authorized key on their servers.
+```
+cabal list
+```
+
+### Getting A Public Key ###
+
+***To learn more, check out `cabal key --help`***
 
 To get a public key for a cluster named "totallyarealcluster," you'd do the following:
 
@@ -72,9 +77,20 @@ cabal key Totally a real clusteR
 cabal key totallyarealcluster
 ```
 
+This command is an alternative to hitting the API endpoint via curl (or similar) to grab a public key, which might be used when installing an authorized key on a server. The following example would append the key for "totallyarealcluster" to the current user's authorized_keys file if it wasn't already present:
+
+```
+if ! grep -q totallyarealcluster ~/.ssh/authorized_keys
+then
+    cabal key totallyarealcluster >> ~/.ssh/authorized_keys
+fi
+```
+
+This is an unprivileged call, so you won't actually need an access key or a secret key. 
+
 ### Connecting To A Server ###
 
-***To learn more, check out `cabal help ssh`***
+***To learn more, check out `cabal ssh --help`***
 
 This is a privileged call, so you need an access key and a secret key in your configuration file.
 
@@ -91,6 +107,10 @@ This basically does the following:
 * Connects you to the server, forwarding your ssh-agent
 * Removes the key and **ALL** ssh-agent identities on disconnect
 
+By default, the forwarded ssh-agent will only have access to the private key for 30 minutes. To change this, you can use the `--lifetime` option to specify a different lifetime for your session.
+
+For tasks that may take a very long time (cluster upgrades, etc), you can pass a lifetime of `0` to keep the agent forwarding in place for the entirety of your session.
+
 ## Development ##
 
 Branches and releases for this project are managed by [git-flow](https://github.com/nvie/gitflow).

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'cucumber/rake/task'
+
+RSpec::Core::RakeTask.new
+Cucumber::Rake::Task.new
+
+task :default => [:spec, :cucumber]

data/cabal.gemspec

@@ -26,10 +26,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'factis', '~> 1.0'
   spec.add_development_dependency 'simplecov', '~> 0.10'
   spec.add_development_dependency 'webmock', '~> 1.22'
-  spec.add_development_dependency 'cabal-api', '~> 0.1'
+  spec.add_development_dependency 'toady', '~> 0.0'
 
   spec.add_runtime_dependency 'cabal-util', '~> 0.1'
-  spec.add_runtime_dependency 'gli', '~> 2.13'
+  spec.add_runtime_dependency 'belafonte', '~> 0.5'
   spec.add_runtime_dependency 'oj', '~> 2.12'
   spec.add_runtime_dependency 'faraday', '~> 0.9'
 end

data/exe/cabal

@@ -2,4 +2,4 @@
 
 require 'cabal/cli'
 
-exit Cabal::CLI.new(ARGV, STDIN, STDOUT, STDERR, Kernel).execute!
+exit Cabal::CLI::Main.new(ARGV, STDIN, STDOUT, STDERR, Kernel).execute!

data/lib/cabal.rb

@@ -3,6 +3,7 @@ require 'cabal/util'
 require 'cabal/client'
 require 'cabal/ssh'
 
+# A library and CLI application for working with servers configured to work
+# with Cabal::API
 module Cabal
-  # Your code goes here...
 end

data/lib/cabal/cli.rb

@@ -1,60 +1,50 @@
-require 'gli'
 require 'yaml'
 require 'cabal'
-require 'cabal/commands/key'
-require 'cabal/commands/ssh'
+require 'cabal/cli/ssh'
+require 'cabal/cli/key'
+require 'cabal/cli/list'
+require 'cabal/cli/main'
 
 module Cabal
-  class CLI
-    include GLI::App
+  # Bootstrap and configure the CLI application
+  module CLI
+    # The expected config file does not exist
+    NoConfig = Class.new(StandardError)
 
-    attr_reader :stdin, :stdout, :stderr, :kernel, :argv
+    # The config file does not contain a :url
+    NoURLDefinition = Class.new(StandardError)
 
-    def initialize(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel)
-      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
-    end
-
-    def register_command(command)
-      command.bootstrap(self)
-    end
+    # The config file does not contain :access_key and :secret_key
+    NoPrivateConfig = Class.new(StandardError)
 
-    def cabal_yml
-       File.expand_path(File.join(ENV['HOME'], '.cabal.yml'))
+    # Calculates the expected path of the Cabal config file
+    # @return [String] the config file path
+    def self.cabal_yml
+      File.expand_path(File.join(ENV['HOME'], '.cabal.yml'))
     end
 
-    def execute!
-      unless File.exist?(cabal_yml)
-        stderr.puts "Please create your config in #{cabal_yml}"
-        exit(1)
-      end
-
-      program_desc 'An interface to the Cabal API'
-      version Cabal::VERSION
-      subcommand_option_handling :normal
-      arguments :strict
-
-      pre do |global,command,options,args|
-        if File.exist?(cabal_yml)
-          config = YAML.load(File.read(cabal_yml))
-          global.merge!(config)
-          true
-        else
-          stderr.puts "Please create #{cabal_yml} and try again"
-          false
-        end
-      end
-
-      post do |global,command,options,args|
-      end
+    # Parses the config file and sets up the global configuration
+    # @return [nil]
+    def self.setup
+      if File.exist?(cabal_yml)
+        @config = YAML.load(File.read(cabal_yml))
 
-      on_error do |exception|
-        true
+        raise NoURLDefinition.new("#{cabal_yml} must contain a :url: definition") unless config[:url]
+      else
+        raise NoConfig.new("Please create #{cabal_yml} and try again")
       end
+    end
 
-      register_command(Cabal::Commands::Key)
-      register_command(Cabal::Commands::SSH)
+    # The global config for the CLI
+    # @return [Hash] the current configuration
+    def self.config
+      @config ||= {}
+    end
 
-      kernel.exit run(argv)
+    # Clears the global configuration
+    # @return [nil]
+    def self.reset
+      @config = {}
     end
   end
 end

data/lib/cabal/cli/authenticated.rb

@@ -0,0 +1,27 @@
+require 'belafonte'
+require 'cabal/cli'
+
+module Cabal
+  module CLI
+    module Authenticated
+      def with_authentication(config, &block)
+        begin
+          unless config[:access_key] && config[:secret_key]
+            raise Cabal::CLI::NoPrivateConfig
+          end
+
+          block.call
+
+        rescue Cabal::CLI::NoPrivateConfig
+          stderr.puts "You must have an access key and a secret key"
+        rescue Cabal::Client::UnauthorizedError
+          stderr.puts "You are not authorized to use the private API."
+          kernel.exit(1)
+        rescue Cabal::Client::NotFoundError
+          stderr.puts "The cluster '#{option(:cluster_name)}' does not exist."
+          kernel.exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/cabal/cli/key.rb

@@ -0,0 +1,18 @@
+require 'belafonte'
+require 'cabal/cli'
+
+module Cabal
+  module CLI
+    class Key < Belafonte::App
+      title 'key'
+      summary 'Get the public key for a cluster'
+
+      arg :cluster_name,
+        times: :unlimited
+
+      def handle
+        stdout.puts partake(:client).public_key(arg(:cluster_name).join(' '))
+      end
+    end
+  end
+end

data/lib/cabal/cli/list.rb

@@ -0,0 +1,24 @@
+require 'belafonte'
+require 'cabal/cli'
+require 'cabal/cli/authenticated'
+
+module Cabal
+  module CLI
+    class List < Belafonte::App
+      include Authenticated
+
+      title 'list'
+      summary 'List all known clusters'
+      description "Displays the list of all known clusters, one line at a time"
+
+      arg :cluster_name,
+        times: :unlimited
+
+      def handle
+        with_authentication(partake(:config)) do
+          stdout.puts partake(:client).clusters.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/cabal/cli/main.rb

@@ -0,0 +1,29 @@
+require 'cabal/cli/key'
+require 'cabal/cli/list'
+require 'cabal/cli/ssh'
+
+module Cabal
+  module CLI
+    class Main < Belafonte::App
+      title 'cabal'
+      summary 'An interface to the Cabal API'
+
+      mount Cabal::CLI::Key
+      mount Cabal::CLI::List
+      mount Cabal::CLI::SSH
+
+      def setup
+        Cabal::CLI.setup
+        config = Cabal::CLI.config
+        client = Cabal::Client.new(
+          api_base: config[:url],
+          access_key: config[:access_key],
+          secret_key: config[:secret_key]
+        )
+
+        share(:config, config)
+        share(:client, client)
+      end
+    end
+  end
+end

data/lib/cabal/cli/ssh.rb

@@ -0,0 +1,46 @@
+require 'belafonte'
+require 'cabal/cli'
+require 'cabal/cli/authenticated'
+require 'cabal/ssh'
+
+module Cabal
+  module CLI
+    class SSH < Belafonte::App
+      include Authenticated
+
+      title "ssh"
+      summary "Connect to a node on a cluster"
+
+      option :cluster_name,
+        short: 'c',
+        long: 'cluster-name',
+        argument: 'CLUSTER_NAME',
+        description: 'The name of the cluster to connect'
+
+      option :lifetime,
+        short: 'l',
+        long: 'lifetime',
+        argument: 'MINUTES',
+        description: 'How long should we forward SSH identities (default: 30, 0 for no timeout)'
+
+      arg :ssh_signature
+
+      def handle
+        with_authentication(partake(:config)) do
+          Cabal::SSH.connect(
+            cluster: option(:cluster_name),
+            ssh_signature: arg(:ssh_signature).first,
+            client: partake(:client),
+            identity_timeout: lifetime,
+            kernel: kernel
+          )
+        end
+      end
+
+      def lifetime
+        return nil unless option(:lifetime)
+        option(:lifetime).to_i * 60
+      end
+    end
+  end
+end

data/lib/cabal/client.rb

@@ -2,11 +2,27 @@ require 'faraday'
 require 'oj'
 
 module Cabal
+  # A client interface for an upstream Cabal::API
   class Client
+    # The requested upstream resource was not found
+    NotFoundError = Class.new(StandardError)
+
+    # The user is not authorized to use a given upstream resource
+    UnauthorizedError = Class.new(StandardError)
+
+    # @return [String] the base URL for the v3 API
     attr_reader :api_base
 
+    # Create a new client instance
+    # @param options [Hash]
+    # @option options [String] :api_base the base URL for the upstream API
+    #   (required)
+    # @option options [String] :access_key the access key to use for
+    #   authenticated API endpoints (optional)
+    # @option options [String] :secret_key the secret key to use for
+    #   authenticated API endpoints (optional)
     def initialize(options = {})
-      @api_base = "#{options[:api_base]}/v2"
+      @api_base = "#{options[:api_base]}/v3"
       @access_key = options[:access_key]
       @secret_key = options[:secret_key]
       @connector = Faraday.new(url: api_base) do |faraday|
@@ -15,15 +31,34 @@ module Cabal
       end
     end
 
+    # Retrieves a list of cluster names from the upstream API
+    # @return [Array<String>] the names of the known clusters
+    def clusters
+      get("clusters").map {|cluster| cluster['name']}
+    end
+
+    # Retrieves a private SSH key from the upstream API
+    # @param cluster_name [String] the name of the cluster
+    # @return [String] the contents of the cluster's private key
     def private_key(cluster_name)
       get("private-key/#{URI.encode(cluster_name)}")['private_ssh_key']
     end
 
+    # Retrieves a public SSH key from teh upstream API
+    # @param cluster_name [String] the name of the cluster
+    # @return [String] the contents of the cluster's public key
     def public_key(cluster_name)
       get("key/#{URI.encode(cluster_name)}")['public_ssh_key']
     end
 
-    def get(endpoint, authenticated = nil)
+    # Does an HTTP GET against the upstream API for the provided endpoint
+    # @param endpoint [String] the relative API path to GET
+    # @return [Object] the parsed JSON response
+    # @raise [Cabal::Client::NotFoundError] if the upstream API returns a
+    #   404 status
+    # @raise [Cabal::Client::UnauthorizedError] if the upstream API retirns
+    #   a 401 status
+    def get(endpoint)
         response = connector.get {|req|
           req.url endpoint
           req.headers['Content-Type'] = 'application/json'
@@ -34,9 +69,9 @@ module Cabal
         when 200
           Oj.load(response.body)
         when 404
-          raise "Cabal::Client::NotFoundError"
+          raise Cabal::Client::NotFoundError
         when 401
-          raise "Cabal::Client::UnauthorizedError"
+          raise Cabal::Client::UnauthorizedError
         end
     end
 

data/lib/cabal/identity_manager.rb

@@ -1,15 +1,32 @@
 module Cabal
+  # Manages ssh-agent sessions for forwarding identity information via
+  # Cabal::SSH
   class IdentityManager
+
+    # @return [String] the environment settings for the running ssh-agent
     attr_reader :env
 
+    # Spawns an ssh-agent process and records its related environment settings
+    # @return [nil]
     def start
-      @env = `ssh-agent`.
+      @env = start_agent.
         split(/(\;|\n)/).
-        select {|x| x =~ /^SSH_/}.
+        select {|line| line =~ /^SSH_/}.
         join(' ')
     end
 
+    # Stops a running ssh-agent that was previously spawned
+    # @return [nil]
     def stop
+      stop_agent
+    end
+
+    private
+    def start_agent
+      `ssh-agent`
+    end
+
+    def stop_agent
       `#{env} ssh-agent -k`
     end
   end

data/lib/cabal/ssh.rb

@@ -7,37 +7,79 @@ require 'uri'
 require 'fileutils'
 
 module Cabal
+  # Generates SSH sessions for remote server interaction
   class SSH
-    def self.connect(cluster, ssh_signature, client)
-      new(cluster, ssh_signature, client).connect
+    # Create a new instance and use it to generate an SSH session
+    # @param options [Hash] the options to pass along to the new instance
+    # @option options [String] :cluster the name of the cluster key to
+    #   use (required)
+    # @option options [String] :ssh_signature the user@hostname
+    #   that would be passed if the normal ssh CLI utility were used (required)
+    # @option options [Cabal::Client] :client the instance of
+    #   Cabal::Client to use for key retrieval (required)
+    # @option options [Integer] :identity_timeout the number of seconds
+    #   that keys should be forwarded in the resulting SSH session (optional)
+    # @option options [Kernel] :kernel the Kernel-compliant object used for
+    #   issuing calls to #system for the SSH session (optional)
+    # @return [nil]
+    def self.connect(options = {})
+      new(
+        options[:cluster],
+        options[:ssh_signature],
+        options[:client],
+        options[:identity_timeout] || 1800,
+        options[:kernel] || Kernel
+      ).connect
     end
 
-    def initialize(cluster, ssh_signature, client)
+    def initialize(cluster, ssh_signature, client, identity_timeout, kernel)
       @cluster = cluster
       @ssh_signature = ssh_signature
       @client = client
-      @key_file = Tempfile.new(SecureRandom.hex(8))
+      @identity_timeout = identity_timeout
+      @kernel = kernel
+    end
+
+    # The lifetime option that would be passed to ssh-add for this session
+    # @return [String] the empty string for immortal sessions,
+    #   "-t identity_timeout" for sessions with a defined lifetime
+    def lifetime
+      return '' if identity_timeout == 0
+      "-t #{identity_timeout}"
     end
 
+    # Initiate an SSH connection in the current terminal
+    # @return [nil]
     def connect
+      begin
+        write_private_key
+        initiate_connection
+      ensure
+        terminate_connection
+      end
+    end
+
+    private
+    def write_private_key
       private_key = client.private_key(cluster)
       @key_file = Tempfile.new(SecureRandom.hex(8))
       key_file.write(private_key)
       key_file.close
+      FileUtils.chmod(0700, key_file.path)
+    end
 
-      begin
-        FileUtils.chmod(0700, key_file.path)
-        agent.start
-        Kernel.system("#{agent.env} ssh-add #{key_file.path} > /dev/null 2>&1")
-        Kernel.system("#{agent.env} ssh -A #{ssh_signature}")
-      ensure
-        Kernel.system("#{agent.env} ssh-add -D > /dev/null 2>&1")
-        agent.stop
-        key_file.unlink
-      end
+    def initiate_connection
+      agent.start
+      kernel.system("#{agent.env} ssh-add #{lifetime} #{key_file.path} > /dev/null 2>&1")
+      kernel.system("#{agent.env} ssh -A #{ssh_signature}")
+    end
+
+    def terminate_connection
+      kernel.system("#{agent.env} ssh-add -D > /dev/null 2>&1")
+      agent.stop
+      key_file.unlink unless key_file.nil?
     end
 
-    private
     def key_file
       @key_file
     end
@@ -57,5 +99,13 @@ module Cabal
     def agent
       @agent ||= Cabal::IdentityManager.new
     end
+
+    def identity_timeout
+      @identity_timeout
+    end
+
+    def kernel
+      @kernel
+    end
   end
 end

data/lib/cabal/version.rb

@@ -1,3 +1,3 @@
 module Cabal
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cabal
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Dennis Walters
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-19 00:00:00.000000000 Z
+date: 2016-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,19 +123,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.22'
 - !ruby/object:Gem::Dependency
-  name: cabal-api
+  name: toady
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: cabal-util
   requirement: !ruby/object:Gem::Requirement
@@ -151,19 +151,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: gli
+  name: belafonte
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -213,9 +213,12 @@ files:
 - exe/cabal
 - lib/cabal.rb
 - lib/cabal/cli.rb
+- lib/cabal/cli/authenticated.rb
+- lib/cabal/cli/key.rb
+- lib/cabal/cli/list.rb
+- lib/cabal/cli/main.rb
+- lib/cabal/cli/ssh.rb
 - lib/cabal/client.rb
-- lib/cabal/commands/key.rb
-- lib/cabal/commands/ssh.rb
 - lib/cabal/identity_manager.rb
 - lib/cabal/ssh.rb
 - lib/cabal/version.rb

data/lib/cabal/commands/key.rb

@@ -1,32 +0,0 @@
-module Cabal
-  module Commands
-    module Key
-      def self.bootstrap(obj)
-        obj.instance_eval do
-          desc 'Get the public key for a cluster'
-          long_desc <<-KEYDESC
-          In order to allow logins for Cabal users, you'll need to retrieve
-          a public SSH key for your cluster.
-          KEYDESC
-
-          arg 'cluster name'
-          command :key do |c|
-            c.action do |global_options, options, args|
-              unless global_options[:url]
-                stderr.puts "#{cabal_yml} must contain a :url: definition"
-                exit(1)
-              end
-
-              client = Cabal::Client.new(
-                api_base: global_options[:url],
-                access_key: global_options[:access_key],
-                secret_key: global_options[:secret_key],
-              )
-              stdout.puts client.public_key(args.join(' '))
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cabal/commands/ssh.rb

@@ -1,36 +0,0 @@
-require 'cabal/ssh'
-
-module Cabal
-  module Commands
-    module SSH
-      def self.bootstrap(obj)
-        obj.instance_eval do
-          desc 'Connect to a node on a cluster'
-          long_desc <<-SSHDESC
-          SSHDESC
-
-          arg 'ssh signature'
-          command :ssh do |c|
-            c.desc 'The name of the cluster'
-            c.arg_name 'cluster'
-            c.flag [:c, :cluster]
-            c.action do |global_options, options, args|
-              unless global_options[:access_key] && global_options[:secret_key]
-                stderr.puts "You must have an access key and secret key"
-                exit(1)
-              end
-
-              client = Cabal::Client.new(
-                api_base: global_options[:url],
-                access_key: global_options[:access_key],
-                secret_key: global_options[:secret_key]
-              )
-
-              Cabal::SSH.connect(options[:cluster], args.shift, client)
-            end
-          end
-        end
-      end
-    end
-  end
-end