package client import ( "context" "fmt" "github.com/nspcc-dev/neofs-api-go/rpc/client" v2netmap "github.com/nspcc-dev/neofs-api-go/v2/netmap" rpcapi "github.com/nspcc-dev/neofs-api-go/v2/rpc" v2signature "github.com/nspcc-dev/neofs-api-go/v2/signature" "github.com/nspcc-dev/neofs-sdk-go/netmap" "github.com/nspcc-dev/neofs-sdk-go/version" ) // Netmap contains methods related to netmap. type Netmap interface { // EndpointInfo returns attributes, address and public key of the node, specified // in client constructor via address or open connection. This can be used as a // health check to see if node is alive and responses to requests. EndpointInfo(context.Context, ...CallOption) (*EndpointInfo, error) // NetworkInfo returns information about the NeoFS network of which the remote server is a part. NetworkInfo(context.Context, ...CallOption) (*netmap.NetworkInfo, error) } // EACLWithSignature represents eACL table/signature pair. type EndpointInfo struct { version *version.Version ni *netmap.NodeInfo } // LatestVersion returns latest NeoFS API version in use. func (e *EndpointInfo) LatestVersion() *version.Version { return e.version } // NodeInfo returns returns information about the NeoFS node. func (e *EndpointInfo) NodeInfo() *netmap.NodeInfo { return e.ni } // EndpointInfo returns attributes, address and public key of the node, specified // in client constructor via address or open connection. This can be used as a // health check to see if node is alive and responses to requests. func (c *clientImpl) EndpointInfo(ctx context.Context, opts ...CallOption) (*EndpointInfo, error) { // apply all available options callOptions := c.defaultCallOptions() for i := range opts { opts[i](callOptions) } reqBody := new(v2netmap.LocalNodeInfoRequestBody) req := new(v2netmap.LocalNodeInfoRequest) req.SetBody(reqBody) req.SetMetaHeader(v2MetaHeaderFromOpts(callOptions)) err := v2signature.SignServiceMessage(callOptions.key, req) if err != nil { return nil, err } resp, err := rpcapi.LocalNodeInfo(c.Raw(), req) if err != nil { return nil, fmt.Errorf("transport error: %w", err) } // handle response meta info if err := c.handleResponseInfoV2(callOptions, resp); err != nil { return nil, err } err = v2signature.VerifyServiceMessage(resp) if err != nil { return nil, fmt.Errorf("can't verify response message: %w", err) } body := resp.GetBody() return &EndpointInfo{ version: version.NewFromV2(body.GetVersion()), ni: netmap.NewNodeInfoFromV2(body.GetNodeInfo()), }, nil } // NetworkInfo returns information about the NeoFS network of which the remote server is a part. func (c *clientImpl) NetworkInfo(ctx context.Context, opts ...CallOption) (*netmap.NetworkInfo, error) { // apply all available options callOptions := c.defaultCallOptions() for i := range opts { opts[i](callOptions) } reqBody := new(v2netmap.NetworkInfoRequestBody) req := new(v2netmap.NetworkInfoRequest) req.SetBody(reqBody) req.SetMetaHeader(v2MetaHeaderFromOpts(callOptions)) err := v2signature.SignServiceMessage(callOptions.key, req) if err != nil { return nil, err } resp, err := rpcapi.NetworkInfo(c.Raw(), req, client.WithContext(ctx)) if err != nil { return nil, fmt.Errorf("v2 NetworkInfo RPC failure: %w", err) } // handle response meta info if err := c.handleResponseInfoV2(callOptions, resp); err != nil { return nil, err } err = v2signature.VerifyServiceMessage(resp) if err != nil { return nil, fmt.Errorf("response message verification failed: %w", err) } return netmap.NewNetworkInfoFromV2(resp.GetBody().GetNetworkInfo()), nil }