knot-ruby/lib/knot/protocol.rb

245 lines
5.6 KiB
Ruby

require 'iounpack'
require 'stringio'
require_relative 'errors'
module Knot
class Protocol
end
end
module Knot::Protocol::Type
def [] code
case code
when 0, End then return End
when 1, Data then return Data
when 2, Extra then return Extra
when 3, Block then return Block
end
end
class Base
def self.expect_data?
false
end
def expect_data?() self.class.expect_data? end
def code() self.class.code end
end
class End < Base
def self.code() 0 end
end
class Data < Base
def code() 1 end
def expect_data?
true
end
attr_reader :data
def initialize data
@data = data
end
end
class Extra < Base
def code() 2 end
def expect_data?
true
end
attr_reader :data
def initialize data
@data = data
end
end
class Block < Base
def code() 3 end
end
end
#class Knot::KnotC
# attr_accessor :debug, :binary
#
# def initialize path = nil, binary: nil
# @path = path
# @binary = binary || 'knotc'
# @conf = Knot::Conf.new self
# @zones = Hash.new {|h, zone| h[zone] = Knot::Zone.new zone, self }
# end
#
# def call command:, flags: nil, section: nil, item: nil, id: nil, zone: nil, owner: nil, ttl: nil, type: nil, data: nil, filter: nil
# cs =
# case command.to_s
# when 'conf-begin', 'conf-commit', 'conf-abort', 'status', 'stop', 'reload'
# [@binary, command, ]
# else raise ArgumentError, "Unknown Command: #{command}"
# end
# end
#end
module Knot::Protocol::Idx
class Id
include Comparable
attr_reader :name, :code, :cname, :description
def initialize name, code, cname, description
raise ArgumentError, "Expecting Symbol for Idx::Id instead of: #{name.inspect}" if Symbol === name
raise ArgumentError, "Expecting Integer for Idx::Id instead of: #{code.inspect}" if Integer === code
@name, @code, @cname, @description = name, code, cname, description
freeze
end
def === x
case x
when self.class then self == x
when Symbol then @name == x
when String then @name == x.to_sym
when Integer then @code == x
else nil
end
end
def <=>( x) @id <=> x.id end
def to_s() @name.to_s end
def to_sym() @name end
def to_i() @code end
end
Idx = [
Id.new( :command, 0x10, :CMD, 'Control command name.'),
Id.new( :flags, 0x11, :FLAGS, 'Control command flags.'),
Id.new( :error, 0x12, :ERROR, 'Error message.'),
Id.new( :section, 0x13, :SECTION, 'Configuration section name.'),
Id.new( :item, 0x14, :ITEM, 'Configuration item name.'),
Id.new( :id, 0x15, :ID, 'Congiguration item identifier.'),
Id.new( :zone, 0x16, :ZONE, 'Zone name.'),
Id.new( :owner, 0x17, :OWNER, 'Zone record owner'),
Id.new( :ttl, 0x18, :TTL, 'Zone record TTL.'),
Id.new( :type, 0x19, :TYPE, 'Zone record type name.'),
Id.new( :data, 0x1a, :DATA, 'Configuration item/zone record data.'),
Id.new( :filter, 0x1b, :FILTER, 'An option or a filter for output data processing.'),
]
Name = {}
Code = {}
Idx.each do |id|
Code[id.to_i] = id
Name[id.to_sym] = id
end
class <<self
def [] k
case k
when Symbol
Name[k] or raise Knot::Errors::EINVAL, "Unknown Idx: #{k}"
when Integer
Code[k] or raise Knot::Errors::EINVAL, "Unknown Idx: #{k}"
else
raise ArgumentError, "Unknown Idx-Type: #{k}"
end
end
def each &exe
block_given? ? Idx.each( &exe) : Idx.to_enum( :each)
end
end
end
class Knot::Protocol
attr_reader :sock, :conf, :zones
attr_accessor :debug
def initialize path_or_sock = nil
case path_or_sock
when String, Pathname
@sock = UNIXSocket.new path_or_sock.to_s
when Socket
@sock = path_or_sock
when nil
@sock = UNIXSocket.new '/run/knot/knot.sock'
end
@debug = false
@conf = Knot::Conf.new self
@zones = Hash.new {|h, zone| h[zone] = Knot::Zone.new zone, self }
end
def snd sock: nil, **data
rsock = sock || @sock
s = ''.b
sock = StringIO.new s
sock.write [1].pack( 'c')
data[:flags] ||= ''
Idx::Idx.each_with_index do |n, i|
v = data[n]&.to_s
sock.write [0x10+i, v.size, v].pack( 'c na*') if v
end
sock.write [3].pack( 'c')
sock.flush
STDERR.puts( {send: data, _: s}.inspect) if @debug
rsock.write s
rsock.flush
end
class RecordIO
attr_reader :str
def initialize sock, str = nil
@str, @sock = str || ''.b, sock
end
def unpack pattern
IOUnpack.new( pattern).unpack self
end
def unpack1 pattern
IOUnpack.new( pattern).unpack1 self
end
def read n
s = @sock.read n
@str.insert -1, s
s
end
end
def rcv sock: nil
ret, r = [], nil
sock = sock || @sock
sock = RecordIO.new sock if @debug
loop do
t = sock.unpack1 'c'
case t
when 0, 3
return ret
when 1, 2
type = t
ret.push( r = {})
else
raise Knot::Errors::EINVAL, "Missing Type before: #{t}" if ret.empty?
i = Idx::Idx[t - 0x10] or raise Knot::Errors::EINVAL, "Unknown index: #{t-0x10}"
l = sock.unpack1 'n'
r[i] = sock.read( l)
end
end
ensure
STDERR.puts( {rcvd: ret, _: sock.str}.inspect) if @debug
ret
end
def call sock: nil, **data
snd sock: sock, **data
rcv( sock: sock).each do |r|
if r[:error]
if e = Knot::Errors.err2exc[r[:error]]
raise e, r[:error]
end
raise Knot::Error, r[:error]
end
end
end
def zone( zone) @zones[zone.to_s.to_sym] end
def conf_set( **opts) call **opts.update( command: 'conf-set') end
def conf_unset( **opts) call **opts.update( command: 'conf-unset') end
def zone_set( **opts) call **opts.update( command: 'zone-set') end
def zone_unset( **opts) call **opts.update( command: 'zone-unset') end
def zone_get( **opts) call **opts.update( command: 'zone-get') end
end