mkit 0.6.3 → 0.7.0

data/lib/mkit/client/command_parser.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+#
+require 'yaml'
+require 'json'
+require 'erb'
+
+class InvalidParametersException < Exception
+  attr_reader :command
+
+  def initialize(cause, command = nil)
+    super(cause)
+    @command = command
+  end
+end
+
+class CommandParser
+  def initialize
+    @dict = YAML.safe_load(File.read("#{File.expand_path('..', __dir__)}/client/commands.yaml"), symbolize_names: true)
+  end
+
+  def dict
+    @dict
+  end
+
+  def parse(args)
+    cmd = args[0]
+    c = nil
+    # short circuit for help
+    if cmd == 'help' || args.empty?
+      if args.size > 1
+        c = find_command(args[1])
+        raise InvalidParametersException, "'#{args[1]}' is not a valid help topic." if c.nil?
+      end
+      return help(cmd: c)
+    else
+      c = find_command(cmd)
+    end
+    raise InvalidParametersException, 'Command not found' if c.nil?
+
+    command = c
+    argv = args.dup
+    argv.delete(cmd)
+
+    request_data = {}
+    request = command[:request]
+    unless argv.empty?
+      # options
+      unless c[:options].nil?
+        command = c[:options].select { |o| o[:cmd] == argv[0] }.first
+        raise InvalidParametersException.new('Invalid parameters found.', c) if command.nil? || command.empty?
+
+        argv.delete_at(0)
+        request = command[:request]
+      end
+      fill_cmd_args(command[:args], argv, request, request_data)
+    end
+    raise InvalidParametersException.new('Invalid command or parameters.', c) if request.nil?
+
+    validate_command(command, request_data)
+    # 
+    {
+      cmd: c[:cmd],
+      request: request,
+      data:  request_data
+    }
+  end
+
+  # args = command[:args]
+  # argv = ARGV.dup - cmd
+  # request = command[:request]
+  # request_data = {}
+  def fill_cmd_args(args, argv, request, request_data)
+    return if args.nil?
+    # add to schema
+    args.each do |arg|
+      arg[:type] = 'value' unless arg[:type]
+    end
+    # flag and options
+    fill_flag_and_options_args(args, argv, request, request_data)
+    idx = 0
+    args.each do |arg|
+      if arg[:type].to_sym == :value
+        request_data[arg[:name].to_sym] = argv[idx]
+        fill_params_and_uri(arg, request)
+      end
+
+      idx += 1
+    end
+  end
+
+  def fill_flag_and_options_args(args, argv, request, request_data)
+    # flags
+    # checking flags first, avoids -n -f, with -f being the value of -n
+    args.select { |arg| arg[:type].to_sym == :flag }.each do |arg|
+      idx = find_option_or_flag_index(arg, argv)
+      if idx
+        fill_params_and_uri(arg, request)
+        argv.delete_at(idx)
+        request_data[arg[:name].to_sym] = arg[:param]
+      end
+    end
+    # options
+    args.select { |arg| arg[:type].to_sym == :option }.each do |arg|
+      idx = find_option_or_flag_index(arg, argv)
+      if idx
+        fill_params_and_uri(arg, request)
+        argv.delete_at(idx)
+        request_data[arg[:name].to_sym] = argv[idx]
+      end
+    end
+  end
+
+  def find_option_or_flag_index(arg, argv)
+    idx = nil
+    arg[:switch].each { | switch |
+      idx ||= argv.index(switch)
+    }
+    idx
+  end
+
+  def fill_params_and_uri(arg, request)
+    request[:uri] = request[:uri] + arg[:uri] unless arg[:uri].nil?
+    unless arg[:param].nil?
+      request[:params] ||= []
+      request[:params] << [ "#{arg[:name]}", "#{arg[:param]}"]
+    end
+  end
+
+  def validate_command(command, request_data)
+    return if command[:args].nil?
+
+    command[:args].select { |arg| arg[:mandatory] == true }.each do |arg|
+      if request_data[arg[:name].to_sym].nil?
+        raise InvalidParametersException.new("Missing mandatory parameter: #{arg[:name]}", command)
+      end
+    end
+    request_data.select{|key, value| value.nil? }.each do |key, value|
+      raise InvalidParametersException.new("Missing parameter value for #{key}", command)
+    end
+  end
+
+  def find_command(cmd)
+    dict.select { |k| k[:cmd] == cmd }.first
+  end
+
+  def doIt(args)
+    result = parse_args(args)
+    puts result
+  rescue InvalidParametersException => e
+    help(cause: e)
+  end
+
+  def format_arg_help_msg(arg)
+    _format(arg[:help][0], arg[:help][1])
+  end
+
+  def format_cmd_help_msg(command)
+    _format(command[:cmd], command[:help])
+  end
+
+  def _format(arg1, srg2)
+    format("%-12s %s\n", arg1, srg2)
+  end
+
+  def help(cause: nil, cmd: nil)
+    msg = ''
+    if cause.nil?
+      my_cmd = cmd
+    else
+      msg += "MKIt: #{cause.message}\n"
+      my_cmd = cause.command
+    end
+    if my_cmd.nil?
+      msg += "\nUsage: mkit <command> [options]\n\n"
+      msg += "Micro k8s on Ruby - a simple tool to mimic a (very) minimalistic k8 cluster\n\n"
+      msg += "Commands:\n\n"
+      dict.each do |c|
+        msg += format_cmd_help_msg(c)
+      end
+      msg += "\n"
+      msg += "Run ' mkit help <command>' for specific command information.\n\n"
+    else
+      # todo mkit help profile set
+      msg += format("\nUsage: mkit %s %s\n\n", my_cmd[:cmd], my_cmd[:usage].nil? ? '' : my_cmd[:usage].join(' '))
+      msg += format("%s\n", my_cmd[:help])
+      if !my_cmd[:options].nil? || !my_cmd[:args].nil?
+        msg += "\nOptions:\n"
+        # command
+        unless my_cmd[:options].nil?
+          my_cmd[:options].each  do |c|
+            msg += format_cmd_help_msg(c)
+          end
+        end
+        # args
+        unless my_cmd[:args].nil?
+          # values only first
+          cmd_args = my_cmd[:args].select{ |arg| (arg[:type].nil? || arg[:type].to_sym == :value) && !arg[:help].nil?}
+          cmd_args.each do |arg|
+            msg += format_arg_help_msg(arg)
+          end
+          cmd_args = my_cmd[:args].select{ |arg| !arg[:type].nil? && (arg[:type].to_sym == :option || arg[:type].to_sym == :flag)}
+          cmd_args.each  do |arg|
+            msg += format_arg_help_msg(arg)
+          end
+        end
+      end
+      msg += "\n"
+    end
+    puts msg
+    exit 1
+  end
+
+end
+

