nf-conductor 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba7313ec020d08caef6fc2f2197023fb5654e7af
-  data.tar.gz: 57b6d1d827a77b4194d409a283ee65b6b8b209a0
+  metadata.gz: f08424a1df3af50e9fafb6b266a91adb9e030c70
+  data.tar.gz: f9f926426fec2d8d96f33d22c45b8269de0ec611
 SHA512:
-  metadata.gz: 5147f3b0c84f105a76e7725ba6859b9a8475d138fa8259ffe4207e17ee70b147ed2fa76ef384e42e6addb5f48da621f1e1699d5a35cefda8d8e5ccc045154fea
-  data.tar.gz: f0d3596b6c67e980b169e1e3f87575810acbf881dc38e757de33d64fea20dd53eed788da8d1cabb3b6435797ece3165b381b688dc9f38012f69c7ce191afac7e
+  metadata.gz: bbe0708f9ff458d5763d3132c6b063b109f29a7380047c080d1bd119b531538aea390358e2a3d2e5c513ec5915f019baec467948fe35812184bdd14a37385c15
+  data.tar.gz: f2cc8bac16811da8db285b87b58c5bb6968d8ad0829985719bec4ff6ea944f0b5b5df2a55a88d3ae168586b4fc8eb2eb013164c8483d60582e7459d1423a7566

data/lib/nf-conductor.rb

@@ -1,5 +1,51 @@
-class Conductor
-  def self.conduct
-    puts 'Hey look at that Conductor is done'
+require 'faraday'
+
+require 'nf-conductor/http/connection'
+require 'nf-conductor/http/model'
+require 'nf-conductor/http/metadata'
+require 'nf-conductor/http/tasks'
+require 'nf-conductor/http/workflow'
+
+require 'nf-conductor/worker/worker'
+
+require 'nf-conductor/coordinator/coordinator'
+
+module Conductor
+  SERVICE_URI_DEVELOPMENT = 'http://cpeworkflowdevint.dyntest.netflix.net:7001/'
+  SERVICE_URI_TESTING     = 'http://cpeworkflowtestintg.dyntest.netflix.net:7001/'
+  SERVICE_URI_PRODUCTION  = 'http://cpeworkflow.dynprod.netflix.net:7001/'
+
+  class << self
+    attr_accessor :config
+
+    def configure
+      self.config ||= Configuration.new
+      yield(config) if block_given?
+    end
+
+    def initialize(service_env)
+      configure if self.config.nil?
+      self.config.service_env ||= service_env
+
+      # Ensure service_uri is set in configuration
+      if self.config.service_env.nil? && self.config.service_uri.nil?
+        raise "Service information is required"
+      elsif self.config.service_uri
+        # No action required
+      elsif self.config.service_env
+        self.config.service_uri = case self.config.service_env
+                                  when 'development'
+                                    SERVICE_URI_DEVELOPMENT
+                                  when 'testing'
+                                    SERVICE_URI_TESTING
+                                  when 'production'
+                                    SERVICE_URI_PRODUCTION
+                                  end
+      end
+    end
+  end
+
+  class Configuration
+    attr_accessor :service_env, :service_uri
   end
 end

data/lib/nf-conductor/coordinator/coordinator.rb

