karist 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a610ac89447543fd04a2edbe3fc5263e6e4a9e63b22892a2e29a2aa48222bcd
+  data.tar.gz: 783771edbea05c3b273b75be8a56b46452f68cff42a76c71b102f4c03b2f1d5a
+SHA512:
+  metadata.gz: cd07008239e7c1723b79b873d1a6645c1d39fa3b07cf0caa5396e62c9f11f949243dd3016c76a25bc7d2bc903c98b4c5d0d60acddc05b889379e14f2a37937b7
+  data.tar.gz: 51a4a7b3632877c1825d0aec2192a432a83597e85bec7aa11c775cbce8fe324b1a0ab2d8412b959865773e2148860c031e3049dadfce7a58608f40bf9b2831eb

data/.ruby-version

@@ -0,0 +1 @@
+3.2.2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mimosa + o
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# Karist
+
+Karist est une manière plus simple de configurer et déployer ses applications sur Kubernetes. Plus concrètement :
+
+* Aucun CRD requis dans vos clusters Kubernetes
+* Support natif d'une infinité d'environnement
+* Structure opiniatée de repository Git
+* Implémentation de fonctions muables
+* Une CLI pour initialiser, prédire et appliquer les changements
+
+Il peut être comparé avec **Helm**, bien que plus limité dans ses fonctions.
+
+## Installation
+
+Karist dépend entièrement de Ruby (> 3.0) car il est construit avec, mais aucune connaissance de Ruby n'est nécessaire pour utiliser cette application.
+
+```bash
+gem install karist
+```
+
+## Quick start
+
+### Concepts
+
+Karist s'article autour des opinions suivants:
+
+* Un fichier YAML ne doit contenir que du YAML
+* Les environnements concernent des valeurs parfois communes, parfois différentes
+* Un déploiement Kubernetes a besoin de plusieurs manifests (Deployment, Service, Ingress, ServiceAccount...), tous doivent être liés
+* L'utilisation des fonctions natives de Kubernetes doit être mis en avant
+
+Le lexique suivant s'applique à Karist:
+
+* `template`: un template est un dossier contenant plusieurs manifests Kubernetes. Un bon manifest doit pouvoir être modifié aisément par injection de variables.
+* `customization`: une customization est l'application de variables à un manifest Kubernetes appartant à un template.
+* `release`: une release est l'instantiation d'un template en accord avec des customizations appliquées à ses manifests.
+* `environment`: un environnement possède une ou plusieurs releases, qui sont des templates adaptés au contexte de l'environnement.
+
+```bash
+karist --init .
+```
+
+Crée une structure initiale dans le répertoire courant, directement utilisable.
+
+```
+.
+├── templates
+│   ├── stateless-app
+│   │   ├── karist.yml
+│   │   └── manifests
+│   │       ├── deployment.yml
+│   │       ├── service.yml
+│   │       └── serviceaccount.yml
+│   └── yourapp
+├── environments
+│   ├── development
+│   │   ├── releases.yml
+│   │   └── nginx
+│   │       └── custom.yml
+│   ├── local
+│   └── production
+└── karist.yml
+```
+
+Le fichier releases.yml indique par défaut ceci:
+
+```
+releases:
+  - name: nginx
+    namespace: default
+    template: stateless-app
+```
+
+Lors de l'exécution de la commande suivante :
+
+```bash
+karist --render --env development
+```
+
+Karist va automatiquement utiliser les manifests de `stateless-app` et charger les variables définies dans le fichier `custom.yml`.
+
+## Variables et fonctions
+
+Helm utilise un moteur de langage qui rend selon moi la lecture de fichiers YAML complexe. En créant Karist, j'ai préféré mettre en avant la simplicité de YAML en implémentant une logique **au niveau des valeurs** des types standards.
+Ainsi, des fonctions (toujours préfixées par _) sont utilisables auprès des manifests:
+
+```
+# templates/stateless-app/manifests/deployment.yml
+yaml
+apiVersion: v1
+metadata:
+  name: $release.name
+  labels:
+    _merge: release.labels
+    karist/template-name: stateless-app
+```
+
+```yaml
+# environments/development/nginx/custom.yml
+release:
+  name: nginx
+  labels:
+    key: value
+```
+
+Lors de l'évaluation du manifest, Karist remplace les fonctions par une évaluation. 
+
+```yaml
+# karist --dry-render \
+#   ./templates/stateless-app/manifests/deployment.yml
+#   ./environments/development/nginx/custom.yml
+
+apiVersion: v1
+metadata:
+  name: nginx
+  labels:
+    karist/template-name: stateless-app
+    key: value
+```
+## Functions
+
+WIP
+
+```
+$variable: inserts a string from custom.yml
+_merge: merges the current dictionnary with dictionnary from custom.yml
+_sum: recursively sums an array of values (curry)
+_concat: recursively concatenates an array of values (curry)
+```

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: %i[test rubocop]

