nomade 0.1.2 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e55097372de361a10d732fb15534044a7f61e2d7d3f99bcdbc32d247aa38fe15
-  data.tar.gz: 3eb026188607bb0dd4814f996d7a5290733832cd669bdc73942a8c3c3f825115
+  metadata.gz: ed05d51537667ac01f3e77adf01ae2b614ae1d40e06fd4461c3def6a21171936
+  data.tar.gz: ca64489b697185037f1921838878963d3f3dbf585228c7f980e616db1a524d14
 SHA512:
-  metadata.gz: e048c5df4f909bfdb575c12740a12b7e2985a74782eb6b54689f203356684754ea52f7b8f2eebabe0f44de24d1f7bc22815c6a86b19fdeddbbdfb9fd943ab1e9
-  data.tar.gz: 1bbd0a9dcf2417651dfab2a64c41c3ffd39a80795d55f92dcc155f10d7c6e5b03f01a6982d11515eb79a54098ca2f7ad387098e3fa83400b6dffad9e7b5600ef
+  metadata.gz: fd50b280e996fea8c141242bd094b78cb4ecb23271402aa8a55a939d9b8ca6a988a9775d12d9d823db8a402f67ec2e789270eee95e7c8bbc5397e11352f2dfa6
+  data.tar.gz: 54117827d93c75f13c6ae2b79ee6c9eb58d3d3514f6ffaa481a6177a4d0b123a013aae063768e942a02067aee4014b47979465d3525902bc18f942b33d7fb709

data/lib/nomade/deployer.rb

@@ -1,3 +1,5 @@
+require "base64"
+
 module Nomade
   class Deployer
     attr_reader :nomad_job
@@ -8,21 +10,32 @@ module Nomade
       @job_builder = Nomade::JobBuilder.new(@http)
       @logger = opts.fetch(:logger, Nomade.logger)
 
-      @timeout = 60 * 3 # seconds
+      @timeout = opts.fetch(:timeout, 60 * 3)
+
+      @linger = opts.fetch(:linger, 8..28)
+      raise GeneralError.new("Linger needs to be a range, supplied with: #{@linger.class}") unless @linger.class == Range
 
       @hooks = {
         Nomade::Hooks::DEPLOY_RUNNING => [],
         Nomade::Hooks::DEPLOY_FINISHED => [],
         Nomade::Hooks::DEPLOY_FAILED => [],
+
+        Nomade::Hooks::DISPATCH_RUNNING => [],
+        Nomade::Hooks::DISPATCH_FINISHED => [],
+        Nomade::Hooks::DISPATCH_FAILED => [],
       }
