nodectl 0.2.4

data/lib/nodectl/recipe.rb

@@ -0,0 +1,197 @@
+# TODO: param validation
+class Nodectl::Recipe
+  @manager = Nodectl::Manager.new(self)
+
+  SLOT_NAMES = [:install, :uninstall, :start, :version, :version_list, :version_set]
+
+  UnsupportedAction = Class.new(StandardError)
+  UnsupportedSlot   = Class.new(StandardError)
+
+  LogNotFound       = Class.new(Nodectl::NotFound)
+
+  attr_reader :name
+
+  def initialize(name, options = {})
+    @name     = name
+    @actions  = options[:actions] || {}
+    @slots    = options[:slots] || {}
+    @triggers = options[:triggers] || {}
+    @events   = options[:events] || {}
+    @logs     = options[:logs] || {}
+    @params   = options[:params] || {}
+
+    self.class[@name.to_s] = self
+  end
+
+  def bind(service)
+    Nodectl::Binding.new(service, self)
+  end
+
+  def run_slot(service, slot_name, run_params = nil)
+    run_params ||= {}
+    
+    unless @slots.key?(slot_name)
+      raise UnsupportedSlot, "slot '#{slot_name}' in not supported by '#{name}' recipe"
+    end
+
+    if slot_name == :install
+      install_deps(service)
+    end
+
+    run_trigger(service, slot_name, :pre)
+
+    @params.each do |key, value|
+      if !run_params.key?(key) && value.key?(:default)
+        run_params[key] = value[:default]
+      end
+    end
+
+    run_params.keys.each do |key|
+      run_params.delete(key) unless @params.key?(key)
+    end
+
+    result = context(service).instance_exec run_params, &@slots[slot_name]
+    run_trigger(service, slot_name, :post)
+    result
+  end
+
+  def run_action(service, action_name, run_params = {})
+    unless @actions.key?(action_name)
+      raise UnsupportedAction, "action '#{action_name}' in not supported by '#{name}' recipe"
+    end
+
+    @params.each do |key, value|
+      if !run_params.key?(key) && value.key?(:default)
+        run_params[key] = value[:default]
+      end
+    end
+
+    Nodectl::Action.run(service, action_name) do
+      run_trigger(service, action_name, :pre)
+      result = context(service).instance_exec run_params, &@actions[action_name]
+      run_trigger(service, action_name, :post)
+    end
+  end
+
+  def run_trigger(service, action_name, trigger_type)
+    unless [:pre, :post].include? trigger_type
+      raise "incorrect trigger type: expected 'post' or 'pre'"
+    end
+
+    trigger = @triggers[:"#{trigger_type}_#{action_name}"]
+    context(service).instance_eval &trigger if trigger
+  end
+
+  def get_logfile(service, log_name)
+    log = @logs.fetch(log_name)
+    log.instance_path(service)
+  rescue KeyError
+    raise LogNotFound, "log '#{log_name}' for recipe '#{name}' not found (service '#{service.name}')"
+  end
+
+  def logs
+    @logs.keys
+  end
+
+  def actions
+    @actions.keys
+  end
+
+  def triggers
+    @triggers.keys
+  end
+
+  def supported_actions(service)
+    @actions.keys
+  end
+
+  def supported_slots(service)
+    @slots.keys
+  end
+
+  def params
+    @params
+  end
+
+  private
+
+  def context(service)
+    Nodectl::Context.new(self, service)
+  end
+
+  def install_deps(service)
+    service.deps.each do |service|
+      if service.status != :installed
+        service.recipe_binding.run_slot :install
+      end
+    end
+  end
+
+  class DSL
+    def initialize(name, &blk)
+      raise "Cannot create recipe without block" unless block_given?
+
+      @name = name
+
+      @actions  = {}
+      @triggers = {}
+      @events   = {}
+      @logs     = {}
+      @params   = {}
+      @slots    = {}
+
+      instance_eval &blk
+    end
+
+    def create
+      Nodectl::Recipe.new(@name, actions:  @actions,
+                                 triggers: @triggers,
+                                 events:   @events,
+                                 logs:     @logs,
+                                 params:   @params,
+                                 slots:    @slots)
+    end
+
+    def action(name, &blk)
+      raise "Cannot create action without block" unless block_given?
+      @actions[name] = blk
+    end
+
+    def slot(name, &blk)
+      raise "Cannot create slots without block" unless block_given?
+      raise "Unsupported slot name #{name}" unless Nodectl::Recipe::SLOT_NAMES.include?(name)
+      @slots[name] = blk
+    end
+
+    def event(name, &blk)
+      raise "Cannot create event without block" unless block_given?
+      @events[name] = blk
+    end
+
+    def trigger(name, &blk)
+      raise "Cannot create trigger without block" unless block_given?
+      @triggers[name] = blk
+    end
+
+    def param(name, options = {})
+      @params[name] = options
+    end
+
+    def log(name, path)
+      @logs[name.to_s] = Nodectl::Log.new(name, path)
+    end
+  end
+
+  # Extension for ruby Object class for creating recipes anywhere
+  module ObjectMethods
+    def declare_recipe(*args, &blk)
+      Nodectl::Recipe.declare(*args, &blk)
+    end
+  end
+
+  class << self
+    def declare(*args, &blk)
+      DSL.new(*args, &blk).create
+    end
+  end
+end

