incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [1/6] git commit: Generated Thrift files.
Date Sun, 06 Dec 2015 21:29:20 GMT
Repository: incubator-blur
Updated Branches:
  refs/heads/v2_command a3e4717bd -> 64437cf0a


http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/64437cf0/scripts/interface/gen-js/Blur_types.js
----------------------------------------------------------------------
diff --git a/scripts/interface/gen-js/Blur_types.js b/scripts/interface/gen-js/Blur_types.js
index 8c07ed9..0cab580 100644
--- a/scripts/interface/gen-js/Blur_types.js
+++ b/scripts/interface/gen-js/Blur_types.js
@@ -4870,3 +4870,180 @@ CommandDescriptor.prototype.write = function(output) {
   return;
 };
 
+CommandTarget = function(args) {
+  this.tables = null;
+  this.shards = null;
+  if (args) {
+    if (args.tables !== undefined) {
+      this.tables = args.tables;
+    }
+    if (args.shards !== undefined) {
+      this.shards = args.shards;
+    }
+  }
+};
+CommandTarget.prototype = {};
+CommandTarget.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.SET) {
+        var _size290 = 0;
+        var _rtmp3294;
+        this.tables = [];
+        var _etype293 = 0;
+        _rtmp3294 = input.readSetBegin();
+        _etype293 = _rtmp3294.etype;
+        _size290 = _rtmp3294.size;
+        for (var _i295 = 0; _i295 < _size290; ++_i295)
+        {
+          var elem296 = null;
+          elem296 = input.readString().value;
+          this.tables.push(elem296);
+        }
+        input.readSetEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.SET) {
+        var _size297 = 0;
+        var _rtmp3301;
+        this.shards = [];
+        var _etype300 = 0;
+        _rtmp3301 = input.readSetBegin();
+        _etype300 = _rtmp3301.etype;
+        _size297 = _rtmp3301.size;
+        for (var _i302 = 0; _i302 < _size297; ++_i302)
+        {
+          var elem303 = null;
+          elem303 = input.readString().value;
+          this.shards.push(elem303);
+        }
+        input.readSetEnd();
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+CommandTarget.prototype.write = function(output) {
+  output.writeStructBegin('CommandTarget');
+  if (this.tables !== null && this.tables !== undefined) {
+    output.writeFieldBegin('tables', Thrift.Type.SET, 1);
+    output.writeSetBegin(Thrift.Type.STRING, this.tables.length);
+    for (var iter304 in this.tables)
+    {
+      if (this.tables.hasOwnProperty(iter304))
+      {
+        iter304 = this.tables[iter304];
+        output.writeString(iter304);
+      }
+    }
+    output.writeSetEnd();
+    output.writeFieldEnd();
+  }
+  if (this.shards !== null && this.shards !== undefined) {
+    output.writeFieldBegin('shards', Thrift.Type.SET, 2);
+    output.writeSetBegin(Thrift.Type.STRING, this.shards.length);
+    for (var iter305 in this.shards)
+    {
+      if (this.shards.hasOwnProperty(iter305))
+      {
+        iter305 = this.shards[iter305];
+        output.writeString(iter305);
+      }
+    }
+    output.writeSetEnd();
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+
+CommandRequest = function(args) {
+  this.name = null;
+  this.target = null;
+  if (args) {
+    if (args.name !== undefined) {
+      this.name = args.name;
+    }
+    if (args.target !== undefined) {
+      this.target = args.target;
+    }
+  }
+};
+CommandRequest.prototype = {};
+CommandRequest.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.name = input.readString().value;
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      case 2:
+      if (ftype == Thrift.Type.STRUCT) {
+        this.target = new CommandTarget();
+        this.target.read(input);
+      } else {
+        input.skip(ftype);
+      }
+      break;
+      default:
+        input.skip(ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return;
+};
+
+CommandRequest.prototype.write = function(output) {
+  output.writeStructBegin('CommandRequest');
+  if (this.name !== null && this.name !== undefined) {
+    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
+    output.writeString(this.name);
+    output.writeFieldEnd();
+  }
+  if (this.target !== null && this.target !== undefined) {
+    output.writeFieldBegin('target', Thrift.Type.STRUCT, 2);
+    this.target.write(output);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  return;
+};
+

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/64437cf0/scripts/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/scripts/interface/gen-perl/Blur/Blur.pm b/scripts/interface/gen-perl/Blur/Blur.pm
index a404f05..c0cad03 100644
--- a/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/scripts/interface/gen-perl/Blur/Blur.pm
@@ -100,16 +100,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size258 = 0;
+          my $_size272 = 0;
           $self->{success} = [];
-          my $_etype261 = 0;
-          $xfer += $input->readListBegin(\$_etype261, \$_size258);
-          for (my $_i262 = 0; $_i262 < $_size258; ++$_i262)
+          my $_etype275 = 0;
+          $xfer += $input->readListBegin(\$_etype275, \$_size272);
+          for (my $_i276 = 0; $_i276 < $_size272; ++$_i276)
           {
-            my $elem263 = undef;
-            $elem263 = new Blur::CommandDescriptor();
-            $xfer += $elem263->read($input);
-            push(@{$self->{success}},$elem263);
+            my $elem277 = undef;
+            $elem277 = new Blur::CommandDescriptor();
+            $xfer += $elem277->read($input);
+            push(@{$self->{success}},$elem277);
           }
           $xfer += $input->readListEnd();
         }
@@ -141,9 +141,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter264 (@{$self->{success}}) 
+        foreach my $iter278 (@{$self->{success}}) 
         {
-          $xfer += ${iter264}->write($output);
+          $xfer += ${iter278}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -634,15 +634,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size265 = 0;
+          my $_size279 = 0;
           $self->{success} = [];
-          my $_etype268 = 0;
-          $xfer += $input->readListBegin(\$_etype268, \$_size265);
-          for (my $_i269 = 0; $_i269 < $_size265; ++$_i269)
+          my $_etype282 = 0;
+          $xfer += $input->readListBegin(\$_etype282, \$_size279);
+          for (my $_i283 = 0; $_i283 < $_size279; ++$_i283)
           {
-            my $elem270 = undef;
-            $xfer += $input->readString(\$elem270);
-            push(@{$self->{success}},$elem270);
+            my $elem284 = undef;
+            $xfer += $input->readString(\$elem284);
+            push(@{$self->{success}},$elem284);
           }
           $xfer += $input->readListEnd();
         }
@@ -674,9 +674,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter271 (@{$self->{success}}) 
+        foreach my $iter285 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter271);
+          $xfer += $output->writeString($iter285);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1059,6 +1059,117 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_executeCommand_args;
+use base qw(Class::Accessor);
+Blur::Blur_executeCommand_args->mk_accessors( qw( commandRequest ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{commandRequest} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{commandRequest}) {
+      $self->{commandRequest} = $vals->{commandRequest};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_executeCommand_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::STRUCT) {
+        $self->{commandRequest} = new Blur::CommandRequest();
+        $xfer += $self->{commandRequest}->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_executeCommand_args');
+  if (defined $self->{commandRequest}) {
+    $xfer += $output->writeFieldBegin('commandRequest', TType::STRUCT, 1);
+    $xfer += $self->{commandRequest}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_executeCommand_result;
+use base qw(Class::Accessor);
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_executeCommand_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)
+    {
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_executeCommand_result');
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::Blur_createTable_args;
 use base qw(Class::Accessor);
 Blur::Blur_createTable_args->mk_accessors( qw( tableDescriptor ) );
@@ -1839,15 +1950,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size272 = 0;
+          my $_size286 = 0;
           $self->{success} = [];
-          my $_etype275 = 0;
-          $xfer += $input->readListBegin(\$_etype275, \$_size272);
-          for (my $_i276 = 0; $_i276 < $_size272; ++$_i276)
+          my $_etype289 = 0;
+          $xfer += $input->readListBegin(\$_etype289, \$_size286);
+          for (my $_i290 = 0; $_i290 < $_size286; ++$_i290)
           {
-            my $elem277 = undef;
-            $xfer += $input->readString(\$elem277);
-            push(@{$self->{success}},$elem277);
+            my $elem291 = undef;
+            $xfer += $input->readString(\$elem291);
+            push(@{$self->{success}},$elem291);
           }
           $xfer += $input->readListEnd();
         }
@@ -1879,9 +1990,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter278 (@{$self->{success}}) 
+        foreach my $iter292 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter278);
+          $xfer += $output->writeString($iter292);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2004,15 +2115,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size279 = 0;
+          my $_size293 = 0;
           $self->{success} = [];
-          my $_etype282 = 0;
-          $xfer += $input->readListBegin(\$_etype282, \$_size279);
-          for (my $_i283 = 0; $_i283 < $_size279; ++$_i283)
+          my $_etype296 = 0;
+          $xfer += $input->readListBegin(\$_etype296, \$_size293);
+          for (my $_i297 = 0; $_i297 < $_size293; ++$_i297)
           {
-            my $elem284 = undef;
-            $xfer += $input->readString(\$elem284);
-            push(@{$self->{success}},$elem284);
+            my $elem298 = undef;
+            $xfer += $input->readString(\$elem298);
+            push(@{$self->{success}},$elem298);
           }
           $xfer += $input->readListEnd();
         }
@@ -2044,9 +2155,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter285 (@{$self->{success}}) 
+        foreach my $iter299 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter285);
+          $xfer += $output->writeString($iter299);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3196,30 +3307,30 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size286 = 0;
+          my $_size300 = 0;
           $self->{success} = {};
-          my $_ktype287 = 0;
-          my $_vtype288 = 0;
-          $xfer += $input->readMapBegin(\$_ktype287, \$_vtype288, \$_size286);
-          for (my $_i290 = 0; $_i290 < $_size286; ++$_i290)
+          my $_ktype301 = 0;
+          my $_vtype302 = 0;
+          $xfer += $input->readMapBegin(\$_ktype301, \$_vtype302, \$_size300);
+          for (my $_i304 = 0; $_i304 < $_size300; ++$_i304)
           {
-            my $key291 = '';
-            my $val292 = [];
-            $xfer += $input->readString(\$key291);
+            my $key305 = '';
+            my $val306 = [];
+            $xfer += $input->readString(\$key305);
             {
-              my $_size293 = 0;
-              $val292 = [];
-              my $_etype296 = 0;
-              $xfer += $input->readListBegin(\$_etype296, \$_size293);
-              for (my $_i297 = 0; $_i297 < $_size293; ++$_i297)
+              my $_size307 = 0;
+              $val306 = [];
+              my $_etype310 = 0;
+              $xfer += $input->readListBegin(\$_etype310, \$_size307);
+              for (my $_i311 = 0; $_i311 < $_size307; ++$_i311)
               {
-                my $elem298 = undef;
-                $xfer += $input->readString(\$elem298);
-                push(@{$val292},$elem298);
+                my $elem312 = undef;
+                $xfer += $input->readString(\$elem312);
+                push(@{$val306},$elem312);
               }
               $xfer += $input->readListEnd();
             }
-            $self->{success}->{$key291} = $val292;
+            $self->{success}->{$key305} = $val306;
           }
           $xfer += $input->readMapEnd();
         }