-      add_hook(Nomade::Hooks::DEPLOY_FAILED, lambda {|hook_type, nomad_job, messages|
+      add_hook(Nomade::Hooks::DEPLOY_FAILED, lambda {|_hook_type, _nomad_job, messages|
         @logger.error "Failing deploy:"
         messages.each do |message|
           @logger.error "- #{message}"
         end
       })
-
-      self
+      add_hook(Nomade::Hooks::DISPATCH_FAILED, lambda {|_hook_type, _nomad_job, messages|
+        @logger.error "Failing dispatch:"
+        messages.each do |message|
+          @logger.error "- #{message}"
+        end
+      })
     end
 
     def init_job(template_file, image_full_name, template_variables = {})
@@ -31,6 +44,15 @@ module Nomade
       @deployment_id = nil
 
       self
+    rescue Nomade::HttpConnectionError => e
+      [e.class.to_s, e.message, "Http connection error, exiting!"].compact.uniq.map{|l| @logger.error(l)}
+      exit(7)
+    rescue Nomade::HttpBadResponse => e
+      [e.class.to_s, e.message, "Http bad response, exiting!"].compact.uniq.map{|l| @logger.error(l)}
+      exit(8)
+    rescue Nomade::HttpBadContentType => e
+      [e.class.to_s, e.message, "Http unexpected content type!"].compact.uniq.map{|l| @logger.error(l)}
+      exit(9)
     end
 
     def add_hook(hook, hook_method)
@@ -40,12 +62,20 @@ module Nomade
         @hooks[Nomade::Hooks::DEPLOY_FINISHED] << hook_method
       elsif Nomade::Hooks::DEPLOY_FAILED == hook
         @hooks[Nomade::Hooks::DEPLOY_FAILED] << hook_method
+      elsif Nomade::Hooks::DISPATCH_RUNNING == hook
+        @hooks[Nomade::Hooks::DISPATCH_RUNNING] << hook_method
+      elsif Nomade::Hooks::DISPATCH_FINISHED == hook
+        @hooks[Nomade::Hooks::DISPATCH_FINISHED] << hook_method
+      elsif Nomade::Hooks::DISPATCH_FAILED == hook
+        @hooks[Nomade::Hooks::DISPATCH_FAILED] << hook_method
       else
         raise "#{hook} not supported!"
       end
     end
 
     def deploy!
+      check_for_job_init
+
       run_hooks(Nomade::Hooks::DEPLOY_RUNNING, @nomad_job, nil)
       _plan
       _deploy
@@ -67,14 +97,78 @@ module Nomade
     rescue Nomade::DeploymentFailedError => e
       run_hooks(Nomade::Hooks::DEPLOY_FAILED, @nomad_job, [e.class.to_s, e.message, "Couldn't deploy succesfully, exiting!"].compact.uniq)
       exit(6)
+    rescue Nomade::HttpConnectionError => e
+      run_hooks(Nomade::Hooks::DEPLOY_FAILED, @nomad_job, [e.class.to_s, e.message, "Http connection error, exiting!"].compact.uniq)
+      exit(7)
+    rescue Nomade::HttpBadResponse => e
+      run_hooks(Nomade::Hooks::DEPLOY_FAILED, @nomad_job, [e.class.to_s, e.message, "Http bad response, exiting!"].compact.uniq)
+      exit(8)
+    rescue Nomade::HttpBadContentType => e
+      run_hooks(Nomade::Hooks::DEPLOY_FAILED, @nomad_job, [e.class.to_s, e.message, "Http unexpected content type!"].compact.uniq)
+      exit(9)
+    end
+
+    def dispatch!(payload_data: nil, payload_metadata: {})
+      check_for_job_init
+
+      run_hooks(Nomade::Hooks::DISPATCH_RUNNING, @nomad_job, nil)
+      _dispatch(payload_data, payload_metadata)
+      run_hooks(Nomade::Hooks::DISPATCH_FINISHED, @nomad_job, nil)
+    rescue Nomade::DispatchMetaDataFormattingError => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Metadata wrongly formatted, exiting!"].compact.uniq)
+      exit(10)
+    rescue Nomade::DispatchMissingMetaData => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Required metadata missing, exiting!"].compact.uniq)
+      exit(11)
+    rescue Nomade::DispatchUnknownMetaData => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Unknown metadata sent to server, exiting!"].compact.uniq)
+      exit(12)
+    rescue Nomade::DispatchMissingPayload => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Job requires payload, but payload isn't set!"].compact.uniq)
+      exit(20)
+    rescue Nomade::DispatchPayloadNotAllowed => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Job does not allow payload!"].compact.uniq)
+      exit(21)
+    rescue Nomade::DispatchPayloadUnknown => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "API error!"].compact.uniq)
+      exit(22)
+    rescue Nomade::DispatchWrongJobType => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Job has wrong job-type"].compact.uniq)
+      exit(30)
+    rescue Nomade::DispatchNotParamaterized => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Job is not paramaterized"].compact.uniq)
+      exit(31)
+    rescue Nomade::AllocationFailedError => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Allocation failed with errors, exiting!"].compact.uniq)
+      exit(40)
+    rescue Nomade::GeneralError => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "GeneralError hit, exiting!"].compact.uniq)
+      exit(1)
+    rescue Nomade::HttpConnectionError => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Http connection error, exiting!"].compact.uniq)
+      exit(7)
+    rescue Nomade::HttpBadResponse => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Http bad response, exiting!"].compact.uniq)
+      exit(8)
+    rescue Nomade::HttpBadContentType => e
+      run_hooks(Nomade::Hooks::DISPATCH_FAILED, @nomad_job, [e.class.to_s, e.message, "Http unexpected content type!"].compact.uniq)
+      exit(9)
     end
 
     def stop!(purge = false)
