/// <inheritdoc /> private protected override ChannelBase CreateChannelImpl(ServiceMetadata serviceMetadata, string endpoint, ChannelCredentials credentials, GrpcChannelOptions options) { var grpcNetClientOptions = ConvertOptions(credentials, options); _optionsConfigurationAction?.Invoke(grpcNetClientOptions); var address = ConvertEndpoint(endpoint); return(GrpcChannel.ForAddress(address, grpcNetClientOptions)); }
/// <summary> /// Creates a channel for the given endpoint, using the given credentials and options. /// </summary> /// <param name="serviceMetadata">The metadata for the service. Must not be null.</param> /// <param name="endpoint">The endpoint to connect to. Must not be null.</param> /// <param name="credentials">The channel credentials to use. Must not be null.</param> /// <param name="options">The channel options to use. Must not be null.</param> /// <returns>A channel for the specified settings.</returns> internal ChannelBase CreateChannel(ServiceMetadata serviceMetadata, string endpoint, ChannelCredentials credentials, GrpcChannelOptions options) { if (!SupportsApi(serviceMetadata)) { throw new ArgumentException($"API {serviceMetadata.Name} does not have any transports in common with {GetType().Name}"); } GaxPreconditions.CheckNotNull(endpoint, nameof(endpoint)); GaxPreconditions.CheckNotNull(credentials, nameof(credentials)); GaxPreconditions.CheckNotNull(options, nameof(options)); return(CreateChannelImpl(serviceMetadata, endpoint, credentials, options)); }
/// <summary> /// Creates a cache which will apply the specified scopes to the default application credentials /// if they require any. /// </summary> /// <param name="serviceMetadata">The metadata of the service the credentials will be used with. Must not be null.</param> internal DefaultChannelCredentialsCache(ServiceMetadata serviceMetadata) { UseJwtAccessWithScopes = serviceMetadata.SupportsScopedJwts; // In theory, we don't actually need to store the scopes as field in this class. We could capture a local variable here. // However, it won't be any more efficient, and having the scopes easily available when debugging could be handy. _scopes = serviceMetadata.DefaultScopes; _lazyScopedDefaultChannelCredentials = new Lazy <Task <ChannelCredentials> >(() => Task.Run(async() => { var appDefaultCredentials = await GoogleCredential.GetApplicationDefaultAsync().ConfigureAwait(false); if (appDefaultCredentials.IsCreateScopedRequired) { appDefaultCredentials = appDefaultCredentials.CreateScoped(_scopes); } if (appDefaultCredentials.UnderlyingCredential is ServiceAccountCredential serviceCredential && serviceCredential.UseJwtAccessWithScopes != UseJwtAccessWithScopes) { appDefaultCredentials = GoogleCredential.FromServiceAccountCredential(serviceCredential.WithUseJwtAccessWithScopes(UseJwtAccessWithScopes)); } return(appDefaultCredentials.ToChannelCredentials()); })); }
/// <inheritdoc /> private protected override ChannelBase CreateChannelImpl(ServiceMetadata serviceMetadata, string endpoint, ChannelCredentials credentials, GrpcChannelOptions options) => channelFactory.Value.Invoke(endpoint, credentials, options);
/// <summary> /// Creates a channel for the given endpoint, using the given credentials and options. All parameters /// are pre-validated to be non-null. /// </summary> /// <param name="apiMetadata"></param> /// <param name="endpoint">The endpoint to connect to. Will not be null.</param> /// <param name="credentials">The channel credentials to use. Will not be null.</param> /// <param name="options">The channel options to use. Will not be null.</param> /// <returns>A channel for the specified settings.</returns> private protected abstract ChannelBase CreateChannelImpl(ServiceMetadata apiMetadata, string endpoint, ChannelCredentials credentials, GrpcChannelOptions options);
/// <summary> /// Returns a fallback provider suitable for the given API /// </summary> /// <param name="serviceMetadata">The descriptor of the API. Must not be null.</param> /// <returns>A suitable GrpcAdapter for the given API, preferring the use of the binary gRPC transport where available.</returns> internal static GrpcAdapter GetFallbackAdapter(ServiceMetadata serviceMetadata) => // TODO: Do we need some way of indicating a preference, if the service supports both Rest and Grpc? // Probably not: the user code can always specify the adapter in the builder serviceMetadata.Transports.HasFlag(ApiTransports.Grpc) ? s_defaultGrpcTransportFactory.Value : serviceMetadata.Transports.HasFlag(ApiTransports.Rest) ? RestGrpcAdapter.Default : throw new ArgumentException("No known adapters support the given service.");
// TODO: potentially expose either or both of the methods below if we want, or a // "get the first adapter that supports this service, from the following list, or a fallback" // method. /// <summary> /// Returns whether or not this adapter supports the specified service. /// </summary> /// <param name="serviceMetadata">The service metadata. Must not be null.</param> /// <returns><c>true</c> if this adapter supports the given service; <c>false</c> otherwise.</returns> internal bool SupportsApi(ServiceMetadata serviceMetadata) { GaxPreconditions.CheckNotNull(serviceMetadata, nameof(serviceMetadata)); return((serviceMetadata.Transports & _supportedTransports) != 0); }
/// <summary> /// Creates a channel pool which will use the given service metadata to determine scopes and the use of self-signed JWTs. /// </summary> /// <param name="serviceMetadata">The metadata for the service that this pool will be used with. Must not be null.</param> public ChannelPool(ServiceMetadata serviceMetadata) { _serviceMetadata = GaxPreconditions.CheckNotNull(serviceMetadata, nameof(serviceMetadata)); _credentialCache = new DefaultChannelCredentialsCache(serviceMetadata); }