gloo_ingress_adapter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97de21875d8934bcca64e1ab8e1b8462fc1f3db4a53f372c7d3aa0c711038bdc
+  data.tar.gz: c873372e2f8ee77d2be7c531d09f24cda4ed190b635a334123b677dc1e58902c
+SHA512:
+  metadata.gz: c79aa9f16640a0c6a78b324e6e8bd6db916b3b9567fa3ad5b622793878d571cb0ecc017552d1452da5a6f788f44e16bf29cebb144bccb99d29476d6b397b5f63
+  data.tar.gz: 22dc8fa2050e06649ccd4787ebf14c32d70baad5bfd82cd8fb25092c20dd54471d4ea1b7811c7358c23b85a906c488274cea59733865834d902d94d0e7e59e8c

data/README.md

@@ -0,0 +1,133 @@
+# Project
+
+Use [Gloo Edge][gloo] gateways with Kubernetes ingress resources. Gloo Edge supports ingress, however it requires you
+to deploy a separate gateway for this. With this adapter, you can integrate your Kubernetes ingresses into an existing
+gateway.
+
+The adapter works by monitoring ingress resources and automatically creating a Gloo route table for each ingress. You
+can then mount the created route tables automatically in your gateway.
+
+[gloo]: https://docs.solo.io/gloo-edge/latest/
+
+## Install
+
+Install a Gloo Edge gateway:
+
+```bash
+kubectl create namespace gloo-system
+helm install gloo gloo --namespace gloo-system --repo https://storage.googleapis.com/solo-public-helm \
+  --set gateway.readGatewaysFromAllNamespaces=true
+```
+
+You can also have a look at the [Gloo documentation][gloo-install] for detailed installation instructions.
+
+[gloo-install]: https://docs.solo.io/gloo-edge/master/installation/gateway/kubernetes/
+
+Install the ingress adapter into namespace `gloo-system`:
+
+```bash
+git checkout git@github.com:CaperWhite/gloo-ingress-adapter.git
+cd gloo-ingress-adapter
+helm --namespace gloo-system install gloo-ingress-adapter charts
+```
+
+After this, the ingress adapter should be up and running, and monitoring ingress resources. By default it will create
+route tables for ingress resources with ingress class name `gloo-route`.
+
+## Verify installation
+
+Deploy a test service:
+
+```bash
+kubectl create namespace ingress-test
+kubectl --namespace ingress-test apply --filename examples/test.yaml
+```
+
+Create an ingress resource for the test service:
+
+```bash
+cat <<-INGRESS | kubectl apply --namespace ingress-test --filename -
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: ingress-test
+spec:
+  ingressClassName: gloo-route
+  rules:
+  - http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: ingress-test
+            port:
+              number: 8080
+INGRESS
+```
+
+Verify a route table has been created:
+
+```bash
+kubectl --namespace ingress-test get routetable ingress-test -o yaml
+```
+
+Create a virtual service resource that automatically mounts the created route tables:
+
+```bash
+cat <<-SERVICE | kubectl --namespace gloo-system apply --filename -
+apiVersion: gateway.solo.io/v1
+kind: VirtualService
+metadata:
+  name: ingress-test
+spec:
+  virtualHost:
+    domains:
+    - ingress-test.local
+    routes:
+    - matchers:
+       - prefix: "/"
+      delegateAction:
+        selector:
+          labels:
+            ingress.caperwhite.com/protocol: http
+          namespaces:
+          - ingress-test
+SERVICE
+```
+
+Make the gateway accessible locally:
+
+```bash
+kubectl --namespace gloo-system port-forward service/gateway-proxy 8080:80
+```
+
+Check if you can access the service:
+
+```bash
+curl -H 'Host: ingress-test.local' http://127.0.0.1:8080
+```
+
+should return
+
+```json
+{"result":true}
+```
+
+Delete the ingress:
+
+```bash
+kubectl --namespace ingress-test delete ingress ingress-test
+```
+
+Verify the route table is gone:
+
+```bash
+kubectl --namespace ingress-test get routetable -A
+```
+
+## Acknowledgements
+
+"Gloo" is a trademark of [Solo.io, Inc.][solo].
+
+[solo]: https://www.solo.io

