lex-consul 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ffef59de9734ecea3f1f7a1f3ddd987705022d9340ed7284034843b0934b411c
+  data.tar.gz: 5ae1ef9cab784f51f516b627448b5c198953c874ba601c1a3da34c0f20bf5fad
+SHA512:
+  metadata.gz: b4a52d05f508d068c957d3a06bee4008b29fb1a4f57abba92c02084de28be5522a5764cc92796a68fcf5587520c67ed3c3f8ea753605fc7abfd6c797a35032e0
+  data.tar.gz: 9bfffc6c5937b54ea43528e55ff6786b62c75236c587b8dc8fdead6b48061c318381c245106594c49550c3ed8953e2ae6c112a0fdd40b410d2315bdec6cb3b9d

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,58 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Max: 1500
+
+Metrics/ModuleLength:
+  Max: 1500
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/ParameterLists:
+  Max: 8
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false
+
+Naming/MethodParameterName:
+  AllowedNames:
+    - dc
+    - id

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [0.1.1] - 2026-03-21
+
+### Added
+- `Runners::Partitions` with `list_partitions`, `get_partition`, `create_partition`, `delete_partition` for Consul Enterprise admin partition CRUD
+
+## [0.1.0] - 2026-03-13
+
+### Added
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,62 @@
+# lex-consul: HashiCorp Consul Integration for LegionIO
+
+**Repository Level 3 Documentation**
+- **Parent (Level 2)**: `/Users/miverso2/rubymine/legion/extensions/CLAUDE.md`
+- **Parent (Level 1)**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Legion Extension that connects LegionIO to HashiCorp Consul. Provides runners for interacting with the Consul HTTP API covering KV store, agent management, service catalog, health checks, sessions, events, and cluster status.
+
+**GitHub**: https://github.com/LegionIO/lex-consul
+**License**: MIT
+**Version**: 0.1.0
+
+## Architecture
+
+```
+Legion::Extensions::Consul
+├── Runners/
+│   ├── Kv                # KV store CRUD (get, put, delete, list keys)
+│   ├── Agent             # Agent info, members, join/leave, maintenance
+│   ├── Catalog           # Datacenters, nodes, services, register/deregister
+│   ├── Health            # Node health, service checks, checks by state
+│   ├── Session           # Distributed lock sessions (create, destroy, renew)
+│   ├── Event             # Custom event fire and list
+│   └── Status            # Raft leader and peers
+├── Helpers/
+│   └── Client            # Faraday connection builder (Consul HTTP API v1)
+└── Client                # Standalone client class (includes all runners)
+```
+
+## Dependencies
+
+| Gem | Purpose |
+|-----|---------|
+| `faraday` | HTTP client for Consul HTTP API |
+
+## API Coverage
+
+| Consul API | Runner | Methods |
+|------------|--------|---------|
+| `/v1/kv/` | Kv | get_key, put_key, delete_key, list_keys |
+| `/v1/agent/` | Agent | self_info, members, join, leave, force_leave, reload, maintenance |
+| `/v1/catalog/` | Catalog | datacenters, nodes, services, service, node, register, deregister |
+| `/v1/health/` | Health | node_health, service_checks, service_health, checks_in_state, connect_health |
+| `/v1/session/` | Session | create_session, destroy_session, session_info, list_sessions, node_sessions, renew_session |
+| `/v1/event/` | Event | fire_event, list_events |
+| `/v1/status/` | Status | leader, peers |
+
+## Testing
+
+30 specs across 9 spec files.
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

data/Dockerfile

