slnky 0.8.3 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8df181eea71fd646f2a3d3d8457ff073498a9b94
-  data.tar.gz: 8608344396d1c576532f397b2fbfc19935e4f5d8
+  metadata.gz: 8f463d4a733b0c60374a3a454f61cab9e87be031
+  data.tar.gz: c250fa9638bd70abc1fbc9d02bf74c56d56b847d
 SHA512:
-  metadata.gz: 8a74844ae2514bf8ea23860e6fe4abcc0cbf6aa2522ba6cb0881eab4b62cfe793b3db7b644dc2c75f32d55fee64b3501520fdc2e0cb43ae060e4426116068db5
-  data.tar.gz: f39d2207c1a50d1dfb57005ff6370dfe1e0dedeac26281a7ad719438e459f083e6db749a1ddf3e4d76f562cde17188869ab9036326f8be1cccb45fda601172f6
+  metadata.gz: dd296841c43e2b34a48cd92a93080efbf146d5ddd71ace7d0c8cba47952b1bb987f906173f1ced9d9a4d3a88026386067c71234e4ab58f5f0a12c5f5013c91e2
+  data.tar.gz: e06bcf6700821592792b287480aec22cb2320374938f8c48c4e4e5971d183cb6f979caa865b5c89105a186f941b11b116e71a9f66068aa1ced2680b2df0ccda2

data/.ruby-gemset

@@ -0,0 +1 @@
+slnky

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.2

data/bin/slnky

@@ -4,4 +4,5 @@ require 'rubygems'
 require 'bundler/setup'
 require 'slnky/cli'
 
+Slnky::Config.configure('cli')
 Slnky::CLI::Main.run

data/lib/slnky/cli/command.rb

@@ -0,0 +1,78 @@
+module Slnky
+  module CLI
+    class Command < Base
+      # option %w{-s --server}, '[SERVER]', 'set server url', environment_variable: 'SLNKY_SERVER'
+      option %w{-n --dry-run}, :flag, "just output the event, don't send"
+      option %w{-t --timeout}, '[TIMEOUT]', "time to wait for response in seconds", default: 10 do |t|
+        Integer(t)
+      end
+      parameter 'SERVICE', 'the name of the service'
+      parameter '[COMMAND]', 'the name of the command', default: 'help'
+      parameter '[ARGUMENTS] ...', <<-DESC.strip_heredoc, attribute_name: :args
+        arguments to the command
+        commands support options and command line arguments similarly to
+        standard option parsing.
+      DESC
+
+      def execute
+        @name = service
+        data = {
+            name: "slnky.#{service}.command",
+            command: service == 'help' ? nil : command,
+            args: args,
+            response: "command-#{$$}",
+        }
+        Slnky::Config.configure('cli')
+        msg = Slnky::Message.new(data)
+        puts JSON.pretty_generate(msg.to_h) if dry_run?
+        amqp(msg) unless dry_run?
+      end
+
+      def name
+        @name
+      end
+
+      def amqp(msg)
+        response = msg.response
+        tx = Slnky::Transport.instance
+
+        tx.start!(self) do |_|
+          tx.exchange('response', :direct)
+          queue = tx.queue(response, 'response', durable: false, auto_delete: true, routing_key: response)
+          queue.subscribe do |raw|
+            message = Slnky::Message.parse(raw)
+            level = message.level.to_sym
+            if level == :complete
+              tx.stop!
+            elsif level == :start
+              # start tracking responders?
+            else
+              out message.level, message.message, message.service
+            end
+          end
+
+          EventMachine.add_periodic_timer(timeout) do
+            out :error, "timed out after #{timeout} seconds"
+            tx.stop!('Timed out')
+          end
+
+          Slnky.notify(msg)
+        end
+      end
+
+      def out(level, message, service=:local)
+        # unless @remote[service]
+        #   say "<%= color('response from service: #{data.service}', BOLD) %>"
+        #   @first = true
+        # end
+        # color = level.to_s == 'info' ? 'GREEN' : 'RED'
+        # say "<%= color(\"#{service}\", GRAY) %> <%= color(\"#{message}\", #{color}) %>"
+        lines = message.split("\n")
+        lines.each do |line|
+          puts "#{service} [#{level}] #{line}"
+        end
+      end
+    end
+  end
+end
+Slnky::CLI::Main.subcommand('command', 'send command to the slnky server', Slnky::CLI::Command)

data/lib/slnky/cli/generate.rb

@@ -3,14 +3,16 @@ module Slnky
     class Generate < Base
       subcommand 'service', 'generate a service named NAME' do
         parameter 'NAME', 'the name of the service'
+        option %w{-f --force}, :flag, "force overwrite of files"
         def execute
