hippo-cli 1.0.1 → 1.1.0

data/lib/hippo/kubernetes.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require 'liquid'
-require 'hippo/util'
-
-module Hippo
-  class Kubernetes
-    OBJECT_DIRECTORY_NAMES = %w[config deployments jobs/install jobs/deploy services].freeze
-
-    include Hippo::Util
-
-    def initialize(recipe, options)
-      @recipe = recipe
-      @options = options
-    end
-
-    # Load and return a set of objects from a given path.
-    # Parse them through the templating and return them in the appropriate
-    # context.
-    #
-    # @param stage [Hippo::Stage]
-    # @param commit [String] the commit ref
-    # @param path [String]
-    # @return
-    def objects(path, stage, commit, deploy_id: nil)
-      time = Time.now
-
-      yamls = load_yaml_from_directory(path)
-      yamls |= load_yaml_from_directory(File.join(path, stage.name))
-
-      yamls.map do |yaml_part|
-        object = yaml_part.parse(@recipe, stage, commit)
-
-        # Unless a namespace has been specified in the metadata we will
-        # want to add the namespace for the current stage.
-        if object['metadata'].nil? || object['metadata']['namespace'].nil?
-          object['metadata'] ||= {}
-          object['metadata']['namespace'] = stage.namespace
-        end
-
-        object['metadata']['annotations'] ||= {}
-        object['metadata']['labels'] ||= {}
-
-        add_default_labels(object, stage)
-
-        # Add some information to Deployments to reflect the latest
-        # information about this deployment.
-        if object['kind'] == 'Deployment'
-          if deploy_id
-            object['metadata']['labels']['hippo.adam.ac/deployID'] ||= deploy_id
-          end
-
-          if commit
-            object['metadata']['annotations']['hippo.adam.ac/commitRef'] ||= commit.objectish
-            object['metadata']['annotations']['hippo.adam.ac/commitMessage'] ||= commit.message
-          end
-
-          if pod_metadata = object.dig('spec', 'template', 'metadata')
-            pod_metadata['labels'] ||= {}
-            pod_metadata['annotations'] ||= {}
-            # add_default_labels(pod_metadata, stage)
-            if deploy_id
-              pod_metadata['labels']['hippo.adam.ac/deployID'] = deploy_id
-            end
-
-            if commit
-              pod_metadata['annotations']['hippo.adam.ac/commitRef'] = commit.objectish
-            end
-          end
-        end
-
-        object
-      end
-    end
-
-    def apply_namespace(stage)
-      namespace = {
-        'kind' => 'Namespace',
-        'apiVersion' => 'v1',
-        'metadata' => {
-          'name' => stage.namespace
-        }
-      }
-      add_default_labels(namespace, stage)
-      apply_with_kubectl(stage, namespace.to_yaml)
-    end
-
-    # Apply the given configuration with kubectl
-    #
-    # @param config [Array<Hippo::YAMLPart>, String]
-    # @return [void]
-    def apply_with_kubectl(stage, yaml_parts)
-      unless yaml_parts.is_a?(String)
-        yaml_parts = [yaml_parts] unless yaml_parts.is_a?(Array)
-        yaml_parts = yaml_parts.map { |yp| yp.hash.to_yaml }.join("\n---\n")
-      end
-
-      command = ['kubectl']
-      command += ['--context', stage.context] if stage.context
-      command += ['apply', '-f', '-']
-
-      Open3.popen3(command.join(' ')) do |stdin, stdout, stderr, wt|
-        stdin.puts yaml_parts
-        stdin.close
-
-        stdout = stdout.read.strip
-        stderr = stderr.read.strip
-
-        if wt.value.success?
-          puts stdout
-          stdout.split("\n").each_with_object({}) do |line, hash|
-            if line =~ %r{\A([\w\/\-\.]+) (\w+)\z}
-              hash[Regexp.last_match(1)] = Regexp.last_match(2)
-            end
-          end
-        else
-          raise Error, "[kubectl] #{stderr}"
-        end
-      end
-    end
-
-    # Get details of objects using kubectl.
-    #
-    # @param stage [Hippo::Stage]
-    # @param names [Array<String>]
-    # @raises [Hippo::Error]
-    # @return [Array<Hash>]
-    def get_with_kubectl(stage, *names)
-      command = stage.kubectl_base_command
-      command += ['get', names, '-o', 'yaml']
-      command = command.flatten.reject(&:nil?)
-
-      Open3.popen3(*command) do |_, stdout, stderr, wt|
-        if wt.value.success?
-          yaml = YAML.safe_load(stdout.read, permitted_classes: [Time])
-          yaml['items'] || [yaml]
-        else
-          raise Error, "[kutectl] #{stderr.read}"
-        end
-      end
-    end
-
-    # Delete a named job from the cluster
-    #
-    # @param stage [Hippo::Stage]
-    # @param name [String]
-    # @raises [Hippo::Error]
-    # @return [void]
-    def delete_job(stage, name)
-      command = stage.kubectl_base_command
-      command += ['delete', 'job', name]
-
-      Open3.popen3(*command) do |_, stdout, stderr, wt|
-        if wt.value.success?
-          puts stdout.read
-          true
-        else
-          stderr = stderr.read
-          if stderr =~ /\"#{name}\" not found/
-            false
-          else
-            raise Error, "[kutectl] #{stderr.read}"
-          end
-        end
-      end
-    end
-
-    # Poll the named jobs and return them when all are complete
-    # or the number of checks is exceeded.
-    #
-    # @param stage [Hippo::Stage]
-    # @param names [Array<String>]
-    # @param times [Integer]
-    # @return [Array<Boolean, Array<Hash>]
-    def wait_for_jobs(stage, names, times = 120)
-      jobs = nil
-      times.times do
-        jobs = get_with_kubectl(stage, *names)
-
-        # Are all the jobs completed?
-        if jobs.all? { |j| j['status']['active'].nil? }
-          return [false, jobs]
-        else
-          sleep 2
-        end
-      end
-      [true, jobs]
-    end
-
-    private
-
-    def add_default_labels(object, stage)
-      object['metadata']['labels'] ||= {}
-      object['metadata']['labels']['app.kubernetes.io/name'] = @recipe.name
-      object['metadata']['labels']['app.kubernetes.io/instance'] = stage.name
-      object['metadata']['labels']['app.kubernetes.io/managed-by'] = 'hippo'
-      object
-    end
-  end
-end

