Update XDS interop tests for PHP and Ruby

src/php/tests/interop/Grpc/Testing/LoadBalancerStatsResponse.php

@@ -25,6 +25,10 @@ class LoadBalancerStatsResponse extends \Google\Protobuf\Internal\Message
      * Generated from protobuf field <code>int32 num_failures = 2;</code>
      */
     protected $num_failures = 0;
+    /**
+     * Generated from protobuf field <code>map<string, .grpc.testing.LoadBalancerStatsResponse.RpcsByPeer> rpcs_by_method = 3;</code>
+     */
+    private $rpcs_by_method;
 
     /**
      * Constructor.
@@ -36,6 +40,7 @@ class LoadBalancerStatsResponse extends \Google\Protobuf\Internal\Message
      *           The number of completed RPCs for each peer.
      *     @type int $num_failures
      *           The number of RPCs that failed to record a remote peer.
+     *     @type array|\Google\Protobuf\Internal\MapField $rpcs_by_method
      * }
      */
     public function __construct($data = NULL) {
@@ -95,5 +100,27 @@ class LoadBalancerStatsResponse extends \Google\Protobuf\Internal\Message
         return $this;
     }
 
+    /**
+     * Generated from protobuf field <code>map<string, .grpc.testing.LoadBalancerStatsResponse.RpcsByPeer> rpcs_by_method = 3;</code>
+     * @return \Google\Protobuf\Internal\MapField
+     */
+    public function getRpcsByMethod()
+    {
+        return $this->rpcs_by_method;
+    }
+
+    /**
+     * Generated from protobuf field <code>map<string, .grpc.testing.LoadBalancerStatsResponse.RpcsByPeer> rpcs_by_method = 3;</code>
+     * @param array|\Google\Protobuf\Internal\MapField $var
+     * @return $this
+     */
+    public function setRpcsByMethod($var)
+    {
+        $arr = GPBUtil::checkMapField($var, \Google\Protobuf\Internal\GPBType::STRING, \Google\Protobuf\Internal\GPBType::MESSAGE, \Grpc\Testing\LoadBalancerStatsResponse\RpcsByPeer::class);
+        $this->rpcs_by_method = $arr;
+
+        return $this;
+    }
+
 }
 

src/php/tests/interop/Grpc/Testing/LoadBalancerStatsResponse/RpcsByPeer.php

@@ -0,0 +1,68 @@
+<?php
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: src/proto/grpc/testing/messages.proto
+
+namespace Grpc\Testing\LoadBalancerStatsResponse;
+
+use Google\Protobuf\Internal\GPBType;
+use Google\Protobuf\Internal\RepeatedField;
+use Google\Protobuf\Internal\GPBUtil;
+
+/**
+ * Generated from protobuf message <code>grpc.testing.LoadBalancerStatsResponse.RpcsByPeer</code>
+ */
+class RpcsByPeer extends \Google\Protobuf\Internal\Message
+{
+    /**
+     * The number of completed RPCs for each peer.
+     *
+     * Generated from protobuf field <code>map<string, int32> rpcs_by_peer = 1;</code>
+     */
+    private $rpcs_by_peer;
+
+    /**
+     * Constructor.
+     *
+     * @param array $data {
+     *     Optional. Data for populating the Message object.
+     *
+     *     @type array|\Google\Protobuf\Internal\MapField $rpcs_by_peer
+     *           The number of completed RPCs for each peer.
+     * }
+     */
+    public function __construct($data = NULL) {
+        \GPBMetadata\Src\Proto\Grpc\Testing\Messages::initOnce();
+        parent::__construct($data);
+    }
+
+    /**
+     * The number of completed RPCs for each peer.
+     *
+     * Generated from protobuf field <code>map<string, int32> rpcs_by_peer = 1;</code>
+     * @return \Google\Protobuf\Internal\MapField
+     */
+    public function getRpcsByPeer()
+    {
+        return $this->rpcs_by_peer;
+    }
+
+    /**
+     * The number of completed RPCs for each peer.
+     *
+     * Generated from protobuf field <code>map<string, int32> rpcs_by_peer = 1;</code>
+     * @param array|\Google\Protobuf\Internal\MapField $var
+     * @return $this
+     */
+    public function setRpcsByPeer($var)
+    {
+        $arr = GPBUtil::checkMapField($var, \Google\Protobuf\Internal\GPBType::STRING, \Google\Protobuf\Internal\GPBType::INT32);
+        $this->rpcs_by_peer = $arr;
+
+        return $this;
+    }
+
+}
+
+// Adding a class alias for backwards compatibility with the previous class name.
+class_alias(RpcsByPeer::class, \Grpc\Testing\LoadBalancerStatsResponse_RpcsByPeer::class);
+