-          generator = Slnky::Generator::Service.new(name)
+          generator = Slnky::Generator::Service.new(name, force: force?)
           generator.generate
         end
       end
 
       subcommand 'command', 'generate a command named NAME' do
         parameter 'NAME', 'the name of the command'
+        option %w{-f --force}, :flag, "force overwrite of files"
         def execute
           raise 'not implemented'
         end

data/lib/slnky/cli/service.rb

@@ -0,0 +1,30 @@
+module Slnky
+  module CLI
+    class Service < Base
+      subcommand 'run', 'run service named NAME' do
+        parameter 'NAME', 'the name of the service'
+        # option %w{-f --force}, :flag, "force overwrite of files"
+        option %w{-e --environment}, '[ENV]', 'the environment to run under', default: 'development', environment_variable: 'SLNKY_ENV'
+        def execute
+          lib = File.expand_path("#{Dir.pwd}/lib", __FILE__)
+          $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+          require 'rubygems'
+          require 'bundler/setup'
+          require 'dotenv'
+          Dotenv.load
+
+          require 'slnky'
+          require "slnky/#{name}"
+
+          Slnky::Config.reset!
+          Slnky::Config.configure(name, 'environment' => environment)
+          Slnky::Chef::Service.new.start
+        rescue => e
+          puts "failed to run service #{name}: #{e.message} at #{e.backtrace.first}"
+        end
+      end
+    end
+  end
+end
+Slnky::CLI::Main.subcommand 'service', 'manage service', Slnky::CLI::Service

data/lib/slnky/cli.rb

@@ -1,7 +1,10 @@
-require 'slnky'
 require 'yaml'
 require 'clamp'
 require 'active_support/all'
+require 'highline'
+
+require 'slnky'
+require 'slnky/generator'
 
 module Slnky
   module CLI

data/lib/slnky/command/request.rb

@@ -0,0 +1,7 @@
+module Slnky
+  module Command
+    class Request < Slnky::Data
+
+    end
+  end
+end

data/lib/slnky/command/response.rb

@@ -0,0 +1,43 @@
+module Slnky
+  module Command
+    class Response
+      def initialize(route, service)
+        @transport = Slnky::Transport.instance
+        @channel = @transport.channel
+        @exchange = @transport.exchanges['response']
+        @route = route
+        @service = Slnky::System.pid(service)
+        start!
+      end
+
+      [:info, :warn, :error].each do |l|
+        define_method(l) do |message|
+          pub l, message
+        end
+      end
+
+      def output(message)
+        info(message)
+      end
+
+      def start!
+        pub :start, "start"
+      end
+
+      def done!
+        pub :complete, "complete"
+      end
+
+      private
+
+      def msg(level, message)
+        Slnky::Message.new({level: level, message: message, service: @service})
+      end
+
+      def pub(level, message)
+        # puts "#{level} #{message}"
+        @exchange.publish(msg(level, message), routing_key: @route)
+      end
+    end
+  end
+end

data/lib/slnky/command.rb

@@ -0,0 +1,100 @@
+require 'slnky/command/request'
+require 'slnky/command/response'
+
+require 'docopt'
+
+module Slnky
+  module Command
+    class Base
+      def initialize
+        @commands = self.class.commands
+      end
+
+      def handle(event, data)
+        begin
+          req = Slnky::Command::Request.new(data)
+          res = Slnky::Command::Response.new(data.response, name)
+          log.response = res
+          res.start!
+
+          if event == 'slnky.help.command'
+            handle_help(req, res)
+          else
+            handle_command(req, res)
+          end
+
+        rescue => e
+          log.error "failed to run command: #{name}: #{data.command}: #{e.message} at #{e.backtrace.first}"
+        ensure
+          res.done!
+          log.response = false
+        end
+      end
+
+      def handle_help(req, res, opts={})
+        @commands.each do |command|
+          log.info "#{name} #{command.name}: #{command.banner}"
+        end
+      end
+
+      def handle_command(req, res)
+        begin
+          processor = @commands.select { |c| c.name == req.command }.first
+          if processor
+            options = processor.process(req.args)
+            self.send("handle_#{processor.name}", req, res, options)
+          else
+            log.error "unknown command: #{req.command}"
+          end
+        rescue Docopt::Exit => e
+          log.info e.message
+        rescue => e
+          log.error "error in #{req.command}: #{e.message} at #{e.backtrace.first}"
+        end
+      end
+
+      def name
+        @name ||= self.class.name.split('::')[1].downcase
+      end
+
+      def log
+        @log ||= Slnky.log
+      end
+
+      class << self
+        attr_reader :commands
+
+        def command(name, banner, desc)
+          @commands ||= [Slnky::Command::Processor.new('help', 'print help', 'help [options]')]
+          @commands << Slnky::Command::Processor.new(name, banner, desc)
+        end
+      end
+    end
+
+    class Processor
+      attr_reader :name
+      attr_reader :banner
+      attr_reader :doc
+
+      def initialize(name, banner, doc)
+        @name = name.to_s
+        @banner = banner
+        @doc = doc =~ /^Usage/ ? doc : "Usage: #{doc}"
+      end
+
+      def usage
+        doc.lines.first.chomp
+      end
+
+      def process(args)
+        opts = Docopt::docopt(@doc, argv: args)
+        data = Slnky::Data.new
+        opts.each do |key, value|
+          k = key.gsub(/^--/, '').downcase
+          data.send("#{k}=", value)
+        end
+        data
+      end
+    end
+  end
+end