data/lib/nodectl/repository.rb

@@ -0,0 +1,80 @@
+class Nodectl::Repository
+  VCSError = Class.new(StandardError)
+
+  def initialize(path)
+    @path = path
+  end
+
+  def current_version
+    ret, out = shell_git("log -1 --pretty=format:%H\\ %ci\\ %s")
+    parse_version(out)
+  end
+
+  def switch_version(version)
+    shell_git("checkout -f #{version}")
+  end
+
+  def versions
+    fetch
+    
+    ret, out = shell_git("log --all --pretty=format:%H\\ %ci\\ %s")
+    result   = []
+
+    out.each_line do |line|
+      result << parse_version(line)
+    end
+
+    result
+  end
+
+  def fetch
+    shell_git("fetch")
+  end
+
+  def pull
+    shell_git("checkout master")
+    shell_git("pull")
+  end
+
+  private
+
+  def shell_git(command, options = {})
+    source_path = options[:source_path] || @path
+    gitdir_path = options[:gitdir_path] || File.join(source_path, ".git")
+
+    self.class.shell_run("git --work-tree=#{source_path} --git-dir=#{gitdir_path} #{command} 2>&1", options)
+  end
+
+  def parse_version(line)
+    {
+      "id"        => line[0...40],
+      "timestamp" => line[41...66],
+      "message"   => line[67..-1]
+    }
+  end
+
+  class << self
+    def clone(from, to)
+      FileUtils.mkdir_p(to)
+      ret, out = shell_run("git clone #{from} #{to}")
+      new(to)
+    end
+
+    def shell_run(command, options = {})
+      command = "#{command} 2>&1"
+      Nodectl.logger.info "repository: run command '#{command}'"
+
+      process = IO.popen(command)
+
+      out = process.read
+      process.close
+      ret = $?
+
+      if ret != 0 && !options[:ignore_status]
+        raise VCSError, "exit status: #{ret.exitstatus}"
+      end
+
+      [ret, out]
+    end
+  end
+end

data/lib/nodectl/server.rb

