Class: Thrift::JsonProtocol

Inherits:
BaseProtocol show all
Defined in:
lib/thrift/protocol/json_protocol.rb

Instance Attribute Summary

Attributes inherited from BaseProtocol

#trans

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from BaseProtocol

#native?, #read_type, #skip, #write_field, #write_type

Constructor Details

#initialize(trans) ⇒ JsonProtocol

Returns a new instance of JsonProtocol.



149
150
151
152
153
154
 
# File 'lib/thrift/protocol/json_protocol.rb', line 149

def initialize(trans)
  super(trans)
  @context = JSONContext.new
  @contexts = Array.new
  @reader = LookaheadReader.new(trans)
end

Class Method Details

.read_syntax_char(reader, ch) ⇒ Object

Read 1 character from the trans and verify that it is the expected character ch. Throw a protocol exception if it is not.



221
222
223
224
225
226
 
# File 'lib/thrift/protocol/json_protocol.rb', line 221

def self.read_syntax_char(reader, ch)
  ch2 = reader.read
  if (ch2 != ch)
    raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected \'#{ch}\' got \'#{ch2}\'.")
  end
end

Instance Method Details

#get_type_id_for_type_name(name) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/thrift/protocol/json_protocol.rb', line 185

def get_type_id_for_type_name(name)
  if (name == "tf")
    result = Types::BOOL
  elsif (name == "i8")
    result = Types::BYTE
  elsif (name == "i16")
    result = Types::I16
  elsif (name == "i32")
    result = Types::I32
  elsif (name == "i64")
    result = Types::I64
  elsif (name == "dbl")
    result = Types::DOUBLE
  elsif (name == "str")
    result = Types::STRING
  elsif (name == "rec")
    result = Types::STRUCT
  elsif (name == "map")
    result = Types::MAP
  elsif (name == "set")
    result = Types::SET
  elsif (name == "lst")
    result = Types::LIST
  else
    result = Types::STOP
  end
  if (result == Types::STOP)
    raise NotImplementedError
  end
  return result
end

#get_type_name_for_type_id(id) ⇒ Object 



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/thrift/protocol/json_protocol.rb', line 156

def get_type_name_for_type_id(id)
  case id
  when Types::BOOL
    "tf"
  when Types::BYTE
    "i8"
  when Types::I16
    "i16"
  when Types::I32
    "i32"
  when Types::I64
    "i64"
  when Types::DOUBLE
    "dbl"
  when Types::STRING
    "str"
  when Types::STRUCT
    "rec"
  when Types::MAP
    "map"
  when Types::SET
    "set"
  when Types::LIST
    "lst"
  else
    raise NotImplementedError
  end
end

#is_json_numeric(ch) ⇒ Object

Return true if the character ch is in [-+0-9.Ee]; false otherwise



229
230
231
232
233
234
235
236
 
# File 'lib/thrift/protocol/json_protocol.rb', line 229

def is_json_numeric(ch)
  case ch
  when '+', '-', '.', '0' .. '9', 'E', "e"
    return true
  else
    return false
  end
end

#pop_context ⇒ Object 



243
244
245
 
# File 'lib/thrift/protocol/json_protocol.rb', line 243

def pop_context
  @context = @contexts.pop
end

#push_context(context) ⇒ Object 



238
239
240
241
 
# File 'lib/thrift/protocol/json_protocol.rb', line 238

def push_context(context)
  @contexts.push(@context)
  @context = context
end

#read_binary ⇒ Object 



756
757
758
 
# File 'lib/thrift/protocol/json_protocol.rb', line 756

def read_binary
  read_json_base64
end

#read_bool ⇒ Object 



727
728
729
730
 
# File 'lib/thrift/protocol/json_protocol.rb', line 727

def read_bool
  byte = read_byte
  byte != 0
end

#read_byte ⇒ Object 



732
733
734
 
# File 'lib/thrift/protocol/json_protocol.rb', line 732

def read_byte
  read_json_integer
end

#read_double ⇒ Object 



748
749
750
 
# File 'lib/thrift/protocol/json_protocol.rb', line 748

def read_double
  read_json_double
end

#read_field_begin ⇒ Object 



678
679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/thrift/protocol/json_protocol.rb', line 678

def read_field_begin
  # Check if we hit the end of the list
  ch = @reader.peek
  if (ch == @@kJSONObjectEnd)
    field_type = Types::STOP
  else
    field_id = read_json_integer
    read_json_object_start
    field_type = get_type_id_for_type_name(read_json_string)
  end
  [nil, field_type, field_id]
end

#read_field_end ⇒ Object 