data/lib/mkit/client/commands.yaml

@@ -0,0 +1,203 @@
+---
+- cmd: init
+  help: init mkit client
+  request: {}
+- cmd: ps
+  usage:
+    - "[service_id_or_name]"
+  help: show services status (alias for status)
+  args:
+    - name: id
+      help:
+        - id
+        - Service id or name
+      mandatory: false
+      uri: "/<%=id%>"
+  request:
+    verb: get
+    uri: "/services"
+- cmd: status
+  usage:
+    - "[service_id_or_name]"
+  help: show services status
+  args:
+    - name: id
+      help:
+        - id
+        - Service id or name
+      mandatory: false
+      uri: "/<%=id%>"
+  request:
+    verb: get
+    uri: "/services"
+- cmd: start
+  usage:
+    - "<service_id_or_name>"
+  help: start service
+  args:
+    - name: id
+      help:
+        - id
+        - Service id or name
+      mandatory: true
+  request:
+    verb: put
+    uri: "/services/<%=id%>/start"
+- cmd: stop
+  usage:
+    - "<service_id_or_name>"
+  help: stop service
+  args:
+    - name: id
+      help:
+        - id
+        - Service id or name
+      mandatory: true
+  request:
+    verb: put
+    uri: "/services/<%=id%>/stop"
+- cmd: restart
+  usage:
+    - "<service_id_or_name>"
+  help: restart service
+  args:
+    - name: id
+      help:
+        - id
+        - Service id or name
+      mandatory: true
+  request:
+    verb: put
+    uri: "/services/<%=id%>/restart"
+- cmd: create
+  usage:
+    - "<service.yaml>"
+  help: create new service
+  args:
+    - name: file
+      help:
+        - file
+        - Service definition
+      mandatory: true
+  request:
+    verb: post
+    uri: "/services"
+- cmd: update
+  usage:
+    - "<service.yaml>"
+  help: update service
+  args:
+    - name: file
+      help:
+        - file
+        - Service definition
+      mandatory: true
+  request:
+    verb: put
+    uri: "/services/<%=id%>"
+- cmd: rm
+  usage:
+    - "<service_id_or_name>"
+  help: remove service
+  args:
+    - name: id
+      help:
+        - id
+        - Service id or name
+      mandatory: true
+  request:
+    verb: delete
+    uri: "/services/<%=id%>"
+- cmd: logs
+  usage:
+    - "<service_id_or_name> [-f] [-n <lines>]"
+  help: view service logs
+  request:
+    verb: ws # new type
+    uri: "/services/<%=id%>/logs"
+  args:
+    - name: id
+      mandatory: true
+      # uri: "/<%=id%>" # if exists, add it to main
+      type: value # option | flag | value # option takes a value, flag does not takes a value, value is like id_or_name
+      help:
+        - id
+        - Service id or name
+    - name: follow
+      help:
+        - -f
+        - Follow log output
+      mandatory: false
+      param: "<%=true%>" # templated. param ou uri - param -> add query parameter name=param_value
+      type: flag
+      switch:
+        - "-f"
+    - name: nr_lines
+      help:
+        - -n <lines>
+        - Number of lines to show from the end of the logs
+      mandatory: false
+      param: "<%=nr_lines%>"
+      type: option
+      switch:
+        - "-n"
+    - name: pods
+      help:
+        - -p <[pods]>
+        - Show logs for specified logs, e.g. pod1, pod2 (default first)
+      mandatory: false
+      param: "<%=pods%>"
+      type: option
+      switch:
+        - "-n"
+- cmd: version
+  help: prints mkit server version
+  request:
+    verb: get
+    uri: "/mkit/version"
+- cmd: proxy
+  usage:
+    - "<start|stop|restart|status>"
+  help: haproxy status and control
+  options:
+    - cmd: start
+      help: start proxy service
+      request:
+        verb: put
+        uri: "/mkit/proxy/start"
+    - cmd: stop
+      help: stop proxy service
+      request:
+        verb: put
+        uri: "/mkit/proxy/stop"
+    - cmd: restart
+      help: restarts proxy service
+      request:
+        verb: put
+        uri: "/mkit/proxy/restart"
+    - cmd: status
+      help: proxy service status
+      request:
+        verb: get
+        uri: "/mkit/proxy/status"
+- cmd: profile
+  usage:
+    - "<[set <profile_name>]|[show]>"
+  help: mkit client configuration profile
+  options:
+    - cmd: set
+      help: set mkit client configuration profile
+      usage:
+        - "<profile>"
+      request:
+        verb: set
+      args:
+        - name: profile
+          help:
+            - profile
+            - profile name
+          mandatory: true
+    - cmd: show
+      help: show mkit client current profile
+      request:
+        verb: show

