nodectl 0.2.4

data/bin/nodectl

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "nodectl"
+Nodectl::CLI::start(ARGV)

data/lib/nodectl.rb

@@ -0,0 +1,137 @@
+require "nodectl/version"
+
+require "thor"
+require "thin"
+require "eventmachine"
+require "em-websocket"
+require 'sinatra/base'
+require 'sinatra/json'
+require "logger"
+require 'stringio'
+require "yaml"
+require "time"
+require "dbm"
+require 'multi_json'
+
+module Nodectl
+  autoload :Action,       "nodectl/action.rb"
+  autoload :Binding,      "nodectl/binding.rb"
+  autoload :CLI,          "nodectl/cli.rb"
+  autoload :Context,      "nodectl/context.rb"
+  autoload :Database,     "nodectl/database.rb"
+  autoload :Log,          "nodectl/log.rb"
+  autoload :Manager,      "nodectl/manager.rb"
+  autoload :MultiIO,      "nodectl/multi_io.rb"
+  autoload :Instance,     "nodectl/instance.rb"
+  autoload :Options,      "nodectl/options.rb"
+  autoload :PromisedFile, "nodectl/promised_file.rb"
+  autoload :Repository,   "nodectl/repository.rb"
+  autoload :Recipe,       "nodectl/recipe.rb"
+  autoload :Process,      "nodectl/process.rb"
+  autoload :Server,       "nodectl/server.rb"
+  autoload :Service,      "nodectl/service.rb"
+  autoload :Watchdog,     "nodectl/watchdog.rb"
+
+  module Generators
+    autoload :Init, "nodectl/generators/init.rb"
+  end
+
+  module Webapp
+    autoload :Actions,   "nodectl/webapp/actions.rb"
+    autoload :Base,      "nodectl/webapp/base.rb"
+    autoload :Instances, "nodectl/webapp/instances.rb"
+    autoload :Services,  "nodectl/webapp/services.rb"
+    autoload :Settings,  "nodectl/webapp/settings.rb"
+    autoload :UI,        "nodectl/webapp/ui.rb"
+    autoload :Versions,  "nodectl/webapp/versions.rb"
+  end
+
+  module Stream
+    autoload :Buffer,         "nodectl/stream/buffer.rb"
+    autoload :EventsSession,  "nodectl/stream/events_session.rb"
+    autoload :File,           "nodectl/stream/file.rb"
+    autoload :FileSession,    "nodectl/stream/file_session.rb"
+    autoload :FileWithMemory, "nodectl/stream/file_with_memory.rb"
+    autoload :Websocket,      "nodectl/stream/websocket.rb"
+  end
+
+  NotFound = Class.new(Sinatra::NotFound)
+
+  class << self
+    attr_reader :options
+
+    # Node initialization: here default global options could be overriden
+    #
+    # @param options [Hash] overrides for default options
+    def boot(options = {})
+      @options = Options.new(options)
+
+      # Routing targets
+      Dir["#{@options[:recipe_dir]}/**/*.rb"].each do |path|
+        require path
+      end
+    end
+
+    # Key-value store for node
+    #
+    # @return [Nodectl::Database]
+    def database
+      @database ||= Nodectl::Database.new(options[:database])
+    end
+
+    def server
+      @server ||= Nodectl::Server.new(options)
+    end
+
+    # Get node manifest: list of hashes with service definitions. It looks like:
+    #
+    # [
+    #   {
+    #     "name" => "hub",
+    #     "repo" => "git://example.com:service.git",
+    #     "path" => "hub"
+    #   },
+    #   ...
+    # ]
+    #
+    # @return [Array] node manifest
+    def manifest
+      @manifest ||= YAML.load_file(@options[:manifest]) || []
+    rescue SystemCallError => e
+      $stderr.puts "Manifest loading error: #{e.message}"
+      abort
+    end
+
+    # Get logger instance
+    #
+    # @return [Logger] logger instance
+    def logger
+      unless defined? @logger
+        file = File.open(options[:logger_dir].join("nodectl.log"), "a")
+        file.sync = true
+        io = MultiIO.new(STDOUT, file)
+
+        @logger ||= Logger.new(io)
+        @logger.level = Logger.const_get(options[:log_level])
+      end
+
+      @logger
+    end
+
+    # Redirect all standard streams to null device
+    def shut_up!
+      $stdout.reopen(File.open(File::NULL, "w"))
+      $stderr.reopen(File.open(File::NULL, "w"))
+      $stdin.reopen(File.open(File::NULL, "r"))
+    end
+
+    # Base path of assets folder
+    #
+    # @return [String]
+    def assets_path
+      File.absolute_path(File.join(__FILE__, "../../assets"))
+    end
+  end
+end
+
+include Nodectl::Recipe::ObjectMethods

