kuroko2 0.2.0

data/app/controllers/kuroko2/sessions_controller.rb

@@ -0,0 +1,32 @@
+class Kuroko2::SessionsController < Kuroko2::ApplicationController
+  skip_before_action :require_sign_in
+
+  def new
+    render layout: false
+  end
+
+  def create
+    return_to = params[:state]
+    reset_session
+
+    self.current_user = Kuroko2::User.find_or_create_user(auth_hash[:uid], auth_hash[:info])
+
+    unless Kuroko2::ReturnToValidator.valid?(return_to)
+      return_to = root_path
+    end
+    redirect_to return_to
+  end
+
+  def destroy
+    reset_session
+
+    redirect_to sign_in_path
+  end
+
+  private
+
+  def auth_hash
+    request.env['omniauth.auth']
+  end
+
+end

data/app/controllers/kuroko2/stars_controller.rb

@@ -0,0 +1,30 @@
+class Kuroko2::StarsController < Kuroko2::ApplicationController
+  def create
+    star = Kuroko2::Star.new do |star|
+      star.job_definition = Kuroko2::JobDefinition.find(star_params[:job_definition_id])
+      star.user           = current_user
+    end
+
+    if (star.save)
+      render json: star, status: :created
+    else
+      raise HTTP::BadRequest
+    end
+  end
+
+  def destroy
+    star = Kuroko2::Star.find(params[:id])
+
+    if (star.destroy)
+      render json: star, status: :ok
+    else
+      raise HTTP::BadRequest
+    end
+  end
+
+  private
+
+  def star_params
+    params.permit(:job_definition_id)
+  end
+end

data/app/controllers/kuroko2/tokens_controller.rb

@@ -0,0 +1,47 @@
+class Kuroko2::TokensController < Kuroko2::ApplicationController
+
+  before_action :set_token, only: %i(update)
+  before_action :set_engine, only: %i(update)
+
+  def index
+    @definition = Kuroko2::JobDefinition.find(tokens_params[:job_definition_id])
+    @instance   = Kuroko2::JobInstance.find(tokens_params[:job_instance_id])
+    @tokens     = @instance.tokens
+
+    render layout: false
+  end
+
+  def update
+    @instance = @token.job_instance
+
+    case params[:invoke]
+    when 'skip'
+      @instance.logs.info("Skipped by #{current_user.name}.")
+
+      @engine.skip(@token)
+    when 'retry'
+      @instance.logs.info("Retry by #{current_user.name}.")
+
+      @engine.retry(@token)
+    else
+      raise HTTP::BadRequest
+    end
+
+    redirect_to job_definition_job_instance_path(job_definition_id: @token.job_definition_id, id: @token.job_instance.id)
+  end
+
+  private
+
+  def set_engine
+    @engine = Kuroko2::Workflow::Engine.new
+  end
+
+  def set_token
+    @token = Kuroko2::Token.where(job_definition_id: params[:job_definition_id], job_instance_id: params[:job_instance_id]).find(params[:id])
+  end
+
+  def tokens_params
+    params.permit(:job_definition_id, :job_instance_id)
+  end
+
+end

data/app/controllers/kuroko2/users_controller.rb

