hippo-cli 1.1.2 → 1.2.0

data/lib/hippo/cli.rb

@@ -3,28 +3,32 @@
 require 'securerandom'
 require 'hippo/manifest'
 require 'hippo/deployment_monitor'
+require 'hippo/working_directory'
 
 module Hippo
   class CLI
-    attr_reader :manifest
+    attr_reader :wd
     attr_reader :stage
 
     # Initialize a new CLI instance
     #
-    # @param manifest [Hippo::Manifest]
-    # @param stage [Hippo::Stage]
+    # @param wd [Hippo::WorkingDirectory]
     # @return [Hippo::CLI]
-    def initialize(manifest, stage)
-      @manifest = manifest
+    def initialize(wd, stage)
+      @wd = wd
       @stage = stage
     end
 
+    def manifest
+      wd.manifest
+    end
+
     # Verify image existence
     #
     # @return [void]
     def verify_image_existence
       missing = 0
-      @stage.images.each do |_, image|
+      stage.images.each do |_, image|
         if image.exists?
           puts "Image for #{image.name} exists at #{image.image_url}"
         else
@@ -43,7 +47,7 @@ module Hippo
     #
     # @return [void]
     def preflight
-      if @stage.context.nil?
+      if stage.context.nil?
         puts "\e[33mStage does not specify a context. The current context specified"
         puts "by the kubectl config will be used (#{Hippo.current_kubectl_context}).\e[0m"
         puts
@@ -61,9 +65,9 @@ module Hippo
         {
           'kind' => 'Namespace',
           'apiVersion' => 'v1',
-          'metadata' => { 'name' => @stage.namespace, 'labels' => { 'name' => @stage.namespace } }
+          'metadata' => { 'name' => stage.namespace, 'labels' => { 'name' => stage.namespace } }
         },
-        @stage
+        stage
       )
       apply([od], 'namespace')
     end
@@ -72,19 +76,19 @@ module Hippo
     #
     # @return [void]
     def apply_config
-      apply(@stage.configs, 'configuration')
+      apply(stage.configs, 'configuration')
     end
 
     # Install all packages
     #
     # @return [void]
     def install_all_packages
-      if @stage.packages.empty?
+      if stage.packages.empty?
         puts 'There are no packages to install'
         return
       end
 
-      @stage.packages.values.each do |package|
+      stage.packages.values.each do |package|
         if package.installed?
           puts "#{package.name} is already installed. Upgrading..."
           package.upgrade
@@ -94,14 +98,14 @@ module Hippo
         end
       end
 
-      puts "Finished with #{@stage.packages.size} #{@stage.packages.size == 1 ? 'package' : 'packages'}"
+      puts "Finished with #{stage.packages.size} #{stage.packages.size == 1 ? 'package' : 'packages'}"
     end
 
     # Apply all services, ingresses and policies
     #
     # @return [void]
     def apply_services
-      apply(@stage.services, 'service')
+      apply(stage.services, 'service')
     end
 
     # Run all deploy jobs
@@ -123,7 +127,7 @@ module Hippo
     # @return [void]
     def deploy
       deployment_id = SecureRandom.hex(6)
-      deployments = @stage.deployments
+      deployments = stage.deployments
       if deployments.empty?
         puts 'There are no deployment objects defined'
         return true
@@ -138,7 +142,7 @@ module Hippo
       apply(deployments, 'deployment')
       puts 'Waiting for all deployments to roll out...'
 
-      monitor = DeploymentMonitor.new(@stage, deployment_id)
+      monitor = DeploymentMonitor.new(stage, deployment_id)
       monitor.on_success do |poll|
         if poll.replica_sets.size == 1
           puts "\e[32mDeployment rolled out successfully\e[0m"
@@ -158,8 +162,8 @@ module Hippo
         poll.pending.each do |rs|
           puts
           name = rs.name.split('-').first
-          puts "  hippo #{@stage.name} kubectl -- describe deployment \e[35m#{name}\e[0m"
-          puts "  hippo #{@stage.name} kubectl -- logs deployment/\e[35m#{name}\e[0m --all-containers"
+          puts "  hippo #{stage.name} kubectl -- describe deployment \e[35m#{name}\e[0m"
+          puts "  hippo #{stage.name} kubectl -- logs deployment/\e[35m#{name}\e[0m --all-containers"
         end
         puts
       end
@@ -174,25 +178,25 @@ module Hippo
         puts "No #{type} objects found to apply"
       else
         puts "Applying #{objects.size} #{type} #{objects.size == 1 ? 'object' : 'objects'}"
-        @stage.apply(objects)
+        stage.apply(objects)
       end
     end
 
     def run_jobs(type)
       puts "Running #{type} jobs"