data/lib/gloo_ingress_adapter/client_factory.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "kubeclient"
+
+module GlooIngressAdapter
+  # Factory for Kubernetes clients
+  class ClientFactory
+    KUBERNETES_API_URL = "https://kubernetes.default.svc"
+
+    def initialize(kubeconfig:, logger:)
+      @kubeconfig = kubeconfig.freeze
+      @logger = logger
+    end
+
+    def create_client(version:, api: nil)
+      suffix = api ? "/apis/#{api}" : ""
+
+      options = {
+        timeouts: { open: 30, read: 30 },
+      }
+
+      url = KUBERNETES_API_URL
+
+      if @kubeconfig
+        context = Kubeclient::Config.read(@kubeconfig).context
+
+        url = context.api_endpoint
+
+        options[:auth_options] = context.auth_options
+        options[:ssl_options] = context.ssl_options
+      else
+        options[:auth_options] = { bearer_token_file: "/var/run/secrets/kubernetes.io/serviceaccount/token" }
+
+        if File.exist?("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt")
+          options[:ssl_options] = { ca_file: "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt" }
+        end
+      end
+
+      Kubeclient::Client.new("#{url}#{suffix}", version, **options)
+    end
+  end
+end

data/lib/gloo_ingress_adapter/controller.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string"
+require "gloo_ingress_adapter/resource_observer"
+require "kubeclient"
+require "logger"
+require "retriable"
+require "set"
+require "yaml"
+
+module GlooIngressAdapter
+  # Controller responsible for creating virtual services from ingress resources
+  class Controller
+    CONTROLLER_NAME = "caperwhite.com/gloo-ingress-adapter"
+
+    RETRY_ON = {
+      StandardError: nil,
+    }.freeze
+
+    def initialize(kubeconfig:, logger:, route_table_builder:)
+      @client_factory = ClientFactory.new(kubeconfig:, logger:).freeze
+      @logger = logger
+      @route_table_builder = route_table_builder
+      @ingress_classes = {}
+      @ingresses = {}
+    end
+
+    def run
+      logger.info("Running ingress adapter")
+    end
+
+    def watch
+      logger.info("Starting ingress adapter")
+
+      queue = Thread::Queue.new
+
+      ingress_class_observer = create_ingress_class_observer
+
+      ingress_class_observer.start(queue:)
+
+      ingress_observer = create_ingress_observer
+
+      ingress_observer.start(queue:)
+
+      loop do
+        event = queue.shift
+        handle_event(event)
+      end
+    rescue StandardError => e
+      log_exception(e)
+    end
+
+    protected
+
+    attr_reader :logger, :queue, :client_factory, :ingress_classes, :ingresses
+
+    def update_ingress_class(ingress_class)
+      logger.info("Updating ingress class #{ingress_class.metadata.name}")
+
+      existing_ingress_class = @ingress_classes[ingress_class.metadata.uid]
+
+      @ingress_classes[ingress_class.metadata.uid] = ingress_class
+
+      if @ingress_classes.empty?
+        logger.warn("Now handling no ingress classes")
+      else
+        logger.info("Now handling ingress classes #{@ingress_classes.values.map { |c| c.metadata.name }.join(", ")}")
+      end
+
+      controller_changed = existing_ingress_class.nil? ||
+                           ingress_class.spec.controller != existing_ingress_class.spec.controller
+
+      ingress_class_name_changed = existing_ingress_class.nil? ||
+                                   existing_ingress_class.metadata.name != ingress_class.metadata.name
+
+      if controller_changed
+        if ingress_class.spec.controller == CONTROLLER_NAME
+          update_ingresses(ingress_class:)
+        elsif existing_ingress_class && existing_ingress_class.spec.controller == CONTROLLER_NAME
+          delete_ingresses(ingress_class:) if controller_changed
+        end
+      elsif ingress_class_name_changed
+        update_ingresses(ingress_class:)
+      end
+    end
+
+    def update_ingresses(ingress_class:)
+      @ingresses.values.filter do |u|
+        u.spec.ingressClassName == ingress_class.metadata.name
+      end.each do |ingress|
+        update_ingress(ingress)
+      end
+    end
+
+    def delete_ingressses(ingress_class:)
+      @ingresses.values.filter do |u|
+        u.spec.ingressClassName == ingress_class.metadata.name
+      end.each do |ingress|
+        networking_client.delete_ingress(ingress.metadata.name, ingress.metadata.namespace)
+      end
+    end
+
+    def remove_ingress_class(uid:)
+      ingress_class = @ingress_classes.delete(uid) || raise("Unknown ingress class uid '#{uid}'")
+
+      logger.info("Removing ingress class #{ingress_class.metadata.name}")
+
+      delete_ingresses(ingress_class:) if ingress_class.spec.controller == CONTROLLER_NAME
+
+      ingress_class
+    end
+
+    def update_ingress(ingress)
+      @ingresses[ingress.metadata.uid] = ingress
+
+      msg = <<~MSG.squish
+        #{ingress.metadata.name} (namespace: #{ingress.metadata.namespace},
+        ingressClass: #{ingress.spec.ingressClassName || "(none)"})
+      MSG
+
+      if ingress_class_names.include?(ingress.spec.ingressClassName)
+        logger.info("Updating ingress #{msg}")
+
+        update_route_table(ingress:)
+      else
+        logger.info("Ignoring ingress #{msg}")
+      end
+    end
+
+    def remove_ingress(uid:)
+      ingress = @ingress_classes.delete(uid) || raise("Unknown ingress class uid '#{uid}'")
+
+      logger.info("Removed ingress #{ingress.metadata.name} (namespace: #{ingress.metadata.namespace})")
+
+      ingress
+    end
+
+    def handle_event(event)
+      raise("Received error event: #{event.to_nice_yaml}") if event.type == "ERROR"
+
+      logger.info("Handling event: #{event.object.kind} #{event.object.metadata.name} #{event.type.downcase}")
+      logger.debug { "Event object: #{event.to_nice_yaml}" }
+
+      raise "Unknown API version '#{event.object.apiVersion}'" if event.object.apiVersion != "networking.k8s.io/v1"
+
+      case event.object.kind
+      when "IngressClass"
+        handle_ingress_class_event(event)
+      when "Ingress"
+        handle_ingress_event(event)
+      else
+        raise "Received event for unknown object kind '#{event.object.kind}'"
+      end
+    end
+
+    def handle_ingress_class_event(event)
+      case event.type
+      when "ADDED", "MODIFIED"
+        update_ingress_class(event.object)
+      when "DELETED"
+        remove_ingress_class(event.object.metadata.name)
+      else
+        logger.error("Unknown event type '#{event.type}'")
+      end
+    end
+
+    def handle_ingress_event(event)
+      case event.type
+      when "ADDED", "MODIFIED"
+        update_ingress(event.object)
+      when "DELETED"
+        # Do nothing
+      else
+        logger.error("Unknown event type '#{event.type}'")
+      end
+    end
+
+    def update_route_table(ingress:)
+      metadata = ingress.metadata
+
+      logger.info "Updating route table for ingress '#{metadata.name}' (namespace: '#{metadata.namespace}')"
+      logger.debug { ingress.to_nice_yaml }
+
+      route_table = @route_table_builder.build(ingress:)
+
+      logger.debug { route_table.to_nice_yaml }
+
+      gateway_client.apply_route_table(route_table, field_manager: "gloo-ingress-adapter", force: true)
+    end
+
+    def create_ingress_class_observer
+      ResourceObserver.new(
+        kind: "ingressclasses",
+        client: client_factory.create_client(version: "v1", api: "networking.k8s.io"),
+        logger:
+      )
+    end
+
+    def create_ingress_observer
+      ResourceObserver.new(
+        kind: "ingresses",
+        client: client_factory.create_client(version: "v1", api: "networking.k8s.io"),
+        logger:
+      )
+    end
+
+    def ingress_class_names
+      @ingress_classes.values.map { |c| c.metadata.name }
+    end
+
+    def log_exception(exception)
+      logger.error("#{exception.message} (#{exception.class}/#{exception.class.ancestors})")
+      logger.debug(exception.backtrace.join("\n"))
+    end
+
+    def failsafe
+      yield
+    rescue StandardError => e
+      log_exception(e)
+      nil
+    end
+
+    def client
+      @client ||= client_factory.create_client(version: "v1")
+    end
+
+    def networking_client
+      @networking_client ||= client_factory.create_client(version: "v1", api: "networking.k8s.io")
+    end
+
+    def gateway_client
+      @gateway_client ||= client_factory.create_client(version: "v1", api: "gateway.solo.io")
+    end
+  end
+end

