metatron 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9252f0668ef9d7bb533e87c696ee1c19968bfc2029b9c9992c2defe42360e8d7
-  data.tar.gz: f0570ad8ffd6ba0256316dce95f0143e5972117851f0e6080d4ff6a773fa8461
+  metadata.gz: 4dee81a42c5ec6246f3d6a8e9399040dadd9d129b38f1b8b807671f89952fbc9
+  data.tar.gz: 1eb701979a19633f39251635b34aaefc6355ddc6174671e68bab40c6ad7216a3
 SHA512:
-  metadata.gz: 8b80a57ab9b8deccfe861e08baedf2c220319443a89d38f3607dc20f8654243b29cb84d35c0da0a4c795f4619be6d32d1c8cb9ee799705046799456f79e5b7ba
-  data.tar.gz: 0d29f8ad2e9b74338ddf8ff2aaaf219541e069e5ae9cbad6cc2bc8ad6e30d65c9c723231d2cd86fc55778ae19bd9161cd60f1e5ac700a9159ebb166fe34fbf15
+  metadata.gz: 70ae144a7cc7ed33b0c623cc93045439f3b78c4d4e95ee85da2c6bef23aa41c3cb7c0bde2fb4ef51becf7a794b7e8e2899919c9817e54f3f83027a5b51b5e020
+  data.tar.gz: 627ccee22056a72d03f04e1150d3f3d315350942e5b6f44d07861e17afd051782444922fd04ac9d71c55fe75472794c45cddc2b12144daf4285713d79b91d916

data/Gemfile.lock

@@ -1,10 +1,9 @@
 PATH
   remote: .
   specs:
-    metatron (0.5.0)
+    metatron (0.6.0)
       json (~> 2.6)
-      sinatra (~> 3.1)
-      sinatra-contrib (~> 3.1)
+      rack (>= 2.2.8, < 4)
 
 GEM
   remote: https://rubygems.org/
@@ -23,21 +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)
-    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
     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)
@@ -84,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)
@@ -94,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

@@ -6,359 +6,4 @@ The intention is to make it as easy as possible to use Ruby to manage [custom re
 
 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: /blogs/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 installed both Metatron and a
-[`rack`][] compatible server:
-
-```ruby
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gem "metatron"
-gem "puma"
-```
-
-[`rack`]: https://github.com/rack/rack
-
-We'll also need a `config.ru` file to instruct [`rack`][] how to route requests:
-
-```ruby
-# frozen_string_literal: true
-
-# \ -s puma
-
-require "metatron"
-require_relative "./lib/blog_controller/composite_controller"
-
-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
-  "/blogs" => BlogController::CompositeController.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::CompositeController` subclass with a `sync` method. We'll put this in `lib/blog_controller/composite_controller.rb`:
-
-```ruby
-# frozen_string_literal: true
-
-module BlogController
-  class CompositeController < Metatron::CompositeController
-    # 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/blogs/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/lib/metatron/composite_controller.rb

@@ -4,51 +4,65 @@ module Metatron
   # Implementes a Metacontroller CompositeController
   # @see https://metacontroller.github.io/metacontroller/api/compositecontroller.html
   class CompositeController < Controller
-    options "/sync" do
-      headers "Access-Control-Allow-Methods" => ["POST"]
-      halt 200
+    def initialize(env)
+      super
+      @strategy = nil
     end
 
-    post "/sync" do
-      if (provided_etag = calculate_sync_etag)
-        etag provided_etag
-      end
+    def calculate_customize_etag = nil
+    def calculate_sync_etag = nil
+    def customize = raise NotImplementedError
+    def finalize = raise NotImplementedError
+    def sync = raise NotImplementedError
 
-      data = sync
-      data[:children] = data[:children]&.map { |c| c.respond_to?(:render) ? c.render : c }
-      halt(data.to_json)
-    end
+    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 = {}
 
-    options "/finalize" do
-      headers "Access-Control-Allow-Methods" => ["POST"]
-      halt 200
+      return Rack::Response[412, headers, []].to_a if etag_matches?(headers)
+
+      Rack::Response[200, headers, processed_data].to_a
     end
 
-    post "/finalize" do
-      # finalize calls should be rare and unique enough that we don't need to worry about ETags
+    def access_control_allow_methods
+      Rack::Response[200, { "access-control-allow-methods" => %w[POST] }, []].to_a
+    end
 
-      data = finalize
-      data[:children] = data[:children]&.map { |c| c.respond_to?(:render) ? c.render : c }
-      halt(data.to_json)
+    def not_found
+      Rack::Response[404, { "x-cascade" => "pass" }, []].to_a
     end
 
-    options "/customize" do
-      headers "Access-Control-Allow-Methods" => ["POST"]
-      halt 200
+    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
 
-    post "/customize" do
-      if (provided_etag = calculate_customize_etag)
-        etag provided_etag
+    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
 
-      halt(customize.to_json)
+      data.to_json
     end
-
-    def calculate_customize_etag = nil
-    def calculate_sync_etag = nil
-    def customize = raise NotImplementedError
-    def finalize = raise NotImplementedError
-    def sync = raise NotImplementedError
   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,5 +1,5 @@
 # frozen_string_literal: true
 
 module Metatron
-  VERSION = "0.5.0"
+  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

data/metatron.gemspec

@@ -26,9 +26,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = "~> 3.1"
 
-  spec.add_runtime_dependency "json",                 "~> 2.6"
-  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.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Jonathan Gnagy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-18 00:00:00.000000000 Z
+date: 2023-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -25,33 +25,25 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.6'
 - !ruby/object:Gem::Dependency
-  name: sinatra
+  name: rack
   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'
-- !ruby/object:Gem::Dependency
-  name: sinatra-contrib
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !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: 2.2.8
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement