vop-plugins 0.3.1 → 0.3.5

data/standard/services/commands/describe_service_installation.rb

@@ -0,0 +1,13 @@
+param! "service"
+param "section", default: :install
+
+show display_type: :data
+
+run do |service, section|
+  result = @op.describe_service(service)
+  if result.has_key? section
+    result[section]
+  else
+    result
+  end
+end

data/standard/services/commands/detect_services.rb

@@ -0,0 +1,34 @@
+param! :machine
+
+read_only
+
+run do |machine, plugin|
+  procs = machine.processes.map { |x| x["command"] }
+
+  result = []
+  plugin.state[:services].each do |service|
+    if service.data.has_key? :process_regex
+      service.data[:process_regex].each do |regex|
+        found = procs.grep regex
+        if found.size > 0
+          result << service.name
+        end
+      end
+    end
+
+    if service.data.has_key? :binary_name
+      service.data[:binary_name].each do |name|
+        found = false
+        begin
+          found = machine.ssh("which #{name}")
+        rescue => e
+        end
+        if found
+          result << service.name
+        end
+      end
+    end
+  end
+
+  result
+end

data/standard/services/commands/install_service.rb

@@ -0,0 +1,134 @@
+require "erb"
+require "tempfile"
+
+param! :machine
+param! :service
+
+allows_extra
+
+run do |plugin, machine, service, params|
+  processed = Hash.new { |h,k| h[k] = [] }
+
+  description = service.data[:install]
+  if description.include?(:files)
+    if description[:files].include?(:create)
+      creates = description[:files][:create]
+      creates.each do |what|
+        if what.include? :in
+          machine.mkdirs(what[:in])
+          (what[:dirs] || []).each do |dir|
+            machine.mkdirs (File.join(what[:in], dir))
+          end
+          processed[:create] << what
+        end
+      end
+    end
+
+    if description[:files].include?(:copy)
+      copies = description[:files][:copy]
+      copies.each do |what|
+        unless what.include?(:from) && what.include?(:to)
+          raise "copy needs to include :from and :to"
+        end
+
+        local_path = File.join(service.plugin.plugin_dir(:files), what[:from])
+        unless File.exists? local_path
+          raise "file not found at #{local_path}"
+        end
+        # TODO this does not work if remote_path needs root permissions
+        # (and current user is marvin)
+        machine.scp_up("local_path" => local_path, "remote_path" => what[:to])
+        processed[:copy] << what
+      end
+    end
+
+    if description[:files].include?(:template)
+      templates = description[:files][:template]
+      templates.each do |what|
+        unless what.include?(:template) && what.include?(:to)
+          raise "template needs to include :template and :to"
+        end
+
+        template_path = File.join(service.plugin.plugin_dir(:templates), what[:template])
+        unless File.exists? template_path
+          raise "template not found at #{template_path}"
+        end
+
+        tmp = Tempfile.new("vop_service_install_template")
+        begin
+          # TODO could use more bindings?
+          vars = {
+            "service" => service,
+            "machine" => machine
+          }
+          @op.machines["localhost"].write_template(
+            template: template_path,
+            to: tmp.path,
+            bind: OpenStruct.new(vars).instance_eval { binding }
+          )
+          tmp.flush
+          $logger.info "template #{what[:template]} processed into #{what[:to]} (using local temp path #{tmp.path})"
+          machine.scp_up("local_path" => tmp.path, "remote_path" => what[:to])
+          processed[:template] << what
+        ensure
+          tmp.close
+        end
+      end
+    end
+  end
+
+  if description.include?(:repo)
+    description[:repo].each do |repo|
+      p = Hash[ repo.map { |k,v| [k.to_s, v] } ]
+      machine.add_apt_repo(p)
+    end
+  end
+
+  if description.include?(:package)
+    machine.install_package(description[:package])
+  end
+
+  if description.include?(:gems)
+    description[:gems].each do |gem|
+      machine.sudo("gem install #{gem}")
+    end
+  end
+
+  if description.include?(:url)
+    description[:url].each do |url|
+      file_name = url.split("?").first.split("/").last
+      puts "downloading to #{file_name} from #{url}"
+      machine.download_file("url" => url, "file" => file_name)
+
+      # TODO auto-extract?
+    end
+  end
+
+  svc = plugin.state[:services].select { |x| x.name == service["name"] }.first
+  raise "no service found named '#{service["name"]}'" unless svc
+  svc.install_blocks.each_with_index do |install_block, idx|
+    $logger.info "calling install block #{idx}"
+    block_param_names = install_block.parameters.map { |x| x.last }
+    payload = []
+    block_param_names.each do |block_param_name|
+      case block_param_name.to_s
+      when "machine"
+        payload << machine
+      when "params"
+        $logger.debug "params for payload for block #{idx} : #{params.pretty_inspect}"
+        payload << params
+      when "plugin"
+        payload << svc.plugin
+      else
+        raise "unknown block param #{block_param_name} in installation block #{idx} for service #{service["name"]}"
+      end
+    end
+
+    install_block.call(*payload)
+  end
+
+  machine.processes!
+  machine.detect_services!
+
+  processed
+end

data/standard/services/commands/list_known_services.rb

@@ -0,0 +1,14 @@
+read_only
+
+run do |plugin|
+  plugin.state[:services].map do |service|
+    h = {
+      "name" => service.name      
+    }
+    if service.data[:icon]
+      h["icon"] = File.join(service.plugin.plugin_dir(:files), service.data[:icon])
+    end
+    h["installable"] = service.data.has_key? :install
+    h
+  end
+end

data/standard/services/commands/load_plugin_services.rb

@@ -0,0 +1,17 @@
+require_relative "../helpers/service_loader"
+require_relative "../helpers/service"
+require_relative "../helpers/service_syntax"
+
+description "loads services defined in plugins"
+
+run do |plugin|
+  @op.plugins.each do |one_plugin|
+    one_plugin.load_code_from_dir :services
+    if one_plugin.sources[:services].keys.size > 0
+      $logger.debug "  found services in #{one_plugin.name} : #{one_plugin.sources[:services].keys}"
+      loader = ServiceLoader.new(one_plugin.clone)
+      loaded = loader.read_sources(one_plugin.sources[:services])
+      plugin.state[:services] += loaded
+    end
+  end
+end

data/standard/services/entities/service.rb

@@ -0,0 +1,3 @@
+entity do |plugin|
+  plugin.state[:services].map { |x| x.to_hash.merge("plugin_name" => x.plugin.name) }
+end

data/standard/services/helpers/service.rb

@@ -0,0 +1,31 @@
+module Vop
+
+  class Service < ThingWithParams
+
+    attr_reader :plugin, :name
+    attr_reader :data
+    attr_accessor :install_blocks
+
+    def initialize(plugin, name)
+      super()
+
+      @plugin = plugin
+      @name = name
+      @data = {
+        install: { }
+      }
+      @install_blocks = [ ]
+    end
+
+    def to_s
+      "Vop::Service #{name}"
+    end
+
+    def to_hash
+      meta = { "name" => @name }
+      @data.merge(meta)
+    end
+
+  end
+
+end

data/standard/services/helpers/service_loader.rb

@@ -0,0 +1,50 @@
+module Vop
+
+  class ServiceLoader
+
+    def initialize(plugin)
+      @plugin = plugin
+      @op = plugin.op
+
+      @services = []
+
+      @plugin.inject_helpers(self)
+
+      extend ServiceSyntax
+    end
+
+    def new_service(name)
+      $logger.debug "new service in #{@plugin.name}: #{name}"
+      @service = Service.new(@plugin, name)
+      $logger.debug "service plugin : #{@service.plugin.name}"
+      @services << @service
+      @service
+    end
+
+    def read_sources(named_sources)
+      # reads a hash of <name> => <source string>
+      named_sources.each do |name, source|
+
+        new_service(name)
+
+        begin
+          self.instance_eval(source[:code], source[:file_name])
+        rescue SyntaxError => detail
+          raise Errors::ServiceLoadError.new("problem loading service #{name}", detail.backtrace.join("\n"))
+        end
+      end
+
+      @services
+    end
+
+  end
+
+  module Errors
+
+    class ServiceLoadError < LoadError
+
+    end
+
+  end
+
+end

