nomade 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d592e96d768d830096aeaf2c1af8abea0e509582895d661c2c25ac718b8b1885
-  data.tar.gz: 711a78ece036b6779792159789501e7b542dcca29b1f7ff2ae78a8eee3cbd55f
+  metadata.gz: 123b90eb6930f46b12b75aee376034b51c623ae5e788149bcff15ca2dccaf8b9
+  data.tar.gz: a0aef251645a73ee2fb61f316298c354316d27e02a2cba59bb3c22e113e06acb
 SHA512:
-  metadata.gz: 808441c9d68364ffa0e0eca8fdcd1fd8e70a0c1acb2bbf3397839ae0dfbf1b61c58dc03452fc92038c01de924c46d46009a665680996b8647671d713a6c60757
-  data.tar.gz: ea50eaf4bb6687334a194b0b805662d51a2be91baa768f68d403a7a4bb897f3b2b1215a4d2d1da98405b64ce5a4acb6bebc64c752c5ae61ddee92ee1405739d7
+  metadata.gz: 7a0dd940d4b32facd28d3e81a2fdb49d97cc0a43205e93997d913d316101902d9922b8e87bca59bd25b84752d1535a19a60b622a1cf85ecd2baf8ae47f965ea6
+  data.tar.gz: 4598198f4be75e00c44f6bf9a0185b013e135ceead95dc25d6ccef0de6bf13f5913cf699fb45f9b3f8a6aaaa7b7cad008366cdc3f131c2c06ec982ec2b6875eb

data/lib/nomade/deployer.rb

@@ -1,3 +1,5 @@
+require "base64"
+
 module Nomade
   class Deployer
     attr_reader :nomad_job
@@ -14,6 +16,10 @@ module Nomade
         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|
         @logger.error "Failing deploy:"
@@ -21,6 +27,12 @@ module Nomade
           @logger.error "- #{message}"
         end
       })
+      add_hook(Nomade::Hooks::DISPATCH_FAILED, lambda {|hook_type, nomad_job, messages|
+        @logger.error "Failing dispatch:"
+        messages.each do |message|
+          @logger.error "- #{message}"
+        end
+      })
 
       self
     end
@@ -31,6 +43,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 +61,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,6 +96,62 @@ 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)
@@ -75,6 +160,12 @@ module Nomade
 
     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)
@@ -112,32 +203,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 +282,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

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

@@ -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
+      http.ssl_timeout = 10
+
       if @nomad_endpoint.include?("https://")
         http.use_ssl = true
         http.verify_mode = OpenSSL::SSL::VERIFY_PEER
@@ -181,24 +203,27 @@ module Nomade
       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.to_s} - #{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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nomade
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Kasper Grubbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-25 00:00:00.000000000 Z
+date: 2020-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yell