mirror of
https://github.com/siderolabs/talos.git
synced 2025-10-08 22:21:16 +02:00
5b7bea2471
This replaces codegen version of apid proxying with talos-systems/grpc-proxy based version. Proxying is transparent, it doesn't require exact information about methods and response types. It requires some common layout response to enhance it properly with node metadata or errors. There should be no signifcant changes to the API with the previous version, but it's worth mentioning a few changes: 1. grpc.ClientConn is established just once per upstream (either local service or remote apid instance). 2. When called without `-t` (`targets`), apid proxies immediately down to local service skipping proxying to itself (as before), which results in empty node metadata in response (before it had local node IP). Might revert this later to proxy to itself (?). 3. Streaming APIs are now fully supported with multiple targets, but message definition doesn't contain `ResponseMetadata`, so streaming APIs are broken now with targets (needs a fix). 4. Errors are now returned as responses with `Error` field set in `ResponseMetadata`, this requires client library update and `osctl` to handle it properly. Signed-off-by: Andrey Smirnov <smirnov.andrey@gmail.com>
73 lines
1.6 KiB
Go
73 lines
1.6 KiB
Go
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
package backend
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"github.com/talos-systems/grpc-proxy/proxy"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/metadata"
|
|
)
|
|
|
|
// Local implements local backend (proxying one2one to local service)
|
|
type Local struct {
|
|
name string
|
|
socketPath string
|
|
|
|
mu sync.Mutex
|
|
conn *grpc.ClientConn
|
|
}
|
|
|
|
// NewLocal builds new Local backend
|
|
func NewLocal(name, socketPath string) *Local {
|
|
return &Local{
|
|
name: name,
|
|
socketPath: socketPath,
|
|
}
|
|
}
|
|
|
|
func (l *Local) String() string {
|
|
return l.name
|
|
}
|
|
|
|
// GetConnection returns a grpc connection to the backend.
|
|
func (l *Local) GetConnection(ctx context.Context) (context.Context, *grpc.ClientConn, error) {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
// copy metadata
|
|
outCtx := ctx
|
|
if md, ok := metadata.FromIncomingContext(ctx); ok {
|
|
outCtx = metadata.NewOutgoingContext(ctx, md)
|
|
}
|
|
|
|
if l.conn != nil {
|
|
return outCtx, l.conn, nil
|
|
}
|
|
|
|
var err error
|
|
l.conn, err = grpc.DialContext(
|
|
ctx,
|
|
"unix:"+l.socketPath,
|
|
grpc.WithInsecure(),
|
|
grpc.WithCodec(proxy.Codec()), //nolint: staticcheck
|
|
|
|
)
|
|
|
|
return outCtx, l.conn, err
|
|
}
|
|
|
|
// AppendInfo is called to enhance response from the backend with additional data.
|
|
func (l *Local) AppendInfo(streaming bool, resp []byte) ([]byte, error) {
|
|
return resp, nil
|
|
}
|
|
|
|
// BuildError is called to convert error from upstream into response field.
|
|
func (l *Local) BuildError(streaming bool, err error) ([]byte, error) {
|
|
return nil, nil
|
|
}
|