data/bin/karist

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "thor"
+require "karist"
+
+require "optparse"
+
+include Karist
+
+class << Thor
+  def exit_on_failure?
+    true
+  end
+end
+
+class KaristCLI < Thor
+  
+  desc "init PATH", "Generates a initial project at PATH"
+  def init(path)
+    Generator.copy_to_path!(path)
+    exit(0)
+  end
+
+  desc "render ENV", "Render releases from environment ENV", default: "development"
+  option :dry_run, type: :boolean, desc: "Shows result from mutations to STDOUT", default: false
+  option :root, type: :string, desc: "Path to root Karist project", default: Dir.pwd
+  option :output, type: :string, desc: "Indicates where final files should be saved", default: "#{Dir.pwd}/output"
+  def render(env)
+    Dir.chdir(options[:root]) do
+      app = Renderer.new(env)
+      app.render
+
+      if options[:dry_run]
+        puts app.display
+        exit(0)
+      end
+
+      if app.save_to_path!(options[:output])
+        puts "Files were generated successfully ! 🥳"
+        exit(0)
+      end
+    end
+  end
+end
+
+KaristCLI.start(ARGV)
+

data/lib/examples/environments/development/nginx/custom.yml

@@ -0,0 +1,16 @@
+---
+name: nginx
+
+image:
+  repo: nginx
+  tag: latest
+
+port: 80
+
+common:
+  labels:
+    app: nginx
+    karist.io/image: 
+      _concat:
+        items: ["$image.repo", "$image.tag"]
+        sep: ":"

data/lib/examples/environments/development/releases.yml

@@ -0,0 +1,5 @@
+---
+releases:
+  - name: nginx
+    namespace: default
+    template: stateless

data/lib/examples/templates/stateless/manifests/deployment.yml

@@ -0,0 +1,31 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name:
+    _concat:
+        items:
+            - $name
+            - deployment
+        sep: "-"
+  labels:
+    _merge: common.labels
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+        _merge: common.labels
+  template:
+    metadata:
+      labels:
+        _merge: common.labels
+    spec:
+      containers:
+      - name: $name
+        image: 
+            _concat:
+                items:
+                    - $image.repo
+                    - $image.tag
+                sep: ":"
+        ports:
+        - containerPort: $port

data/lib/karist/generator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Karist
+  class Generator
+    def self.copy_to_path!(path)
+      examples_dir = File.dirname(__dir__) + "/examples"
+      FileUtils.cp_r(examples_dir, path, verbose: false)
+    end
+  end
+end

data/lib/karist/patch/array.rb

@@ -0,0 +1,6 @@
+class Array
+  # [a, b, c] = [a.mutate, b.mutate, c.mutate]
+  def mutate(mutations)
+    self.map {|z| z.mutate(mutations)}
+  end
+end

data/lib/karist/patch/hash.rb

@@ -0,0 +1,76 @@
+class Hash
+  def mutate(mutations)
+    _merge(mutations)
+
+    sum_result = _sum(mutations)
+    return sum_result[0] if sum_result[1]
+    
+    concat = _concat(mutations)
+    if concat.is_a?(String)
+      return concat
+    end
+
+    self.each {|a, z| self[a] = z.mutate(mutations)}
+  end
+
+  # { _sum: [x, y, z]} = x + (y + z)
+  def _sum(mutations)
+    if self.key?(:_sum)
+      return [self[:_sum].map{|el| el.mutate(mutations)}.sum, true]
+    end
+
+    self
+  end
+
+  # { _merge: x, **} = {**, x}
+  def _merge(mutations)
+    if self.key?(:_merge)
+      self.merge!(mutations.dig_str(self[:_merge], mutations))
+      self.delete(:_merge)
+    end
+  
+    self
+  end
+
+  # {_concat: {items: [a, b], sep: sep}} = a`sep`b
+  def _concat(mutations)
+    if self.key?(:_concat)
+      case self[:_concat]
+      in {items: items, sep: sep}
+        return items.mutate(mutations).join(sep)
+      end
+    end
+  end
+
+  def dig_str(str, mutations)
+    self.dig(*str.split(".").map{|k| k.to_sym}).mutate(mutations)
+  end
+
+  # monkey-patch from Rails code to implement
+  # #deep_symbolize_keys.
+  # https://github.com/rails/rails/blob/19eebf6d33dd15a0172e3ed2481bec57a89a2404/activesupport/lib/active_support/core_ext/hash/keys.rb#L65
+  def deep_symbolize_keys
+    deep_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object(self.class.new) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  def deep_stringify_keys
+    deep_transform_keys(&:to_s)
+  end
+end

data/lib/karist/patch/integer.rb

@@ -0,0 +1,5 @@
+class Integer
+  def mutate(mutations)
+    self
+  end
+end

data/lib/karist/patch/string.rb

@@ -0,0 +1,13 @@
+class String
+  # "_ -> x" = y
+  # "_from x" = y
+  def mutate(mutations)
+    case self.split("$")
+    in ["", from]
+      return mutations.dig_str(from, mutations)
+    else
+    end
+
+    return self
+  end
+end

data/lib/karist/patch/true_false.rb

@@ -0,0 +1,17 @@
+class TrueClass
+  def mutate(mutations)
+    self
+  end
+end
+
+class FalseClass
+  def mutate(mutations)
+    self
+  end
+end
+
+class NilClass
+  def mutate(mutations)
+    self
+  end
+end