@@ -0,0 +1,103 @@
+class Nodectl::Server
+  attr_reader :options
+
+  def initialize(options = {})
+    @options = self.class.default_options.merge(options)
+  end
+
+  def run
+    if @options["daemonize"]
+      if Process.fork
+        exit
+      else
+        Nodectl.shut_up!
+      end
+    end
+
+    if @options["pidfile"]
+      File.open(@options["pidfile"], "w") do |file|
+        file.write(Process.pid)
+      end
+
+      at_exit { File.unlink @options["pidfile"] }
+    end
+
+    Nodectl.logger.info "server with pid #{Process.pid} started"
+    at_exit { Nodectl.logger.info "server with pid #{Process.pid} shutting down" }
+
+    Nodectl::Service.load_register
+    Nodectl::Instance.load_register
+
+    EM.run do
+      setup_signals
+      rack_run
+      watchdog_run
+      stream_run
+    end
+  end
+
+  def stop
+    @thin.stop if @thin
+    EM.stop
+  end
+
+  def stop!
+    @thin.stop! if @thin
+    EM.stop
+  end
+
+  def self.default_options
+    @default_options ||= YAML.load_file(Nodectl.options[:config_dir].join('server.yml'))
+  end
+
+  private
+
+    def rack_run
+      options = @options
+
+      @thin = Thin::Server.new(@options["http_host"], @options["http_port"], signals: false) do
+        map('/instances') { run Nodectl::Webapp::Instances.new }
+        map('/services')  { run Nodectl::Webapp::Services.new }
+        map('/actions')   { run Nodectl::Webapp::Actions.new }
+        map('/versions')  { run Nodectl::Webapp::Versions.new }
+        map('/settings')  { run Nodectl::Webapp::Settings.new }
+
+        unless options["ui_disabled"]
+          map('/') { run Nodectl::Webapp::UI.new }
+        end
+      end
+
+      @thin.start!
+    end
+
+    def watchdog_run
+      @watchdog = Nodectl::Watchdog.new
+    end
+
+    def stream_run
+      @websocket = Nodectl::Stream::Websocket.new(@options["websocket_host"],
+                                                  @options["websocket_port"])
+    end
+
+    def setup_signals
+      @signal_queue ||= []
+
+      %w( INT TERM ).each do |signal|
+        trap(signal) { @signal_queue << signal }
+      end
+
+      @signal_timer ||= EM.add_periodic_timer(1) { handle_signals }
+    end
+
+    def handle_signals
+      case @signal_queue.shift
+      when 'INT'
+        stop!
+      when 'TERM', 'QUIT'
+        stop
+      end
+
+      EM.next_tick { handle_signals } unless @signal_queue.empty?
+    end
+
+end

data/lib/nodectl/service.rb

@@ -0,0 +1,126 @@
+class Nodectl::Service
+  @manager = Nodectl::Manager.new(self)
+
+  attr_reader :manifest
+  
+  def initialize(manifest)
+    @manifest = manifest
+
+    Nodectl::Service[name] = self
+  end
+
+  def name; @manifest["name"]; end
+  def path; @manifest["path"]; end
+  def repo; @manifest["repo"]; end
+
+  def deps
+    (@manifest["deps"] || []).map do |service_name|
+      self.class.find!(service_name)
+    end
+  end
+
+  def recipe_name
+    @manifest["recipe"]
+  end
+
+  def inspect
+    "#<#{self.class} name:#{name}>"
+  end
+
+  def source_path
+    Nodectl.options[:source_dir].join(path)
+  end
+
+  def exist?
+    # TODO: think of a better criterion for existing installation
+    source_path.exist?
+  end
+
+  def status
+    exist? ? :installed : :available
+  end
+
+  def recipe
+    @recipe ||= Nodectl::Recipe.find(recipe_name)
+  end
+
+  def recipe_binding
+    recipe.bind(self) if recipe
+  end
+
+  def instances
+    Nodectl::Instance.all.select { |i| i.service == self }
+  end
+
+  def supported_actions
+    binding = recipe_binding
+    if binding
+      binding.supported_actions
+    else
+      []
+    end
+  end
+
+  def supported_slots
+    binding = recipe_binding
+    if binding
+      binding.supported_slots
+    else
+      []
+    end
+  end
+
+  # TODO: Refactor this method (and may be whole log-related classes):
+  #       service class should not know about log internals and streaming
+  #       urls
+  def logs
+    unless @logs
+      if recipe
+        binding = recipe_binding
+        @logs = recipe.logs.map do |log|
+          {
+            "id"   => "#{name}-#{log}",
+            "name" => log,
+            "path" => "/logs/#{name}/#{log}",
+          }
+        end
+      else
+        @logs = []
+      end
+    end
+
+    @logs
+  end
+
+  def as_json
+    json = {
+      "id"                => name,
+      "status"            => status,
+      "instance_ids"      => instances.map(&:pid),
+      "recipe_name"       => recipe_name,
+      "supported_actions" => supported_actions,
+      "supported_slots"   => supported_slots,
+      "logs"              => logs,
+      "params"            => recipe.params
+    }
+
+    binding = recipe_binding
+
+    if status == :installed && binding.supported_slots.include?(:version)
+      version = binding.run_slot(:version)
+      json["version_id"]        = version["id"]
+      json["version_timestamp"] = version["timestamp"]
+      json["version_message"]   = version["message"]
+    end
+    
+    json
+  end
+
+  class << self
+    def load_register
+      Nodectl.manifest["services"].each do |service_manifest|
+        new(service_manifest)
+      end
+    end
+  end
+end