data/standard/services/helpers/service_syntax.rb

@@ -0,0 +1,126 @@
+module Vop
+
+  module ServiceSyntax
+
+    def resolve_options_string(options)
+      if options.is_a? String
+        options = {
+          description: options
+        }
+      end
+      options
+    end
+
+    def param(name, options = {})
+      options = resolve_options_string(options)
+
+      @service.params << CommandParam.new(name, options)
+    end
+
+    def param!(name, options = {})
+      options = resolve_options_string(options)
+      options.merge! mandatory: true
+      param(name, options)
+    end
+
+
+
+
+    def process_regex(regex)
+      @service.data[:process_regex] ||= []
+      @service.data[:process_regex] << regex
+    end
+
+    def binary_name(name)
+      @service.data[:binary_name] ||= []
+      @service.data[:binary_name] << name
+    end
+
+    def deploy(what = {}, &block)
+      if block_given?
+        @service.install_blocks << block
+      end
+
+      if what.include? :create
+        files = @service.data[:install][:files] ||= {}
+        files[:create] ||= []
+        files[:create] << what[:create]
+      end
+
+      if what.include? :files
+        raise "deploy (:files) needs a 'to' option" unless what.include?(:to)
+        files = @service.data[:install][:files] ||= {}
+        files[:copy] ||= []
+        files[:copy] << {
+          from: what[:files],
+          to: what[:to]
+        }
+      end
+
+      if what.include? :template
+        raise "deploy (:template) needs a 'to' option" unless what.include?(:to)
+        files = @service.data[:install][:files] ||= {}
+        (files[:template] ||= []) << what
+      end
+
+      if what.include? :package
+        @service.data[:install][:package] ||= []
+
+        if what[:package].is_a?(Array)
+            @service.data[:install][:package] += what[:package]
+        else
+          @service.data[:install][:package] << what[:package]
+        end
+      end
+
+      if what.include? :gem
+        @service.data[:install][:gems] ||= []
+
+        gems = if what[:gem].is_a?(Array)
+          what[:gem]
+        else
+          [ what[:gem] ]
+        end
+        @service.data[:install][:gems] += gems
+      end
+
+      if what.include? :repository
+        @service.data[:install][:repo] ||= []
+
+        if what[:repository].is_a?(Array)
+            @service.data[:install][:repo] += what[:repository]
+        else
+          @service.data[:install][:repo] << what[:repository]
+        end
+      end
+
+      if what.include? :url
+        @service.data[:install][:url] ||= []
+        @service.data[:install][:url] << what[:url]
+      end
+
+    end
+
+    def known_binaries(list)
+
+    end
+
+    def version_command(command)
+
+    end
+
+    def port(port)
+
+    end
+
+    def icon(name)
+      @service.data[:icon] = name
+    end
+
+    def vhost(vhost)
+
+    end
+
+  end
+
+end

data/standard/services/services.plugin

@@ -0,0 +1,9 @@
+depends_on :machines
+
+on :init do |plugin|
+  plugin.state[:services] = []
+end
+
+hook :loading_finished do
+  @op.load_plugin_services
+end

data/standard/ssh/commands/clean_known_host.rb

@@ -0,0 +1,11 @@
+param! "ip"
+
+run do |ip|
+  # TODO validate ip ?
+  localhost = @op.machines["localhost"]
+
+  home = localhost.ssh('echo $HOME').chomp
+  known_hosts = File.join(home, ".ssh", "known_hosts")
+  
+  localhost.ssh "ssh-keygen -f #{known_hosts} -R #{ip}"
+end