data/lib/karist/release.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Release
+  attr_reader :results, :name
+
+  def initialize(release, release_file_obj)
+    @release_file = release_file_obj
+    @name = release.fetch(:name)
+    @namespace = release.fetch(:namespace, "default")
+    @template = release.fetch(:template)
+    @results = {}
+  end
+
+  def render
+    custom_file = "#{@release_file.env_path}/#{@name}/custom.yml"
+    mutations = YAML.safe_load(File.read(custom_file)).deep_symbolize_keys
+
+    manifests_path = "#{@release_file.templates_path}/#{@template}/manifests/**.yml"
+    manifest_files = Dir.glob(manifests_path)
+    manifest_files.each do |manifest_file|
+      content = YAML.safe_load(File.read(manifest_file)).deep_symbolize_keys
+      @results[manifest_file] = content.mutate(mutations)
+    end
+  end
+
+  def marshal_all_yaml
+    @results.map do |k, _|
+      marshal_yaml(k)
+    end
+  end
+
+  def marshal_yaml(k)
+    @results[k].deep_stringify_keys.to_yaml
+  end
+end

data/lib/karist/release_file.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class ReleaseFile
+  attr_reader :env_path, :templates_path, :releases
+
+  def initialize(release_file, env_path, templates_path)
+    @env_path = env_path
+    @templates_path = templates_path
+
+    @releases = release_file.fetch(:releases, []).map do |release|
+      Release.new(release, self)
+    end
+  end
+
+  def render_all
+    @releases.each do |release|
+      release.render
+    end
+  end
+
+  def display_all
+    @releases.map do |release|
+      release.marshal_all_yaml
+    end
+  end
+end

data/lib/karist/renderer.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Renderer
+  def initialize(env, root_path=".")
+    @env_path = "#{root_path}/environments/#{env}"
+    @templates_path = "#{root_path}/templates"
+
+    @release_file = File.read("#{@env_path}/releases.yml").then do |f|
+      YAML.safe_load(f).then do |y|
+        y.deep_symbolize_keys.then do |r|
+          ReleaseFile.new(r, @env_path, @templates_path)
+        end
+      end
+    end
+  end
+
+  def render
+    @release_file.render_all
+  end
+
+  def display
+    @release_file.display_all
+  end
+
+  def save_to_path!(path)
+    begin
+      FileUtils.mkdir_p(path)
+      @release_file.releases.each do |release|
+        FileUtils.mkdir_p("#{path}/#{release.name}")
+        release.results.each do |filename, result|
+          r_filename = filename.split("/")
+          case r_filename
+          in [*subpath, filename]
+            result_path = "#{path}/#{release.name}/#{subpath.join("/")}"
+            FileUtils.mkdir_p(result_path)
+            File.open("#{result_path}/#{filename}", "a+") do |f|
+              f.write(result.deep_stringify_keys.to_yaml)
+            end
+          end
+        end
+      end
+      return true
+    rescue => e
+      raise e
+      return false
+    end
+  end
+end
+    

data/lib/karist/version.rb

@@ -0,0 +1,5 @@
+# frozen_strint_literal: true
+
+module Karist
+  VERSION = "0.1.7"
+end

data/lib/karist.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require "yaml"
+require "json"
+
+require_relative "karist/version"
+require_relative "karist/patch/array"
+require_relative "karist/patch/hash"
+require_relative "karist/patch/string"
+require_relative "karist/patch/true_false"
+require_relative "karist/patch/integer"
+
+require_relative "karist/generator"
+require_relative "karist/renderer"
+require_relative "karist/release_file"
+require_relative "karist/release"
+
+module Karist
+  class GenericError < StandardError; end
+  class FunctionsError < GenericError; end
+  class SyntaxError < GenericError; end
+  class ParserError < GenericError; end
+  class NotAHashError < ParserError; end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: karist
+version: !ruby/object:Gem::Version
+  version: 0.1.7
+platform: ruby
+authors:
+- Mimosao
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Karist simplifies development of manifests and releases on Kubernetes
+  by automating templating operations.
+email:
+- mimosao@duck.com
+executables:
+- karist
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- LICENSE
+- README.md
+- Rakefile
+- bin/karist
+- lib/examples/environments/development/nginx/custom.yml
+- lib/examples/environments/development/releases.yml
+- lib/examples/templates/stateless/manifests/deployment.yml
+- lib/karist.rb
+- lib/karist/generator.rb
+- lib/karist/patch/array.rb
+- lib/karist/patch/hash.rb
+- lib/karist/patch/integer.rb
+- lib/karist/patch/string.rb
+- lib/karist/patch/true_false.rb
+- lib/karist/release.rb
+- lib/karist/release_file.rb
+- lib/karist/renderer.rb
+- lib/karist/version.rb
+homepage: https://github.com/mimosao/karist
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/mimosao/karist
+  source_code_uri: https://github.com/mimosao/karist
+  changelog_uri: https://github.com/mimosao/karist
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Karist is a templating system for Kubernetes
+test_files: []