@@ -3251,15 +3362,15 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::LIST, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter299,$viter300) = each %{$self->{success}}) 
+        while( my ($kiter313,$viter314) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter299);
+          $xfer += $output->writeString($kiter313);
           {
-            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter300}}));
+            $xfer += $output->writeListBegin(TType::STRING, scalar(@{${viter314}}));
             {
-              foreach my $iter301 (@{${viter300}}) 
+              foreach my $iter315 (@{${viter314}}) 
               {
-                $xfer += $output->writeString($iter301);
+                $xfer += $output->writeString($iter315);
               }
             }
             $xfer += $output->writeListEnd();
@@ -3761,16 +3872,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size302 = 0;
+          my $_size316 = 0;
           $self->{selectors} = [];
-          my $_etype305 = 0;
-          $xfer += $input->readListBegin(\$_etype305, \$_size302);
-          for (my $_i306 = 0; $_i306 < $_size302; ++$_i306)
+          my $_etype319 = 0;
+          $xfer += $input->readListBegin(\$_etype319, \$_size316);
+          for (my $_i320 = 0; $_i320 < $_size316; ++$_i320)
           {
-            my $elem307 = undef;
-            $elem307 = new Blur::Selector();
-            $xfer += $elem307->read($input);
-            push(@{$self->{selectors}},$elem307);
+            my $elem321 = undef;
+            $elem321 = new Blur::Selector();
+            $xfer += $elem321->read($input);
+            push(@{$self->{selectors}},$elem321);
           }
           $xfer += $input->readListEnd();
         }