+      check_for_job_init
+
       @http.stop_job(@nomad_job, purge)
     end
 
     private
 
+    def check_for_job_init
+      unless @nomad_job
+        raise Nomade::GeneralError.new("Did you forget to run init_job?")
+      end
+    end
+
     def run_hooks(hook, job, messages)
       @hooks[hook].each do |hook_method|
         hook_method.call(hook, job, messages)
@@ -92,7 +186,7 @@ module Nomade
       @logger.info "Checking cluster for connectivity and capacity.."
       plan_data = @http.plan_job(@nomad_job)
 
-      sum_of_changes = plan_data["Annotations"]["DesiredTGUpdates"].map { |group_name, task_group_updates|
+      sum_of_changes = plan_data["Annotations"]["DesiredTGUpdates"].map { |_group_name, task_group_updates|
         task_group_updates["Stop"] +
         task_group_updates["Place"] +
         task_group_updates["Migrate"] +
@@ -112,32 +206,36 @@ module Nomade
         @http.create_job(@nomad_job)
       end
 
-      @logger.info "EvaluationID: #{@evaluation_id}"
-      @logger.info "#{@evaluation_id} Waiting until evaluation is complete"
-      eval_status = nil
-      while(eval_status != "complete") do
-        evaluation = @http.evaluation_request(@evaluation_id)
-        @deployment_id ||= evaluation["DeploymentID"]
-        eval_status = evaluation["Status"]
-        @logger.info "."
-        sleep(1)
-      end
+      if @evaluation_id.empty?
+        @logger.info "Parameterized job without evaluation, no more work needed"
+      else
+        @logger.info "EvaluationID: #{@evaluation_id}"
+        @logger.info "#{@evaluation_id} Waiting until evaluation is complete"
+        eval_status = nil
+        while(eval_status != "complete") do
+          evaluation = @http.evaluation_request(@evaluation_id)
+          @deployment_id ||= evaluation["DeploymentID"]
+          eval_status = evaluation["Status"]
+          @logger.info "."
+          sleep(1)
+        end
 
-      @logger.info "Waiting until allocations are no longer pending"
-      allocations = @http.allocations_from_evaluation_request(@evaluation_id)
-      until allocations.all?{|a| a["ClientStatus"] != "pending"}
-        @logger.info "."
-        sleep(2)
-        allocations = @http.allocations_from_evaluation_request(@evaluation_id)
-      end
+        @logger.info "Waiting until allocations are no longer pending"
+        allocations = []
+        until !allocations.empty? && allocations.all?{|a| a["ClientStatus"] != "pending"}
+          @logger.info "."
+          sleep(2)
+          allocations = @http.allocations_from_evaluation_request(@evaluation_id)
+        end
 
-      case @nomad_job.job_type
-      when "service"
-        service_deploy
-      when "batch"
-        batch_deploy
-      else
-        raise Nomade::GeneralError.new("Job-type '#{@nomad_job.job_type}' not implemented")
+        case @nomad_job.job_type
+        when "service"
+          service_deploy
+        when "batch"
+          batch_deploy
+        else
+          raise Nomade::GeneralError.new("Job-type '#{@nomad_job.job_type}' not implemented")
+        end
       end
     rescue Nomade::AllocationFailedError => e
       e.allocations.each do |allocation|
@@ -187,6 +285,96 @@ module Nomade
       raise
     end
 
+    def _dispatch(payload_data, payload_metadata)
+      @logger.info "Dispatching #{@nomad_job.job_name} (#{@nomad_job.job_type}) with #{@nomad_job.image_name_and_version}"
+      @logger.info "URL: #{@nomad_endpoint}/ui/jobs/#{@nomad_job.job_name}"
+
+      @logger.info "Running sanity checks.."
+
+      if @nomad_job.job_type != "batch"
+        raise DispatchWrongJobType.new("Job-type for #{@nomad_job.job_name} is \"#{@nomad_job.job_type}\" but should be \"batch\"")
+      end
+
+      if @nomad_job.configuration(:hash)["ParameterizedJob"] == nil
+        raise DispatchNotParamaterized.new("Job doesn't seem to be a paramaterized job, returned JobHash doesn't contain ParameterizedJob-key")
+      end
+
+      payload_data = if payload_data
+         Base64.encode64(payload_data)
+      else
+        nil
+      end
+
+      payload_metadata = if payload_metadata == nil
+        {}
+      else
+        Hash[payload_metadata.collect{|k,v| [k.to_s, v]}]
+        payload_metadata.each do |key, value|
+          unless [key, value].map(&:class) == [String, String]
+            raise Nomade::DispatchMetaDataFormattingError.new("Dispatch metadata must only be strings: #{key}(#{key.class}) = #{value}(#{value.class})")
+          end
+        end
+      end
+
+      meta_required = @nomad_job.configuration(:hash)["ParameterizedJob"]["MetaRequired"]
+      meta_optional = @nomad_job.configuration(:hash)["ParameterizedJob"]["MetaOptional"]
+      payload       = @nomad_job.configuration(:hash)["ParameterizedJob"]["Payload"]
+
+      if meta_required
+        @logger.info "Dispatch job expects the following metakeys: #{meta_required.join(", ")}"
+        meta_required.each do |required_key|
+          unless payload_metadata.keys.include?(required_key)
+            raise Nomade::DispatchMissingMetaData.new("Dispatch job expects metakey #{required_key} but it was not set")
+          end
+        end
+      end
+
+      allowed_meta_tags = [meta_required, meta_optional].flatten.uniq
+      @logger.info "Dispatch job allows the following metakeys: #{allowed_meta_tags.join(", ")}"
+      if payload_metadata
+        payload_metadata.keys.each do |metadata_key|
+          unless allowed_meta_tags.include?(metadata_key)
+            raise Nomade::DispatchUnknownMetaData.new("Dispatch job does not allow #{metadata_key} to be set!")
+          end
+        end
+      end
+
+      case payload
+      when "optional", ""
+        @logger.info "Expectation for Payload is: optional"
+      when "required"
+        @logger.info "Expectation for Payload is: required"
+
+        unless payload_data
+          raise Nomade::DispatchMissingPayload.new("Dispatch job expects payload_data, but we don't supply any!")
+        end
+      when "forbidden"
+        @logger.info "Expectation for Payload is: forbidden"
+
+        if payload_data
+          raise Nomade::DispatchPayloadNotAllowed.new("Dispatch job do not allow payload_data!")
+        end
+      else
+        raise Nomade::DispatchPayloadUnknown.new("Invalid value for [\"ParameterizedJob\"][\"Payload\"] = #{payload}")
+      end
+
+      @logger.info "Checking cluster for connectivity and capacity.."
+      _plan_data = @http.plan_job(@nomad_job)
+
+      dispatch_job = @http.dispatch_job(@nomad_job, payload_data: payload_data, payload_metadata: payload_metadata)
+      @evaluation_id = dispatch_job["EvalID"]
+
+      @logger.info "Waiting until allocations are no longer pending"
+      allocations = []
+      until !allocations.empty? && allocations.all?{|a| a["ClientStatus"] != "pending"}
+        @logger.info "."
+        sleep(2)
+        allocations = @http.allocations_from_evaluation_request(@evaluation_id)
+      end
+
+      batch_deploy
+    end
+
     def service_deploy
       @logger.info "Waiting until tasks are placed"
       deploy_timeout = Time.now.utc + @timeout
@@ -213,7 +401,6 @@ module Nomade
 
       announced_completed = []
       promoted = false
-      failed = false
       succesful_deployment = nil
       while(succesful_deployment == nil) do
         json = @http.deployment_request(@deployment_id)
@@ -223,13 +410,13 @@ module Nomade
 
           desired_canaries = task_data["DesiredCanaries"]
           desired_total = task_data["DesiredTotal"]
-          placed_allocations = task_data["PlacedAllocs"]
+          _placed_allocations = task_data["PlacedAllocs"]
           healthy_allocations = task_data["HealthyAllocs"]
-          unhealthy_allocations = task_data["UnhealthyAllocs"]
+          _unhealthy_allocations = task_data["UnhealthyAllocs"]
 
           if manual_work_required
             @logger.info "#{json["ID"]} #{task_name}: #{healthy_allocations}/#{desired_canaries}/#{desired_total} (Healthy/WantedCanaries/Total)"
-            announced_completed << task_name if healthy_allocations == desired_canaries
+            announced_completed << task_name if healthy_allocations == desired_canaries && desired_canaries > 0
           else
             @logger.info "#{json["ID"]} #{task_name}: #{healthy_allocations}/#{desired_total} (Healthy/Total)"
             announced_completed << task_name if healthy_allocations == desired_total
@@ -250,7 +437,7 @@ module Nomade
 
           if succesful_deployment == nil && json["TaskGroups"].values.all?{|tg| tg["HealthyAllocs"] >= tg["DesiredCanaries"]}
             if !promoted
-              random_linger = rand(8..28)
+              random_linger = rand(@linger)
               @logger.info "Lingering around for #{random_linger} seconds before deployment.."
               sleep(random_linger)
 
@@ -319,7 +506,7 @@ module Nomade
 
         tasks           = get_tasks(allocations)
         upcoming_tasks  = get_upcoming_tasks(tasks)
-        succesful_tasks = get_succesful_tasks(tasks)
+        _succesful_tasks = get_succesful_tasks(tasks)
         failed_tasks    = get_failed_tasks(tasks)
 
         if upcoming_tasks.size == 0

data/lib/nomade/exceptions.rb

@@ -16,4 +16,19 @@ module Nomade
 
   class UnsupportedDeploymentMode < StandardError; end
   class FailedTaskGroupPlan < StandardError; end
+
+  class DispatchWrongJobType < StandardError; end
+  class DispatchNotParamaterized < StandardError; end
+
+  class DispatchMetaDataFormattingError < StandardError; end
+  class DispatchMissingMetaData < StandardError; end
+  class DispatchUnknownMetaData < StandardError; end
+
+  class DispatchMissingPayload < StandardError; end
+  class DispatchPayloadNotAllowed < StandardError; end
+  class DispatchPayloadUnknown < StandardError; end
+
+  class HttpConnectionError < StandardError; end
+  class HttpBadResponse < StandardError; end
+  class HttpBadContentType < StandardError; end
 end

data/lib/nomade/hooks.rb

@@ -3,5 +3,9 @@ module Nomade
     DEPLOY_RUNNING = Class.new
     DEPLOY_FINISHED = Class.new
     DEPLOY_FAILED = Class.new
+
+    DISPATCH_RUNNING = Class.new
+    DISPATCH_FINISHED = Class.new
+    DISPATCH_FAILED = Class.new
   end
 end

data/lib/nomade/http.rb

@@ -90,7 +90,7 @@ module Nomade
         "DeploymentID" => deployment_id,
         "All" => true,
       }.to_json
-      res_body = _request(:post, "/v1/deployment/promote/#{deployment_id}", body: req_body)
+      _request(:post, "/v1/deployment/promote/#{deployment_id}", body: req_body)
 
       return true
     rescue StandardError => e
@@ -99,7 +99,7 @@ module Nomade
     end
 
     def fail_deployment(deployment_id)
-      res_body = _request(:post, "/v1/deployment/fail/#{deployment_id}")
+      _request(:post, "/v1/deployment/fail/#{deployment_id}")
       return true
     rescue StandardError => e
       Nomade.logger.fatal "HTTP Request failed (#{e.message})"
@@ -125,7 +125,7 @@ module Nomade
       end
 
       true
-    rescue Nomade::FailedTaskGroupPlan => e
+    rescue Nomade::FailedTaskGroupPlan
       raise
     rescue StandardError => e
       Nomade.logger.fatal "HTTP Request failed (#{e.message})"
@@ -154,12 +154,34 @@ module Nomade
       raise
     end
 
+    def dispatch_job(nomad_job, payload_data: nil, payload_metadata: nil)
+      if payload_metadata.class != Hash
+        raise DispatchMetaDataFormattingError.new("Expected #{payload_metadata} to be a Hash, but received #{payload_metadata.class}")
+      end
+
+      req_body = JSON.generate({
+        "Payload": payload_data,
+        "Meta": payload_metadata,
+      }.delete_if { |_k, v| v.nil? })
+
+      res_body = _request(:post, "/v1/job/#{nomad_job.job_name}/dispatch", body: req_body)
+      JSON.parse(res_body)
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
     private
 
     def _request(request_type, path, body: nil, total_retries: 0, expected_content_type: "application/json")
       uri = URI("#{@nomad_endpoint}#{path}")
 
       http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 10
+      http.read_timeout = 10
+      http.write_timeout = 10 if Net::HTTP.method_defined?(:write_timeout)
+      http.ssl_timeout = 10
+
       if @nomad_endpoint.include?("https://")
         http.use_ssl = true
         http.verify_mode = OpenSSL::SSL::VERIFY_PEER
@@ -175,30 +197,34 @@ module Nomade
       else
         raise "#{request_type} not supported"
       end
+
       req.add_field "Content-Type", "application/json"
       req.body = body if body
 
       res = begin
         retries ||= 0
         http.request(req)
-      rescue Timeout::Error, Errno::ETIMEDOUT, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, SocketError
+      rescue Timeout::Error, Errno::ETIMEDOUT, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, SocketError => e
         if retries < total_retries
           retries += 1
           sleep 1
           retry
         else
-          raise
+          raise HttpConnectionError.new("#{e.class} - #{e.message}")
         end
       end
 
-      raise if res.code != "200"
+      if res.code != "200"
+        raise HttpBadResponse.new("Bad response (not 200) but #{res.code}: #{res.body}")
+      end
+
       if res.content_type != expected_content_type
         # Sometimes the log endpoint doesn't set content_type on no content
         # https://github.com/hashicorp/nomad/issues/7264
         if res.content_type == nil && expected_content_type == "text/plain"
           # don't raise
         else
-          raise
+          raise HttpBadContentType.new("Expected #{expected_content_type} but got #{res.content_type}")
         end
       end
 

data/lib/nomade/logger.rb

@@ -10,7 +10,7 @@ module Nomade
       end
 
       Yell.new do |l|
-        unless ARGV.include?("-q")
+        unless ENV["QUIET_NOMADE"] == "1"
           l.adapter STDOUT, level: stdout
           l.adapter STDERR, level: [:error, :fatal]
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nomade
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.7
 platform: ruby
 authors:
 - Kasper Grubbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-06 00:00:00.000000000 Z
+date: 2020-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yell
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Gem that deploys nomad jobs