nodectl 0.2.4

data/lib/nodectl/stream/buffer.rb

@@ -0,0 +1,44 @@
+class Nodectl::Stream::Buffer
+  def initialize
+    @buffer = ""
+    @valid  = ""
+  end
+
+  def <<(string)
+    string  = @buffer + string
+    @buffer = ""
+    @buffer.force_encoding(Encoding::ASCII_8BIT)
+
+    string.force_encoding(Encoding::UTF_8)
+
+    16.times do
+      if string.valid_encoding?
+        break
+      end
+
+      string, byte = byte_rotate(string)
+      @buffer << byte
+    end
+    
+    if string.valid_encoding?
+      @valid << string
+    else
+      Nodectl.logger.error("buffer: cannot convert string to valid UTF-8, ignore it")
+    end
+  end
+
+  def read
+    ret = @valid
+    @valid = ""
+    ret
+  end
+
+  private
+
+  def byte_rotate(string)
+    byte   = string.byteslice(-1)
+    string = string.byteslice(0...-1)
+    byte.force_encoding(Encoding::ASCII_8BIT)
+    [string, byte]
+  end
+end

data/lib/nodectl/stream/events_session.rb

@@ -0,0 +1,39 @@
+class Nodectl::Stream::EventsSession
+  @manager = Nodectl::Manager.new(self)
+
+  attr_reader :websocket
+  attr_reader :file
+
+  def initialize(websocket, handshake)
+    @websocket = websocket
+    @handshake = handshake
+
+    self.class[self.class.next_id] = self
+  end
+
+  def publish(resource, id, event_name, payload = {})
+    message = MultiJson.dump({resource:   resource,
+                              id:         id,
+                              event_name: event_name,
+                              payload:    payload})
+
+    @websocket.send(message)
+
+    Nodectl.logger.debug("events_session: sent 'message'")
+  end
+
+  def close
+    self.class.delete(self)
+    @websocket.close unless @websocket.closed?
+  end
+
+  def onclose(&block)
+    @websocket.onclose(&block)
+  end
+
+  class << self
+    def publish(resource, id, event_name, payload = {})
+      all.each { |session| session.publish(resource, id, event_name, payload) }
+    end
+  end
+end

data/lib/nodectl/stream/file.rb

@@ -0,0 +1,69 @@
+class Nodectl::Stream::File
+  def initialize(file, options = {})
+    @onread  = []
+    @onclose = []
+
+    if file.respond_to? :read_nonblock
+      @file = file
+    else
+      begin
+        @file = File.new(file)
+      rescue Errno::ENOENT
+        raise Nodectl::NotFound, "file not found"
+      end
+    end
+
+    @options = options
+
+    if @options[:end_offset]
+      offset = @file.size - @options[:end_offset]
+      if offset > 0
+        @file.seek(offset)
+        @options[:end_offset].times do
+          break if @file.readchar == "\n"
+        end
+      end
+    end
+  end
+
+  def onread(&blk)
+    @onread << blk
+  end
+
+  def onclose(&blk)
+    @onclose << blk
+  end
+
+  def read_chunk
+    chunk = @file.read_nonblock(4096)
+
+    if chunk.size > 0
+      onread_call(chunk)
+    end
+  rescue Errno::EAGAIN, EOFError
+    # Nothing to do
+  end
+
+  def close
+    onclose_call
+    @file.close
+  end
+
+  def closed?
+    @file.closed?
+  end
+
+  private
+
+  def file
+    @file
+  end
+
+  def onread_call(chunk)
+    @onread.each { |blk| blk.call(chunk) }
+  end
+
+  def onclose_call
+    @onclose.each { |blk| blk.call }
+  end
+end

data/lib/nodectl/stream/file_session.rb

@@ -0,0 +1,35 @@
+class Nodectl::Stream::FileSession
+  @manager = Nodectl::Manager.new(self)
+
+  attr_reader :websocket
+  attr_reader :file
+
+  def initialize(websocket, handshake, file)
+    @websocket = websocket
+    @handshake = handshake
+    @file      = file
+    @buffer    = Nodectl::Stream::Buffer.new
+
+    @file.onread do |chunk|
+      @buffer << chunk
+      publish(@buffer.read)
+    end
+
+    self.class[self.class.next_id] = self
+  end
+
+  def publish(message)
+    @websocket.send(message)
+    Nodectl.logger.debug("file_session: sent #{message.bytesize} bytes")
+  end
+
+  def close
+    self.class.delete(self)
+    @file.close
+    @websocket.close unless @websocket.closed?
+  end
+
+  def onclose(&block)
+    @websocket.onclose(&block)
+  end
+end