@@ -3800,9 +3911,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{selectors}}));
       {
-        foreach my $iter308 (@{$self->{selectors}}) 
+        foreach my $iter322 (@{$self->{selectors}}) 
         {
-          $xfer += ${iter308}->write($output);
+          $xfer += ${iter322}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3856,16 +3967,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size309 = 0;
+          my $_size323 = 0;
           $self->{success} = [];
-          my $_etype312 = 0;
-          $xfer += $input->readListBegin(\$_etype312, \$_size309);
-          for (my $_i313 = 0; $_i313 < $_size309; ++$_i313)
+          my $_etype326 = 0;
+          $xfer += $input->readListBegin(\$_etype326, \$_size323);
+          for (my $_i327 = 0; $_i327 < $_size323; ++$_i327)
           {
-            my $elem314 = undef;
-            $elem314 = new Blur::FetchResult();
-            $xfer += $elem314->read($input);
-            push(@{$self->{success}},$elem314);
+            my $elem328 = undef;
+            $elem328 = new Blur::FetchResult();
+            $xfer += $elem328->read($input);
+            push(@{$self->{success}},$elem328);
           }
           $xfer += $input->readListEnd();
         }
@@ -3897,9 +4008,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter315 (@{$self->{success}}) 
+        foreach my $iter329 (@{$self->{success}}) 
         {
-          $xfer += ${iter315}->write($output);
+          $xfer += ${iter329}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4108,15 +4219,15 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size316 = 0;
+          my $_size330 = 0;
           $self->{externalIndexPaths} = [];
-          my $_etype319 = 0;
-          $xfer += $input->readListBegin(\$_etype319, \$_size316);
-          for (my $_i320 = 0; $_i320 < $_size316; ++$_i320)
+          my $_etype333 = 0;
+          $xfer += $input->readListBegin(\$_etype333, \$_size330);
+          for (my $_i334 = 0; $_i334 < $_size330; ++$_i334)
           {
-            my $elem321 = undef;
-            $xfer += $input->readString(\$elem321);
-            push(@{$self->{externalIndexPaths}},$elem321);
+            my $elem335 = undef;
+            $xfer += $input->readString(\$elem335);
+            push(@{$self->{externalIndexPaths}},$elem335);
           }
           $xfer += $input->readListEnd();
         }
@@ -4146,9 +4257,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{externalIndexPaths}}));
       {
-        foreach my $iter322 (@{$self->{externalIndexPaths}}) 
+        foreach my $iter336 (@{$self->{externalIndexPaths}}) 
         {
-          $xfer += $output->writeString($iter322);
+          $xfer += $output->writeString($iter336);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4273,15 +4384,15 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size323 = 0;
+          my $_size337 = 0;
           $self->{externalIndexPaths} = [];
-          my $_etype326 = 0;
-          $xfer += $input->readListBegin(\$_etype326, \$_size323);
-          for (my $_i327 = 0; $_i327 < $_size323; ++$_i327)
+          my $_etype340 = 0;
+          $xfer += $input->readListBegin(\$_etype340, \$_size337);
+          for (my $_i341 = 0; $_i341 < $_size337; ++$_i341)
           {
-            my $elem328 = undef;
-            $xfer += $input->readString(\$elem328);
-            push(@{$self->{externalIndexPaths}},$elem328);
+            my $elem342 = undef;
+            $xfer += $input->readString(\$elem342);
+            push(@{$self->{externalIndexPaths}},$elem342);
           }
           $xfer += $input->readListEnd();
         }
@@ -4311,9 +4422,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{externalIndexPaths}}));
       {
-        foreach my $iter329 (@{$self->{externalIndexPaths}}) 
+        foreach my $iter343 (@{$self->{externalIndexPaths}}) 
         {
-          $xfer += $output->writeString($iter329);
+          $xfer += $output->writeString($iter343);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4688,16 +4799,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size330 = 0;
+          my $_size344 = 0;
           $self->{mutations} = [];
-          my $_etype333 = 0;
-          $xfer += $input->readListBegin(\$_etype333, \$_size330);
-          for (my $_i334 = 0; $_i334 < $_size330; ++$_i334)
+          my $_etype347 = 0;
+          $xfer += $input->readListBegin(\$_etype347, \$_size344);
+          for (my $_i348 = 0; $_i348 < $_size344; ++$_i348)
           {
-            my $elem335 = undef;
-            $elem335 = new Blur::RowMutation();
-            $xfer += $elem335->read($input);
-            push(@{$self->{mutations}},$elem335);
+            my $elem349 = undef;
+            $elem349 = new Blur::RowMutation();
+            $xfer += $elem349->read($input);
+            push(@{$self->{mutations}},$elem349);
           }
           $xfer += $input->readListEnd();
         }
@@ -4722,9 +4833,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter336 (@{$self->{mutations}}) 
+        foreach my $iter350 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter336}->write($output);
+          $xfer += ${iter350}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4839,16 +4950,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size337 = 0;
+          my $_size351 = 0;
           $self->{mutations} = [];
