metatron 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe8d0dcac1a47b872ca203dea9ec4e816e07fdb2bb14fd01f6458ca4b7789cef
-  data.tar.gz: 255bc8c1efdd1c173455f3b28533ceffd70e34115aad86dba1f685dfceba1318
+  metadata.gz: 4dee81a42c5ec6246f3d6a8e9399040dadd9d129b38f1b8b807671f89952fbc9
+  data.tar.gz: 1eb701979a19633f39251635b34aaefc6355ddc6174671e68bab40c6ad7216a3
 SHA512:
-  metadata.gz: ca1ba6ad7b4b5aa5677b6e7bbd30fe7b643f1f9459232a950d97684430fec3d3c7b710c327aa5a98e8d9324ebe457950df9acb1b50df0678eb875b2f869b6a8d
-  data.tar.gz: 1c7bc21979e3087dd5e55a381d7fddb9ade45159a72a105ba6d306dd60a8cb34828bad8d9a3ee7db6e1025f5b839e287a3bc21daaa834cb8aa49f31ade19943d
+  metadata.gz: 70ae144a7cc7ed33b0c623cc93045439f3b78c4d4e95ee85da2c6bef23aa41c3cb7c0bde2fb4ef51becf7a794b7e8e2899919c9817e54f3f83027a5b51b5e020
+  data.tar.gz: 627ccee22056a72d03f04e1150d3f3d315350942e5b6f44d07861e17afd051782444922fd04ac9d71c55fe75472794c45cddc2b12144daf4285713d79b91d916

data/.rubocop.yml

@@ -56,3 +56,6 @@ Style/StringLiteralsInInterpolation:
 Style/StringConcatenation:
   Exclude:
   - 'Rakefile'
+
+RSpec/ExampleLength:
+  Max: 10

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/CONTRIBUTING.md