@@ -0,0 +1,87 @@
+require 'pry'
+require 'concurrent'
+
+module Conductor
+  class Coordinator
+    attr_accessor :workers, :polling_timers, :max_thread_count
+
+    # Create a new Coordinator for a certain set of Workers.
+    # A Worker is an implementatino of the Worker Interface for a specific task.
+    # Conductor::Coordinator.new([Conductor::Worker.new('matt-1'), Conductor::Worker.new('matt-2')])
+    def initialize(workers, max_thread_count: 5)
+      self.workers = workers
+      self.polling_timers = []
+      self.max_thread_count = max_thread_count
+    end
+
+    # Creates and executes a TimerTask for each Worker that the Coordinator has been instantiated with.
+    # http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html
+    def run(execution_interval=15)
+      self.workers.each do |worker|
+        polling_timer = Concurrent::TimerTask.new(execution_interval: execution_interval) do
+          puts "Conductor::Coordinator : Worker (#{worker.task_type}) polling..."
+          poll_for_task(worker)
+        end
+
+        self.polling_timers << polling_timer
+        polling_timer.execute
+      end
+    end
+
+    # Shuts down all polling_timers for the Coordinator. Workers will no longer poll for new Tasks.
+    def stop
+      self.polling_timers.each do |polling_timer|
+        polling_timer.shutdown
+      end
+    end
+
+    # Executed once every x seconds based on the parent polling_timer.
+    # Batch polls the Conductor task queue for the given worker and task type,
+    # and executes as many tasks concurrently as possible, using a CachedThreadPool
+    # http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html
+    def poll_for_task(worker)
+      # bulk poll for task, concurrently, up to size of queue
+      tasks = [Conductor::Tasks.poll_task(worker.task_type)]
+      tasks.each do |task|
+        next if task[:status] != 200
+        process_task(worker, task[:body])
+      end
+    rescue => e
+      puts "Conductor::Coordinator : Failed to poll worker (#{worker.task_type}) with error #{e.message}"
+    end
+
+    # Acknowledges the Task in Conductor, then passes the Task to the Worker to execute.
+    # Update the Task in Conductor with status and output data.
+    def process_task(worker, task)
+      puts "Conductor::Coordinator : Processing task #{task}"
+
+      task_identifiers = {
+        taskId: task['taskId'],
+        workflowInstanceId: task['workflowInstanceId']
+      }
+
+      # Acknowledge the task, so other pollers will not be able to see the task in Conductor's queues
+      Conductor::Tasks.acknowledge_task(*(task_identifiers.values))
+
+      # Execute the task with the implementing application's worker
+      result = worker.execute(task)
+      task_body = result.merge!(task_identifiers)
+
+      # Update Conductor about the result of the task
+      update_task_with_retry(task_body, 0)
+    rescue => e
+      puts "Conductor::Coordinator : Failed to process task (#{task}) with error #{e.message}"
+      update_task_with_retry({ status: 'FAILED' }.merge(task_identifiers), 0)
+    end
+
+    def update_task_with_retry(task_body, count)
+      # Put this in a retryable block instead
+      begin
+        return if count >= 3
+        Conductor::Tasks.update_task(task_body)
+      rescue
+        update_task_with_retry(task_body, count+1)
+      end
+    end
+  end
+end

data/lib/nf-conductor/data/task.rb

@@ -0,0 +1,9 @@
+module Conductor
+  class Data::Task
+    def initialize()
+
+    end
+
+    # def to_json
+  end
+end

data/lib/nf-conductor/http/connection.rb

@@ -0,0 +1,55 @@
+require 'faraday_middleware'
+
+module Conductor
+  class Connection
+    attr_reader :connection, :args
+
+    def initialize(args = {})
+      @connection ||= Faraday.new(url: Conductor.config.service_uri) do |c|
+        c.request :json
+        c.response :json, :content_type => /\bjson$/
+        c.adapter Faraday.default_adapter
+      end
+
+      args.each do |k,v|
+        @connection.headers[k] = v
+      end
+    end
+
+    def get(url, args={})
+      puts "Conductor::Connection : GET #{url} with args #{args}"
+      connection.get do |req|
+        req.url url
+        req.headers['Content-Type'] = ( args[:headers] && args[:headers]['Content-Type'] || 'application/json' )
+        req.body = args[:body] if args[:body]
+      end
+    end
+
+    def post(url, args={})
+      puts "Conductor::Connection : POST #{url} with args #{args}"
+      connection.post do |req|
+        req.url url
+        req.headers['Content-Type'] = ( args[:headers] && args[:headers]['Content-Type'] || 'application/json' )
+        req.body = args[:body] if args[:body]
+      end
+    end
+
+    def put(url, args={})
+      puts "Conductor::Connection : PUT #{url} with args #{args}"
+      connection.put do |req|
+        req.url url
+        req.headers['Content-Type'] = ( args[:headers] && args[:headers]['Content-Type'] || 'application/json' )
+        req.body = args[:body] if args[:body]
+      end
+    end
+
+    def delete(url, args={})
+      puts "Conductor::Connection : DELETE #{url} with args #{args}"
+      connection.delete do |req|
+        req.url url
+        req.headers['Content-Type'] = ( args[:headers] && args[:headers]['Content-Type'] || 'application/json' )
+        req.body = args[:body] if args[:body]
+      end
+    end
+  end
+end

data/lib/nf-conductor/http/metadata.rb