-          my $_etype340 = 0;
-          $xfer += $input->readListBegin(\$_etype340, \$_size337);
-          for (my $_i341 = 0; $_i341 < $_size337; ++$_i341)
+          my $_etype354 = 0;
+          $xfer += $input->readListBegin(\$_etype354, \$_size351);
+          for (my $_i355 = 0; $_i355 < $_size351; ++$_i355)
           {
-            my $elem342 = undef;
-            $elem342 = new Blur::RowMutation();
-            $xfer += $elem342->read($input);
-            push(@{$self->{mutations}},$elem342);
+            my $elem356 = undef;
+            $elem356 = new Blur::RowMutation();
+            $xfer += $elem356->read($input);
+            push(@{$self->{mutations}},$elem356);
           }
           $xfer += $input->readListEnd();
         }
@@ -4873,9 +4984,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter343 (@{$self->{mutations}}) 
+        foreach my $iter357 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter343}->write($output);
+          $xfer += ${iter357}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -5274,16 +5385,16 @@ sub read {
       last; };
       /^2$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size344 = 0;
+          my $_size358 = 0;
           $self->{rowMutations} = [];
-          my $_etype347 = 0;
-          $xfer += $input->readListBegin(\$_etype347, \$_size344);
-          for (my $_i348 = 0; $_i348 < $_size344; ++$_i348)
+          my $_etype361 = 0;
+          $xfer += $input->readListBegin(\$_etype361, \$_size358);
+          for (my $_i362 = 0; $_i362 < $_size358; ++$_i362)
           {
-            my $elem349 = undef;
-            $elem349 = new Blur::RowMutation();
-            $xfer += $elem349->read($input);
-            push(@{$self->{rowMutations}},$elem349);
+            my $elem363 = undef;
+            $elem363 = new Blur::RowMutation();
+            $xfer += $elem363->read($input);
+            push(@{$self->{rowMutations}},$elem363);
           }
           $xfer += $input->readListEnd();
         }
@@ -5313,9 +5424,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{rowMutations}}));
       {
-        foreach my $iter350 (@{$self->{rowMutations}}) 
+        foreach my $iter364 (@{$self->{rowMutations}}) 
         {
-          $xfer += ${iter350}->write($output);
+          $xfer += ${iter364}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -5801,15 +5912,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size351 = 0;
+          my $_size365 = 0;
           $self->{success} = [];
-          my $_etype354 = 0;
-          $xfer += $input->readListBegin(\$_etype354, \$_size351);
-          for (my $_i355 = 0; $_i355 < $_size351; ++$_i355)
+          my $_etype368 = 0;
+          $xfer += $input->readListBegin(\$_etype368, \$_size365);
+          for (my $_i369 = 0; $_i369 < $_size365; ++$_i369)
           {
-            my $elem356 = undef;
-            $xfer += $input->readString(\$elem356);
-            push(@{$self->{success}},$elem356);
+            my $elem370 = undef;
+            $xfer += $input->readString(\$elem370);
+            push(@{$self->{success}},$elem370);
           }
           $xfer += $input->readListEnd();
         }
@@ -5841,9 +5952,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter357 (@{$self->{success}}) 
+        foreach my $iter371 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter357);
+          $xfer += $output->writeString($iter371);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6186,15 +6297,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size358 = 0;
+          my $_size372 = 0;
           $self->{success} = [];
