tessl/maven-com-google-api--gax-grpc

Google API Extensions for Java providing gRPC-specific functionality for Google Cloud client libraries

—

Pending

Overview

Eval results

Files

Callable Factory

Name: tessl/maven-com-google-api--gax-grpc
Author: tessl

Factory methods for creating different types of gRPC callables including unary, streaming, paged, batching, and operation callables.

Capabilities

GrpcCallableFactory

Primary factory class for creating various types of gRPC callables with proper configuration and context handling.

/**
 * Factory for creating gRPC callables of different types
 * Supports unary, streaming, paged, batching, and operation patterns
 */
public class GrpcCallableFactory {
    /** Create a unary callable for single request-response pattern */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createUnaryCallable(
        GrpcCallSettings<RequestT, ResponseT> grpcCallSettings,
        UnaryCallSettings<RequestT, ResponseT> callSettings,
        ClientContext clientContext);
    
    /** Create a paged callable for paginated responses */
    public static <RequestT, ResponseT, PagedListResponseT> UnaryCallable<RequestT, PagedListResponseT> 
        createPagedCallable(
            GrpcCallSettings<RequestT, ResponseT> grpcCallSettings,
            PagedCallSettings<RequestT, ResponseT, PagedListResponseT> callSettings,
            ClientContext clientContext);
    
    /** Create a batching callable for request batching */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createBatchingCallable(
        GrpcCallSettings<RequestT, ResponseT> grpcCallSettings,
        BatchingCallSettings<RequestT, ResponseT> callSettings,
        ClientContext clientContext);
    
    /** Create an operation callable for long-running operations */
    public static <RequestT, ResponseT, MetadataT> OperationCallable<RequestT, ResponseT, MetadataT> 
        createOperationCallable(
            GrpcCallSettings<RequestT, Operation> grpcCallSettings,
            OperationCallSettings<RequestT, ResponseT, MetadataT> operationCallSettings,
            ClientContext clientContext,
            OperationsStub operationsStub);
    
    /** Create a bidirectional streaming callable */
    public static <RequestT, ResponseT> BidiStreamingCallable<RequestT, ResponseT> 
        createBidiStreamingCallable(
            GrpcCallSettings<RequestT, ResponseT> grpcCallSettings,
            StreamingCallSettings<RequestT, ResponseT> callSettings,
            ClientContext clientContext);
    
    /** Create a server streaming callable */
    public static <RequestT, ResponseT> ServerStreamingCallable<RequestT, ResponseT> 
        createServerStreamingCallable(
            GrpcCallSettings<RequestT, ResponseT> grpcCallSettings,
            ServerStreamingCallSettings<RequestT, ResponseT> callSettings,
            ClientContext clientContext);
    
    /** Create a client streaming callable */
    public static <RequestT, ResponseT> ClientStreamingCallable<RequestT, ResponseT> 
        createClientStreamingCallable(
            GrpcCallSettings<RequestT, ResponseT> grpcCallSettings,
            StreamingCallSettings<RequestT, ResponseT> callSettings,
            ClientContext clientContext);
}

GrpcRawCallableFactory

Factory for creating raw gRPC callables without additional GAX layers, used for low-level operations.

/**
 * Factory for creating raw gRPC callables
 * Provides direct access to gRPC functionality without GAX abstractions
 */
public class GrpcRawCallableFactory {
    /** Create a raw unary callable */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createUnaryCallable(
        MethodDescriptor<RequestT, ResponseT> methodDescriptor,
        Function<RequestT, RequestT> requestMutator,
        Function<ResponseT, ResponseT> responseMutator);
    
    /** Create a raw server streaming callable */
    public static <RequestT, ResponseT> ServerStreamingCallable<RequestT, ResponseT> 
        createServerStreamingCallable(
            MethodDescriptor<RequestT, ResponseT> methodDescriptor,
            Function<RequestT, RequestT> requestMutator,
            Function<ResponseT, ResponseT> responseMutator);
    
    /** Create a raw client streaming callable */
    public static <RequestT, ResponseT> ClientStreamingCallable<RequestT, ResponseT> 
        createClientStreamingCallable(
            MethodDescriptor<RequestT, ResponseT> methodDescriptor,
            Function<RequestT, RequestT> requestMutator,
            Function<ResponseT, ResponseT> responseMutator);
    
    /** Create a raw bidirectional streaming callable */
    public static <RequestT, ResponseT> BidiStreamingCallable<RequestT, ResponseT> 
        createBidiStreamingCallable(
            MethodDescriptor<RequestT, ResponseT> methodDescriptor,
            Function<RequestT, RequestT> requestMutator,
            Function<ResponseT, ResponseT> responseMutator);
}

GrpcStubCallableFactory

Factory for creating stub-level callables with enhanced error handling and metadata processing.