data/lib/mkit/client/http_client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'net/http'
+require 'json'
+require 'net_http_unix'
+require 'securerandom'
+require 'erb'
+require 'uri'
+require 'fileutils'
+
+module MKIt
+  class HttpClient
+    def initialize(server_url, my_id)
+      @server_url = server_url
+      @my_id = my_id
+    end
+
+    #
+    # http client
+    #
+
+    def client(req)
+      req['X-API-KEY'] = @my_id
+      uri = URI(@server_url)
+      case uri.scheme
+      when 'https'
+        @client = NetX::HTTPUnix.new(uri.host, uri.port)
+        @client.use_ssl = true
+        @client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      when 'http'
+        @client = NetX::HTTPUnix.new(uri.host, uri.port)
+      when 'sock'
+        @client = NetX::HTTPUnix.new("unix://#{uri.path}")
+      else
+        raise InvalidParametersException, 'Invalid mkit server uri. Please check configuration'
+      end
+      @client.request(req)
+    end
+
+    def request(request, request_data = nil)
+      req = nil
+      uri = request[:uri]
+      request[:file] = request_data[:file]
+
+      unless request[:params].nil? || request[:params].empty?
+        uri = uri + '?' + request[:params].map { |k, v| "#{k}=#{v}" }.join('&')
+      end
+      uri = ERB.new(uri).result_with_hash(request_data)
+      case request[:verb].to_sym
+      when :post
+        req = Net::HTTP::Post.new(uri)
+        unless request[:file].nil?
+          (body, boundary) = attach(request[:file])
+          req.body = body
+          req['Content-Type'] = "multipart/form-data, boundary=#{boundary}"
+        end
+      when :put
+        req = Net::HTTP::Put.new(uri)
+        unless request[:file].nil?
+          (body, boundary) = attach(request[:file])
+          req.body = body
+          req['Content-Type'] = "multipart/form-data, boundary=#{boundary}"
+        end
+      when :patch
+        req = Net::HTTP::Patch.new(uri)
+      when :get
+        req = Net::HTTP::Get.new(uri)
+      when :delete
+        req = Net::HTTP::Delete.new(uri)
+      when :ws
+
+      end
+      client(req).body
+    end
+
+    def attach(file)
+      boundary = SecureRandom.alphanumeric
+      body = []
+      body << "--#{boundary}\r\n"
+      body << "Content-Disposition: form-data; name=file; filename='#{File.basename(file)}'\r\n"
+      body << "Content-Type: text/plain\r\n"
+      body << "\r\n"
+      body << File.read(file)
+      body << "\r\n--#{boundary}--\r\n"
+      [body.join, boundary]
+    end
+
+  end
+end