-          my $_etype361 = 0;
-          $xfer += $input->readListBegin(\$_etype361, \$_size358);
-          for (my $_i362 = 0; $_i362 < $_size358; ++$_i362)
+          my $_etype375 = 0;
+          $xfer += $input->readListBegin(\$_etype375, \$_size372);
+          for (my $_i376 = 0; $_i376 < $_size372; ++$_i376)
           {
-            my $elem363 = undef;
-            $xfer += $input->readString(\$elem363);
-            push(@{$self->{success}},$elem363);
+            my $elem377 = undef;
+            $xfer += $input->readString(\$elem377);
+            push(@{$self->{success}},$elem377);
           }
           $xfer += $input->readListEnd();
         }
@@ -6226,9 +6337,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter364 (@{$self->{success}}) 
+        foreach my $iter378 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter364);
+          $xfer += $output->writeString($iter378);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6522,15 +6633,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size365 = 0;
+          my $_size379 = 0;
           $self->{success} = [];
-          my $_etype368 = 0;
-          $xfer += $input->readListBegin(\$_etype368, \$_size365);
-          for (my $_i369 = 0; $_i369 < $_size365; ++$_i369)
+          my $_etype382 = 0;
+          $xfer += $input->readListBegin(\$_etype382, \$_size379);
+          for (my $_i383 = 0; $_i383 < $_size379; ++$_i383)
           {
-            my $elem370 = undef;
-            $xfer += $input->readString(\$elem370);
-            push(@{$self->{success}},$elem370);
+            my $elem384 = undef;
+            $xfer += $input->readString(\$elem384);
+            push(@{$self->{success}},$elem384);
           }
           $xfer += $input->readListEnd();
         }
@@ -6562,9 +6673,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter371 (@{$self->{success}}) 
+        foreach my $iter385 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter371);
+          $xfer += $output->writeString($iter385);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6687,15 +6798,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size372 = 0;
+          my $_size386 = 0;
           $self->{success} = [];
-          my $_etype375 = 0;
-          $xfer += $input->readListBegin(\$_etype375, \$_size372);
-          for (my $_i376 = 0; $_i376 < $_size372; ++$_i376)
+          my $_etype389 = 0;
+          $xfer += $input->readListBegin(\$_etype389, \$_size386);
+          for (my $_i390 = 0; $_i390 < $_size386; ++$_i390)
           {
-            my $elem377 = undef;
-            $xfer += $input->readString(\$elem377);
-            push(@{$self->{success}},$elem377);
+            my $elem391 = undef;
+            $xfer += $input->readString(\$elem391);
+            push(@{$self->{success}},$elem391);
           }
           $xfer += $input->readListEnd();
         }
@@ -6727,9 +6838,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter378 (@{$self->{success}}) 
+        foreach my $iter392 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter378);
+          $xfer += $output->writeString($iter392);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6834,15 +6945,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size379 = 0;
+          my $_size393 = 0;
           $self->{success} = [];
-          my $_etype382 = 0;
-          $xfer += $input->readListBegin(\$_etype382, \$_size379);
-          for (my $_i383 = 0; $_i383 < $_size379; ++$_i383)
+          my $_etype396 = 0;
+          $xfer += $input->readListBegin(\$_etype396, \$_size393);
+          for (my $_i397 = 0; $_i397 < $_size393; ++$_i397)
           {
-            my $elem384 = undef;
-            $xfer += $input->readString(\$elem384);
-            push(@{$self->{success}},$elem384);
+            my $elem398 = undef;
+            $xfer += $input->readString(\$elem398);
+            push(@{$self->{success}},$elem398);
           }
           $xfer += $input->readListEnd();
         }
@@ -6874,9 +6985,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter385 (@{$self->{success}}) 
+        foreach my $iter399 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter385);
+          $xfer += $output->writeString($iter399);
         }
       }
       $xfer += $output->writeListEnd();
@@ -6999,18 +7110,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size386 = 0;
+          my $_size400 = 0;
           $self->{success} = {};
-          my $_ktype387 = 0;
-          my $_vtype388 = 0;
-          $xfer += $input->readMapBegin(\$_ktype387, \$_vtype388, \$_size386);
-          for (my $_i390 = 0; $_i390 < $_size386; ++$_i390)
+          my $_ktype401 = 0;
+          my $_vtype402 = 0;
+          $xfer += $input->readMapBegin(\$_ktype401, \$_vtype402, \$_size400);
+          for (my $_i404 = 0; $_i404 < $_size400; ++$_i404)
           {
-            my $key391 = '';
-            my $val392 = '';
-            $xfer += $input->readString(\$key391);
-            $xfer += $input->readString(\$val392);
-            $self->{success}->{$key391} = $val392;
+            my $key405 = '';
+            my $val406 = '';
+            $xfer += $input->readString(\$key405);
+            $xfer += $input->readString(\$val406);
+            $self->{success}->{$key405} = $val406;
           }
           $xfer += $input->readMapEnd();
         }
@@ -7042,10 +7153,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter393,$viter394) = each %{$self->{success}}) 
+        while( my ($kiter407,$viter408) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter393);
-          $xfer += $output->writeString($viter394);
+          $xfer += $output->writeString($kiter407);
+          $xfer += $output->writeString($viter408);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -7168,33 +7279,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size395 = 0;
+          my $_size409 = 0;
           $self->{success} = {};