@@ -0,0 +1,89 @@
+module Conductor
+  class Metadata < Model
+    def initialize(response)
+      super(response)
+    end
+
+    class << self
+      # GET /metadata/taskdefs
+      def get_all_tasks
+        response = Connection.new.get(
+          "/metadata/taskdefs"
+        )
+        Metadata.build(response)
+      end
+
+      # GET /metadata/taskdefs/{taskType}
+      def get_task(task_type)
+        response = Connection.new.get(
+          "/metadata/taskdefs/#{task_type}"
+        )
+        Metadata.build(response)
+      end
+
+      # POST /metadata/taskdefs
+      # 204 success
+      def create_tasks(task_list)
+        response = Connection.new.post(
+          "/metadata/taskdefs",
+          { body: (task_list.is_a?(Array) ? task_list : [task_list]).to_json }
+        )
+        Metadata.build(response)
+      end
+
+      # PUT /metadata/taskdefs
+      def update_task(task_definition)
+        response = Connection.new.put(
+          "/metadata/taskdefs",
+          { body: task_definition.to_json }
+        )
+        Metadata.build(response)
+      end
+
+      # DELETE /metadata/taskdefs/{taskType}
+      def delete_task(task_type)
+        response = Connection.new.delete(
+          "/metadata/taskdefs/#{task_type}"
+        )
+        Metadata.build(response)
+      end
+
+      # GET /metadata/workflow
+      def get_all_workflows
+        response = Connection.new.get(
+          "/metadata/workflow"
+        )
+        Metadata.build(response)
+      end
+
+      # GET /metadata/workflow/{name}?version=
+      # Workflow name required, version optional
+      def get_workflow(workflow_name, version=nil)
+        response = Connection.new.get(
+          "/metadata/workflow/#{workflow_name}?version=#{version}"
+        )
+        Metadata.build(response)
+      end
+
+      # POST /metadata/workflow
+      # Only one workflow
+      def create_workflow(workflow)
+        response = Connection.new.post(
+          "/metadata/workflow",
+          { body: workflow.to_json }
+        )
+        Metadata.build(response)
+      end
+
+      # PUT /metadata/workflow
+      # Multiple workflows
+      def create_or_update_workflows(workflow_list)
+        response = Connection.new.put(
+          "/metadata/taskdefs",
+          { body: (workflow_list.is_a?(Array) ? workflow_list : [workflow_list]).to_json }
+        )
+        Metadata.build(response)
+      end
+    end
+  end
+end

data/lib/nf-conductor/http/model.rb

@@ -0,0 +1,18 @@
+module Conductor
+  class Model
+    attr_reader :response
+    attr_accessor :status
+
+    def initialize(response)
+      @response = response
+    end
+
+    def self.build(response)
+      # Add error handling
+      {
+        status: response.status,
+        body: response.body
+      }
+    end
+  end
+end

data/lib/nf-conductor/http/tasks.rb

