From bd19fc7e30abcd9ea7cb2bad8217e1b405e8e14f Mon Sep 17 00:00:00 2001
From: Muxi Yan <mxyan@google.com>
Date: Tue, 25 Oct 2016 13:28:12 -0700
Subject: [PATCH] clang-format format clean
---
.../GRPCClient/GRPCCall+ChannelArg.h | 17 +-
.../GRPCClient/GRPCCall+ChannelCredentials.h | 16 +-
src/objective-c/GRPCClient/GRPCCall+OAuth2.h | 14 +-
src/objective-c/GRPCClient/GRPCCall+Tests.h | 25 ++-
src/objective-c/GRPCClient/GRPCCall.h | 189 +++++++++-------
src/objective-c/GRPCClient/GRPCCall.m | 202 +++++++++++-------
.../GRPCClient/private/GRPCCompletionQueue.h | 17 +-
.../private/GRPCConnectivityMonitor.h | 11 +-
.../private/GRPCConnectivityMonitor.m | 15 +-
src/objective-c/GRPCClient/private/GRPCHost.m | 106 +++++----
.../GRPCClient/private/GRPCRequestHeaders.m | 41 ++--
.../GRPCClient/private/GRPCWrappedCall.m | 86 ++++----
.../GRPCClient/private/NSError+GRPC.h | 7 +-
13 files changed, 424 insertions(+), 322 deletions(-)
diff --git a/src/objective-c/GRPCClient/GRPCCall+ChannelArg.h b/src/objective-c/GRPCClient/GRPCCall+ChannelArg.h
index 4a3f3fa4a1..c1623a0068 100644
--- a/src/objective-c/GRPCClient/GRPCCall+ChannelArg.h
+++ b/src/objective-c/GRPCClient/GRPCCall+ChannelArg.h
@@ -40,15 +40,18 @@
@interface GRPCCall (ChannelArg)
/**
- * Use the provided @c userAgentPrefix at the beginning of the HTTP User Agent string for all calls
- * to the specified @c host.
+ * Use the provided @c userAgentPrefix at the beginning of the HTTP User Agent
+ * string for all calls to the specified @c host.
*/
-+ (void)setUserAgentPrefix:(nonnull NSString *)userAgentPrefix forHost:(nonnull NSString *)host;
++ (void)setUserAgentPrefix:(nonnull NSString *)userAgentPrefix
+ forHost:(nonnull NSString *)host;
-/** The default response size limit is 4MB. Set this to override that default. */
+/** The default response size limit is 4MB. Set this to override that default.
+ */
+ (void)setResponseSizeLimit:(NSUInteger)limit forHost:(nonnull NSString *)host;
-+ (void)closeOpenConnections DEPRECATED_MSG_ATTRIBUTE("The API for this feature is experimental, "
- "and might be removed or modified at any "
- "time.");
++ (void)closeOpenConnections DEPRECATED_MSG_ATTRIBUTE(
+ "The API for this feature is experimental, "
+ "and might be removed or modified at any "
+ "time.");
@end
diff --git a/src/objective-c/GRPCClient/GRPCCall+ChannelCredentials.h b/src/objective-c/GRPCClient/GRPCCall+ChannelCredentials.h
index ac2a37d75f..beae0d11a2 100644
--- a/src/objective-c/GRPCClient/GRPCCall+ChannelCredentials.h
+++ b/src/objective-c/GRPCClient/GRPCCall+ChannelCredentials.h
@@ -33,24 +33,26 @@
#import "GRPCCall.h"
-/** Helpers for setting TLS Trusted Roots, Client Certificates, and Private Key */
+/** Helpers for setting TLS Trusted Roots, Client Certificates, and Private Key
+ */
@interface GRPCCall (ChannelCredentials)
/**
- * Use the provided @c pemRootCert as the set of trusted root Certificate Authorities for @c host.
+ * Use the provided @c pemRootCert as the set of trusted root Certificate
+ * Authorities for @c host.
*/
+ (BOOL)setTLSPEMRootCerts:(nullable NSString *)pemRootCert
forHost:(nonnull NSString *)host
- error:(NSError * _Nullable * _Nullable)errorPtr;
+ error:(NSError *_Nullable *_Nullable)errorPtr;
/**
- * Configures @c host with TLS/SSL Client Credentials and optionally trusted root Certificate
- * Authorities. If @c pemRootCerts is nil, the default CA Certificates bundled with gRPC will be
- * used.
+ * Configures @c host with TLS/SSL Client Credentials and optionally trusted
+ * root Certificate Authorities. If @c pemRootCerts is nil, the default CA
+ * Certificates bundled with gRPC will be used.
*/
+ (BOOL)setTLSPEMRootCerts:(nullable NSString *)pemRootCerts
withPrivateKey:(nullable NSString *)pemPrivateKey
withCertChain:(nullable NSString *)pemCertChain
forHost:(nonnull NSString *)host
- error:(NSError * _Nullable * _Nullable)errorPtr;
+ error:(NSError *_Nullable *_Nullable)errorPtr;
@end
diff --git a/src/objective-c/GRPCClient/GRPCCall+OAuth2.h b/src/objective-c/GRPCClient/GRPCCall+OAuth2.h
index 6b443877e9..467c6332c1 100644
--- a/src/objective-c/GRPCClient/GRPCCall+OAuth2.h
+++ b/src/objective-c/GRPCClient/GRPCCall+OAuth2.h
@@ -37,15 +37,17 @@
@interface GRPCCall (OAuth2)
/**
- * Setting this property is equivalent to setting "Bearer <passed token>" as the value of the
- * request header with key "authorization" (the authorization header). Setting it to nil removes the
- * authorization header from the request.
- * The value obtained by getting the property is the OAuth2 bearer token if the authorization header
- * of the request has the form "Bearer <token>", or nil otherwise.
+ * Setting this property is equivalent to setting "Bearer <passed token>" as the
+ * value of the request header with key "authorization" (the authorization
+ * header). Setting it to nil removes the authorization header from the request.
+ * The value obtained by getting the property is the OAuth2 bearer token if the
+ * authorization header of the request has the form "Bearer <token>", or nil
+ * otherwise.
*/
@property(atomic, copy) NSString *oauth2AccessToken;
-/** Returns the value (if any) of the "www-authenticate" response header (the challenge header). */
+/** Returns the value (if any) of the "www-authenticate" response header (the
+ * challenge header). */
@property(atomic, readonly) NSString *oauth2ChallengeHeader;
@end
diff --git a/src/objective-c/GRPCClient/GRPCCall+Tests.h b/src/objective-c/GRPCClient/GRPCCall+Tests.h
index 184ad09c5c..f517f3aac8 100644
--- a/src/objective-c/GRPCClient/GRPCCall+Tests.h
+++ b/src/objective-c/GRPCClient/GRPCCall+Tests.h
@@ -34,33 +34,36 @@
#import "GRPCCall.h"
/**
- * Methods to let tune down the security of gRPC connections for specific hosts. These shouldn't be
- * used in releases, but are sometimes needed for testing.
+ * Methods to let tune down the security of gRPC connections for specific hosts.
+ * These shouldn't be used in releases, but are sometimes needed for testing.
*/
@interface GRPCCall (Tests)
/**
- * Establish all SSL connections to the provided host using the passed SSL target name and the root
- * certificates found in the file at |certsPath|.
+ * Establish all SSL connections to the provided host using the passed SSL
+ * target name and the root certificates found in the file at |certsPath|.
*
- * Must be called before any gRPC call to that host is made. It's illegal to pass the same host to
- * more than one invocation of the methods of this category.
+ * Must be called before any gRPC call to that host is made. It's illegal to
+ * pass the same host to more than one invocation of the methods of this
+ * category.
*/
+ (void)useTestCertsPath:(NSString *)certsPath
testName:(NSString *)testName
forHost:(NSString *)host;
/**
- * Establish all connections to the provided host using cleartext instead of SSL.
+ * Establish all connections to the provided host using cleartext instead of
+ * SSL.
*
- * Must be called before any gRPC call to that host is made. It's illegal to pass the same host to
- * more than one invocation of the methods of this category.
+ * Must be called before any gRPC call to that host is made. It's illegal to
+ * pass the same host to more than one invocation of the methods of this
+ * category.
*/
+ (void)useInsecureConnectionsForHost:(NSString *)host;
/**
- * Resets all host configurations to their default values, and flushes all connections from the
- * cache.
+ * Resets all host configurations to their default values, and flushes all
+ * connections from the cache.
*/
+ (void)resetHostSettings;
@end
diff --git a/src/objective-c/GRPCClient/GRPCCall.h b/src/objective-c/GRPCClient/GRPCCall.h
index 7645bb1d34..5ed160d7a0 100644
--- a/src/objective-c/GRPCClient/GRPCCall.h
+++ b/src/objective-c/GRPCClient/GRPCCall.h
@@ -34,17 +34,18 @@
/**
* The gRPC protocol is an RPC protocol on top of HTTP2.
*
- * While the most common type of RPC receives only one request message and returns only one response
- * message, the protocol also supports RPCs that return multiple individual messages in a streaming
- * fashion, RPCs that accept a stream of request messages, or RPCs with both streaming requests and
+ * While the most common type of RPC receives only one request message and
+ * returns only one response message, the protocol also supports RPCs that
+ * return multiple individual messages in a streaming fashion, RPCs that accept
+ * a stream of request messages, or RPCs with both streaming requests and
* responses.
*
- * Conceptually, each gRPC call consists of a bidirectional stream of binary messages, with RPCs of
- * the "non-streaming type" sending only one message in the corresponding direction (the protocol
- * doesn't make any distinction).
+ * Conceptually, each gRPC call consists of a bidirectional stream of binary
+ * messages, with RPCs of the "non-streaming type" sending only one message in
+ * the corresponding direction (the protocol doesn't make any distinction).
*
- * Each RPC uses a different HTTP2 stream, and thus multiple simultaneous RPCs can be multiplexed
- * transparently on the same TCP connection.
+ * Each RPC uses a different HTTP2 stream, and thus multiple simultaneous RPCs
+ * can be multiplexed transparently on the same TCP connection.
*/
#import <Foundation/Foundation.h>
@@ -59,51 +60,56 @@ extern NSString *const kGRPCErrorDomain;
/**
* gRPC error codes.
- * Note that a few of these are never produced by the gRPC libraries, but are of general utility for
- * server applications to produce.
+ * Note that a few of these are never produced by the gRPC libraries, but are of
+ * general utility for server applications to produce.
*/
typedef NS_ENUM(NSUInteger, GRPCErrorCode) {
/** The operation was cancelled (typically by the caller). */
GRPCErrorCodeCancelled = 1,
/**
- * Unknown error. Errors raised by APIs that do not return enough error information may be
+ * Unknown error. Errors raised by APIs that do not return enough error
+ * information may be
* converted to this error.
*/
GRPCErrorCodeUnknown = 2,
/**
- * The client specified an invalid argument. Note that this differs from FAILED_PRECONDITION.
- * INVALID_ARGUMENT indicates arguments that are problematic regardless of the state of the
- * server (e.g., a malformed file name).
+ * The client specified an invalid argument. Note that this differs from
+ * FAILED_PRECONDITION.
+ * INVALID_ARGUMENT indicates arguments that are problematic regardless of the
+ * state of the server (e.g., a malformed file name).
*/
GRPCErrorCodeInvalidArgument = 3,
/**
- * Deadline expired before operation could complete. For operations that change the state of the
- * server, this error may be returned even if the operation has completed successfully. For
- * example, a successful response from the server could have been delayed long enough for the
- * deadline to expire.
+ * Deadline expired before operation could complete. For operations that
+ * change the state of the server, this error may be returned even if the
+ * operation has completed successfully. For example, a successful response
+ * from the server could have been delayed long enough for the deadline to
+ * expire.
*/
GRPCErrorCodeDeadlineExceeded = 4,
/** Some requested entity (e.g., file or directory) was not found. */
GRPCErrorCodeNotFound = 5,
- /** Some entity that we attempted to create (e.g., file or directory) already exists. */
+ /** Some entity that we attempted to create (e.g., file or directory) already
+ exists. */
GRPCErrorCodeAlreadyExists = 6,
/**
- * The caller does not have permission to execute the specified operation. PERMISSION_DENIED isn't
- * used for rejections caused by exhausting some resource (RESOURCE_EXHAUSTED is used instead for
- * those errors). PERMISSION_DENIED doesn't indicate a failure to identify the caller
+ * The caller does not have permission to execute the specified operation.
+ * PERMISSION_DENIED isn't used for rejections caused by exhausting some
+ * resource (RESOURCE_EXHAUSTED is used instead for those errors).
+ * PERMISSION_DENIED doesn't indicate a failure to identify the caller
* (UNAUTHENTICATED is used instead for those errors).
*/
GRPCErrorCodePermissionDenied = 7,
/**
- * The request does not have valid authentication credentials for the operation (e.g. the caller's
- * identity can't be verified).
+ * The request does not have valid authentication credentials for the
+ * operation (e.g. the caller's identity can't be verified).
*/
GRPCErrorCodeUnauthenticated = 16,
@@ -111,42 +117,47 @@ typedef NS_ENUM(NSUInteger, GRPCErrorCode) {
GRPCErrorCodeResourceExhausted = 8,
/**
- * The RPC was rejected because the server is not in a state required for the procedure's
+ * The RPC was rejected because the server is not in a state required for the
+ * procedure's
* execution. For example, a directory to be deleted may be non-empty, etc.
- * The client should not retry until the server state has been explicitly fixed (e.g. by
- * performing another RPC). The details depend on the service being called, and should be found in
- * the NSError's userInfo.
+ * The client should not retry until the server state has been explicitly
+ * fixed (e.g. by
+ * performing another RPC). The details depend on the service being called,
+ * and should be found in the NSError's userInfo.
*/
GRPCErrorCodeFailedPrecondition = 9,
/**
- * The RPC was aborted, typically due to a concurrency issue like sequencer check failures,
- * transaction aborts, etc. The client should retry at a higher-level (e.g., restarting a read-
- * modify-write sequence).
+ * The RPC was aborted, typically due to a concurrency issue like sequencer
+ * check failures, transaction aborts, etc. The client should retry at a
+ * higher-level (e.g., restarting a read-modify-write sequence).
*/
GRPCErrorCodeAborted = 10,
/**
- * The RPC was attempted past the valid range. E.g., enumerating past the end of a list.
- * Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed if the system state
- * changes. For example, an RPC to get elements of a list will generate INVALID_ARGUMENT if asked
- * to return the element at a negative index, but it will generate OUT_OF_RANGE if asked to return
- * the element at an index past the current size of the list.
+ * The RPC was attempted past the valid range. E.g., enumerating past the end
+ * of a list.
+ * Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed
+ * if the system state changes. For example, an RPC to get elements of a list
+ * will generate INVALID_ARGUMENT if asked to return the element at a negative
+ * index, but it will generate OUT_OF_RANGE if asked to return the element at
+ * an index past the current size of the list.
*/
GRPCErrorCodeOutOfRange = 11,
- /** The procedure is not implemented or not supported/enabled in this server. */
+ /** The procedure is not implemented or not supported/enabled in this server.
+ */
GRPCErrorCodeUnimplemented = 12,
/**
- * Internal error. Means some invariant expected by the server application or the gRPC library has
- * been broken.
+ * Internal error. Means some invariant expected by the server application or
+ * the gRPC library has been broken.
*/
GRPCErrorCodeInternal = 13,
/**
- * The server is currently unavailable. This is most likely a transient condition and may be
- * corrected by retrying with a backoff.
+ * The server is currently unavailable. This is most likely a transient
+ * condition and may be corrected by retrying with a backoff.
*/
GRPCErrorCodeUnavailable = 14,
@@ -158,17 +169,19 @@ typedef NS_ENUM(NSUInteger, GRPCErrorCode) {
* Safety remark of a gRPC method as defined in RFC 2616 Section 9.1
*/
typedef NS_ENUM(NSUInteger, GRPCCallSafety) {
- /** Signal that there is no guarantees on how the call affects the server state. */
+ /** Signal that there is no guarantees on how the call affects the server
+ state. */
GRPCCallSafetyDefault = 0,
/** Signal that the call is idempotent. gRPC is free to use PUT verb. */
GRPCCallSafetyIdempotentRequest = 1,
- /** Signal that the call is cacheable and will not affect server state. gRPC is free to use GET verb. */
+ /** Signal that the call is cacheable and will not affect server state. gRPC
+ is free to use GET verb. */
GRPCCallSafetyCacheableRequest = 2,
};
/**
- * Keys used in |NSError|'s |userInfo| dictionary to store the response headers and trailers sent by
- * the server.
+ * Keys used in |NSError|'s |userInfo| dictionary to store the response headers
+ * and trailers sent by the server.
*/
extern id const kGRPCHeadersKey;
extern id const kGRPCTrailersKey;
@@ -179,20 +192,24 @@ extern id const kGRPCTrailersKey;
@interface GRPCCall : GRXWriter
/**
- * The container of the request headers of an RPC conforms to this protocol, which is a subset of
- * NSMutableDictionary's interface. It will become a NSMutableDictionary later on.
- * The keys of this container are the header names, which per the HTTP standard are case-
- * insensitive. They are stored in lowercase (which is how HTTP/2 mandates them on the wire), and
- * can only consist of ASCII characters.
- * A header value is a NSString object (with only ASCII characters), unless the header name has the
- * suffix "-bin", in which case the value has to be a NSData object.
+ * The container of the request headers of an RPC conforms to this protocol,
+ * which is a subset of NSMutableDictionary's interface. It will become a
+ * NSMutableDictionary later on. The keys of this container are the header
+ * names, which per the HTTP standard are case-insensitive. They are stored in
+ * lowercase (which is how HTTP/2 mandates them on the wire), and can only
+ * consist of ASCII characters.
+ * A header value is a NSString object (with only ASCII characters), unless the
+ * header name has the suffix "-bin", in which case the value has to be a NSData
+ * object.
*/
/**
- * These HTTP headers will be passed to the server as part of this call. Each HTTP header is a
- * name-value pair with string names and either string or binary values.
+ * These HTTP headers will be passed to the server as part of this call. Each
+ * HTTP header is a name-value pair with string names and either string or
+ * binary values.
*
- * The passed dictionary has to use NSString keys, corresponding to the header names. The value
- * associated to each can be a NSString object or a NSData object. E.g.:
+ * The passed dictionary has to use NSString keys, corresponding to the header
+ * names. The value associated to each can be a NSString object or a NSData
+ * object. E.g.:
*
* call.requestHeaders = @{@"authorization": @"Bearer ..."};
*
@@ -205,53 +222,61 @@ extern id const kGRPCTrailersKey;
@property(atomic, readonly) NSMutableDictionary *requestHeaders;
/**
- * This dictionary is populated with the HTTP headers received from the server. This happens before
- * any response message is received from the server. It has the same structure as the request
- * headers dictionary: Keys are NSString header names; names ending with the suffix "-bin" have a
- * NSData value; the others have a NSString value.
+ * This dictionary is populated with the HTTP headers received from the server.
+ * This happens before any response message is received from the server. It has
+ * the same structure as the request headers dictionary: Keys are NSString
+ * header names; names ending with the suffix "-bin" have a NSData value; the
+ * others have a NSString value.
*
- * The value of this property is nil until all response headers are received, and will change before
- * any of -writeValue: or -writesFinishedWithError: are sent to the writeable.
+ * The value of this property is nil until all response headers are received,
+ * and will change before any of -writeValue: or -writesFinishedWithError: are
+ * sent to the writeable.
*/
@property(atomic, readonly) NSDictionary *responseHeaders;
/**
- * Same as responseHeaders, but populated with the HTTP trailers received from the server before the
- * call finishes.
+ * Same as responseHeaders, but populated with the HTTP trailers received from
+ * the server before the call finishes.
*
- * The value of this property is nil until all response trailers are received, and will change
- * before -writesFinishedWithError: is sent to the writeable.
+ * The value of this property is nil until all response trailers are received,
+ * and will change before -writesFinishedWithError: is sent to the writeable.
*/
@property(atomic, readonly) NSDictionary *responseTrailers;
/**
- * The request writer has to write NSData objects into the provided Writeable. The server will
- * receive each of those separately and in order as distinct messages.
- * A gRPC call might not complete until the request writer finishes. On the other hand, the request
- * finishing doesn't necessarily make the call to finish, as the server might continue sending
- * messages to the response side of the call indefinitely (depending on the semantics of the
- * specific remote method called).
+ * The request writer has to write NSData objects into the provided Writeable.
+ * The server will receive each of those separately and in order as distinct
+ * messages.
+ * A gRPC call might not complete until the request writer finishes. On the
+ * other hand, the request finishing doesn't necessarily make the call to
+ * finish, as the server might continue sending messages to the response side of
+ * the call indefinitely (depending on the semantics of the specific remote
+ * method called).
* To finish a call right away, invoke cancel.
- * host parameter should not contain the scheme (http:// or https://), only the name or IP addr
- * and the port number, for example @"localhost:5050".
+ * host parameter should not contain the scheme (http:// or https://), only the
+ * name or IP addr and the port number, for example @"localhost:5050".
*/
- (instancetype)initWithHost:(NSString *)host
path:(NSString *)path
- requestsWriter:(GRXWriter *)requestsWriter NS_DESIGNATED_INITIALIZER;
+ requestsWriter:(GRXWriter *)requestsWriter
+ NS_DESIGNATED_INITIALIZER;
/**
- * Finishes the request side of this call, notifies the server that the RPC should be cancelled, and
- * finishes the response side of the call with an error of code CANCELED.
+ * Finishes the request side of this call, notifies the server that the RPC
+ * should be cancelled, and finishes the response side of the call with an error
+ * of code CANCELED.
*/
- (void)cancel;
/**
* Set the call flag for a specific host path.
*
- * Host parameter should not contain the scheme (http:// or https://), only the name or IP addr
- * and the port number, for example @"localhost:5050".
+ * Host parameter should not contain the scheme (http:// or https://), only the
+ * name or IP addr and the port number, for example @"localhost:5050".
*/
-+ (void)setCallSafety:(GRPCCallSafety)callSafety host:(NSString *)host path:(NSString *)path;
++ (void)setCallSafety:(GRPCCallSafety)callSafety
+ host:(NSString *)host
+ path:(NSString *)path;
// TODO(jcanizales): Let specify a deadline. As a category of GRXWriter?
@end
@@ -260,7 +285,7 @@ extern id const kGRPCTrailersKey;
/** This protocol is kept for backwards compatibility with existing code. */
DEPRECATED_MSG_ATTRIBUTE("Use NSDictionary or NSMutableDictionary instead.")
-@protocol GRPCRequestHeaders <NSObject>
+@protocol GRPCRequestHeaders<NSObject>
@property(nonatomic, readonly) NSUInteger count;
- (id)objectForKeyedSubscript:(id)key;
@@ -273,6 +298,6 @@ DEPRECATED_MSG_ATTRIBUTE("Use NSDictionary or NSMutableDictionary instead.")
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated"
/** This is only needed for backwards-compatibility. */
-@interface NSMutableDictionary (GRPCRequestHeaders) <GRPCRequestHeaders>
+@interface NSMutableDictionary (GRPCRequestHeaders)<GRPCRequestHeaders>
@end
#pragma clang diagnostic pop
diff --git a/src/objective-c/GRPCClient/GRPCCall.m b/src/objective-c/GRPCClient/GRPCCall.m
index d977866565..470d4f4c76 100644
--- a/src/objective-c/GRPCClient/GRPCCall.m
+++ b/src/objective-c/GRPCClient/GRPCCall.m
@@ -33,9 +33,9 @@
#import "GRPCCall.h"
+#import <RxLibrary/GRXConcurrentWriteable.h>
#include <grpc/grpc.h>
#include <grpc/support/time.h>
-#import <RxLibrary/GRXConcurrentWriteable.h>
#import "private/GRPCConnectivityMonitor.h"
#import "private/GRPCHost.h"
@@ -45,11 +45,11 @@
#import "private/NSDictionary+GRPC.h"
#import "private/NSError+GRPC.h"
-NSString * const kGRPCHeadersKey = @"io.grpc.HeadersKey";
-NSString * const kGRPCTrailersKey = @"io.grpc.TrailersKey";
+NSString *const kGRPCHeadersKey = @"io.grpc.HeadersKey";
+NSString *const kGRPCTrailersKey = @"io.grpc.TrailersKey";
static NSMutableDictionary *callFlags;
-@interface GRPCCall () <GRXWriteable>
+@interface GRPCCall ()<GRXWriteable>
// Make them read-write.
@property(atomic, strong) NSDictionary *responseHeaders;
@property(atomic, strong) NSDictionary *responseTrailers;
@@ -85,17 +85,21 @@ static NSMutableDictionary *callFlags;
// correct ordering.
GRXConcurrentWriteable *_responseWriteable;
- // The network thread wants the requestWriter to resume (when the server is ready for more input),
- // or to stop (on errors), concurrently with user threads that want to start it, pause it or stop
- // it. Because a writer isn't thread-safe, we'll synchronize those operations on it.
- // We don't use a dispatch queue for that purpose, because the writer can call writeValue: or
- // writesFinishedWithError: on this GRPCCall as part of those operations. We want to be able to
- // pause the writer immediately on writeValue:, so we need our locking to be recursive.
+ // The network thread wants the requestWriter to resume (when the server is
+ // ready for more input), or to stop (on errors), concurrently with user
+ // threads that want to start it, pause it or stop it. Because a writer isn't
+ // thread-safe, we'll synchronize those operations on it.
+ // We don't use a dispatch queue for that purpose, because the writer can call
+ // writeValue: or writesFinishedWithError: on this GRPCCall as part of those
+ // operations. We want to be able to pause the writer immediately on
+ // writeValue:, so we need our locking to be recursive.
GRXWriter *_requestWriter;
// To create a retain cycle when a call is started, up until it finishes. See
- // |startWithWriteable:| and |finishWithError:|. This saves users from having to retain a
- // reference to the call object if all they're interested in is the handler being executed when
+ // |startWithWriteable:| and |finishWithError:|. This saves users from having
+ // to retain a
+ // reference to the call object if all they're interested in is the handler
+ // being executed when
// the response arrives.
GRPCCall *_retainSelf;
@@ -104,13 +108,16 @@ static NSMutableDictionary *callFlags;
@synthesize state = _state;
-// TODO(jcanizales): If grpc_init is idempotent, this should be changed from load to initialize.
+// TODO(jcanizales): If grpc_init is idempotent, this should be changed from
+// load to initialize.
+ (void)load {
grpc_init();
callFlags = [NSMutableDictionary dictionary];
}
-+ (void)setCallSafety:(GRPCCallSafety)callSafety host:(NSString *)host path:(NSString *)path {
++ (void)setCallSafety:(GRPCCallSafety)callSafety
+ host:(NSString *)host
+ path:(NSString *)path {
NSString *hostAndPath = [NSString stringWithFormat:@"%@/%@", host, path];
switch (callSafety) {
case GRPCCallSafetyDefault:
@@ -141,7 +148,8 @@ static NSMutableDictionary *callFlags;
path:(NSString *)path
requestsWriter:(GRXWriter *)requestWriter {
if (!host || !path) {
- [NSException raise:NSInvalidArgumentException format:@"Neither host nor path can be nil."];
+ [NSException raise:NSInvalidArgumentException
+ format:@"Neither host nor path can be nil."];
}
if (requestWriter.state != GRXWriterStateNotStarted) {
[NSException raise:NSInvalidArgumentException
@@ -191,7 +199,10 @@ static NSMutableDictionary *callFlags;
- (void)cancel {
[self finishWithError:[NSError errorWithDomain:kGRPCErrorDomain
code:GRPCErrorCodeCancelled
- userInfo:@{NSLocalizedDescriptionKey: @"Canceled by app"}]];
+ userInfo:@{
+ NSLocalizedDescriptionKey :
+ @"Canceled by app"
+ }]];
[self cancelCall];
}
@@ -206,15 +217,18 @@ static NSMutableDictionary *callFlags;
// Only called from the call queue.
// The handler will be called from the network queue.
-- (void)startReadWithHandler:(void(^)(grpc_byte_buffer *))handler {
+- (void)startReadWithHandler:(void (^)(grpc_byte_buffer *))handler {
// TODO(jcanizales): Add error handlers for async failures
- [_wrappedCall startBatchWithOperations:@[[[GRPCOpRecvMessage alloc] initWithHandler:handler]]];
+ [_wrappedCall startBatchWithOperations:@[ [[GRPCOpRecvMessage alloc]
+ initWithHandler:handler] ]];
}
// Called initially from the network queue once response headers are received,
-// then "recursively" from the responseWriteable queue after each response from the
+// then "recursively" from the responseWriteable queue after each response from
+// the
// server has been written.
-// If the call is currently paused, this is a noop. Restarting the call will invoke this
+// If the call is currently paused, this is a noop. Restarting the call will
+// invoke this
// method.
// TODO(jcanizales): Rename to readResponseIfNotPaused.
- (void)startNextRead {
@@ -237,15 +251,23 @@ static NSMutableDictionary *callFlags;
// don't want to throw, because the app shouldn't crash for a behavior
// that's on the hands of any server to have. Instead we finish and ask
// the server to cancel.
- [weakSelf finishWithError:[NSError errorWithDomain:kGRPCErrorDomain
- code:GRPCErrorCodeResourceExhausted
- userInfo:@{NSLocalizedDescriptionKey: @"Client does not have enough memory to hold the server response."}]];
+ [weakSelf
+ finishWithError:[NSError
+ errorWithDomain:kGRPCErrorDomain
+ code:GRPCErrorCodeResourceExhausted
+ userInfo:@{
+ NSLocalizedDescriptionKey :
+ @"Client does not have enough "
+ @"memory to hold the server "
+ @"response."
+ }]];
[weakSelf cancelCall];
return;
}
- [weakWriteable enqueueValue:data completionHandler:^{
- [weakSelf startNextRead];
- }];
+ [weakWriteable enqueueValue:data
+ completionHandler:^{
+ [weakSelf startNextRead];
+ }];
}];
});
}
@@ -254,19 +276,22 @@ static NSMutableDictionary *callFlags;
- (void)sendHeaders:(NSDictionary *)headers {
// TODO(jcanizales): Add error handlers for async failures
- [_wrappedCall startBatchWithOperations:@[[[GRPCOpSendMetadata alloc] initWithMetadata:headers
- flags:[GRPCCall callFlagsForHost:_host path:_path]
- handler:nil]]];
+ [_wrappedCall startBatchWithOperations:@[
+ [[GRPCOpSendMetadata alloc]
+ initWithMetadata:headers
+ flags:[GRPCCall callFlagsForHost:_host path:_path]
+ handler:nil]
+ ]];
}
#pragma mark GRXWriteable implementation
// Only called from the call queue. The error handler will be called from the
// network queue if the write didn't succeed.
-- (void)writeMessage:(NSData *)message withErrorHandler:(void (^)())errorHandler {
-
+- (void)writeMessage:(NSData *)message
+ withErrorHandler:(void (^)())errorHandler {
__weak GRPCCall *weakSelf = self;
- void(^resumingHandler)(void) = ^{
+ void (^resumingHandler)(void) = ^{
// Resume the request writer.
GRPCCall *strongSelf = weakSelf;
if (strongSelf) {
@@ -275,8 +300,9 @@ static NSMutableDictionary *callFlags;
}
}
};
- [_wrappedCall startBatchWithOperations:@[[[GRPCOpSendMessage alloc] initWithMessage:message
- handler:resumingHandler]]
+ [_wrappedCall startBatchWithOperations:@[ [[GRPCOpSendMessage alloc]
+ initWithMessage:message
+ handler:resumingHandler] ]
errorHandler:errorHandler];
}
@@ -291,18 +317,20 @@ static NSMutableDictionary *callFlags;
__weak GRPCCall *weakSelf = self;
dispatch_async(_callQueue, ^{
- [weakSelf writeMessage:value withErrorHandler:^{
- [weakSelf finishWithError:[NSError errorWithDomain:kGRPCErrorDomain
+ [weakSelf writeMessage:value
+ withErrorHandler:^{
+ [weakSelf
+ finishWithError:[NSError errorWithDomain:kGRPCErrorDomain
code:GRPCErrorCodeInternal
userInfo:nil]];
- }];
+ }];
});
}
// Only called from the call queue. The error handler will be called from the
// network queue if the requests stream couldn't be closed successfully.
- (void)finishRequestWithErrorHandler:(void (^)())errorHandler {
- [_wrappedCall startBatchWithOperations:@[[[GRPCOpSendClose alloc] init]]
+ [_wrappedCall startBatchWithOperations:@[ [[GRPCOpSendClose alloc] init] ]
errorHandler:errorHandler];
}
@@ -323,17 +351,19 @@ static NSMutableDictionary *callFlags;
#pragma mark Invoke
-// Both handlers will eventually be called, from the network queue. Writes can start immediately
-// after this.
+// Both handlers will eventually be called, from the network queue. Writes can
+// start immediately after this.
// The first one (headersHandler), when the response headers are received.
// The second one (completionHandler), whenever the RPC finishes for any reason.
-- (void)invokeCallWithHeadersHandler:(void(^)(NSDictionary *))headersHandler
- completionHandler:(void(^)(NSError *, NSDictionary *))completionHandler {
+- (void)invokeCallWithHeadersHandler:(void (^)(NSDictionary *))headersHandler
+ completionHandler:
+ (void (^)(NSError *, NSDictionary *))completionHandler {
// TODO(jcanizales): Add error handlers for async failures
- [_wrappedCall startBatchWithOperations:@[[[GRPCOpRecvMetadata alloc]
- initWithHandler:headersHandler]]];
- [_wrappedCall startBatchWithOperations:@[[[GRPCOpRecvStatus alloc]
- initWithHandler:completionHandler]]];
+ [_wrappedCall startBatchWithOperations:@[ [[GRPCOpRecvMetadata alloc]
+ initWithHandler:headersHandler] ]];
+ [_wrappedCall
+ startBatchWithOperations:@[ [[GRPCOpRecvStatus alloc]
+ initWithHandler:completionHandler] ]];
}
- (void)invokeCall {
@@ -341,27 +371,31 @@ static NSMutableDictionary *callFlags;
// Response headers received.
self.responseHeaders = headers;
[self startNextRead];
- } completionHandler:^(NSError *error, NSDictionary *trailers) {
- self.responseTrailers = trailers;
-
- if (error) {
- NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
- if (error.userInfo) {
- [userInfo addEntriesFromDictionary:error.userInfo];
- }
- userInfo[kGRPCTrailersKey] = self.responseTrailers;
- // TODO(jcanizales): The C gRPC library doesn't guarantee that the headers block will be
- // called before this one, so an error might end up with trailers but no headers. We
- // shouldn't call finishWithError until ater both blocks are called. It is also when this is
- // done that we can provide a merged view of response headers and trailers in a thread-safe
- // way.
- if (self.responseHeaders) {
- userInfo[kGRPCHeadersKey] = self.responseHeaders;
- }
- error = [NSError errorWithDomain:error.domain code:error.code userInfo:userInfo];
- }
- [self finishWithError:error];
- }];
+ }
+ completionHandler:^(NSError *error, NSDictionary *trailers) {
+ self.responseTrailers = trailers;
+
+ if (error) {
+ NSMutableDictionary *userInfo = [NSMutableDictionary dictionary];
+ if (error.userInfo) {
+ [userInfo addEntriesFromDictionary:error.userInfo];
+ }
+ userInfo[kGRPCTrailersKey] = self.responseTrailers;
+ // TODO(jcanizales): The C gRPC library doesn't guarantee that the
+ // headers block will be called before this one, so an error might end
+ // up with trailers but no headers. We shouldn't call finishWithError
+ // until ater both blocks are called. It is also when this is done
+ // that we can provide a merged view of response headers and trailers
+ // in a thread-safe way.
+ if (self.responseHeaders) {
+ userInfo[kGRPCHeadersKey] = self.responseHeaders;
+ }
+ error = [NSError errorWithDomain:error.domain
+ code:error.code
+ userInfo:userInfo];
+ }
+ [self finishWithError:error];
+ }];
// Now that the RPC has been initiated, request writes can start.
@synchronized(_requestWriter) {
[_requestWriter startWithWriteable:self];
@@ -376,32 +410,37 @@ static NSMutableDictionary *callFlags;
}
// TODO(jcanizales): Extract this logic somewhere common.
- NSString *host = [NSURL URLWithString:[@"https://" stringByAppendingString:_host]].host;
+ NSString *host =
+ [NSURL URLWithString:[@"https://" stringByAppendingString:_host]].host;
if (!host) {
// TODO(jcanizales): Check this on init.
- [NSException raise:NSInvalidArgumentException format:@"host of %@ is nil", _host];
+ [NSException raise:NSInvalidArgumentException
+ format:@"host of %@ is nil", _host];
}
__weak typeof(self) weakSelf = self;
- _connectivityMonitor = [GRPCConnectivityMonitor monitorWithHost:host];
+ _connectivityMonitor = [GRPCConnectivityMonitor monitorWithHost:host];
void (^handler)() = ^{
typeof(self) strongSelf = weakSelf;
if (strongSelf) {
- [strongSelf finishWithError:[NSError errorWithDomain:kGRPCErrorDomain
- code:GRPCErrorCodeUnavailable
- userInfo:@{NSLocalizedDescriptionKey: @"Connectivity lost."}]];
+ [strongSelf
+ finishWithError:[NSError errorWithDomain:kGRPCErrorDomain
+ code:GRPCErrorCodeUnavailable
+ userInfo:@{
+ NSLocalizedDescriptionKey :
+ @"Connectivity lost."
+ }]];
}
};
[_connectivityMonitor handleLossWithHandler:handler
- wifiStatusChangeHandler:^{}];
+ wifiStatusChangeHandler:^{
+ }];
// Create a retain cycle so that this instance lives until the RPC finishes
- // (or is cancelled).
- // This makes RPCs in which the call isn't externally retained possible (as
- // long as it is started
- // before being autoreleased).
+ // (or is cancelled). This makes RPCs in which the call isn't externally
+ // retained possible (as long as it is started before being autoreleased).
// Care is taken not to retain self strongly in any of the blocks used in this
- // implementation, so
- // that the life of the instance is determined by this retain cycle.
+ // implementation, so that the life of the instance is determined by this
+ // retain cycle.
_retainSelf = self;
_responseWriteable =
@@ -417,7 +456,8 @@ static NSMutableDictionary *callFlags;
- (void)setState:(GRXWriterState)newState {
@synchronized(self) {
// Manual transitions are only allowed from the started or paused states.
- if (_state == GRXWriterStateNotStarted || _state == GRXWriterStateFinished) {
+ if (_state == GRXWriterStateNotStarted ||
+ _state == GRXWriterStateFinished) {
return;
}
diff --git a/src/objective-c/GRPCClient/private/GRPCCompletionQueue.h b/src/objective-c/GRPCClient/private/GRPCCompletionQueue.h
index fe3b8f39d1..c0bbf22c74 100644
--- a/src/objective-c/GRPCClient/private/GRPCCompletionQueue.h
+++ b/src/objective-c/GRPCClient/private/GRPCCompletionQueue.h
@@ -34,18 +34,19 @@
#import <Foundation/Foundation.h>
#include <grpc/grpc.h>
-typedef void(^GRPCQueueCompletionHandler)(bool success);
+typedef void (^GRPCQueueCompletionHandler)(bool success);
/**
- * This class lets one more easily use |grpc_completion_queue|. To use it, pass the value of the
- * |unmanagedQueue| property of an instance of this class to |grpc_channel_create_call|. Then for
- * every |grpc_call_*| method that accepts a tag, you can pass a block of type
- * |GRPCQueueCompletionHandler| (remembering to cast it using |__bridge_retained|). The block is
- * guaranteed to eventually be called, by a concurrent queue, and then released. Each such block is
+ * This class lets one more easily use |grpc_completion_queue|. To use it, pass
+ * the value of the |unmanagedQueue| property of an instance of this class to
+ * |grpc_channel_create_call|. Then for every |grpc_call_*| method that accepts
+ * a tag, you can pass a block of type |GRPCQueueCompletionHandler| (remembering
+ * to cast it using |__bridge_retained|). The block is guaranteed to eventually
+ * be called, by a concurrent queue, and then released. Each such block is
* passed a |bool| that tells if the operation was successful.
*
- * Release the GRPCCompletionQueue object only after you are not going to pass any more blocks to
- * the |grpc_call| that's using it.
+ * Release the GRPCCompletionQueue object only after you are not going to pass
+ * any more blocks to the |grpc_call| that's using it.
*/
@interface GRPCCompletionQueue : NSObject
@property(nonatomic, readonly) grpc_completion_queue *unmanagedQueue;
diff --git a/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.h b/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.h
index 383225fb72..941b596d2c 100644
--- a/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.h
+++ b/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.h
@@ -61,20 +61,17 @@
/**
* Queue on which callbacks will be dispatched. Default is the main queue. Set
- * it before calling
- * handleLossWithHandler:.
+ * it before calling handleLossWithHandler:.
*/
// TODO(jcanizales): Default to a serial background queue instead.
@property(nonatomic, strong, null_resettable) dispatch_queue_t queue;
/**
* Calls handler every time the connectivity to this instance's host is lost. If
- * this instance is
- * released before that happens, the handler won't be called.
+ * this instance is released before that happens, the handler won't be called.
* Only one handler is active at a time, so if this method is called again
- * before the previous
- * handler has been called, it might never be called at all (or yes, if it has
- * already been queued).
+ * before the previous handler has been called, it might never be called at all
+ * (or yes, if it has already been queued).
*/
- (void)handleLossWithHandler:(nonnull void (^)())handler
wifiStatusChangeHandler:(nonnull void (^)())wifiStatusChangeHandler;
diff --git a/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.m b/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.m
index b5c43075ee..e829f84469 100644
--- a/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.m
+++ b/src/objective-c/GRPCClient/private/GRPCConnectivityMonitor.m
@@ -67,11 +67,9 @@
- (BOOL)isHostReachable {
// Note: connectionOnDemand means it'll be reachable only if using the
- // CFSocketStream API or APIs
- // on top of it.
+ // CFSocketStream API or APIs on top of it.
// connectionRequired means we can't tell until a connection is attempted
- // (e.g. for VPN on
- // demand).
+ // (e.g. for VPN on demand).
return self.reachable && !self.interventionRequired &&
!self.connectionOnDemand;
}
@@ -112,15 +110,13 @@ if (self.isCell) {
#pragma mark Connectivity Monitor
// Assumes the third argument is a block that accepts a GRPCReachabilityFlags
-// object, and passes the
-// received ones to it.
+// object, and passes the received ones to it.
static void PassFlagsToContextInfoBlock(SCNetworkReachabilityRef target,
SCNetworkReachabilityFlags flags,
void *info) {
#pragma unused(target)
// This can be called many times with the same info. The info is retained by
- // SCNetworkReachability
- // while this function is being executed.
+ // SCNetworkReachability while this function is being executed.
void (^handler)(GRPCReachabilityFlags *) =
(__bridge void (^)(GRPCReachabilityFlags *))info;
handler([[GRPCReachabilityFlags alloc] initWithFlags:flags]);
@@ -181,8 +177,7 @@ static void PassFlagsToContextInfoBlock(SCNetworkReachabilityRef target,
- (void)startListeningWithHandler:(void (^)(GRPCReachabilityFlags *))handler {
// Copy to ensure the handler block is in the heap (and so can't be
- // deallocated when this method
- // returns).
+ // deallocated when this method returns).
void (^copiedHandler)(GRPCReachabilityFlags *) = [handler copy];
SCNetworkReachabilityContext context = {
.version = 0,
diff --git a/src/objective-c/GRPCClient/private/GRPCHost.m b/src/objective-c/GRPCClient/private/GRPCHost.m
index 7031e01eb1..4737e45168 100644
--- a/src/objective-c/GRPCClient/private/GRPCHost.m
+++ b/src/objective-c/GRPCClient/private/GRPCHost.m
@@ -33,9 +33,9 @@
#import "GRPCHost.h"
+#import <GRPCClient/GRPCCall.h>
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
-#import <GRPCClient/GRPCCall.h>
#ifdef GRPC_COMPILE_WITH_CRONET
#import <GRPCClient/GRPCCall+ChannelArg.h>
#import <GRPCClient/GRPCCall+Cronet.h>
@@ -48,7 +48,8 @@
NS_ASSUME_NONNULL_BEGIN
-// TODO(jcanizales): Generate the version in a standalone header, from templates. Like
+// TODO(jcanizales): Generate the version in a standalone header, from
+// templates. Like
// templates/src/core/surface/version.c.template .
#define GRPC_OBJC_VERSION_STRING @"1.0.0"
@@ -56,7 +57,8 @@ static NSMutableDictionary *kHostCache;
static GRPCConnectivityMonitor *connectivityMonitor = nil;
@implementation GRPCHost {
- // TODO(mlumish): Investigate whether caching channels with strong links is a good idea.
+ // TODO(mlumish): Investigate whether caching channels with strong links is a
+ // good idea.
GRPCChannel *_channel;
}
@@ -76,11 +78,13 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
return nil;
}
- // To provide a default port, we try to interpret the address. If it's just a host name without
- // scheme and without port, we'll use port 443. If it has a scheme, we pass it untouched to the C
- // gRPC library.
- // TODO(jcanizales): Add unit tests for the types of addresses we want to let pass untouched.
- NSURL *hostURL = [NSURL URLWithString:[@"https://" stringByAppendingString:address]];
+ // To provide a default port, we try to interpret the address. If it's just a
+ // host name without scheme and without port, we'll use port 443. If it has a
+ // scheme, we pass it untouched to the C gRPC library.
+ // TODO(jcanizales): Add unit tests for the types of addresses we want to let
+ // pass untouched.
+ NSURL *hostURL =
+ [NSURL URLWithString:[@"https://" stringByAppendingString:address]];
if (hostURL.host && !hostURL.port) {
address = [hostURL.host stringByAppendingString:@":443"];
}
@@ -126,7 +130,7 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
}
+ (void)resetAllHostSettings {
- @synchronized (kHostCache) {
+ @synchronized(kHostCache) {
kHostCache = [NSMutableDictionary dictionary];
}
}
@@ -152,16 +156,19 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
static NSError *kDefaultRootsError;
static dispatch_once_t loading;
dispatch_once(&loading, ^{
- NSString *defaultPath = @"gRPCCertificates.bundle/roots"; // .pem
- // Do not use NSBundle.mainBundle, as it's nil for tests of library projects.
+ NSString *defaultPath = @"gRPCCertificates.bundle/roots"; // .pem
+ // Do not use NSBundle.mainBundle, as it's nil for tests of library
+ // projects.
NSBundle *bundle = [NSBundle bundleForClass:self.class];
NSString *path = [bundle pathForResource:defaultPath ofType:@"pem"];
NSError *error;
- // Files in PEM format can have non-ASCII characters in their comments (e.g. for the name of the
- // issuer). Load them as UTF8 and produce an ASCII equivalent.
- NSString *contentInUTF8 = [NSString stringWithContentsOfFile:path
- encoding:NSUTF8StringEncoding
- error:&error];
+ // Files in PEM format can have non-ASCII characters in their comments (e.g.
+ // for the name of the issuer). Load them as UTF8 and produce an ASCII
+ // equivalent.
+ NSString *contentInUTF8 =
+ [NSString stringWithContentsOfFile:path
+ encoding:NSUTF8StringEncoding
+ error:&error];
if (contentInUTF8 == nil) {
kDefaultRootsError = error;
return;
@@ -173,17 +180,21 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
NSData *rootsASCII;
if (pemRootCerts != nil) {
rootsASCII = [pemRootCerts dataUsingEncoding:NSASCIIStringEncoding
- allowLossyConversion:YES];
+ allowLossyConversion:YES];
} else {
if (kDefaultRootsASCII == nil) {
if (errorPtr) {
*errorPtr = kDefaultRootsError;
}
- NSAssert(kDefaultRootsASCII, @"Could not read gRPCCertificates.bundle/roots.pem. This file, "
- "with the root certificates, is needed to establish secure (TLS) connections. "
- "Because the file is distributed with the gRPC library, this error is usually a sign "
- "that the library wasn't configured correctly for your project. Error: %@",
- kDefaultRootsError);
+ NSAssert(kDefaultRootsASCII,
+ @"Could not read gRPCCertificates.bundle/roots.pem. This file, "
+ "with the root certificates, is needed to establish secure "
+ "(TLS) connections. "
+ "Because the file is distributed with the gRPC library, this "
+ "error is usually a sign "
+ "that the library wasn't configured correctly for your "
+ "project. Error: %@",
+ kDefaultRootsError);
return NO;
}
rootsASCII = kDefaultRootsASCII;
@@ -194,10 +205,12 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
creds = grpc_ssl_credentials_create(rootsASCII.bytes, NULL, NULL);
} else {
grpc_ssl_pem_key_cert_pair key_cert_pair;
- NSData *privateKeyASCII = [pemPrivateKey dataUsingEncoding:NSASCIIStringEncoding
- allowLossyConversion:YES];
- NSData *certChainASCII = [pemCertChain dataUsingEncoding:NSASCIIStringEncoding
- allowLossyConversion:YES];
+ NSData *privateKeyASCII =
+ [pemPrivateKey dataUsingEncoding:NSASCIIStringEncoding
+ allowLossyConversion:YES];
+ NSData *certChainASCII =
+ [pemCertChain dataUsingEncoding:NSASCIIStringEncoding
+ allowLossyConversion:YES];
key_cert_pair.private_key = privateKeyASCII.bytes;
key_cert_pair.cert_chain = certChainASCII.bytes;
creds = grpc_ssl_credentials_create(rootsASCII.bytes, &key_cert_pair, NULL);
@@ -217,7 +230,8 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
NSMutableDictionary *args = [NSMutableDictionary dictionary];
// TODO(jcanizales): Add OS and device information (see
- // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#user-agents ).
+ // https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#user-agents
+ // ).
NSString *userAgent = @"grpc-objc/" GRPC_OBJC_VERSION_STRING;
if (_userAgentPrefix) {
userAgent = [_userAgentPrefix stringByAppendingFormat:@" %@", userAgent];
@@ -231,7 +245,7 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
if (_responseSizeLimitOverride) {
args[@GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH] = _responseSizeLimitOverride;
}
- // Use 10000ms initial backoff time for correct behavior on bad/slow networks
+ // Use 10000ms initial backoff time for correct behavior on bad/slow networks
args[@GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS] = @10000;
return args;
}
@@ -242,31 +256,35 @@ static GRPCConnectivityMonitor *connectivityMonitor = nil;
BOOL useCronet = [GRPCCall isUsingCronet];
#endif
if (_secure) {
- GRPCChannel *channel;
- @synchronized(self) {
- if (_channelCreds == nil) {
- [self setTLSPEMRootCerts:nil withPrivateKey:nil withCertChain:nil error:nil];
- }
+ GRPCChannel *channel;
+ @synchronized(self) {
+ if (_channelCreds == nil) {
+ [self setTLSPEMRootCerts:nil
+ withPrivateKey:nil
+ withCertChain:nil
+ error:nil];
+ }
#ifdef GRPC_COMPILE_WITH_CRONET
- if (useCronet) {
- channel = [GRPCChannel secureCronetChannelWithHost:_address
- channelArgs:args];
- } else
+ if (useCronet) {
+ channel =
+ [GRPCChannel secureCronetChannelWithHost:_address channelArgs:args];
+ } else
#endif
- {
- channel = [GRPCChannel secureChannelWithHost:_address
- credentials:_channelCreds
- channelArgs:args];
- }
+ {
+ channel = [GRPCChannel secureChannelWithHost:_address
+ credentials:_channelCreds
+ channelArgs:args];
}
- return channel;
+ }
+ return channel;
} else {
return [GRPCChannel insecureChannelWithHost:_address channelArgs:args];
}
}
- (NSString *)hostName {
- // TODO(jcanizales): Default to nil instead of _address when Issue #2635 is clarified.
+ // TODO(jcanizales): Default to nil instead of _address when Issue #2635 is
+ // clarified.
return _hostNameOverride ?: _address;
}
diff --git a/src/objective-c/GRPCClient/private/GRPCRequestHeaders.m b/src/objective-c/GRPCClient/private/GRPCRequestHeaders.m
index c6a03c145e..58c6032e80 100644
--- a/src/objective-c/GRPCClient/private/GRPCRequestHeaders.m
+++ b/src/objective-c/GRPCClient/private/GRPCRequestHeaders.m
@@ -38,9 +38,10 @@
#import "NSDictionary+GRPC.h"
// Used by the setter.
-static void CheckIsNonNilASCII(NSString *name, NSString* value) {
+static void CheckIsNonNilASCII(NSString *name, NSString *value) {
if (!value) {
- [NSException raise:NSInvalidArgumentException format:@"%@ cannot be nil", name];
+ [NSException raise:NSInvalidArgumentException
+ format:@"%@ cannot be nil", name];
}
if (![value canBeConvertedToEncoding:NSASCIIStringEncoding]) {
[NSException raise:NSInvalidArgumentException
@@ -52,15 +53,20 @@ static void CheckIsNonNilASCII(NSString *name, NSString* value) {
static void CheckKeyValuePairIsValid(NSString *key, id value) {
if ([key hasSuffix:@"-bin"]) {
if (![value isKindOfClass:NSData.class]) {
- [NSException raise:NSInvalidArgumentException
- format:@"Expected NSData value for header %@ ending in \"-bin\", "
- @"instead got %@", key, value];
+ [NSException
+ raise:NSInvalidArgumentException
+ format:@"Expected NSData value for header %@ ending in \"-bin\", "
+ @"instead got %@",
+ key, value];
}
} else {
if (![value isKindOfClass:NSString.class]) {
- [NSException raise:NSInvalidArgumentException
- format:@"Expected NSString value for header %@ not ending in \"-bin\", "
- @"instead got %@", key, value];
+ [NSException
+ raise:NSInvalidArgumentException
+ format:
+ @"Expected NSString value for header %@ not ending in \"-bin\", "
+ @"instead got %@",
+ key, value];
}
CheckIsNonNilASCII(@"Text header value", (NSString *)value);
}
@@ -68,9 +74,10 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
@implementation GRPCRequestHeaders {
__weak GRPCCall *_call;
- // The NSMutableDictionary superclass doesn't hold any storage (so that people can implement their
- // own in subclasses). As that's not the reason we're subclassing, we just delegate storage to the
- // default NSMutableDictionary subclass returned by the cluster (e.g. __NSDictionaryM on iOS 9).
+ // The NSMutableDictionary superclass doesn't hold any storage (so that people
+ // can implement their own in subclasses). As that's not the reason we're
+ // subclassing, we just delegate storage to the default NSMutableDictionary
+ // subclass returned by the cluster (e.g. __NSDictionaryM on iOS 9).
NSMutableDictionary *_delegate;
}
@@ -91,7 +98,8 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
}
// Designated initializer
-- (instancetype)initWithCall:(GRPCCall *)call storage:(NSMutableDictionary *)storage {
+- (instancetype)initWithCall:(GRPCCall *)call
+ storage:(NSMutableDictionary *)storage {
// TODO(jcanizales): Throw if call or storage are nil.
if ((self = [super init])) {
_call = call;
@@ -100,9 +108,10 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
return self;
}
-- (instancetype)initWithObjects:(const id _Nonnull __unsafe_unretained *)objects
- forKeys:(const id<NSCopying> _Nonnull __unsafe_unretained *)keys
- count:(NSUInteger)cnt {
+- (instancetype)
+initWithObjects:(const id _Nonnull __unsafe_unretained *)objects
+ forKeys:(const id<NSCopying> _Nonnull __unsafe_unretained *)keys
+ count:(NSUInteger)cnt {
return [self init];
}
@@ -134,7 +143,7 @@ static void CheckKeyValuePairIsValid(NSString *key, id value) {
return _delegate.count;
}
-- (NSEnumerator * _Nonnull)keyEnumerator {
+- (NSEnumerator *_Nonnull)keyEnumerator {
return [_delegate keyEnumerator];
}
diff --git a/src/objective-c/GRPCClient/private/GRPCWrappedCall.m b/src/objective-c/GRPCClient/private/GRPCWrappedCall.m
index 627b6aa86d..bbda9f2f64 100644
--- a/src/objective-c/GRPCClient/private/GRPCWrappedCall.m
+++ b/src/objective-c/GRPCClient/private/GRPCWrappedCall.m
@@ -34,27 +34,27 @@
#import "GRPCWrappedCall.h"
#import <Foundation/Foundation.h>
-#include <grpc/grpc.h>
#include <grpc/byte_buffer.h>
+#include <grpc/grpc.h>
#include <grpc/support/alloc.h>
#import "GRPCCompletionQueue.h"
#import "GRPCHost.h"
-#import "NSDictionary+GRPC.h"
#import "NSData+GRPC.h"
+#import "NSDictionary+GRPC.h"
#import "NSError+GRPC.h"
@implementation GRPCOperation {
-@protected
- // Most operation subclasses don't set any flags in the grpc_op, and rely on the flag member being
- // initialized to zero.
+ @protected
+ // Most operation subclasses don't set any flags in the grpc_op, and rely on
+ // the flag member being initialized to zero.
grpc_op _op;
- void(^_handler)();
+ void (^_handler)();
}
- (void)finish {
if (_handler) {
- void(^handler)() = _handler;
+ void (^handler)() = _handler;
_handler = nil;
handler();
}
@@ -101,7 +101,8 @@
- (instancetype)initWithMessage:(NSData *)message handler:(void (^)())handler {
if (!message) {
- [NSException raise:NSInvalidArgumentException format:@"message cannot be nil"];
+ [NSException raise:NSInvalidArgumentException
+ format:@"message cannot be nil"];
}
if (self = [super init]) {
_op.op = GRPC_OP_SEND_MESSAGE;
@@ -137,11 +138,11 @@
grpc_metadata_array _headers;
}
-- (instancetype) init {
+- (instancetype)init {
return [self initWithHandler:nil];
}
-- (instancetype) initWithHandler:(void (^)(NSDictionary *))handler {
+- (instancetype)initWithHandler:(void (^)(NSDictionary *))handler {
if (self = [super init]) {
_op.op = GRPC_OP_RECV_INITIAL_METADATA;
grpc_metadata_array_init(&_headers);
@@ -152,7 +153,7 @@
_handler = ^{
__strong typeof(self) strongSelf = weakSelf;
NSDictionary *metadata = [NSDictionary
- grpc_dictionaryFromMetadataArray:strongSelf->_headers];
+ grpc_dictionaryFromMetadataArray:strongSelf->_headers];
handler(metadata);
};
}
@@ -166,7 +167,7 @@
@end
-@implementation GRPCOpRecvMessage{
+@implementation GRPCOpRecvMessage {
grpc_byte_buffer *_receivedMessage;
}
@@ -192,18 +193,18 @@
@end
-@implementation GRPCOpRecvStatus{
+@implementation GRPCOpRecvStatus {
grpc_status_code _statusCode;
char *_details;
size_t _detailsCapacity;
grpc_metadata_array _trailers;
}
-- (instancetype) init {
+- (instancetype)init {
return [self initWithHandler:nil];
}
-- (instancetype) initWithHandler:(void (^)(NSError *, NSDictionary *))handler {
+- (instancetype)initWithHandler:(void (^)(NSError *, NSDictionary *))handler {
if (self = [super init]) {
_op.op = GRPC_OP_RECV_STATUS_ON_CLIENT;
_op.data.recv_status_on_client.status = &_statusCode;
@@ -216,10 +217,11 @@
__weak typeof(self) weakSelf = self;
_handler = ^{
__strong typeof(self) strongSelf = weakSelf;
- NSError *error = [NSError grpc_errorFromStatusCode:strongSelf->_statusCode
- details:strongSelf->_details];
+ NSError *error =
+ [NSError grpc_errorFromStatusCode:strongSelf->_statusCode
+ details:strongSelf->_details];
NSDictionary *trailers = [NSDictionary
- grpc_dictionaryFromMetadataArray:strongSelf->_trailers];
+ grpc_dictionaryFromMetadataArray:strongSelf->_trailers];
handler(error, trailers);
};
}
@@ -245,20 +247,21 @@
return [self initWithHost:nil path:nil];
}
-- (instancetype)initWithHost:(NSString *)host
- path:(NSString *)path {
+- (instancetype)initWithHost:(NSString *)host path:(NSString *)path {
if (!path || !host) {
[NSException raise:NSInvalidArgumentException
format:@"path and host cannot be nil."];
}
if (self = [super init]) {
- // Each completion queue consumes one thread. There's a trade to be made between creating and
- // consuming too many threads and having contention of multiple calls in a single completion
- // queue. Currently we use a singleton queue.
+ // Each completion queue consumes one thread. There's a trade to be made
+ // between creating and consuming too many threads and having contention of
+ // multiple calls in a single completion queue. Currently we use a singleton
+ // queue.
_queue = [GRPCCompletionQueue completionQueue];
- _call = [[GRPCHost hostWithAddress:host] unmanagedCallWithPath:path completionQueue:_queue];
+ _call = [[GRPCHost hostWithAddress:host] unmanagedCallWithPath:path
+ completionQueue:_queue];
if (_call == NULL) {
return nil;
}
@@ -270,32 +273,35 @@
[self startBatchWithOperations:operations errorHandler:nil];
}
-- (void)startBatchWithOperations:(NSArray *)operations errorHandler:(void (^)())errorHandler {
+- (void)startBatchWithOperations:(NSArray *)operations
+ errorHandler:(void (^)())errorHandler {
size_t nops = operations.count;
grpc_op *ops_array = gpr_malloc(nops * sizeof(grpc_op));
size_t i = 0;
for (GRPCOperation *operation in operations) {
ops_array[i++] = operation.op;
}
- grpc_call_error error = grpc_call_start_batch(_call, ops_array, nops,
- (__bridge_retained void *)(^(bool success){
- if (!success) {
- if (errorHandler) {
- errorHandler();
- } else {
- return;
- }
- }
- for (GRPCOperation *operation in operations) {
- [operation finish];
- }
- }), NULL);
+ grpc_call_error error = grpc_call_start_batch(
+ _call, ops_array, nops, (__bridge_retained void *)(^(bool success) {
+ if (!success) {
+ if (errorHandler) {
+ errorHandler();
+ } else {
+ return;
+ }
+ }
+ for (GRPCOperation *operation in operations) {
+ [operation finish];
+ }
+ }),
+ NULL);
gpr_free(ops_array);
if (error != GRPC_CALL_OK) {
[NSException raise:NSInternalInconsistencyException
- format:@"A precondition for calling grpc_call_start_batch wasn't met. Error %i",
- error];
+ format:@"A precondition for calling grpc_call_start_batch "
+ @"wasn't met. Error %i",
+ error];
}
}
diff --git a/src/objective-c/GRPCClient/private/NSError+GRPC.h b/src/objective-c/GRPCClient/private/NSError+GRPC.h
index e0c1efc1f9..a9a321470c 100644
--- a/src/objective-c/GRPCClient/private/NSError+GRPC.h
+++ b/src/objective-c/GRPCClient/private/NSError+GRPC.h
@@ -36,8 +36,9 @@
@interface NSError (GRPC)
/**
- * Returns nil if the status code is OK. Otherwise, a NSError whose code is one of |GRPCErrorCode|
- * and whose domain is |kGRPCErrorDomain|.
+ * Returns nil if the status code is OK. Otherwise, a NSError whose code is one
+ * of |GRPCErrorCode| and whose domain is |kGRPCErrorDomain|.
*/
-+ (instancetype)grpc_errorFromStatusCode:(grpc_status_code)statusCode details:(char *)details;
++ (instancetype)grpc_errorFromStatusCode:(grpc_status_code)statusCode
+ details:(char *)details;
@end
--
GitLab