data/lib/slnky/config.rb

@@ -0,0 +1,69 @@
+require 'open-uri'
+
+module Slnky
+  class << self
+    def config
+      Slnky::Config.instance
+    end
+  end
+
+  class Config < Data
+    class << self
+      def configure(name, config={})
+        @name = name
+        @config ||= begin
+          config['service'] = name
+          config['environment'] ||= 'development'
+          file = ENV['SLINKY_CONFIG']||"~/.slnky/config.yaml"
+          config.merge!(config_file(file))
+          server = ENV['SLNKY_SERVER'] || config['url']
+          config.merge!(config_server(server))
+          self.new(config)
+        end
+      end
+
+      # def load_file(file)
+      #   self.load(YAML.load_file(File.expand_path(file)))
+      # end
+
+      def instance
+        @config || configure('unknown')
+      end
+
+      def reset!
+        @config = nil
+      end
+
+      # def merge(config)
+      #   @config.merge!(config)
+      # end
+
+      protected
+
+      def config_file(file)
+        path = File.expand_path(file)
+        return {} unless File.exists?(path)
+        d = YAML.load_file(path) rescue {}
+        d['slnky'] ? d['slnky'] : d
+      end
+
+      def config_server(server)
+        return {} unless server
+        server = "https://#{server}" unless server =~ /^http/
+        JSON.parse(open("#{server}/configs/#{@name}") { |f| f.read }) rescue {}
+      end
+    end
+
+    def development?
+      !self.environment || self.environment == 'development'
+    end
+
+    def production?
+      self.environment == 'production'
+    end
+
+    def test?
+      self.environment == 'test'
+    end
+  end
+end

data/lib/slnky/data.rb

@@ -3,14 +3,25 @@ require 'slnky/ext/deep_struct'
 
 module Slnky
   class Data < DeepStruct
-    class << self
-      def parse(str)
-        new(JSON.parse(str))
+    def initialize(hash={})
+      if hash.is_a?(Slnky::Data)
+        hash = hash.to_h
       end
+      super(hash)
     end
 
     def to_s
       to_h.to_json
     end
+
+    def delete(name)
+      self.delete_field(name) || self.delete_field(name.to_s)
+    end
+
+    class << self
+      def parse(str)
+        new(JSON.parse(str))
+      end
+    end
   end
 end

data/lib/slnky/generator.rb

@@ -5,41 +5,66 @@ require 'find'
 module Slnky
   module Generator
     class Base
+      require 'highline/import'
       attr_reader :name
       attr_reader :dir
 
-      def initialize(name)
+      def initialize(name, options={})
+        options = {
+            force: false,
+        }.merge(options)
         @name = name
-        @dir = File.expand_path("slnky-#{name}")
+        @service = "slnky-#{name}"
+        @dir = File.expand_path("./#{@service}")
         short = self.class.name.split('::').last.downcase
         @template = File.expand_path("../template/#{short}", __FILE__)
+        @force = options[:force]
       end
 
       def generate
-        puts "generating service #{@name}:"
-        puts "  from: #{@template}"
-        puts "  to:   #{@dir}"
+        say "<%= color('generating service #{@name}', BOLD) %>"
+        # puts "  from: #{@template}"
+        # puts "  to:   #{@dir}"
         process_files
         # make service executable
         `chmod 755 #{@dir}/service-slnky-#{@name}`
         # git init
-        puts "initializing git..."
-        `cd #{@dir} && git init . || true`
-        `cd #{@dir} && git add .`
+        if File.directory?("#{@dir}/.git")
+          puts "git already initialized"
+        else
+          puts "initializing git..."
+          `cd #{@dir} && git init . || true`
+          `cd #{@dir} && git add .`
+        end
       end
 
       protected
 