691
692
693
 
# File 'lib/thrift/protocol/json_protocol.rb', line 691

def read_field_end
  read_json_object_end
end

#read_i16 ⇒ Object 



736
737
738
 
# File 'lib/thrift/protocol/json_protocol.rb', line 736

def read_i16
  read_json_integer
end

#read_i32 ⇒ Object 



740
741
742
 
# File 'lib/thrift/protocol/json_protocol.rb', line 740

def read_i32
  read_json_integer
end

#read_i64 ⇒ Object 



744
745
746
 
# File 'lib/thrift/protocol/json_protocol.rb', line 744

def read_i64
  read_json_integer
end

#read_json_array_end ⇒ Object 



645
646
647
648
649
 
# File 'lib/thrift/protocol/json_protocol.rb', line 645

def read_json_array_end
  read_json_syntax_char(@@kJSONArrayEnd)
  pop_context
  nil
end

#read_json_array_start ⇒ Object 



638
639
640
641
642
643
 
# File 'lib/thrift/protocol/json_protocol.rb', line 638

def read_json_array_start
  @context.read(@reader)
  read_json_syntax_char(@@kJSONArrayStart)
  push_context(JSONListContext.new)
  nil
end

#read_json_base64 ⇒ Object

Reads a block of base64 characters, decoding it, and returns via str



545
546
547
 
# File 'lib/thrift/protocol/json_protocol.rb', line 545

def read_json_base64
  read_json_string.unpack("m")[0]
end

#read_json_double ⇒ Object

Reads a JSON number or string and interprets it as a double.



587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
 
# File 'lib/thrift/protocol/json_protocol.rb', line 587

def read_json_double
  @context.read(@reader)
  num = 0
  if (@reader.peek == @@kJSONStringDelimiter)
    str = read_json_string(true)
    # Check for NaN, Infinity and -Infinity
    if (str == @@kThriftNan)
      num = (+1.0/0.0)/(+1.0/0.0)
    elsif (str == @@kThriftInfinity)
      num = +1.0/0.0
    elsif (str == @@kThriftNegativeInfinity)
      num = -1.0/0.0
    else
      if (!@context.escapeNum)
        # Raise exception -- we should not be in a string in this case
        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Numeric data unexpectedly quoted")
      end
      begin
        num = Float(str)
      rescue
        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
      end
    end
  else
    if (@context.escapeNum)
      # This will throw - we should have had a quote if escapeNum == true
      read_json_syntax_char(@@kJSONStringDelimiter)
    end
    str = read_json_numeric_chars
    begin
      num = Float(str)
    rescue
      raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
    end
  end
  return num
end

#read_json_escape_char ⇒ Object

Decodes the four hex parts of a JSON escaped string character and returns the character via out.

Note - this only supports Unicode characters in the BMP (U+0000 to U+FFFF); characters above the BMP are encoded as two escape sequences (surrogate pairs), which is not yet implemented



491
492
493
494
495
496
497
498
499
500
501
 
# File 'lib/thrift/protocol/json_protocol.rb', line 491

def read_json_escape_char
  str = @reader.read
  str += @reader.read
  str += @reader.read
  str += @reader.read
  if RUBY_VERSION >= '1.9'
    str.hex.chr(Encoding::UTF_8)
  else
    str.hex.chr
  end
end

#read_json_integer ⇒ Object

Reads a sequence of characters and assembles them into a number, returning them via num



566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
 
# File 'lib/thrift/protocol/json_protocol.rb', line 566

def read_json_integer
  @context.read(@reader)
  if (@context.escapeNum)
    read_json_syntax_char(@@kJSONStringDelimiter)
  end
  str = read_json_numeric_chars

  begin
    num = Integer(str);
  rescue
    raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
  end

  if (@context.escapeNum)
    read_json_syntax_char(@@kJSONStringDelimiter)
  end

  return num
end

#read_json_numeric_chars ⇒ Object

Reads a sequence of characters, stopping at the first one that is not a valid JSON numeric character.



551
552
553
554
555
556
557
558
559
560
561
562
 
# File 'lib/thrift/protocol/json_protocol.rb', line 551

def read_json_numeric_chars
  str = ""
  while (true)
    ch = @reader.peek
    if (!is_json_numeric(ch))
      break;
    end
    ch = @reader.read
    str += ch
  end
  return str
end

#read_json_object_end ⇒ Object 



632
633
634
635
636
 
# File 'lib/thrift/protocol/json_protocol.rb', line 632

def read_json_object_end
  read_json_syntax_char(@@kJSONObjectEnd)
  pop_context
  nil
