bytemark/flexnbd-c
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rubocop

Browse Source
This commit is contained in:
Patrick J Cherry
2018-02-02 21:34:14 +00:00
parent 1b7b688f7a
commit 9c48da82cc
40 changed files with 666 additions and 858 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
tests/acceptance/flexnbd/constants.rb
View File

@@ -1,10 +1,7 @@
# encoding: utf-8
module FlexNBD
def self.binary( str )
def self.binary(str)
if str.respond_to? :force_encoding
str.force_encoding "ASCII-8BIT"
str.force_encoding 'ASCII-8BIT'
else
str
end
@@ -13,36 +10,33 @@ module FlexNBD
# eeevil is his one and only name...
def self.read_constants
parents = []
current = File.expand_path(".")
while current != "/"
current = File.expand_path('.')
while current != '/'
parents << current
current = File.expand_path( File.join( current, ".." ) )
current = File.expand_path(File.join(current, '..'))
end
source_root = parents.find do |dirname|
File.directory?( File.join( dirname, "src" ) )
File.directory?(File.join(dirname, 'src'))
end
fail "No source root!" unless source_root
raise 'No source root!' unless source_root
headers = Dir[File.join( source_root, "src", "{common,proxy,server}","*.h" ) ]
headers = Dir[File.join(source_root, 'src', '{common,proxy,server}', '*.h')]
headers.each do |header_filename|
txt_lines = File.readlines( header_filename )
txt_lines = File.readlines(header_filename)
txt_lines.each do |line|
if line =~ /^#\s*define\s+([A-Z0-9_]+)\s+(\d+)\s*$/
# Bodge until I can figure out what to do with #ifdefs
const_set($1, $2.to_i) unless const_defined?( $1 )
const_set(Regexp.last_match(1), Regexp.last_match(2).to_i) unless const_defined?(Regexp.last_match(1))
end
end
end
end
read_constants()
read_constants
REQUEST_MAGIC = binary("\x25\x60\x95\x13") unless defined?(REQUEST_MAGIC)
REPLY_MAGIC = binary("\x67\x44\x66\x98") unless defined?(REPLY_MAGIC)
end # module FlexNBD

116
tests/acceptance/flexnbd/fake_dest.rb
View File