data/lib/gloo_ingress_adapter/resource_observer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "kubeclient"
+
+module GlooIngressAdapter
+  # Watcher for ingress resources
+  class ResourceObserver
+    # Thread running an observer
+    class ObserverThread < Thread
+      attr_reader :observer
+
+      def initialize(observer:, queue:)
+        @observer = observer
+
+        super { observer.watch(queue:) }
+
+        self.abort_on_exception = true
+        self.name = "observer-#{observer.kind}"
+      end
+
+      def finish
+        observer.watcher.finish
+      end
+    end
+
+    attr_reader :kind
+
+    def initialize(kind:, client:, logger:, field_selector: nil)
+      @kind = kind
+      @client = client
+      @logger = logger
+      @field_selector = field_selector
+      @watcher = nil
+      @lock = Mutex.new
+    end
+
+    def start(queue:)
+      ObserverThread.new(observer: self, queue:)
+    end
+
+    def watch(queue:)
+      logger.info("Watching #{kind}#{field_selector && " with #{field_selector.to_json}"}")
+
+      retriable do
+        self.watcher = client.watch_entities(kind, field_selector:, as: :ros)
+
+        watcher.each do |event|
+          logger.info("Received event: #{event.object.kind} #{event.object.metadata.name} #{event.type.downcase}")
+          queue << event
+        end
+      end
+    rescue StandardError => e
+      logger.error("Error observing #{kind} resources: #{e.full_message}")
+      raise(e)
+    ensure
+      self.watcher = nil
+    end
+
+    def stop
+      watcher&.finish
+    end
+
+    protected
+
+    attr_reader :client, :logger, :field_selector
+
+    def watcher
+      @lock.synchronize do
+        @watcher
+      end
+    end
+
+    def watcher=(watcher)
+      @lock.synchronize do
+        @watcher = watcher
+      end
+    end
+
+    def retriable(&)
+      retry_proc = proc do |exception|
+        logger.error(exception.full_message)
+      end
+
+      Retriable.retriable(tries: 10, base_interval: 1, on_retry: retry_proc, &)
+    end
+  end
+end

data/lib/gloo_ingress_adapter/route_table_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "kubeclient/resource"
+
+module GlooIngressAdapter
+  # Builder responsible to create a route table for an ingress
+  class RouteTableBuilder
+    def build(ingress:)
+      attributes = {
+        apiVersion: "gateway.solo.io/v1",
+        kind: "RouteTable",
+        metadata: {
+          name: ingress.metadata.name,
+          namespace: ingress.metadata.namespace,
+          labels: build_labels(ingress:),
+          ownerReferences: [
+            {
+              apiVersion: "networking.k8s.io/v1",
+              kind: "Ingress",
+              name: ingress.metadata.name,
+              uid: ingress.metadata.uid,
+            },
+          ],
+        },
+        spec: {
+          routes: build_routes(ingress:),
+        },
+      }
+
+      Kubeclient::Resource.new(attributes)
+    end
+
+    protected
+
+    def build_labels(ingress:)
+      {
+        "ingress.caperwhite.com/protocol" => ingress.spec.tls ? "https" : "http",
+      }
+    end
+
+    def build_routes(ingress:)
+      ingress.spec.rules.flat_map do |rule|
+        rule.http&.paths&.map do |path|
+          build_matcher(ingress:, rule:, path:)
+        end
+      end.compact
+    end
+
+    def build_matcher(ingress:, rule:, path:)
+      service = path.backend.service
+
+      {
+        matchers: [
+          {
+            headers: headers_matcher(rule:),
+            path_type(path.pathType) => path.path,
+          }.compact,
+        ],
+        routeAction: {
+          single: {
+            kube: {
+              ref: {
+                name: service.name,
+                namespace: service.namespace || ingress.metadata.namespace,
+              },
+              port: service.port.number || service.port.name,
+            },
+          },
+        },
+      }
+    end
+
+    HOST_PATTERN =
+
+      def headers_matcher(rule:)
+        if rule.host
+          unless %r{\A(?<star>\*\.)?(?<host>(?:[-a-z0-9]+\.)*[-a-z0-9]+)\z}i =~ rule.host
+            raise "Illegal host name '#{rule.host}'"
+          end
+
+          if star
+            [{ name: "Host", regex: true, value: "^[^.]+\\.#{host.gsub(".", "\\.")}$" }]
+          else
+            [{ name: "Host", value: host }]
+          end
+        end
+      end
+
+    def convert_host(host); end
+
+    def path_type(type)
+      case type.downcase
+      when "exact"
+        :exact
+      when "prefix", "implementationspecific"
+        :prefix
+      else
+        raise "Unknown path type '#{type}'"
+      end
+    end
+  end
+end

data/lib/gloo_ingress_adapter/util/resource_extensions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/hash"
+
+module GlooIngressAdapter
+  module Util
+    # Extensions to Resource
+    module ResourceExtensions
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+
+      def to_nice_yaml
+        to_h.deep_stringify_keys.to_yaml
+      end
+    end
+  end
+end

data/lib/gloo_ingress_adapter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GlooIngressAdapter
+  VERSION = "0.1.0"
+end

data/lib/gloo_ingress_adapter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "kubeclient"
+require "zeitwerk"
+
+# Main module
+module GlooIngressAdapter
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+Kubeclient::Resource.include(GlooIngressAdapter::Util::ResourceExtensions)

metadata

@@ -0,0 +1,317 @@
+--- !ruby/object:Gem::Specification
+name: gloo_ingress_adapter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- CaperWhite GmbH
+autorequire:
+bindir: cmd
+cert_chain: []
+date: 2022-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.9'
+- !ruby/object:Gem::Dependency
+  name: retriable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: cheetah
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: debase
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.5.beta2
+- !ruby/object:Gem::Dependency
+  name: equatable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: hashdiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: memery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-debug-ide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.40'
+- !ruby/object:Gem::Dependency
+  name: toml-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+description: |2
+      This controller allows to integrate routes created from ingresses into a normal (non-ingress) Gloo gateway, thus
+      making deploying a separate ingress gateway obsolete. The controller does this by creating route table resources
+      from ingress objects in the cluster. These route tables then can be automatically mounted in a Gloo virtual service.
+email:
+- info@caperwhite.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/gloo_ingress_adapter.rb
+- lib/gloo_ingress_adapter/client_factory.rb
+- lib/gloo_ingress_adapter/controller.rb
+- lib/gloo_ingress_adapter/resource_observer.rb
+- lib/gloo_ingress_adapter/route_table_builder.rb
+- lib/gloo_ingress_adapter/util/resource_extensions.rb
+- lib/gloo_ingress_adapter/version.rb
+homepage: https://github.com/CaperWhite/gloo-ingress-adapter
+licenses:
+- AGPL-3.0-or-later
+metadata:
+  docker_platforms: linux/arm64,linux/amd64
+  github_user: CaperWhite
+  helm_repo: https://caperwhite.github.io/gloo-ingress-adapter
+  homepage_uri: https://github.com/CaperWhite/gloo-ingress-adapter
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Use ingress resources with Gloo gateways
+test_files: []