Class: AMQ::Protocol::Basic

Inherits:
Class
  • Object
show all
Defined in:
lib/amq/protocol/client.rb

Defined Under Namespace

Classes: Ack, Cancel, CancelOk, Consume, ConsumeOk, Deliver, Get, GetEmpty, GetOk, Nack, Publish, Qos, QosOk, Recover, RecoverAsync, RecoverOk, Reject, Return

Constant Summary collapse

PROPERTIES = 
[
  :content_type, # shortstr
  :content_encoding, # shortstr
  :headers, # table
  :delivery_mode, # octet
  :priority, # octet
  :correlation_id, # shortstr
  :reply_to, # shortstr
  :expiration, # shortstr
  :message_id, # shortstr
  :timestamp, # timestamp
  :type, # shortstr
  :user_id, # shortstr
  :app_id, # shortstr
  :cluster_id, # shortstr
]
DECODE_PROPERTIES =

THIS DECODES ONLY FLAGS

{
  0x8000 => :content_type,
  0x4000 => :content_encoding,
  0x2000 => :headers,
  0x1000 => :delivery_mode,
  0x0800 => :priority,
  0x0400 => :correlation_id,
  0x0200 => :reply_to,
  0x0100 => :expiration,
  0x0080 => :message_id,
  0x0040 => :timestamp,
  0x0020 => :type,
  0x0010 => :user_id,
  0x0008 => :app_id,
  0x0004 => :cluster_id,
}
DECODE_PROPERTIES_TYPE = 
{
  0x8000 => :shortstr,
  0x4000 => :shortstr,
  0x2000 => :table,
  0x1000 => :octet,
  0x0800 => :octet,
  0x0400 => :shortstr,
  0x0200 => :shortstr,
  0x0100 => :shortstr,
  0x0080 => :shortstr,
  0x0040 => :timestamp,
  0x0020 => :shortstr,
  0x0010 => :shortstr,
  0x0008 => :shortstr,
  0x0004 => :shortstr,
}
DECODE_PROPERTIES_KEYS =

Hash doesn’t give any guarantees on keys order, we will do it in a straightforward way

[
  0x8000,
  0x4000,
  0x2000,
  0x1000,
  0x0800,
  0x0400,
  0x0200,
  0x0100,
  0x0080,
  0x0040,
  0x0020,
  0x0010,
  0x0008,
  0x0004,
]

Class Method Summary collapse

Methods inherited from Class

classes, inherited, method_id, name

Class Method Details

.decode_properties(data) ⇒ Object 



1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
 
# File 'lib/amq/protocol/client.rb', line 1549

def self.decode_properties(data)
  offset, data_length, properties = 0, data.bytesize, {}

  compressed_index = data[offset, 2].unpack(PACK_UINT16)[0]
  offset += 2
  while data_length > offset
    DECODE_PROPERTIES_KEYS.each do |key|
      next unless compressed_index >= key
      compressed_index -= key
      name = DECODE_PROPERTIES[key] || raise(RuntimeError.new("No property found for index #{index.inspect}!"))
      case DECODE_PROPERTIES_TYPE[key]
      when :shortstr
        size = data[offset, 1].unpack(PACK_CHAR)[0]
        offset += 1
        result = data[offset, size]
      when :octet
        size = 1
        result = data[offset, size].unpack(PACK_CHAR).first
      when :timestamp
        size = 8
        result = Time.at(data[offset, size].unpack(PACK_UINT32_X2).last)
      when :table
        size = 4 + data[offset, 4].unpack(PACK_UINT32)[0]
        result = Table.decode(data[offset, size])
      end
      properties[name] = result
      offset += size
    end
  end

  properties
end

.encode_app_id(value) ⇒ Object

1 << 3



1462
1463
1464
1465
1466
1467
 
# File 'lib/amq/protocol/client.rb', line 1462