-          my $_ktype396 = 0;
-          my $_vtype397 = 0;
-          $xfer += $input->readMapBegin(\$_ktype396, \$_vtype397, \$_size395);
-          for (my $_i399 = 0; $_i399 < $_size395; ++$_i399)
+          my $_ktype410 = 0;
+          my $_vtype411 = 0;
+          $xfer += $input->readMapBegin(\$_ktype410, \$_vtype411, \$_size409);
+          for (my $_i413 = 0; $_i413 < $_size409; ++$_i413)
           {
-            my $key400 = '';
-            my $val401 = [];
-            $xfer += $input->readString(\$key400);
+            my $key414 = '';
+            my $val415 = [];
+            $xfer += $input->readString(\$key414);
             {
-              my $_size402 = 0;
-              $val401 = {};
-              my $_ktype403 = 0;
-              my $_vtype404 = 0;
-              $xfer += $input->readMapBegin(\$_ktype403, \$_vtype404, \$_size402);
-              for (my $_i406 = 0; $_i406 < $_size402; ++$_i406)
+              my $_size416 = 0;
+              $val415 = {};
+              my $_ktype417 = 0;
+              my $_vtype418 = 0;
+              $xfer += $input->readMapBegin(\$_ktype417, \$_vtype418, \$_size416);
+              for (my $_i420 = 0; $_i420 < $_size416; ++$_i420)
               {
-                my $key407 = '';
-                my $val408 = 0;
-                $xfer += $input->readString(\$key407);
-                $xfer += $input->readI32(\$val408);
-                $val401->{$key407} = $val408;
+                my $key421 = '';
+                my $val422 = 0;
+                $xfer += $input->readString(\$key421);
+                $xfer += $input->readI32(\$val422);
+                $val415->{$key421} = $val422;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key400} = $val401;
+            $self->{success}->{$key414} = $val415;
           }
           $xfer += $input->readMapEnd();
         }
@@ -7226,16 +7337,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter409,$viter410) = each %{$self->{success}}) 
+        while( my ($kiter423,$viter424) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter409);
+          $xfer += $output->writeString($kiter423);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter410}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter424}}));
             {
-              while( my ($kiter411,$viter412) = each %{${viter410}}) 
+              while( my ($kiter425,$viter426) = each %{${viter424}}) 
               {
-                $xfer += $output->writeString($kiter411);
-                $xfer += $output->writeI32($viter412);
+                $xfer += $output->writeString($kiter425);
+                $xfer += $output->writeI32($viter426);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -7488,18 +7599,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size413 = 0;
+          my $_size427 = 0;
           $self->{success} = {};
-          my $_ktype414 = 0;
-          my $_vtype415 = 0;
-          $xfer += $input->readMapBegin(\$_ktype414, \$_vtype415, \$_size413);
-          for (my $_i417 = 0; $_i417 < $_size413; ++$_i417)
+          my $_ktype428 = 0;
+          my $_vtype429 = 0;
+          $xfer += $input->readMapBegin(\$_ktype428, \$_vtype429, \$_size427);
+          for (my $_i431 = 0; $_i431 < $_size427; ++$_i431)
           {
-            my $key418 = '';
-            my $val419 = '';
-            $xfer += $input->readString(\$key418);
-            $xfer += $input->readString(\$val419);
-            $self->{success}->{$key418} = $val419;
+            my $key432 = '';
+            my $val433 = '';
+            $xfer += $input->readString(\$key432);
+            $xfer += $input->readString(\$val433);
+            $self->{success}->{$key432} = $val433;
           }
           $xfer += $input->readMapEnd();
         }
@@ -7531,10 +7642,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter420,$viter421) = each %{$self->{success}}) 
+        while( my ($kiter434,$viter435) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter420);
-          $xfer += $output->writeString($viter421);
+          $xfer += $output->writeString($kiter434);
+          $xfer += $output->writeString($viter435);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -7748,15 +7859,15 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::SET) {
         {
-          my $_size422 = 0;
+          my $_size436 = 0;
           $self->{metrics} = {};
-          my $_etype425 = 0;
-          $xfer += $input->readSetBegin(\$_etype425, \$_size422);
-          for (my $_i426 = 0; $_i426 < $_size422; ++$_i426)
+          my $_etype439 = 0;
+          $xfer += $input->readSetBegin(\$_etype439, \$_size436);
+          for (my $_i440 = 0; $_i440 < $_size436; ++$_i440)
           {
-            my $elem427 = undef;
-            $xfer += $input->readString(\$elem427);
-            $self->{metrics}->{$elem427} = 1;
+            my $elem441 = undef;
+            $xfer += $input->readString(\$elem441);
+            $self->{metrics}->{$elem441} = 1;
           }
           $xfer += $input->readSetEnd();
         }
@@ -7781,9 +7892,9 @@ sub write {
     {
       $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
       {
-        foreach my $iter428 (@{$self->{metrics}})
+        foreach my $iter442 (@{$self->{metrics}})
         {
-          $xfer += $output->writeString($iter428);
+          $xfer += $output->writeString($iter442);
         }
       }
       $xfer += $output->writeSetEnd();
@@ -7837,19 +7948,19 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size429 = 0;
+          my $_size443 = 0;
           $self->{success} = {};
-          my $_ktype430 = 0;
-          my $_vtype431 = 0;
-          $xfer += $input->readMapBegin(\$_ktype430, \$_vtype431, \$_size429);
-          for (my $_i433 = 0; $_i433 < $_size429; ++$_i433)
+          my $_ktype444 = 0;
+          my $_vtype445 = 0;
+          $xfer += $input->readMapBegin(\$_ktype444, \$_vtype445, \$_size443);
+          for (my $_i447 = 0; $_i447 < $_size443; ++$_i447)
           {
-            my $key434 = '';
-            my $val435 = new Blur::Metric();
-            $xfer += $input->readString(\$key434);
-            $val435 = new Blur::Metric();
-            $xfer += $val435->read($input);
-            $self->{success}->{$key434} = $val435;
+            my $key448 = '';
+            my $val449 = new Blur::Metric();
+            $xfer += $input->readString(\$key448);
+            $val449 = new Blur::Metric();
+            $xfer += $val449->read($input);
+            $self->{success}->{$key448} = $val449;
           }
           $xfer += $input->readMapEnd();
         }
@@ -7881,10 +7992,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter436,$viter437) = each %{$self->{success}}) 
+        while( my ($kiter450,$viter451) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter436);
-          $xfer += ${viter437}->write($output);
+          $xfer += $output->writeString($kiter450);
+          $xfer += ${viter451}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -8114,15 +8225,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size438 = 0;
+          my $_size452 = 0;
           $self->{success} = [];