data/lib/mkit/client/mkitd_client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'mkit/client/http_client'
+require 'mkit/client/websocket_client'
+
+module MKIt
+  class MKItdClient
+    def initialize(request, server_url, my_id)
+      case request[:verb].to_sym
+      when :ws
+        @client = MKIt::WebSocketClient.new(server_url, my_id)
+      else
+        @client = MKIt::HttpClient.new(server_url, my_id)
+      end
+    end
+
+    def request(request, request_data)
+      @client.request(request, request_data)
+    end 
+  end
+end
+

data/lib/mkit/client/websocket_client.rb

@@ -0,0 +1,68 @@
+# # frozen_string_literal: true
+require 'faye/websocket'
+require 'eventmachine'
+require 'json'
+
+module MKIt
+  class WebSocketClient
+    def initialize(server_url, my_id)
+      @server_url = server_url
+      @my_id = my_id
+      uri = URI(@server_url)
+      use_ssl = uri.scheme == 'https'
+      @options = use_ssl ? { tls: { :verify_peer => false } } : {}
+      @options[:headers] = { 'X-API-KEY' => @my_id }
+      url_prefix = use_ssl ? "wss" : "ws"
+      @ws_url = "#{url_prefix}://#{uri.host}:#{uri.port}"
+      trap("SIGINT") do
+        puts "Bye..."
+        EventMachine.stop
+      end
+    end
+
+    def request(request, request_data)
+      uri = request[:uri]
+      unless request[:params].nil? || request[:params].empty?
+        uri = uri + '?' + request[:params].map { |k, v| "#{k}=#{v}" }.join('&')
+      end
+      uri = ERB.new("#{@ws_url}#{uri}").result_with_hash(request_data)
+      
+      EM.run {
+        ws = Faye::WebSocket::Client.new(uri, nil, @options) 
+
+        ws.on :open do |event|
+          # no op
+        end
+
+        ws.on :message do |event|
+          puts event.data
+        end
+
+        ws.on :error do |event|
+          p [:error, event.message]
+          ws = nil
+          return
+        end
+
+        ws.on :close do |event|
+          ws = nil
+          EventMachine.stop
+        end
+
+        Thread.new do
+          loop do
+            input = STDIN.gets.chomp
+            if input == 'exit'
+              puts "bye..."
+              EventMachine.stop
+              break
+            end
+          end
+        end
+      }
+    end
+  end
+end
+
+
+

