Ejemplo n.º 1
0
        /// <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));
        }
Ejemplo n.º 2
0
 /// <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());
            }));
        }
Ejemplo n.º 4
0
 /// <inheritdoc />
 private protected override ChannelBase CreateChannelImpl(ServiceMetadata serviceMetadata, string endpoint, ChannelCredentials credentials, GrpcChannelOptions options) =>
 channelFactory.Value.Invoke(endpoint, credentials, options);
Ejemplo n.º 5
0
 /// <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);
Ejemplo n.º 6
0
 /// <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.");
Ejemplo n.º 7
0
        // 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);
        }
Ejemplo n.º 8
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);
 }