@@ -0,0 +1,62 @@
+class Kuroko2::UsersController < Kuroko2::ApplicationController
+  before_action :set_user, only: [:destroy]
+
+  def index
+    @user  = Kuroko2::User.new
+    if params[:target] == 'group'
+      @users = Kuroko2::User.group_user.all.page(page_params[:page])
+    else
+      @users = Kuroko2::User.all.page(page_params[:page])
+    end
+  end
+
+  def show
+    @user = Kuroko2::User.find(params[:id])
+    @input_tags  = params[:tag] || []
+
+    @definitions = @user.assigned_job_definitions
+    if @input_tags.present?
+      @definitions = @definitions.tagged_by(@input_tags)
+    end
+
+    @instances    = Kuroko2::JobInstance.working.where(job_definition: @definitions)
+    @related_tags = @definitions.includes(:tags).map(&:tags).flatten.uniq
+  end
+
+  def create
+    @user = Kuroko2::User.new(user_params)
+    @user.provider = Kuroko2::User::GROUP_PROVIDER
+    @user.uid      = @user.email
+
+    if @user.save
+      redirect_to users_path
+    else
+      @users = Kuroko2::User.all
+
+      render action: :index
+    end
+  end
+
+  def destroy
+    if @user.destroy
+      redirect_to users_url
+    else
+      @users = Kuroko2::User.all
+
+      render :index
+    end
+  end
+
+  private
+  def set_user
+    @user = Kuroko2::User.find(params[:id])
+  end
+
+  def user_params
+    params.require(:user).permit(:name, :email)
+  end
+
+  def page_params
+    params.permit(:page)
+  end
+end

data/app/controllers/kuroko2/workers_controller.rb

@@ -0,0 +1,5 @@
+class Kuroko2::WorkersController < Kuroko2::ApplicationController
+  def index
+    @workers = Kuroko2::Worker.ordered.all
+  end
+end

data/app/errors/http/bad_request.rb

@@ -0,0 +1,4 @@
+module HTTP
+  class BadRequest < StandardError
+  end
+end

data/app/errors/http/forbidden.rb

@@ -0,0 +1,4 @@
+module HTTP
+  class Forbidden < StandardError
+  end
+end

data/app/errors/http/unauthorized.rb

@@ -0,0 +1,4 @@
+module HTTP
+  class Unauthorized < StandardError
+  end
+end

data/app/helpers/kuroko2/application_helper.rb

@@ -0,0 +1,8 @@
+require 'rails_rinku'
+
+module Kuroko2
+  module ApplicationHelper
+    include RailsRinku
+    alias_method :auto_link, :rinku_auto_link
+  end
+end

data/app/helpers/kuroko2/dashboard_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module DashboardHelper
+  end
+end

data/app/helpers/kuroko2/executions_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module ExecutionsHelper
+  end
+end

data/app/helpers/kuroko2/job_definitions_helper.rb

@@ -0,0 +1,38 @@
+module Kuroko2
+  module JobDefinitionsHelper
+    def first_line(text)
+      truncate(text.split("\n").first, length: 140)
+    end
+
+    def markdown_format(text)
+      pipeline = HTML::Pipeline.new([HTML::Pipeline::MarkdownFilter])
+      raw(pipeline.call(text)[:output].to_s)
+    end
+
+    def stared_with(definition)
+      current_user.stars.find {|star| star.job_definition_id == definition.id }
+    end
+
+    def star_link_for(definition)
+      if stared_with(definition)
+        link_to(
+          raw('<i class="fa fa-star"></i>'),
+          job_definition_star_path(id: stared_with(definition), job_definition_id: definition),
+          remote: true,
+          method: :delete,
+          class: 'star',
+          data: { definition_id: definition.id, star_id: stared_with(definition).id, definitions_path: job_definitions_path }
+        )
+      else
+        link_to(
+          raw('<i class="fa fa-star-o"></i>'),
+          job_definition_stars_path(definition.id),
+          remote: true,
+          method: :post,
+          class: 'star',
+          data: { definition_id: definition.id, definitions_path: job_definitions_path }
+        )
+      end
+    end
+  end
+end

data/app/helpers/kuroko2/job_instances_helper.rb

