vop 0.3.1 → 0.3.4

data/lib/vop/vop.rb

@@ -0,0 +1,216 @@
+require "pathname"
+require "pp"
+require "logger"
+
+require_relative "parts/plugin_finder"
+require_relative "parts/plugin_loader"
+require_relative "parts/dependency_resolver"
+require_relative "objects/request"
+require_relative "objects/entity"
+require_relative "objects/entities"
+require_relative "util/errors"
+require_relative "util/pluralizer"
+require_relative "util/worker"
+
+module Vop
+
+  $logger = Logger.new(STDOUT)
+
+  class Vop
+
+    attr_reader :plugins
+    attr_reader :commands
+    attr_reader :entities
+
+    attr_reader :filters
+    attr_reader :filter_chain
+
+    attr_reader :finder, :loader, :sorter
+
+    def initialize(options = {})
+      @options = {
+        config_path: "/etc/vop",
+        log_level: Logger::INFO
+      }.merge(options)
+      $logger.level = @options[:log_level]
+
+      @finder = PluginFinder.new
+      @loader = PluginLoader.new(self)
+      @sorter = DependencyResolver.new(self)
+
+      _reset
+    end
+
+    def clear
+      @plugins = []
+      @commands = {}
+      @entities = {}
+      @filters = {}
+      @filter_chain = []
+      @hooks = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def _reset
+      clear
+      load
+    end
+
+    def to_s
+      "Vop (#{@plugins.size} plugins)"
+    end
+
+    def inspect
+      {
+        plugins: @plugins.map(&:name)
+      }.to_json()
+    end
+
+    def plugin(name)
+      result = @plugins.select { |x| x.name == name }.first
+      raise "no such plugin: #{name}" if result.nil?
+      result
+    end
+
+    def lib_path
+      Pathname.new(File.join(File.dirname(__FILE__), "..")).realpath
+    end
+
+    def core_location
+      File.join(lib_path, "core")
+    end
+
+    def plugin_locations
+      result = []
+
+      # during development, we might find checkouts for "plugins" and "services"
+      # next to the core
+      vop_dir = Pathname.new(File.join(lib_path, "..", "..")).realpath
+      unless vop_dir.to_s.start_with? "/usr"
+        %w|plugins services|.each do |thing|
+          sibling_dir = File.join(vop_dir, thing)
+          result << sibling_dir
+        end
+      end
+
+      # for distribution packages (?)
+      result << "/usr/lib/vop-plugins"
+
+      # an extra path might have been passed in the options
+      if @options.has_key? :plugin_path
+        result << @options[:plugin_path]
+      end
+
+      result
+    end
+
+    def config_path
+      @options[:config_path]
+    end
+
+    def plugin_config_path
+      @plugin_config_path ||= File.join(config_path, "plugins.d")
+    end
+
+    def load_from(locations, load_options = {})
+      found = finder.find(locations)
+      plugins = loader.load(found, load_options)
+      new_plugins = sorter.sort(plugins.loaded)
+
+      new_plugins.each do |plugin|
+        plugin.init
+        self << plugin
+      end
+
+      $logger.debug "loaded #{new_plugins.size} plugins from #{locations}"
+      $logger.debug plugins.loaded.map(&:name)
+    end
+
+    def load
+      load_from(core_location, { core: true })
+      load_from(plugin_locations)
+      load_from(search_path)
+
+      call_global_hook :loading_finished
+
+      $logger.info "init complete : #{@plugins.size} plugins, #{@commands.size} commands"
+    end
+
+    def <<(stuff)
+      if stuff.is_a? Array
+        stuff.each do |thing|
+          self << thing
+        end
+      else
+        if stuff.is_a? Plugin
+          @plugins << stuff
+        elsif stuff.is_a? EntityDefinition
+          entity = stuff
+          @entities[entity.short_name] = stuff
+        elsif stuff.is_a? Command
+          command = stuff
+          unless command.dont_register
+            $logger.debug "registering #{command.name}"
+            if @commands.keys.include? command.short_name
+              $logger.warn "overriding previous declaration of #{command.short_name}"
+            end
+            @commands[command.short_name] = stuff
+
+            self.class.send(:define_method, command.short_name) do |*args, &block|
+              ruby_args = args.length > 0 ? args[0] : {}
+              # TODO we might want to do this only if there's a block param defined
+              if block
+                ruby_args["block"] = block
+              end
+              self.execute(command.short_name, ruby_args)
+            end
+          end
+        elsif stuff.is_a? Filter
+          short_name = stuff.short_name
+          @filters[short_name] = stuff
+          @filter_chain.unshift short_name
+        else
+          raise Errors::LoadError.new "unexpected type '#{stuff.class}'"
+        end
+      end
+    end
+
+    def hook(hook_sym, &block)
+      @hooks[hook_sym] << block
+    end
+
+    def call_global_hook(hook_sym, payload = {})
+      @hooks[hook_sym].each do |h|
+        h.call(payload)
+      end
+    end
+
+    def execute_request(request)
+      call_global_hook(:before_execute, { request: request })
+      begin
+        response = request.execute()
+      rescue => e
+        response = ::Vop::Response.new(nil, {})
+        response.status = "error"
+        raise e
+      ensure
+        call_global_hook(:after_execute, { request: request, response: response })
+      end
+
+      #$logger.debug "executed : #{request.command.name}, response : #{response.pretty_inspect}"
+      response
+    end
+
+    def execute(command_name, param_values = {}, extra = {})
+      request = Request.new(self, command_name, param_values, extra)
+      response = execute_request(request)
+
+      response.result
+    end
+
+    def execute_async(request)
+      AsyncExecutorWorker.perform_async(request.to_json)
+    end
+
+  end
+
+end