-      jobs = @stage.jobs(type)
+      jobs = stage.jobs(type)
       if jobs.empty?
         puts "There are no #{type} jobs to run"
         return true
       end
 
       jobs.each do |job|
-        @stage.delete('job', job.name)
+        stage.delete('job', job.name)
       end
 
       applied_jobs = apply(jobs, 'deploy job')
 
-      timeout, jobs = @stage.wait_for_jobs(applied_jobs.keys)
+      timeout, jobs = stage.wait_for_jobs(applied_jobs.keys)
       success_jobs = []
       failed_jobs = []
       jobs.each do |job|
@@ -221,22 +225,22 @@ module Hippo
                else
                  '❌'
                end
-        puts "  #{icon}  hippo #{@stage.name} kubectl -- logs job/#{job.name}"
+        puts "  #{icon}  hippo #{stage.name} kubectl -- logs job/#{job.name}"
       end
       puts
       result
     end
 
     class << self
-      def setup(context)
-        manifest = Hippo::Manifest.load_from_file(context.options[:hippofile] || './Hippofile')
+      def setup(_context)
+        wd = Hippo::WorkingDirectory.new
 
-        stage = manifest.stages[CURRENT_STAGE]
+        stage = wd.stages[CURRENT_STAGE]
         if stage.nil?
           raise Error, "Invalid stage name `#{CURRENT_STAGE}`. Check this has been defined in in your stages directory with a matching name?"
         end
 
-        new(manifest, stage)
+        new(wd, stage)
       end
     end
   end

data/lib/hippo/image.rb

@@ -56,6 +56,7 @@ module Hippo
     end
 
     def exists?
+      return true unless tag.is_a?(RepositoryTag)
       return true if host.nil?
       return true unless can_check_for_existence?
 

data/lib/hippo/manifest.rb

@@ -51,6 +51,18 @@ module Hippo
       end
     end
 