@@ -0,0 +1,71 @@
+module Kuroko2
+  module JobInstancesHelper
+    def labeled_log_level(level)
+      modifier = case level
+                 when 'INFO'
+                   'info'
+                 when 'ERROR'
+                   'danger'
+                 when 'WARN'
+                   'warning'
+                 else
+                   'default'
+                 end
+      content_tag(:span, level, class: "label label-#{modifier}")
+    end
+
+    def labeled_token_status(status)
+      modifier = case status
+                 when 'working'
+                   'primary'
+                 when 'finished'
+                   'success'
+                 when 'waiting'
+                   'warning'
+                 when 'failure'
+                   'danger'
+                 when 'critical'
+                   'warning'
+                 else
+                   'default'
+                 end
+      content_tag(:span, status.upcase, class: "label label-#{modifier}")
+    end
+
+    def labeled_status(instance)
+      return '--' if instance.nil?
+      modifier = case instance.status
+                 when 'success'
+                   'success'
+                 when 'canceled'
+                   'warning'
+                 when 'error'
+                   'danger'
+                 when 'working'
+                   'primary'
+                 else
+                   'default'
+                 end
+      content_tag(:span, instance.status.upcase, class: "label label-#{modifier}")
+    end
+
+    def first_line(lines)
+      lines.split("\n").first
+    end
+
+    def distance_of_time(from, to)
+      secs  = (to - from).to_i
+      mins  = secs / 60
+      hours = mins / 60
+      days  = hours / 24
+
+      text = ''
+      if days > 0
+        text << "#{days}days "
+      end
+
+      text << "#{sprintf('%02d', hours % 24)}:#{sprintf('%02d', mins % 60)}:#{sprintf('%02d', secs % 60)}"
+      text
+    end
+  end
+end

data/app/helpers/kuroko2/job_schedules_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module JobSchedulesHelper
+  end
+end

data/app/helpers/kuroko2/logs_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module LogsHelper
+  end
+end

data/app/helpers/kuroko2/sessions_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module SessionsHelper
+  end
+end

data/app/helpers/kuroko2/stars_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module StarsHelper
+  end
+end

data/app/helpers/kuroko2/tokens_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module TokensHelper
+  end
+end

data/app/helpers/kuroko2/users_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module UsersHelper
+  end
+end

data/app/helpers/kuroko2/workers_helper.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  module WorkersHelper
+  end
+end

data/app/jobs/kuroko2/application_job.rb

@@ -0,0 +1,4 @@
+module Kuroko2
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/kuroko2/application_mailer.rb

@@ -0,0 +1,6 @@
+module Kuroko2
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/mailers/kuroko2/notifications.rb

@@ -0,0 +1,63 @@
+module Kuroko2
+  class Notifications < ApplicationMailer
+    default(
+      from: Kuroko2.config.notifiers.mail.mail_from,
+      to:   Kuroko2.config.notifiers.mail.mail_to,
+    )
+    helper_method :job_instance_url
+
+    def job_failure(job_instance)
+      @definition = job_instance.job_definition
+      @instance   = job_instance
+
+      attachments.inline['kuroko-logo-horizontal.jpg'] = Kuroko2::Engine.root.join('app/assets/images/kuroko2/kuroko-logo-horizontal.png').read
+
+      mail(subject: "[CRITICAL] Failed to execute '#{@definition.name}' on kuroko",
+        to:      @definition.admins.map(&:email),
+        cc:      Kuroko2.config.notifiers.mail.mail_to)
+    end
+
+    def remind_failure(job_instance)
+      @definition = job_instance.job_definition
+      @instance   = job_instance
+
+      attachments.inline['kuroko-logo-horizontal.jpg'] = Kuroko2::Engine.root.join('app/assets/images/kuroko2/kuroko-logo-horizontal.png').read
+
+      mail(subject: "[WARN] '#{@definition.name}' is still in ERROR state",
+        to:      @definition.admins.map(&:email),
+        cc:      Kuroko2.config.notifiers.mail.mail_to)
+    end
+
+    def process_absence(execution, hostname)
+      @execution  = execution
+      @definition = execution.job_definition
+      @instance   = execution.job_instance
+      @hostname   = hostname
+
+      mail(subject: '[CRITICAL] Process is not running on kuroko')
+    end
+
+    def executor_not_assigned(execution, hostname)
+      @execution  = execution
+      @definition = execution.job_definition
+      @instance   = execution.job_instance
+
+      mail(subject: '[CRITICAL] Process is not assigned to any job-executor')
+    end
+
+    def notify_long_elapsed_time(job_instance)
+      @definition = job_instance.job_definition
+      @instance   = job_instance
+
+      mail(subject: "[WARN] The running time is longer than expected '#{@definition.name}' on kuroko",
+        to:      @definition.admins.map(&:email),
+        cc:      Kuroko2.config.notifiers.mail.mail_to)
+    end
+
+    private
+
+    def job_instance_url
+      job_definition_job_instance_url(@definition, @instance)
+    end
+  end
+end