+      def askyn(message, options={})
+        options = {
+            choices: 'yn',
+        }.merge(options)
+        answer = ask("<%= color('#{message}', BOLD) %> [#{options[:choices]}]") do |q|
+          q.echo = false
+          q.character = true
+          q.validate = /\A[#{options[:choices]}]\Z/
+        end
+        answer == 'y'
+      end
+
       def process_files
         Find.find(@template).each do |path|
           next unless File.file?(path)
-          file = path.gsub(/^#{@template}\//, '')
+          file = path.gsub(/^#{@template}\//, '').gsub('NAME', @name)
           ext = File.extname(path)
           mkdir(File.dirname("#{@dir}/#{file}"))
+          dest = "#{@dir}/#{file}".gsub(/\.erb$/, '')
+          say "  <%= color('#{dest.gsub(/^#{File.expand_path('.')}\//, '')}', GREEN) %>"
           if ext == '.erb'
-            tmpl(file)
+            dest = dest
+            tmpl(path, dest) if !File.exists?(dest) || @force || askyn('    overwrite file?')
           else
-            file(file)
+            file(path, dest) if !File.exists?(dest) || @force || askyn('    overwrite file?')
           end
         end
       end
@@ -50,20 +75,21 @@ module Slnky
         FileUtils.mkdir_p(dir)
       end
 
-      def file(file)
+      def file(path, dest)
         # puts "file:  #{file}"
-        FileUtils.cp("#{@template}/#{file}", "#{@dir}/#{file}")
+        FileUtils.cp(path, dest)
       end
 
-      def tmpl(file)
+      def tmpl(path, dest)
         # puts "tmpl:  #{file}"
-        path = "#{@template}/#{file}"
         var = {
             name: @name,
-            dir: @dir
+            dir: @dir,
+            cap: @name.capitalize,
+            service: @service
         }
-        out = file.gsub(/\.erb$/, '').gsub('NAME', @name)
-        dest = "#{@dir}/#{out}"
+        # out = file.gsub(/\.erb$/, '')
+        # dest = "#{@dir}/#{out}"
         # puts "       #{dest}"
         template = Tilt.new(path)
         output = template.render(self, var)

data/lib/slnky/log.rb

@@ -0,0 +1,117 @@
+module Slnky
+  class << self
+    def log
+      Slnky::Log.instance
+    end
+  end
+
+  class Log
+    class << self
+      def instance
+        @logger ||= self.new
+      end
+    end
+
+    attr_accessor :local
+    attr_accessor :service
+    attr_accessor :response
+
+    def initialize
+      @config = Slnky::Config.instance
+      @env = @config.environment
+      @response = false
+      case @config.environment
+        when 'production'
+          @local   = false
+          @service = Slnky::Log::Service.new
+        when 'test'
+          @local   = false
+          @service = false
+        else # development or unset
+          @local   = Slnky::Log::Local.new
+          @service = false
+      end
+    end
+
+    [:debug, :info, :warn, :error].each do |l|
+      define_method(l) do |message|
+        log(l, message)
+      end
+    end
+
+    private
+
+    def log(level, message)
+      @local.send(level, message) if @local
+      @service.send(level, message) if @service
+      @response.send(level, message) if @response
+    end
+
+    class Base
+      [:debug, :info, :warn, :error].each do |l|
+        define_method(l) do |message|
+          log(l, message)
+        end
+      end
+
+      protected
+
+      def log(level, message)
+        # override in subclass
+      end
+    end
+
+    class False < Base
+
+    end
+
+    class Local < Base
+      def initialize
+        super
+        @logger = Logger.new(STDOUT)
+      end
+
+      protected
+
+      def log(level, message)
+        @logger.send(level, message)
+      end
+    end
+
+    class Service < Base
+      # ex = @transport.exchanges['logs']
+      # ex.publish(msg(data)) if ex # only log to the exchange if it's created
+      # puts "%s [%6s] %s" % [Time.now, data[:level], data[:message]] if development? # log to the console if in development
+
+      def initialize
+        super
+        @service = Slnky::System.pid('unknown')
+        @hostname = Slnky::System.hostname
+        @ipaddress = Slnky::System.ipaddress
+        @transport = Slnky::Transport.instance
+        @exchange = nil
+        if @transport
+          @exchange = @transport.exchanges['logs']
+        end
+      end
+
+      protected
+
+      def log(level, message)
+        return unless @exchange
+        data = {
+            service: "#{@name}-#{$$}",
+            level: level,
+            hostname: @hostname,
+            ipaddress: @ipaddress,
+            message: message
+        }
+        @exchange.publish(msg(data))
+      end
+
+      def msg(data)
+        Slnky::Message.new(data)
+      end
+    end
+  end
+end