data/lib/hippo/recipe.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require 'hippo/build_spec'
-require 'hippo/error'
-require 'hippo/kubernetes'
-require 'hippo/repository'
-require 'hippo/stage'
-require 'hippo/util'
-
-module Hippo
-  class Recipe
-    include Util
-
-    class RecipeNotFound < Error
-    end
-
-    class << self
-      # Load a new Recipe class from a given file.
-      #
-      # @param path [String] path to recipe file.
-      # @return [Hippo::Recipe]
-      def load_from_file(path)
-        unless File.file?(path)
-          raise RecipeNotFound, "No recipe file found at #{path}"
-        end
-
-        hash = YAML.load_file(path)
-        new(hash, path)
-      end
-    end
-
-    # @param hash [Hash] the raw hash from the underlying yaml file
-    def initialize(hash, hippofile_path = nil)
-      @hash = hash
-      @hippofile_path = hippofile_path
-    end
-
-    attr_reader :path
-
-    # Return the root directory where the Hippofile is located
-    #
-    def root
-      File.dirname(@hippofile_path)
-    end
-
-    # Return the repository that this manifest should be working with
-    #
-    # @return [Hippo::Repository]
-    def repository
-      return unless @hash['repository']
-
-      @repository ||= Repository.new(@hash['repository'])
-    end
-
-    # Return the app name
-    #
-    # @return [String, nil]
-    def name
-      @hash['name']
-    end
-
-    # Return kubernetes configuration
-    #
-    # @return [Hippo::Kubernetes]
-    def kubernetes
-      @kubernetes ||= Kubernetes.new(self, @hash['kubernetes'] || {})
-    end
-
-    # Return the stages for this recipe
-    #
-    # @return [Hash<Hippo::Stage>]
-    def stages
-      @stages ||= begin
-        yamls = load_yaml_from_directory(File.join(root, 'stages'))
-        yamls.each_with_object({}) do |yaml, hash|
-          stage = Stage.new(yaml)
-          hash[stage.name] = stage
-        end
-      end
-    end
-
-    # Return the builds for this recipe
-    #
-    # @return [Hash<Hippo::BuildSpec>]
-    def build_specs
-      @build_specs ||= @hash['builds'].each_with_object({}) do |(key, options), hash|
-        hash[key] = BuildSpec.new(self, key, options)
-      end
-    end
-
-    # Return configuration
-    #
-    # @return []
-    def console
-      @hash['console']
-    end
-
-    # Return the template variables that should be exposed
-    #
-    # @return [Hash]
-    def template_vars
-      {
-        'repository' => repository ? repository.template_vars : nil,
-        'builds' => build_specs.each_with_object({}) { |(_, bs), h| h[bs.name] = bs.template_vars }
-      }
-    end
-
-    # Parse a string through the template parser
-    #
-    # @param string [String]
-    # @return [String]
-    def parse(stage, commit, string)
-      template = Liquid::Template.parse(string)
-      template_variables = template_vars
-      template_variables['stage'] = stage.template_vars
-      if commit
-        template_variables['commit'] = {
-          'ref' => commit.objectish,
-          'message' => commit.message
-        }
-      end
-      template.render(template_variables)
-    end
-  end
-end