@@ -0,0 +1,6 @@
+FROM legionio/legion
+
+COPY . /usr/src/app/lex-consul
+
+WORKDIR /usr/src/app/lex-consul
+RUN bundle install

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop'
+  gem 'simplecov'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Esity
+
+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,93 @@
+# lex-consul
+
+HashiCorp Consul integration for [LegionIO](https://github.com/LegionIO/LegionIO). Provides runners for interacting with the Consul HTTP API covering KV store, agent management, catalog, health checks, sessions, events, and cluster status.
+
+## Installation
+
+```bash
+gem install lex-consul
+```
+
+## Functions
+
+### KV Store (`Runners::Kv`)
+- `get_key` - Read a key (supports recursive and raw modes)
+- `put_key` - Write a key (supports CAS, flags, lock acquire/release)
+- `delete_key` - Delete a key (supports recursive delete and CAS)
+- `list_keys` - List keys by prefix
+
+### Agent (`Runners::Agent`)
+- `self_info` - Read agent configuration
+- `members` - List cluster members
+- `join` - Join a node to the cluster
+- `leave` - Graceful leave
+- `force_leave` - Force remove a node
+- `reload` - Reload agent configuration
+- `maintenance` - Enable/disable maintenance mode
+
+### Catalog (`Runners::Catalog`)
+- `datacenters` - List known datacenters
+- `nodes` - List catalog nodes
+- `services` - List catalog services
+- `service` - List nodes for a service
+- `node` - Get services on a node
+- `register` - Register a node/service/check
+- `deregister` - Deregister a node/service/check
+
+### Health (`Runners::Health`)
+- `node_health` - Health checks for a node
+- `service_checks` - Checks for a service
+- `service_health` - Healthy service instances
+- `checks_in_state` - Checks by state (passing/warning/critical)
+- `connect_health` - Mesh-capable service instances
+
+### Session (`Runners::Session`)
+- `create_session` - Create a session (for distributed locks)
+- `destroy_session` - Destroy a session
+- `session_info` - Read session details
+- `list_sessions` - List all sessions
+- `node_sessions` - List sessions for a node
+- `renew_session` - Renew a session TTL
+
+### Event (`Runners::Event`)
+- `fire_event` - Fire a custom event
+- `list_events` - List recent events
+
+### Status (`Runners::Status`)
+- `leader` - Get Raft leader address
+- `peers` - List Raft peer addresses
+
+## Standalone Usage
+
+```ruby
+require 'legion/extensions/consul'
+
+client = Legion::Extensions::Consul::Client.new(
+  url: 'http://consul.example.com:8500',
+  token: 'my-consul-token'
+)
+
+# KV operations
+client.put_key(key: 'config/db/host', value: 'db.example.com')
+client.get_key(key: 'config/db/host')
+client.list_keys(prefix: 'config/')
+
+# Service discovery
+client.services
+client.service_health(service: 'web', passing: true)
+
+# Cluster status
+client.leader
+client.members
+```
+
+## Requirements
+
+- Ruby >= 3.4
+- [LegionIO](https://github.com/LegionIO/LegionIO) framework (optional for standalone client usage)
+- HashiCorp Consul cluster (any version with HTTP API v1)
+- `faraday` >= 2.0
+
+## License
+
+MIT

data/lex-consul.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/consul/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-consul'
+  spec.version       = Legion::Extensions::Consul::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Consul'
+  spec.description   = 'Connects LegionIO to HashiCorp Consul'
+  spec.homepage      = 'https://github.com/LegionIO/lex-consul'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/LegionIO/lex-consul'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-consul'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-consul'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-consul/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday', '>= 2.0'
+end

data/lib/legion/extensions/consul/client.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+require 'legion/extensions/consul/runners/kv'
+require 'legion/extensions/consul/runners/agent'
+require 'legion/extensions/consul/runners/catalog'
+require 'legion/extensions/consul/runners/health'
+require 'legion/extensions/consul/runners/session'
+require 'legion/extensions/consul/runners/event'
+require 'legion/extensions/consul/runners/status'
+
+module Legion
+  module Extensions
+    module Consul
+      class Client
+        include Helpers::Client
+        include Runners::Kv
+        include Runners::Agent
+        include Runners::Catalog
+        include Runners::Health
+        include Runners::Session
+        include Runners::Event
+        include Runners::Status
+        include Runners::Partitions
+
+        attr_reader :opts
+
+        def initialize(url: 'http://127.0.0.1:8500', token: nil, **extra)
+          @opts = { url: url, token: token, **extra }
+        end
+
+        def connection(**override)
+          super(**@opts.merge(override))
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/helpers/client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Legion
+  module Extensions
+    module Consul
+      module Helpers
+        module Client
+          def connection(url: 'http://127.0.0.1:8500', token: nil, **_opts)
+            Faraday.new(url: url) do |conn|
+              conn.request :json
+              conn.response :json, content_type: /\bjson$/
+              conn.headers['X-Consul-Token'] = token if token
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/agent.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Agent
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def self_info(**)
+            response = connection(**).get('/v1/agent/self')
+            { result: response.body }
+          end
+
+          def members(wan: false, **)
+            params = {}
+            params[:wan] = true if wan
+            response = connection(**).get('/v1/agent/members', params)
+            { result: response.body }
+          end
+
+          def join(address:, wan: false, **)
+            params = {}
+            params[:wan] = true if wan
+            response = connection(**).put("/v1/agent/join/#{address}", nil, params)
+            { result: response.body }
+          end
+
+          def leave(**)
+            response = connection(**).put('/v1/agent/leave')
+            { result: response.body }
+          end
+
+          def force_leave(node:, prune: false, **)
+            params = {}
+            params[:prune] = true if prune
+            response = connection(**).put("/v1/agent/force-leave/#{node}", nil, params)
+            { result: response.body }
+          end
+
+          def reload(**)
+            response = connection(**).put('/v1/agent/reload')
+            { result: response.body }
+          end
+
+          def maintenance(enable:, reason: nil, **)
+            params = { enable: enable }
+            params[:reason] = reason if reason
+            response = connection(**).put('/v1/agent/maintenance', nil, params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/catalog.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Catalog
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def datacenters(**)
+            response = connection(**).get('/v1/catalog/datacenters')
+            { result: response.body }
+          end
+
+          def nodes(dc: nil, near: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:near] = near if near
+            params[:filter] = filter if filter
+            response = connection(**).get('/v1/catalog/nodes', params)
+            { result: response.body }
+          end
+
+          def services(dc: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:filter] = filter if filter
+            response = connection(**).get('/v1/catalog/services', params)
+            { result: response.body }
+          end
+
+          def service(service:, dc: nil, tag: nil, near: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:tag] = tag if tag
+            params[:near] = near if near
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/catalog/service/#{service}", params)
+            { result: response.body }
+          end
+
+          def node(node:, dc: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/catalog/node/#{node}", params)
+            { result: response.body }
+          end
+
+          def register(node:, address:, service: nil, check: nil, dc: nil, **)
+            body = { Node: node, Address: address }
+            body[:Service] = service if service
+            body[:Check] = check if check
+            body[:Datacenter] = dc if dc
+            response = connection(**).put('/v1/catalog/register', body)
+            { result: response.body }
+          end
+
+          def deregister(node:, check_id: nil, service_id: nil, dc: nil, **)
+            body = { Node: node }
+            body[:CheckID] = check_id if check_id
+            body[:ServiceID] = service_id if service_id
+            body[:Datacenter] = dc if dc
+            response = connection(**).put('/v1/catalog/deregister', body)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/event.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Event
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def fire_event(name:, body: nil, dc: nil, node: nil, service: nil, tag: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:node] = node if node
+            params[:service] = service if service
+            params[:tag] = tag if tag
+            response = connection(**).put("/v1/event/fire/#{name}", body) do |req|
+              req.params = params
+              req.headers['Content-Type'] = 'text/plain' if body
+            end
+            { result: response.body }
+          end
+
+          def list_events(name: nil, node: nil, service: nil, tag: nil, **)
+            params = {}
+            params[:name] = name if name
+            params[:node] = node if node
+            params[:service] = service if service
+            params[:tag] = tag if tag
+            response = connection(**).get('/v1/event/list', params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/health.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Health
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def node_health(node:, dc: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/health/node/#{node}", params)
+            { result: response.body }
+          end
+
+          def service_checks(service:, dc: nil, near: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:near] = near if near
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/health/checks/#{service}", params)
+            { result: response.body }
+          end
+
+          def service_health(service:, dc: nil, passing: false, tag: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:passing] = true if passing
+            params[:tag] = tag if tag
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/health/service/#{service}", params)
+            { result: response.body }
+          end
+
+          def checks_in_state(state:, dc: nil, near: nil, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:near] = near if near
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/health/state/#{state}", params)
+            { result: response.body }
+          end
+
+          def connect_health(service:, dc: nil, passing: false, filter: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:passing] = true if passing
+            params[:filter] = filter if filter
+            response = connection(**).get("/v1/health/connect/#{service}", params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/kv.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Kv
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def get_key(key:, dc: nil, recurse: false, raw: false, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:recurse] = true if recurse
+            params[:raw] = true if raw
+            response = connection(**).get("/v1/kv/#{key}", params)
+            { result: response.body }
+          end
+
+          def put_key(key:, value:, dc: nil, flags: nil, cas: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:flags] = flags if flags
+            params[:cas] = cas if cas
+            response = connection(**).put("/v1/kv/#{key}", value) do |req|
+              req.params = params
+              req.headers['Content-Type'] = 'text/plain'
+            end
+            { result: response.body }
+          end
+
+          def delete_key(key:, dc: nil, recurse: false, cas: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            params[:recurse] = true if recurse
+            params[:cas] = cas if cas
+            response = connection(**).delete("/v1/kv/#{key}", params)
+            { result: response.body }
+          end
+
+          def list_keys(prefix: '', dc: nil, separator: nil, **)
+            params = { keys: true }
+            params[:dc] = dc if dc
+            params[:separator] = separator if separator
+            response = connection(**).get("/v1/kv/#{prefix}", params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/partitions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Partitions
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def list_partitions(**)
+            response = connection(**).get('/v1/partitions')
+            { result: response.body }
+          end
+
+          def get_partition(name:, **)
+            response = connection(**).get("/v1/partition/#{name}")
+            { result: response.body }
+          end
+
+          def create_partition(name:, description: nil, **)
+            body = { Name: name }
+            body[:Description] = description if description
+            response = connection(**).put("/v1/partition/#{name}", body)
+            { result: response.body }
+          end
+
+          def delete_partition(name:, **)
+            response = connection(**).delete("/v1/partition/#{name}")
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/session.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Session
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def create_session(node: nil, name: nil, lock_delay: nil, ttl: nil, behavior: nil, checks: nil, dc: nil, **)
+            body = {}
+            body[:Node] = node if node
+            body[:Name] = name if name
+            body[:LockDelay] = lock_delay if lock_delay
+            body[:TTL] = ttl if ttl
+            body[:Behavior] = behavior if behavior
+            body[:Checks] = checks if checks
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).put('/v1/session/create', body) do |req|
+              req.params = params
+            end
+            { result: response.body }
+          end
+
+          def destroy_session(id:, dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).put("/v1/session/destroy/#{id}", nil, params)
+            { result: response.body }
+          end
+
+          def session_info(id:, dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).get("/v1/session/info/#{id}", params)
+            { result: response.body }
+          end
+
+          def list_sessions(dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).get('/v1/session/list', params)
+            { result: response.body }
+          end
+
+          def node_sessions(node:, dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).get("/v1/session/node/#{node}", params)
+            { result: response.body }
+          end
+
+          def renew_session(id:, dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).put("/v1/session/renew/#{id}", nil, params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/runners/status.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/helpers/client'
+
+module Legion
+  module Extensions
+    module Consul
+      module Runners
+        module Status
+          include Legion::Extensions::Consul::Helpers::Client
+
+          def leader(dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).get('/v1/status/leader', params)
+            { result: response.body }
+          end
+
+          def peers(dc: nil, **)
+            params = {}
+            params[:dc] = dc if dc
+            response = connection(**).get('/v1/status/peers', params)
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/consul/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Consul
+      VERSION = '0.1.1'
+    end
+  end
+end

data/lib/legion/extensions/consul.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/consul/version'
+require 'legion/extensions/consul/helpers/client'
+require 'legion/extensions/consul/runners/kv'
+require 'legion/extensions/consul/runners/agent'
+require 'legion/extensions/consul/runners/catalog'
+require 'legion/extensions/consul/runners/health'
+require 'legion/extensions/consul/runners/session'
+require 'legion/extensions/consul/runners/event'
+require 'legion/extensions/consul/runners/status'
+require 'legion/extensions/consul/runners/partitions'
+require 'legion/extensions/consul/client'
+
+module Legion
+  module Extensions
+    module Consul
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: lex-consul
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Connects LegionIO to HashiCorp Consul
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Dockerfile
+- Gemfile
+- LICENSE
+- README.md
+- lex-consul.gemspec
+- lib/legion/extensions/consul.rb
+- lib/legion/extensions/consul/client.rb
+- lib/legion/extensions/consul/helpers/client.rb
+- lib/legion/extensions/consul/runners/agent.rb
+- lib/legion/extensions/consul/runners/catalog.rb
+- lib/legion/extensions/consul/runners/event.rb
+- lib/legion/extensions/consul/runners/health.rb
+- lib/legion/extensions/consul/runners/kv.rb
+- lib/legion/extensions/consul/runners/partitions.rb
+- lib/legion/extensions/consul/runners/session.rb
+- lib/legion/extensions/consul/runners/status.rb
+- lib/legion/extensions/consul/version.rb
+homepage: https://github.com/LegionIO/lex-consul
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-consul
+  source_code_uri: https://github.com/LegionIO/lex-consul
+  documentation_uri: https://github.com/LegionIO/lex-consul
+  changelog_uri: https://github.com/LegionIO/lex-consul
+  bug_tracker_uri: https://github.com/LegionIO/lex-consul/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Consul
+test_files: []