data/lib/nodectl/stream/file_with_memory.rb

@@ -0,0 +1,17 @@
+class Nodectl::Stream::FileWithMemory < Nodectl::Stream::File
+  def initialize(file, options = {})
+    super(file, options)
+
+    @memory = ""
+  end
+
+  def onread(&blk)
+    blk.call(@memory)
+    @onread << blk
+  end
+
+  def onread_call(chunk)
+    @memory << chunk
+    super(chunk)
+  end
+end

data/lib/nodectl/stream/websocket.rb

@@ -0,0 +1,90 @@
+class Nodectl::Stream::Websocket
+  URI_LOG    = /\A\/logs\/(?<service_name>[\w_-]+)\/(?<log_name>\w+)\Z/
+  URI_ACTION = /\A\/actions\/(?<action_id>\w+)\Z/
+  URI_EVENTS = /\A\/events\Z/
+
+  def initialize(host, port)
+    EM::WebSocket.run(host: host, port: port) do |ws|
+      Nodectl.logger.info("websocket: socket created")
+      ws.onopen { |handshake| connection_open(ws, handshake) }
+    end
+
+    callbacks_init
+  end
+
+  def connection_open(ws, handshake)
+    Nodectl.logger.info("websocket: connection opened with url '#{handshake.path}'")
+
+    case handshake.path
+    when URI_LOG
+      create_log_session(ws, handshake)
+    when URI_ACTION
+      create_action_session(ws, handshake)
+    when URI_EVENTS
+      create_events_session(ws, handshake)
+    else
+      ws.close
+    end
+  end
+
+  def callbacks_init
+    EM.add_periodic_timer(0.5, method(:tick))
+
+    Nodectl::Instance.onadd do |instance|
+      Nodectl::Stream::EventsSession.publish('instance', instance.pid, 'started')
+    end
+
+    Nodectl::Instance.ondelete do |instance, options|
+      Nodectl::Stream::EventsSession.publish('instance', instance.pid, 'stopped', options)
+    end
+
+    Nodectl::Action.onadd do |action|
+      Nodectl::Stream::EventsSession.publish('action', action.id, 'started')
+    end
+
+    Nodectl::Action.onkill do |action, options|
+      Nodectl::Stream::EventsSession.publish('action', action.id, 'stopped', options)
+    end
+  end
+
+  private
+
+  def create_log_session(ws, handshake)
+    match   = URI_LOG.match(handshake.path)
+    service = Nodectl::Service.find!(match[:service_name])
+    logfile = service.recipe_binding.get_logfile(match[:log_name])
+    file    = Nodectl::PromisedFile.new(logfile, Nodectl::Stream::File, end_offset: 5000, infinity: true)
+    session = Nodectl::Stream::FileSession.new(ws, handshake, file)
+
+    Nodectl.logger.info("websocket: log session open succeed: #{logfile}")
+  rescue StandardError => e
+    Nodectl.logger.info("websocket: log session open failed: #{e.message}")
+    ws.close
+  end
+
+  def create_action_session(ws, handshake)
+    match   = URI_ACTION.match(handshake.path)
+    action  = Nodectl::Action.find!(match[:action_id].to_i)
+    session = Nodectl::Stream::FileSession.new(ws, handshake, action.output)
+
+    Nodectl.logger.info("websocket: action session open succeed: action ##{action.id}")
+  rescue StandardError => e
+    Nodectl.logger.info("websocket: action session open failed: #{e.message}")
+    ws.close
+  end
+
+  def create_events_session(ws, handshake)
+    session = Nodectl::Stream::EventsSession.new(ws, handshake)
+
+    Nodectl.logger.info("websocket: events session open succeed")
+  rescue StandardError => e
+    Nodectl.logger.info("websocket: events session open failed: #{e.message}")
+    ws.close
+  end
+
+  def tick
+    Nodectl::Stream::FileSession.all.each do |session|
+      session.file.read_chunk
+    end
+  end
+end

data/lib/nodectl/version.rb

@@ -0,0 +1,3 @@
+module Nodectl
+  VERSION = "0.2.4"
+end

data/lib/nodectl/watchdog.rb

