container_broker 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 021bb9a1ca3d028ae71c5640840335415923572f5427f4ae2ab0905cadd35fe4
+  data.tar.gz: e8af975eb58b008668e654fa0e1d0ca4b7ea70e9832ca788ed4842d021fe6f8d
+SHA512:
+  metadata.gz: 963ddbcc97ebc45676eab092818f8f3e23d20be0e24f45aec26fb3c5f49db3ef7fe9342f6bc0488b7827b6d99bdb8bbba586f446a7cf25ba6b5613bc0f9fa35d
+  data.tar.gz: c59b5198d1b4fdc532ac1ea93cafd947ea04b35573f752b9c8ce6277c9a40a76fa1903ac774d98afc13693e846558056ef8d2ac0a771c9b3c26edb9a36675d36

data/README.md

@@ -0,0 +1,98 @@
+# Container Broker
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'container-broker'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install container-broker
+
+## Usage
+
+### Routes
+
+#### Nodes
+
+##### List
+  - `GET /nodes`
+
+##### Add
+  - `POST /nodes`
+  - Parameters: `{ "hostname": "", "slots_execution_types": {"cpu": 2, "network": 10} }`
+
+##### Update
+  - `PATCH /nodes/:uuid`
+  - Parameters: `{ "slots_execution_types": {"cpu": 2, "network": 10} }`
+
+##### Remove
+  - `DELETE /nodes/:uuid`
+  - Parameters: `{ "slots_execution_types": {"cpu": 2, "network": 10} }`
+
+#### Tasks
+
+##### Create
+  - `POST /tasks`
+  - Parameters: `{ "name": "", "image": "", "cmd": "", "storage_mounts": "{}", "tags": {"type": "video"} }`
+  - Response:
+  ```json
+  {
+    "status": "ok|error",
+    "uuid": "2d272b5c-953c-44e9-ad15-6c31187903c9"
+  }
+  ```
+
+##### Task Details
+  - Show information about some job
+  - Parameters (query string): `id`
+  - Response:
+  ```json
+  {
+    "uuid": "2d272b5c-953c-44e9-ad15-6c31187903c9",
+    "status": "waiting|running|completed|error"
+  }
+  ```
+
+#### GET /status
+  - Show pool informations
+  - Response:
+  ```json
+  {
+    "nodes": [
+      {
+        "hostname": "",
+        "cores": 10,
+        "memory": 4096,
+        "jobs": [
+          {
+            "uuid": "2d272b5c-953c-44e9-ad15-6c31187903c9",
+            "status": "waiting|running|completed|error"
+          }
+        ]
+      }
+    ]
+  }
+  ```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Expose Docker HTTP API on MacOSX:
+```shell
+socat TCP-LISTEN:2376,reuseaddr,fork UNIX-CONNECT:/var/run/docker.sock
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/globocom/container-broker.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationController < ActionController::API
+  # protect_from_forgery with: :exception
+end

data/app/controllers/healthcheck_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class HealthcheckController < ApplicationController
+  def index
+    render json: {
+      status: "OK",
+      sidekiq_redis: Sidekiq.redis_info["redis_version"],
+      lock_manager_redis: LockManager.redis_client.info["redis_version"],
+      mongodb: {
+        nodes: Node.count,
+        slots: Slot.count,
+        pending_tasks: Task.where(status: "waiting").count
+      }
+    }
+  rescue StandardError => e
+    render json: {
+      status: "ERROR",
+      message: "#{e.class}: #{e.message}"
+    }
+  end
+end

data/app/controllers/nodes_controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class NodesController < ApplicationController
+  before_action :load_node, only: %i[update show destroy accept_new_tasks reject_new_tasks kill_containers]
+
+  rescue_from Mongoid::Errors::Validations do |exception|
+    render json: exception.record.errors.messages, status: :unprocessable_entity
+  end
+
+  def index
+    render json: Node.all
+  end
+
+  def create
+    @node = Node.create!(node_params)
+
+    FriendlyNameNodes.new.perform
+    AdjustNodeSlotsJob.perform_later(node: @node)
+
+    render json: @node, status: :created
+  end
+
+  def show
+    render json: @node
+  end
+
+  def update
+    @node.update!(node_params.slice(:slots_execution_types))
+    AdjustNodeSlotsJob.perform_later(node: @node)
+
+    render json: @node
+  end
+
+  def destroy
+    DeleteNode.new(node: @node).perform
+    FriendlyNameNodes.new.perform
+
+    head :ok
+  rescue DeleteNode::NodeWithRunningSlotsError
+    head :not_acceptable
+  end
+
+  def reject_new_tasks
+    NodeTaskAcceptance.new(node: @node).reject!
+
+    head :ok
+  end
+
+  def accept_new_tasks
+    NodeTaskAcceptance.new(node: @node).accept!
+
+    head :ok
+  end
+
+  def kill_containers
+    KillNodeRunners.new(node: @node).perform
+
+    head :ok
+  end
+
+  private
+
+  def load_node
+    @node = Node.find_by!(uuid: params[:uuid])
+  end
+
+  def node_params
+    params.require(:node).permit(:hostname, slots_execution_types: {})
+  end
+end

data/app/controllers/nodes_healthcheck_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class NodesHealthcheckController < ApplicationController
+  def index
+    render json: {
+      status: status,
+      failed_nodes: failed_nodes.map { |node| NodeHealthcheckSerializer.new(node) }
+    }
+  end
+
+  private
+
+  def failed_nodes
+    @failed_nodes ||= Node.unavailable
+  end
+
+  def nodes_failed?
+    failed_nodes.to_a.any?
+  end
+
+  def status
+    if nodes_failed?
+      "FAILING"
+    else
+      "WORKING"
+    end
+  end
+end

data/app/controllers/status_controller.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class StatusController < ApplicationController
+  LIMIT_TASKS = 200
+
+  def nodes
+    render json: Node.includes(:slots).order(name: :asc), each_serializer: StatusPanelNodeSerializer
+  end
+
+  def tasks
+    @tasks = Task
+             .only(Task.attribute_names - %w[logs])
+             .includes(:slot)
+             .order_by("created_at" => "desc")
+             .batch_size(LIMIT_TASKS)
+             .limit(LIMIT_TASKS)
+
+    @tasks = @tasks.where(status: params[:status]) if params[:status].present?
+    if params[:tags]
+      params.require(:tags).each do |tag, value|
+        @tasks = @tasks.where("tags.#{tag}" => value.to_s)
+      end
+    end
+
+    render json: @tasks, each_serializer: StatusPanelTaskSerializer
+  end
+
+  def tags
+    @tags = TaskTag.pluck(:name)
+    render json: @tags
+  end
+
+  def task_statuses
+    render json: Task.all_status
+  end
+
+  def tag_values
+    @tag = TaskTag.find_by!(name: params[:tag_name])
+    render json: @tag.values.take(50)
+  end
+
+  def retry_task
+    @task = Task.find_by!(uuid: params[:uuid])
+    @task.force_retry!
+
+    head :ok
+  end
+end

data/app/controllers/tasks_controller.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class TasksController < ApplicationController
+  before_action :set_task, only: %i[show logs mark_as_error kill_container]
+  before_action :set_request_id, only: %i[create]
+
+  def create
+    @task = Task.new(task_params)
+
+    if @task.save
+      Metrics.new("tasks").count(
+        task_id: @task.id,
+        name: @task&.name,
+        status: @task.status
+      )
+
+      render json: @task
+    else
+      render json: @task.errors, status: :unprocessable_entity
+    end
+  end
+
+  def show
+    render json: @task
+  end
+
+  def logs
+    render json: { logs: @task.get_logs&.encode("utf-8", undef: :replace, replace: "?") }
+  end
+
+  def clear_errors
+    Task.error.destroy
+    head :ok
+  end
+
+  def mark_as_error
+    if @task.failed?
+      @task.error!
+
+      head :ok
+    else
+      render json: { message: "Task must have failed status to be marked as error" }, status: :unprocessable_entity
+    end
+  end
+
+  def kill_container
+    KillTaskContainer.new(task: @task).perform
+
+    head :ok
+  rescue KillTaskContainer::TaskNotRunningError => e
+    render json: { message: e.message }, status: :bad_request
+  end
+
+  private
+
+  def set_task
+    @task = Task.find_by!(uuid: params[:uuid])
+  end
+
+  def task_params
+    params.require(:task).permit(
+      :name,
+      :image,
+      :cmd,
+      :persist_logs,
+      :execution_type,
+      storage_mounts: {},
+      tags: {}
+    ).tap do |permitted_params|
+      # TODO: Remove after migrate encoder
+      if params.key?(:ingest_storage_mount) || params[:task].key?(:ingest_storage_mount)
+        permitted_params[:storage_mounts] = {
+          "ingest-nfs" => params[:ingest_storage_mount] || params.dig(:task, :ingest_storage_mount)
+        }
+      end
+    end
+  end
+
+  def set_request_id
+    params[:task][:tags] ||= {}
+    params[:task][:tags][:request_id] = request.request_id
+  end
+end

data/app/controllers/tasks_healthcheck_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class TasksHealthcheckController < ApplicationController
+  def index
+    render json: {
+      status: status,
+      failed_tasks_count: failed_tasks_count
+    }
+  end
+
+  private
+
+  def failed_tasks_count
+    @failed_tasks_count ||= Task.failed.count
+  end
+
+  def tasks_failed?
+    failed_tasks_count > 0
+  end
+
+  def status
+    if tasks_failed?
+      "FAILING"
+    else
+      "WORKING"
+    end
+  end
+end

data/app/jobs/add_task_tags_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AddTaskTagsJob < ContainerBrokerBaseJob
+  extend RequestIdFromTask
+
+  queue_as :default
+
+  def perform(task:)
+    task.tags.keys.each do |tag_name|
+      TaskTag.find_or_create_by(name: tag_name.to_s)
+    end
+  end
+end

data/app/jobs/adjust_node_slots_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class AdjustNodeSlotsJob < ContainerBrokerBaseJob
+  queue_as :default
+
+  def perform(node:)
+    lock_manager_instance(node).lock do
+      node.reload
+      all_execution_types(node).each do |execution_type|
+        AdjustExecutionTypeSlots.new(
+          node: node,
+          execution_type: execution_type
+        ).perform
+      end
+    end
+  end
+
+  private
+
+  def all_execution_types(node)
+    (node.slots_execution_types.keys + node.slots.map(&:execution_type)).uniq
+  end
+
+  def lock_manager_instance(node)
+    LockManager.new(type: self.class.to_s, id: node.id, wait: true, expire: 1.minute)
+  end
+end