lnrpc/peers: skeleton logic for updateNodeAnnouncement

Basic logic for the endpoint:

- Get the current nodeAnn information
- Calculate modifications
- Apply modifications
- Return changes
This commit is contained in:
positiveblue committed 2022-04-01 18:36:21 -07:00
1 parent 5ab0cbd433
commit e4e0935816
17 files changed
+438 -8

No files matched your search

+24 -1
View File
@@ -3,4 +3,27 @@
package peersrpc
type Config struct{}
import (
"net"
"github.com/lightningnetwork/lnd/lnwire"
"github.com/lightningnetwork/lnd/netann"
)
// Config is the primary configuration struct for the peers RPC subserver.
// It contains all the items required for the server to carry out its duties.
// The fields with struct tags are meant to be parsed as normal configuration
// options, while if able to be populated, the latter fields MUST also be
// specified.
type Config struct {
// GetNodeAnnouncement is used to send our retrieve the current
// node announcement information.
GetNodeAnnouncement func() (lnwire.NodeAnnouncement, error)
// ParseAddr parses an address from its string format to a net.Addr.
ParseAddr func(addr string) (net.Addr, error)
// UpdateNodeAnnouncement updates our node announcement applying the
// given NodeAnnModifiers and broadcasts the new version to the network.
UpdateNodeAnnouncement func(...netann.NodeAnnModifier) error
}
+167
View File
@@ -0,0 +1,167 @@
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
// source: peersrpc/peers.proto
/*
Package peersrpc is a reverse proxy.
It translates gRPC into RESTful JSON APIs.
*/
package peersrpc
import (
"context"
"io"
"net/http"
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/proto"
)
// Suppress "imported and not used" errors
var _ codes.Code
var _ io.Reader
var _ status.Status
var _ = runtime.String
var _ = utilities.NewDoubleArray
var _ = metadata.Join
func request_Peers_UpdateNodeAnnouncement_0(ctx context.Context, marshaler runtime.Marshaler, client PeersClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq NodeAnnouncementUpdateRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.UpdateNodeAnnouncement(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Peers_UpdateNodeAnnouncement_0(ctx context.Context, marshaler runtime.Marshaler, server PeersServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq NodeAnnouncementUpdateRequest
var metadata runtime.ServerMetadata
newReader, berr := utilities.IOReaderFactory(req.Body)
if berr != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
}
if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.UpdateNodeAnnouncement(ctx, &protoReq)
return msg, metadata, err
}
// RegisterPeersHandlerServer registers the http handlers for service Peers to "mux".
// UnaryRPC :call PeersServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterPeersHandlerFromEndpoint instead.
func RegisterPeersHandlerServer(ctx context.Context, mux *runtime.ServeMux, server PeersServer) error {
mux.Handle("POST", pattern_Peers_UpdateNodeAnnouncement_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/peersrpc.Peers/UpdateNodeAnnouncement", runtime.WithHTTPPathPattern("/v2/peers/nodeannouncement"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Peers_UpdateNodeAnnouncement_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Peers_UpdateNodeAnnouncement_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
// RegisterPeersHandlerFromEndpoint is same as RegisterPeersHandler but
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
func RegisterPeersHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
conn, err := grpc.Dial(endpoint, opts...)
if err != nil {
return err
}
defer func() {
if err != nil {
if cerr := conn.Close(); cerr != nil {
grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
}
return
}
go func() {
<-ctx.Done()
if cerr := conn.Close(); cerr != nil {
grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
}
}()
}()
return RegisterPeersHandler(ctx, mux, conn)
}
// RegisterPeersHandler registers the http handlers for service Peers to "mux".
// The handlers forward requests to the grpc endpoint over "conn".
func RegisterPeersHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
return RegisterPeersHandlerClient(ctx, mux, NewPeersClient(conn))
}
// RegisterPeersHandlerClient registers the http handlers for service Peers
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "PeersClient".
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "PeersClient"
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
// "PeersClient" to call the correct interceptors.
func RegisterPeersHandlerClient(ctx context.Context, mux *runtime.ServeMux, client PeersClient) error {
mux.Handle("POST", pattern_Peers_UpdateNodeAnnouncement_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req, "/peersrpc.Peers/UpdateNodeAnnouncement", runtime.WithHTTPPathPattern("/v2/peers/nodeannouncement"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Peers_UpdateNodeAnnouncement_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Peers_UpdateNodeAnnouncement_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
var (
pattern_Peers_UpdateNodeAnnouncement_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v2", "peers", "nodeannouncement"}, ""))
)
var (
forward_Peers_UpdateNodeAnnouncement_0 = runtime.ForwardResponseMessage
)
+62 -1
View File
@@ -15,7 +15,41 @@
"produces": [
"application/json"
],
"paths": {},
"paths": {
"/v2/peers/nodeannouncement": {
"post": {
"summary": "lncli: peers updatenodeannouncement\nUpdateNodeAnnouncement allows the caller to update the node parameters\nand broadcasts a new version of the node announcement to its peers.",
"operationId": "Peers_UpdateNodeAnnouncement",
"responses": {
"200": {
"description": "A successful response.",
"schema": {
"$ref": "#/definitions/peersrpcNodeAnnouncementUpdateResponse"
}
},
"default": {
"description": "An unexpected error response.",
"schema": {
"$ref": "#/definitions/rpcStatus"
}
}
},
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"$ref": "#/definitions/peersrpcNodeAnnouncementUpdateRequest"
}
}
],
"tags": [
"Peers"
]
}
}
},
"definitions": {
"lnrpcFeatureBit": {
"type": "string",
@@ -62,6 +96,33 @@
}
}
},
"peersrpcNodeAnnouncementUpdateRequest": {
"type": "object",
"properties": {
"feature_updates": {
"type": "array",
"items": {
"$ref": "#/definitions/peersrpcUpdateFeatureAction"
},
"description": "Set of changes for the features that the node supports."
},
"color": {
"type": "string",
"description": "Color is the node's color in hex code format."
},
"alias": {
"type": "string",
"description": "Alias or nick name of the node."
},
"address_updates": {
"type": "array",
"items": {
"$ref": "#/definitions/peersrpcUpdateAddressAction"
},
"description": "Set of changes for the node's known addresses."
}
}
},
"peersrpcNodeAnnouncementUpdateResponse": {
"type": "object",
"properties": {
+6
View File
@@ -1,2 +1,8 @@
type: google.api.Service
config_version: 3
http:
rules:
- selector: peersrpc.Peers.UpdateNodeAnnouncement
post: "/v2/peers/nodeannouncement"
body: "*"
+54 -1
View File
@@ -5,10 +5,12 @@ package peersrpc
import (
"context"
"fmt"
"sync/atomic"
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"github.com/lightningnetwork/lnd/lnrpc"
"github.com/lightningnetwork/lnd/netann"
"google.golang.org/grpc"
"gopkg.in/macaroon-bakery.v2/bakery"
)
@@ -23,7 +25,12 @@ const (
var (
// macPermissions maps RPC calls to the permissions they require.
macPermissions = map[string][]bakery.Op{}
macPermissions = map[string][]bakery.Op{
"/peersrpc.Peers/UpdateNodeAnnouncement": {{
Entity: "peers",
Action: "write",
}},
}
)
// ServerShell is a shell struct holding a reference to the actual sub-server.
@@ -119,6 +126,17 @@ func (r *ServerShell) RegisterWithRootServer(grpcServer *grpc.Server) error {
func (r *ServerShell) RegisterWithRestServer(ctx context.Context,
mux *runtime.ServeMux, dest string, opts []grpc.DialOption) error {
// We make sure that we register it with the main REST server to ensure
// all our methods are routed properly.
err := RegisterPeersHandlerFromEndpoint(ctx, mux, dest, opts)
if err != nil {
log.Errorf("Could not register Peers REST server "+
"with root REST server: %v", err)
return err
}
log.Debugf("Peers REST server successfully registered with " +
"root REST server")
return nil
}
@@ -140,3 +158,38 @@ func (r *ServerShell) CreateSubServer(configRegistry lnrpc.SubServerConfigDispat
r.PeersServer = subServer
return subServer, macPermissions, nil
}
// UpdateNodeAnnouncement allows the caller to update the node parameters
// and broadcasts a new version of the node announcement to its peers.
func (s *Server) UpdateNodeAnnouncement(_ context.Context,
req *NodeAnnouncementUpdateRequest) (
*NodeAnnouncementUpdateResponse, error) {
resp := &NodeAnnouncementUpdateResponse{}
nodeModifiers := make([]netann.NodeAnnModifier, 0)
_, err := s.cfg.GetNodeAnnouncement()
if err != nil {
return nil, fmt.Errorf("unable to get current node "+
"announcement: %v", err)
}
// TODO(positiveblue): apply feature bit modifications
// TODO(positiveblue): apply color modifications
// TODO(positiveblue): apply alias modifications
// TODO(positiveblue): apply addresses modifications
if len(nodeModifiers) == 0 {
return nil, fmt.Errorf("unable detect any new values to " +
"update the node announcement")
}
if err := s.cfg.UpdateNodeAnnouncement(nodeModifiers...); err != nil {
return nil, err
}
return resp, nil
}