protean

package main

import (
	"context"
	"fmt"
	"net/http/httptest"
	"net/url"
	"strings"
	"time"

	"github.com/dogmatiq/protean"
	"github.com/dogmatiq/protean/internal/stringservice"
)

// serviceImplementation is an implementation of the
// stringservice.ProteanStringService interface, which is generated by
// protoc-gen-go-protean from the ./internal/stringservice/service.proto file.
//
// Note: The .proto file and the generated code are kept in an "internal"
// package path to avoid any possibility of them appearing in Protean's public
// API by accident. The generated code is not committed to the Git repository.
// To see the generated code, please clone this repository and run "make test".
type serviceImplementation struct{}

// ToUpper is an RPC method that returns the uppercase version of a string.
func (serviceImplementation) ToUpper(
	ctx context.Context,
	request *stringservice.ToUpperRequest,
) (*stringservice.ToUpperResponse, error) {
	uppercase := strings.ToUpper(
		request.GetOriginalString(),
	)

	response := &stringservice.ToUpperResponse{
		UppercaseString: uppercase,
	}

	return response, nil
}

func main() {
	// Create the Protean HTTP handler.
	//
	// This is an implementation of Go's standard http.Handler that dispatches
	// calls to RPC services.
	handler := protean.NewHandler()

	// Register our example implementation of the string service with the
	// Protean handler.
	service := serviceImplementation{}
	stringservice.RegisterProteanStringService(handler, service)

	// Start an HTTP server to accept our RPC requests.
	//
	// We use the server from the httptest package so that we can easily listen
	// on a random port, and shut down the server at the end of the example.
	// Typically you would use the Protean handler with Go's regular
	// "production" HTTP server from the http package.
	server := httptest.NewServer(handler)
	defer server.Close()

	// Now that we have a running server, we can create a client and start
	// calling some RPC methods.
	//
	// The test server conveniently provides the URL we can use to connect to
	// it. We use that to construct the base URL for the Protean RPC client.
	baseURL, err := url.Parse(server.URL)
	if err != nil {
		panic(err)
	}

	// Create the client for the string service. The returned client implements
	// the same stringservice.ProteanStringService interface that is used on the
	// server-side.
	client := stringservice.NewProteanStringServiceClient(baseURL)

	// Now we can finally outsource our uppercase conversions to another server!
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	request := &stringservice.ToUpperRequest{
		OriginalString: "This is the string.",
	}

	response, err := client.ToUpper(ctx, request)
	if err != nil {
		panic(err)
	}

	fmt.Println(response.GetUppercaseString())

}

Output:

THIS IS THE STRING.