data/lib/nodectl/action.rb

@@ -0,0 +1,80 @@
+class Nodectl::Action < Nodectl::Process
+  @manager = Nodectl::Manager.new(self)
+
+  attr_reader :id
+  attr_reader :service
+  attr_reader :name
+  attr_reader :output
+
+  def initialize(service, name, options = {}, &blk)
+    super(options, &blk)
+
+    @id      = Nodectl::Action.next_id
+    @service = service
+    @name    = name
+
+    onkill do
+      result = if @exit_status == 0
+                  "succeed"
+               else
+                  "failed"
+               end
+
+      self.class.onkill_call(self, reason: result)
+    end
+  end
+
+  def run
+    rout, @wout = IO.pipe
+
+    @output = Nodectl::Stream::FileWithMemory.new(rout)
+
+    super
+
+    @started_at = Time.now
+
+    Nodectl::Action[@id] = self
+    Nodectl.logger.info("action: [#{pid}] started: #{service.name}##{name}")
+  end
+
+  def as_json
+    {
+      "id"          => @id,
+      "pid"         => @pid,
+      "name"        => @name,
+      "service_id"  => @service.name,
+      "ws"          => "/actions/#{id}",
+      "exit_status" => @exit_status,
+      "started_at"  => @started_at.iso8601
+    }
+  end
+
+  private
+
+  def pre_fork_block
+    $stdout.reopen(@wout)
+    $stderr.reopen(@wout)
+
+    $stdout.sync = true
+    $stderr.sync = true
+
+    @wout.close
+  end
+
+  class << self
+    def onkill(&blk)
+      @onkill ||= []
+      @onkill << blk
+    end
+
+    def onkill_call(action, options = {})
+      @onkill.each { |b| b.call(action, options) }
+    end
+
+    def run(service, name, *args, &blk)
+      action = new(service, name, *args, &blk)
+      action.run
+      action
+    end
+  end
+end

data/lib/nodectl/binding.rb

@@ -0,0 +1,13 @@
+class Nodectl::Binding
+  attr_reader :service
+  attr_reader :recipe
+
+  def initialize(service, recipe)
+    @service = service
+    @recipe  = recipe
+  end
+
+  def method_missing(name, *args, &blk)
+    @recipe.public_send(name, @service, *args, &blk)
+  end
+end

data/lib/nodectl/cli.rb

