nodectl 0.2.4

data/lib/nodectl/generators/init.rb

@@ -0,0 +1,22 @@
+class Nodectl::Generators::Init < Thor::Group
+  include Thor::Actions
+
+  argument :host_path
+
+  def self.source_root
+    File.join(File.dirname(__FILE__), "templates", "init")
+  end
+
+  def self.destination_root
+    host_path
+  end
+
+  def copy_template
+    directory "./", host_path
+  end
+
+  def database
+    db = Nodectl::Database.new(File.join(host_path, "nodectl.db"))
+    db.reset
+  end
+end

data/lib/nodectl/generators/templates/init/.gitignore

@@ -0,0 +1,5 @@
+src/
+log/
+tmp/
+nodectl.db.dir
+nodectl.db.pag

data/lib/nodectl/generators/templates/init/config/manifest.yml

@@ -0,0 +1 @@
+# Write service definitions here

data/lib/nodectl/generators/templates/init/config/server.yml

@@ -0,0 +1,7 @@
+http_host:
+http_port: 8080
+websocket_port: 8090
+websocket_host: 0.0.0.0
+
+ui_default_env: development
+ui_disabled: false

data/lib/nodectl/instance.rb

@@ -0,0 +1,100 @@
+class Nodectl::Instance < Nodectl::Process
+  @manager = Nodectl::Manager.new(self)
+
+  attr_reader :service
+  attr_reader :options
+  attr_reader :command
+
+  def initialize(service, command, options = {}, &blk)
+    super(options) do
+      blk.call if blk
+      Process.exec command
+    end
+
+    @service = service
+    @options = options
+    @command = command
+
+    if @options[:started]
+      @status = :running
+      @pid    = @options[:pid]
+      @detach = Process.detach(@pid)
+
+      Nodectl::Instance[@pid] = self
+      Nodectl.logger.info("#{@service.name} [#{@pid}] found")
+    end
+
+    onkill do
+      self.class.delete(pid, reason: @status)
+    end
+  end
+
+  def run
+    super
+
+    Nodectl::Instance[@pid] = self
+    Nodectl.logger.info("#{@service.name} [#{@pid}] started")
+  end
+
+  def as_json
+    {
+      "id"         => pid,
+      "service_id" => service.name,
+      "status"     => status,
+      "options"    => options
+    }
+  end
+
+  def dump
+    {
+      "service_name" => service.name,
+      "pid"          => pid,
+      "options"      => options,
+      "command"      => command
+    }
+  end
+
+  def pre_fork_block
+    Nodectl.shut_up!
+  end
+
+  class << self
+    def load(dump)
+      service = Nodectl::Service.find(dump["service_name"])
+
+      if service
+        puts "Service found: #{dump['service_name']}"
+        new(service, dump["command"], dump["options"].merge(started: true, pid: dump["pid"]))
+      else
+        puts "Service not found"
+        raise "service not found"
+      end
+    end
+
+    def push(pid, instance)
+      super(pid, instance)
+      save_register
+    end
+
+    alias :[]= :push
+
+    def delete(pid, options = {})
+      super(pid, options)
+      save_register
+    end
+
+    def save_register
+      Nodectl.database["instances"] = all.map(&:dump)
+    end
+
+    def load_register
+      database = Nodectl.database["instances"] || []
+
+      database.each do |dump|
+        load(dump) rescue RuntimeError
+      end
+
+      save_register
+    end
+  end
+end

data/lib/nodectl/log.rb

@@ -0,0 +1,13 @@
+class Nodectl::Log
+  attr_reader :name
+  attr_reader :path
+
+  def initialize(name, path)
+    @name = name
+    @path = path
+  end
+
+  def instance_path(service)
+    service.source_path.join(path)
+  end
+end

data/lib/nodectl/manager.rb

@@ -0,0 +1,71 @@
+class Nodectl::Manager
+  MANAGER_METHODS = [:all, :find, :find!, :push, :delete, :[], :[]=, :next_id, :onadd, :ondelete]
+
+  def initialize(target_class)
+    @objects      = {}
+    @target_class = target_class
+
+    @onadd    = []
+    @ondelete = []
+
+
+    MANAGER_METHODS.each do |method|
+      @target_class.define_singleton_method method do |*args, &blk|
+        @manager.send(method, *args, &blk)
+      end
+    end
+  end
+
+  def find(key)
+    @objects[key]
+  end
+
+  alias :[] :find
+
+  def find!(key)
+    object = find(key)
+
+    unless object
+      raise Nodectl::NotFound, "#{@target_class.name} with key '#{key}' not found"
+    end
+
+    object
+  end
+
+  def all
+    @objects.values
+  end
+
+  def push(key, object)
+    @objects[key] = object
+    onadd_call(object)
+  end
+
+  alias :[]= :push
+
+  def delete(key, options = {})
+    object = @objects.delete(key)
+    ondelete_call(object, options)
+  end
+
+  def next_id
+    @next_id ||= 0
+    @next_id += 1
+  end
+
+  def onadd(&blk)
+    @onadd << blk
+  end
+
+  def ondelete(&blk)
+    @ondelete << blk
+  end
+
+  def onadd_call(object)
+    @onadd.each { |b| b.call(object) }
+  end
+
+  def ondelete_call(object, options)
+    @ondelete.each { |b| b.call(object, options) }
+  end
+end

data/lib/nodectl/multi_io.rb

@@ -0,0 +1,16 @@
+# Redirect `write` calls to multiple targets, used with standard ruby
+# logger instance for writing messages to log file and stdout at the
+# same time
+class Nodectl::MultiIO
+  def initialize(*targets)
+    @targets = targets
+  end
+
+  def write(*args)
+    @targets.each {|t| t.write(*args)}
+  end
+
+  def close
+    @targets.each(&:close)
+  end
+end