@@ -1,5 +1,3 @@
# encoding: utf-8
require 'socket'
require 'timeout'
@@ -7,114 +5,104 @@ require 'flexnbd/constants'
module FlexNBD
class FakeDest
class Client
def initialize( sock )
def initialize(sock)
@sock = sock
end
def write_hello( opts = {} )
@sock.write( "NBDMAGIC" )
def write_hello(opts = {})
@sock.write('NBDMAGIC')
if opts[:magic] == :wrong
write_rand( @sock, 8 )
write_rand(@sock, 8)
else
@sock.write( "\x00\x00\x42\x02\x81\x86\x12\x53" )
@sock.write("\x00\x00\x42\x02\x81\x86\x12\x53")
end
if opts[:size] == :wrong
write_rand( @sock, 8 )
write_rand(@sock, 8)
else
@sock.write( "\x00\x00\x00\x00\x00\x00\x10\x00" )
@sock.write("\x00\x00\x00\x00\x00\x00\x10\x00")
end
@sock.write( "\x00" * 128 )
@sock.write("\x00" * 128)
end
def write_rand( sock, len )
len.times do sock.write( rand(256).chr ) end
def write_rand(sock, len)
len.times { sock.write(rand(256).chr) }
end
def read_request()
def read_request
req = @sock.read(28)
magic_s = req[0 ... 4 ]
type_s = req[4 ... 8 ]
handle_s = req[8 ... 16]
from_s = req[16 ... 24]
len_s = req[24 ... 28]
magic_s = req[0...4]
type_s = req[4...8]
handle_s = req[8...16]
from_s = req[16...24]
len_s = req[24...28]
{
:magic => magic_s,
:type => type_s.unpack("N").first,
:handle => handle_s,
:from => self.class.parse_be64( from_s ),
:len => len_s.unpack( "N").first
magic: magic_s,
type: type_s.unpack('N').first,
handle: handle_s,
from: self.class.parse_be64(from_s),
len: len_s.unpack('N').first
}
end
def write_error( handle )
write_reply( handle, 1 )
def write_error(handle)
write_reply(handle, 1)
end
def disconnected?
begin
Timeout.timeout(2) do
@sock.read(1) == nil
end
rescue Timeout::Error
return false
Timeout.timeout(2) do
@sock.read(1).nil?
end
rescue Timeout::Error
return false
end
def write_reply( handle, err=0, opts={} )
def write_reply(handle, err = 0, opts = {})
if opts[:magic] == :wrong
write_rand( @sock, 4 )
write_rand(@sock, 4)
else
@sock.write( ::FlexNBD::REPLY_MAGIC )
@sock.write(::FlexNBD::REPLY_MAGIC)
end
@sock.write( [err].pack("N") )
@sock.write( handle )
@sock.write([err].pack('N'))
@sock.write(handle)
end
def close
@sock.close
end
def read_data( len )
@sock.read( len )
def read_data(len)
@sock.read(len)
end
def write_data( len )
@sock.write( len )
def write_data(len)
@sock.write(len)
end
def self.parse_be64(str)
raise "String is the wrong length: 8 bytes expected (#{str.length} received)" unless
str.length == 8
top, bottom = str.unpack("NN")
top, bottom = str.unpack('NN')
(top << 32) + bottom
end
def receive_mirror( opts = {} )
write_hello()
def receive_mirror(opts = {})
write_hello
loop do
req = read_request
case req[:type]
when 1
read_data( req[:len] )
write_reply( req[:handle] )
when 65536
write_reply( req[:handle], opts[:err] == :entrust ? 1 : 0 )
read_data(req[:len])
write_reply(req[:handle])
when 65_536
write_reply(req[:handle], opts[:err] == :entrust ? 1 : 0)
break
else
raise "Unexpected request: #{req.inspect}"
@@ -129,16 +117,13 @@ module FlexNBD
raise "Not a disconnect: #{req.inspect}"
end
end
end # class Client
def initialize( addr, port )
@sock = TCPServer.new( addr, port )
def initialize(addr, port)
@sock = TCPServer.new(addr, port)
end
def accept( err_msg = "Timed out waiting for a connection", timeout = 5)
def accept(err_msg = 'Timed out waiting for a connection', timeout = 5)
client_sock = nil
begin
@@ -146,21 +131,16 @@ module FlexNBD
client_sock = @sock.accept
end
rescue Timeout::Error
raise Timeout::Error.new(err_msg)
raise Timeout::Error, err_msg
end
client_sock
Client.new( client_sock )
Client.new(client_sock)
end
def close
@sock.close
end
end # module FakeDest
end # module FlexNBD

129
tests/acceptance/flexnbd/fake_source.rb
View File

