aptible-cli 0.14.1 → 0.15.0

data/lib/aptible/cli/helpers/app.rb

@@ -152,6 +152,7 @@ module Aptible
         end
 
         def apps_from_handle(handle, environment)
+          # TODO: This should probably use each_app for more efficiency.
           if environment
             environment.apps
           else

data/lib/aptible/cli/helpers/database.rb

@@ -40,12 +40,6 @@ module Aptible
           databases.select { |a| a.handle == handle }
         end
 
-        def present_environment_databases(environment)
-          say "=== #{environment.handle}"
-          environment.databases.each { |db| say db.handle }
-          say ''
-        end
-
         def clone_database(source, dest_handle)
           op = source.create_operation!(type: 'clone', handle: dest_handle)
           attach_to_operation_logs(op)
@@ -120,6 +114,28 @@ module Aptible
           err = "No credential with type #{type} for database" if type
           raise Thor::Error, "#{err}, valid credential types: #{valid}"
         end
+
+        def find_database_image(type, version)
+          available_versions = []
+
+          Aptible::Api::DatabaseImage.all(token: fetch_token).each do |i|
+            next unless i.type == type
+            return i if i.version == version
+            available_versions << i.version
+          end
+
+          err = "No Database Image of type #{type} with version #{version}"
+          err = "#{err}, valid versions: #{available_versions.join(' ')}"
+          raise Thor::Error, err
+        end
+
+        def render_database(database, account)
+          Formatter.render(Renderer.current) do |root|
+            root.keyed_object('connection_url') do |node|
+              ResourceFormatter.inject_database(node, database, account)
+            end
+          end
+        end
       end
     end
   end

data/lib/aptible/cli/helpers/operation.rb

@@ -37,13 +37,14 @@ module Aptible
           # operation failed, poll_for_success will immediately fall through to
           # the error message.
           unless code == 0
-            puts 'Disconnected from logs, waiting for operation to complete'
+            e = 'Disconnected from logs, waiting for operation to complete'
+            CLI.logger.warn e
             poll_for_success(operation)
           end
         end
 
         def cancel_operation(operation)
-          puts "Cancelling #{prettify_operation(operation)}..."
+          CLI.logger.info "Cancelling #{prettify_operation(operation)}..."
           operation.update!(cancelled: true)
         end
 

data/lib/aptible/cli/helpers/tunnel.rb

@@ -53,9 +53,7 @@ module Aptible
             out_read.readline
           rescue EOFError
             stop
-            e = 'Tunnel did not come up, is something else listening on port ' \
-                "#{@local_port}?\n#{err_read.read}"
-            raise e
+            raise UserError, "Tunnel did not come up: #{err_read.read}"
           ensure
             [out_read, err_read].map(&:close)
           end

data/lib/aptible/cli/helpers/vhost.rb

@@ -2,52 +2,15 @@ module Aptible
   module CLI
     module Helpers
       module Vhost
-        def explain_vhost(service, vhost)
-          say "Service: #{service.process_type}"
-          say "Hostname: #{vhost.external_host}"
-          say "Status: #{vhost.status}"
-
-          case vhost.type
-          when 'tcp', 'tls'
-            ports = if vhost.container_ports.any?
-                      vhost.container_ports.map(&:to_s).join(' ')
-                    else
-                      'all'
-                    end
-            say "Type: #{vhost.type}"
-            say "Ports: #{ports}"
-          when 'http', 'http_proxy_protocol'
-            port = vhost.container_port ? vhost.container_port : 'default'
-            say 'Type: https'
-            say "Port: #{port}"
-          end
-
-          say "Internal: #{vhost.internal}"
-
-          ip_whitelist = if vhost.ip_whitelist.any?
-                           vhost.ip_whitelist.join(' ')
-                         else
-                           'all traffic'
-                         end
-          say "IP Whitelist: #{ip_whitelist}"
-
-          say "Default Domain Enabled: #{vhost.default}"
-          say "Default Domain: #{vhost.virtual_domain}" if vhost.default
-
-          say "Managed TLS Enabled: #{vhost.acme}"
-          if vhost.acme
-            say "Managed TLS Domain: #{vhost.user_domain}"
-            say 'Managed TLS DNS Challenge Hostname: ' \
-                "#{vhost.acme_dns_challenge_host}"
-            say "Managed TLS Status: #{vhost.acme_status}"
-          end
-        end
-
         def provision_vhost_and_explain(service, vhost)
           op = vhost.create_operation!(type: 'provision')
           attach_to_operation_logs(op)
