nomade 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a5ac73ef2143a1d2553ba24433aa6ee34b572a6465f3dc80f3a9f5e71b3750b0
+  data.tar.gz: 7c1e97c20ec00bb4d6e6405c92a91aa3946f2b2187a5f8de053f090555fffff1
+SHA512:
+  metadata.gz: 0625b32824125388ce00910ef895263168b9d56d57cf5be15673e51ddf8c2e88e8965db2dd23942ed1748feb48035f3876454abe67eead80c128928807b89842
+  data.tar.gz: 8b4e23a2594d7b66885023580b238a7cfac12f829ed99ba5a4265cc30eee341707326715c07c594683959d2a2fe4b630276d7391dba61a977e4f4b1c89a69ef9

data/lib/nomade/decorators.rb

@@ -0,0 +1,18 @@
+module Nomade
+  class Decorator
+    def self.task_state_decorator(task_state, task_failed)
+      case task_state
+      when "pending"
+        "Pending"
+      when "running"
+        "Running"
+      when "dead"
+        if task_failed
+          "Failed with errors!"
+        else
+          "Completed succesfully!"
+        end
+      end
+    end
+  end
+end

data/lib/nomade/deployer.rb

@@ -0,0 +1,328 @@
+module Nomade
+  class Deployer
+    def initialize(nomad_endpoint, nomad_job)
+      @nomad_job = nomad_job
+      @evaluation_id = nil
+      @deployment_id = nil
+      @timeout = Time.now.utc + 60 * 9 # minutes
+      @http = Nomade::Http.new(nomad_endpoint)
+    end
+
+    def deploy!
+      deploy
+    rescue Nomade::NoModificationsError => e
+      Nomade.logger.warn "No modifications to make, exiting!"
+      exit(0)
+    rescue Nomade::GeneralError => e
+      Nomade.logger.warn e.message
+      Nomade.logger.warn "GeneralError hit, exiting!"
+      exit(1)
+    rescue Nomade::PlanningError => e
+      Nomade.logger.warn "Couldn't make a plan, maybe a bad connection to Nomad server, exiting!"
+      exit(2)
+    rescue Nomade::AllocationFailedError => e
+      Nomade.logger.warn "Allocation failed with errors, exiting!"
+      exit(3)
+    rescue Nomade::UnsupportedDeploymentMode => e
+      Nomade.logger.warn e.message
+      Nomade.logger.warn "Deployment failed with errors, exiting!"
+      exit(4)
+    end
+
+    private
+
+    def deploy
+      Nomade.logger.info "Deploying #{@nomad_job.job_name} (#{@nomad_job.job_type}) with #{@nomad_job.image_name_and_version}"
+
+      Nomade.logger.info "Checking cluster for connectivity and capacity.."
+      @http.plan_job(@nomad_job)
+
+      @evaluation_id = if @http.check_if_job_exists?(@nomad_job)
+        Nomade.logger.info "Updating existing job"
+        @http.update_job(@nomad_job)
+      else
+        Nomade.logger.info "Creating new job"
+        @http.create_job(@nomad_job)
+      end
+
+      Nomade.logger.info "EvaluationID: #{@evaluation_id}"
+      Nomade.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"]
+        Nomade.logger.info "."
+        sleep(1)
+      end
+
+      Nomade.logger.info "Waiting until allocations are complete"
+      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
+    rescue Nomade::AllocationFailedError => e
+      e.allocations.each do |allocation|
+        allocation["TaskStates"].sort.each do |task_name, task_data|
+          pretty_state = Nomade::Decorator.task_state_decorator(task_data["State"], task_data["Failed"])
+
+          Nomade.logger.info ""
+          Nomade.logger.info "#{allocation["ID"]} #{allocation["Name"]} #{task_name}: #{pretty_state}"
+          unless task_data["Failed"]
+            Nomade.logger.info "Task \"#{task_name}\" was succesfully run, skipping log-printing because it isn't relevant!"
+            next
+          end
+
+          stdout = @http.get_allocation_logs(allocation["ID"], task_name, "stdout")
+          if stdout != ""
+            Nomade.logger.info
+            Nomade.logger.info "stdout:"
+            stdout.lines do |logline|
+              Nomade.logger.info(logline.strip)
+            end
+          end
+
+          stderr = @http.get_allocation_logs(allocation["ID"], task_name, "stderr")
+          if stderr != ""
+            Nomade.logger.info
+            Nomade.logger.info "stderr:"
+            stderr.lines do |logline|
+              Nomade.logger.info(logline.strip)
+            end
+          end
+
+          task_data["Events"].each do |event|
+            event_type = event["Type"]
+            event_time = Time.at(event["Time"]/1000/1000000).utc
+            event_message = event["DisplayMessage"]
+
+            event_details = if event["Details"].any?
+              dts = event["Details"].map{|k,v| "#{k}: #{v}"}.join(", ")
+              "(#{dts})"
+            end
+
+            Nomade.logger.info "[#{event_time}] #{event_type}: #{event_message} #{event_details}"
+          end
+        end
+      end
+
+      raise
+    end
+
+    def service_deploy
+      Nomade.logger.info "Waiting until tasks are placed"
+      Nomade.logger.info ".. deploy timeout is #{@timeout}"
+
+      json = @http.deployment_request(@deployment_id)
+      Nomade.logger.info "#{json["JobID"]} version #{json["JobVersion"]}"
+
+      need_manual_promotion = json["TaskGroups"].values.any?{|tg| tg["DesiredCanaries"] > 0 && tg["AutoPromote"] == false}
+      need_manual_rollback  = json["TaskGroups"].values.any?{|tg| tg["DesiredCanaries"] > 0 && tg["AutoRevert"] == false}
+
+      manual_work_required = case [need_manual_promotion, need_manual_rollback]
+      when [true, true]
+        Nomade.logger.info "Job needs manual promotion/rollback, we'll take care of that!"
+        true
+      when [false, false]
+        Nomade.logger.info "Job manages its own promotion/rollback, we will just monitor in a hands-off mode!"
+        false
+      when [false, true]
+        raise UnsupportedDeploymentMode.new("Unsupported deployment-mode, manual-promotion=#{need_manual_promotion}, manual-rollback=#{need_manual_rollback}")
+      when [true, false]
+        raise UnsupportedDeploymentMode.new("Unsupported deployment-mode, manual-promotion=#{need_manual_promotion}, manual-rollback=#{need_manual_rollback}")
+      end
+
+      announced_completed = []
+      promoted = false
+      failed = false
+      succesful_deployment = nil
+      while(succesful_deployment == nil) do
+        json = @http.deployment_request(@deployment_id)
+
+        json["TaskGroups"].each do |task_name, task_data|
+          next if announced_completed.include?(task_name)
+
+          desired_canaries = task_data["DesiredCanaries"]
+          desired_total = task_data["DesiredTotal"]
+          placed_allocations = task_data["PlacedAllocs"]
+          healthy_allocations = task_data["HealthyAllocs"]
+          unhealthy_allocations = task_data["UnhealthyAllocs"]
+
+          if manual_work_required
+            Nomade.logger.info "#{json["ID"]} #{task_name}: #{healthy_allocations}/#{desired_canaries}/#{desired_total} (Healthy/WantedCanaries/Total)"
+            announced_completed << task_name if healthy_allocations == desired_canaries
+          else
+            Nomade.logger.info "#{json["ID"]} #{task_name}: #{healthy_allocations}/#{desired_total} (Healthy/Total)"
+            announced_completed << task_name if healthy_allocations == desired_total
+          end
+        end
+
+        if manual_work_required
+          if json["Status"] == "failed"
+            Nomade.logger.info "#{json["Status"]}: #{json["StatusDescription"]}"
+            succesful_deployment = false
+          end
+
+          if succesful_deployment == nil && Time.now.utc > @timeout
+            Nomade.logger.info "Timeout hit, rolling back deploy!"
+            @http.fail_deployment(@deployment_id)
+            succesful_deployment = false
+          end
+
+          if succesful_deployment == nil && json["TaskGroups"].values.all?{|tg| tg["HealthyAllocs"] >= tg["DesiredCanaries"]}
+            if !promoted
+              Nomade.logger.info "Promoting #{@deployment_id} (version #{json["JobVersion"]})"
+              @http.promote_deployment(@deployment_id)
+              promoted = true
+              Nomade.logger.info ".. promoted!"
+            else
+              if json["Status"] == "successful"
+                succesful_deployment = true
+              else
+                Nomade.logger.info "Waiting for promotion to complete #{@deployment_id} (version #{json["JobVersion"]})"
+              end
+            end
+          end
+        else
+          case json["Status"]
+          when "running"
+            # no-op
+          when "failed"
+            Nomade.logger.info "#{json["Status"]}: #{json["StatusDescription"]}"
+            succesful_deployment = false
+          when "successful"
+            Nomade.logger.info "#{json["Status"]}: #{json["StatusDescription"]}"
+            succesful_deployment = true
+          end
+        end
+
+        sleep 10 if succesful_deployment == nil
+      end
+
+      if succesful_deployment
+        Nomade.logger.info ""
+        Nomade.logger.info "#{@deployment_id} (version #{json["JobVersion"]}) was succesfully deployed!"
+      else
+        Nomade.logger.warn ""
+        Nomade.logger.warn "#{@deployment_id} (version #{json["JobVersion"]}) deployment _failed_!"
+      end
+    end
+
+    def batch_deploy
+      alloc_status = nil
+      announced_dead = []
+
+      while(alloc_status != true) do
+        allocations = @http.allocations_from_evaluation_request(@evaluation_id)
+
+        allocations.each do |allocation|
+          allocation["TaskStates"].sort.each do |task_name, task_data|
+            full_task_address = [allocation["ID"], allocation["Name"], task_name].join(" ")
+            pretty_state = Nomade::Decorator.task_state_decorator(task_data["State"], task_data["Failed"])
+
+            unless announced_dead.include?(full_task_address)
+              Nomade.logger.info "#{allocation["ID"]} #{allocation["Name"]} #{task_name}: #{pretty_state}"
+
+              if task_data["State"] == "dead"
+                announced_dead << full_task_address
+              end
+            end
+          end
+        end
+
+        tasks           = get_tasks(allocations)
+        upcoming_tasks  = get_upcoming_tasks(tasks)
+        succesful_tasks = get_succesful_tasks(tasks)
+        failed_tasks    = get_failed_tasks(tasks)
+
+        if upcoming_tasks.size == 0
+          if failed_tasks.any?
+            raise Nomade::AllocationFailedError.new(@evaluation_id, allocations)
+          end
+
+          Nomade.logger.info "Deployment complete"
+
+          allocations.each do |allocation|
+            allocation["TaskStates"].sort.each do |task_name, task_data|
+              pretty_state = Nomade::Decorator.task_state_decorator(task_data["State"], task_data["Failed"])
+
+              Nomade.logger.info ""
+              Nomade.logger.info "#{allocation["ID"]} #{allocation["Name"]} #{task_name}: #{pretty_state}"
+
+              stdout = @http.get_allocation_logs(allocation["ID"], task_name, "stdout")
+              if stdout != ""
+                Nomade.logger.info
+                Nomade.logger.info "stdout:"
+                stdout.lines do |logline|
+                  Nomade.logger.info(logline.strip)
+                end
+              end
+
+              stderr = @http.get_allocation_logs(allocation["ID"], task_name, "stderr")
+              if stderr != ""
+                Nomade.logger.info
+                Nomade.logger.info "stderr:"
+                stderr.lines do |logline|
+                  Nomade.logger.info(logline.strip)
+                end
+              end
+            end
+          end
+
+          alloc_status = true
+        end
+
+        sleep(1)
+      end
+    end
+
+    # Task-helpers
+    def get_tasks(allocations)
+      [].tap do |it|
+        allocations.each do |allocation|
+          allocation["TaskStates"].sort.each do |task_name, task_data|
+            it << {
+              "Name" => task_name,
+              "Allocation" => allocation,
+            }.merge(task_data)
+          end
+        end
+      end
+    end
+
+    def get_upcoming_tasks(tasks)
+      [].tap do |it|
+        tasks.each do |task|
+          if ["pending", "running"].include?(task["State"])
+            it << task
+          end
+        end
+      end
+    end
+
+    def get_succesful_tasks(tasks)
+      [].tap do |it|
+        tasks.each do |task|
+          if task["State"] == "dead" && task["Failed"] == false
+            it << task
+          end
+        end
+      end
+    end
+
+    def get_failed_tasks(tasks)
+      [].tap do |it|
+        tasks.each do |task|
+          if task["State"] == "dead" && task["Failed"] == true
+            it << task
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/nomade/exceptions.rb