@@ -0,0 +1,47 @@
+# Contributing
+
+## How to Contribute Code
+
+I'm so glad you're reading this, because we need volunteer developers to help this project grow and thrive!
+
+Before you begin, ensure that your contribution is associated with a [GitHub issue](https://github.com/jgnagy/metatron/issues). If there isn't an existing issue, please create one.
+
+1. Fork the repository
+2. Create a new branch (`git checkout -b feature-branch`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin feature-branch`)
+5. Create a new [Pull Request](http://help.github.com/pull-requests/)
+
+### Testing
+
+Please make sure that your code passes the existing tests and add tests for any new functionality. Please write [RSpec](https://rspec.info/) examples for new features you add or modify.
+
+To execute the tests, run `bundle exec rake spec`.
+
+### Coding Style
+
+This project uses [Rubocop](https://rubocop.org/) to enforce a consistent coding style. Please make sure that your code passes the Rubocop checks.
+
+To execute Rubocop, run `bundle exec rake rubocop`.
+
+### Documentation
+
+Please make sure that your code is well documented. If you add new features, please add documentation for them. This project uses [YARD](https://yardoc.org/) for documentation, so please add YARD tags to your code when appropriate.
+
+### License
+
+By contributing your code, you agree to license your contribution under the terms of the [MIT License](LICENSE.txt).
+
+## Code of Conduct
+
+By participating in this project, you agree to abide by our [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## Reporting Bugs
+
+Please use the [GitHub issue tracker](https://github.com/jgnagy/metatron/issues) to report any bugs.
+
+## Suggesting Enhancements
+
+If you have ideas for enhancements or improvements please use the [GitHub issue tracker](https://github.com/jgnagy/metatron/issues) to suggest them.
+
+Thank you for your interest in contributing!

data/Gemfile.lock

@@ -1,11 +1,9 @@
 PATH
   remote: .
   specs:
-    metatron (0.4.2)
+    metatron (0.6.0)
       json (~> 2.6)
-      puma (~> 6.3)
-      sinatra (~> 3.1)
-      sinatra-contrib (~> 3.1)
+      rack (>= 2.2.8, < 4)
 
 GEM
   remote: https://rubygems.org/
@@ -24,24 +22,16 @@ GEM
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     language_server-protocol (3.17.0.3)
-    multi_json (1.15.0)
-    mustermann (3.0.0)
-      ruby2_keywords (~> 0.0.1)
-    nio4r (2.6.0)
-    nokogiri (1.15.4-arm64-darwin)
+    nokogiri (1.15.5-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.15.4-x86_64-linux)
+    nokogiri (1.15.5-x86_64-linux)
       racc (~> 1.4)
     parallel (1.23.0)
     parser (3.2.2.4)
       ast (~> 2.4.1)
       racc
-    puma (6.4.0)
-      nio4r (~> 2.0)
     racc (1.7.3)
-    rack (2.2.8)
-    rack-protection (3.1.0)
-      rack (~> 2.2, >= 2.2.4)
+    rack (3.0.8)
     rack-test (2.1.0)
       rack (>= 1.3)
     rainbow (3.1.1)
@@ -88,7 +78,6 @@ GEM
       rubocop-capybara (~> 2.17)
       rubocop-factory_bot (~> 2.22)
     ruby-progressbar (1.13.0)
-    ruby2_keywords (0.0.5)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
@@ -98,17 +87,6 @@ GEM
       simplecov (~> 0.19)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    sinatra (3.1.0)
-      mustermann (~> 3.0)
-      rack (~> 2.2, >= 2.2.4)
-      rack-protection (= 3.1.0)
-      tilt (~> 2.0)
-    sinatra-contrib (3.1.0)
-      multi_json
-      mustermann (~> 3.0)
-      rack-protection (= 3.1.0)
-      sinatra (= 3.1.0)
-      tilt (~> 2.0)
     solargraph (0.49.0)
       backport (~> 1.2)
       benchmark

data/README.md

@@ -2,359 +2,8 @@
 
 Metatron is a Ruby library for creating [Metacontroller](https://metacontroller.github.io/metacontroller/)-based custom Kubernetes controllers.
 
-The intention is to make it as easy as possible to use Ruby to manage [custom resources](https://kubernetes.io/docs/concepts/api-extension/custom-resources/) within your Kubernetes infrastructure. No Golang required to listen for and respond to resources based on your own [CustomResourceDefinition](https://kubernetes.io/docs/tasks/access-kubernetes-api/extend-api-custom-resource-definitions/) or to modify existing kubernetes resources via a [DecoratorController](https://metacontroller.github.io/metacontroller/api/decoratorcontroller.html).
+The intention is to make it as easy as possible to use Ruby to manage [custom resources](https://kubernetes.io/docs/concepts/api-extension/custom-resources/) within your Kubernetes infrastructure. No Golang required!
 
-Your Ruby code doesn't have to have any _real_ knowledge of the Kubernetes environment in which it operates; Metacontroller takes care of all the Kubernetes interactions and Metatron handles providing the JSON interface. Just write a `sync` method that can receive and respond with the appropriate Hashes and you're on your way!
+For more information, see the [Metatron Wiki on GitHub](https://github.com/jgnagy/metatron/wiki)!
 
-## Usage
-
-For a complete walk-through, check out my [blog mini-series](https://therubyist.org/2022/10/25/kubernetes-controllers-via-metatron-part-1/) about Metatron!
-### Getting Started
-
-To use Metatron, first decide what type of Metacontroller you'd like to create, mostly based on the type(s) of resource(s) you'll manage. Most of the time, what you want is a Custom Resource that has child resources, which means you'll want a [Composite Controller](https://metacontroller.github.io/metacontroller/api/compositecontroller.html).
-
-Reading the [Metacontroller user's guide](https://metacontroller.github.io/metacontroller/guide.html) will be pretty helpful but isn't strictly required.
-
-You'll need to [install Metacontroller](https://metacontroller.github.io/metacontroller/guide/install.html) into your cluster before proceeding. This guide doesn't provide a recommendation on how to do that, but it isn't very difficult.
-
-### Creating a Composite Controller
-
-As an example, let's suppose we want to simplify launching blogs for users. Each `Blog` resource should have its own application server (as a `Deployment`), a database (as a `StatefulSet`), a Kubernetes `Service`, and an `Ingress`. A `Blog` will probably have a `name`, an `hostname` (which we'll derive based on its name), and a `username` and `password` (as a `Secret`) to restrict who can author content.
-
-This means we'll want a `Blog` custom resource and it'll need a few basic properties, like those listed above. It'll also need to specify a container image, and a number of replicas (so we can scale it up and down).
-
-Here's how that CRD (let's call it `blog-crd.yaml`) might look:
-
-```yaml
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  name: blogs.therubyist.org
-spec:
-  group: therubyist.org
-  names:
-    kind: Blog
-    plural: blogs
-    singular: blog
-  scope: Namespaced
-  versions:
-  - name: v1
-    served: true
-    storage: true
-    subresources:
-      status: {}
-    schema:
-      openAPIV3Schema:
-        type: object
-        properties:
-          spec:
-            type: object
-            properties:
-              image:
-                type: string
-              replicas:
-                type: integer
-                minimum: 1
-              storage:
-                type: object
-                properties:
-                  app:
-                    type: string
-                  db:
-                    type: string
-```
-
-This means we'll be able to query our Kubernetes cluster for `blogs`. You might eventually want to expand the field list, or simplify it and defer to your controller for validating it. You'll also probably want to make `metadata.name` and `spec.group` use a real domain to avoid potential conflicts. This should be safe to `kubectl apply` as the CRD doesn't do much on its own.
-
-Now, you'll need to define a `CompositeController` resource (let's call this `blog-controller.yaml`) that instructs Metacontroller where to send sync requests:
-
-```yaml
-apiVersion: metacontroller.k8s.io/v1alpha1
-kind: CompositeController
-metadata:
-  name: blog-controller
-spec:
-  generateSelector: true
-  parentResource:
-    apiVersion: therubyist.org/v1
-    resource: blogs
-  childResources:
-  - apiVersion: apps/v1
-    resource: deployments
-    updateStrategy:
-      method: InPlace
-  - apiVersion: apps/v1
-    resource: statefulsets
-    updateStrategy:
-      method: InPlace
-  - apiVersion: v1
-    resource: services
-    updateStrategy:
-      method: InPlace
-  - apiVersion: networking.k8s.io/v1
-    resource: ingresses
-    updateStrategy:
-      method: InPlace
-  - apiVersion: v1
-    resource: secrets
-    updateStrategy:
-      method: InPlace
-  hooks:
-    sync:
-      webhook:
-        service:
-          name: blog-controller
-          namespace: blog-controller
-          port: 9292
-          protocol: http
-        path: /sync
-```
-
-Before applying the above though, we'll need to actually create a service that can response to sync requests. That's where Metatron comes in!
-
-### Creating a Sync Controller with Metatron
-
-As Metatron is a tool for creating Ruby projects, you'll need a few prerequistes. First, make a directory (and git repo) for your controller:
-
-```sh
-$ git init blog_controller && cd blog_controller
-```
-
-We'll need a `Gemfile` to ensure we have Metatron installed:
-
-```ruby
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gem "metatron"
-```
-
-We'll also need a `config.ru` file to instruct [`rack`](https://github.com/rack/rack) how to route requests:
-
-```ruby
-# frozen_string_literal: true
-
-# \ -s puma
-
-require "metatron"
-require_relative "./lib/blog_controller/sync"
-
-use Rack::ShowExceptions
-use Rack::Deflater
-
-mappings = {
-  # This one is built-in to Metatron and is useful for monitoring
-  "/ping" => Metatron::Controllers::Ping.new,
-  # We'll need to make this one
-  "/sync" => BlogController::Sync.new
-}
-
-run Rack::URLMap.new(mappings)
-```
-
-Finally, before we start hacking on some actual Metatron-related code, we'll need a `Dockerfile` to create an image that we can deploy to Kubernetes:
-
-```dockerfile
-FROM ruby:3.1
-
-RUN mkdir -p /app
-
-COPY config.ru /app/
-COPY Gemfile /app/
-COPY Gemfile.lock /app/
-COPY lib/ /app/lib/
-
-RUN apt update && apt upgrade -y
-RUN useradd appuser -d /app -M -c "App User"
-RUN chown appuser /app/Gemfile.lock
-
-USER appuser
-WORKDIR /app
-RUN bundle install
-
-ENTRYPOINT ["bundle", "exec"]
-CMD ["puma"]
-```
-
-*Phew*, ok, with all that out of the way, we can get started with our development. We'll need to create a `Metatron::SyncController` subclass with a `sync` method. We'll put this in `lib/blog_controller/sync.rb`:
-
-```ruby
-# frozen_string_literal: true
-
-module BlogController
-  class Sync < Metatron::SyncController
-    # This method needs to return a Hash which will be converted to JSON
-    # It should have the keys "status" (a Hash) and "children" (an Array)
-    def sync
-      # request_body is a convenient way to access the data provided by MetaController
-      parent = request_body["parent"]
-      existing_children = request_body["children"]
-      desired_children = []
-
-      # first, let's create the DB and its service
-      desired_children += construct_db_resources(parent, existing_children)
-
-      # now let's make the app and its parts
-      db_secret = desired_children.find { |r| r.kind == "Secret" && r.name.end_with?("db") }
-      desired_children += construct_app_resources(parent, db_secret)
-
-      # We might eventually want a mechanism to build status based on the world:
-      #   status = compare_children(request_body["children"], desired_children)
-      status = {}
-
-      { status:, children: desired_children }
-    end
-
-    def construct_app_resources(parent, db_secret)
-      resources = []
-      app_db_secret = construct_app_secret(parent["metadata"], db_secret)
-      resources << app_db_secret
-      app_deployment = construct_app_deployment(
-        parent["metadata"], parent["spec"], app_db_secret
-      )
-      resources << app_deployment
-      app_service = construct_service(parent["metadata"], app_deployment)
-      resources << app_service
-      resources << construct_ingress(parent["metadata"], app_service)
-      resources
-    end
-
-    def construct_db_resources(parent, existing_children)
-      resources = []
-      db_secret = construct_db_secret(parent["metadata"], existing_children["Secret.v1"])
-      resources << db_secret
-      db_stateful_set = construct_db_stateful_set(db_secret)
-      resources << db_stateful_set
-      db_service = construct_service(
-        parent["metadata"], db_stateful_set, name: "db", port: 3306
-      )
-      resources << db_service
-      resources
-    end
-
-    def construct_db_stateful_set(secret)
-      stateful_set = Metatron::Templates::StatefulSet.new("db")
-      container = Metatron::Templates::Container.new("db")
-      container.image = "mysql:8.0"
-      container.envfrom << secret.name
-      stateful_set.containers << container
-      stateful_set.additional_pod_labels = { "app.kubernetes.io/component": "db" }
-      stateful_set
-    end
-
-    def construct_app_deployment(meta, spec, auth_secret)
-      deployment = Metatron::Templates::Deployment.new(meta["name"], replicas: spec["replicas"])
-      container = Metatron::Templates::Container.new("app")
-      container.image = spec["image"]
-      container.envfrom << auth_secret.name
-      container.ports << { name: "web", containerPort: 3000 }
-
-      deployment.containers << container
-      deployment.additional_pod_labels = { "app.kubernetes.io/component": "app" }
-      deployment
-    end
-
-    def construct_ingress(meta, service)
-      ingress = Metatron::Templates::Ingress.new(meta["name"])
-      ingress.add_rule(
-        "#{meta["name"]}.blogs.therubyist.org": { service.name => service.ports.first[:name] }
-      )
-      ingress.add_tls("#{meta["name"]}.blogs.therubyist.org")
-      ingress
-    end
-
-    def construct_service(meta, resource, name: meta["name"], port: "3000")
-      service = Metatron::Templates::Service.new(name, port)
-      service.additional_selector_labels = resource.additional_pod_labels
-      service
-    end
-
-    def construct_app_secret(meta, db_secret)
-      # We'll want to use the password we specified for the DB user
-      user_pass = db_secret.data["MYSQL_PASSWORD"]
-      Metatron::Templates::Secret.new(
-        "#{meta["name"]}app",
-        {
-          "DATABASE_URL" => "mysql2://#{meta["name"]}:#{user_pass}@db:3306/#{meta["name"]}"
-        }
-      )
-    end
-
-    def construct_db_secret(meta, existing_secrets)
-      name = "#{meta["name"]}db"
-      existing = (existing_secrets || {})[name]
-      data = if existing
-               {
-                 "MYSQL_ROOT_PASSWORD" => Base64.decode64(existing.dig("data", "MYSQL_ROOT_PASSWORD")),
-                 "MYSQL_DATABASE" => Base64.decode64(existing.dig("data", "MYSQL_DATABASE")),
-                 "MYSQL_USER" => Base64.decode64(existing.dig("data", "MYSQL_USER")),
-                 "MYSQL_PASSWORD" => Base64.decode64(existing.dig("data", "MYSQL_PASSWORD"))
-               }
-             else
-               {
-                 "MYSQL_ROOT_PASSWORD" => SecureRandom.urlsafe_base64(12),
-                 "MYSQL_DATABASE" => meta["name"],
-                 "MYSQL_USER" => meta["name"],
-                 "MYSQL_PASSWORD" => SecureRandom.urlsafe_base64(8)
-               }
-             end
-      Metatron::Templates::Secret.new(name, data)
-    end
-  end
-end
-```
-
-That might seem like a lot of code, but it does a **lot** of heavy lifting for you in creating Kubernetes resources. Try creating all the above Kubernetes resources by hand and you'll see what Metatron is doing for you. It is pretty likely you'll want to adjust a lot of the above code, but it should be a decent starting point.
-
-To use it, you'll need to create your `Gemfile.lock` file then work on your Docker image:
-
-```sh
-$ bundle install
-$ docker build -t "blogcontroller:latest" .
-```
-
-You can test your controller locally by running the image:
-
-```sh
-$ docker run -it --rm -p 9292:9292 "blogcontroller:latest"
-```
-
-Try POSTing a request via `curl` and inspecting the JSON response to see what your controller is doing for you:
-
-```sh
-$ curl \
-  -H "Content-Type: application/json" \
-  --data '{"parent": {"metadata": {"name": "foo"}, "spec": {"replicas": 1, "image": "nginx:latest"}}}' \
-  http://localhost:9292/sync
-```
-
-Once we've confirmed this works, we'll need to publish our image somewhere and run it. Make sure you update the Service details in `blog-controller.yaml` to reflect its actual location.
-
-### Using the New Composite Controller
-
-After your Metatron controller is up and running in your Kubernetes cluster, you'll need to actually `kubectl apply` your `blog-controller.yaml` file we created way above. Once that is deployed, you can create new `Blog` resources that look something like this (let's call it `test-blog.yaml`):
-
-```yaml
-apiVersion: therubyist.org/v1
-kind: Blog
-metadata:
-  name: test
-spec:
-  image: myapp:tag
-  replicas: 2
-  storage:
-    app: 15Gi
-    db: 5Gi
-```
-
-Note that `myapp:tag` should point to some image that is ready to run a blog. This is just an example and, much like the other resources we've created in this guide, it will almost certainly not work as-is. The `DATABASE_URL` secret we create in our Metatron controller should work well for a [Ruby on Rails](https://rubyonrails.org/) app though.
-
-Let's make a new namespace for this blog and launch it:
-
-```sh
-$ kubectl create namespace blog-test
-$ kubectl -n blog-test apply -f test-blog.yaml
-```
-
-You should be able to inspect the pods, services, etc. in the `blog-test` namespace and see your resources running!
+For help on how to get started, take a look at the [User Guide](https://github.com/jgnagy/metatron/wiki/User-Guide) in the Wiki!

data/Rakefile

@@ -16,4 +16,36 @@ task :demo do
   system("rackup --host 0.0.0.0 -P #{File.expand_path(".")}/tmp/daemon.pid")
 end
 
+desc "automatically bump the gem's version"
+task :bump, [:type] do |_t, args|
+  type = args[:type] || ENV["TYPE"] || "patch"
+  current_version = Metatron::VERSION
+  new_version = calculate_new_version(type)
+  puts "Bumping gem version from #{current_version} to #{new_version}"
+  update_version(new_version)
+end
+
 task default: %i[spec rubocop yard]
+
+def calculate_new_version(type)
+  version = Metatron::VERSION.split(".").map(&:to_i)
+  case type
+  when "patch"
+    version[2] += 1
+  when "minor"
+    version[1] += 1
+    version[2] = 0
+  when "major"
+    version[0] += 1
+    version[1] = 0
+    version[2] = 0
+  end
+
+  version.join(".")
+end
+
+def update_version(new_version)
+  file = File.read("lib/metatron/version.rb")
+  new_contents = file.gsub(/VERSION = "(.+)"/, %(VERSION = "#{new_version}"))
+  File.write("lib/metatron/version.rb", new_contents)
+end

data/lib/metatron/composite_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Metatron
+  # Implementes a Metacontroller CompositeController
+  # @see https://metacontroller.github.io/metacontroller/api/compositecontroller.html
+  class CompositeController < Controller
+    def initialize(env)
+      super
+      @strategy = nil
+    end
+
+    def calculate_customize_etag = nil
+    def calculate_sync_etag = nil
+    def customize = raise NotImplementedError
+    def finalize = raise NotImplementedError
+    def sync = raise NotImplementedError
+
+    private
+
+    STRATEGY = {
+      "/customize" => { data: :customize, etag: :calculate_customize_etag },
+      # finalize calls should be rare and unique enough that we don't need to worry about ETags
+      "/finalize" => { data: :finalize },
+      "/sync" => { data: :sync, etag: :calculate_sync_etag }
+    }.freeze
+
+    def _call
+      return access_control_allow_methods if request.options?
+      return not_found unless request.post?
+
+      @strategy = STRATEGY.fetch(request.path_info) { return not_found }
+
+      headers = {}
+
+      return Rack::Response[412, headers, []].to_a if etag_matches?(headers)
+
+      Rack::Response[200, headers, processed_data].to_a
+    end
+
+    def access_control_allow_methods
+      Rack::Response[200, { "access-control-allow-methods" => %w[POST] }, []].to_a
+    end
+
+    def not_found
+      Rack::Response[404, { "x-cascade" => "pass" }, []].to_a
+    end
+
+    def etag_matches?(headers)
+      return false unless (calculator = @strategy[:etag])
+      return false unless (raw_etag = public_send(calculator))
+
+      etag = +'"' << raw_etag << '"'
+      headers["etag"] = etag
+
+      (none_match = request.get_header("HTTP_IF_NONE_MATCH")) && none_match.include?(etag)
+    end
+
+    def processed_data
+      data = public_send(@strategy[:data])
+
+      if data[:children]
+        data[:children] = data[:children].map { |c| c.respond_to?(:render) ? c.render : c }
+      end
+
+      data.to_json
+    end
+  end
+end

data/lib/metatron/controller.rb

@@ -2,37 +2,37 @@
 
 module Metatron
   # Base class for API services
-  class Controller < Sinatra::Base
-    helpers Sinatra::CustomLogger
-
-    configure do
-      set :protection, except: :http_origin
-      set :logging, true
-      set :logger, Metatron.logger
-      set :show_exceptions, false
-    end
-
-    before do
-      # Sets up a useful variable (@json_body) for accessing a parsed request body
-      if request.content_type&.include?("json") && !request.body.read.empty?
-        request.body.rewind
-        @json_body = JSON.parse(request.body.read)
+  class Controller
+    class << self
+      def call(env)
+        new(env).call
       end
-    rescue StandardError => e
-      halt(400, { error: "Request must be JSON: #{e.message}}" }.to_json)
     end
 
-    error do
-      content_type :json
+    attr_accessor :params
 
-      e = env["sinatra.error"]
-      resp = { result: "error", message: e.message }
-      resp[:trace] = e.full_message if settings.environment.to_s != "production"
-      resp.to_json
+    def initialize(env)
+      @env = env
+      @request = Rack::Request.new(env)
     end
 
-    def request_body
-      @json_body
+    def call
+      begin
+        if request&.content_type&.include?("json")
+          body = request.body.read
+          request.body.rewind if request.body.respond_to?(:rewind)
+
+          self.params = JSON.parse(body) unless body.empty?
+        end
+      rescue JSON::ParserError => e
+        return [400, {}, [{ error: "Request must be JSON: #{e.message}" }.to_json]]
+      end
+
+      _call
     end
+
+    private
+
+    attr_reader :request
   end
 end

data/lib/metatron/controllers/ping.rb

@@ -3,33 +3,26 @@
 module Metatron
   module Controllers
     # Healthcheck service
-    class Ping < Sinatra::Application
-      configure do
-        set :logging, true
-        set :logger, Metatron.logger
-      end
-
-      before do
-        content_type "application/json"
+    class Ping
+      RESPONSE = { status: "up" }.to_json
 
-        halt 403 unless request.get? || request.options?
+      def call(env)
+        req = Rack::Request.new(env)
 
-        if request.get?
-          headers "X-Frame-Options" => "SAMEORIGIN"
-          headers "X-XSS-Protection" => "1; mode=block"
-        end
-      end
+        return access_control_allow_methods if req.options?
+        return [403, { Rack::CONTENT_TYPE => "application/json" }, []] unless req.get?
 
-      after do
-        headers "Access-Control-Allow-Methods" => %w[GET] if request.options?
+        Rack::Response[200, {
+          "content-type" => "application/json",
+          "x-frame-options" => "SAMEORIGIN",
+          "x-xss-protection" => "1; mode=block"
+        }, [RESPONSE]].to_a
       end
 
-      get "/" do
-        '{ "status": "up" }'
-      end
+      private
 
-      options "/" do
-        halt 200
+      def access_control_allow_methods
+        Rack::Response[200, { "access-control-allow-methods" => %w[GET] }, []].to_a
       end
     end
   end

data/lib/metatron/version.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
 module Metatron
-  VERSION = [
-    0, # major
-    4, # minor
-    2  # patch
-  ].join(".")
+  VERSION = "0.6.0"
 end

data/lib/metatron.rb

@@ -1,16 +1,11 @@
 # frozen_string_literal: true
 
 # Standard Library requirements
-require "base64"
 require "resolv"
 require "securerandom"
 require "time"
 require "logger"
 
-# External requirements
-require "sinatra/base"
-require "sinatra/custom_logger"
-
 # The top-level module for Metatron
 module Metatron
   class Error < StandardError; end
@@ -46,6 +41,6 @@ require "metatron/templates/service"
 require "metatron/templates/service_account"
 require "metatron/templates/stateful_set"
 require "metatron/controller"
-require "metatron/sync_controller"
+require "metatron/composite_controller"
 require "metatron/controllers/ping"
 require "metatron/railtie" if defined? Rails::Railtie

data/metatron.gemspec

@@ -26,10 +26,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = "~> 3.1"
 
-  spec.add_runtime_dependency "json",                 "~> 2.6"
-  spec.add_runtime_dependency "puma",                 "~> 6.3"
-  spec.add_runtime_dependency "sinatra",              "~> 3.1"
-  spec.add_runtime_dependency "sinatra-contrib",      "~> 3.1"
+  spec.add_runtime_dependency "json", "~> 2.6"
+  spec.add_runtime_dependency "rack", ">= 2.2.8", "< 4"
 
   spec.add_development_dependency "bundler",             "~> 2.3"
   spec.add_development_dependency "byebug",              "~> 11"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metatron
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Jonathan Gnagy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2023-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -25,47 +25,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.6'
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '6.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.3'
-- !ruby/object:Gem::Dependency
-  name: sinatra
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: 2.2.8
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: sinatra-contrib
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+        version: 2.2.8
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -246,6 +224,8 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -253,10 +233,10 @@ files:
 - Rakefile
 - bin/console
 - lib/metatron.rb
+- lib/metatron/composite_controller.rb
 - lib/metatron/controller.rb
 - lib/metatron/controllers/ping.rb
 - lib/metatron/railtie.rb
-- lib/metatron/sync_controller.rb
 - lib/metatron/template.rb
 - lib/metatron/templates/cluster_role.rb
 - lib/metatron/templates/cluster_role_binding.rb

data/lib/metatron/sync_controller.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Metatron
-  # Used for "normal" sync requests
-  class SyncController < Controller
-    options "/" do
-      headers "Access-Control-Allow-Methods" => ["POST"]
-      halt 200
-    end
-
-    post "/" do
-      if (provided_etag = calculate_etag)
-        etag provided_etag
-      end
-
-      data = sync
-      data[:children] = data[:children]&.map { |c| c.respond_to?(:render) ? c.render : c }
-      halt(data.to_json)
-    end
-
-    def calculate_etag = nil
-    def sync = raise NotImplementedError
-  end
-end