Class: Protocol::HPACK::Compressor

Inherits:
Object
  • Object
show all
Defined in:
lib/protocol/hpack/compressor.rb

Overview

Responsible for encoding header key-value pairs using HPACK algorithm.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(buffer, context = Context.new, table_size_limit: nil) ⇒ Compressor

Returns a new instance of Compressor.



45
46
47
48
49
50
 
# File 'lib/protocol/hpack/compressor.rb', line 45

def initialize(buffer, context = Context.new, table_size_limit: nil)
  @buffer = buffer
  @context = context
  
  @table_size_limit = table_size_limit
end

Instance Attribute Details

#buffer ⇒ Object (readonly)

Returns the value of attribute buffer.



54
55
56
 
# File 'lib/protocol/hpack/compressor.rb', line 54

def buffer
  @buffer
end

#context ⇒ Object (readonly)

Returns the value of attribute context.



55
56
57
 
# File 'lib/protocol/hpack/compressor.rb', line 55

def context
  @context
end

#offset ⇒ Object (readonly)

Returns the value of attribute offset.



56
57
58
 
# File 'lib/protocol/hpack/compressor.rb', line 56

def offset
  @offset
end

#table_size_limit ⇒ Object (readonly)

Returns the value of attribute table_size_limit.



52
53
54
 
# File 'lib/protocol/hpack/compressor.rb', line 52

def table_size_limit
  @table_size_limit
end

Instance Method Details

#encode(headers, table_size = @table_size_limit) ⇒ Buffer

Encodes provided list of HTTP headers.

Parameters:

  • headers (Array) —

    [[name, value], …]

Returns:

  • (Buffer) 


173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/protocol/hpack/compressor.rb', line 173

def encode(headers, table_size = @table_size_limit)
  if table_size and table_size != @context.table_size
    command = @context.change_table_size(table_size)
    
    write_header(command)
  end
  
  commands = @context.encode(headers)
  
  commands.each do |command|
    write_header(command)
  end
  
  return @buffer
end

#huffman ⇒ Object 



93
94
95
 
# File 'lib/protocol/hpack/compressor.rb', line 93

def huffman
  @context.huffman
end

#write_bytes(bytes) ⇒ Object 



58
59
60
 
# File 'lib/protocol/hpack/compressor.rb', line 58

def write_bytes(bytes)
  @buffer << bytes
end

#write_header(command) ⇒ Buffer

Encodes header command with appropriate header representation.

Parameters:

  • h (Hash) —

    header command

  • buffer (String)

Returns:

  • (Buffer) 


144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/protocol/hpack/compressor.rb', line 144

def write_header(command)
  representation = HEADER_REPRESENTATION[command[:type]]
  
  first = @buffer.bytesize
  
  case command[:type]
  when :indexed
    write_integer(command[:name] + 1, representation[:prefix])
  when :change_table_size
    write_integer(command[:value], representation[:prefix])
  else
    if command[:name].is_a? Integer
      write_integer(command[:name] + 1, representation[:prefix])
    else
      write_integer(0, representation[:prefix])
      write_string(command[:name])
    end
    
    write_string(command[:value])
  end

  # set header representation pattern on first byte
  @buffer.setbyte(first, @buffer.getbyte(first) | representation[:pattern])
end

#write_integer(value, bits) ⇒ String

Encodes provided value via integer representation.

If I < 2^N - 1, encode I on N bits
Else
    encode 2^N - 1 on N bits
    I = I - (2^N - 1)
    While I >= 128
         Encode (I % 128 + 128) on 8 bits
         I = I / 128
    encode (I) on 8 bits

Parameters:

  • value (Integer) —

    value to encode

  • bits (Integer) —

    number of available bits

Returns:

  • (String) —

    binary string



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/protocol/hpack/compressor.rb', line 77

def write_integer(value, bits)
  limit = (1 << bits) - 1
  
  return @buffer << value if value < limit
  
  @buffer << limit unless bits.zero?
  
  value -= limit
  while value >= 128
    @buffer << ((value & 0x7f) + 128)
    value /= 128
  end
  
  @buffer << value
end

#write_string(string, huffman = self.huffman) ⇒ String

Encodes provided value via string literal representation.

  • tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-5.2

  • The string length, defined as the number of bytes needed to store its UTF-8 representation, is represented as an integer with a seven bits prefix. If the string length is strictly less than 127, it is represented as one byte.

  • If the bit 7 of the first byte is 1, the string value is represented as a list of Huffman encoded octets (padded with bit 1’s until next octet boundary).

  • If the bit 7 of the first byte is 0, the string value is represented as a list of UTF-8 encoded octets.

@options [:huffman] controls whether to use Huffman encoding:

:never   Do not use Huffman encoding
:always  Always use Huffman encoding
:shorter Use Huffman when the result is strictly shorter

Parameters:

  • string (String)

Returns:

  • (String) —

    binary string



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/protocol/hpack/compressor.rb', line 117

def write_string(string, huffman = self.huffman)
  if huffman != :never
    encoded = Huffman.encode(string)
    
    if huffman == :shorter and encoded.bytesize >= string.bytesize
      encoded = nil
    end
  end
  
  if encoded
    first = @buffer.bytesize
    
    write_integer(encoded.bytesize, 7)
    write_bytes(encoded.b)
    
    @buffer.setbyte(first, @buffer.getbyte(first).ord | 0x80)
  else
    write_integer(string.bytesize, 7)
    write_bytes(string.b)
  end
end