src/php/tests/interop/Grpc/Testing/LoadBalancerStatsResponse_RpcsByPeer.php

@@ -0,0 +1,16 @@
+<?php
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: src/proto/grpc/testing/messages.proto
+
+namespace Grpc\Testing;
+
+if (false) {
+    /**
+     * This class is deprecated. Use Grpc\Testing\LoadBalancerStatsResponse\RpcsByPeer instead.
+     * @deprecated
+     */
+    class LoadBalancerStatsResponse_RpcsByPeer {}
+}
+class_exists(LoadBalancerStatsResponse\RpcsByPeer::class);
+@trigger_error('Grpc\Testing\LoadBalancerStatsResponse_RpcsByPeer is deprecated and will be removed in the next major release. Use Grpc\Testing\LoadBalancerStatsResponse\RpcsByPeer instead', E_USER_DEPRECATED);
+

src/php/tests/interop/Grpc/Testing/XdsUpdateHealthServiceClient.php

@@ -0,0 +1,66 @@
+<?php
+// GENERATED CODE -- DO NOT EDIT!
+
+// Original file comments:
+// Copyright 2015-2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+//
+namespace Grpc\Testing;
+
+/**
+ * A service to remotely control health status of an xDS test server.
+ */
+class XdsUpdateHealthServiceClient extends \Grpc\BaseStub {
+
+    /**
+     * @param string $hostname hostname
+     * @param array $opts channel options
+     * @param \Grpc\Channel $channel (optional) re-use channel object
+     */
+    public function __construct($hostname, $opts, $channel = null) {
+        parent::__construct($hostname, $opts, $channel);
+    }
+
+    /**
+     * @param \Grpc\Testing\EmptyMessage $argument input argument
+     * @param array $metadata metadata
+     * @param array $options call options
+     * @return \Grpc\Testing\EmptyMessage
+     */
+    public function SetServing(\Grpc\Testing\EmptyMessage $argument,
+      $metadata = [], $options = []) {
+        return $this->_simpleRequest('/grpc.testing.XdsUpdateHealthService/SetServing',
+        $argument,
+        ['\Grpc\Testing\EmptyMessage', 'decode'],
+        $metadata, $options);
+    }
+
+    /**
+     * @param \Grpc\Testing\EmptyMessage $argument input argument
+     * @param array $metadata metadata
+     * @param array $options call options
+     * @return \Grpc\Testing\EmptyMessage
+     */
+    public function SetNotServing(\Grpc\Testing\EmptyMessage $argument,
+      $metadata = [], $options = []) {
+        return $this->_simpleRequest('/grpc.testing.XdsUpdateHealthService/SetNotServing',
+        $argument,
+        ['\Grpc\Testing\EmptyMessage', 'decode'],
+        $metadata, $options);
+    }
+
+}

src/php/tests/interop/xds_client.php