end

#read_json_object_start ⇒ Object 



625
626
627
628
629
630
 
# File 'lib/thrift/protocol/json_protocol.rb', line 625

def read_json_object_start
  @context.read(@reader)
  read_json_syntax_char(@@kJSONObjectStart)
  push_context(JSONPairContext.new)
  nil
end

#read_json_string(skipContext = false) ⇒ Object

Decodes a JSON string, including unescaping, and returns the string via str



504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
 
# File 'lib/thrift/protocol/json_protocol.rb', line 504

def read_json_string(skipContext = false)
  # This string's characters must match up with the elements in escape_char_vals.
  # I don't have '/' on this list even though it appears on www.json.org --
  # it is not in the RFC
  escape_chars = "\"\\bfnrt"

  # The elements of this array must match up with the sequence of characters in
  # escape_chars
  escape_char_vals = [
    '"', '\\', '\b', '\f', '\n', '\r', '\t',
  ]

  if !skipContext
    @context.read(@reader)
  end
  read_json_syntax_char(@@kJSONStringDelimiter)
  ch = ""
  str = ""
  while (true)
    ch = @reader.read
    if (ch == @@kJSONStringDelimiter)
      break
    end
    if (ch == @@kJSONBackslash)
      ch = @reader.read
      if (ch == 'u')
        ch = read_json_escape_char
      else
        pos = escape_chars.index(ch);
        if (pos.nil?) # not found
          raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected control char, got \'#{ch}\'.")
        end
        ch = escape_char_vals[pos]
      end
    end
    str += ch
  end
  return str
end

#read_json_syntax_char(ch) ⇒ Object

Reads 1 byte and verifies that it matches ch.



481
482
483
 
# File 'lib/thrift/protocol/json_protocol.rb', line 481

def read_json_syntax_char(ch)
  JsonProtocol::read_syntax_char(@reader, ch)
end

#read_list_begin ⇒ Object 



709
710
711
712
 
# File 'lib/thrift/protocol/json_protocol.rb', line 709

def read_list_begin
  read_json_array_start
  [get_type_id_for_type_name(read_json_string), read_json_integer]
end

#read_list_end ⇒ Object 



714
715
716
 
# File 'lib/thrift/protocol/json_protocol.rb', line 714

def read_list_end
  read_json_array_end
end

#read_map_begin ⇒ Object 



695
696
697
698
699
700
701
702
 
# File 'lib/thrift/protocol/json_protocol.rb', line 695

def read_map_begin
  read_json_array_start
  key_type = get_type_id_for_type_name(read_json_string)
  val_type = get_type_id_for_type_name(read_json_string)
  size = read_json_integer
  read_json_object_start
  [key_type, val_type, size]
end

#read_map_end ⇒ Object 



704
705
706
707
 
# File 'lib/thrift/protocol/json_protocol.rb', line 704

def read_map_end
  read_json_object_end
  read_json_array_end
end

#read_message_begin ⇒ Object 



651
652
653
654
655
656
657
658
659
660
661
 
# File 'lib/thrift/protocol/json_protocol.rb', line 651

def read_message_begin
  read_json_array_start
  version = read_json_integer
  if (version != @@kThriftVersion1)
    raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Message contained bad version.')
  end
  name = read_json_string
  message_type = read_json_integer
  seqid = read_json_integer
  [name, message_type, seqid]
end

#read_message_end ⇒ Object 



663
664
665
666
 
# File 'lib/thrift/protocol/json_protocol.rb', line 663

def read_message_end
  read_json_array_end
  nil
end

#read_set_begin ⇒ Object 



718
719
720
721
 
# File 'lib/thrift/protocol/json_protocol.rb', line 718

def read_set_begin
  read_json_array_start
  [get_type_id_for_type_name(read_json_string), read_json_integer]
end

#read_set_end ⇒ Object 



723
724
725
 
# File 'lib/thrift/protocol/json_protocol.rb', line 723

def read_set_end
  read_json_array_end
end

#read_string ⇒ Object 



752
753
754
 
# File 'lib/thrift/protocol/json_protocol.rb', line 752

def read_string
  read_json_string
end

#read_struct_begin ⇒ Object 



668
669
670
671
 
# File 'lib/thrift/protocol/json_protocol.rb', line 668

def read_struct_begin
  read_json_object_start
  nil
end

#read_struct_end ⇒ Object 



673
674
675
676
 
# File 'lib/thrift/protocol/json_protocol.rb', line 673

def read_struct_end
  read_json_object_end
  nil
end

#write_binary(str) ⇒ Object 



