mkit 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ce73321371e8f675a5c28106e9287762ed5cf8b39ecfc8c97b35f62806a45c1
-  data.tar.gz: 21189b10e952913a03d50498201869010fef447f4b621a5f3e2f39a1ab12c94c
+  metadata.gz: f85d1f4b78a2859ecf2646e493cb8f65a379143cf4ec7ac1928e1fd184f58fe6
+  data.tar.gz: e8af8e1747b6a5488f1980c57a13947965d4b8762aa8f8a276bcffd5583a7a5f
 SHA512:
-  metadata.gz: e38e72898702d11bf928534444a63fe1744b3af47494c4da7789ece5c01cb611b824e716cc7cc39454c738d730da5533393aefea8801da236ecce97d9b291f3e
-  data.tar.gz: 2e2d930ef466b48fbb75b07dbf12586cb41e0324a043eed2f334b9d4a638ba9369f6d65f85ca6c24d4573d8076dacfb26d43bc166de465212df8dbda3ee4edae
+  metadata.gz: 5818402f2e7403254e749a9b69588ab99c944639e652eb7a5b66df35e71c921c4f98c7767bee10fb9dc23d6b3ea6871a86cc948962b73bff3cba80417fc26fc4
+  data.tar.gz: 2d592b0ee76177beefd71a0d0b0965d229548d638e2207e54b013633055482ebad3226c641a464138103c56adf3084ec38a7706ae35ad3cf27282647975ee31e

data/Gemfile

@@ -1,23 +1,4 @@
 # frozen_string_literal: true
 
 source 'https://rubygems.org'
-
-# ruby '3.0.2'
-
-gem 'dry-container'
-gem 'net-ping'
-gem 'rake'
-gem 'sqlite3'
-gem 'standalone_migrations'
-gem 'text-table'
-
-gem 'async-dns'
-gem 'pry'
-gem 'rack', '>= 2.0.6'
-gem 'rubydns'
-gem 'sinatra-activerecord'
-# rest http server
-gem 'net_http_unix' # socket client
-gem 'sinatra'
-gem 'thin' # socket server
-# gem 'puma'
+gemspec

data/README.md

@@ -183,21 +183,21 @@ Micro k8s on Ruby - a simple tool to mimic a (very) minimalistic k8 cluster
 
 Commands:
 