/**
 * Factory for creating stub-level callables
 * Provides enhanced error handling and metadata processing
 */
public class GrpcStubCallableFactory {
    /** Create a stub unary callable with enhanced error handling */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createUnaryCallable(
        ClientCall<RequestT, ResponseT> clientCall,
        UnaryCallSettings<RequestT, ResponseT> callSettings,
        ClientContext clientContext);
    
    /** Create a stub server streaming callable */
    public static <RequestT, ResponseT> ServerStreamingCallable<RequestT, ResponseT> 
        createServerStreamingCallable(
            ClientCall<RequestT, ResponseT> clientCall,
            ServerStreamingCallSettings<RequestT, ResponseT> callSettings,
            ClientContext clientContext);
    
    /** Create a stub client streaming callable */  
    public static <RequestT, ResponseT> ClientStreamingCallable<RequestT, ResponseT> 
        createClientStreamingCallable(
            ClientCall<RequestT, ResponseT> clientCall,
            StreamingCallSettings<RequestT, ResponseT> callSettings,
            ClientContext clientContext);
    
    /** Create a stub bidirectional streaming callable */
    public static <RequestT, ResponseT> BidiStreamingCallable<RequestT, ResponseT> 
        createBidiStreamingCallable(
            ClientCall<RequestT, ResponseT> clientCall,
            StreamingCallSettings<RequestT, ResponseT> callSettings,
            ClientContext clientContext);
}

Callable Creation Helpers

Helper methods and utilities for common callable creation patterns and configurations.

/**
 * Helper utilities for callable creation
 */
public class GrpcCallableFactory {
    /** Create a callable with automatic retries */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createRetryingCallable(
        UnaryCallable<RequestT, ResponseT> innerCallable,
        RetrySettings retrySettings,
        Set<StatusCode.Code> retryableCodes,
        ClientContext clientContext);
    
    /** Create a callable with timeout handling */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createTimeoutCallable(
        UnaryCallable<RequestT, ResponseT> innerCallable,
        Duration timeout,
        ClientContext clientContext);
    
    /** Create a callable with tracing */
    public static <RequestT, ResponseT> UnaryCallable<RequestT, ResponseT> createTracedCallable(
        UnaryCallable<RequestT, ResponseT> innerCallable,
        SpanName spanName,
        ClientContext clientContext);
}

Callable Configuration Types

Method Descriptor Configuration

/**
 * Configuration for gRPC method descriptors
 */
public interface MethodDescriptorConfig<RequestT, ResponseT> {
    /** Get the gRPC method descriptor */
    MethodDescriptor<RequestT, ResponseT> getMethodDescriptor();
    
    /** Get the request marshaller */
    MethodDescriptor.Marshaller<RequestT> getRequestMarshaller();
    
    /** Get the response marshaller */
    MethodDescriptor.Marshaller<ResponseT> getResponseMarshaller();
    
    /** Get the method type */
    MethodDescriptor.MethodType getMethodType();
}

Callable Enhancement Options

/**
 * Options for enhancing callables with additional functionality
 */
public static class CallableEnhancementOptions {
    /** Enable automatic retries */
    public CallableEnhancementOptions withRetries(RetrySettings retrySettings);
    
    /** Enable timeout handling */
    public CallableEnhancementOptions withTimeout(Duration timeout);
    
    /** Enable distributed tracing */
    public CallableEnhancementOptions withTracing(boolean enabled);
    
    /** Enable response metadata collection */
    public CallableEnhancementOptions withMetadataCollection(boolean enabled);
    
    /** Enable request/response logging */
    public CallableEnhancementOptions withLogging(boolean enabled);
}

Usage Examples

Basic Unary Callable Creation

import com.google.api.gax.grpc.GrpcCallableFactory;
import com.google.api.gax.grpc.GrpcCallSettings;
import com.google.api.gax.rpc.UnaryCallSettings;
import com.google.api.gax.rpc.ClientContext;

// Create method descriptor (typically from generated code)
MethodDescriptor<MyRequest, MyResponse> methodDescriptor = 
    MyServiceGrpc.getMyMethodMethod();

// Create gRPC call settings
GrpcCallSettings<MyRequest, MyResponse> grpcSettings = 
    GrpcCallSettings.<MyRequest, MyResponse>newBuilder()
        .setMethodDescriptor(methodDescriptor)
        .build();

// Create unary call settings
UnaryCallSettings<MyRequest, MyResponse> callSettings = 
    UnaryCallSettings.<MyRequest, MyResponse>newUnaryCallSettingsBuilder()
        .setRetrySettings(retrySettings)
        .build();

// Create the callable
UnaryCallable<MyRequest, MyResponse> callable = 
    GrpcCallableFactory.createUnaryCallable(grpcSettings, callSettings, clientContext);

// Use the callable
MyResponse response = callable.call(MyRequest.newBuilder().build());