@@ -1,29 +1,25 @@
# encoding: utf-8
require 'socket'
require "timeout"
require 'timeout'
require 'flexnbd/constants'
module FlexNBD
class FakeSource
def initialize( addr, port, err_msg, source_addr=nil, source_port=0 )
timing_out( 2, err_msg ) do
def initialize(addr, port, err_msg, source_addr = nil, source_port = 0)
timing_out(2, err_msg) do
begin
@sock = if source_addr
TCPSocket.new( addr, port, source_addr, source_port )
TCPSocket.new(addr, port, source_addr, source_port)
else
TCPSocket.new( addr, port )
TCPSocket.new(addr, port)
end
rescue Errno::ECONNREFUSED
$stderr.puts "Connection refused, retrying"
warn 'Connection refused, retrying'
sleep(0.2)
retry
end
end
end
def close
@sock.close
end
@@ -31,8 +27,8 @@ module FlexNBD
def read_hello
timing_out(::FlexNBD::MS_HELLO_TIME_SECS,
'Timed out waiting for hello.') do
fail 'No hello.' unless (hello = @sock.read(152)) &&
hello.length == 152
raise 'No hello.' unless (hello = @sock.read(152)) &&
hello.length == 152
passwd_s = hello[0..7]
magic = hello[8..15].unpack('Q>').first
@@ -44,97 +40,86 @@ module FlexNBD
end
end
def send_request(type, handle = 'myhandle', from = 0, len = 0, magic = REQUEST_MAGIC)
raise 'Bad handle' unless handle.length == 8
def send_request( type, handle="myhandle", from=0, len=0, magic=REQUEST_MAGIC )
fail "Bad handle" unless handle.length == 8
@sock.write( magic )
@sock.write( [type].pack( 'N' ) )
@sock.write( handle )
@sock.write( [n64( from )].pack( 'q' ) )
@sock.write( [len].pack( 'N' ) )
@sock.write(magic)
@sock.write([type].pack('N'))
@sock.write(handle)
@sock.write([n64(from)].pack('q'))
@sock.write([len].pack('N'))
end
def write_write_request( from, len, handle="myhandle" )
send_request( 1, handle, from, len )
def write_write_request(from, len, handle = 'myhandle')
send_request(1, handle, from, len)
end
def write_entrust_request( handle="myhandle" )
send_request( 65536, handle )
def write_entrust_request(handle = 'myhandle')
send_request(65_536, handle)
end
def write_disconnect_request( handle="myhandle" )
send_request( 2, handle )
def write_disconnect_request(handle = 'myhandle')
send_request(2, handle)
end
def write_read_request( from, len, handle="myhandle" )
send_request( 0, "myhandle", from, len )
def write_read_request(from, len, _handle = 'myhandle')
send_request(0, 'myhandle', from, len)
end
def write_data( data )
@sock.write( data )
def write_data(data)
@sock.write(data)
end
# Handy utility
def read( from, len )
timing_out( 2, "Timed out reading" ) do
send_request( 0, "myhandle", from, len )
read_raw( len )
def read(from, len)
timing_out(2, 'Timed out reading') do
send_request(0, 'myhandle', from, len)
read_raw(len)
end
end
def read_raw( len )
@sock.read( len )
def read_raw(len)
@sock.read(len)
end
def send_mirror
read_hello()
write( 0, "12345678" )
read_response()
write_disconnect_request()
close()
read_hello
write(0, '12345678')
read_response
write_disconnect_request
close
end
def write( from, data )
write_write_request( from, data.length )
write_data( data )
def write(from, data)
write_write_request(from, data.length)
write_data(data)
end
def read_response
magic = @sock.read(4)
error_s = @sock.read(4)
handle = @sock.read(8)
{
:magic => magic,
:error => error_s.unpack("N").first,
:handle => handle
magic: magic,
error: error_s.unpack('N').first,
handle: handle
}
end
def disconnected?
result = nil
Timeout.timeout( 2 ) { result = ( @sock.read(1) == nil ) }
Timeout.timeout(2) { result = @sock.read(1).nil? }
result
end
def timing_out( time, msg )
begin
Timeout.timeout( time ) do
yield
end
rescue Timeout::Error
$stderr.puts msg
exit 1
def timing_out(time, msg)
Timeout.timeout(time) do
yield
end
rescue Timeout::Error
warn msg
exit 1
end
private
@@ -144,15 +129,13 @@ module FlexNBD
# )
def n64(b)
((b & 0xff00000000000000) >> 56) |
((b & 0x00ff000000000000) >> 40) |
((b & 0x0000ff0000000000) >> 24) |
((b & 0x000000ff00000000) >> 8) |
((b & 0x00000000ff000000) << 8) |
((b & 0x0000000000ff0000) << 24) |
((b & 0x000000000000ff00) << 40) |
((b & 0x00000000000000ff) << 56)
((b & 0x00ff000000000000) >> 40) |
((b & 0x0000ff0000000000) >> 24) |
((b & 0x000000ff00000000) >> 8) |
((b & 0x00000000ff000000) << 8) |
((b & 0x0000000000ff0000) << 24) |
((b & 0x000000000000ff00) << 40) |
((b & 0x00000000000000ff) << 56)
end
end # class FakeSource
end # module FlexNBD