lex-nomad 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea9788d8ae72a73c8314fcfc45eca2c0cdbe55f2dbf05bbc0c638e7b62fdd5bb
+  data.tar.gz: 41b14d70b2477aefdd7ccf780864e961b384844b10fc4218e45f0233bbc7343f
+SHA512:
+  metadata.gz: a098209444e9c8faa88d37156ab9764997aa840577dade17d34fc7dd580f8e25e6f48e712eea33b70161c539ce99bc118338d1e4b84012d9333d15802c0832b4
+  data.tar.gz: ee0a2589d45e81758cfafa92c8b7b292b2b69762bcadf70eb7d6bc64b90aa1806875744d418869e8de5dfb8d2608e2dac1f6d5cf00cefe7987af0ea99becfd2b

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,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,50 @@
+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/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

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [0.1.1] - 2026-03-22
+
+### Changed
+- Add runtime dependencies for all 7 legion sub-gems (legion-cache, legion-crypt, legion-data, legion-json, legion-logging, legion-settings, legion-transport)
+- Update spec_helper with real sub-gem helper requires and Helpers::Lex stub
+
+## [0.1.0] - 2026-03-13
+
+### Added
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,57 @@
+# lex-nomad: HashiCorp Nomad 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 Nomad. Provides runners for interacting with the full Nomad HTTP API v1 covering jobs, nodes, allocations, deployments, evaluations, namespaces, services, variables, cluster status, and search.
+
+**GitHub**: https://github.com/LegionIO/lex-nomad
+**License**: MIT
+**Version**: 0.1.0
+
+## Architecture
+
+```
+Legion::Extensions::Nomad
+├── Runners/
+│   ├── Jobs              # CRUD jobs, plan, dispatch, revert, scale, versions, summary
+│   ├── Nodes             # List/get nodes, drain, purge, eligibility
+│   ├── Allocations       # List/get/stop/signal/restart allocations, services, checks
+│   ├── Deployments       # List/get deployments, fail, pause, promote, health, unblock
+│   ├── Evaluations       # List/get/delete evaluations, count
+│   ├── Namespaces        # CRUD namespaces
+│   ├── Services          # List/get/delete service registrations
+│   ├── Variables         # CRUD variables (Nomad KV)
+│   ├── Status            # Cluster leader and raft peers
+│   └── Search            # Prefix and fuzzy search across resources
+├── Helpers/
+│   └── Client            # Faraday connection builder (Nomad API v1)
+└── Client                # Standalone client class (includes all runners)
+```
+
+## Dependencies
+
+| Gem | Purpose |
+|-----|---------|
+| `faraday` (>= 2.0) | HTTP client for Nomad REST API |
+
+## Connection
+
+Authentication uses `X-Nomad-Token` header (ACL token). Namespace scoping via `namespace` query parameter. Default address: `http://127.0.0.1:4646`.
+
+## Testing
+
+48 specs across 12 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-nomad
+
+WORKDIR /usr/src/app/lex-nomad
+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/Gemfile.lock

