+
+ | From/To |
+ CONNECTING |
+ READY |
+ TRANSIENT_FAILURE |
+ IDLE |
+ SHUTDOWN |
+
+
+ | CONNECTING |
+ Incremental progress during connection establishment |
+ All steps needed to establish a connection succeeded |
+ Any failure in any of the steps needed to establish connection |
+ No RPC activity on channel for IDLE_TIMEOUT |
+ Shutdown triggered by application. |
+
+
+ | READY |
+ |
+ Incremental successful communication on established channel. |
+ Any failure encountered while expecting successful communication on
+ established channel. |
+ No RPC activity on channel for IDLE_TIMEOUT
OR
upon receiving a GOAWAY while there are no pending RPCs. |
+ Shutdown triggered by application. |
+
+
+ | TRANSIENT_FAILURE |
+ Wait time required to implement (exponential) backoff is over. |
+ |
+ |
+ |
+ Shutdown triggered by application. |
+
+
+ | IDLE |
+ Any new RPC activity on the channel |
+ |
+ |
+ |
+ Shutdown triggered by application. |
+
+
+ | FATAL_FAILURE |
+ |
+ |
+ |
+ |
+ |
+
+
+
+
+Channel State API
+-----------------
+
+All gRPC libraries will expose a channel-level API method to poll the current
+state of a channel. In C++, this method is called GetCurrentState and returns
+an enum for one of the four legal states.
+
+All libraries should also expose an API that enables the application (user of
+the gRPC API) to be notified when the channel state changes. Since state
+changes can be rapid and race with any such notification, the notification
+should just inform the user that some state change has happened, leaving it to
+the user to poll the channel for the current state.
+
+The synchronous version of this API is:
+
+```cpp
+bool WaitForStateChange(gpr_timespec deadline, ChannelState source_state);
+```
+
+which returns true when the state changes to something other than the
+source_state and false if the deadline expires. Asynchronous and futures based
+APIs should have a corresponding method that allows the application to be
+notified when the state of a channel changes.
+
+Note that a notification is delivered every time there is a transition from any
+state to any *other* state. On the other hand the rules for legal state
+transition, require a transition from CONNECTING to TRANSIENT_FAILURE and back
+to CONNECTING for every recoverable failure, even if the corresponding
+exponential backoff requires no wait before retry. The combined effect is that
+the application may receive state change notifications that appear spurious.
+e.g., an application waiting for state changes on a channel that is CONNECTING
+may receive a state change notification but find the channel in the same
+CONNECTING state on polling for current state because the channel may have
+spent infinitesimally small amount of time in the TRANSIENT_FAILURE state.
diff --git a/gRPC.podspec b/gRPC.podspec
index eaebb27423f..ad621cd2e8a 100644
--- a/gRPC.podspec
+++ b/gRPC.podspec
@@ -1,6 +1,6 @@
Pod::Spec.new do |s|
s.name = 'gRPC'
- s.version = '0.5.1'
+ s.version = '0.6.0'
s.summary = 'gRPC client library for iOS/OSX'
s.homepage = 'http://www.grpc.io'
s.license = 'New BSD'
diff --git a/include/grpc++/async_unary_call.h b/include/grpc++/async_unary_call.h
index 911092b70e6..d631ccd1341 100644
--- a/include/grpc++/async_unary_call.h
+++ b/include/grpc++/async_unary_call.h
@@ -64,7 +64,7 @@ class ClientAsyncResponseReader GRPC_FINAL
: context_(context), call_(channel->CreateCall(method, context, cq)) {
init_buf_.SendInitialMetadata(context->send_initial_metadata_);
// TODO(ctiller): don't assert
- GPR_ASSERT(init_buf_.SendMessage(request).IsOk());
+ GPR_ASSERT(init_buf_.SendMessage(request).ok());
init_buf_.ClientSendClose();
call_.PerformOps(&init_buf_);
}
@@ -120,7 +120,7 @@ class ServerAsyncResponseWriter GRPC_FINAL
ctx_->sent_initial_metadata_ = true;
}
// The response is dropped if the status is not OK.
- if (status.IsOk()) {
+ if (status.ok()) {
finish_buf_.ServerSendStatus(
ctx_->trailing_metadata_, finish_buf_.SendMessage(msg));
} else {
@@ -130,7 +130,7 @@ class ServerAsyncResponseWriter GRPC_FINAL
}
void FinishWithError(const Status& status, void* tag) {
- GPR_ASSERT(!status.IsOk());
+ GPR_ASSERT(!status.ok());
finish_buf_.set_output_tag(tag);
if (!ctx_->sent_initial_metadata_) {
finish_buf_.SendInitialMetadata(ctx_->initial_metadata_);
diff --git a/include/grpc++/byte_buffer.h b/include/grpc++/byte_buffer.h
index a90f4c90b3a..3326f5b21a9 100644
--- a/include/grpc++/byte_buffer.h
+++ b/include/grpc++/byte_buffer.h
@@ -35,6 +35,7 @@
#define GRPCXX_BYTE_BUFFER_H
#include