-init       init mkit client
-ps         show services status (alias for status)
-status     show services status
-logs       prints service logs
-start      start service
-stop       stop service
-restart    restart service
-create     create new service
-update     update service
-rm         remove service
-version    prints mkit server version
-proxy      haproxy status and control
-profile    mkit client configuration profile
-
-Run 'mkit help <command>' for specific command information.
+init         init mkit client
+ps           show services status (alias for status)
+status       show services status
+start        start service
+stop         stop service
+restart      restart service
+create       create new service
+update       update service
+rm           remove service
+logs         view service logs
+version      prints mkit server version
+proxy        haproxy status and control
+profile      mkit client configuration profile
+
+Run ' mkit help <command>' for specific command information.
 ```
 
 Example:

data/bin/mkit

@@ -11,8 +11,10 @@ require 'securerandom'
 require 'erb'
 require 'uri'
 require 'fileutils'
+require 'mkit/client/command_parser'
+require 'mkit/client/mkitd_client'
 
-class InvalidParametersException < Exception
+class InvalidConfigurationException < Exception
   attr_reader :command
 
   def initialize(cause, command = nil)
@@ -21,164 +23,19 @@ class InvalidParametersException < Exception
   end
 end
 
-class CommandPalette
-  def schema
-    global_args = [
-      { short: '-v', long: '--verbose', help: 'verbose', mandatory: false, value: nil }
-    ]
-    [
-      {
-        cmd: 'init',
-        help: 'init mkit client',
-        request: { }
-      },
-      {
-        cmd: 'ps',
-        args: [
-          { name: 'id', mandatory: false, uri: '/<%=id%>' }
-        ],
-        help: 'show services status (alias for status)',
-        usage: ['[service_id_or_name]'],
-        request: { verb: :get, uri: '/services' }
-      },
-      {
-        cmd: 'status',
-        args: [
-          { name: 'id', mandatory: false, uri: '/<%=id%>' }
-        ],
-        help: 'show services status',
-        usage: ['[service_id_or_name]'],
-        request: { verb: :get, uri: '/services' }
-      },
-      {
-        cmd: 'logs',
-        args: [
-          { name: 'id', mandatory: true }
-        ],
-        help: 'prints service logs',
-        usage: ['<service_id_or_name>'],
-        request: { verb: :get, uri: '/services/<%=id%>/logs' }
-      },
-      {
-        cmd: 'start',
-        args: [
-          { name: 'id', mandatory: true }
-        ],
-        help: 'start service',
-        usage: ['<service_id_or_name>'],
-        request: { verb: :put, uri: '/services/<%=id%>/start' }
-      },
-      {
-        cmd: 'stop',
-        args: [
-          { name: 'id', mandatory: true }
-        ],
-        help: 'stop service',
-        usage: ['<service_id_or_name>'],
-        request: { verb: :put, uri: '/services/<%=id%>/stop' }
-      },
-      {
-        cmd: 'restart',
-        args: [
-          { name: 'id', mandatory: true }
-        ],
-        help: 'restart service',
-        usage: ['<service_id_or_name>'],
-        request: { verb: :put, uri: '/services/<%=id%>/restart' }
-      },
-      {
-        cmd: 'create',
-        args: [
-          { name: 'file', mandatory: true }
-        ],
-        help: 'create new service',
-        usage: ['<service.yaml>'],
-        request: { verb: :post, uri: '/services' }
-      },
-      {
-        cmd: 'update',
-        args: [
-          { name: 'file', mandatory: true }
-        ],
-        help: 'update service',
-        usage: ['<service.yaml>'],
-        request: { verb: :put, uri: '/services/<%=id%>' }
-      },
-      {
-        cmd: 'rm',
-        args: [
-          { name: 'id', mandatory: true }
-        ],
-        help: 'remove service',
-        usage: ['<service_id_or_name>'],
-        request: { verb: :delete, uri: '/services/<%=id%>' }
-      },
-      {
-        cmd: 'version',
-        help: 'prints mkit server version',
-        request: { verb: :get, uri: '/mkit/version' }
-      },
-      {
-        cmd: 'proxy',
-        options: [
-          {
-            cmd: 'start',
-            request: { verb: :put, uri: '/mkit/proxy/start' },
-            help: 'start proxy service'
-          },
-          {
-            cmd: 'stop',
-            request: { verb: :put, uri: '/mkit/proxy/stop' },
-            help: 'stop proxy service'
-          },
-          {
-            cmd: 'restart',
-            request: { verb: :put, uri: '/mkit/proxy/restart' },
-            help: 'restarts proxy service'
-          },
-          {
-            cmd: 'status',
-            request: { verb: :get, uri: '/mkit/proxy/status' },
-            help: 'proxy service status'
-          }
-        ],
-        help: 'haproxy status and control',
-        usage: ['<start|stop|restart|status>']
-      },
-      {
-        cmd: 'profile',
-        options: [
-          {
-            cmd: 'set',
-            request: { verb: 'set' },
-            args: [
-              { name: 'profile_name', mandatory: true }
-            ],
-            help: 'set mkit client configuration profile'
-          },
-          {
-            cmd: 'show',
-            request: { verb: 'show' },
-            help: 'show mkit client current profile'
-          }
-        ],
-        help: 'mkit client configuration profile',
-        usage: ['<[set <profile_name>]|[show]>']
-      }
-    ]
-  end
-end
-
 class MKItClient
   def initialize
     @root = File.expand_path('..', __dir__)
     @config_dir = "#{ENV['HOME']}/.mkit"
     @profile_file = "#{@config_dir}/current"
-    @commands = CommandPalette.new
     @config_file = "#{@config_dir}/mkitc_config.yml"
+    @parser = CommandParser.new
     create_default_config
   end
 
+  # 
+  # client config
+  #
   def create_default_config
     unless File.exist?(@config_dir)
       puts "Creating config directory on '#{@config_dir}'..."
@@ -203,187 +60,41 @@ class MKItClient
 
     @configuration = cfg['mkit'][current_profile.lstrip]
     if !init_call && cfg['my_id'].nil?
-      raise InvalidParametersException.new("Please run ' mkit init' to initialize mkit client.", find_command('init'))
+      raise InvalidParametersException.new("Please run ' mkit init' to initialize mkit client.", @parser.find_command('init'))
     end
     @my_id = cfg['my_id']
     cfg
   end
 
-  def client(req)
+  #
+  # doIt
+  #
+  def doIt(argv)
     read_configuration
-    req['X-API-KEY'] = @my_id
-    uri = URI(@configuration['server.uri'])
-    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 dict
-    @commands.schema
-  end
-
-  def find_command(cmd)
-    dict.select { |k| k[:cmd] == cmd }.first
-  end
-
-  def parse_args(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
-    myargs = args.dup
-    myargs.delete(cmd)
-
-    request_hash = {}
-    request = command[:request]
-    unless myargs.empty?
-      # options
-      unless c[:options].nil?
-        command = c[:options].select { |o| o[:cmd] == myargs[0] }.first
-        raise InvalidParametersException.new('Invalid parameters found.', c) if command.nil? || command.empty?
-
-        myargs.delete_at(0)
-        request = command[:request]
-      end
-      fill_cmd_args(command[:args], myargs, request, request_hash)
-    end
-    raise InvalidParametersException.new('Invalid command or parameters.', c) if request.nil?
-
-    validate_command(command, request_hash)
-    if respond_to? c[:cmd]
-      send(c[:cmd], request, request_hash)
-    else
-      request(request, request_hash)
-    end
-  end
-
-  def fill_cmd_args(args, myargs, request, request_hash)
-    return if args.nil?
-
-    idx = 0
-    args.each do |a|
-      request_hash[a[:name].to_sym] = myargs[idx]
-      request[:uri] = request[:uri] + a[:uri] unless a[:uri].nil?
-      idx += 1
-    end
-  end
-
-  def validate_command(command, request_hash)
-    return if command[:args].nil?
-
-    command[:args].select { |a| a[:mandatory] == true }.each do |a|
-      if request_hash[a[:name].to_sym].nil?
-        raise InvalidParametersException.new("Missing mandatory parameter: #{a[:name]}", command)
-      end
-    end
-  end
-
-  def request(request, request_args = nil)
-    req = nil
-    uri = ERB.new(request[:uri]).result_with_hash(request_args)
-    request[:file] = request_args[:file]
-
-    unless request[:params].nil? || request[:params].empty?
-      uri = uri + '?' + request[:params].map { |k, v| "#{k}=#{v}" }.join('&')
-    end
-    case request[:verb]
-    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)
-    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
-
-  def doIt(args)
-    result = parse_args(args)
+    request = @parser.parse(argv)
+    result = execute(request)
     puts result
   rescue InvalidParametersException => e
-    help(cause: e)
+    @parser.help(cause: e)
   end
 
-  def help(cause: nil, cmd: nil)
-    msg = ''
-    if cause.nil?
-      my_cmd = cmd
-    else
-      msg += "MKItc: #{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("%-10s %s\n", c[:cmd], c[:help])
-      end
-      msg += "\n"
-      msg += "Run ' mkit help <command>' for specific command information.\n\n"
+  def execute(request)
+    if respond_to? request[:cmd]
+      send(request[:cmd], request[:request], request[:data])
     else
-      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])
-      unless my_cmd[:options].nil?
-        msg += "\nOptions:\n"
-        my_cmd[:options].each  do |c|
-          msg += format("%-10s %s\n", c[:cmd], c[:help])
-        end
-      end
-      msg += "\n"
+      request(request[:request], request[:data])
     end
-    puts msg
-    exit 1
   end
 
-  def init(request, request_hash = nil)
+  def request(request, request_data)
+    client = MKIt::MKItdClient.new(request, @configuration['server.uri'], @my_id)
+    client.request(request, request_data)
+  end
+
+  #
+  # commands
+  #
+  def init(request, request_data = nil)
     cfg = read_configuration(true)
     if cfg['my_id'].nil?
       my_id = SecureRandom.uuid.gsub('-','')
@@ -395,37 +106,38 @@ class MKItClient
     end
     puts "Your api-key is #{my_id}"
   end
-  def create(request, request_hash = nil)
-    unless File.file?(request_hash[:file])
-      raise InvalidParametersException.new('File not found.', find_command('create'))
+
+  def create(request, request_data = nil)
+    unless File.file?(request_data[:file])
+      raise InvalidParametersException.new('File not found.', @parser.find_command('create'))
     end
 
-    yaml = YAML.load_file(request_hash[:file])
+    yaml = YAML.load_file(request_data[:file])
     if yaml['service'].nil?
-      raise InvalidParametersException.new('Invalid configuration file', find_command('create'))
+      raise InvalidParametersException.new('Invalid configuration file', @parser.find_command('create'))
     else
-      request(request, request_hash)
+      request(request, request_data)
     end
   end
 
-  def update(request, request_hash = nil)
-    unless File.file?(request_hash[:file])
-      raise InvalidParametersException.new('File not found.', find_command('update'))
+  def update(request, request_data = nil)
+    unless File.file?(request_data[:file])
+      raise InvalidParametersException.new('File not found.', @parser.find_command('update'))
     end
 
-    yaml = YAML.load_file(request_hash[:file])
+    yaml = YAML.load_file(request_data[:file])
     if yaml['service'].nil?
-      raise InvalidParametersException.new('Invalid configuration file', find_command('update'))
+      raise InvalidParametersException.new('Invalid configuration file', @parser.find_command('update'))
     else
       id = yaml['service']['name']
-      request_hash[:id] = id
-      request(request, request_hash)
+      request_data[:id] = id
+      request(request, request_data)
     end
   end
 
-  def profile(request, request_hash = {})
+  def profile(request, request_data = {})
     cfg = YAML.load_file("#{@config_dir}/mkitc_config.yml")
-    cmd = find_command('profile')
+    cmd = @parser.find_command('profile')
     if cfg['mkit'].nil?
       raise InvalidParametersException.new(
         "Invalid configuration on '~/.mkit'\nPlease fix or clean up for defaults apply", cmd
@@ -434,13 +146,13 @@ class MKItClient
 
     case request[:verb]
     when 'set'
-      profile = request_hash[:profile_name]
+      profile = request_data[:profile_name]
       if cfg['mkit'][profile.lstrip].nil?
         raise InvalidParametersException.new("Profile not found on '~/.mkit' configuration", cmd)
       end
 
       puts "Setting current profile to #{profile}."
-      File.write(@profile_file, request_hash[:profile_name])
+      File.write(@profile_file, request_data[:profile_name])
       ''
     when 'show'
       active = File.read("#{@config_dir}/current")

data/lib/mkit/app/controllers/pods_controller.rb

@@ -18,12 +18,6 @@ class PodsController < MKIt::Server
   end
 
   post '/services/:service_id/pods' do
-    xx = 'no file'
-    if params[:file]
-      tempfile = params[:file][:tempfile]
-      xx = YAML.safe_load(tempfile.read)
-      puts xx
-    end
-    JSON.pretty_generate(JSON.parse(xx.to_json))
+    "Not implemented\n"
   end
 end

data/lib/mkit/app/controllers/services_controller.rb

@@ -2,6 +2,7 @@
 
 require 'mkit/app/model/service'
 require 'mkit/app/helpers/services_helper'
+require 'mkit/docker_log_listener'
 
 class ServicesController < MKIt::Server
   helpers MKIt::ServicesHelper
@@ -33,7 +34,33 @@ class ServicesController < MKIt::Server
 
   get '/services/:id/logs' do
     srv = find_by_id_or_name
-    srv.log
+    if !request.websocket?
+      srv.log
+    else
+      options_parameter = build_options_hash(params: params, options: [:nr_lines, :pods, :follow])
+      request.websocket do |ws|
+        listener = nil
+        ws.onopen do
+          settings.sockets << ws
+          ws.send("<<<< %s | %s >>>>\n" % [srv.name, srv.pod.first.name])
+          listener = MKIt::DockerLogListener.new(srv.pod.first, ws, options: options_parameter)
+          settings.listeners << listener
+          listener.register
+        end
+        ws.onmessage do |msg|
+          puts msg
+        end
+        ws.onclose do
+          MKItLogger.info("websocket closed [#{listener}]")
+          settings.sockets.delete(ws)
+          if listener
+            MKItLogger.info("unregister [#{listener}]")
+            settings.listeners.delete(listener)
+            listener.unregister
+          end
+        end
+      end
+    end
   end
 
   # curl -X PUT localhost:4567/services/1  -F "file=@mkit/samples/mkit.yml"

data/lib/mkit/app/helpers/services_helper.rb

@@ -16,6 +16,13 @@ module MKIt
       table.to_s
     end
 
+    def build_options_hash(params:, options:)
+      hash = {}
+      options.each do |option|
+        hash[option] = params[option]
+      end
+      hash
+    end
     def find_by_id_or_name
       srv = Service.find_by_id(params[:id])
       srv ||= Service.find_by_name(params[:id])

data/lib/mkit/app/mkit_server.rb

@@ -8,6 +8,8 @@ module MKIt
     set :dump_errors, true
     set :show_exceptions, false
     set :raise_errors, false
+    set :sockets, []
+    set :listeners, []
 
     before do
       api_key = request.env['HTTP_X_API_KEY']

data/lib/mkit/app/model/service.rb

@@ -241,7 +241,6 @@ class Service < ActiveRecord::Base
     out = ""
     self.pod.each { |p|
       out << "<<<< %s | %s >>>>\n" % [self.name, p.name]
-      puts logs(p.name)
       out << logs(p.name)
     }
     out