@@ -0,0 +1,123 @@
+class Nodectl::CLI < Thor
+  class_option :root,       desc: "Root directory path"
+  class_option :config_dir, desc: "Config directory path"
+  class_option :source_dir, desc: "Source directory path"
+  class_option :logger_dir, desc: "Logger directory path"
+  class_option :manifest,   desc: "Manifest file path"
+  class_option :database,   desc: "Nodectl database path"
+  class_option :log_level,  desc: "Log level", enum: ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"]
+
+  desc "init [HOST_PATH]", "Initialize new node"
+  def init(host_path = "./")
+    Nodectl::Generators::Init.start [host_path]
+  end
+
+  desc "recipes", "Show available recipes list"
+  def recipes
+    boot
+
+    Nodectl::Recipe.all.each do |recipe|
+      puts recipe.name
+    end
+  end
+
+  desc "recipe RECIPE_NAME", "Show recipe info"
+  def recipe(recipe_name)
+    boot
+
+    recipe = Nodectl::Recipe.find!(recipe_name)
+
+    print "Logs:     "
+    puts  recipe.logs.map(&:to_s).join(", ")
+
+    print "Actions:  "
+    puts  recipe.actions.map(&:to_s).join(", ")
+
+    print "Triggers: "
+    puts  recipe.triggers.map(&:to_s).join(", ")
+
+  rescue Nodectl::NotFound
+    $stderr.puts "recipe '#{recipe_name}' not found"
+    abort
+  end
+
+  desc "services", "Show services list"
+  def services
+    boot
+
+    Nodectl::Service.load_register
+
+    Nodectl::Service.all.each do |service|
+      puts "#{service.name} #{service.status}"
+    end
+  end
+
+  desc "install SERVICE_NAME", "Install specified service"
+  def install(service_name)
+    boot
+
+    service = find_service!(service_name)
+    recipe  = find_recipe!(service)
+
+    recipe.run_action :install
+  end
+
+  option :ui_disabled, desc: "Disable UI and only API", type: :boolean
+  option :daemonize,   desc: "Daemonize server", type: :boolean, default: false
+  option :pidfile,     desc: "File to save server PID"
+
+  option :http_host,     desc: "Host to bind webserver"
+  option :http_port,     desc: "Port to bind webserver"
+
+  option :websocket_host, desc: "Host to bind websocket server"
+  option :websocket_port, desc: "Port to bind websocket server"
+
+  # AMPQ support is not implemented yet
+  #
+  # option :amqp_host,     desc: "Host of AMQP broker"
+  # option :amqp_port,     desc: "Port of AMQP broker"
+  # option :amqp_username, desc: "AMQP username"
+  # option :amqp_password, desc: "AMQP password"
+  # option :amqp_vhost,    desc: "AMQP vhost"
+
+  desc 'server', 'Run node'
+  def server
+    boot
+    
+    Nodectl::server.run
+  end
+
+  desc 'version', 'Show nodectl version'
+  def version
+    puts "Nodectl #{Nodectl::VERSION}"
+  end
+
+  private
+
+  def boot
+    Nodectl.boot(options)
+  end
+
+  def find_service!(service_name)
+    service = Nodectl::Service.find(service_name)
+
+    unless service
+      $stderr.puts "service '#{service_name}' not found"
+      abort
+    end
+
+    service
+  end
+
+  def find_recipe!(service)
+    recipe = service.recipe_binding
+
+    unless recipe
+      $stderr.puts "recipe '#{service.recipe_name}' for service '#{service.name}' not found"
+      abort
+    end
+
+    recipe
+  end
+
+end

data/lib/nodectl/context.rb

@@ -0,0 +1,34 @@
+class Nodectl::Context
+  attr_reader :recipe
+  attr_reader :service
+
+  def initialize(recipe, service, methods = nil)
+    @recipe  = recipe
+    @service = service
+
+    if methods
+      extend methods
+    end
+  end
+
+  def exec(*args)
+    Process.exec(*args)
+  end
+
+  def chdir(dir)
+    Dir.chdir(dir)
+  end
+
+  def run(command, options = {}, &blk)
+    instance = Nodectl::Instance.new(service, command, options) do
+      instance_eval &blk if blk
+    end
+
+    instance.run
+    instance
+  end
+
+  def run_action(action_name, options = {})
+    service.recipe_binding.run_action(action_name, options)
+  end
+end

data/lib/nodectl/database.rb

@@ -0,0 +1,55 @@
+class Nodectl::Database
+  LoadError = Class.new(StandardError)
+  DumpError = Class.new(StandardError)
+
+  def initialize(file_path)
+    @db = DBM.open(file_path, 0666, DBM::WRCREAT)
+  end
+
+  def reset
+    @db.clear
+  end
+
+  def fetch(key, default = nil)
+    blob = @db[key]
+
+    if blob
+      load(blob)
+    elsif default
+      default
+    else
+      raise LoadError, "key not found: '#{key}'"
+    end
+  end
+
+  def [](key)
+    blob = @db[key]
+
+    if blob
+      load(blob)
+    else
+      nil
+    end
+  end
+
+  def []=(key, value)
+    @db[key] = Marshal.dump(value)
+  rescue TypeError => e
+    raise LoadError, "marshal dump error for key '#{key}' and value '#{value}': #{e.message}"
+  end
+
+  private
+
+    def dump(value)
+      Marshal.dump(value)
+    rescue TypeError => e
+      raise LoadError, "marshal dump error for key '#{key}' and value '#{value}': #{e.message}"
+    end
+
+    def load(value)
+      Marshal.load(value)
+    rescue TypeError => e
+      raise LoadError, "marshal load error for key '#{key}': #{e.message}"
+    end
+    
+end