-          explain_vhost(service, vhost.reload)
-          # TODO: Instructions if ACME is enabled?
+
+          Formatter.render(Renderer.current) do |root|
+            root.object do |node|
+              ResourceFormatter.inject_vhost(node, vhost.reload, service)
+            end
+          end
         end
 
         def find_vhost(service_enumerator, hostname)
@@ -65,10 +28,10 @@ module Aptible
           raise Thor::Error, e
         end
 
-        def each_vhost(resource, &block)
-          return enum_for(:each_vhost, resource) unless block_given?
-
+        def each_service(resource, &block)
+          return enum_for(:each_service, resource) if block.nil?
           klass = resource.class
+
           if klass == Aptible::Api::App
             resource.each_service(&block)
           elsif klass == Aptible::Api::Database

data/lib/aptible/cli/renderer.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+require_relative 'renderer/base'
+require_relative 'renderer/json'
+require_relative 'renderer/text'
+
+module Aptible
+  module CLI
+    module Renderer
+      FORMAT_VAR = 'APTIBLE_OUTPUT_FORMAT'.freeze
+
+      def self.current
+        case (format = ENV[FORMAT_VAR])
+        when 'json'
+          Json.new
+        when 'text'
+          Text.new
+        when nil
+          Text.new
+        else
+          raise UserError, "Invalid #{FORMAT_VAR}: #{format}"
+        end
+      end
+    end
+  end
+end

data/lib/aptible/cli/renderer/base.rb

@@ -0,0 +1,8 @@
+module Aptible
+  module CLI
+    module Renderer
+      class Base
+      end
+    end
+  end
+end

data/lib/aptible/cli/renderer/json.rb

@@ -0,0 +1,26 @@
+module Aptible
+  module CLI
+    module Renderer
+      class Json < Base
+        def visit(node)
+          case node
+          when Formatter::Root
+            visit(node.root)
+          when Formatter::Object
+            Hash[node.children.each_pair.map { |k, c| [k, visit(c)] }]
+          when Formatter::List
+            node.children.map { |c| visit(c) }
+          when Formatter::Value
+            node.value
+          else
+            raise "Unhandled node: #{node.inspect}"
+          end
+        end
+
+        def render(node)
+          JSON.pretty_generate(visit(node))
+        end
+      end
+    end
+  end
+end

data/lib/aptible/cli/renderer/text.rb