-          my $_etype441 = 0;
-          $xfer += $input->readListBegin(\$_etype441, \$_size438);
-          for (my $_i442 = 0; $_i442 < $_size438; ++$_i442)
+          my $_etype455 = 0;
+          $xfer += $input->readListBegin(\$_etype455, \$_size452);
+          for (my $_i456 = 0; $_i456 < $_size452; ++$_i456)
           {
-            my $elem443 = undef;
-            $xfer += $input->readString(\$elem443);
-            push(@{$self->{success}},$elem443);
+            my $elem457 = undef;
+            $xfer += $input->readString(\$elem457);
+            push(@{$self->{success}},$elem457);
           }
           $xfer += $input->readListEnd();
         }
@@ -8154,9 +8265,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter444 (@{$self->{success}}) 
+        foreach my $iter458 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter444);
+          $xfer += $output->writeString($iter458);
         }
       }
       $xfer += $output->writeListEnd();
@@ -8279,15 +8390,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size445 = 0;
+          my $_size459 = 0;
           $self->{success} = [];
-          my $_etype448 = 0;
-          $xfer += $input->readListBegin(\$_etype448, \$_size445);
-          for (my $_i449 = 0; $_i449 < $_size445; ++$_i449)
+          my $_etype462 = 0;
+          $xfer += $input->readListBegin(\$_etype462, \$_size459);
+          for (my $_i463 = 0; $_i463 < $_size459; ++$_i463)
           {
-            my $elem450 = undef;
-            $xfer += $input->readString(\$elem450);
-            push(@{$self->{success}},$elem450);
+            my $elem464 = undef;
+            $xfer += $input->readString(\$elem464);
+            push(@{$self->{success}},$elem464);
           }
           $xfer += $input->readListEnd();
         }
@@ -8319,9 +8430,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter451 (@{$self->{success}}) 
+        foreach my $iter465 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter451);
+          $xfer += $output->writeString($iter465);
         }
       }
       $xfer += $output->writeListEnd();
@@ -9028,6 +9139,13 @@ sub refresh{
   die 'implement interface';
 }
 