data/lib/vop.rb

@@ -1,242 +1,29 @@
-require 'pp'
-require 'logger'
-require 'pathname'
+require "pathname"
 
-require 'vop/version'
-require 'vop/plugin_loader'
-require 'active_support/inflector'
+require_relative "vop/version"
+require_relative "vop/shell/shell"
+require_relative "vop/vop"
 
 module Vop
 
-  VOP_ROOT = Pathname.new(File.join(File.dirname(__FILE__), '..')).realpath
-  CORE_PLUGIN_PATH = Pathname.new(File.join(File.dirname(__FILE__), 'vop', 'plugins')).realpath
-  #CONFIG_PATH = '/etc/vop'
-  #PLUGIN_CONFIG_PATH = File.join(CONFIG_PATH, 'plugins.d')
-
-  class Vop
-
-    DEFAULTS = {
-      :search_path => [
-        File.join(VOP_ROOT, '..', 'plugins/standard'),
-        File.join(VOP_ROOT, '..', 'plugins/extended')
-      ],
-      :command_dir_name => 'commands',
-      :plugin_config => {
-
-      }
-    }
-
-    attr_reader :config
-
-    attr_reader :plugins
-    attr_reader :commands
-
-    def initialize(options = {})
-      at_exit {
-        self.shutdown
-      }
-
-      @version = ::Vop::VERSION
-
-      @config = DEFAULTS
-      @config.merge! options
-
-      $logger = Logger.new(STDOUT)
-      $logger.level = options['--verbose'] ? Logger::DEBUG : Logger::INFO
-
-      _reset
-
-      $logger.info "virtualop (#{@version}) init complete."
-      $logger.info "hello."
-    end
-
-    def _pry
-      binding.pry
-    end
-
-    def _reset
-      $logger.debug "loading..."
-
-      load_plugins
-
-      $logger.info "loaded #{@commands.size} commands from #{@plugins.size} plugins"
-    end
-
-    def _search_path
-      [ CORE_PLUGIN_PATH ] + config[:search_path]
-    end
-
-    def inspect
-      chunk_size = 25
-      plugin_string = @plugins.keys.sort[0..chunk_size-1].join(' ')
-      if @plugins.length > chunk_size
-        plugin_string += " + #{@plugins.length - chunk_size} more"
-      end
-      "vop #{@version} (#{plugin_string})"
-    end
-
-    def eat(command)
-      @commands[command.short_name] = command
-
-      self.class.send(:define_method, command.short_name) do |*args|
-        ruby_args = args.length > 0 ? args[0] : {}
-        self.execute(command.short_name, ruby_args)
-      end
-    end
-
-    def load_plugins
-      @plugins = {}
-      @commands = {}
-      @hooks = Hash.new { |h,k| h[k] = [] }
-
-      # step 1 : read plugins from all existing source dirs
-      candidates = _search_path
-      search_path = candidates.select { |path| File.exists? path }
-      search_path.each do |path|
-        PluginLoader.read(self, path)
-      end
-
-      # step 2 : activate plugins (in the right order)
-      ordered_plugins.each do |plugin|
-        plugin.init
-      end
-
-      # step 3 : expand entities
-      @plugins['core'].state[:entities].each do |entity|
-        entity_name = entity[:name]
-        entity_command = @commands[entity_name]
-        list_command_name = "list_#{entity_name.pluralize(42)}"
-        $logger.debug "generating #{list_command_name}"
-        list_command = Command.new(entity_command.plugin, list_command_name)
-
-        if entity[:options][:on]
-          list_command.params << {
-            :name => entity[:options][:on],
-            :multi => false,
-            :mandatory => true,
-            :default_param => true
-          }
-        end
-        list_command.block = entity_command.param(entity[:key])[:lookup]
-        eat(list_command)
-        # TODO add pseudo source code so that `source <list_command_name>` works
-      end
-
-      # TODO add pre-flight hook so that plugins can attach logic to execute here
-    end
-
-    def resolve(plugin, resolved, unresolved, level = 0)
-      unresolved << plugin.name
-
-      plugin.dependencies.each do |dep|
-        unless resolved.include? dep
-          if unresolved.include? dep
-            raise "running in circles #{plugin.name} -> #{dep}"
-          else
-            unless @plugins.has_key? dep
-              raise "missing dependency: #{plugin.name} depends on #{dep}"
-            end
-            dependency = @plugins[dep]
-            resolve(dependency, resolved, unresolved, level + 1)
-          end
-        end
-      end
-      resolved << plugin.name
-    end
-
-    def ordered_plugins
-      root_plugin = Plugin.new(self, '__root__', nil)
-      @plugins.values.each do |plugin|
-        root_plugin.dependencies << plugin.name
-      end
-      resolved = []
-      unresolved = []
-
-      resolve(root_plugin, resolved, unresolved)
-      resolved.delete_if { |x| x == root_plugin.name }
-
-      resolved.map { |x| @plugins[x] }
-    end
-
-    def command(name)
-      unless commands.has_key?(name)
-        raise "no such command : #{name}"
-      end
-
-      commands[name]
-    end
-
-    def core
-      @plugins['core']
-    end
-
-    def hook(name, plugin_name)
-      @hooks[name] << plugin_name
-    end
-
-    def call_hook(name, *payload)
-      @hooks[name].each do |plugin_name, block|
-        @plugins[plugin_name].call_hook(name, payload)
-      end
-    end
-
-    def before_execute(request)
-      #puts ">> #{request.command_name} #{request.param_values.keys}"
-      call_hook :before_execute, request
-    end
-
-    def after_execute(request, response)
-      #puts "<< #{request.command_name} #{response.result}"
-      call_hook :after_execute, request, response
-    end
-
-    def execute(command_name, param_values, extra = {})
-      request = Request.new(command_name, param_values, extra)
-      before_execute(request)
-
-      (result, context) = execute_command(command_name, param_values, extra)
-
-      response = Response.new(result, context)
-      after_execute(request, response)
-
-      result
-    end
-
-    def execute_command(command_name, param_values, extra = {})
-      $logger.debug "+++ #{command_name} +++"
-      command = @commands[command_name]
-
-      command.execute(param_values, extra)
-    end
-
-    def shutdown()
-      $logger.debug "shutting down..."
-    end
-
+  def self.setup(options = {})
+    ::Vop::Vop.new(options)
   end
 