data/lib/mkit/cmd/shell_client.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module MKIt
+  class ExitShell < RuntimeError; end
+
+  class ShellClient
+    def initialize(command:)
+      @command = command
+      @logger = MKItLogger
+      @logger.debug("Command initialized: [#{@command}]")
+    end
+
+    def unregister
+      @logger.info("ending [#{@command}]...")
+      if @client
+        begin
+          @client.raise ExitShell.new
+        rescue
+          @logger.error("Failed to raise ExitShell")
+        end
+        @client.exit rescue @logger.warn("Failed to exit client thread")
+      end
+    end
+
+    def close
+      # no op
+    end
+
+    def register
+      @client = Thread.new {
+        begin
+          PTY.spawn( @command ) do |stdout, stdin, pid |
+            begin
+              yield stdout, stdin, pid if block_given?
+            rescue Errno::EIO
+              @logger.warn(
+                "Errno:EIO error, but this probably just means that the process has finished giving output"
+              )
+            rescue ExitShell
+              @logger.info("#{@command} ended")
+            ensure
+              stdin.close rescue @logger.warn("Failed to close stdin")
+              stdout.close rescue @logger.warn("Failed to close stdout")
+              begin
+                close
+              rescue => e
+                @logger.warn("Error closing client", e)
+              end
+              Process.wait(pid)
+            end
+          end
+        rescue PTY::ChildExited
+          @logger.info("#{@command} exited.")
+        end
+      }
+    end
+  end
+end

data/lib/mkit/docker_listener.rb

@@ -1,5 +1,6 @@
 require 'pty'
 require 'mkit/status'
+require "mkit/cmd/shell_client"
 
 #
 # https://docs.docker.com/engine/reference/commandline/events
@@ -12,6 +13,7 @@ class StopThread < RuntimeError; end
 
     def initialize
       @queue = Queue.new
+      @listener = ShellClient.new(command: "docker events --format '{{json .}}'")
     end
 
     def enqueue(msg)
@@ -20,11 +22,11 @@ class StopThread < RuntimeError; end
 
     def start
       @consumer.run if register_consumer
-      @listener.run if register_listener
+      register_listener
     end
 
     def stop
-      @listener.exit if @listener
+      @listener.unregister if @listener
       @consumer.raise StopThread.new
       MKItLogger.info("docker listener stopped")
     end
@@ -107,25 +109,9 @@ class StopThread < RuntimeError; end
     end
 
     def register_listener
-      return false unless @listener.nil?
-
-      @listener = Thread.new {
-        cmd = "docker events --format '{{json .}}'"
-        begin
-          PTY.spawn( cmd ) do |stdout, stdin, pid|
-            begin
-              stdout.each { |line| enqueue JSON.parse(line).to_o }
-            rescue Errno::EIO
-              MKItLogger.warn("Errno:EIO error, but this probably just means " +
-                "that the process has finished giving output")
-            end
-          end
-        rescue PTY::ChildExited
-          MKItLogger.warn("docker event listener process exited!")
-        end
-      }
-      MKItLogger.info("docker listener started")
-      true
+      @listener.register do |stdout, stdin, pid|
+        stdout.each { |line| enqueue JSON.parse(line).to_o }
+      end
     end
   end
 end