data/lib/nodectl/options.rb

@@ -0,0 +1,47 @@
+# Boot options container, keep info about node directory structure etc
+class Nodectl::Options
+  def initialize(overrides = {})
+    @options = default_options.merge(overrides)
+    @options = calculate_options(@options)
+  end
+
+  def [](option_name)
+    @options[option_name.to_s]
+  end
+
+  def inspect
+    @options.inspect
+  end
+
+  def to_s
+    @options.to_s
+  end
+
+  def to_hash
+    @options
+  end
+
+  private
+
+  def default_options
+    {
+      "root"      => Dir.pwd,
+      "log_level" => "INFO"
+    }
+  end
+
+  def calculate_options(source_options)
+    options = source_options.dup
+
+    options["root"] = Pathname.new(options["root"])
+
+    options["config_dir"] ||= options["root"].join("config")
+    options["source_dir"] ||= options["root"].join("src")
+    options["logger_dir"] ||= options["root"].join("log")
+    options["recipe_dir"] ||= options["root"].join("recipes")
+    options["database"]   ||= options["root"].join("nodectl.db")
+    options["manifest"]   ||= options["config_dir"].join("manifest.yml")
+
+    options
+  end
+end

data/lib/nodectl/process.rb

@@ -0,0 +1,145 @@
+class Nodectl::Process
+  ENV_BLACKLIST = %w(BUNDLE_BIN_PATH BUNDLE_GEMFILE USE_BUNDLER _ORIGINAL_GEM_PATH _ RUBYOPT)
+  TIMEOUT = 10
+
+  @manager = Nodectl::Manager.new(self)
+
+  attr_reader :pid
+  attr_reader :status
+  attr_reader :exit_status
+
+  def initialize(options = {}, &blk)
+    raise "cannot create process without block" unless block_given?
+    
+    @status   = :pending
+    @stopping = false
+    @options  = options
+    @blk      = blk
+    @oncrash  = []
+    @onstop   = []
+    @onkill   = []
+  end
+
+  def run
+    if @status != :pending
+      raise "Cannot run one process twice"
+    end
+
+    @pid = fork do
+      ENV_BLACKLIST.each do |name|
+        ENV.delete(name)
+      end
+
+      args = @options[:args] || []
+      @blk.call(*args)
+
+      EM.stop
+    end
+
+    @detach = Process.detach(@pid)
+
+    @status = :running
+    Nodectl::Process[pid] = self
+  end
+
+  def alive?
+    Process.getpgid(pid)
+    true
+  rescue Errno::ESRCH
+    dead!
+    false
+  end
+
+  def stop(options = {})
+    @status = :stopping
+    signal = options[:force] ? "KILL" : "TERM"
+
+    Nodectl.logger.info("process: send #{signal} to #{pid}")
+
+    Process.kill(signal, pid)
+  rescue Errno::ESRCH, Errno::EPERM
+    dead!
+  end
+
+  def restart(options = {})
+    stop(options)
+    TIMEOUT.times do
+      unless alive?
+        @status = :pending
+        run
+        break
+      end
+
+      sleep 1
+    end
+  end
+
+  def dead!(exit_status = nil)
+    @detach.join
+
+    if @detach.value
+      @exit_status = @detach.value.exitstatus
+    end
+
+    if [:running, :stopping].include?(@status)
+      case @status 
+      when :stopping
+        @status = :stopped
+        Nodectl.logger.info("process: [#{pid}] stopped")
+        onstop_call
+      when :running
+        @status = :crashed
+        Nodectl.logger.info("process: [#{pid}] crashed")
+        oncrash_call
+      end
+
+      onkill_call
+      Nodectl::Process.delete(pid)
+    end
+  end
+
+  # When process crashed
+  def oncrash(&blk)
+    @oncrash << blk
+  end
+
+  # When process gracefully stoped
+  def onstop(&blk)
+    @onstop << blk
+  end
+
+  # When process is dead, regardless of reason
+  def onkill(&blk)
+    @onkill << blk
+  end
+
+  private
+
+  def oncrash_call
+    @oncrash.each { |b| b.call(self) }
+  end
+
+  def onkill_call
+    @onkill.each { |b| b.call(self) }
+  end
+
+  def onstop_call
+    @onstop.each { |b| b.call(self) }
+  end
+
+  def pre_fork_block
+    # Override it to customize process behaviour
+  end
+
+  def post_fork_block
+    # Override it to customize process behaviour
+  end
+
+  def fork(&blk)
+    Process.fork do
+      pre_fork_block
+      blk.call
+      post_fork_block
+    end
+  end
+end

data/lib/nodectl/promised_file.rb

@@ -0,0 +1,37 @@
+# Promised file is file which looks like an empty file while it does not exists 
+class Nodectl::PromisedFile
+  def initialize(path, file_class, options = {})
+    @path       = path
+    @file_class = file_class
+    @options    = options
+    @fake_file  = Nodectl::Stream::File.new(StringIO.new)
+  end
+
+  def close
+    @closed = true
+    current_file.close
+  end
+
+  # Hook Nodectl::Stream::File#onread for call it when real 
+  # file was created
+  def onread(&blk)
+    @onread = blk
+  end
+
+  def method_missing(name, *args, &blk)
+    current_file.public_send(name, *args, &blk)
+  end
+
+  private
+
+  def current_file
+    if !@real_file && !@closed && File.exist?(@path)
+      @real_file = @file_class.new(@path, @options)
+      @real_file.onread(&@onread) if @onread
+    end
+
+    @real_file || @fake_file
+  end
+
+
+end