Paged Callable Creation

import com.google.api.gax.rpc.PagedCallSettings;

// Create paged call settings
PagedCallSettings<ListRequest, ListResponse, ListPagedResponse> pagedSettings = 
    PagedCallSettings.<ListRequest, ListResponse, ListPagedResponse>newBuilder()
        .setPagedListResponseFactory(new ListPagedResponseFactory())
        .setRetrySettings(retrySettings)
        .build();

// Create the paged callable
UnaryCallable<ListRequest, ListPagedResponse> pagedCallable = 
    GrpcCallableFactory.createPagedCallable(grpcSettings, pagedSettings, clientContext);

// Use the paged callable
for (Item item : pagedCallable.call(ListRequest.newBuilder().build()).iterateAll()) {
    // Process each item
    System.out.println(item);
}

Streaming Callable Creation

import com.google.api.gax.rpc.ServerStreamingCallable;
import com.google.api.gax.rpc.ResponseObserver;
import com.google.api.gax.rpc.StreamController;

// Create server streaming callable
ServerStreamingCallable<StreamRequest, StreamResponse> streamingCallable = 
    GrpcCallableFactory.createServerStreamingCallable(grpcSettings, streamingSettings, clientContext);

// Use the streaming callable
streamingCallable.call(
    StreamRequest.newBuilder().build(),
    new ResponseObserver<StreamResponse>() {
        @Override
        public void onStart(StreamController controller) {
            // Stream started
        }
        
        @Override
        public void onResponse(StreamResponse response) {
            // Handle each response
            System.out.println(response);
        }
        
        @Override
        public void onError(Throwable t) {
            // Handle errors
            System.err.println("Stream error: " + t.getMessage());
        }
        
        @Override
        public void onComplete() {
            // Stream completed
            System.out.println("Stream completed");
        }
    }
);

Operation Callable Creation

import com.google.api.gax.longrunning.OperationCallable;
import com.google.api.gax.longrunning.OperationCallSettings;
import com.google.longrunning.Operation;

// Create operation call settings
OperationCallSettings<CreateRequest, CreateResponse, CreateMetadata> operationSettings = 
    OperationCallSettings.<CreateRequest, CreateResponse, CreateMetadata>newBuilder()
        .setInitialCallSettings(initialCallSettings)
        .setResponseTransformer(ProtoOperationTransformers.ResponseTransformer.create(CreateResponse.class))
        .setMetadataTransformer(ProtoOperationTransformers.MetadataTransformer.create(CreateMetadata.class))
        .setPollingSettings(PollingSettings.newBuilder()
            .setInitialRetryDelay(Duration.ofSeconds(5))
            .setRetryDelayMultiplier(1.5)
            .setMaxRetryDelay(Duration.ofMinutes(5))
            .setInitialRpcTimeout(Duration.ofMinutes(2))
            .setRpcTimeoutMultiplier(1.0)
            .setMaxRpcTimeout(Duration.ofMinutes(2))
            .setTotalTimeout(Duration.ofHours(24))
            .build())
        .build();

// Create the operation callable
OperationCallable<CreateRequest, CreateResponse, CreateMetadata> operationCallable = 
    GrpcCallableFactory.createOperationCallable(
        grpcSettings, operationSettings, clientContext, operationsStub);

// Use the operation callable
OperationFuture<CreateResponse, CreateMetadata> future = 
    operationCallable.futureCall(CreateRequest.newBuilder().build());

// Wait for completion
CreateResponse response = future.get();

Batching Callable Creation

import com.google.api.gax.batching.BatchingSettings;
import com.google.api.gax.batching.FlowControlSettings;

// Create batching settings
BatchingSettings batchingSettings = BatchingSettings.newBuilder()
    .setElementCountThreshold(100L)
    .setRequestByteThreshold(1024L * 1024L) // 1MB
    .setDelayThreshold(Duration.ofMillis(10))
    .setFlowControlSettings(FlowControlSettings.newBuilder()
        .setMaxOutstandingElementCount(1000L)
        .setMaxOutstandingRequestBytes(10L * 1024L * 1024L) // 10MB
        .build())
    .build();

BatchingCallSettings<BatchRequest, BatchResponse> batchingCallSettings = 
    BatchingCallSettings.<BatchRequest, BatchResponse>newBuilder()
        .setBatchingSettings(batchingSettings)
        .setBatchingDescriptor(new MyBatchingDescriptor())
        .build();

// Create the batching callable
UnaryCallable<BatchRequest, BatchResponse> batchingCallable = 
    GrpcCallableFactory.createBatchingCallable(grpcSettings, batchingCallSettings, clientContext);

Install with Tessl CLI

npx tessl i tessl/maven-com-google-api--gax-grpc

docs

call-context.md

callable-factory.md

channel-management.md

tessl/maven-com-google-api--gax-grpc