Class: Thrift::JsonProtocol

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

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(trans) ⇒ JsonProtocol

Returns a new instance of JsonProtocol.



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

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.



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

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 



184
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
 
# File 'lib/thrift/json_protocol.rb', line 184

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 



155
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
 
# File 'lib/thrift/json_protocol.rb', line 155

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



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

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

#pop_context ⇒ Object 



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

def pop_context
  @context = @contexts.pop
end

#push_context(context) ⇒ Object 



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

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

#read_binary ⇒ Object 



746
747
748
 
# File 'lib/thrift/json_protocol.rb', line 746

def read_binary
  read_json_base64
end

#read_bool ⇒ Object 



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

def read_bool
  byte = read_byte
  byte != 0
end

#read_byte ⇒ Object 



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

def read_byte
  read_json_integer
end

#read_double ⇒ Object 



738
739
740
 
# File 'lib/thrift/json_protocol.rb', line 738

def read_double
  read_json_double
end

#read_field_begin ⇒ Object 



669
670
671
672
673
674
675
676
677
678
679
680
 
# File 'lib/thrift/json_protocol.rb', line 669

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 



682
683
684
 
# File 'lib/thrift/json_protocol.rb', line 682

def read_field_end
  read_json_object_end
end

#read_i16 ⇒ Object 



726
727
728
 
# File 'lib/thrift/json_protocol.rb', line 726

def read_i16
  read_json_integer
end

#read_i32 ⇒ Object 



730
731
732
 
# File 'lib/thrift/json_protocol.rb', line 730

def read_i32
  read_json_integer
end

#read_i64 ⇒ Object 



734
735
736
 
# File 'lib/thrift/json_protocol.rb', line 734

def read_i64
  read_json_integer
end

#read_json_array_end ⇒ Object 



636
637
638
639
640
 
# File 'lib/thrift/json_protocol.rb', line 636

def read_json_array_end
  read_json_syntax_char(@@kJSONArrayEnd)
  pop_context
  nil
end

#read_json_array_start ⇒ Object 



629
630
631
632
633
634
 
# File 'lib/thrift/json_protocol.rb', line 629

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



536
537
538
 
# File 'lib/thrift/json_protocol.rb', line 536

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.



578
579
580
581
582
583
584
585
586
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
 
# File 'lib/thrift/json_protocol.rb', line 578

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. The first two characters must be “00”.



486
487
488
489
490
491
492
 
# File 'lib/thrift/json_protocol.rb', line 486

def read_json_escape_char
  read_json_syntax_char('0')
  read_json_syntax_char('0')
  str = @reader.read
  str += @reader.read
  str.hex.chr
end

#read_json_integer ⇒ Object

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



557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
 
# File 'lib/thrift/json_protocol.rb', line 557

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.



542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/thrift/json_protocol.rb', line 542

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 



623
624
625
626
627
 
# File 'lib/thrift/json_protocol.rb', line 623

def read_json_object_end
  read_json_syntax_char(@@kJSONObjectEnd)
  pop_context
  nil
end

#read_json_object_start ⇒ Object 



616
617
618
619
620
621
 
# File 'lib/thrift/json_protocol.rb', line 616

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



495
496
497
498
499
500
501
502
503
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
 
# File 'lib/thrift/json_protocol.rb', line 495

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.



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

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

#read_list_begin ⇒ Object 



700
701
702
703
 
# File 'lib/thrift/json_protocol.rb', line 700

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 



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

def read_list_end
  read_json_array_end
end

#read_map_begin ⇒ Object 



686
687
688
689
690
691
692
693
 
# File 'lib/thrift/json_protocol.rb', line 686

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 



695
696
697
698
 
# File 'lib/thrift/json_protocol.rb', line 695

def read_map_end
  read_json_object_end
  read_json_array_end
end

#read_message_begin ⇒ Object 



642
643
644
645
646
647
648
649
650
651
652
 
# File 'lib/thrift/json_protocol.rb', line 642

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 



654
655
656
657
 
# File 'lib/thrift/json_protocol.rb', line 654

def read_message_end
  read_json_array_end
  nil
end

#read_set_begin ⇒ Object 



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

def read_set_begin
  read_json_array_start
end

#read_set_end ⇒ Object 



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

def read_set_end
  read_json_array_end
end

#read_string ⇒ Object 



742
743
744
 
# File 'lib/thrift/json_protocol.rb', line 742

def read_string
  read_json_string
end

#read_struct_begin ⇒ Object 



659
660
661
662
 
# File 'lib/thrift/json_protocol.rb', line 659

def read_struct_begin
  read_json_object_start
  nil
end

#read_struct_end ⇒ Object 



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

def read_struct_end
  read_json_object_end
  nil
end

#write_binary(str) ⇒ Object 



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

def write_binary(str)
  write_json_base64(str)
end

#write_bool(bool) ⇒ Object 



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

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

#write_byte(byte) ⇒ Object 



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

def write_byte(byte)
  write_json_integer(byte)
end

#write_double(dub) ⇒ Object 



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

def write_double(dub)
  write_json_double(dub)
end

#write_field_begin(name, type, id) ⇒ Object 



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

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 



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

def write_field_end
  write_json_object_end
end

#write_field_stop ⇒ Object 



408
 
# File 'lib/thrift/json_protocol.rb', line 408

def write_field_stop; nil; end

#write_i16(i16) ⇒ Object 



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

def write_i16(i16)
  write_json_integer(i16)
end

#write_i32(i32) ⇒ Object 



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

def write_i32(i32)
  write_json_integer(i32)
end

#write_i64(i64) ⇒ Object 



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

def write_i64(i64)
  write_json_integer(i64)
end

#write_json_array_end ⇒ Object 



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

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

#write_json_array_start ⇒ Object 



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

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



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

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.



257
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
 
# File 'lib/thrift/json_protocol.rb', line 257

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”.



329
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
 
# File 'lib/thrift/json_protocol.rb', line 329

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”)



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

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).



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

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 



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

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

#write_json_object_start ⇒ Object 



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

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.



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

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 



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

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 



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

def write_list_end
  write_json_array_end
end

#write_map_begin(ktype, vtype, size) ⇒ Object 



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

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 



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

def write_map_end
  write_json_object_end
  write_json_array_end
end

#write_message_begin(name, type, seqid) ⇒ Object 



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

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 



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

def write_message_end
  write_json_array_end
end

#write_set_begin(etype, size) ⇒ Object 



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

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 



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

def write_set_end
  write_json_array_end
end

#write_string(str) ⇒ Object 



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

def write_string(str)
  write_json_string(str)
end

#write_struct_begin(name) ⇒ Object 



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

def write_struct_begin(name)
  write_json_object_start
end

#write_struct_end ⇒ Object 



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

def write_struct_end
  write_json_object_end
end