@@ -0,0 +1,171 @@
+PATH
+  remote: .
+  specs:
+    lex-nomad (0.1.1)
+      faraday (>= 2.0)
+      legion-cache (>= 1.3.11)
+      legion-crypt (>= 1.4.9)
+      legion-data (>= 1.4.17)
+      legion-json (>= 1.2.1)
+      legion-logging (>= 1.3.2)
+      legion-settings (>= 1.3.14)
+      legion-transport (>= 1.3.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.9)
+      public_suffix (>= 2.0.2, < 8.0)
+    amq-protocol (2.5.1)
+    ast (2.4.3)
+    aws-eventstream (1.4.0)
+    aws-sigv4 (1.12.1)
+      aws-eventstream (~> 1, >= 1.0.2)
+    base64 (0.3.0)
+    bigdecimal (4.0.1)
+    bunny (2.24.0)
+      amq-protocol (~> 2.3)
+      sorted_set (~> 1, >= 1.0.2)
+    concurrent-ruby (1.3.6)
+    connection_pool (2.5.5)
+    dalli (5.0.2)
+      logger
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    ed25519 (1.4.0)
+    faraday (2.14.1)
+      faraday-net_http (>= 2.0, < 3.5)
+      json
+      logger
+    faraday-net_http (3.4.2)
+      net-http (~> 0.5)
+    json (2.19.1)
+    json-schema (6.2.0)
+      addressable (~> 2.8)
+      bigdecimal (>= 3.1, < 5)
+    json_pure (2.8.1)
+    jwt (3.1.2)
+      base64
+    language_server-protocol (3.17.0.5)
+    legion-cache (1.3.11)
+      connection_pool (>= 2.4)
+      dalli (>= 3.0)
+      legion-logging (>= 1.2.8)
+      legion-settings (>= 1.3.12)
+      redis (>= 5.0)
+    legion-crypt (1.4.9)
+      ed25519 (~> 1.3)
+      jwt (>= 2.7)
+      vault (>= 0.17)
+    legion-data (1.4.17)
+      legion-logging (>= 1.2.8)
+      legion-settings (>= 1.3.12)
+      sequel (>= 5.70)
+      sqlite3 (>= 2.0)
+    legion-json (1.2.1)
+      json_pure
+      multi_json
+    legion-logging (1.3.2)
+      logger
+      rainbow (~> 3)
+    legion-settings (1.3.14)
+      legion-json (>= 1.2.0)
+    legion-transport (1.3.9)
+      bunny (>= 2.23)
+      concurrent-ruby (>= 1.2)
+      legion-json (>= 1.2.0)
+      legion-settings (>= 1.3.12)
+      logger
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    mcp (0.8.0)
+      json-schema (>= 4.1)
+    mini_portile2 (2.8.9)
+    multi_json (1.19.1)
+    net-http (0.9.1)
+      uri (>= 0.11.1)
+    net-http-persistent (4.0.8)
+      connection_pool (>= 2.2.4, < 4)
+    parallel (1.27.0)
+    parser (3.3.10.2)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    public_suffix (7.0.5)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.3.1)
+    rbtree (0.4.6)
+    redis (5.4.1)
+      redis-client (>= 0.22.0)
+    redis-client (0.28.0)
+      connection_pool
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rspec_junit_formatter (0.6.0)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (1.85.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      mcp (~> 0.6)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    ruby-progressbar (1.13.0)
+    sequel (5.102.0)
+      bigdecimal
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.2)
+    simplecov_json_formatter (0.1.4)
+    sorted_set (1.1.0)
+      rbtree
+    sqlite3 (2.9.2)
+      mini_portile2 (~> 2.8.0)
+    sqlite3 (2.9.2-arm64-darwin)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
+    vault (0.20.0)
+      aws-sigv4
+      base64
+      connection_pool (~> 2.4)
+      net-http-persistent (~> 4.0, >= 4.0.2)
+
+PLATFORMS
+  arm64-darwin-25
+  ruby
+
+DEPENDENCIES
+  lex-nomad!
+  rake
+  rspec
+  rspec_junit_formatter
+  rubocop
+  simplecov
+
+BUNDLED WITH
+   2.6.9

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,68 @@
+# lex-nomad
+
+HashiCorp Nomad integration for [LegionIO](https://github.com/LegionIO/LegionIO). Provides runners for interacting with the Nomad HTTP API covering jobs, nodes, allocations, deployments, evaluations, namespaces, services, variables, status, and search.
+
+## Installation
+
+```bash
+gem install lex-nomad
+```
+
+## Functions
+
+### Jobs
+`list_jobs`, `get_job`, `create_job`, `update_job`, `delete_job`, `plan_job`, `dispatch_job`, `revert_job`, `job_versions`, `job_summary`, `job_allocations`, `job_evaluations`, `job_deployments`, `job_latest_deployment`, `evaluate_job`, `force_periodic_job`, `scale_job`, `job_scale_status`, `job_services`, `parse_job`
+
+### Nodes
+`list_nodes`, `get_node`, `node_allocations`, `evaluate_node`, `drain_node`, `purge_node`, `set_node_eligibility`
+
+### Allocations
+`list_allocations`, `get_allocation`, `stop_allocation`, `signal_allocation`, `restart_allocation`, `allocation_services`, `allocation_checks`
+
+### Deployments
+`list_deployments`, `get_deployment`, `deployment_allocations`, `fail_deployment`, `pause_deployment`, `promote_deployment`, `set_allocation_health`, `unblock_deployment`
+
+### Evaluations
+`list_evaluations`, `get_evaluation`, `evaluation_allocations`, `evaluations_count`, `delete_evaluations`
+
+### Namespaces
+`list_namespaces`, `get_namespace`, `create_or_update_namespace`, `delete_namespace`
+
+### Services
+`list_services`, `get_service`, `delete_service`
+
+### Variables
+`list_variables`, `get_variable`, `create_or_update_variable`, `delete_variable`
+
+### Status
+`leader`, `peers`
+
+### Search
+`prefix_search`, `fuzzy_search`
+
+## Standalone Usage
+
+```ruby
+require 'legion/extensions/nomad'
+
+client = Legion::Extensions::Nomad::Client.new(
+  address: 'http://nomad.example.com:4646',
+  token: 'your-acl-token',
+  namespace: 'default'
+)
+
+client.list_jobs
+client.get_job(job_id: 'my-service')
+client.leader
+```
+
+## Requirements
+
+- Ruby >= 3.4
+- [LegionIO](https://github.com/LegionIO/LegionIO) framework (optional for standalone client usage)
+- HashiCorp Nomad cluster (API v1)
+- `faraday` >= 2.0
+
+## License
+
+MIT

data/lex-nomad.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/nomad/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-nomad'
+  spec.version       = Legion::Extensions::Nomad::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Nomad'
+  spec.description   = 'Connects LegionIO to HashiCorp Nomad'
+  spec.homepage      = 'https://github.com/LegionIO/lex-nomad'
+  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-nomad'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-nomad'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-nomad'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-nomad/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'
+  spec.add_dependency 'legion-cache',     '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',     '>= 1.4.9'
+  spec.add_dependency 'legion-data',      '>= 1.4.17'
+  spec.add_dependency 'legion-json',      '>= 1.2.1'
+  spec.add_dependency 'legion-logging',   '>= 1.3.2'
+  spec.add_dependency 'legion-settings',  '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+require 'legion/extensions/nomad/runners/jobs'
+require 'legion/extensions/nomad/runners/nodes'
+require 'legion/extensions/nomad/runners/allocations'
+require 'legion/extensions/nomad/runners/deployments'
+require 'legion/extensions/nomad/runners/evaluations'
+require 'legion/extensions/nomad/runners/namespaces'
+require 'legion/extensions/nomad/runners/services'
+require 'legion/extensions/nomad/runners/variables'
+require 'legion/extensions/nomad/runners/status'
+require 'legion/extensions/nomad/runners/search'
+
+module Legion
+  module Extensions
+    module Nomad
+      class Client
+        include Helpers::Client
+        include Runners::Jobs
+        include Runners::Nodes
+        include Runners::Allocations
+        include Runners::Deployments
+        include Runners::Evaluations
+        include Runners::Namespaces
+        include Runners::Services
+        include Runners::Variables
+        include Runners::Status
+        include Runners::Search
+
+        attr_reader :opts
+
+        def initialize(address: 'http://127.0.0.1:4646', token: nil, namespace: nil, **extra)
+          @opts = { address: address, token: token, namespace: namespace, **extra }
+        end
+
+        def connection(**override)
+          super(**@opts.merge(override))
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/nomad/runners/allocations.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Allocations
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_allocations(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/allocations', params)
+            { result: response.body }
+          end
+
+          def get_allocation(alloc_id:, **)
+            response = connection(**).get("/v1/allocation/#{alloc_id}")
+            { result: response.body }
+          end
+
+          def stop_allocation(alloc_id:, **)
+            response = connection(**).post("/v1/allocation/#{alloc_id}/stop")
+            { result: response.body }
+          end
+
+          def signal_allocation(alloc_id:, signal: 'SIGTERM', task: nil, **)
+            body = { Signal: signal }
+            body[:Task] = task if task
+            response = connection(**).post("/v1/client/allocation/#{alloc_id}/signal", body)
+            { result: response.body }
+          end
+
+          def restart_allocation(alloc_id:, task: nil, all_tasks: false, **)
+            body = { AllTasks: all_tasks }
+            body[:TaskName] = task if task
+            response = connection(**).post("/v1/client/allocation/#{alloc_id}/restart", body)
+            { result: response.body }
+          end
+
+          def allocation_services(alloc_id:, **)
+            response = connection(**).get("/v1/allocation/#{alloc_id}/services")
+            { result: response.body }
+          end
+
+          def allocation_checks(alloc_id:, **)
+            response = connection(**).get("/v1/allocation/#{alloc_id}/checks")
+            { 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/nomad/runners/deployments.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Deployments
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_deployments(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/deployments', params)
+            { result: response.body }
+          end
+
+          def get_deployment(deployment_id:, **)
+            response = connection(**).get("/v1/deployment/#{deployment_id}")
+            { result: response.body }
+          end
+
+          def deployment_allocations(deployment_id:, **)
+            response = connection(**).get("/v1/deployment/allocations/#{deployment_id}")
+            { result: response.body }
+          end
+
+          def fail_deployment(deployment_id:, **)
+            response = connection(**).post("/v1/deployment/fail/#{deployment_id}")
+            { result: response.body }
+          end
+
+          def pause_deployment(deployment_id:, pause: true, **)
+            body = { DeploymentID: deployment_id, Pause: pause }
+            response = connection(**).post("/v1/deployment/pause/#{deployment_id}", body)
+            { result: response.body }
+          end
+
+          def promote_deployment(deployment_id:, all: true, groups: nil, **)
+            body = { DeploymentID: deployment_id, All: all }
+            body[:Groups] = groups if groups
+            response = connection(**).post("/v1/deployment/promote/#{deployment_id}", body)
+            { result: response.body }
+          end
+
+          def set_allocation_health(deployment_id:, healthy_ids: nil, unhealthy_ids: nil, **)
+            body = { DeploymentID: deployment_id }
+            body[:HealthyAllocationIDs] = healthy_ids if healthy_ids
+            body[:UnhealthyAllocationIDs] = unhealthy_ids if unhealthy_ids
+            response = connection(**).post("/v1/deployment/allocation-health/#{deployment_id}", body)
+            { result: response.body }
+          end
+
+          def unblock_deployment(deployment_id:, **)
+            response = connection(**).post("/v1/deployment/unblock/#{deployment_id}")
+            { 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/nomad/runners/evaluations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Evaluations
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_evaluations(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/evaluations', params)
+            { result: response.body }
+          end
+
+          def get_evaluation(eval_id:, **)
+            response = connection(**).get("/v1/evaluation/#{eval_id}")
+            { result: response.body }
+          end
+
+          def evaluation_allocations(eval_id:, **)
+            response = connection(**).get("/v1/evaluation/#{eval_id}/allocations")
+            { result: response.body }
+          end
+
+          def evaluations_count(**)
+            response = connection(**).get('/v1/evaluations/count')
+            { result: response.body }
+          end
+
+          def delete_evaluations(eval_ids:, **)
+            response = connection(**).delete('/v1/evaluations', { EvalIDs: eval_ids })
+            { 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/nomad/runners/jobs.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Jobs
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_jobs(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/jobs', params)
+            { result: response.body }
+          end
+
+          def get_job(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}")
+            { result: response.body }
+          end
+
+          def create_job(job:, **)
+            response = connection(**).post('/v1/jobs', { Job: job })
+            { result: response.body }
+          end
+
+          def update_job(job_id:, job:, **)
+            response = connection(**).post("/v1/job/#{job_id}", { Job: job })
+            { result: response.body }
+          end
+
+          def delete_job(job_id:, purge: false, **)
+            params = {}
+            params[:purge] = true if purge
+            response = connection(**).delete("/v1/job/#{job_id}", params)
+            { result: response.body }
+          end
+
+          def plan_job(job_id:, job:, diff: true, **)
+            response = connection(**).post("/v1/job/#{job_id}/plan", { Job: job, Diff: diff })
+            { result: response.body }
+          end
+
+          def dispatch_job(job_id:, payload: nil, meta: nil, **)
+            body = {}
+            body[:Payload] = payload if payload
+            body[:Meta] = meta if meta
+            response = connection(**).post("/v1/job/#{job_id}/dispatch", body)
+            { result: response.body }
+          end
+
+          def revert_job(job_id:, version:, enforce_prior_version: nil, **)
+            body = { JobID: job_id, JobVersion: version }
+            body[:EnforcePriorVersion] = enforce_prior_version unless enforce_prior_version.nil?
+            response = connection(**).post("/v1/job/#{job_id}/revert", body)
+            { result: response.body }
+          end
+
+          def job_versions(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/versions")
+            { result: response.body }
+          end
+
+          def job_summary(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/summary")
+            { result: response.body }
+          end
+
+          def job_allocations(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/allocations")
+            { result: response.body }
+          end
+
+          def job_evaluations(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/evaluations")
+            { result: response.body }
+          end
+
+          def job_deployments(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/deployments")
+            { result: response.body }
+          end
+
+          def job_latest_deployment(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/deployment")
+            { result: response.body }
+          end
+
+          def evaluate_job(job_id:, **)
+            response = connection(**).post("/v1/job/#{job_id}/evaluate")
+            { result: response.body }
+          end
+
+          def force_periodic_job(job_id:, **)
+            response = connection(**).post("/v1/job/#{job_id}/periodic/force")
+            { result: response.body }
+          end
+
+          def scale_job(job_id:, group:, count: nil, message: nil, **)
+            body = { Target: { Group: group } }
+            body[:Count] = count unless count.nil?
+            body[:Message] = message if message
+            response = connection(**).post("/v1/job/#{job_id}/scale", body)
+            { result: response.body }
+          end
+
+          def job_scale_status(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/scale")
+            { result: response.body }
+          end
+
+          def job_services(job_id:, **)
+            response = connection(**).get("/v1/job/#{job_id}/services")
+            { result: response.body }
+          end
+
+          def parse_job(hcl:, canonicalize: false, **)
+            response = connection(**).post('/v1/jobs/parse', { JobHCL: hcl, Canonicalize: canonicalize })
+            { 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/nomad/runners/namespaces.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Namespaces
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_namespaces(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/namespaces', params)
+            { result: response.body }
+          end
+
+          def get_namespace(namespace:, **)
+            response = connection(**).get("/v1/namespace/#{namespace}")
+            { result: response.body }
+          end
+
+          def create_or_update_namespace(namespace:, description: nil, **)
+            body = { Name: namespace }
+            body[:Description] = description if description
+            response = connection(**).post("/v1/namespace/#{namespace}", body)
+            { result: response.body }
+          end
+
+          def delete_namespace(namespace:, **)
+            response = connection(**).delete("/v1/namespace/#{namespace}")
+            { 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/nomad/runners/nodes.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Nodes
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_nodes(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/nodes', params)
+            { result: response.body }
+          end
+
+          def get_node(node_id:, **)
+            response = connection(**).get("/v1/node/#{node_id}")
+            { result: response.body }
+          end
+
+          def node_allocations(node_id:, **)
+            response = connection(**).get("/v1/node/#{node_id}/allocations")
+            { result: response.body }
+          end
+
+          def evaluate_node(node_id:, **)
+            response = connection(**).post("/v1/node/#{node_id}/evaluate")
+            { result: response.body }
+          end
+
+          def drain_node(node_id:, enable: true, deadline: nil, ignore_system_jobs: false, **)
+            drain_spec = nil
+            drain_spec = { Deadline: deadline || 0, IgnoreSystemJobs: ignore_system_jobs } if enable
+            body = { DrainSpec: drain_spec, NodeID: node_id }
+            response = connection(**).post("/v1/node/#{node_id}/drain", body)
+            { result: response.body }
+          end
+
+          def purge_node(node_id:, **)
+            response = connection(**).post("/v1/node/#{node_id}/purge")
+            { result: response.body }
+          end
+
+          def set_node_eligibility(node_id:, eligible: true, **)
+            eligibility = eligible ? 'eligible' : 'ineligible'
+            body = { NodeID: node_id, Eligibility: eligibility }
+            response = connection(**).post("/v1/node/#{node_id}/eligibility", 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/nomad/runners/search.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Search
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def prefix_search(prefix:, context: 'all', **)
+            body = { Prefix: prefix, Context: context }
+            response = connection(**).post('/v1/search', body)
+            { result: response.body }
+          end
+
+          def fuzzy_search(text:, context: 'all', **)
+            body = { Text: text, Context: context }
+            response = connection(**).post('/v1/search/fuzzy', 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/nomad/runners/services.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Services
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_services(**)
+            response = connection(**).get('/v1/services')
+            { result: response.body }
+          end
+
+          def get_service(service_name:, **)
+            response = connection(**).get("/v1/service/#{service_name}")
+            { result: response.body }
+          end
+
+          def delete_service(service_name:, service_id:, **)
+            response = connection(**).delete("/v1/service/#{service_name}/#{service_id}")
+            { result: response.status == 200 }
+          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/nomad/runners/status.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Status
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def leader(**)
+            response = connection(**).get('/v1/status/leader')
+            { result: response.body }
+          end
+
+          def peers(**)
+            response = connection(**).get('/v1/status/peers')
+            { 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/nomad/runners/variables.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/helpers/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      module Runners
+        module Variables
+          include Legion::Extensions::Nomad::Helpers::Client
+
+          def list_variables(prefix: nil, **)
+            params = {}
+            params[:prefix] = prefix if prefix
+            response = connection(**).get('/v1/vars', params)
+            { result: response.body }
+          end
+
+          def get_variable(path:, **)
+            response = connection(**).get("/v1/var/#{path}")
+            { result: response.body }
+          end
+
+          def create_or_update_variable(path:, items:, **)
+            body = { Path: path, Items: items }
+            response = connection(**).put("/v1/var/#{path}", body)
+            { result: response.body }
+          end
+
+          def delete_variable(path:, **)
+            response = connection(**).delete("/v1/var/#{path}")
+            { result: response.status == 200 }
+          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/nomad/version.rb

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

data/lib/legion/extensions/nomad.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/nomad/version'
+require 'legion/extensions/nomad/helpers/client'
+require 'legion/extensions/nomad/runners/jobs'
+require 'legion/extensions/nomad/runners/nodes'
+require 'legion/extensions/nomad/runners/allocations'
+require 'legion/extensions/nomad/runners/deployments'
+require 'legion/extensions/nomad/runners/evaluations'
+require 'legion/extensions/nomad/runners/namespaces'
+require 'legion/extensions/nomad/runners/services'
+require 'legion/extensions/nomad/runners/variables'
+require 'legion/extensions/nomad/runners/status'
+require 'legion/extensions/nomad/runners/search'
+require 'legion/extensions/nomad/client'
+
+module Legion
+  module Extensions
+    module Nomad
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: lex-nomad
+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'
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+description: Connects LegionIO to HashiCorp Nomad
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Dockerfile
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lex-nomad.gemspec
+- lib/legion/extensions/nomad.rb
+- lib/legion/extensions/nomad/client.rb
+- lib/legion/extensions/nomad/helpers/client.rb
+- lib/legion/extensions/nomad/runners/allocations.rb
+- lib/legion/extensions/nomad/runners/deployments.rb
+- lib/legion/extensions/nomad/runners/evaluations.rb
+- lib/legion/extensions/nomad/runners/jobs.rb
+- lib/legion/extensions/nomad/runners/namespaces.rb
+- lib/legion/extensions/nomad/runners/nodes.rb
+- lib/legion/extensions/nomad/runners/search.rb
+- lib/legion/extensions/nomad/runners/services.rb
+- lib/legion/extensions/nomad/runners/status.rb
+- lib/legion/extensions/nomad/runners/variables.rb
+- lib/legion/extensions/nomad/version.rb
+homepage: https://github.com/LegionIO/lex-nomad
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-nomad
+  source_code_uri: https://github.com/LegionIO/lex-nomad
+  documentation_uri: https://github.com/LegionIO/lex-nomad
+  changelog_uri: https://github.com/LegionIO/lex-nomad
+  bug_tracker_uri: https://github.com/LegionIO/lex-nomad/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 Nomad
+test_files: []