472
473
474
 
# File 'lib/thrift/protocol/json_protocol.rb', line 472

def write_binary(str)
  write_json_base64(str)
end

#write_bool(bool) ⇒ Object 



444
445
446
 
# File 'lib/thrift/protocol/json_protocol.rb', line 444

def write_bool(bool)
  write_json_integer(bool ? 1 : 0)
end

#write_byte(byte) ⇒ Object 



448
449
450
 
# File 'lib/thrift/protocol/json_protocol.rb', line 448

def write_byte(byte)
  write_json_integer(byte)
end

#write_double(dub) ⇒ Object 



464
465
466
 
# File 'lib/thrift/protocol/json_protocol.rb', line 464

def write_double(dub)
  write_json_double(dub)
end

#write_field_begin(name, type, id) ⇒ Object 



399
400
401
402
403
 
# File 'lib/thrift/protocol/json_protocol.rb', line 399

def write_field_begin(name, type, id)
  write_json_integer(id)
  write_json_object_start
  write_json_string(get_type_name_for_type_id(type))
end

#write_field_end ⇒ Object 



405
406
407
 
# File 'lib/thrift/protocol/json_protocol.rb', line 405

def write_field_end
  write_json_object_end
end

#write_field_stop ⇒ Object 



409
 
# File 'lib/thrift/protocol/json_protocol.rb', line 409

def write_field_stop; nil; end

#write_i16(i16) ⇒ Object 



452
453
454
 
# File 'lib/thrift/protocol/json_protocol.rb', line 452

def write_i16(i16)
  write_json_integer(i16)
end

#write_i32(i32) ⇒ Object 



456
457
458
 
# File 'lib/thrift/protocol/json_protocol.rb', line 456

def write_i32(i32)
  write_json_integer(i32)
end

#write_i64(i64) ⇒ Object 



460
461
462
 
# File 'lib/thrift/protocol/json_protocol.rb', line 460

def write_i64(i64)
  write_json_integer(i64)
end

#write_json_array_end ⇒ Object 



374
375
376
377
 
# File 'lib/thrift/protocol/json_protocol.rb', line 374

def write_json_array_end
  pop_context
  trans.write(@@kJSONArrayEnd)
end

#write_json_array_start ⇒ Object 



368
369
370
371
372
 
# File 'lib/thrift/protocol/json_protocol.rb', line 368

def write_json_array_start
  @context.write(trans)
  trans.write(@@kJSONArrayStart)
  push_context(JSONListContext.new);
end

#write_json_base64(str) ⇒ Object

Write out the contents of the string as JSON string, base64-encoding the string’s contents, and escaping as appropriate



307
308
309
310
311
312
 
# File 'lib/thrift/protocol/json_protocol.rb', line 307