@@ -0,0 +1,14 @@
+module Nomade
+  class GeneralError < StandardError; end
+  class NoModificationsError < StandardError; end
+  class PlanningError < StandardError; end
+
+  class AllocationFailedError < StandardError
+    def initialize(evaluation_id, allocations)
+      @evaluation_id = evaluation_id
+      @allocations = allocations
+    end
+    attr_reader :evaluation_id, :allocations
+  end
+  class UnsupportedDeploymentMode < StandardError; end
+end

data/lib/nomade/http.rb

@@ -0,0 +1,228 @@
+require "net/https"
+require "json"
+
+module Nomade
+  class Http
+    def initialize(nomad_endpoint)
+      @nomad_endpoint = nomad_endpoint
+    end
+
+    def job_index_request(search_prefix = nil)
+      search_prefix = if search_prefix
+        "?prefix=#{search_prefix}"
+      else
+        ""
+      end
+      uri = URI("#{@nomad_endpoint}/v1/jobs#{search_prefix}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Get.new(uri)
+      req.add_field "Content-Type", "application/json"
+
+      res = http.request(req)
+
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return JSON.parse(res.body)
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def evaluation_request(evaluation_id)
+      uri = URI("#{@nomad_endpoint}/v1/evaluation/#{evaluation_id}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Get.new(uri)
+      req.add_field "Content-Type", "application/json"
+
+      res = http.request(req)
+
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return JSON.parse(res.body)
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def allocations_from_evaluation_request(evaluation_id)
+      uri = URI("#{@nomad_endpoint}/v1/evaluation/#{evaluation_id}/allocations")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Get.new(uri)
+      req.add_field "Content-Type", "application/json"
+
+      res = http.request(req)
+
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return JSON.parse(res.body)
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def deployment_request(deployment_id)
+      uri = URI("#{@nomad_endpoint}/v1/deployment/#{deployment_id}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Get.new(uri)
+      req.add_field "Content-Type", "application/json"
+
+      res = http.request(req)
+
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return JSON.parse(res.body)
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def check_if_job_exists?(nomad_job)
+      jobs = job_index_request(nomad_job.job_name)
+      jobs.map{|job| job["ID"]}.include?(nomad_job.job_name)
+    end
+
+    def create_job(nomad_job)
+      uri = URI("#{@nomad_endpoint}/v1/jobs")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Post.new(uri)
+      req.add_field "Content-Type", "application/json"
+      req.body = nomad_job.configuration(:json)
+
+      res = http.request(req)
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return JSON.parse(res.body)["EvalID"]
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def update_job(nomad_job)
+      uri = URI("#{@nomad_endpoint}/v1/job/#{nomad_job.job_name}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Post.new(uri)
+      req.add_field "Content-Type", "application/json"
+      req.body = nomad_job.configuration(:json)
+
+      res = http.request(req)
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return JSON.parse(res.body)["EvalID"]
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def promote_deployment(deployment_id)
+      uri = URI("#{@nomad_endpoint}/v1/deployment/promote/#{deployment_id}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Post.new(uri)
+      req.add_field "Content-Type", "application/json"
+      req.body = {
+        "DeploymentID" => deployment_id,
+        "All" => true,
+      }.to_json
+
+      res = http.request(req)
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return true
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def fail_deployment(deployment_id)
+      uri = URI("#{@nomad_endpoint}/v1/deployment/fail/#{deployment_id}")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Post.new(uri)
+      req.add_field "Content-Type", "application/json"
+
+      res = http.request(req)
+      raise if res.code != "200"
+      raise if res.content_type != "application/json"
+
+      return true
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def get_allocation_logs(allocation_id, task_name, logtype)
+      uri = URI("#{@nomad_endpoint}/v1/client/fs/logs/#{allocation_id}?task=#{task_name}&type=#{logtype}&plain=true&origin=end")
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+      req = Net::HTTP::Get.new(uri)
+      res = http.request(req)
+      raise if res.code != "200"
+
+      return res.body.gsub(/\e\[\d+m/, '')
+    rescue StandardError => e
+      Nomade.logger.fatal "HTTP Request failed (#{e.message})"
+      raise
+    end
+
+    def plan_job(nomad_job)
+      rendered_template = nomad_job.configuration(:hcl)
+      #   0: No allocations created or destroyed. Nothing to do.
+      #   1: Allocations created or destroyed.
+      # 255: Error determining plan results. Nothing to do.
+      allowed_exit_codes = [0, 1, 255]
+
+      exit_status, stdout, stderr = Shell.exec("NOMAD_ADDR=#{@nomad_endpoint} nomad job plan -diff -verbose -no-color -", rendered_template, allowed_exit_codes)
+
+      case exit_status
+      when 0
+        raise Nomade::NoModificationsError.new
+      when 1
+        # no-op
+      when 255
+        raise Nomade::PlanningError.new
+      end
+
+      true
+    end
+  end
+end

data/lib/nomade/job.rb

@@ -0,0 +1,76 @@
+require "erb"
+require "json"
+
+module Nomade
+  class Job
+    class FormattingError < StandardError; end
+
+    def initialize(template_file, image_full_name, environment_variables = {})
+      @image_full_name = image_full_name
+      @environment_variables = environment_variables
+
+      # image_full_name should be in the form of:
+      # redis:4.0.1
+      # kaspergrubbe/secretimage:latest
+      unless @image_full_name.match(/\A[a-zA-Z0-9\/]+\:[a-zA-Z0-9\.\-\_]+\z/)
+        raise Nomade::Job::FormattingError.new("Image-format wrong: #{@image_full_name}")
+      end
+
+      @config_hcl = render_erb(template_file)
+      @config_json = convert_job_hcl_to_json(@config_hcl)
+      @config_hash = JSON.parse(@config_json)
+    end
+
+    def configuration(format)
+      case format
+      when :hcl
+        @config_hcl
+      when :json
+        @config_json
+      else
+        @config_hash
+      end
+    end
+
+    def job_name
+      @config_hash["Job"]["ID"]
+    end
+
+    def job_type
+      @config_hash["Job"]["Type"]
+    end
+
+    def image_name_and_version
+      @image_full_name
+    end
+
+    def image_name
+      image_name_and_version.split(":").first
+    end
+
+    def image_version
+      image_name_and_version.split(":").last
+    end
+
+    def environment_variables
+      @environment_variables
+    end
+
+    private
+
+    def render_erb(erb_template)
+      file = File.open(erb_template).read
+      rendered = ERB.new(file, nil, '-').result(binding)
+
+      rendered
+    end
+
+    def convert_job_hcl_to_json(rendered_template)
+      exit_status, stdout, stderr = Shell.exec("nomad job run -output -no-color -", rendered_template)
+
+      JSON.pretty_generate({
+        "Job": JSON.parse(stdout)["Job"],
+      })
+    end
+  end
+end

data/lib/nomade/logger.rb

@@ -0,0 +1,18 @@
+require 'yell'
+
+module Nomade
+  def self.logger
+    $logger ||= begin
+      stdout = if ARGV.include?("-d") || ARGV.include?("--debug")
+        [:debug, :info, :warn]
+      else
+        [:info, :warn]
+      end
+
+      Yell.new do |l|
+        l.adapter STDOUT, level: stdout
+        l.adapter STDERR, level: [:error, :fatal]
+      end
+    end
+  end
+end

data/lib/nomade/shell.rb

@@ -0,0 +1,45 @@
+require "open3"
+
+module Nomade
+  class Shell
+    def self.exec(command, input = nil, allowed_exit_codes = [0])
+      Nomade.logger.debug("+: #{command}")
+
+      process, status, stdout, stderr = Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
+        if input
+          stdin.puts(input)
+        end
+        stdin.close
+
+        threads = {}.tap do |it|
+          it[:stdout] = Thread.new do
+            output = []
+            stdout.each do |l|
+              output << l
+              Nomade.logger.debug(l)
+            end
+            Thread.current[:output] = output.join
+          end
+
+          it[:stderr] = Thread.new do
+            output = []
+            stderr.each do |l|
+              output << l
+              Nomade.logger.debug(l)
+            end
+            Thread.current[:output] = output.join
+          end
+        end
+        threads.values.map(&:join)
+
+        [wait_thread.value, wait_thread.value.exitstatus, threads[:stdout][:output], threads[:stderr][:output]]
+      end
+
+      unless allowed_exit_codes.include?(status)
+        raise "`#{command}` failed with status=#{status}"
+      end
+
+      return [status, stdout, stderr]
+    end
+  end
+end

data/lib/nomade.rb

@@ -0,0 +1,12 @@
+ENV["TZ"] = "UTC"
+
+require "nomade/shell"
+require "nomade/job"
+require "nomade/logger"
+require "nomade/exceptions"
+require "nomade/http"
+require "nomade/deployer"
+require "nomade/decorators"
+
+module Nomade
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: nomade
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kasper Grubbe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+description: 
+email: nomade@kaspergrubbe.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nomade.rb
+- lib/nomade/decorators.rb
+- lib/nomade/deployer.rb
+- lib/nomade/exceptions.rb
+- lib/nomade/http.rb
+- lib/nomade/job.rb
+- lib/nomade/logger.rb
+- lib/nomade/shell.rb
+homepage: https://billetto.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Gem that deploys nomad jobs
+test_files: []