@@ -0,0 +1,99 @@
+module Aptible
+  module CLI
+    module Renderer
+      class Text < Base
+        include ActiveSupport::Inflector
+
+        POST_PROCESSED_KEYS = {
+          'Tls' => 'TLS',
+          'Dns' => 'DNS',
+          'Ip' => 'IP'
+        }.freeze
+
+        def visit(node, io)
+          case node
+          when Formatter::Root
+            visit(node.root, io)
+          when Formatter::KeyedObject
+            visit(node.children.fetch(node.key), io)
+          when Formatter::Object
+            # TODO: We should have a way to fail in tests if we're going to
+            # nest an object under another object (or at least handle it
+            # decently).
+            #
+            # Right now, it provides unusable output like this:
+            #
+            # Foo: Bar: bar
+            # Qux: qux
+            #
+            # (when rendering { foo => { bar => bar }, qux => qux })
+            #
+            # The solution to this problem is typically to make sure the
+            # children are KeyedObject instances so they can render properly,
+            # but we need to warn in tests that this is required.
+            node.children.each_pair do |k, c|
+              io.print "#{format_key(k)}: "
+              visit(c, io)
+            end
+          when Formatter::GroupedKeyedList
+            enum = spacer_enumerator
+            node.groups.each_pair.sort_by(&:first).each do |key, group|
+              io.print enum.next
+              io.print '=== '
+              nodes = group.map { |n| n.children.fetch(node.key) }
+              visit(key, io)
+              output_list(nodes, io)
+            end
+          when Formatter::KeyedList
+            nodes = node.children.map { |n| n.children.fetch(node.key) }
+            output_list(nodes, io)
+          when Formatter::List
+            output_list(node.children, io)
+          when Formatter::Value
+            io.puts node.value
+          else
+            raise "Unhandled node: #{node.inspect}"
+          end
+        end
+
+        def render(node)
+          io = StringIO.new
+          visit(node, io)
+          io.rewind
+          io.read
+        end
+
+        private
+
+        def output_list(nodes, io)
+          if nodes.all? { |v| v.is_a?(Formatter::Value) }
+            # All nodes are single values, so we render one per line.
+            nodes.each { |c| visit(c, io) }
+          else
+            # Nested values. Display each as a block with newlines in between.
+            enum = spacer_enumerator
+            nodes.each do |c|
+              io.print enum.next
+              visit(c, io)
+            end
+          end
+        end
+
+        def format_key(key)
+          key = titleize(humanize(key))
+          POST_PROCESSED_KEYS.each_pair do |pk, pv|
+            key = key.gsub(/(^|\W)#{Regexp.escape(pk)}($|\W)/, "\\1#{pv}\\2")
+          end
+          key
+        end
+
+        def spacer_enumerator
+          Enumerator.new do |y|
+            y << ''
+            loop { y << "\n" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aptible/cli/resource_formatter.rb

@@ -0,0 +1,136 @@
+module Aptible
+  module CLI
+    module ResourceFormatter
+      class << self
+        NO_NESTING = Object.new.freeze
+
+        def inject_account(node, account)
+          node.value('id', account.id)
+          node.value('handle', account.handle)
+        end
+
+        def inject_app(node, app, account)
+          node.value('id', app.id)
+          node.value('handle', app.handle)
+
+          node.value('status', app.status)
+          node.value('git_remote', app.git_repo)
+
+          node.list('services') do |services_list|
+            app.each_service do |service|
+              services_list.object do |n|
+                inject_service(n, service, NO_NESTING)
+              end
+            end
+          end
+
+          attach_account(node, account)
+        end
+
+        def inject_database(node, database, account)
+          node.value('id', database.id)
+          node.value('handle', database.handle)
+
+          node.value('type', database.type)
+          node.value('status', database.status)
+          node.value('connection_url', database.connection_url)
+
+          node.list('credentials') do |creds_list|
+            database.database_credentials.each do |cred|
+              creds_list.object { |n| inject_credential(n, cred) }
+            end
+          end
+
+          attach_account(node, account)
+        end
+
+        def inject_credential(node, credential)
+          # TODO: Should this accept a DB for nesting? Maybe if we have any
+          # callers that could benefit from it.
+          node.value('type', credential.type)
+          node.value('connection_url', credential.connection_url)
+          node.value('default', credential.default)
+        end
+
+        def inject_service(node, service, app)
+          node.value('id', service.id)
+          node.value('service', service.process_type)
+
+          node.value('command', service.command || 'CMD')
+          node.value('container_count', service.container_count)
+          node.value('container_size', service.container_memory_limit_mb)
+
+          attach_app(node, app)
+        end
+
+        def inject_vhost(node, vhost, service)
+          node.value('id', vhost.id)
+          node.value('hostname', vhost.external_host)
+          node.value('status', vhost.status)
+
+          case vhost.type
+          when 'tcp', 'tls'
+            ports = if vhost.container_ports.any?
+                      vhost.container_ports.map(&:to_s).join(' ')
+                    else
+                      'all'
+                    end
+            node.value('type', vhost.type)
+            node.value('ports', ports)
+          when 'http', 'http_proxy_protocol'
+            port = vhost.container_port ? vhost.container_port : 'default'
+            node.value('type', 'https')
+            node.value('port', port)
+          end
+
+          node.value('internal', vhost.internal)
+
+          ip_whitelist = if vhost.ip_whitelist.any?
+                           vhost.ip_whitelist.join(' ')
+                         else
+                           'all traffic'
+                         end
+          node.value('ip_whitelist', ip_whitelist)
+
+          node.value('default_domain_enabled', vhost.default)
+          node.value('default_domain', vhost.virtual_domain) if vhost.default
+
+          node.value('managed_tls_enabled', vhost.acme)
+          if vhost.acme
+            node.value('managed_tls_domain', vhost.user_domain)
+            node.value(
+              'managed_tls_dns_challenge_hostname',
+              vhost.acme_dns_challenge_host
+            )
+            node.value('managed_tls_status', vhost.acme_status)
+          end
+
+          attach_service(node, service)
+        end
+
+        private
+
+        def attach_account(node, account)
+          return if NO_NESTING.eql?(account)
+          node.keyed_object('environment', 'handle') do |n|
+            inject_account(n, account)
+          end
+        end
+
+        def attach_app(node, app)
+          return if NO_NESTING.eql?(app)
+          node.keyed_object('app', 'handle') do |n|
+            inject_app(n, app, NO_NESTING)
+          end
+        end
+
+        def attach_service(node, service)
+          return if NO_NESTING.eql?(service)
+          node.keyed_object('service', 'service') do |n|
+            inject_service(n, service, NO_NESTING)
+          end
+        end
+      end
+    end
+  end
+end