def write_json_base64(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  write_json_string([str].pack("m"))
  trans.write(@@kJSONStringDelimiter)
end

#write_json_char(ch) ⇒ Object

Write the character ch as part of a JSON string, escaping as appropriate.



258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/thrift/protocol/json_protocol.rb', line 258

def write_json_char(ch)
  # This table describes the handling for the first 0x30 characters
  # 0 : escape using "\u00xx" notation
  # 1 : just output index
  # <other> : escape using "\<other>" notation
  kJSONCharTable = [
      # 0 1 2 3 4 5 6 7 8 9 A B C D E F
      0, 0, 0, 0, 0, 0, 0, 0,'b','t','n', 0,'f','r', 0, 0, # 0
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 1
      1, 1,'"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, # 2
  ]

  ch_value = ch[0]
  if (ch_value.kind_of? String)
    ch_value = ch.bytes.first
  end
  if (ch_value >= 0x30)
    if (ch == @@kJSONBackslash) # Only special character >= 0x30 is '\'
      trans.write(@@kJSONBackslash)
      trans.write(@@kJSONBackslash)
    else
      trans.write(ch)
    end
  else
    outCh = kJSONCharTable[ch_value];
    # Check if regular character, backslash escaped, or JSON escaped
    if outCh.kind_of? String
      trans.write(@@kJSONBackslash)
      trans.write(outCh)
    elsif outCh == 1
      trans.write(ch)
    else
      write_json_escape_char(ch)
    end
  end
end

#write_json_double(num) ⇒ Object

Convert the given double to a JSON string, which is either the number, “NaN” or “Infinity” or “-Infinity”.



330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'lib/thrift/protocol/json_protocol.rb', line 330

def write_json_double(num)
  @context.write(trans)
  # Normalize output of boost::lexical_cast for NaNs and Infinities
  special = false;
  if (num.nan?)
    special = true;
    val = @@kThriftNan;
  elsif (num.infinite?)
    special = true;
    val = @@kThriftInfinity;
    if (num < 0.0)
      val = @@kThriftNegativeInfinity;
    end
  else
    val = num.to_s
  end

  escapeNum = special || @context.escapeNum
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
  trans.write(val)
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
end

#write_json_escape_char(ch) ⇒ Object

Write the character ch as a JSON escape sequence (“u00xx”)



248
249
250
251
252
253
254
255
 
# File 'lib/thrift/protocol/json_protocol.rb', line 248

def write_json_escape_char(ch)
  trans.write('\\u')
  ch_value = ch[0]
  if (ch_value.kind_of? String)
    ch_value = ch.bytes.first
  end
  trans.write(ch_value.to_s(16).rjust(4,'0'))
end

#write_json_integer(num) ⇒ Object

Convert the given integer type to a JSON number, or a string if the context requires it (eg: key in a map pair).



316
317
318
319
320
321
322
323
324
325
326
 
# File 'lib/thrift/protocol/json_protocol.rb', line 316

def write_json_integer(num)
  @context.write(trans)
  escapeNum = @context.escapeNum
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
  trans.write(num.to_s);
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
end

#write_json_object_end ⇒ Object 



363
364
365
366
 
# File 'lib/thrift/protocol/json_protocol.rb', line 363

def write_json_object_end
  pop_context
  trans.write(@@kJSONObjectEnd)
end

#write_json_object_start ⇒ Object 



357
358
359
360
361
 
# File 'lib/thrift/protocol/json_protocol.rb', line 357

def write_json_object_start
  @context.write(trans)
  trans.write(@@kJSONObjectStart)
  push_context(JSONPairContext.new);
end

#write_json_string(str) ⇒ Object

Write out the contents of the string str as a JSON string, escaping characters as appropriate.



296
297
298
299
300
301
302
303
 
# File 'lib/thrift/protocol/json_protocol.rb', line 296

def write_json_string(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  str.split('').each do |ch|
    write_json_char(ch)
  end
  trans.write(@@kJSONStringDelimiter)
end

#write_list_begin(etype, size) ⇒ Object 



424
425
426
427
428
 
# File 'lib/thrift/protocol/json_protocol.rb', line 424

def write_list_begin(etype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(etype))
  write_json_integer(size)
end

#write_list_end ⇒ Object 



430
431
432
 
# File 'lib/thrift/protocol/json_protocol.rb', line 430

def write_list_end
  write_json_array_end
end

#write_map_begin(ktype, vtype, size) ⇒ Object 



411
412
413
414
415
416
417
 
# File 'lib/thrift/protocol/json_protocol.rb', line 411

def write_map_begin(ktype, vtype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(ktype))
  write_json_string(get_type_name_for_type_id(vtype))
  write_json_integer(size)
  write_json_object_start
end

#write_map_end ⇒ Object 



419
420
421
422
 
# File 'lib/thrift/protocol/json_protocol.rb', line 419

def write_map_end
  write_json_object_end
  write_json_array_end
end

#write_message_begin(name, type, seqid) ⇒ Object 



379
380
381
382
383
384
385
 
# File 'lib/thrift/protocol/json_protocol.rb', line 379

def write_message_begin(name, type, seqid)
  write_json_array_start
  write_json_integer(@@kThriftVersion1)
  write_json_string(name)
  write_json_integer(type)
  write_json_integer(seqid)
end

#write_message_end ⇒ Object 



387
388
389
 
# File 'lib/thrift/protocol/json_protocol.rb', line 387

def write_message_end
  write_json_array_end
end

#write_set_begin(etype, size) ⇒ Object 



434
435
436
437
438
 
# File 'lib/thrift/protocol/json_protocol.rb', line 434

def write_set_begin(etype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(etype))
  write_json_integer(size)
end

#write_set_end ⇒ Object 



440
441
442
 
# File 'lib/thrift/protocol/json_protocol.rb', line 440

def write_set_end
  write_json_array_end
end

#write_string(str) ⇒ Object 



468
469
470
 
# File 'lib/thrift/protocol/json_protocol.rb', line 468

def write_string(str)
  write_json_string(str)
end

#write_struct_begin(name) ⇒ Object 



391
392
393
 
# File 'lib/thrift/protocol/json_protocol.rb', line 391

def write_struct_begin(name)
  write_json_object_start
end

#write_struct_end ⇒ Object 



395
396
397
 
# File 'lib/thrift/protocol/json_protocol.rb', line 395

def write_struct_end
  write_json_object_end
end