http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/distribution/src/main/scripts/interface/gen-js/Blur.js ---------------------------------------------------------------------- diff --git a/distribution/src/main/scripts/interface/gen-js/Blur.js b/distribution/src/main/scripts/interface/gen-js/Blur.js index 25aed89..bc51fd3 100644 --- a/distribution/src/main/scripts/interface/gen-js/Blur.js +++ b/distribution/src/main/scripts/interface/gen-js/Blur.js @@ -4766,6 +4766,521 @@ Blur_startTrace_result.prototype.write = function(output) { return; }; +Blur_traceList_args = function(args) { +}; +Blur_traceList_args.prototype = {}; +Blur_traceList_args.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + input.skip(ftype); + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceList_args.prototype.write = function(output) { + output.writeStructBegin('Blur_traceList_args'); + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceList_result = function(args) { + this.success = null; + this.ex = null; + if (args instanceof BlurException) { + this.ex = args; + return; + } + if (args) { + if (args.success !== undefined) { + this.success = args.success; + } + if (args.ex !== undefined) { + this.ex = args.ex; + } + } +}; +Blur_traceList_result.prototype = {}; +Blur_traceList_result.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == Thrift.Type.LIST) { + var _size364 = 0; + var _rtmp3368; + this.success = []; + var _etype367 = 0; + _rtmp3368 = input.readListBegin(); + _etype367 = _rtmp3368.etype; + _size364 = _rtmp3368.size; + for (var _i369 = 0; _i369 < _size364; ++_i369) + { + var elem370 = null; + elem370 = input.readString().value; + this.success.push(elem370); + } + input.readListEnd(); + } else { + input.skip(ftype); + } + break; + case 1: + if (ftype == Thrift.Type.STRUCT) { + this.ex = new BlurException(); + this.ex.read(input); + } else { + input.skip(ftype); + } + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceList_result.prototype.write = function(output) { + output.writeStructBegin('Blur_traceList_result'); + if (this.success !== null && this.success !== undefined) { + output.writeFieldBegin('success', Thrift.Type.LIST, 0); + output.writeListBegin(Thrift.Type.STRING, this.success.length); + for (var iter371 in this.success) + { + if (this.success.hasOwnProperty(iter371)) + { + iter371 = this.success[iter371]; + output.writeString(iter371); + } + } + output.writeListEnd(); + output.writeFieldEnd(); + } + if (this.ex !== null && this.ex !== undefined) { + output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1); + this.ex.write(output); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceRequestList_args = function(args) { + this.traceId = null; + if (args) { + if (args.traceId !== undefined) { + this.traceId = args.traceId; + } + } +}; +Blur_traceRequestList_args.prototype = {}; +Blur_traceRequestList_args.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == Thrift.Type.STRING) { + this.traceId = input.readString().value; + } else { + input.skip(ftype); + } + break; + case 0: + input.skip(ftype); + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceRequestList_args.prototype.write = function(output) { + output.writeStructBegin('Blur_traceRequestList_args'); + if (this.traceId !== null && this.traceId !== undefined) { + output.writeFieldBegin('traceId', Thrift.Type.STRING, 1); + output.writeString(this.traceId); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceRequestList_result = function(args) { + this.success = null; + this.ex = null; + if (args instanceof BlurException) { + this.ex = args; + return; + } + if (args) { + if (args.success !== undefined) { + this.success = args.success; + } + if (args.ex !== undefined) { + this.ex = args.ex; + } + } +}; +Blur_traceRequestList_result.prototype = {}; +Blur_traceRequestList_result.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == Thrift.Type.LIST) { + var _size372 = 0; + var _rtmp3376; + this.success = []; + var _etype375 = 0; + _rtmp3376 = input.readListBegin(); + _etype375 = _rtmp3376.etype; + _size372 = _rtmp3376.size; + for (var _i377 = 0; _i377 < _size372; ++_i377) + { + var elem378 = null; + elem378 = input.readString().value; + this.success.push(elem378); + } + input.readListEnd(); + } else { + input.skip(ftype); + } + break; + case 1: + if (ftype == Thrift.Type.STRUCT) { + this.ex = new BlurException(); + this.ex.read(input); + } else { + input.skip(ftype); + } + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceRequestList_result.prototype.write = function(output) { + output.writeStructBegin('Blur_traceRequestList_result'); + if (this.success !== null && this.success !== undefined) { + output.writeFieldBegin('success', Thrift.Type.LIST, 0); + output.writeListBegin(Thrift.Type.STRING, this.success.length); + for (var iter379 in this.success) + { + if (this.success.hasOwnProperty(iter379)) + { + iter379 = this.success[iter379]; + output.writeString(iter379); + } + } + output.writeListEnd(); + output.writeFieldEnd(); + } + if (this.ex !== null && this.ex !== undefined) { + output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1); + this.ex.write(output); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceRequestFetch_args = function(args) { + this.traceId = null; + this.requestId = null; + if (args) { + if (args.traceId !== undefined) { + this.traceId = args.traceId; + } + if (args.requestId !== undefined) { + this.requestId = args.requestId; + } + } +}; +Blur_traceRequestFetch_args.prototype = {}; +Blur_traceRequestFetch_args.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == Thrift.Type.STRING) { + this.traceId = input.readString().value; + } else { + input.skip(ftype); + } + break; + case 2: + if (ftype == Thrift.Type.STRING) { + this.requestId = input.readString().value; + } else { + input.skip(ftype); + } + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceRequestFetch_args.prototype.write = function(output) { + output.writeStructBegin('Blur_traceRequestFetch_args'); + if (this.traceId !== null && this.traceId !== undefined) { + output.writeFieldBegin('traceId', Thrift.Type.STRING, 1); + output.writeString(this.traceId); + output.writeFieldEnd(); + } + if (this.requestId !== null && this.requestId !== undefined) { + output.writeFieldBegin('requestId', Thrift.Type.STRING, 2); + output.writeString(this.requestId); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceRequestFetch_result = function(args) { + this.success = null; + this.ex = null; + if (args instanceof BlurException) { + this.ex = args; + return; + } + if (args) { + if (args.success !== undefined) { + this.success = args.success; + } + if (args.ex !== undefined) { + this.ex = args.ex; + } + } +}; +Blur_traceRequestFetch_result.prototype = {}; +Blur_traceRequestFetch_result.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 0: + if (ftype == Thrift.Type.STRING) { + this.success = input.readString().value; + } else { + input.skip(ftype); + } + break; + case 1: + if (ftype == Thrift.Type.STRUCT) { + this.ex = new BlurException(); + this.ex.read(input); + } else { + input.skip(ftype); + } + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceRequestFetch_result.prototype.write = function(output) { + output.writeStructBegin('Blur_traceRequestFetch_result'); + if (this.success !== null && this.success !== undefined) { + output.writeFieldBegin('success', Thrift.Type.STRING, 0); + output.writeString(this.success); + output.writeFieldEnd(); + } + if (this.ex !== null && this.ex !== undefined) { + output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1); + this.ex.write(output); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceRemove_args = function(args) { + this.traceId = null; + if (args) { + if (args.traceId !== undefined) { + this.traceId = args.traceId; + } + } +}; +Blur_traceRemove_args.prototype = {}; +Blur_traceRemove_args.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == Thrift.Type.STRING) { + this.traceId = input.readString().value; + } else { + input.skip(ftype); + } + break; + case 0: + input.skip(ftype); + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceRemove_args.prototype.write = function(output) { + output.writeStructBegin('Blur_traceRemove_args'); + if (this.traceId !== null && this.traceId !== undefined) { + output.writeFieldBegin('traceId', Thrift.Type.STRING, 1); + output.writeString(this.traceId); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + +Blur_traceRemove_result = function(args) { + this.ex = null; + if (args instanceof BlurException) { + this.ex = args; + return; + } + if (args) { + if (args.ex !== undefined) { + this.ex = args.ex; + } + } +}; +Blur_traceRemove_result.prototype = {}; +Blur_traceRemove_result.prototype.read = function(input) { + input.readStructBegin(); + while (true) + { + var ret = input.readFieldBegin(); + var fname = ret.fname; + var ftype = ret.ftype; + var fid = ret.fid; + if (ftype == Thrift.Type.STOP) { + break; + } + switch (fid) + { + case 1: + if (ftype == Thrift.Type.STRUCT) { + this.ex = new BlurException(); + this.ex.read(input); + } else { + input.skip(ftype); + } + break; + case 0: + input.skip(ftype); + break; + default: + input.skip(ftype); + } + input.readFieldEnd(); + } + input.readStructEnd(); + return; +}; + +Blur_traceRemove_result.prototype.write = function(output) { + output.writeStructBegin('Blur_traceRemove_result'); + if (this.ex !== null && this.ex !== undefined) { + output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1); + this.ex.write(output); + output.writeFieldEnd(); + } + output.writeFieldStop(); + output.writeStructEnd(); + return; +}; + BlurClient = function(input, output) { this.input = input; this.output = (!output) ? input : output; @@ -6002,3 +6517,148 @@ BlurClient.prototype.send_startTrace = function(traceId, requestId) { this.output.writeMessageEnd(); return this.output.getTransport().flush(); }; +BlurClient.prototype.traceList = function() { + this.send_traceList(); + return this.recv_traceList(); +}; + +BlurClient.prototype.send_traceList = function() { + this.output.writeMessageBegin('traceList', Thrift.MessageType.CALL, this.seqid); + var args = new Blur_traceList_args(); + args.write(this.output); + this.output.writeMessageEnd(); + return this.output.getTransport().flush(); +}; + +BlurClient.prototype.recv_traceList = function() { + var ret = this.input.readMessageBegin(); + var fname = ret.fname; + var mtype = ret.mtype; + var rseqid = ret.rseqid; + if (mtype == Thrift.MessageType.EXCEPTION) { + var x = new Thrift.TApplicationException(); + x.read(this.input); + this.input.readMessageEnd(); + throw x; + } + var result = new Blur_traceList_result(); + result.read(this.input); + this.input.readMessageEnd(); + + if (null !== result.ex) { + throw result.ex; + } + if (null !== result.success) { + return result.success; + } + throw 'traceList failed: unknown result'; +}; +BlurClient.prototype.traceRequestList = function(traceId) { + this.send_traceRequestList(traceId); + return this.recv_traceRequestList(); +}; + +BlurClient.prototype.send_traceRequestList = function(traceId) { + this.output.writeMessageBegin('traceRequestList', Thrift.MessageType.CALL, this.seqid); + var args = new Blur_traceRequestList_args(); + args.traceId = traceId; + args.write(this.output); + this.output.writeMessageEnd(); + return this.output.getTransport().flush(); +}; + +BlurClient.prototype.recv_traceRequestList = function() { + var ret = this.input.readMessageBegin(); + var fname = ret.fname; + var mtype = ret.mtype; + var rseqid = ret.rseqid; + if (mtype == Thrift.MessageType.EXCEPTION) { + var x = new Thrift.TApplicationException(); + x.read(this.input); + this.input.readMessageEnd(); + throw x; + } + var result = new Blur_traceRequestList_result(); + result.read(this.input); + this.input.readMessageEnd(); + + if (null !== result.ex) { + throw result.ex; + } + if (null !== result.success) { + return result.success; + } + throw 'traceRequestList failed: unknown result'; +}; +BlurClient.prototype.traceRequestFetch = function(traceId, requestId) { + this.send_traceRequestFetch(traceId, requestId); + return this.recv_traceRequestFetch(); +}; + +BlurClient.prototype.send_traceRequestFetch = function(traceId, requestId) { + this.output.writeMessageBegin('traceRequestFetch', Thrift.MessageType.CALL, this.seqid); + var args = new Blur_traceRequestFetch_args(); + args.traceId = traceId; + args.requestId = requestId; + args.write(this.output); + this.output.writeMessageEnd(); + return this.output.getTransport().flush(); +}; + +BlurClient.prototype.recv_traceRequestFetch = function() { + var ret = this.input.readMessageBegin(); + var fname = ret.fname; + var mtype = ret.mtype; + var rseqid = ret.rseqid; + if (mtype == Thrift.MessageType.EXCEPTION) { + var x = new Thrift.TApplicationException(); + x.read(this.input); + this.input.readMessageEnd(); + throw x; + } + var result = new Blur_traceRequestFetch_result(); + result.read(this.input); + this.input.readMessageEnd(); + + if (null !== result.ex) { + throw result.ex; + } + if (null !== result.success) { + return result.success; + } + throw 'traceRequestFetch failed: unknown result'; +}; +BlurClient.prototype.traceRemove = function(traceId) { + this.send_traceRemove(traceId); + this.recv_traceRemove(); +}; + +BlurClient.prototype.send_traceRemove = function(traceId) { + this.output.writeMessageBegin('traceRemove', Thrift.MessageType.CALL, this.seqid); + var args = new Blur_traceRemove_args(); + args.traceId = traceId; + args.write(this.output); + this.output.writeMessageEnd(); + return this.output.getTransport().flush(); +}; + +BlurClient.prototype.recv_traceRemove = function() { + var ret = this.input.readMessageBegin(); + var fname = ret.fname; + var mtype = ret.mtype; + var rseqid = ret.rseqid; + if (mtype == Thrift.MessageType.EXCEPTION) { + var x = new Thrift.TApplicationException(); + x.read(this.input); + this.input.readMessageEnd(); + throw x; + } + var result = new Blur_traceRemove_result(); + result.read(this.input); + this.input.readMessageEnd(); + + if (null !== result.ex) { + throw result.ex; + } + return; +};
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm ---------------------------------------------------------------------- diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm index 335da5d..fafbd82 100644 --- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm +++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm @@ -5466,6 +5466,606 @@ sub write { return $xfer; } +package Blur::Blur_traceList_args; +use base qw(Class::Accessor); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceList_args'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceList_args'); + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceList_result; +use base qw(Class::Accessor); +Blur::Blur_traceList_result->mk_accessors( qw( success ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{success} = undef; + $self->{ex} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{success}) { + $self->{success} = $vals->{success}; + } + if (defined $vals->{ex}) { + $self->{ex} = $vals->{ex}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceList_result'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^0$/ && do{ if ($ftype == TType::LIST) { + { + my $_size323 = 0; + $self->{success} = []; + my $_etype326 = 0; + $xfer += $input->readListBegin(\$_etype326, \$_size323); + for (my $_i327 = 0; $_i327 < $_size323; ++$_i327) + { + my $elem328 = undef; + $xfer += $input->readString(\$elem328); + push(@{$self->{success}},$elem328); + } + $xfer += $input->readListEnd(); + } + } else { + $xfer += $input->skip($ftype); + } + last; }; + /^1$/ && do{ if ($ftype == TType::STRUCT) { + $self->{ex} = new Blur::BlurException(); + $xfer += $self->{ex}->read($input); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceList_result'); + if (defined $self->{success}) { + $xfer += $output->writeFieldBegin('success', TType::LIST, 0); + { + $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}})); + { + foreach my $iter329 (@{$self->{success}}) + { + $xfer += $output->writeString($iter329); + } + } + $xfer += $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if (defined $self->{ex}) { + $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1); + $xfer += $self->{ex}->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceRequestList_args; +use base qw(Class::Accessor); +Blur::Blur_traceRequestList_args->mk_accessors( qw( traceId ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{traceId} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{traceId}) { + $self->{traceId} = $vals->{traceId}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceRequestList_args'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^1$/ && do{ if ($ftype == TType::STRING) { + $xfer += $input->readString(\$self->{traceId}); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceRequestList_args'); + if (defined $self->{traceId}) { + $xfer += $output->writeFieldBegin('traceId', TType::STRING, 1); + $xfer += $output->writeString($self->{traceId}); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceRequestList_result; +use base qw(Class::Accessor); +Blur::Blur_traceRequestList_result->mk_accessors( qw( success ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{success} = undef; + $self->{ex} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{success}) { + $self->{success} = $vals->{success}; + } + if (defined $vals->{ex}) { + $self->{ex} = $vals->{ex}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceRequestList_result'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^0$/ && do{ if ($ftype == TType::LIST) { + { + my $_size330 = 0; + $self->{success} = []; + my $_etype333 = 0; + $xfer += $input->readListBegin(\$_etype333, \$_size330); + for (my $_i334 = 0; $_i334 < $_size330; ++$_i334) + { + my $elem335 = undef; + $xfer += $input->readString(\$elem335); + push(@{$self->{success}},$elem335); + } + $xfer += $input->readListEnd(); + } + } else { + $xfer += $input->skip($ftype); + } + last; }; + /^1$/ && do{ if ($ftype == TType::STRUCT) { + $self->{ex} = new Blur::BlurException(); + $xfer += $self->{ex}->read($input); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceRequestList_result'); + if (defined $self->{success}) { + $xfer += $output->writeFieldBegin('success', TType::LIST, 0); + { + $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}})); + { + foreach my $iter336 (@{$self->{success}}) + { + $xfer += $output->writeString($iter336); + } + } + $xfer += $output->writeListEnd(); + } + $xfer += $output->writeFieldEnd(); + } + if (defined $self->{ex}) { + $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1); + $xfer += $self->{ex}->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceRequestFetch_args; +use base qw(Class::Accessor); +Blur::Blur_traceRequestFetch_args->mk_accessors( qw( traceId requestId ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{traceId} = undef; + $self->{requestId} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{traceId}) { + $self->{traceId} = $vals->{traceId}; + } + if (defined $vals->{requestId}) { + $self->{requestId} = $vals->{requestId}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceRequestFetch_args'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^1$/ && do{ if ($ftype == TType::STRING) { + $xfer += $input->readString(\$self->{traceId}); + } else { + $xfer += $input->skip($ftype); + } + last; }; + /^2$/ && do{ if ($ftype == TType::STRING) { + $xfer += $input->readString(\$self->{requestId}); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceRequestFetch_args'); + if (defined $self->{traceId}) { + $xfer += $output->writeFieldBegin('traceId', TType::STRING, 1); + $xfer += $output->writeString($self->{traceId}); + $xfer += $output->writeFieldEnd(); + } + if (defined $self->{requestId}) { + $xfer += $output->writeFieldBegin('requestId', TType::STRING, 2); + $xfer += $output->writeString($self->{requestId}); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceRequestFetch_result; +use base qw(Class::Accessor); +Blur::Blur_traceRequestFetch_result->mk_accessors( qw( success ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{success} = undef; + $self->{ex} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{success}) { + $self->{success} = $vals->{success}; + } + if (defined $vals->{ex}) { + $self->{ex} = $vals->{ex}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceRequestFetch_result'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^0$/ && do{ if ($ftype == TType::STRING) { + $xfer += $input->readString(\$self->{success}); + } else { + $xfer += $input->skip($ftype); + } + last; }; + /^1$/ && do{ if ($ftype == TType::STRUCT) { + $self->{ex} = new Blur::BlurException(); + $xfer += $self->{ex}->read($input); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceRequestFetch_result'); + if (defined $self->{success}) { + $xfer += $output->writeFieldBegin('success', TType::STRING, 0); + $xfer += $output->writeString($self->{success}); + $xfer += $output->writeFieldEnd(); + } + if (defined $self->{ex}) { + $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1); + $xfer += $self->{ex}->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceRemove_args; +use base qw(Class::Accessor); +Blur::Blur_traceRemove_args->mk_accessors( qw( traceId ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{traceId} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{traceId}) { + $self->{traceId} = $vals->{traceId}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceRemove_args'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^1$/ && do{ if ($ftype == TType::STRING) { + $xfer += $input->readString(\$self->{traceId}); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceRemove_args'); + if (defined $self->{traceId}) { + $xfer += $output->writeFieldBegin('traceId', TType::STRING, 1); + $xfer += $output->writeString($self->{traceId}); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + +package Blur::Blur_traceRemove_result; +use base qw(Class::Accessor); +Blur::Blur_traceRemove_result->mk_accessors( qw( ) ); + +sub new { + my $classname = shift; + my $self = {}; + my $vals = shift || {}; + $self->{ex} = undef; + if (UNIVERSAL::isa($vals,'HASH')) { + if (defined $vals->{ex}) { + $self->{ex} = $vals->{ex}; + } + } + return bless ($self, $classname); +} + +sub getName { + return 'Blur_traceRemove_result'; +} + +sub read { + my ($self, $input) = @_; + my $xfer = 0; + my $fname; + my $ftype = 0; + my $fid = 0; + $xfer += $input->readStructBegin(\$fname); + while (1) + { + $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); + if ($ftype == TType::STOP) { + last; + } + SWITCH: for($fid) + { + /^1$/ && do{ if ($ftype == TType::STRUCT) { + $self->{ex} = new Blur::BlurException(); + $xfer += $self->{ex}->read($input); + } else { + $xfer += $input->skip($ftype); + } + last; }; + $xfer += $input->skip($ftype); + } + $xfer += $input->readFieldEnd(); + } + $xfer += $input->readStructEnd(); + return $xfer; +} + +sub write { + my ($self, $output) = @_; + my $xfer = 0; + $xfer += $output->writeStructBegin('Blur_traceRemove_result'); + if (defined $self->{ex}) { + $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1); + $xfer += $self->{ex}->write($output); + $xfer += $output->writeFieldEnd(); + } + $xfer += $output->writeFieldStop(); + $xfer += $output->writeStructEnd(); + return $xfer; +} + package Blur::BlurIf; use strict; @@ -5731,6 +6331,34 @@ sub startTrace{ die 'implement interface'; } +sub traceList{ + my $self = shift; + + die 'implement interface'; +} + +sub traceRequestList{ + my $self = shift; + my $traceId = shift; + + die 'implement interface'; +} + +sub traceRequestFetch{ + my $self = shift; + my $traceId = shift; + my $requestId = shift; + + die 'implement interface'; +} + +sub traceRemove{ + my $self = shift; + my $traceId = shift; + + die 'implement interface'; +} + package Blur::BlurRest; use strict; @@ -6003,6 +6631,34 @@ sub startTrace{ return $self->{impl}->startTrace($traceId, $requestId); } +sub traceList{ + my ($self, $request) = @_; + + return $self->{impl}->traceList(); +} + +sub traceRequestList{ + my ($self, $request) = @_; + + my $traceId = ($request->{'traceId'}) ? $request->{'traceId'} : undef; + return $self->{impl}->traceRequestList($traceId); +} + +sub traceRequestFetch{ + my ($self, $request) = @_; + + my $traceId = ($request->{'traceId'}) ? $request->{'traceId'} : undef; + my $requestId = ($request->{'requestId'}) ? $request->{'requestId'} : undef; + return $self->{impl}->traceRequestFetch($traceId, $requestId); +} + +sub traceRemove{ + my ($self, $request) = @_; + + my $traceId = ($request->{'traceId'}) ? $request->{'traceId'} : undef; + return $self->{impl}->traceRemove($traceId); +} + package Blur::BlurClient; @@ -7585,6 +8241,187 @@ sub send_startTrace{ $self->{output}->writeMessageEnd(); $self->{output}->getTransport()->flush(); } +sub traceList{ + my $self = shift; + + $self->send_traceList(); + return $self->recv_traceList(); +} + +sub send_traceList{ + my $self = shift; + + $self->{output}->writeMessageBegin('traceList', TMessageType::CALL, $self->{seqid}); + my $args = new Blur::Blur_traceList_args(); + $args->write($self->{output}); + $self->{output}->writeMessageEnd(); + $self->{output}->getTransport()->flush(); +} + +sub recv_traceList{ + my $self = shift; + + my $rseqid = 0; + my $fname; + my $mtype = 0; + + $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid); + if ($mtype == TMessageType::EXCEPTION) { + my $x = new TApplicationException(); + $x->read($self->{input}); + $self->{input}->readMessageEnd(); + die $x; + } + my $result = new Blur::Blur_traceList_result(); + $result->read($self->{input}); + $self->{input}->readMessageEnd(); + + if (defined $result->{success} ) { + return $result->{success}; + } + if (defined $result->{ex}) { + die $result->{ex}; + } + die "traceList failed: unknown result"; +} +sub traceRequestList{ + my $self = shift; + my $traceId = shift; + + $self->send_traceRequestList($traceId); + return $self->recv_traceRequestList(); +} + +sub send_traceRequestList{ + my $self = shift; + my $traceId = shift; + + $self->{output}->writeMessageBegin('traceRequestList', TMessageType::CALL, $self->{seqid}); + my $args = new Blur::Blur_traceRequestList_args(); + $args->{traceId} = $traceId; + $args->write($self->{output}); + $self->{output}->writeMessageEnd(); + $self->{output}->getTransport()->flush(); +} + +sub recv_traceRequestList{ + my $self = shift; + + my $rseqid = 0; + my $fname; + my $mtype = 0; + + $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid); + if ($mtype == TMessageType::EXCEPTION) { + my $x = new TApplicationException(); + $x->read($self->{input}); + $self->{input}->readMessageEnd(); + die $x; + } + my $result = new Blur::Blur_traceRequestList_result(); + $result->read($self->{input}); + $self->{input}->readMessageEnd(); + + if (defined $result->{success} ) { + return $result->{success}; + } + if (defined $result->{ex}) { + die $result->{ex}; + } + die "traceRequestList failed: unknown result"; +} +sub traceRequestFetch{ + my $self = shift; + my $traceId = shift; + my $requestId = shift; + + $self->send_traceRequestFetch($traceId, $requestId); + return $self->recv_traceRequestFetch(); +} + +sub send_traceRequestFetch{ + my $self = shift; + my $traceId = shift; + my $requestId = shift; + + $self->{output}->writeMessageBegin('traceRequestFetch', TMessageType::CALL, $self->{seqid}); + my $args = new Blur::Blur_traceRequestFetch_args(); + $args->{traceId} = $traceId; + $args->{requestId} = $requestId; + $args->write($self->{output}); + $self->{output}->writeMessageEnd(); + $self->{output}->getTransport()->flush(); +} + +sub recv_traceRequestFetch{ + my $self = shift; + + my $rseqid = 0; + my $fname; + my $mtype = 0; + + $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid); + if ($mtype == TMessageType::EXCEPTION) { + my $x = new TApplicationException(); + $x->read($self->{input}); + $self->{input}->readMessageEnd(); + die $x; + } + my $result = new Blur::Blur_traceRequestFetch_result(); + $result->read($self->{input}); + $self->{input}->readMessageEnd(); + + if (defined $result->{success} ) { + return $result->{success}; + } + if (defined $result->{ex}) { + die $result->{ex}; + } + die "traceRequestFetch failed: unknown result"; +} +sub traceRemove{ + my $self = shift; + my $traceId = shift; + + $self->send_traceRemove($traceId); + $self->recv_traceRemove(); +} + +sub send_traceRemove{ + my $self = shift; + my $traceId = shift; + + $self->{output}->writeMessageBegin('traceRemove', TMessageType::CALL, $self->{seqid}); + my $args = new Blur::Blur_traceRemove_args(); + $args->{traceId} = $traceId; + $args->write($self->{output}); + $self->{output}->writeMessageEnd(); + $self->{output}->getTransport()->flush(); +} + +sub recv_traceRemove{ + my $self = shift; + + my $rseqid = 0; + my $fname; + my $mtype = 0; + + $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid); + if ($mtype == TMessageType::EXCEPTION) { + my $x = new TApplicationException(); + $x->read($self->{input}); + $self->{input}->readMessageEnd(); + die $x; + } + my $result = new Blur::Blur_traceRemove_result(); + $result->read($self->{input}); + $self->{input}->readMessageEnd(); + + if (defined $result->{ex}) { + die $result->{ex}; + } + return; +} package Blur::BlurProcessor; use strict; @@ -8196,4 +9033,72 @@ sub process_startTrace { $self->{handler}->startTrace($args->traceId, $args->requestId); return; } +sub process_traceList { + my ($self, $seqid, $input, $output) = @_; + my $args = new Blur::Blur_traceList_args(); + $args->read($input); + $input->readMessageEnd(); + my $result = new Blur::Blur_traceList_result(); + eval { + $result->{success} = $self->{handler}->traceList(); + }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ + $result->{ex} = $@; + } + $output->writeMessageBegin('traceList', TMessageType::REPLY, $seqid); + $result->write($output); + $output->writeMessageEnd(); + $output->getTransport()->flush(); +} + +sub process_traceRequestList { + my ($self, $seqid, $input, $output) = @_; + my $args = new Blur::Blur_traceRequestList_args(); + $args->read($input); + $input->readMessageEnd(); + my $result = new Blur::Blur_traceRequestList_result(); + eval { + $result->{success} = $self->{handler}->traceRequestList($args->traceId); + }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ + $result->{ex} = $@; + } + $output->writeMessageBegin('traceRequestList', TMessageType::REPLY, $seqid); + $result->write($output); + $output->writeMessageEnd(); + $output->getTransport()->flush(); +} + +sub process_traceRequestFetch { + my ($self, $seqid, $input, $output) = @_; + my $args = new Blur::Blur_traceRequestFetch_args(); + $args->read($input); + $input->readMessageEnd(); + my $result = new Blur::Blur_traceRequestFetch_result(); + eval { + $result->{success} = $self->{handler}->traceRequestFetch($args->traceId, $args->requestId); + }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ + $result->{ex} = $@; + } + $output->writeMessageBegin('traceRequestFetch', TMessageType::REPLY, $seqid); + $result->write($output); + $output->writeMessageEnd(); + $output->getTransport()->flush(); +} + +sub process_traceRemove { + my ($self, $seqid, $input, $output) = @_; + my $args = new Blur::Blur_traceRemove_args(); + $args->read($input); + $input->readMessageEnd(); + my $result = new Blur::Blur_traceRemove_result(); + eval { + $self->{handler}->traceRemove($args->traceId); + }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ + $result->{ex} = $@; + } + $output->writeMessageBegin('traceRemove', TMessageType::REPLY, $seqid); + $result->write($output); + $output->writeMessageEnd(); + $output->getTransport()->flush(); +} + 1; http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/distribution/src/main/scripts/interface/gen-rb/blur.rb ---------------------------------------------------------------------- diff --git a/distribution/src/main/scripts/interface/gen-rb/blur.rb b/distribution/src/main/scripts/interface/gen-rb/blur.rb index 6439b3b..5bd5b2e 100644 --- a/distribution/src/main/scripts/interface/gen-rb/blur.rb +++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb @@ -544,6 +544,69 @@ module Blur def send_startTrace(traceId, requestId) send_message('startTrace', StartTrace_args, :traceId => traceId, :requestId => requestId) end + def traceList() + send_traceList() + return recv_traceList() + end + + def send_traceList() + send_message('traceList', TraceList_args) + end + + def recv_traceList() + result = receive_message(TraceList_result) + return result.success unless result.success.nil? + raise result.ex unless result.ex.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'traceList failed: unknown result') + end + + def traceRequestList(traceId) + send_traceRequestList(traceId) + return recv_traceRequestList() + end + + def send_traceRequestList(traceId) + send_message('traceRequestList', TraceRequestList_args, :traceId => traceId) + end + + def recv_traceRequestList() + result = receive_message(TraceRequestList_result) + return result.success unless result.success.nil? + raise result.ex unless result.ex.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'traceRequestList failed: unknown result') + end + + def traceRequestFetch(traceId, requestId) + send_traceRequestFetch(traceId, requestId) + return recv_traceRequestFetch() + end + + def send_traceRequestFetch(traceId, requestId) + send_message('traceRequestFetch', TraceRequestFetch_args, :traceId => traceId, :requestId => requestId) + end + + def recv_traceRequestFetch() + result = receive_message(TraceRequestFetch_result) + return result.success unless result.success.nil? + raise result.ex unless result.ex.nil? + raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT, 'traceRequestFetch failed: unknown result') + end + + def traceRemove(traceId) + send_traceRemove(traceId) + recv_traceRemove() + end + + def send_traceRemove(traceId) + send_message('traceRemove', TraceRemove_args, :traceId => traceId) + end + + def recv_traceRemove() + result = receive_message(TraceRemove_result) + raise result.ex unless result.ex.nil? + return + end + end class Processor @@ -924,6 +987,50 @@ module Blur return end + def process_traceList(seqid, iprot, oprot) + args = read_args(iprot, TraceList_args) + result = TraceList_result.new() + begin + result.success = @handler.traceList() + rescue ::Blur::BlurException => ex + result.ex = ex + end + write_result(result, oprot, 'traceList', seqid) + end + + def process_traceRequestList(seqid, iprot, oprot) + args = read_args(iprot, TraceRequestList_args) + result = TraceRequestList_result.new() + begin + result.success = @handler.traceRequestList(args.traceId) + rescue ::Blur::BlurException => ex + result.ex = ex + end + write_result(result, oprot, 'traceRequestList', seqid) + end + + def process_traceRequestFetch(seqid, iprot, oprot) + args = read_args(iprot, TraceRequestFetch_args) + result = TraceRequestFetch_result.new() + begin + result.success = @handler.traceRequestFetch(args.traceId, args.requestId) + rescue ::Blur::BlurException => ex + result.ex = ex + end + write_result(result, oprot, 'traceRequestFetch', seqid) + end + + def process_traceRemove(seqid, iprot, oprot) + args = read_args(iprot, TraceRemove_args) + result = TraceRemove_result.new() + begin + @handler.traceRemove(args.traceId) + rescue ::Blur::BlurException => ex + result.ex = ex + end + write_result(result, oprot, 'traceRemove', seqid) + end + end # HELPER FUNCTIONS AND STRUCTURES @@ -2171,6 +2278,145 @@ module Blur ::Thrift::Struct.generate_accessors self end + class TraceList_args + include ::Thrift::Struct, ::Thrift::Struct_Union + + FIELDS = { + + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceList_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + EX = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRING}}, + EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceRequestList_args + include ::Thrift::Struct, ::Thrift::Struct_Union + TRACEID = 1 + + FIELDS = { + # the trace id. + TRACEID => {:type => ::Thrift::Types::STRING, :name => 'traceId'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceRequestList_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + EX = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::LIST, :name => 'success', :element => {:type => ::Thrift::Types::STRING}}, + EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceRequestFetch_args + include ::Thrift::Struct, ::Thrift::Struct_Union + TRACEID = 1 + REQUESTID = 2 + + FIELDS = { + # the trace id. + TRACEID => {:type => ::Thrift::Types::STRING, :name => 'traceId'}, + # the request id. + REQUESTID => {:type => ::Thrift::Types::STRING, :name => 'requestId'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceRequestFetch_result + include ::Thrift::Struct, ::Thrift::Struct_Union + SUCCESS = 0 + EX = 1 + + FIELDS = { + SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'}, + EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceRemove_args + include ::Thrift::Struct, ::Thrift::Struct_Union + TRACEID = 1 + + FIELDS = { + # the trace id. + TRACEID => {:type => ::Thrift::Types::STRING, :name => 'traceId'} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + + class TraceRemove_result + include ::Thrift::Struct, ::Thrift::Struct_Union + EX = 1 + + FIELDS = { + EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException} + } + + def struct_fields; FIELDS; end + + def validate + end + + ::Thrift::Struct.generate_accessors self + end + end end http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/cc606b47/docs/Blur.html ---------------------------------------------------------------------- diff --git a/docs/Blur.html b/docs/Blur.html index 2e17c2f..fc56caa 100644 --- a/docs/Blur.html +++ b/docs/Blur.html @@ -134,6 +134,10 @@ limitations under the License. <li><a href="#Fn_Blur_configuration"> configuration</a></li> <li><a href="#Fn_Blur_metrics"> metrics</a></li> <li><a href="#Fn_Blur_startTrace"> startTrace</a></li> +<li><a href="#Fn_Blur_traceList"> traceList</a></li> +<li><a href="#Fn_Blur_traceRequestList"> traceRequestList</a></li> +<li><a href="#Fn_Blur_traceRequestFetch"> traceRequestFetch</a></li> +<li><a href="#Fn_Blur_traceRemove"> traceRemove</a></li> </ul></li> </ul> </li> @@ -899,6 +903,37 @@ throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code> </td></tr> <tr><td>requestId</td><td>the request id, used to connected remote calls together. Client can pass null. </td></tr> +</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceList">Function: Blur.traceList</h4></div><p class="lead"> +<pre><code>list<<code>string</code>></code> traceList() +throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code> +</pre>Get a list of all the traces. +@return the list of trace ids. +<br/></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceRequestList">Function: Blur.traceRequestList</h4></div><p class="lead"> +<pre><code>list<<code>string</code>></code> traceRequestList(<code>string</code> traceId) +throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code> +</pre>Gets a request list for the given trace. +@return the list of request ids for the given trace id. +<br/><br/><h4 id="Parameters_Blur_traceRequestList">Parameters</h4> +<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>traceId</td><td>the trace id. +</td></tr> +</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceRequestFetch">Function: Blur.traceRequestFetch</h4></div><p class="lead"> +<pre><code>string</code> traceRequestFetch(<code>string</code> traceId, +<code>string</code> requestId) +throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code> +</pre>Fetches the given trace. +@return the json for the given trace request. +<br/><br/><h4 id="Parameters_Blur_traceRequestFetch">Parameters</h4> +<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>traceId</td><td>the trace id. +</td></tr> +<tr><td>requestId</td><td>the request id. +</td></tr> +</table></p></section><section><div class="page-header"><h4 id="Fn_Blur_traceRemove">Function: Blur.traceRemove</h4></div><p class="lead"> +<pre><code>void</code> traceRemove(<code>string</code> traceId) +throws <code><a href="Blur.html#Struct_BlurException">BlurException</a></code> +</pre>Remove the trace for the given trace id. +<br/><br/><h4 id="Parameters_Blur_traceRemove">Parameters</h4> +<table class="table-bordered table-striped table-condensed"><thead><th>Name</th><th>Description</th></thead><tr><td>traceId</td><td>the trace id. +</td></tr> </table></p></section> </div> </div>