+    def readme
+      return @readme if instance_variable_defined?('@readme')
+
+      path = File.join(@root, 'readme.txt')
+      unless File.file?(path)
+        @readme = nil
+        return
+      end
+
+      @readme = File.read(path)
+    end
+
     def template_vars
       {
         'name' => name
@@ -63,29 +75,13 @@ module Hippo
       @options['images']
     end
 
-    # Load all stages that are available in the manifest
-    #
-    # @return [Hash<Symbol, Hippo::Stage>]
-    def stages
-      objects('stages').each_with_object({}) do |(_, objects), hash|
-        objects.each do |obj|
-          stage = Stage.new(self, obj)
-          hash[stage.name] = stage
-        end
-      end
-    end
-
     # Load all YAML objects at a given path and return them.
     #
     # @param path [String]
     # @param decorator [Proc] an optional parser to run across the raw YAML file
     # @return [Array<Hash>]
     def objects(path, decorator: nil)
-      files = Dir[File.join(@root, path, '*.{yaml,yml}')]
-      files.each_with_object({}) do |path, objects|
-        file = Util.load_yaml_from_file(path, decorator: decorator)
-        objects[path.sub(%r{\A#{@root}/}, '')] = file
-      end
+      Util.load_objects_from_path(File.join(@root, path, '*.{yaml,yml}'), decorator: decorator)
     end
   end
 end

data/lib/hippo/repository_tag.rb

@@ -30,8 +30,9 @@ module Hippo
       return nil if @options['url'].nil?
 
       @remote_refs ||= begin
-        puts "Getting remote refs from #{@options['url']}"
-        Git.ls_remote(@options['url'])
+        Util.action "Getting remote refs from #{@options['url']}..." do
+          Git.ls_remote(@options['url'])
+        end
       end
     end
   end

data/lib/hippo/secret_manager.rb

@@ -15,17 +15,7 @@ module Hippo
     CIPHER = OpenSSL::Cipher.new('aes-256-gcm')
 
     def path
-      File.join(@stage.manifest.root, 'secrets', @stage.name + '.yaml')
-    end
-
-    def secret(name)
-      Secret.new(self, name)
-    end
-
-    def secrets
-      Dir[File.join(root, '*.{yml,yaml}')].map do |path|
-        secret(path.split('/').last.sub(/\.ya?ml\z/, ''))
-      end
+      File.join(@stage.config_root, 'secrets.yaml')
     end
 
     # Download the current key from the Kubernetes API and set it as the
@@ -35,13 +25,24 @@ module Hippo
     def download_key
       return if @key
 
-      value = @stage.get('secret', 'hippo-secret-key').first
-      return if value.nil?
-      return if value.dig('data', 'key').nil?
-
-      @key = Base64.decode64(Base64.decode64(value['data']['key']))
-    rescue Hippo::Error => e
-      raise unless e.message =~ /not found/
+      Util.action 'Downloading secret encryiption key...' do |state|
+        begin
+          value = @stage.get('secret', 'hippo-secret-key').first
+
+          if value.nil? || value.dig('data', 'key').nil?
+            state.call('not found')
+            return
+          end
+
+          @key = Base64.decode64(Base64.decode64(value['data']['key']))
+        rescue Hippo::Error => e
+          if e.message =~ /not found/
+            state.call('not found')
+          else
+            raise
+          end
+        end
+      end
     end
 
     # Is there a key availale in this manager?
@@ -118,7 +119,7 @@ module Hippo
 
       return if exists?
 
-      yaml = { 'example' => 'This is an example secret!' }.to_yaml
+      yaml = { 'example' => 'This is an example secret2!' }.to_yaml
       FileUtils.mkdir_p(File.dirname(path))
       File.open(path, 'w') { |f| f.write(encrypt(yaml)) }
     end

data/lib/hippo/stage.rb

@@ -8,13 +8,19 @@ require 'hippo/liquid_filters'
 
 module Hippo
   class Stage
-    attr_reader :manifest
+    attr_reader :wd
+    attr_reader :config_root
 
-    def initialize(manifest, options)
-      @manifest = manifest
+    def initialize(wd, config_root, options)
+      @wd = wd
+      @config_root = config_root
       @options = options
     end
 
+    def manifest
+      wd.manifest
+    end
+
     def name
       @options['name']
     end
@@ -40,7 +46,7 @@ module Hippo
     end
 
     def images
-      @images ||= @manifest.images.deep_merge(@options['images'] || {}).each_with_object({}) do |(key, image), hash|
+      @images ||= manifest.images.deep_merge(@options['images'] || {}).each_with_object({}) do |(key, image), hash|
         hash[key] = Image.new(key, image)
       end
     end
@@ -49,14 +55,14 @@ module Hippo
     def template_vars
       @template_vars ||= begin
         {
-          'manifest' => @manifest.template_vars,
+          'manifest' => manifest.template_vars,
           'stage-name' => name,
           'branch' => branch,
           'image-tag' => image_tag,
           'namespace' => namespace,
           'context' => context,
           'images' => images.values.each_with_object({}) { |image, hash| hash[image.name] = image.template_vars },
-          'config' => @manifest.config.deep_merge(config),
+          'config' => manifest.config.deep_merge(config),
           'secrets' => secret_manager.all
         }
       end
@@ -75,8 +81,44 @@ module Hippo
       end
     end
 
+    def readme
+      return unless manifest.readme
+
+      decorator.call(manifest.readme)
+    end
+
+    # Return an array of objects that currently exist on the kubernetesa
+    # API.
+    #
+    # @return [Array<Hash>]
+    def live_objects(pruneable_only: false)
+      los = get(all_objects.keys.join(','), '--selector', 'app.kubernetes.io/managed-by=hippo')
+      los.each_with_object([]) do |live_obj, array|
+        local = all_objects.dig(live_obj.kind, live_obj.name)
+        pruneable = local.nil? && (live_obj.kind != 'Secret' && live_obj.name != 'hippo-secret-key')
+
+        next if pruneable_only && !pruneable
+
+        array << {
+          live: live_obj,
+          local: local,
+          pruneable: pruneable
+        }
+      end
+    end
+
+    # Remove any objects which are prunable
+    #
+    # @return [void]
+    def delete_pruneable_objects
+      live_objects(pruneable_only: true).each do |object|
+        object = object[:live]
+        delete(object.kind, object.name)
+      end
+    end
+
     def objects(path)
-      @manifest.objects(path, decorator: decorator)
+      manifest.objects(path, decorator: decorator)
     end
 
     def secret_manager
@@ -112,6 +154,19 @@ module Hippo
       @jobs[type] ||= Util.create_object_definitions(objects("jobs/#{type}"), self)
     end
 
+    # Return an array of all objects that should be managed by Hippo
+    #
+    # @return [Hash]
+    def all_objects
+      @all_objects ||= begin
+        all = (deployments | services | configs | jobs('install') | jobs('deploy'))
+        all.each_with_object({}) do |object, hash|
+          hash[object.kind] ||= {}
+          hash[object.kind][object.name] = object
+        end
+      end
+    end
+
     # Return a hash of all packages available in the stage
     #
     # @return [Hash<String, Hippo::Package>]
@@ -145,33 +200,17 @@ module Hippo
     # @param objects [Array<Hippo::ObjectDefinition>]
     # @return [Hash]
     def apply(objects)
-      yaml_to_apply = objects.map(&:yaml_to_apply).join("\n")
-
       command = ['kubectl']
       command += ['--context', context] if context
       command += ['apply', '-f', '-']
-      Open3.popen3(command.join(' ')) do |stdin, stdout, stderr, wt|
-        stdin.puts yaml_to_apply
-        stdin.close
 
-        stdout = stdout.read.strip
-        stderr = stderr.read.strip
+      yaml_to_apply = objects.map(&:yaml_to_apply).join("\n")
 
-        if wt.value.success?
-          stdout.split("\n").each_with_object({}) do |line, hash|
-            next unless line =~ %r{\A([\w\/\-\.]+) (\w+)\z}
+      stdout, stderr, status = Open3.capture3(command.join(' '), stdin_data: yaml_to_apply + "\n")
 
-            object = Regexp.last_match(1)
-            status = Regexp.last_match(2)
-            hash[object] = status
+      raise Error, "[kubectl] #{stderr}" unless status.success?
 
-            status = "\e[32m#{status}\e[0m" unless status == 'unchanged'
-            puts "\e[37m====> #{object} #{status}\e[0m"
-          end
-        else
-          raise Error, "[kubectl] #{stderr}"
-        end
-      end
+      Util.parse_kubectl_apply_lines(stdout)
     end
 
     # Get some data from the kubernetes API
@@ -194,19 +233,16 @@ module Hippo
     # @return [Boolean]
     def delete(*names)
       command = kubectl('delete', *names)
-      Open3.popen3(*command) do |_, stdout, stderr, wt|
-        if wt.value.success?
-          stdout.read.split("\n").each do |line|
-            puts "\e[37m====> #{line}\e[0m"
-          end
-          true
+      stdout, stderr, status = Open3.capture3(*command)
+      if status.success?
+        Util.parse_kubectl_apply_lines(stdout)
+        true
+      else
+        stderr = stderr.read
+        if stderr =~ /\" not found$/
+          false
         else
-          stderr = stderr.read
-          if stderr =~ /\" not found$/
-            false
-          else
-            raise Error, "[kutectl] #{stderr}"
-          end
+          raise Error, "[kutectl] #{stderr}"
         end
       end
     end

data/lib/hippo/util.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
+require 'open3'
 require 'hippo/error'
 require 'hippo/object_definition'
 
@@ -30,6 +31,14 @@ module Hippo
         end
       end
 
+      def load_objects_from_path(path, decorator: nil)
+        files = Dir[path]
+        files.each_with_object({}) do |path, objects|
+          file = load_yaml_from_file(path, decorator: decorator)
+          objects[path] = file
+        end
+      end
+
       def create_object_definitions(hash, stage, required_kinds: nil, clean: false)
         index = 0
         hash.each_with_object([]) do |(path, objects), array|
@@ -55,13 +64,17 @@ module Hippo
       end
 
       def open_in_editor(name, contents)
+        if ENV['EDITOR'].nil?
+          raise Error, 'No EDITOR environment variable has been defined'
+        end
+
         tmp_root = File.join(ENV['HOME'], '.hippo')
         FileUtils.mkdir_p(tmp_root)
         begin
           tmpfile = Tempfile.new([name, '.yaml'], tmp_root)
           tmpfile.write(contents)
           tmpfile.close
-          system("#{ENV['EDITOR']} #{tmpfile.path}")
+          Kernel.system("#{ENV['EDITOR']} #{tmpfile.path}")
           tmpfile.open
           tmpfile.read
         ensure
@@ -102,6 +115,53 @@ module Hippo
         response = response.to_s.strip
         response.empty? ? default : response
       end
+
+      def system(command, stdin_data: nil)
+        stdout, stderr, status = Open3.capture3(command, stdin_data: stdin_data)
+        unless status.success?
+          raise Error, "Command failed to execute: #{stderr}"
+        end
+
+        stdout
+      end
+
+      def action(message)
+        $stdout.print message
+        complete_state = 'done'
+        color = '32'
+        passed_proc = proc do |value|
+          complete_state = value
+          color = '33'
+        end
+        return_value = yield(passed_proc)
+        puts " \e[#{color}m#{complete_state}\e[0m"
+        return_value
+      rescue StandardError => e
+        puts " \e[31merror\e[0m"
+        raise
+      end
+    end
+
+    def self.parse_kubectl_apply_lines(stdout)
+      stdout.split("\n").each_with_object({}) do |line, hash|
+        if line =~ %r{\A([\w\/\-\.]+) (\w+)\z}
+          object = Regexp.last_match(1)
+          status = Regexp.last_match(2)
+        elsif line =~ %r{\A[\w\.\/\-]+ \"([\w\-]+)\" (\w+)\z}
+          object = Regexp.last_match(1)
+          status = Regexp.last_match(2)
+        else
+          next
+        end
+        hash[object] = status
+
+        color = '32'
+        color = '31' if status == 'deleted'
+        color = '33' if status == 'configured'
+
+        status = "\e[#{color}m#{status}\e[0m" unless status == 'unchanged'
+        puts "\e[37m====> #{object} #{status}\e[0m"
+      end
     end
   end
 end

data/lib/hippo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hippo
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end