@@ -0,0 +1,176 @@
+module Conductor
+  class Tasks < Model
+    def initialize(response)
+      super(response)
+    end
+
+    class << self
+      # GET /tasks/poll/batch/{tasktype}
+      # batch Poll for a task of a certain type
+      def batch_poll_for_tasks(task_type, worker_id, domain, count, timeout)
+        response = Connection.new.get(
+          "/tasks/poll/batch/#{task_type}?workerid=#{worker_id}&domain=#{domain}&count=#{count}&timeout=#{timeout}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/in_progress/{tasktype}
+      # Get in progress tasks. The results are paginated.
+      def get_in_progress_tasks(task_type, start_key, count)
+        response = Connection.new.get(
+          "/tasks/in_progress/#{task_type}?startKey=#{start_key}&count=#{count}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/in_progress/{workflowId}/{taskRefName}
+      # Get in progress task for a given workflow id.
+      def get_in_progress_task_in_workflow(workflow_id, task_name)
+        response = Connection.new.get(
+          "/tasks/in_progress/#{workflow_id}/#{task_name}"
+        )
+        Tasks.build(response)
+      end
+
+      # POST /tasks
+      # Update a task
+      def update_task(task_body)
+        response = Connection.new.post(
+          "/tasks",
+          { body: task_body.to_json }
+        )
+        Tasks.build(response)
+      end
+
+      # POST /tasks/{taskId}/ack
+      # Ack Task is recieved
+      def acknowledge_task(task_id, worker_id=nil)
+        response = Connection.new.post(
+          "/tasks/#{task_id}/ack?workerid=#{worker_id}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/{taskId}/log
+      # Get Task Execution Logs
+      def get_task_logs(task_id)
+        response = Connection.new.get(
+          "/tasks/#{task_id}/log"
+        )
+        Tasks.build(response)
+      end
+
+      # POST /tasks/{taskId}/log
+      # Log Task Execution Details
+      def add_task_log(task_id, task_log)
+        response = Connection.new.post(
+          "/tasks/#{task_id}/log",
+          { body: task_log.to_json }
+        )
+        Tasks.build(response)
+      end
+
+      # DELETE /tasks/queue/{taskType}/{taskId}
+      # Remove Task from a Task type queue
+      def remove_task(task_type, task_id)
+        response = Connection.new.delete(
+          "/tasks/queue/#{task_type}/#{task_id}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/queue/all/verbose
+      # Get the details about each queue
+      def get_all_tasks_verbose
+        response = Connection.new.get(
+          "/tasks/queue/all/verbose"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/queue/polldata
+      # Get the last poll data for a given task type
+      def get_poll_data(task_type)
+        response = Connection.new.get(
+          "/tasks/queue/polldata?taskType=#{task_type}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/queue/polldata/all
+      # Get the last poll data for a given task type
+      def get_all_poll_data
+        response = Connection.new.get(
+          "/tasks/queue/polldata/all"
+        )
+        Tasks.build(response)
+      end
+
+      # POST /tasks/queue/requeue/{taskType}
+      # Requeue pending tasks
+      def requeue_tasks(task_type)
+        response = Connection.new.post(
+          "/tasks/queue/requeue/#{task_type}"
+        )
+        Tasks.build(response)
+      end
+
+      # POST /tasks/queue/requeue
+      # Requeue pending tasks for all the running workflows
+      def requeue_all_tasks
+        response = Connection.new.post(
+          "/tasks/queue/requeue"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/queue/sizes
+      # Get Task type queue sizes
+      def get_queue_sizes(task_types)
+        task_types_query = task_types.is_a?(Array) ? task_types.to_query('taskType') : "taskType=#{taskType}"
+        response = Connection.new.get(
+          "/tasks/queue/sizes?#{task_types_query}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/poll/{tasktype}
+      # Poll for a task of a certain type
+      def poll_task(task_type, worker_id=nil, domain=nil)
+        query_string = "/tasks/poll/#{task_type}"
+        query_string += "?workerid=#{worker_id}" if worker_id
+        query_string += "&domain=#{domain}" if domain
+
+        response = Connection.new.get(query_string)
+        Tasks.build(response)
+      end
+
+      # GET /tasks/search
+      # Search for tasks based in payload and other parameters
+      def search_task(start, size, sort, free_text, query)s
+        response = Connection.new.get(
+          "/tasks/search?start=#{start}&size=#{size}&sort=#{sort}&freeText=#{free_text}&query=#{query}"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/queue/all
+      # Get the details about each queue
+      def get_all_tasks
+        response = Connection.new.get(
+          "/tasks/queue/all"
+        )
+        Tasks.build(response)
+      end
+
+      # GET /tasks/{taskId}
+      # Get task by Id
+      def get_task(task_id)
+        response = Connection.new.get(
+          "/tasks/#{task_id}"
+        )
+        Tasks.build(response)
+      end
+    end
+  end
+end

data/lib/nf-conductor/http/workflow.rb

@@ -0,0 +1,141 @@
+module Conductor
+  class Workflow < Model
+    def initialize(response)
+      super(response)
+    end
+
+    class << self
+      # POST /workflow/{name}
+      def start_workflow(name, version=nil, correlation_id=nil, body={})
+        response = Connection.new.post(
+          "/workflow/#{name}?version=#{version}&correlationId=#{correlation_id}",
+          { body: body.to_json }
+        )
+        Workflow.build(response)
+      end
+
+      # POST /workflow
+      def start_workflow_with_domains(workflow)
+        response = Connection.new.post(
+          "/workflow",
+          { body: workflow.to_json }
+        )
+        Workflow.build(response)
+      end
+
+      # GET /workflow/{name}/correlated/{correlationId}
+      def get_correlated_workflows(workflow_name, correlation_id, include_closed=false, include_tasks=false)
+        response = Connection.new.get(
+          "/workflow/#{workflow_name}/correlated/#{correlation_id}?includeClosed=#{include_closed}&includeTasks=#{include_tasks}"
+        )
+        Workflow.build(response)
+      end
+
+      # DELETE /workflow/{workflowId}
+      def terminate_workflow(workflow_id, reason)
+        response = Connection.new.delete(
+          "/workflow/#{workflow_id}?reason=#{reason}"
+        )
+        Workflow.build(response)
+      end
+
+      # GET /workflow/{workflowId}
+      def get_workflow(workflow_id, include_tasks=true)
+        response = Connection.new.get(
+          "/workflow/#{workflow_id}?includeTasks=#{include_tasks}"
+        )
+        Workflow.build(response)
+      end
+
+      # GET /workflow/running/{name}
+      def get_running_workflow(workflow_name, version, start_time, end_time)
+        response = Connection.new.get(
+          "/workflow/running/#{workflow_name}?version=#{version}&startTime=#{start_time}&endTime=#{end_time}"
+        )
+        Workflow.build(response)
+      end
+
+      # PUT /workflow/decide/{workflowId}
+      def decide_workflow(workflow_id)
+        response = Connection.new.put(
+          "/workflow/decide/#{workflow_id}"
+        )
+        Workflow.build(response)
+      end
+
+      # PUT /workflow/{workflowId}/pause
+      def pause_workflow(workflow_id)
+        response = Connection.new.put(
+          "/workflow/#{workflow_id}/pause"
+        )
+        Workflow.build(response)
+      end
+
+      # PUT /workflow/{workflowId}/resume
+      def resume_workflow(workflow_id)
+        response = Connection.new.put(
+          "/workflow/#{workflow_id}/resume"
+        )
+        Workflow.build(response)
+      end
+
+      # PUT /workflow/{workflowId}/skiptask/{taskReferenceName}
+      def skip_task_for_workflow(workflow_id, task_name, task_body)
+        response = Connection.new.put(
+          "/workflow/#{workflow_id}/skiptask/#{task_name}",
+          { body: task_body.to_json }
+        )
+        Workflow.build(response)
+      end
+
+      # POST /workflow/{workflowId}/rerun
+      def rerun_workflow(workflow_id, rerun_body)
+        response = Connection.new.post(
+          "/workflow/#{workflow_id}/rerun",
+          { body: rerun_body.to_json }
+        )
+        Workflow.build(response)
+      end
+
+      # POST /workflow/{workflowId}/restart
+      def restart_workflow(workflow_id)
+        response = Connection.new.post(
+          "/workflow/#{workflow_id}/restart"
+        )
+        Workflow.build(response)
+      end
+
+      # POST /workflow/{workflowId}/retry
+      def retry_workflow(workflow_id)
+        response = Connection.new.post(
+          "/workflow/#{workflow_id}/retry"
+        )
+        Workflow.build(response)
+      end
+
+      # DELETE /workflow/{workflowId}/remove
+      def delete_workflow(workflow_id)
+        response = Connection.new.delete(
+          "/workflow/#{workflow_id}/remove"
+        )
+        Workflow.build(response)
+      end
+
+      # POST /workflow/{workflowId}/resetcallbacks
+      def reset_callbacks_for_workflow(workflow_id)
+        response = Connection.new.post(
+          "/workflow/#{workflow_id}/resetcallbacks"
+        )
+        Workflow.build(response)
+      end
+
+      # GET /workflow/search
+      def search_workflows(start, size, sort, free_text, query)
+        response = Connection.new.get(
+          "/workflow/search?start=#{start}&size=#{size}&sort=#{sort}&freeText=#{free_text}&query=#{query}"
+        )
+        Workflow.build(response)
+      end
+    end
+  end
+end

data/lib/nf-conductor/version.rb

@@ -0,0 +1,3 @@
+module Conductor
+  VERSION = '0.0.2'
+end

data/lib/nf-conductor/worker/worker.rb

@@ -0,0 +1,17 @@
+module Conductor
+  class Worker
+    attr_accessor :task_type
+
+    def method_not_implemented
+      raise "Conductor::Worker: Interface method must be implemented by worker subclass"
+    end
+
+    def initialize(task_type)
+      self.task_type = task_type
+    end
+
+    def execute(task)
+      method_not_implemented
+    end
+  end
+end

metadata

@@ -1,15 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: nf-conductor
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Matthew Rials
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-17 00:00:00.000000000 Z
-dependencies: []
+date: 2017-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Ruby client containing a task worker interface, worker coordinator, and
   HTTP client for Netflix's Conductor API
 email: mrials@netflix.com
@@ -18,6 +88,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/nf-conductor.rb
+- lib/nf-conductor/coordinator/coordinator.rb
+- lib/nf-conductor/data/task.rb
+- lib/nf-conductor/data/workflow.rb
+- lib/nf-conductor/http/connection.rb
+- lib/nf-conductor/http/metadata.rb
+- lib/nf-conductor/http/model.rb
+- lib/nf-conductor/http/tasks.rb
+- lib/nf-conductor/http/workflow.rb
+- lib/nf-conductor/version.rb
+- lib/nf-conductor/worker/worker.rb
 homepage: http://rubygems.org/gems/nf-conductor
 licenses:
 - MIT