def self.encode_app_id(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [12, 0x0008, buffer]
end

.encode_cluster_id(value) ⇒ Object

1 << 2



1470
1471
1472
1473
1474
1475
 
# File 'lib/amq/protocol/client.rb', line 1470

def self.encode_cluster_id(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [13, 0x0004, buffer]
end

.encode_content_encoding(value) ⇒ Object

1 << 14



1378
1379
1380
1381
1382
1383
 
# File 'lib/amq/protocol/client.rb', line 1378

def self.encode_content_encoding(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [1, 0x4000, buffer]
end

.encode_content_type(value) ⇒ Object

1 << 15



1370
1371
1372
1373
1374
1375
 
# File 'lib/amq/protocol/client.rb', line 1370

def self.encode_content_type(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [0, 0x8000, buffer]
end

.encode_correlation_id(value) ⇒ Object

1 << 10



1407
1408
1409
1410
1411
1412
 
# File 'lib/amq/protocol/client.rb', line 1407

def self.encode_correlation_id(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [5, 0x0400, buffer]
end

.encode_delivery_mode(value) ⇒ Object

1 << 12



1393
1394
1395
1396
1397
 
# File 'lib/amq/protocol/client.rb', line 1393

def self.encode_delivery_mode(value)
  buffer = ''
  buffer << [value].pack(PACK_CHAR)
  [3, 0x1000, buffer]
end

.encode_expiration(value) ⇒ Object

1 << 8



1423
1424
1425
1426
1427
1428
 
# File 'lib/amq/protocol/client.rb', line 1423

def self.encode_expiration(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [7, 0x0100, buffer]
end

.encode_headers(value) ⇒ Object

1 << 13



1386
1387
1388
1389
1390
 
# File 'lib/amq/protocol/client.rb', line 1386

def self.encode_headers(value)
  buffer = ''
  buffer << AMQ::Protocol::Table.encode(value)
  [2, 0x2000, buffer]
end

.encode_message_id(value) ⇒ Object

1 << 7



1431
1432
1433
1434
1435
1436
 
# File 'lib/amq/protocol/client.rb', line 1431

def self.encode_message_id(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [8, 0x0080, buffer]
end

.encode_priority(value) ⇒ Object

1 << 11



1400
1401
1402
1403
1404
 
# File 'lib/amq/protocol/client.rb', line 1400

def self.encode_priority(value)
  buffer = ''
  buffer << [value].pack(PACK_CHAR)
  [4, 0x0800, buffer]
end

.encode_properties(body_size, properties) ⇒ Object 



1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
 
# File 'lib/amq/protocol/client.rb', line 1479

def self.encode_properties(body_size, properties)
  pieces, flags = [], 0

  properties.reject {|key, value| value.nil?}.each do |key, value|
    i, f, result = self.__send__(:"encode_#{key}", value)
    flags |= f
    pieces[i] = result
  end

  # result = [60, 0, body_size, flags].pack('n2Qn')
  result = [60, 0].pack(PACK_UINT16_X2)
  result += AMQ::Hacks.pack_64_big_endian(body_size)
  result += [flags].pack(PACK_UINT16)
  result + pieces.join(EMPTY_STRING)
end

.encode_reply_to(value) ⇒ Object

1 << 9



1415
1416
1417
1418
1419
1420
 
# File 'lib/amq/protocol/client.rb', line 1415

def self.encode_reply_to(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [6, 0x0200, buffer]
end

.encode_timestamp(value) ⇒ Object

1 << 6



1439
1440
1441
1442
1443
 
# File 'lib/amq/protocol/client.rb', line 1439

def self.encode_timestamp(value)
  buffer = ''
  buffer << AMQ::Hacks.pack_64_big_endian(value)
  [9, 0x0040, buffer]
end

.encode_type(value) ⇒ Object

1 << 5



1446
1447
1448
1449
1450
1451
 
# File 'lib/amq/protocol/client.rb', line 1446

def self.encode_type(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [10, 0x0020, buffer]
end

.encode_user_id(value) ⇒ Object

1 << 4



1454
1455
1456
1457
1458
1459
 
# File 'lib/amq/protocol/client.rb', line 1454

def self.encode_user_id(value)
  buffer = ''
  buffer << value.to_s.bytesize.chr
  buffer << value.to_s
  [11, 0x0010, buffer]
end