-  class Request
-
-    attr_reader :command_name, :param_values
-
-    def initialize(command_name, param_values, extra = {})
-      @command_name = command_name
-      @param_values = param_values
-      # fuck extra
+  def self.boot(options = {})
+    if ENV["VOP_DEV_MODE"]
+      sibling_lib_dir = Pathname.new(File.join(File.dirname(__FILE__), "..", "lib")).realpath
+      if File.exists? sibling_lib_dir
+        #puts "adding local lib path #{sibling_lib_dir}"
+        $: << sibling_lib_dir
+      end
     end
 
+    ::Vop.setup(options)
   end
 
-  class Response
-
-    attr_reader :result
-
-    def initialize(result, context)
-      @result = result
-      @context = context
-    end
-
+  def vop_setup(options = {})
+    ::Vop.boot(options)
   end
 
-
 end

data/vop.gemspec

@@ -1,31 +1,34 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# encoding: utf-8
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'vop/version'
+require "vop/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "vop"
   spec.version       = Vop::VERSION
   spec.authors       = ["Philipp T."]
-  spec.email         = ["philipp@virtualop.org"]
+  spec.email         = ["philipp@hitchhackers.net"]
 
-  spec.summary       = %q{The virtualop is a tool for automating things.}
-  spec.description   = %q{Automated processes fail more consistently, that's why I wrote a tool to make scripts that will do things that we won't have to do ourselves then. (see xkcd #1629)}
-  spec.homepage      = "http://www.virtualop.org"
+  spec.summary       = %q{The vop is a scripting framework.}
+  spec.description   = %q{Automation framework with a plugin/command architecture, entities, contributions, filters and asynchronous workers. Shell included, web interface in a separate project.}
+  spec.homepage      = "http://virtualop.org"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "terminal-table"
   spec.add_dependency "net-ssh"
   spec.add_dependency "net-scp"
-  spec.add_dependency "docopt"
-  spec.add_dependency "activesupport"
-  spec.add_dependency "pry"
+  spec.add_dependency "redis"
+  spec.add_dependency "sidekiq"
+  spec.add_dependency "terminal-table"
+  spec.add_dependency "xml-simple"
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
 end