data/lib/hippo/repository.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-require 'git'
-require 'hippo/error'
-
-module Hippo
-  class Repository
-    def initialize(options)
-      @options = options
-    end
-
-    def url
-      @options['url']
-    end
-
-    # Return the path where this repository is stored on the local
-    # computer.
-    #
-    # @return [String]
-    def path
-      return @options['path'] if @options['path']
-
-      @path ||= begin
-        digest = Digest::SHA256.hexdigest(url)
-        File.join(ENV['HOME'], '.hippo', 'repos', digest)
-      end
-    end
-
-    # Clone this repository into the working directory for this
-    # application.
-    #
-    # @return [Boolean]
-    def clone
-      if File.directory?(path)
-        raise RepositoryAlreadyClonedError, "Repository has already been cloned to #{path}. Maybe you just want to pull?"
-      end
-
-      @git = Git.clone(url, path)
-      true
-    rescue Git::GitExecuteError => e
-      raise RepositoryCloneError, e.message
-    end
-
-    # Has this been cloned?
-    #
-    # @return [Boolean]
-    def cloned?
-      File.directory?(path)
-    end
-
-    # Fetch the latest copy of this repository
-    #
-    # @return [Boolean]
-    def fetch
-      git.fetch
-      true
-    rescue Git::GitExecuteError => e
-      raise RepositoryFetchError, e.message
-    end
-
-    # Checkout the version of the application for the given commit or
-    # branch name in the local copy.
-    #
-    # @param ref [String]
-    # @return [Boolean]
-    def checkout(ref)
-      git.checkout("origin/#{ref}")
-      true
-    rescue Git::GitExecuteError => e
-      if e.message =~ /did not match any file\(s\) known to git/
-        raise RepositoryCheckoutError, "No branch named '#{ref}' found in repository"
-      else
-        raise RepositoryCheckoutError, e.message
-      end
-    end
-
-    # Return the commit reference for the currently checked out branch
-    #
-    # @return [String]
-    def commit
-      git.log(1).first
-    end
-
-    # Get the commit reference for the given branch on the remote
-    # repository by asking it directly.
-    #
-    # @param name [String]
-    # @return [Git::Commit]
-    def commit_for_branch(branch)
-      git.object("origin/#{branch}").log(1).first
-    rescue Git::GitExecuteError => e
-      if e.message =~ /Not a valid object name/
-        raise Error, "'#{branch}' is not a valid branch name in repository"
-      else
-        raise
-      end
-    end
-
-    # Return the template variables for a repository
-    #
-    # @return [Hash]
-    def template_vars
-      {
-        'url' => url,
-        'path' => path
-      }
-    end
-
-    private
-
-    def git
-      @git ||= begin
-        if cloned?
-          Git.open(path)
-        else
-          raise Error, 'Could not create a git instance because there is no repository cloned for it.'
-        end
-      end
-    end
-  end
-end

data/lib/hippo/yaml_part.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Hippo
-  class YAMLPart
-    attr_reader :yaml
-
-    def initialize(yaml, path, index)
-      @yaml = yaml.strip
-      @path = path
-      @index = index
-    end
-
-    def hash
-      @hash ||= YAML.safe_load(@yaml)
-    rescue Psych::SyntaxError => e
-      raise Error, "YAML parsing error in #{@path} (index #{@index}) (#{e.message})"
-    end
-
-    def empty?
-      @yaml.nil? ||
-        @yaml.empty? ||
-        hash.nil? ||
-        hash.empty?
-    end
-
-    def to_yaml
-      hash.to_yaml
-    end
-
-    def dig(*args)
-      hash.dig(*args)
-    end
-
-    def [](name)
-      hash[name]
-    end
-
-    def []=(name, value)
-      hash[name] = value
-    end
-
-    def parse(recipe, stage, commit)
-      parsed_part = recipe.parse(stage, commit, @yaml)
-      self.class.new(parsed_part, @path, @index)
-    end
-  end
-end