+sub executeCommand{
+  my $self = shift;
+  my $commandRequest = shift;
+
+  die 'implement interface';
+}
+
 sub createTable{
   my $self = shift;
   my $tableDescriptor = shift;
@@ -9476,6 +9594,13 @@ sub refresh{
   return $self->{impl}->refresh();
 }
 
+sub executeCommand{
+  my ($self, $request) = @_;
+
+  my $commandRequest = ($request->{'commandRequest'}) ? $request->{'commandRequest'} : undef;
+  return $self->{impl}->executeCommand($commandRequest);
+}
+
 sub createTable{
   my ($self, $request) = @_;
 
@@ -10175,6 +10300,24 @@ sub send_refresh{
   $self->{output}->writeMessageEnd();
   $self->{output}->getTransport()->flush();
 }
+sub executeCommand{
+  my $self = shift;
+  my $commandRequest = shift;
+
+    $self->send_executeCommand($commandRequest);
+}
+
+sub send_executeCommand{
+  my $self = shift;
+  my $commandRequest = shift;
+
+  $self->{output}->writeMessageBegin('executeCommand', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_executeCommand_args();
+  $args->{commandRequest} = $commandRequest;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
 sub createTable{
   my $self = shift;
   my $tableDescriptor = shift;
@@ -12653,6 +12796,14 @@ sub process_refresh {
     $self->{handler}->refresh();
     return;
 }
+sub process_executeCommand {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_executeCommand_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    $self->{handler}->executeCommand($args->commandRequest);
+    return;
+}
 sub process_createTable {
     my ($self, $seqid, $input, $output) = @_;
     my $args = new Blur::Blur_createTable_args();

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/64437cf0/scripts/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/scripts/interface/gen-perl/Blur/Types.pm b/scripts/interface/gen-perl/Blur/Types.pm
index 32db537..c63e4d6 100644
--- a/scripts/interface/gen-perl/Blur/Types.pm
+++ b/scripts/interface/gen-perl/Blur/Types.pm
@@ -5112,4 +5112,205 @@ sub write {
   return $xfer;
 }
 
+package Blur::CommandTarget;
+use base qw(Class::Accessor);
+Blur::CommandTarget->mk_accessors( qw( tables shards ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{tables} = undef;
+  $self->{shards} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{tables}) {
+      $self->{tables} = $vals->{tables};
+    }
+    if (defined $vals->{shards}) {
+      $self->{shards} = $vals->{shards};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'CommandTarget';
+}
+
+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::SET) {
+        {
+          my $_size258 = 0;
+          $self->{tables} = {};
+          my $_etype261 = 0;
+          $xfer += $input->readSetBegin(\$_etype261, \$_size258);
+          for (my $_i262 = 0; $_i262 < $_size258; ++$_i262)
+          {
+            my $elem263 = undef;
+            $xfer += $input->readString(\$elem263);
+            $self->{tables}->{$elem263} = 1;
+          }
+          $xfer += $input->readSetEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::SET) {
+        {
+          my $_size264 = 0;
+          $self->{shards} = {};
+          my $_etype267 = 0;
+          $xfer += $input->readSetBegin(\$_etype267, \$_size264);
+          for (my $_i268 = 0; $_i268 < $_size264; ++$_i268)
+          {
+            my $elem269 = undef;
+            $xfer += $input->readString(\$elem269);
+            $self->{shards}->{$elem269} = 1;
+          }
+          $xfer += $input->readSetEnd();
+        }
+      } 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('CommandTarget');
+  if (defined $self->{tables}) {
+    $xfer += $output->writeFieldBegin('tables', TType::SET, 1);
+    {
+      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{tables}}));
+      {
+        foreach my $iter270 (@{$self->{tables}})
+        {
+          $xfer += $output->writeString($iter270);
+        }
+      }
+      $xfer += $output->writeSetEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shards}) {
+    $xfer += $output->writeFieldBegin('shards', TType::SET, 2);
+    {
+      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{shards}}));
+      {
+        foreach my $iter271 (@{$self->{shards}})
+        {
+          $xfer += $output->writeString($iter271);
+        }
+      }
+      $xfer += $output->writeSetEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::CommandRequest;
+use base qw(Class::Accessor);
+Blur::CommandRequest->mk_accessors( qw( name target ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{name} = undef;
+  $self->{target} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
+    }
+    if (defined $vals->{target}) {
+      $self->{target} = $vals->{target};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'CommandRequest';
+}
+
+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->{name});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{target} = new Blur::CommandTarget();
+        $xfer += $self->{target}->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('CommandRequest');
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
+    $xfer += $output->writeString($self->{name});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{target}) {
+    $xfer += $output->writeFieldBegin('target', TType::STRUCT, 2);
+    $xfer += $self->{target}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 1;

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/64437cf0/scripts/interface/gen-rb/blur.rb
----------------------------------------------------------------------
diff --git a/scripts/interface/gen-rb/blur.rb b/scripts/interface/gen-rb/blur.rb
index 66677f0..681b335 100644
--- a/scripts/interface/gen-rb/blur.rb
+++ b/scripts/interface/gen-rb/blur.rb
@@ -116,6 +116,13 @@ module Blur
       def send_refresh()
         send_message('refresh', Refresh_args)
       end
+      def executeCommand(commandRequest)
+        send_executeCommand(commandRequest)
+      end
+
+      def send_executeCommand(commandRequest)
+        send_message('executeCommand', ExecuteCommand_args, :commandRequest => commandRequest)
+      end
       def createTable(tableDescriptor)
         send_createTable(tableDescriptor)
         recv_createTable()
@@ -987,6 +994,12 @@ module Blur
         return
       end
 
+      def process_executeCommand(seqid, iprot, oprot)
+        args = read_args(iprot, ExecuteCommand_args)
+        @handler.executeCommand(args.commandRequest)
+        return
+      end
+
       def process_createTable(seqid, iprot, oprot)
         args = read_args(iprot, CreateTable_args)
         result = CreateTable_result.new()
@@ -1793,6 +1806,37 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class ExecuteCommand_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      COMMANDREQUEST = 1
+
+      FIELDS = {
+        COMMANDREQUEST => {:type => ::Thrift::Types::STRUCT, :name => 'commandRequest', :class => ::Blur::CommandRequest}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class ExecuteCommand_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+
+      FIELDS = {
+
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
     class CreateTable_args
       include ::Thrift::Struct, ::Thrift::Struct_Union
       TABLEDESCRIPTOR = 1

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/64437cf0/scripts/interface/gen-rb/blur_types.rb
----------------------------------------------------------------------
diff --git a/scripts/interface/gen-rb/blur_types.rb b/scripts/interface/gen-rb/blur_types.rb
index 902c566..2a4df2f 100644
--- a/scripts/interface/gen-rb/blur_types.rb
+++ b/scripts/interface/gen-rb/blur_types.rb
@@ -1261,4 +1261,40 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
+  class CommandTarget
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    TABLES = 1
+    SHARDS = 2
+
+    FIELDS = {
+      TABLES => {:type => ::Thrift::Types::SET, :name => 'tables', :element => {:type => ::Thrift::Types::STRING}},
+      SHARDS => {:type => ::Thrift::Types::SET, :name => 'shards', :element => {:type => ::Thrift::Types::STRING}}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
+  class CommandRequest
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    NAME = 1
+    TARGET = 2
+
+    FIELDS = {
+      NAME => {:type => ::Thrift::Types::STRING, :name => 'name'},
+      TARGET => {:type => ::Thrift::Types::STRUCT, :name => 'target', :class => ::Blur::CommandTarget}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
 end


Mime
View raw message