@@ -0,0 +1,17 @@
+class Nodectl::Watchdog
+  TICK_INTERVAL = 2
+
+  def initialize
+    @timer = EM.add_periodic_timer(TICK_INTERVAL, method(:tick))
+  end
+
+  def tick
+    Nodectl::Instance.all.each do |instance|
+      instance.alive?
+    end
+
+    Nodectl::Process.all.each do |process|
+      process.alive?
+    end
+  end
+end

data/lib/nodectl/webapp/actions.rb

@@ -0,0 +1,21 @@
+class Nodectl::Webapp::Actions < Nodectl::Webapp::Base
+  get '/' do
+    json actions: Nodectl::Action.all.map(&:as_json)
+  end
+
+  get '/:id' do
+    json action: Nodectl::Action.find!(params[:id]).as_json
+  end
+
+  post '/' do
+    service = Nodectl::Service.find(params[:action][:service_id])
+
+    if service
+      action = service.recipe_binding.run_action(params[:action][:name].to_sym, params[:action][:params] || {})
+      json action: action.as_json
+    else
+      json errors: {service_id: "service not found"}
+      status 422
+    end
+  end
+end

data/lib/nodectl/webapp/base.rb

@@ -0,0 +1,29 @@
+class Nodectl::Webapp::Base < Sinatra::Base
+  helpers Sinatra::JSON
+
+  before do
+    params.merge! json_body_params
+  end
+  
+  helpers do
+    def json_body_params
+      @json_body_params ||= begin
+        MultiJson.load(request.body.read.to_s, symbolize_keys: true)
+      rescue MultiJson::LoadError
+        {}
+      end
+    end
+  end
+
+  configure do
+    set    :threaded, false
+    set    :show_exceptions, :after_handler
+    enable :logging
+  end
+
+  error StandardError do
+    exception = env['sinatra.error']
+    backtrace = [exception.inspect] + exception.backtrace
+    Nodectl.logger.error('webapp error - ' + backtrace.join("\n        from"))
+  end
+end

data/lib/nodectl/webapp/instances.rb

@@ -0,0 +1,46 @@
+class Nodectl::Webapp::Instances < Nodectl::Webapp::Base
+  get '/' do
+    if params[:ids]
+      select_id = params[:ids].map(&:to_i)
+      instances = Nodectl::Instance.all.select { |i| select_id.include?(i.pid) }
+    else
+      instances = Nodectl::Instance.all
+    end
+
+    json instances: instances.map(&:as_json)
+  end
+
+  get '/:pid' do
+    instance = Nodectl::Instance.find!(params[:pid].to_i)
+    json instance: instance.as_json
+  end
+
+  post '/' do
+    service = Nodectl::Service.find(params[:instance][:service_id])
+
+    if service
+      instance = service.recipe_binding.run_slot :start, params[:instance][:options]
+      status 201
+      json instance: instance.as_json
+    else
+      json errors: {service_name: "service not found"}
+      status 422
+    end
+  end
+
+  put '/:pid' do
+    instance = Nodectl::Instance.find!(params[:pid].to_i)
+
+    if params[:instance][:status] == "stopping"
+      if params[:instance][:force_stop]
+        instance.stop(force: true)
+      else
+        instance.stop
+      end
+    elsif params[:instance][:status] == "restarting"
+      instance.restart(force: true)
+    end
+
+    json instance: instance.as_json
+  end
+end

data/lib/nodectl/webapp/services.rb

@@ -0,0 +1,39 @@
+class Nodectl::Webapp::Services < Nodectl::Webapp::Base
+  get '/' do
+    json services: Nodectl::Service.all.map(&:as_json)
+  end
+
+  get '/:name' do
+    service = Nodectl::Service.find!(params[:name])
+    json service: service.as_json
+  end
+
+  put '/:name' do
+    service = Nodectl::Service.find!(params[:name])
+
+    if params[:service][:slot]
+      service.recipe_binding.run_slot params[:service][:slot].to_sym, params[:service][:slot_params]
+    end
+
+    binding = service.recipe_binding
+
+    if  !params[:service][:version_id].nil? &&
+        binding.supported_slots.include?(:version_set) &&
+        binding.supported_slots.include?(:version)
+      current = binding.run_slot(:version)["id"]
+      target  = params[:service][:version_id]
+
+      if current != target
+        binding.run_slot(:version_set, {id: target})
+      end
+    end
+
+    json service: service.as_json
+  end
+
+  private
+
+    def service_params
+      params[:service] || {}
+    end
+end