data/app/models/concerns/kuroko2/table_name_customizable.rb

@@ -0,0 +1,16 @@
+module Kuroko2
+  module TableNameCustomizable
+    extend ActiveSupport::Concern
+
+    included do
+      self.table_name = self.kuroko2_table_name
+    end
+
+    module ClassMethods
+      def kuroko2_table_name
+        Kuroko2.config.table_name_prefix +
+          self.name.gsub(/^Kuroko2::/, '').underscore.pluralize
+      end
+    end
+  end
+end

data/app/models/kuroko2/admin_assignment.rb

@@ -0,0 +1,6 @@
+class Kuroko2::AdminAssignment < Kuroko2::ApplicationRecord
+  include Kuroko2::TableNameCustomizable
+
+  belongs_to :job_definition
+  belongs_to :user
+end

data/app/models/kuroko2/api/application_resource.rb

@@ -0,0 +1,10 @@
+class Kuroko2::Api::ApplicationResource
+  include Garage::Representer
+  include Garage::Authorizable
+
+  attr_reader :model
+
+  def initialize(model = nil)
+    @model = model
+  end
+end

data/app/models/kuroko2/api/job_instance_resource.rb

@@ -0,0 +1,7 @@
+class Kuroko2::Api::JobInstanceResource < Kuroko2::Api::ApplicationResource
+  property :id
+
+  property :status
+
+  delegate :id, :status, to: :model
+end

data/app/models/kuroko2/application_record.rb

@@ -0,0 +1,5 @@
+module Kuroko2
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/kuroko2/execution.rb

@@ -0,0 +1,55 @@
+class Kuroko2::Execution < Kuroko2::ApplicationRecord
+  include Kuroko2::TableNameCustomizable
+
+  DEFAULT_QUEUE = '@default'
+
+  scope :of, ->(token) { where(token: token) }
+  scope :with, ->(queue) { where(queue: queue) }
+  scope :unstarted, -> { where(started_at: nil) }
+  scope :started, -> { where.not(started_at: nil) }
+
+  serialize :context, JSON
+
+  belongs_to :job_definition
+  belongs_to :job_instance
+  belongs_to :token, optional: true
+
+  has_one :worker
+
+  before_create :set_default_values
+
+  delegate :log_memory_consumption, to: :job_instance
+
+  def completed?
+    started_at? && finished_at?
+  end
+
+  def success?
+    exit_status == 0
+  end
+
+  def self.poll(queue = DEFAULT_QUEUE)
+    self.transaction do
+      unstarted.with(queue).lock.take.tap do |execution|
+        execution.touch(:started_at) if execution
+      end
+    end
+  end
+
+  def finish(output:, exit_status:)
+    update!(output: output, exit_status: exit_status, finished_at: Time.now)
+    job_definition.memory_expectancy.calculate!
+  end
+
+  def finish_by_signal(output:, term_signal:)
+    update!(output: output, term_signal: term_signal, finished_at: Time.now)
+    job_definition.memory_expectancy.calculate!
+  end
+
+  private
+
+  def set_default_values
+    self.uuid    ||= SecureRandom.uuid
+    self.context ||= {}
+  end
+end