hippo-cli 1.1.1 → 1.2.3

data/lib/hippo/stage.rb

@@ -4,16 +4,23 @@ require 'liquid'
 require 'open3'
 require 'hippo/secret_manager'
 require 'hippo/package'
+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
@@ -38,8 +45,18 @@ module Hippo
       @options['config']
     end
 
+    def command(name)
+      base = manifest.commands[name]
+      return nil if base.nil?
+
+      {
+        target: base['target'],
+        command: decorator.call(base['command'])
+      }
+    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
@@ -48,14 +65,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
@@ -67,15 +84,51 @@ module Hippo
       proc do |data|
         begin
           template = Liquid::Template.parse(data)
-          template.render(template_vars)
+          template.render(template_vars, filters: [LiquidFilters])
         rescue Liquid::SyntaxError => e
           raise Error, "Template error: #{e.message}"
         end
       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
@@ -111,6 +164,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>]
@@ -144,33 +210,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
@@ -193,19 +243,15 @@ 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
+        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.1'
+  VERSION = '1.2.3'
 end

data/lib/hippo/working_directory.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'hippo/manifest'
+require 'hippo/util'
+require 'hippo/error'
+
+module Hippo
+  class WorkingDirectory
+    attr_reader :root
+
+    def initialize(root = FileUtils.pwd)
+      @root = root
+    end
+
+    # Return the path to the config file in this working directory
+    #
+    # @return [String]
+    def config_path
+      File.join(@root, 'manifest.yaml')
+    end
+
+    # Return the path to the local config file
+    #
+    # @return [String]
+    def local_config_path
+      File.join(@root, 'manifest.local.yaml')
+    end
+
+    # Return all the options configured in this working directory
+    #
+    # @return [Hash]
+    def options
+      return @options if @options
+
+      if File.file?(config_path)
+        @options = YAML.load_file(config_path)
+        if File.file?(local_config_path)
+          @options = @options.deep_merge(YAML.load_file(local_config_path))
+        end
+        @options
+      else
+        raise Error, "No manifest config file found at #{config_path}"
+      end
+    end
+
+    # Return the manifest objet for this working directory
+    #
+    # @return [Hippo::Manifest]
+    def manifest(update: true)
+      if update && !@updated_manifest
+        update_from_remote if can_update?
+        @updated_manifest = true
+      end
+
+      raise Error, 'No manifest path could be determined' if manifest_path.nil?
+
+      @manifest ||= Manifest.load_from_file(File.join(manifest_path, 'Hippofile'))
+    end
+
+    # Return the path to the manifest directory
+    #
+    # @return [String]
+    def manifest_path
+      case source_type
+      when 'local'
+        options.dig('source', 'localOptions', 'path')
+      when 'remote'
+        path = [remote_path] if remote_path
+        File.join(remote_root_path, *path)
+      else
+        raise Error, "Invalid source.type ('#{source_type}')"
+      end
+    end
+
+    # Return the type of manifest
+    #
+    # @return [String]
+    def source_type
+      options.dig('source', 'type')
+    end
+
+    # Return the path on the local filesystem that the remote repository
+    # should be stored in.
+    #
+    # @return [String]
+    def remote_root_path
+      repo_ref = Digest::SHA1.hexdigest([remote_repository, remote_branch].join('---'))
+      File.join(Hippo.tmp_root, 'manifests', repo_ref)
+    end
+
+    # Return the branch to use from the remote repository
+    #
+    # @return [String]
+    def remote_branch
+      options.dig('source', 'remoteOptions', 'branch') || 'master'
+    end
+
+    # Return the URL to the remote repository
+    #
+    # @return [String]
+    def remote_repository
+      options.dig('source', 'remoteOptions', 'repository')
+    end
+
+    # Return the path within the remote repository that we wish to work
+    # with.
+    #
+    # @return [String]
+    def remote_path
+      options.dig('source', 'remoteOptions', 'path')
+    end
+
+    # Update the local cached copy of the manifest from the remote
+    #
+    # @return [Boolean]
+    def update_from_remote(verbose: false)
+      return false unless source_type == 'remote'
+
+      Util.action "Updating manifest from #{remote_repository}..." do
+        if File.directory?(remote_root_path)
+          Util.system("git -C #{remote_root_path} fetch")
+        else
+          FileUtils.mkdir_p(File.dirname(remote_root_path))
+          Util.system("git clone #{remote_repository} #{remote_root_path}")
+        end
+
+        Util.system("git -C #{remote_root_path} checkout origin/#{remote_branch}")
+        File.open(update_timestamp_path, 'w') { |f| f.write(Time.now.to_i.to_s + "\n") }
+      end
+
+      if verbose
+        puts
+        puts "  Repository....: \e[33m#{wd.remote_repository}\e[0m"
+        puts "  Branch........: \e[33m#{wd.remote_branch}\e[0m"
+        puts "  Path..........: \e[33m#{wd.remote_path}\e[0m"
+        puts
+      end
+
+      true
+    end
+
+    # Return the time this manifest was last updated
+    #
+    # @return [Time, nil]
+    def last_updated_at
+      if File.file?(update_timestamp_path)
+        timestamp = File.read(update_timestamp_path)
+        Time.at(timestamp.strip.to_i)
+      end
+    end
+
+    # Return the path to the file where the last updated timestamp
+    # is stored
+    #
+    # @return [String]
+    def update_timestamp_path
+      File.join(remote_root_path + '.uptime-timestamp')
+    end
+
+    # Can this working directory be updated?
+    #
+    # @return [Boolean]
+    def can_update?
+      source_type == 'remote'
+    end
+
+    # Load all stages that are available in this working directory
+    #
+    # @return [Hash<Symbol, Hippo::Stage>]
+    def stages
+      objects = Util.load_objects_from_path(File.join(@root, '*', 'config.{yml,yaml}'))
+      objects.each_with_object({}) do |(path, objects), hash|
+        objects.each do |obj|
+          stage = Stage.new(self, File.dirname(path), obj)
+          hash[stage.name] = stage
+        end
+      end
+    end
+  end
+end