@@ -33,13 +33,14 @@ class LoadBalancerStatsService
     function getClientStats(\Grpc\Testing\LoadBalancerStatsRequest $request) {
         $num_rpcs = $request->getNumRpcs();
         $timeout_sec = $request->getTimeoutSec();
+        $rpcs_by_method = [];
         $rpcs_by_peer = [];
-        $num_failures = $num_rpcs;
+        $num_failures = 0;
 
         // Heavy limitation now: the server is blocking, until all
         // the necessary num_rpcs are finished, or timeout is reached
         global $client_thread;
-        $start_id = count($client_thread->results) + 1;
+        $start_id = $client_thread->num_results + 1;
         $end_id = $start_id + $num_rpcs;
         $now = hrtime(true);
         $timeout = $now[0] + ($now[1] / 1e9) + $timeout_sec;
@@ -50,7 +51,7 @@ class LoadBalancerStatsService
                 break;
             }
             // Thread variable seems to be read-only
-            $curr_id = count($client_thread->results);
+            $curr_id = $client_thread->num_results;
             if ($curr_id >= $end_id) {
                 break;
             }
@@ -58,19 +59,52 @@ class LoadBalancerStatsService
         }
 
         // Tally up results
-        $end_id = min($end_id, count($client_thread->results));
-        for ($i = $start_id; $i < $end_id; $i++) {
-            $hostname = $client_thread->results[$i];
-            if ($hostname) {
-                $num_failures -= 1;
-                if (!array_key_exists($hostname, $rpcs_by_peer)) {
-                    $rpcs_by_peer[$hostname] = 0;
+        $end_id = min($end_id, $client_thread->num_results);
+        // "$client_thread->results" will be in the form of
+        // [
+        //   'rpc1' => [
+        //     'hostname1', '', 'hostname2', 'hostname1', '', ...
+        //   ],
+        //   'rpc2' => [
+        //     '', 'hostname1', 'hostname2', '', 'hostname2', ...
+        //   ],
+        // ]
+        foreach ($client_thread->results as $rpc => $results) {
+            // initialize, can always start from scratch here
+            $rpcs_by_method[$rpc] = [];
+            for ($i = $start_id; $i < $end_id; $i++) {
+                $hostname = $results[$i];
+                if ($hostname) {
+                    // initialize in case we haven't seen this hostname
+                    // before
+                    if (!array_key_exists($hostname, $rpcs_by_method[$rpc])) {
+                        $rpcs_by_method[$rpc][$hostname] = 0;
+                    }
+                    if (!array_key_exists($hostname, $rpcs_by_peer)) {
+                        $rpcs_by_peer[$hostname] = 0;
+                    }
+                    // increment the remote hostname distribution histogram
+                    // both by overall, and broken down per RPC
+                    $rpcs_by_method[$rpc][$hostname] += 1;
+                    $rpcs_by_peer[$hostname] += 1;
+                } else {
+                    // $num_failures here are counted per individual RPC
+                    $num_failures += 1;
                 }
-                $rpcs_by_peer[$hostname] += 1;
             }
         }
+
+        // Convert our hashmaps above into protobuf objects
         $response = new Grpc\Testing\LoadBalancerStatsResponse();
+        $rpcs_by_method_map = [];
+        foreach ($rpcs_by_method as $rpc => $rpcs_by_peer_per_method) {
+            $rpcs_by_peer_proto_obj
+                = new Grpc\Testing\LoadBalancerStatsResponse\RpcsByPeer();
+            $rpcs_by_peer_proto_obj->setRpcsByPeer($rpcs_by_peer_per_method);
+            $rpcs_by_method_map[$rpc] = $rpcs_by_peer_proto_obj;
+        }
         $response->setRpcsByPeer($rpcs_by_peer);
+        $response->setRpcsByMethod($rpcs_by_method_map);
         $response->setNumFailures($num_failures);
         return $response;
     }
@@ -83,28 +117,74 @@ class ClientThread extends Thread {
     private $target_seconds_between_rpcs_;
     private $fail_on_failed_rpcs_;
     private $autoload_path_;
+    private $TIMEOUT_US = 30 * 1e6; // 30 seconds
+    public $num_results = 0;
     public $results;
-    
+
     public function __construct($server_address, $qps, $fail_on_failed_rpcs,
+                                $rpcs_to_send, $metadata_to_send,
                                 $autoload_path) {
         $this->server_address_ = $server_address;
         $this->target_seconds_between_rpcs_ = 1.0 / $qps;
         $this->fail_on_failed_rpcs_ = $fail_on_failed_rpcs;
+        $this->rpcs_to_send = explode(',', $rpcs_to_send);
+        // Convert input in the form of
+        //   rpc1:k1:v1,rpc2:k2:v2,rpc1:k3:v3
+        // into
+        //   [
+        //     'rpc1' => [
+        //       'k1' => 'v1',
+        //       'k3' => 'v3',
+        //     ],
+        //     'rpc2' => [
+        //       'k2' => 'v2'
+        //     ],
+        //   ]
+        $this->metadata_to_send = [];
+        if ($_all_metadata = explode(',', $metadata_to_send)) {
+            foreach ($_all_metadata as $one_metadata_pair) {
+                list($rpc,
+                     $metadata_key,
+                     $metadata_value) = explode(':', $one_metadata_pair);
+                // initialize in case we haven't seen this rpc before
+                if (!array_key_exists($rpc, $this->metadata_to_send)) {
+                    $this->metadata_to_send[$rpc] = [];
+                }
+                $this->metadata_to_send[$rpc][$metadata_key]
+                    = $metadata_value;
+            }
+        }
         $this->autoload_path_ = $autoload_path;
+        $this->simple_request = new Grpc\Testing\SimpleRequest();
+        $this->empty_request = new Grpc\Testing\EmptyMessage();
         $this->results = [];
+        foreach ($this->rpcs_to_send as $rpc) {
+            $this->results[$rpc] = [];
+        }
+    }
+
+    public function sendUnaryCall($stub, $metadata) {
+        return $stub->UnaryCall($this->simple_request,
+                                $metadata,
+                                ['timeout' => $this->TIMEOUT_US]);
+    }
+
+    public function sendEmptyCall($stub, $metadata) {
+        return $stub->EmptyCall($this->empty_request,
+                                $metadata,
+                                ['timeout' => $this->TIMEOUT_US]);
     }
 
     public function run() {
         // Autoloaded classes do not get inherited in threads.
         // Hence we need to do this.
         require_once($this->autoload_path_);
-        $TIMEOUT_US = 30 * 1e6; // 30 seconds
 
         $stub = new Grpc\Testing\TestServiceClient($this->server_address_, [
             'credentials' => Grpc\ChannelCredentials::createInsecure()
         ]);
-        $request = new Grpc\Testing\SimpleRequest();
-        $target_next_start_us = hrtime(true) / 1000; # hrtime returns nanoseconds
+        # hrtime returns nanoseconds
+        $target_next_start_us = hrtime(true) / 1000;
         while (true) {
             $now_us = hrtime(true) / 1000;
             $sleep_us = $target_next_start_us - $now_us;
@@ -121,18 +201,43 @@ class ClientThread extends Thread {
                         ($this->target_seconds_between_rpcs_ * 1e6);
                 usleep($sleep_us);
             }
-            list($response, $status)
-                = $stub->UnaryCall($request, [],
-                                   ['timeout' => $TIMEOUT_US])->wait();
-            if ($status->code == Grpc\STATUS_OK) {
-                $this->results[] = $response->getHostname();
-            } else {
-                if ($this->fail_on_failed_rpcs_) {
-                    throw new Exception('UnaryCall failed with status '
-                                        . $status->code);
+            foreach ($this->rpcs_to_send as $rpc) {
+                $metadata = array_key_exists(
+                    $rpc, $this->metadata_to_send) ?
+                          $this->metadata_to_send[$rpc] : [];
+                // This copy is somehow necessary because
+                // $this->metadata_to_send[$rpc] somehow becomes a
+                // Volatile object, instead of an associative array.
+                $metadata_array = [];
+                foreach ($metadata as $key => $value) {
+                    $metadata_array[$key] = [$value];
+                }
+                $call = null;
+                if ($rpc == 'UnaryCall') {
+                    $call = $this->sendUnaryCall($stub, $metadata_array);
+                } else if ($rpc == 'EmptyCall') {
+                    $call = $this->sendEmptyCall($stub, $metadata_array);
+                } else {
+                    throw new Exception("Unhandled rpc $rpc");
+                }
+                // the remote peer is being returned as part of the
+                // initial metadata, according to the test spec
+                $initial_metadata = $call->getMetadata();
+                list($response, $status) = $call->wait();
+                if ($status->code == Grpc\STATUS_OK &&
+                    array_key_exists('hostname', $initial_metadata)) {
+                    $this->results[$rpc][] = $initial_metadata['hostname'][0];
+                } else {
+                    if ($this->fail_on_failed_rpcs_) {
+                        throw new Exception("$rpc failed with status "
+                                            . $status->code);
+                    }
+                    $this->results[$rpc][] = "";
                 }
-                $this->results[] = "";
             }
+            // $num_results here is only incremented when the group of
+            // all $rpcs_to_send are done.
+            $this->num_results++;
         }
     }
 
@@ -145,10 +250,14 @@ class ClientThread extends Thread {
 
 // Note: num_channels are currently ignored for now
 $args = getopt('', ['fail_on_failed_rpcs:', 'num_channels:',
+                    'rpc:', 'metadata:',
                     'server:', 'stats_port:', 'qps:']);
 
 $client_thread = new ClientThread($args['server'], $args['qps'],
                                   $args['fail_on_failed_rpcs'],
+                                  (empty($args['rpc']) ? 'UnaryCall'
+                                   : $args['rpc']),
+                                  $args['metadata'],
                                   $autoload_path);
 $client_thread->start();
 

src/ruby/pb/test/xds_client.rb

@@ -81,6 +81,7 @@ class TestTarget < Grpc::Testing::LoadBalancerStatsService::Service
     watcher = {}
     $watchers_mutex.synchronize do
       watcher = {
+        "rpcs_by_method" => Hash.new(),
         "rpcs_by_peer" => Hash.new(0),
         "rpcs_needed" => req['num_rpcs'],
         "no_remote_peer" => 0
@@ -95,17 +96,45 @@ class TestTarget < Grpc::Testing::LoadBalancerStatsService::Service
       end
       $watchers.delete_at($watchers.index(watcher))
     end
+    # convert results into proper proto object
+    rpcs_by_method = {}
+    watcher['rpcs_by_method'].each do | rpc_name, rpcs_by_peer |
+      rpcs_by_method[rpc_name] = LoadBalancerStatsResponse::RpcsByPeer.new(
+        rpcs_by_peer: rpcs_by_peer
+      )
+    end
     LoadBalancerStatsResponse.new(
+      rpcs_by_method: rpcs_by_method,
       rpcs_by_peer: watcher['rpcs_by_peer'],
       num_failures: watcher['no_remote_peer'] + watcher['rpcs_needed']
     );
   end
 end
 
+# execute 1 RPC and return remote hostname
+def execute_rpc(op, fail_on_failed_rpcs)
+  remote_peer = ""
+  begin
+    op.execute
+    if op.metadata.key?('hostname')
+      remote_peer = op.metadata['hostname']
+    end
+  rescue GRPC::BadStatus => e
+    GRPC.logger.info("ruby xds: rpc failed:|#{e.message}|, " \
+                     "this may or may not be expected")
+    if fail_on_failed_rpcs
+      raise e
+    end
+  end
+  remote_peer
+end
+
 # send 1 rpc every 1/qps second
-def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
+def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs,
+                  rpcs_to_send, metadata_to_send)
   include Grpc::Testing
-  req = SimpleRequest.new()
+  simple_req = SimpleRequest.new()
+  empty_req = Empty.new()
   target_next_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   while !$shutdown
     now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -121,25 +150,42 @@ def run_test_loop(stub, target_seconds_between_rpcs, fail_on_failed_rpcs)
       target_next_start += target_seconds_between_rpcs
       sleep(sleep_seconds)
     end
-    begin
-      deadline = GRPC::Core::TimeConsts::from_relative_time(30) # 30 seconds
-      resp = stub.unary_call(req, deadline: deadline)
-      remote_peer = resp.hostname
-    rescue GRPC::BadStatus => e
-      remote_peer = ""
-      GRPC.logger.info("ruby xds: rpc failed:|#{e.message}|, " \
-                       "this may or may not be expected")
-      if fail_on_failed_rpcs
-        raise e
+    deadline = GRPC::Core::TimeConsts::from_relative_time(30) # 30 seconds
+    results = {}
+    rpcs_to_send.each do |rpc|
+      metadata = metadata_to_send.key?(rpc) ? metadata_to_send[rpc] : {}
+      if rpc == 'UnaryCall'
+        op = stub.unary_call(simple_req,
+                             metadata: metadata,
+                             deadline: deadline,
+                             return_op: true)
+      elsif rpc == 'EmptyCall'
+        op = stub.empty_call(empty_req,
+                             metadata: metadata,
+                             deadline: deadline,
+                             return_op: true)
+      else
+        raise "Unsupported rpc %s" % [rpc]
       end
+      results[rpc] = execute_rpc(op, fail_on_failed_rpcs)
     end
     $watchers_mutex.synchronize do
       $watchers.each do |watcher|
+        # this is counted once when each group of all rpcs_to_send were done
         watcher['rpcs_needed'] -= 1
-        if remote_peer.strip.empty?
-          watcher['no_remote_peer'] += 1
-        else
-          watcher['rpcs_by_peer'][remote_peer] += 1
+        results.each do | rpc_name, remote_peer |
+          if remote_peer.strip.empty?
+            # error is counted per individual RPC
+            watcher['no_remote_peer'] += 1
+          else
+            if not watcher['rpcs_by_method'].key?(rpc_name)
+              watcher['rpcs_by_method'][rpc_name] = Hash.new(0)
+            end
+            # increment the remote hostname distribution histogram
+            # both by overall, and broken down per RPC
+            watcher['rpcs_by_method'][rpc_name][remote_peer] +=  1
+            watcher['rpcs_by_peer'][remote_peer] += 1
+          end
         end
       end
       $watchers_cv.broadcast
@@ -149,6 +195,7 @@ end
 
 # Args is used to hold the command line info.
 Args = Struct.new(:fail_on_failed_rpcs, :num_channels,
+                  :rpc, :metadata,
                   :server, :stats_port, :qps)
 
 # validates the command line options, returning them as a Hash.
@@ -156,6 +203,8 @@ def parse_args
   args = Args.new
   args['fail_on_failed_rpcs'] = false
   args['num_channels'] = 1
+  args['rpc'] = 'UnaryCall'
+  args['metadata'] = ''
   OptionParser.new do |opts|
     opts.on('--fail_on_failed_rpcs BOOL', ['false', 'true']) do |v|
       args['fail_on_failed_rpcs'] = v == 'true'
@@ -163,6 +212,12 @@ def parse_args
     opts.on('--num_channels CHANNELS', 'number of channels') do |v|
       args['num_channels'] = v.to_i
     end
+    opts.on('--rpc RPCS_TO_SEND', 'list of RPCs to send') do |v|
+      args['rpc'] = v
+    end
+    opts.on('--metadata METADATA_TO_SEND', 'metadata to send per RPC') do |v|
+      args['metadata'] = v
+    end
     opts.on('--server SERVER_HOST', 'server hostname') do |v|
       GRPC.logger.info("ruby xds: server address is #{v}")
       args['server'] = v
@@ -195,11 +250,40 @@ def main
   # The client just sends unary rpcs continuously in a regular interval
   stub = create_stub(opts)
   target_seconds_between_rpcs = (1.0 / opts['qps'].to_f)
+  rpcs_to_send = []
+  if opts['rpc']
+    rpcs_to_send = opts['rpc'].split(',')
+  end
+  # Convert 'metadata' input in the form of
+  #   rpc1:k1:v1,rpc2:k2:v2,rpc1:k3:v3
+  # into
+  #   {
+  #     'rpc1' => {
+  #       'k1' => 'v1',
+  #       'k3' => 'v3',
+  #     },
+  #     'rpc2' => {
+  #       'k2' => 'v2'
+  #     },
+  #   }
+  metadata_to_send = {}
+  if opts['metadata']
+    metadata_entries = opts['metadata'].split(',')
+    metadata_entries.each do |e|
+      (rpc_name, metadata_key, metadata_value) = e.split(':')
+      # initialize if we haven't seen this rpc_name yet
+      if !metadata_to_send.key?(rpc_name)
+        metadata_to_send[rpc_name] = {}
+      end
+      metadata_to_send[rpc_name][metadata_key] = metadata_value
+    end
+  end
   client_threads = Array.new
   opts['num_channels'].times {
     client_threads << Thread.new {
       run_test_loop(stub, target_seconds_between_rpcs,
-                    opts['fail_on_failed_rpcs'])
+                    opts['fail_on_failed_rpcs'],
+                    rpcs_to_send, metadata_to_send)
     }
   }
 

tools/internal_ci/linux/grpc_xds_php_test_in_docker.sh

@@ -60,10 +60,10 @@ export CC=/usr/bin/gcc
 
 GRPC_VERBOSITY=debug GRPC_TRACE=xds_client,xds_resolver,xds_routing_lb,cds_lb,eds_lb,priority_lb,weighted_target_lb,lrs_lb "$PYTHON" \
   tools/run_tests/run_xds_tests.py \
-  --test_case=all \
+  --test_case="all,path_matching,header_matching" \
   --project_id=grpc-testing \
-  --source_image=projects/grpc-testing/global/images/xds-test-server \
+  --source_image=projects/grpc-testing/global/images/xds-test-server-2 \
   --path_to_server_binary=/java_server/grpc-java/interop-testing/build/install/grpc-interop-testing/bin/xds-test-server \
   --gcp_suffix=$(date '+%s') \
   --verbose \
-  --client_cmd='php -d extension=grpc.so -d extension=pthreads.so src/php/tests/interop/xds_client.php --server=xds:///{server_uri} --stats_port={stats_port} --qps={qps}'
+  --client_cmd='php -d extension=grpc.so -d extension=pthreads.so src/php/tests/interop/xds_client.php --server=xds:///{server_uri} --stats_port={stats_port} --qps={qps} {fail_on_failed_rpc} {rpcs_to_send} {metadata_to_send}'

tools/internal_ci/linux/grpc_xds_ruby_test_in_docker.sh

@@ -50,10 +50,10 @@ touch "$TOOLS_DIR"/src/proto/grpc/testing/__init__.py
 
 GRPC_VERBOSITY=debug GRPC_TRACE=xds_client,xds_resolver,xds_routing_lb,cds_lb,eds_lb,priority_lb,weighted_target_lb,lrs_lb "$PYTHON" \
   tools/run_tests/run_xds_tests.py \
-    --test_case=all \
+    --test_case="all,path_matching,header_matching" \
     --project_id=grpc-testing \
-    --source_image=projects/grpc-testing/global/images/xds-test-server \
+    --source_image=projects/grpc-testing/global/images/xds-test-server-2 \
     --path_to_server_binary=/java_server/grpc-java/interop-testing/build/install/grpc-interop-testing/bin/xds-test-server \
     --gcp_suffix=$(date '+%s') \
     --verbose \
-    --client_cmd='ruby src/ruby/pb/test/xds_client.rb --server=xds:///{server_uri} --stats_port={stats_port} --qps={qps}'
+    --client_cmd='ruby src/ruby/pb/test/xds_client.rb --server=xds:///{server_uri} --stats_port={stats_port} --qps={qps} {fail_on_failed_rpc} {rpcs_to_send} {metadata_to_send}'