|
|
@@ -0,0 +1,2310 @@
|
|
|
+<?php
|
|
|
+/*
|
|
|
+ *
|
|
|
+ * Copyright 2015 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.
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+//==============Channel Test====================
|
|
|
+
|
|
|
+function callbackFunc($context)
|
|
|
+{
|
|
|
+ return [];
|
|
|
+}
|
|
|
+
|
|
|
+function callbackFunc2($context)
|
|
|
+{
|
|
|
+ return ["k1" => "v1"];
|
|
|
+}
|
|
|
+
|
|
|
+function assertConnecting($state)
|
|
|
+{
|
|
|
+ assert(($state == GRPC\CHANNEL_CONNECTING || $state == GRPC\CHANNEL_TRANSIENT_FAILURE) == true);
|
|
|
+}
|
|
|
+
|
|
|
+function waitUntilNotIdle($channel) {
|
|
|
+ for ($i = 0; $i < 10; $i++) {
|
|
|
+ $now = Grpc\Timeval::now();
|
|
|
+ $deadline = $now->add(new Grpc\Timeval(10000));
|
|
|
+ if ($channel->watchConnectivityState(GRPC\CHANNEL_IDLE,
|
|
|
+ $deadline)) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ assert(true == false);
|
|
|
+}
|
|
|
+
|
|
|
+// Set up
|
|
|
+$channel = new Grpc\Channel('localhost:0', ['credentials' => Grpc\ChannelCredentials::createInsecure()]);
|
|
|
+
|
|
|
+// Test InsecureCredentials
|
|
|
+assert('Grpc\Channel' == get_class($channel));
|
|
|
+
|
|
|
+// Test ConnectivityState
|
|
|
+$state = $channel->getConnectivityState();
|
|
|
+assert(0 == $state);
|
|
|
+
|
|
|
+// Test GetConnectivityStateWithInt
|
|
|
+$state = $channel->getConnectivityState(123);
|
|
|
+assert(0 == $state);
|
|
|
+
|
|
|
+// Test GetConnectivityStateWithString
|
|
|
+$state = $channel->getConnectivityState('hello');
|
|
|
+assert(0 == $state);
|
|
|
+
|
|
|
+// Test GetConnectivityStateWithBool
|
|
|
+$state = $channel->getConnectivityState(true);
|
|
|
+assert(0 == $state);
|
|
|
+
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test GetTarget
|
|
|
+$channel = new Grpc\Channel('localhost:8888', ['credentials' => Grpc\ChannelCredentials::createInsecure()]);
|
|
|
+$target = $channel->getTarget();
|
|
|
+assert(is_string($target) == true);
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test WatchConnectivityState
|
|
|
+$channel = new Grpc\Channel('localhost:0', ['credentials' => Grpc\ChannelCredentials::createInsecure()]);
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$deadline = $now->add(new Grpc\Timeval(100*1000));
|
|
|
+
|
|
|
+$state = $channel->watchConnectivityState(1, $deadline);
|
|
|
+assert($state == true);
|
|
|
+
|
|
|
+unset($now);
|
|
|
+unset($deadline);
|
|
|
+
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test InvalidConstructorWithNull
|
|
|
+try {
|
|
|
+ $channel = new Grpc\Channel();
|
|
|
+ assert($channel == NULL);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidConstructorWith
|
|
|
+try {
|
|
|
+ $channel = new Grpc\Channel('localhost:0', 'invalid');
|
|
|
+ assert($channel == NULL);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalideCredentials
|
|
|
+try {
|
|
|
+ $channel = new Grpc\Channel('localhost:0', ['credentials' => new Grpc\Timeval(100)]);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidOptionsArrray
|
|
|
+try {
|
|
|
+ $channel = new Grpc\Channel('localhost:0', ['abc' => []]);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidGetConnectivityStateWithArray
|
|
|
+$channel = new Grpc\Channel('localhost:0', ['credentials' => Grpc\ChannelCredentials::createInsecure()]);
|
|
|
+try {
|
|
|
+ $channel->getConnectivityState([]);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidWatchConnectivityState
|
|
|
+try {
|
|
|
+ $channel->watchConnectivityState([]);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidWatchConnectivityState2
|
|
|
+try {
|
|
|
+ $channel->watchConnectivityState(1, 'hi');
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test PersistentChannelSameHost
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', []);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', []);
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelDifferentHost
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', ["grpc_target_persist_bound" => 3,]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:2', []);
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelSameArgs
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ "abc" => "def",
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', ["abc" => "def"]);
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelDifferentArgs
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', []);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', ["abc" => "def"]);
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelSameChannelCredentials
|
|
|
+$creds1 = Grpc\ChannelCredentials::createSsl();
|
|
|
+$creds2 = Grpc\ChannelCredentials::createSsl();
|
|
|
+
|
|
|
+$channel1 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds1,
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds2]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+print "state: ".$state."......................";
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelDifferentChannelCredentials
|
|
|
+$creds1 = Grpc\ChannelCredentials::createSsl();
|
|
|
+$creds2 = Grpc\ChannelCredentials::createSsl(
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/ca.pem'));
|
|
|
+
|
|
|
+$channel1 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds1,
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds2]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+
|
|
|
+// Test PersistentChannelSameChannelCredentialsRootCerts
|
|
|
+$creds1 = Grpc\ChannelCredentials::createSsl(
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/ca.pem'));
|
|
|
+$creds2 = Grpc\ChannelCredentials::createSsl(
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/ca.pem'));
|
|
|
+
|
|
|
+$channel1 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds1,
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds2]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelDifferentSecureChannelCredentials
|
|
|
+$creds1 = Grpc\ChannelCredentials::createSsl();
|
|
|
+$creds2 = Grpc\ChannelCredentials::createInsecure();
|
|
|
+
|
|
|
+$channel1 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds1,
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds2]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelSharedChannelClose1
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelSharedChannelClose2
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+try{
|
|
|
+ $state = $channel1->getConnectivityState();
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+//Test PersistentChannelCreateAfterClose
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+]);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', []);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+//Test PersistentChannelSharedMoreThanTwo
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', []);
|
|
|
+$channel3 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel3->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+//Test PersistentChannelWithCallCredentials
|
|
|
+$creds = Grpc\ChannelCredentials::createSsl();
|
|
|
+$callCreds = Grpc\CallCredentials::createFromPlugin(
|
|
|
+ 'callbackFunc');
|
|
|
+$credsWithCallCreds = Grpc\ChannelCredentials::createComposite(
|
|
|
+ $creds, $callCreds);
|
|
|
+
|
|
|
+$channel1 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" =>
|
|
|
+ $credsWithCallCreds,
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" =>
|
|
|
+ $credsWithCallCreds]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelWithDifferentCallCredentials
|
|
|
+$callCreds1 = Grpc\CallCredentials::createFromPlugin('callbackFunc');
|
|
|
+$callCreds2 = Grpc\CallCredentials::createFromPlugin('callbackFunc2');
|
|
|
+
|
|
|
+$creds1 = Grpc\ChannelCredentials::createSsl();
|
|
|
+$creds2 = Grpc\ChannelCredentials::createComposite(
|
|
|
+ $creds1, $callCreds1);
|
|
|
+$creds3 = Grpc\ChannelCredentials::createComposite(
|
|
|
+ $creds1, $callCreds2);
|
|
|
+
|
|
|
+$channel1 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds1,
|
|
|
+ "grpc_target_persist_bound" => 3,
|
|
|
+ ]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds2]);
|
|
|
+$channel3 = new Grpc\Channel('localhost:1',
|
|
|
+ ["credentials" => $creds3]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+$state = $channel3->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+$channel3->close();
|
|
|
+
|
|
|
+// Test PersistentChannelForceNew
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 2,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["force_new" => true]);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelForceNewOldChannelIdle1
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 2,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["force_new" => true]);
|
|
|
+$channel3 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$state = $channel2->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel2);
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel3->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelForceNewOldChannelIdle2
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 2,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel2);
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+// Test PersistentChannelForceNewOldChannelClose1
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 2,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["force_new" => true]);
|
|
|
+$channel3 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+$state = $channel3->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+$channel2->close();
|
|
|
+$channel3->close();
|
|
|
+
|
|
|
+// Test PersistentChannelForceNewOldChannelClose2
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 2,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["force_new" => true]);
|
|
|
+// channel3 shares with channel1
|
|
|
+$channel3 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+$state = $channel2->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+// channel3 is still usable
|
|
|
+$state = $channel3->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+// channel 1 is closed
|
|
|
+try{
|
|
|
+ $channel1->getConnectivityState();
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+$channel2->close();
|
|
|
+$channel3->close();
|
|
|
+
|
|
|
+// Test PersistentChannelForceNewNewChannelClose
|
|
|
+$channel1 = new Grpc\Channel('localhost:1', [
|
|
|
+ "grpc_target_persist_bound" => 2,
|
|
|
+]);
|
|
|
+$channel2 = new Grpc\Channel('localhost:1',
|
|
|
+ ["force_new" => true]);
|
|
|
+$channel3 = new Grpc\Channel('localhost:1', []);
|
|
|
+
|
|
|
+$channel2->close();
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assert(GRPC\CHANNEL_IDLE == $state);
|
|
|
+
|
|
|
+// can still connect on channel1
|
|
|
+$state = $channel1->getConnectivityState(true);
|
|
|
+waitUntilNotIdle($channel1);
|
|
|
+
|
|
|
+$state = $channel1->getConnectivityState();
|
|
|
+assertConnecting($state);
|
|
|
+
|
|
|
+$channel1->close();
|
|
|
+
|
|
|
+//============== Call Test ====================
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+$port = $server->addHttp2Port('0.0.0.0:53000');
|
|
|
+$channel = new Grpc\Channel('localhost:'.$port, []);
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+
|
|
|
+// Test AddEmptyMetadata
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+];
|
|
|
+$result = $call->startBatch($batch);
|
|
|
+assert($result->send_metadata == true);
|
|
|
+
|
|
|
+// Test testAddSingleMetadata
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => ['key' => ['value']],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+$result = $call->startBatch($batch);
|
|
|
+assert($result->send_metadata == true);
|
|
|
+
|
|
|
+// Test AddMultiValue
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => ['key' => ['value1', 'value2']],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+$result = $call->startBatch($batch);
|
|
|
+assert($result->send_metadata == true);
|
|
|
+
|
|
|
+// Test AddSingleAndMultiValueMetadata
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => ['key1' => ['value1'],
|
|
|
+ 'key2' => ['value2',
|
|
|
+ 'value3', ], ],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+$result = $call->startBatch($batch);
|
|
|
+assert($result->send_metadata == true);
|
|
|
+
|
|
|
+// Test AddMultiAndMultiValueMetadata
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => ['key1' => ['value1'],
|
|
|
+ 'key2' => ['value2',
|
|
|
+ 'value3', ], ],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+$result = $call->startBatch($batch);
|
|
|
+assert($result->send_metadata == true);
|
|
|
+
|
|
|
+// Test GetPeer
|
|
|
+assert(is_string($call->getPeer()) == true);
|
|
|
+
|
|
|
+// Test Cancel
|
|
|
+assert($call->cancel == NULL);
|
|
|
+
|
|
|
+// Test InvalidStartBatchKey
|
|
|
+$batch = [
|
|
|
+ 'invalid' => ['key1' => 'value1'],
|
|
|
+];
|
|
|
+try{
|
|
|
+ $result = $call->startBatch($batch);
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalideMetadataStrKey
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => ['Key' => ['value1', 'value2']],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+try{
|
|
|
+ $result = $call->startBatch($batch);
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidMetadataIntKey
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [1 => ['value1', 'value2']],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+try{
|
|
|
+ $result = $call->startBatch($batch);
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidMetadataInnerValue
|
|
|
+$batch = [
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => ['key1' => 'value1'],
|
|
|
+];
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/foo',
|
|
|
+ Grpc\Timeval::infFuture());
|
|
|
+try{
|
|
|
+ $result = $call->startBatch($batch);
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidConstuctor
|
|
|
+try {
|
|
|
+ $call = new Grpc\Call();
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidConstuctor2
|
|
|
+try {
|
|
|
+ $call = new Grpc\Call('hi', 'hi', 'hi');
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidSetCredentials
|
|
|
+try{
|
|
|
+ $call->setCredentials('hi');
|
|
|
+}
|
|
|
+catch(\Exception $e){
|
|
|
+}
|
|
|
+
|
|
|
+// Test InvalidSetCredentials2
|
|
|
+try {
|
|
|
+ $call->setCredentials([]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+
|
|
|
+//============== CallCredentials Test 2 ====================
|
|
|
+// Set Up
|
|
|
+$credentials = Grpc\ChannelCredentials::createSsl(
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/ca.pem'));
|
|
|
+$server_credentials = Grpc\ServerCredentials::createSsl(
|
|
|
+ null,
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/server1.key'),
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/server1.pem'));
|
|
|
+$server = new Grpc\Server();
|
|
|
+$port = $server->addSecureHttp2Port('0.0.0.0:0',
|
|
|
+ $server_credentials);
|
|
|
+$server->start();
|
|
|
+$host_override = 'foo.test.google.fr';
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:'.$port,
|
|
|
+ [
|
|
|
+ 'grpc.ssl_target_name_override' => $host_override,
|
|
|
+ 'grpc.default_authority' => $host_override,
|
|
|
+ 'credentials' => $credentials,
|
|
|
+ ]
|
|
|
+);
|
|
|
+function callCredscallbackFunc($context)
|
|
|
+{
|
|
|
+ is_string($context->service_url);
|
|
|
+ is_string($context->method_name);
|
|
|
+ return ['k1' => ['v1'], 'k2' => ['v2']];
|
|
|
+}
|
|
|
+
|
|
|
+// Test CreateFromPlugin
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/abc/dummy_method',
|
|
|
+ $deadline,
|
|
|
+ $host_override);
|
|
|
+ $call_credentials = Grpc\CallCredentials::createFromPlugin(
|
|
|
+ 'callCredscallbackFunc');
|
|
|
+$call->setCredentials($call_credentials);
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert(is_array($event->metadata) == true);
|
|
|
+
|
|
|
+$metadata = $event->metadata;
|
|
|
+assert(array_key_exists('k1', $metadata) == true);
|
|
|
+assert(array_key_exists('k2', $metadata) == true);
|
|
|
+assert($metadata['k1'] == ['v1']);
|
|
|
+assert($metadata['k2'] == ['v2']);
|
|
|
+assert('/abc/dummy_method' == $event->method);
|
|
|
+
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_status == true);
|
|
|
+assert($event->cancelled == false);
|
|
|
+
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+assert([] == $event->metadata);
|
|
|
+
|
|
|
+$status = $event->status;
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+function invalidKeyCallbackFunc($context)
|
|
|
+{
|
|
|
+ is_string($context->service_url);
|
|
|
+ is_string($context->method_name);
|
|
|
+ return ['K1' => ['v1']];
|
|
|
+}
|
|
|
+
|
|
|
+// Test CallbackWithInvalidKey
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/abc/dummy_method',
|
|
|
+ $deadline,
|
|
|
+ $host_override);
|
|
|
+ $call_credentials = Grpc\CallCredentials::createFromPlugin(
|
|
|
+ 'invalidKeyCallbackFunc');
|
|
|
+$call->setCredentials($call_credentials);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+assert(($event->status->code == Grpc\STATUS_UNAVAILABLE) == true);
|
|
|
+
|
|
|
+function invalidReturnCallbackFunc($context)
|
|
|
+{
|
|
|
+ is_string($context->service_url);
|
|
|
+ is_string($context->method_name);
|
|
|
+ return 'a string';
|
|
|
+}
|
|
|
+
|
|
|
+// Test CallbackWithInvalidReturnValue
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ '/abc/dummy_method',
|
|
|
+ $deadline,
|
|
|
+ $host_override);
|
|
|
+ $call_credentials = Grpc\CallCredentials::createFromPlugin(
|
|
|
+ 'invalidReturnCallbackFunc');
|
|
|
+$call->setCredentials($call_credentials);
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+assert(($event->status->code == Grpc\STATUS_UNAVAILABLE) == true);
|
|
|
+
|
|
|
+unset($channel);
|
|
|
+unset($server);
|
|
|
+
|
|
|
+//============== CallCredentials Test ====================
|
|
|
+//Set Up
|
|
|
+$credentials = Grpc\ChannelCredentials::createSsl(
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/ca.pem'));
|
|
|
+$call_credentials = Grpc\CallCredentials::createFromPlugin('callbackFunc');
|
|
|
+$credentials = Grpc\ChannelCredentials::createComposite(
|
|
|
+ $credentials,
|
|
|
+ $call_credentials
|
|
|
+);
|
|
|
+$server_credentials = Grpc\ServerCredentials::createSsl(
|
|
|
+ null,
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/server1.key'),
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/server1.pem'));
|
|
|
+$server = new Grpc\Server();
|
|
|
+$port = $server->addSecureHttp2Port('0.0.0.0:0',
|
|
|
+ $server_credentials);
|
|
|
+$server->start();
|
|
|
+$host_override = 'foo.test.google.fr';
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:'.$port,
|
|
|
+ [
|
|
|
+ 'grpc.ssl_target_name_override' => $host_override,
|
|
|
+ 'grpc.default_authority' => $host_override,
|
|
|
+ 'credentials' => $credentials,
|
|
|
+ ]
|
|
|
+);
|
|
|
+
|
|
|
+// Test CreateComposite
|
|
|
+$call_credentials2 = Grpc\CallCredentials::createFromPlugin('callbackFunc');
|
|
|
+$call_credentials3 = Grpc\CallCredentials::createComposite(
|
|
|
+ $call_credentials,
|
|
|
+ $call_credentials2
|
|
|
+);
|
|
|
+assert('Grpc\CallCredentials' == get_class($call_credentials3));
|
|
|
+
|
|
|
+// Test CreateFromPluginInvalidParam
|
|
|
+try{
|
|
|
+ $call_credentials = Grpc\CallCredentials::createFromPlugin(
|
|
|
+ 'callbackFunc'
|
|
|
+ );
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+// Test CreateCompositeInvalidParam
|
|
|
+try{
|
|
|
+ $call_credentials3 = Grpc\CallCredentials::createComposite(
|
|
|
+ $call_credentials,
|
|
|
+ $credentials
|
|
|
+ );
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+unset($channel);
|
|
|
+unset($server);
|
|
|
+
|
|
|
+
|
|
|
+//============== EndToEnd Test ====================
|
|
|
+// Set Up
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+$port = $server->addHttp2Port('0.0.0.0:0');
|
|
|
+$channel = new Grpc\Channel('localhost:'.$port, []);
|
|
|
+$server->start();
|
|
|
+
|
|
|
+// Test SimpleRequestBody
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_status == true);
|
|
|
+assert($event->cancelled == false)
|
|
|
+;
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+$status = $event->status;
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test MessageWriteFlags
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'message_write_flags_test';
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text,
|
|
|
+ 'flags' => Grpc\WRITE_NO_COMPRESS, ],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+]);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+$status = $event->status;
|
|
|
+
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test ClientServerFullRequestResponse
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+assert($event->send_message == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+$server_call = $event->call;
|
|
|
+
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_status == true);
|
|
|
+assert($event->send_message == true);
|
|
|
+assert($event->cancelled == false);
|
|
|
+assert($req_text == $event->message);
|
|
|
+
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+assert([] == $event->metadata);
|
|
|
+assert($reply_text == $event->message);
|
|
|
+$status = $event->status;
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test InvalidClientMessageArray
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+try {
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => 'invalid',
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidClientMessageString
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+try{
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => 0],
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidClientMessageFlags
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+try{
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => 'abc',
|
|
|
+ 'flags' => 'invalid',
|
|
|
+ ],
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidServerStatusMetadata
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+assert($event->send_message == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+$server_call = $event->call;
|
|
|
+try {
|
|
|
+ $event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => 'invalid',
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidServerStatusCode
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+assert($event->send_message == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+$server_call = $event->call;
|
|
|
+try {
|
|
|
+ $event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => 'invalid',
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test MissingServerStatusCode
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+$event = $server->requestCall();
|
|
|
+$server_call = $event->call;
|
|
|
+try {
|
|
|
+ $event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidServerStatusDetails
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+$event = $server->requestCall();
|
|
|
+$server_call = $event->call;
|
|
|
+try {
|
|
|
+ $event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => 0,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test MissingServerStatusDetails
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+$event = $server->requestCall();
|
|
|
+$server_call = $event->call;
|
|
|
+try {
|
|
|
+ $event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidStartBatchKey
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+try {
|
|
|
+ $event = $call->startBatch([
|
|
|
+ 9999999 => [],
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test InvalidStartBatch
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline);
|
|
|
+try {
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => 'abc',
|
|
|
+ ],
|
|
|
+ ]);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+
|
|
|
+// Test GetTarget
|
|
|
+assert(is_string($channel->getTarget()) == true);
|
|
|
+
|
|
|
+// Test GetConnectivityState
|
|
|
+assert(($channel->getConnectivityState() ==
|
|
|
+ Grpc\CHANNEL_IDLE) == true);
|
|
|
+
|
|
|
+// Test WatchConnectivityStateFailed
|
|
|
+$idle_state = $channel->getConnectivityState();
|
|
|
+assert(($idle_state == Grpc\CHANNEL_IDLE) == true);
|
|
|
+
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(50000); // should timeout
|
|
|
+$deadline = $now->add($delta);
|
|
|
+assert($channel->watchConnectivityState(
|
|
|
+ $idle_state, $deadline) == false);
|
|
|
+
|
|
|
+// Test WatchConnectivityStateSuccess()
|
|
|
+$idle_state = $channel->getConnectivityState(true);
|
|
|
+assert(($idle_state == Grpc\CHANNEL_IDLE) == true);
|
|
|
+
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(3000000); // should finish well before
|
|
|
+$deadline = $now->add($delta);
|
|
|
+$new_state = $channel->getConnectivityState();
|
|
|
+assert($new_state != $idle_state);
|
|
|
+
|
|
|
+// Test WatchConnectivityStateDoNothing
|
|
|
+$idle_state = $channel->getConnectivityState();
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(50000);
|
|
|
+$deadline = $now->add($delta);
|
|
|
+assert(!$channel->watchConnectivityState(
|
|
|
+ $idle_state, $deadline));
|
|
|
+
|
|
|
+$new_state = $channel->getConnectivityState();
|
|
|
+assert($new_state == Grpc\CHANNEL_IDLE);
|
|
|
+
|
|
|
+// Test GetConnectivityStateInvalidParam
|
|
|
+try {
|
|
|
+ $channel->getConnectivityState(new Grpc\Timeval());
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// Test WatchConnectivityStateInvalidParam
|
|
|
+try {
|
|
|
+ $channel->watchConnectivityState(0, 1000);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// Test ChannelConstructorInvalidParam
|
|
|
+try {
|
|
|
+ $channel = new Grpc\Channel('localhost:'.$port, null);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// testClose()
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+
|
|
|
+//============== SecureEndToEnd Test ====================
|
|
|
+// Set Up
|
|
|
+
|
|
|
+$credentials = Grpc\ChannelCredentials::createSsl(
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/ca.pem'));
|
|
|
+$server_credentials = Grpc\ServerCredentials::createSsl(
|
|
|
+ null,
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/server1.key'),
|
|
|
+ file_get_contents(dirname(__FILE__).'/../data/server1.pem'));
|
|
|
+$server = new Grpc\Server();
|
|
|
+$port = $server->addSecureHttp2Port('0.0.0.0:0',
|
|
|
+ $server_credentials);
|
|
|
+$server->start();
|
|
|
+$host_override = 'foo.test.google.fr';
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:'.$port,
|
|
|
+ [
|
|
|
+ 'grpc.ssl_target_name_override' => $host_override,
|
|
|
+ 'grpc.default_authority' => $host_override,
|
|
|
+ 'credentials' => $credentials,
|
|
|
+ ]
|
|
|
+);
|
|
|
+
|
|
|
+// Test SimpleRequestBody
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline,
|
|
|
+ $host_override);
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_status == true);
|
|
|
+assert($event->cancelled == false);
|
|
|
+
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+assert([] == $event->metadata);
|
|
|
+$status = $event->status;
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test MessageWriteFlags
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'message_write_flags_test';
|
|
|
+$status_text = 'xyz';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline,
|
|
|
+ $host_override);
|
|
|
+ $event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text,
|
|
|
+ 'flags' => Grpc\WRITE_NO_COMPRESS, ],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+]);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+assert([] == $event->metadata);
|
|
|
+$status = $event->status;
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);unset($call);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test ClientServerFullRequestResponse
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$req_text = 'client_server_full_request_response';
|
|
|
+$reply_text = 'reply:client_server_full_request_response';
|
|
|
+$status_text = 'status:client_server_full_response_text';
|
|
|
+$call = new Grpc\Call($channel,
|
|
|
+ 'dummy_method',
|
|
|
+ $deadline,
|
|
|
+ $host_override);
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $req_text],
|
|
|
+]);
|
|
|
+assert($event->send_metadata == true);
|
|
|
+assert($event->send_close == true);
|
|
|
+assert($event->send_message == true);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('dummy_method' == $event->method);
|
|
|
+
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_MESSAGE => ['message' => $reply_text],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => $status_text,
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert($event->send_metadata);
|
|
|
+assert($event->send_status);
|
|
|
+assert($event->send_message);
|
|
|
+assert(!$event->cancelled);
|
|
|
+assert($req_text == $event->message);
|
|
|
+
|
|
|
+$event = $call->startBatch([
|
|
|
+ Grpc\OP_RECV_INITIAL_METADATA => true,
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_STATUS_ON_CLIENT => true,
|
|
|
+]);
|
|
|
+assert([] == $event->metadata);
|
|
|
+assert($reply_text == $event->message);
|
|
|
+$status = $event->status;
|
|
|
+assert([] == $status->metadata);
|
|
|
+assert(Grpc\STATUS_OK == $status->code);
|
|
|
+assert($status_text == $status->details);
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+
|
|
|
+//============== Timeval Test ====================
|
|
|
+// Test ConstructorWithInt
|
|
|
+$time = new Grpc\Timeval(1234);
|
|
|
+assert($time != NULL);
|
|
|
+assert('Grpc\Timeval' == get_class($time));
|
|
|
+
|
|
|
+// Test ConstructorWithNegative
|
|
|
+$time = new Grpc\Timeval(-123);
|
|
|
+assert($time != NULL);
|
|
|
+assert('Grpc\Timeval' == get_class($time));
|
|
|
+
|
|
|
+// Test ConstructorWithZero
|
|
|
+$time = new Grpc\Timeval(0);
|
|
|
+assert($time != NULL);
|
|
|
+assert('Grpc\Timeval' == get_class($time));
|
|
|
+
|
|
|
+// Test ConstructorWithOct
|
|
|
+$time = new Grpc\Timeval(0123);
|
|
|
+assert($time != NULL);
|
|
|
+assert('Grpc\Timeval' == get_class($time));
|
|
|
+
|
|
|
+// Test ConstructorWithHex
|
|
|
+$time = new Grpc\Timeval(0x1A);
|
|
|
+assert($time != NULL);
|
|
|
+assert('Grpc\Timeval' == get_class($time));
|
|
|
+
|
|
|
+// Test ConstructorWithFloat
|
|
|
+$time = new Grpc\Timeval(123.456);
|
|
|
+assert($time != NULL);
|
|
|
+assert('Grpc\Timeval' == get_class($time));
|
|
|
+
|
|
|
+// Test CompareSame
|
|
|
+$zero = Grpc\Timeval::zero();
|
|
|
+assert(0 == Grpc\Timeval::compare($zero, $zero));
|
|
|
+
|
|
|
+// Test PastIsLessThanZero
|
|
|
+$zero = Grpc\Timeval::zero();
|
|
|
+$past = Grpc\Timeval::infPast();
|
|
|
+assert(0 > Grpc\Timeval::compare($past, $zero));
|
|
|
+assert(0 < Grpc\Timeval::compare($zero, $past));
|
|
|
+
|
|
|
+// Test FutureIsGreaterThanZero
|
|
|
+$zero = Grpc\Timeval::zero();
|
|
|
+$future = Grpc\Timeval::infFuture();
|
|
|
+assert(0 > Grpc\Timeval::compare($zero, $future));
|
|
|
+assert(0 < Grpc\Timeval::compare($future, $zero));
|
|
|
+
|
|
|
+// Test NowIsBetweenZeroAndFuture
|
|
|
+$zero = Grpc\Timeval::zero();
|
|
|
+$future = Grpc\Timeval::infFuture();
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+assert(0 > Grpc\Timeval::compare($zero, $now));
|
|
|
+assert(0 > Grpc\Timeval::compare($now, $future));
|
|
|
+
|
|
|
+// Test NowAndAdd
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+assert($now != NULL);
|
|
|
+$delta = new Grpc\Timeval(1000);
|
|
|
+$deadline = $now->add($delta);
|
|
|
+assert(0 < Grpc\Timeval::compare($deadline, $now));
|
|
|
+
|
|
|
+// Test NowAndSubtract
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(1000);
|
|
|
+$deadline = $now->subtract($delta);
|
|
|
+assert(0 > Grpc\Timeval::compare($deadline, $now));
|
|
|
+
|
|
|
+// Test AddAndSubtract
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(1000);
|
|
|
+$deadline = $now->add($delta);
|
|
|
+$back_to_now = $deadline->subtract($delta);
|
|
|
+assert(0 == Grpc\Timeval::compare($back_to_now, $now));
|
|
|
+
|
|
|
+// Test Similar
|
|
|
+$a = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(1000);
|
|
|
+$b = $a->add($delta);
|
|
|
+$thresh = new Grpc\Timeval(1100);
|
|
|
+assert(Grpc\Timeval::similar($a, $b, $thresh));
|
|
|
+$thresh = new Grpc\Timeval(900);
|
|
|
+assert(!Grpc\Timeval::similar($a, $b, $thresh));
|
|
|
+
|
|
|
+// Test SleepUntil
|
|
|
+$curr_microtime = microtime(true);
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$delta = new Grpc\Timeval(1000);
|
|
|
+$deadline = $now->add($delta);
|
|
|
+$deadline->sleepUntil();
|
|
|
+$done_microtime = microtime(true);
|
|
|
+assert(($done_microtime - $curr_microtime) > 0.0009);
|
|
|
+
|
|
|
+// Test ConstructorInvalidParam
|
|
|
+try {
|
|
|
+ $delta = new Grpc\Timeval('abc');
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// Test AddInvalidParam
|
|
|
+$a = Grpc\Timeval::now();
|
|
|
+try {
|
|
|
+ $a->add(1000);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// Test SubtractInvalidParam
|
|
|
+$a = Grpc\Timeval::now();
|
|
|
+try {
|
|
|
+ $a->subtract(1000);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// Test CompareInvalidParam
|
|
|
+try {
|
|
|
+ $a = Grpc\Timeval::compare(1000, 1100);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+// Test SimilarInvalidParam
|
|
|
+try {
|
|
|
+ $a = Grpc\Timeval::similar(1000, 1100, 1200);
|
|
|
+} catch (\Exception $e) {}
|
|
|
+ unset($time);
|
|
|
+
|
|
|
+ //============== Server Test ====================
|
|
|
+ //Set Up
|
|
|
+ $server = NULL;
|
|
|
+
|
|
|
+ // Test ConstructorWithNull
|
|
|
+$server = new Grpc\Server();
|
|
|
+assert($server != NULL);
|
|
|
+
|
|
|
+// Test ConstructorWithNullArray
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+assert($server != NULL);
|
|
|
+
|
|
|
+// Test ConstructorWithArray
|
|
|
+$server = new Grpc\Server(['ip' => '127.0.0.1',
|
|
|
+ 'port' => '8080', ]);
|
|
|
+assert($server != NULL);
|
|
|
+
|
|
|
+// Test RequestCall
|
|
|
+$server = new Grpc\Server();
|
|
|
+$port = $server->addHttp2Port('0.0.0.0:0');
|
|
|
+$server->start();
|
|
|
+$channel = new Grpc\Channel('localhost:'.$port,
|
|
|
+ [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure()
|
|
|
+ ]);
|
|
|
+
|
|
|
+$deadline = Grpc\Timeval::infFuture();
|
|
|
+$call = new Grpc\Call($channel, 'dummy_method', $deadline);
|
|
|
+
|
|
|
+$event = $call->startBatch([Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_CLOSE_FROM_CLIENT => true,
|
|
|
+ ]);
|
|
|
+
|
|
|
+$c = $server->requestCall();
|
|
|
+assert('dummy_method' == $c->method);
|
|
|
+assert(is_string($c->host));
|
|
|
+
|
|
|
+unset($call);
|
|
|
+unset($channel);
|
|
|
+
|
|
|
+// Test InvalidConstructorWithNumKeyOfArray
|
|
|
+try{
|
|
|
+ $server = new Grpc\Server([10 => '127.0.0.1',
|
|
|
+ 20 => '8080', ]);
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+// Test Invalid ArgumentException
|
|
|
+try{
|
|
|
+ $server = new Grpc\Server(['127.0.0.1', '8080']);
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+// Test InvalidAddHttp2Port
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+try{
|
|
|
+ $port = $server->addHttp2Port(['0.0.0.0:0']);
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+// Test InvalidAddSecureHttp2Port
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+try{
|
|
|
+ $port = $server->addSecureHttp2Port(['0.0.0.0:0']);
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+// Test InvalidAddSecureHttp2Port2
|
|
|
+$server = new Grpc\Server();
|
|
|
+try{
|
|
|
+ $port = $server->addSecureHttp2Port('0.0.0.0:0');
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+
|
|
|
+// Test InvalidAddSecureHttp2Port3
|
|
|
+$server = new Grpc\Server();
|
|
|
+try{
|
|
|
+ $port = $server->addSecureHttp2Port('0.0.0.0:0', 'invalid');
|
|
|
+}
|
|
|
+catch(\Exception $e){}
|
|
|
+unset($server);
|
|
|
+
|
|
|
+
|
|
|
+//============== ChannelCredential Test ====================
|
|
|
+// Test CreateSslWith3Null
|
|
|
+$channel_credentials = Grpc\ChannelCredentials::createSsl(null, null,
|
|
|
+ null);
|
|
|
+assert($channel_credentials != NULL);
|
|
|
+
|
|
|
+// Test CreateSslWith3NullString
|
|
|
+$channel_credentials = Grpc\ChannelCredentials::createSsl('', '', '');
|
|
|
+assert($channel_credentials != NULL);
|
|
|
+
|
|
|
+// Test CreateInsecure
|
|
|
+$channel_credentials = Grpc\ChannelCredentials::createInsecure();
|
|
|
+assert($channel_credentials == NULL);
|
|
|
+
|
|
|
+// Test InvalidCreateSsl()
|
|
|
+try {
|
|
|
+ $channel_credentials = Grpc\ChannelCredentials::createSsl([]);
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+try {
|
|
|
+ $channel_credentials = Grpc\ChannelCredentials::createComposite(
|
|
|
+ 'something', 'something');
|
|
|
+}
|
|
|
+catch (\Exception $e) {
|
|
|
+}
|
|
|
+
|
|
|
+//============== Interceptor Test ====================
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/BaseStub.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/AbstractCall.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/UnaryCall.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/ClientStreamingCall.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/Interceptor.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/CallInvoker.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/DefaultCallInvoker.php');
|
|
|
+require_once(dirname(__FILE__).'/../../lib/Grpc/Internal/InterceptorChannel.php');
|
|
|
+
|
|
|
+class SimpleRequest
|
|
|
+{
|
|
|
+ private $data;
|
|
|
+ public function __construct($data)
|
|
|
+ {
|
|
|
+ $this->data = $data;
|
|
|
+ }
|
|
|
+ public function setData($data)
|
|
|
+ {
|
|
|
+ $this->data = $data;
|
|
|
+ }
|
|
|
+ public function serializeToString()
|
|
|
+ {
|
|
|
+ return $this->data;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class InterceptorClient extends Grpc\BaseStub
|
|
|
+{
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param string $hostname hostname
|
|
|
+ * @param array $opts channel options
|
|
|
+ * @param Channel|InterceptorChannel $channel (optional) re-use channel object
|
|
|
+ */
|
|
|
+ public function __construct($hostname, $opts, $channel = null)
|
|
|
+ {
|
|
|
+ parent::__construct($hostname, $opts, $channel);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * A simple RPC.
|
|
|
+ * @param SimpleRequest $argument input argument
|
|
|
+ * @param array $metadata metadata
|
|
|
+ * @param array $options call options
|
|
|
+ */
|
|
|
+ public function UnaryCall(
|
|
|
+ SimpleRequest $argument,
|
|
|
+ $metadata = [],
|
|
|
+ $options = []
|
|
|
+ ) {
|
|
|
+ return $this->_simpleRequest(
|
|
|
+ '/dummy_method',
|
|
|
+ $argument,
|
|
|
+ [],
|
|
|
+ $metadata,
|
|
|
+ $options
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * A client-to-server streaming RPC.
|
|
|
+ * @param array $metadata metadata
|
|
|
+ * @param array $options call options
|
|
|
+ */
|
|
|
+ public function StreamCall(
|
|
|
+ $metadata = [],
|
|
|
+ $options = []
|
|
|
+ ) {
|
|
|
+ return $this->_clientStreamRequest('/dummy_method', [], $metadata, $options);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class ChangeMetadataInterceptor extends Grpc\Interceptor
|
|
|
+{
|
|
|
+ public function interceptUnaryUnary($method,
|
|
|
+ $argument,
|
|
|
+ $deserialize,
|
|
|
+ array $metadata = [],
|
|
|
+ array $options = [],
|
|
|
+ $continuation)
|
|
|
+ {
|
|
|
+ $metadata["foo"] = array('interceptor_from_unary_request');
|
|
|
+ return $continuation($method, $argument, $deserialize, $metadata, $options);
|
|
|
+ }
|
|
|
+ public function interceptStreamUnary($method, $deserialize, array $metadata = [], array $options = [], $continuation)
|
|
|
+ {
|
|
|
+ $metadata["foo"] = array('interceptor_from_stream_request');
|
|
|
+ return $continuation($method, $deserialize, $metadata, $options);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class ChangeMetadataInterceptor2 extends Grpc\Interceptor
|
|
|
+{
|
|
|
+ public function interceptUnaryUnary($method,
|
|
|
+ $argument,
|
|
|
+ $deserialize,
|
|
|
+ array $metadata = [],
|
|
|
+ array $options = [],
|
|
|
+ $continuation)
|
|
|
+ {
|
|
|
+ if (array_key_exists('foo', $metadata)) {
|
|
|
+ $metadata['bar'] = array('ChangeMetadataInterceptor should be executed first');
|
|
|
+ } else {
|
|
|
+ $metadata["bar"] = array('interceptor_from_unary_request');
|
|
|
+ }
|
|
|
+ return $continuation($method, $argument, $deserialize, $metadata, $options);
|
|
|
+ }
|
|
|
+ public function interceptStreamUnary($method,
|
|
|
+ $deserialize,
|
|
|
+ array $metadata = [],
|
|
|
+ array $options = [],
|
|
|
+ $continuation)
|
|
|
+ {
|
|
|
+ if (array_key_exists('foo', $metadata)) {
|
|
|
+ $metadata['bar'] = array('ChangeMetadataInterceptor should be executed first');
|
|
|
+ } else {
|
|
|
+ $metadata["bar"] = array('interceptor_from_stream_request');
|
|
|
+ }
|
|
|
+ return $continuation($method, $deserialize, $metadata, $options);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class ChangeRequestCall
|
|
|
+{
|
|
|
+ private $call;
|
|
|
+
|
|
|
+ public function __construct($call)
|
|
|
+ {
|
|
|
+ $this->call = $call;
|
|
|
+ }
|
|
|
+ public function getCall()
|
|
|
+ {
|
|
|
+ return $this->call;
|
|
|
+ }
|
|
|
+
|
|
|
+ public function write($request)
|
|
|
+ {
|
|
|
+ $request->setData('intercepted_stream_request');
|
|
|
+ $this->getCall()->write($request);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function wait()
|
|
|
+ {
|
|
|
+ return $this->getCall()->wait();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class ChangeRequestInterceptor extends Grpc\Interceptor
|
|
|
+{
|
|
|
+ public function interceptUnaryUnary($method,
|
|
|
+ $argument,
|
|
|
+ $deserialize,
|
|
|
+ array $metadata = [],
|
|
|
+ array $options = [],
|
|
|
+ $continuation)
|
|
|
+ {
|
|
|
+ $argument->setData('intercepted_unary_request');
|
|
|
+ return $continuation($method, $argument, $deserialize, $metadata, $options);
|
|
|
+ }
|
|
|
+ public function interceptStreamUnary($method, $deserialize, array $metadata = [], array $options = [], $continuation)
|
|
|
+ {
|
|
|
+ return new ChangeRequestCall(
|
|
|
+ $continuation($method, $deserialize, $metadata, $options)
|
|
|
+ );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class StopCallInterceptor extends Grpc\Interceptor
|
|
|
+{
|
|
|
+ public function interceptUnaryUnary($method,
|
|
|
+ $argument,
|
|
|
+ array $metadata = [],
|
|
|
+ array $options = [],
|
|
|
+ $continuation)
|
|
|
+ {
|
|
|
+ $metadata["foo"] = array('interceptor_from_request_response');
|
|
|
+ }
|
|
|
+ public function interceptStreamUnary($method,
|
|
|
+ array $metadata = [],
|
|
|
+ array $options = [],
|
|
|
+ $continuation)
|
|
|
+ {
|
|
|
+ $metadata["foo"] = array('interceptor_from_request_response');
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Set Up
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+$port = $server->addHttp2Port('0.0.0.0:0');
|
|
|
+$channel = new Grpc\Channel('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure()]);
|
|
|
+$server->start();
|
|
|
+
|
|
|
+// Test ClientChangeMetadataOneInterceptor
|
|
|
+$req_text = 'client_request';
|
|
|
+$channel_matadata_interceptor = new ChangeMetadataInterceptor();
|
|
|
+$intercept_channel = Grpc\Interceptor::intercept($channel, $channel_matadata_interceptor);
|
|
|
+$client = new InterceptorClient('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure(),
|
|
|
+], $intercept_channel);
|
|
|
+$req = new SimpleRequest($req_text);
|
|
|
+$unary_call = $client->UnaryCall($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+assert(['interceptor_from_unary_request'] == $event->metadata['foo']);
|
|
|
+
|
|
|
+$stream_call = $client->StreamCall();
|
|
|
+$stream_call->write($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+assert(['interceptor_from_stream_request'] == $event->metadata['foo']);
|
|
|
+
|
|
|
+unset($unary_call);
|
|
|
+unset($stream_call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test ClientChangeMetadataTwoInterceptor
|
|
|
+$req_text = 'client_request';
|
|
|
+$channel_matadata_interceptor = new ChangeMetadataInterceptor();
|
|
|
+$channel_matadata_intercepto2 = new ChangeMetadataInterceptor2();
|
|
|
+// test intercept separately.
|
|
|
+$intercept_channel1 = Grpc\Interceptor::intercept($channel, $channel_matadata_interceptor);
|
|
|
+$intercept_channel2 = Grpc\Interceptor::intercept($intercept_channel1, $channel_matadata_intercepto2);
|
|
|
+$client = new InterceptorClient('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure(),
|
|
|
+], $intercept_channel2);
|
|
|
+
|
|
|
+$req = new SimpleRequest($req_text);
|
|
|
+$unary_call = $client->UnaryCall($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+assert(['interceptor_from_unary_request'] == $event->metadata['foo']);
|
|
|
+assert(['interceptor_from_unary_request'] == $event->metadata['bar']);
|
|
|
+
|
|
|
+$stream_call = $client->StreamCall();
|
|
|
+$stream_call->write($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+assert(['interceptor_from_stream_request'] == $event->metadata['foo']);
|
|
|
+assert(['interceptor_from_stream_request'] == $event->metadata['bar']);
|
|
|
+
|
|
|
+unset($unary_call);
|
|
|
+unset($stream_call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// test intercept by array.
|
|
|
+$intercept_channel3 = Grpc\Interceptor::intercept($channel,
|
|
|
+ [$channel_matadata_intercepto2, $channel_matadata_interceptor]);
|
|
|
+$client = new InterceptorClient('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure(),
|
|
|
+], $intercept_channel3);
|
|
|
+
|
|
|
+$req = new SimpleRequest($req_text);
|
|
|
+$unary_call = $client->UnaryCall($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+assert(['interceptor_from_unary_request'] == $event->metadata['foo']);
|
|
|
+assert(['interceptor_from_unary_request'] == $event->metadata['bar']);
|
|
|
+
|
|
|
+$stream_call = $client->StreamCall();
|
|
|
+$stream_call->write($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+assert(['interceptor_from_stream_request'] == $event->metadata['foo']);
|
|
|
+assert(['interceptor_from_stream_request'] == $event->metadata['bar']);
|
|
|
+
|
|
|
+unset($unary_call);
|
|
|
+unset($stream_call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+
|
|
|
+// Test ClientChangeRequestInterceptor
|
|
|
+$req_text = 'client_request';
|
|
|
+$change_request_interceptor = new ChangeRequestInterceptor();
|
|
|
+$intercept_channel = Grpc\Interceptor::intercept($channel,
|
|
|
+ $change_request_interceptor);
|
|
|
+$client = new InterceptorClient('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure(),
|
|
|
+], $intercept_channel);
|
|
|
+
|
|
|
+$req = new SimpleRequest($req_text);
|
|
|
+$unary_call = $client->UnaryCall($req);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => '',
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert('intercepted_unary_request' == $event->message);
|
|
|
+
|
|
|
+$stream_call = $client->StreamCall();
|
|
|
+$stream_call->write($req);
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => '',
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert('intercepted_stream_request' == $event->message);
|
|
|
+
|
|
|
+unset($unary_call);
|
|
|
+unset($stream_call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test ClientChangeStopCallInterceptor
|
|
|
+$req_text = 'client_request';
|
|
|
+$channel_request_interceptor = new StopCallInterceptor();
|
|
|
+$intercept_channel = Grpc\Interceptor::intercept($channel,
|
|
|
+ $channel_request_interceptor);
|
|
|
+$client = new InterceptorClient('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure(),
|
|
|
+], $intercept_channel);
|
|
|
+
|
|
|
+$req = new SimpleRequest($req_text);
|
|
|
+$unary_call = $client->UnaryCall($req);
|
|
|
+assert($unary_call == NULL);
|
|
|
+
|
|
|
+
|
|
|
+$stream_call = $client->StreamCall();
|
|
|
+assert($stream_call == NULL);
|
|
|
+
|
|
|
+unset($unary_call);
|
|
|
+unset($stream_call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+// Test GetInterceptorChannelConnectivityState
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:0',
|
|
|
+ [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure()
|
|
|
+ ]
|
|
|
+);
|
|
|
+$interceptor_channel = Grpc\Interceptor::intercept($channel, new Grpc\Interceptor());
|
|
|
+$state = $interceptor_channel->getConnectivityState();
|
|
|
+assert(0 == $state);
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test InterceptorChannelWatchConnectivityState
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:0',
|
|
|
+ [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure()
|
|
|
+ ]
|
|
|
+);
|
|
|
+$interceptor_channel = Grpc\Interceptor::intercept($channel, new Grpc\Interceptor());
|
|
|
+$now = Grpc\Timeval::now();
|
|
|
+$deadline = $now->add(new Grpc\Timeval(100*1000));
|
|
|
+$state = $interceptor_channel->watchConnectivityState(1, $deadline);
|
|
|
+assert($state);
|
|
|
+unset($time);
|
|
|
+unset($deadline);
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test InterceptorChannelClose
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:0',
|
|
|
+ [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure()
|
|
|
+ ]
|
|
|
+);
|
|
|
+$interceptor_channel = Grpc\Interceptor::intercept($channel, new Grpc\Interceptor());
|
|
|
+assert($interceptor_channel != NULL);
|
|
|
+$channel->close();
|
|
|
+
|
|
|
+// Test InterceptorChannelGetTarget
|
|
|
+$channel = new Grpc\Channel(
|
|
|
+ 'localhost:8888',
|
|
|
+ [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure()
|
|
|
+ ]
|
|
|
+);
|
|
|
+$interceptor_channel = Grpc\Interceptor::intercept($channel, new Grpc\Interceptor());
|
|
|
+$target = $interceptor_channel->getTarget();
|
|
|
+assert(is_string($target));
|
|
|
+
|
|
|
+$channel->close();
|
|
|
+unset($server);
|
|
|
+
|
|
|
+
|
|
|
+//============== CallInvoker Test ====================
|
|
|
+class CallInvokerSimpleRequest
|
|
|
+{
|
|
|
+ private $data;
|
|
|
+ public function __construct($data)
|
|
|
+ {
|
|
|
+ $this->data = $data;
|
|
|
+ }
|
|
|
+ public function setData($data)
|
|
|
+ {
|
|
|
+ $this->data = $data;
|
|
|
+ }
|
|
|
+ public function serializeToString()
|
|
|
+ {
|
|
|
+ return $this->data;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class CallInvokerClient extends Grpc\BaseStub
|
|
|
+{
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param string $hostname hostname
|
|
|
+ * @param array $opts channel options
|
|
|
+ * @param Channel|InterceptorChannel $channel (optional) re-use channel object
|
|
|
+ */
|
|
|
+ public function __construct($hostname, $opts, $channel = null)
|
|
|
+ {
|
|
|
+ parent::__construct($hostname, $opts, $channel);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * A simple RPC.
|
|
|
+ * @param SimpleRequest $argument input argument
|
|
|
+ * @param array $metadata metadata
|
|
|
+ * @param array $options call options
|
|
|
+ */
|
|
|
+ public function UnaryCall(
|
|
|
+ CallInvokerSimpleRequest $argument,
|
|
|
+ $metadata = [],
|
|
|
+ $options = []
|
|
|
+ ) {
|
|
|
+ return $this->_simpleRequest(
|
|
|
+ '/dummy_method',
|
|
|
+ $argument,
|
|
|
+ [],
|
|
|
+ $metadata,
|
|
|
+ $options
|
|
|
+ );
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class CallInvokerUpdateChannel implements \Grpc\CallInvoker
|
|
|
+{
|
|
|
+ private $channel;
|
|
|
+
|
|
|
+ public function getChannel() {
|
|
|
+ return $this->channel;
|
|
|
+ }
|
|
|
+
|
|
|
+ public function createChannelFactory($hostname, $opts) {
|
|
|
+ $this->channel = new \Grpc\Channel('localhost:50050', $opts);
|
|
|
+ return $this->channel;
|
|
|
+ }
|
|
|
+
|
|
|
+ public function UnaryCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new UnaryCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function ClientStreamingCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new ClientStreamingCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function ServerStreamingCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new ServerStreamingCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function BidiStreamingCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new BidiStreamingCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class CallInvokerChangeRequest implements \Grpc\CallInvoker
|
|
|
+{
|
|
|
+ private $channel;
|
|
|
+
|
|
|
+ public function getChannel() {
|
|
|
+ return $this->channel;
|
|
|
+ }
|
|
|
+ public function createChannelFactory($hostname, $opts) {
|
|
|
+ $this->channel = new \Grpc\Channel($hostname, $opts);
|
|
|
+ return $this->channel;
|
|
|
+ }
|
|
|
+
|
|
|
+ public function UnaryCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new CallInvokerChangeRequestCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function ClientStreamingCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new ClientStreamingCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function ServerStreamingCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new ServerStreamingCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function BidiStreamingCall($channel, $method, $deserialize, $options) {
|
|
|
+ return new BidiStreamingCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+class CallInvokerChangeRequestCall
|
|
|
+{
|
|
|
+ private $call;
|
|
|
+
|
|
|
+ public function __construct($channel, $method, $deserialize, $options)
|
|
|
+ {
|
|
|
+ $this->call = new \Grpc\UnaryCall($channel, $method, $deserialize, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function start($argument, $metadata, $options) {
|
|
|
+ $argument->setData('intercepted_unary_request');
|
|
|
+ $this->call->start($argument, $metadata, $options);
|
|
|
+ }
|
|
|
+
|
|
|
+ public function wait()
|
|
|
+ {
|
|
|
+ return $this->call->wait();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Set Up
|
|
|
+$server = new Grpc\Server([]);
|
|
|
+$port = $server->addHttp2Port('0.0.0.0:0');
|
|
|
+$server->start();
|
|
|
+
|
|
|
+// Test CreateDefaultCallInvoker
|
|
|
+$call_invoker = new \Grpc\DefaultCallInvoker();
|
|
|
+
|
|
|
+// Test CreateCallInvoker
|
|
|
+$call_invoker = new CallInvokerUpdateChannel();
|
|
|
+
|
|
|
+// Test CallInvokerAccessChannel
|
|
|
+$call_invoker = new CallInvokerUpdateChannel();
|
|
|
+$stub = new \Grpc\BaseStub('localhost:50051',
|
|
|
+ ['credentials' => \Grpc\ChannelCredentials::createInsecure(),
|
|
|
+ 'grpc_call_invoker' => $call_invoker]);
|
|
|
+assert($call_invoker->getChannel()->getTarget() == 'localhost:50050');
|
|
|
+$call_invoker->getChannel()->close();
|
|
|
+
|
|
|
+// Test ClientChangeRequestCallInvoker
|
|
|
+$req_text = 'client_request';
|
|
|
+$call_invoker = new CallInvokerChangeRequest();
|
|
|
+$client = new CallInvokerClient('localhost:'.$port, [
|
|
|
+ 'force_new' => true,
|
|
|
+ 'credentials' => Grpc\ChannelCredentials::createInsecure(),
|
|
|
+ 'grpc_call_invoker' => $call_invoker,
|
|
|
+]);
|
|
|
+
|
|
|
+$req = new CallInvokerSimpleRequest($req_text);
|
|
|
+$unary_call = $client->UnaryCall($req);
|
|
|
+
|
|
|
+$event = $server->requestCall();
|
|
|
+assert('/dummy_method' == $event->method);
|
|
|
+$server_call = $event->call;
|
|
|
+$event = $server_call->startBatch([
|
|
|
+ Grpc\OP_SEND_INITIAL_METADATA => [],
|
|
|
+ Grpc\OP_SEND_STATUS_FROM_SERVER => [
|
|
|
+ 'metadata' => [],
|
|
|
+ 'code' => Grpc\STATUS_OK,
|
|
|
+ 'details' => '',
|
|
|
+ ],
|
|
|
+ Grpc\OP_RECV_MESSAGE => true,
|
|
|
+ Grpc\OP_RECV_CLOSE_ON_SERVER => true,
|
|
|
+]);
|
|
|
+assert('intercepted_unary_request' == $event->message);
|
|
|
+$call_invoker->getChannel()->close();
|
|
|
+unset($unary_call);
|
|
|
+unset($server_call);
|
|
|
+
|
|
|
+unset($server);
|
|
|
+
|
|
|
+<<<<<<< HEAD
|
|
|
+<<<<<<< HEAD
|
|
|
+echo "Went Through All Unit Tests..............\r\n";
|
|
|
+=======
|
|
|
+echo "Went Through All Unit Tests..............";
|
|
|
+>>>>>>> add MemoryLeakTest
|
|
|
+=======
|
|
|
+echo "Went Through All Unit Tests..............\r\n";
|
|
|
+>>>>>>> complete memory leak test
|
|
|
+
|
|
|
+
|
Bill Feng