diff --git a/go.mod b/go.mod index 08d4c245b..67d18003b 100644 --- a/go.mod +++ b/go.mod @@ -38,6 +38,8 @@ require ( golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 golang.org/x/text v0.3.7 + google.golang.org/grpc v1.49.0 + google.golang.org/protobuf v1.27.1 gopkg.in/yaml.v3 v3.0.1 ) @@ -70,6 +72,7 @@ require ( github.com/yuin/goldmark-emoji v1.0.1 // indirect golang.org/x/net v0.0.0-20220722155237-a158d28d115b // indirect golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a // indirect + google.golang.org/genproto v0.0.0-20200825200019-8632dd797987 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect ) diff --git a/go.sum b/go.sum index f24d36e0a..66d90b82e 100644 --- a/go.sum +++ b/go.sum @@ -485,6 +485,7 @@ google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEY google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987 h1:PDIOdWxZ8eRizhKa1AAvY53xsvLB1cWorMjslvY3VA8= google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= @@ -498,6 +499,8 @@ google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKa google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.49.0 h1:WTLtQzmQori5FUH25Pq4WT22oCsv8USpQ+F6rqtsmxw= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -509,8 +512,9 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= diff --git a/internal/codespaces/grpc/client.go b/internal/codespaces/grpc/client.go new file mode 100644 index 000000000..76119d659 --- /dev/null +++ b/internal/codespaces/grpc/client.go @@ -0,0 +1,145 @@ +package grpc + +// gRPC client implementation to be able to connect to the gRPC server and perform the following operations: +// - Start a remote JupyterLab server + +import ( + "context" + "fmt" + "net" + "strconv" + "time" + + "github.com/cli/cli/v2/internal/codespaces/grpc/jupyter" + "github.com/cli/cli/v2/pkg/liveshare" + "golang.org/x/crypto/ssh" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials/insecure" + "google.golang.org/grpc/metadata" +) + +const ( + ConnectionTimeout = 5 * time.Second + RequestTimeout = 30 * time.Second +) + +const ( + codespacesInternalPort = 16634 + codespacesInternalSessionName = "CodespacesInternal" +) + +type Client struct { + conn *grpc.ClientConn + token string + listener net.Listener + jupyterClient jupyter.JupyterServerHostClient + cancelPF context.CancelFunc +} + +type liveshareSession interface { + KeepAlive(string) + OpenStreamingChannel(context.Context, liveshare.ChannelID) (ssh.Channel, error) + StartSharing(context.Context, string, int) (liveshare.ChannelID, error) +} + +// Finds a free port to listen on and creates a new gRPC client that connects to that port +func Connect(ctx context.Context, session liveshareSession, token string) (*Client, error) { + listener, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", 0)) + if err != nil { + return nil, fmt.Errorf("failed to listen to local port over tcp: %w", err) + } + localAddress := fmt.Sprintf("127.0.0.1:%d", listener.Addr().(*net.TCPAddr).Port) + + client := &Client{ + token: token, + listener: listener, + } + + // Create a cancelable context to be able to cancel background tasks + // if we encounter an error while connecting to the gRPC server + connectctx, cancel := context.WithCancel(context.Background()) + defer func() { + if err != nil { + cancel() + } + }() + + ch := make(chan error, 2) // Buffered channel to ensure we don't block on the goroutine + + // Ensure we close the port forwarder if we encounter an error + // or once the gRPC connection is closed. pfcancel is retained + // to close the PF whenever we close the gRPC connection. + pfctx, pfcancel := context.WithCancel(connectctx) + client.cancelPF = pfcancel + + // Tunnel the remote gRPC server port to the local port + go func() { + fwd := liveshare.NewPortForwarder(session, codespacesInternalSessionName, codespacesInternalPort, true) + ch <- fwd.ForwardToListener(pfctx, listener) + }() + + var conn *grpc.ClientConn + go func() { + // Attempt to connect to the port + opts := []grpc.DialOption{ + grpc.WithTransportCredentials(insecure.NewCredentials()), + grpc.WithBlock(), + } + conn, err = grpc.DialContext(connectctx, localAddress, opts...) + ch <- err // nil if we successfully connected + }() + + // Wait for the connection to be established or for the context to be cancelled + select { + case <-ctx.Done(): + return nil, ctx.Err() + case err := <-ch: + if err != nil { + return nil, err + } + } + + client.conn = conn + client.jupyterClient = jupyter.NewJupyterServerHostClient(conn) + + return client, nil +} + +// Closes the gRPC connection +func (g *Client) Close() error { + g.cancelPF() + + // Closing the local listener effectively closes the gRPC connection + if err := g.listener.Close(); err != nil { + g.conn.Close() // If we fail to close the listener, explicitly close the gRPC connection and ignore any error + return fmt.Errorf("failed to close local tcp port listener: %w", err) + } + + return nil +} + +// Appends the authentication token to the gRPC context +func (g *Client) appendMetadata(ctx context.Context) context.Context { + return metadata.AppendToOutgoingContext(ctx, "Authorization", "Bearer "+g.token) +} + +// Starts a remote JupyterLab server to allow the user to connect to the codespace via JupyterLab in their browser +func (g *Client) StartJupyterServer(ctx context.Context) (port int, serverUrl string, err error) { + ctx = g.appendMetadata(ctx) + + response, err := g.jupyterClient.GetRunningServer(ctx, &jupyter.GetRunningServerRequest{}) + if err != nil { + return 0, "", fmt.Errorf("failed to invoke JupyterLab RPC: %w", err) + } + + if !response.Result { + return 0, "", fmt.Errorf("failed to start JupyterLab: %s", response.Message) + } + + port, err = strconv.Atoi(response.Port) + if err != nil { + return 0, "", fmt.Errorf("failed to parse JupyterLab port: %w", err) + } + + return port, response.ServerUrl, err +} diff --git a/internal/codespaces/grpc/client_test.go b/internal/codespaces/grpc/client_test.go new file mode 100644 index 000000000..d905c0e29 --- /dev/null +++ b/internal/codespaces/grpc/client_test.go @@ -0,0 +1,80 @@ +package grpc + +import ( + "context" + "fmt" + "log" + "testing" + + grpctest "github.com/cli/cli/v2/internal/codespaces/grpc/test" +) + +func startServer(t *testing.T) { + t.Helper() + + ctx, cancel := context.WithCancel(context.Background()) + + // Start the gRPC server in the background + go func() { + err := grpctest.StartServer(ctx) + if err != nil && err != context.Canceled { + log.Println(fmt.Errorf("error starting test server: %v", err)) + } + }() + + // Stop the gRPC server when the test is done + t.Cleanup(func() { + cancel() + }) +} + +func connect(t *testing.T) (client *Client) { + t.Helper() + + client, err := Connect(context.Background(), &grpctest.Session{}, "token") + if err != nil { + t.Fatalf("error connecting to internal server: %v", err) + } + + t.Cleanup(func() { + client.Close() + }) + + return client +} + +// Test that the gRPC client returns the correct port and URL when the JupyterLab server starts successfully +func TestStartJupyterServerSuccess(t *testing.T) { + startServer(t) + client := connect(t) + + port, url, err := client.StartJupyterServer(context.Background()) + if err != nil { + t.Fatalf("expected %v, got %v", nil, err) + } + if port != grpctest.JupyterPort { + t.Fatalf("expected %d, got %d", grpctest.JupyterPort, port) + } + if url != grpctest.JupyterServerUrl { + t.Fatalf("expected %s, got %s", grpctest.JupyterServerUrl, url) + } +} + +// Test that the gRPC client returns an error when the JupyterLab server fails to start +func TestStartJupyterServerFailure(t *testing.T) { + startServer(t) + client := connect(t) + grpctest.JupyterMessage = "error message" + grpctest.JupyterResult = false + errorMessage := fmt.Sprintf("failed to start JupyterLab: %s", grpctest.JupyterMessage) + port, url, err := client.StartJupyterServer(context.Background()) + if err.Error() != errorMessage { + t.Fatalf("expected %v, got %v", errorMessage, err) + } + if port != 0 { + t.Fatalf("expected %d, got %d", 0, port) + } + if url != "" { + t.Fatalf("expected %s, got %s", "", url) + } +} diff --git a/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1.pb.go b/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1.pb.go new file mode 100644 index 000000000..c48f3d0cf --- /dev/null +++ b/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1.pb.go @@ -0,0 +1,241 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.0 +// protoc v3.21.3 +// source: JupyterServerHostService.v1.proto + +package jupyter + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type GetRunningServerRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GetRunningServerRequest) Reset() { + *x = GetRunningServerRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_JupyterServerHostService_v1_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRunningServerRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRunningServerRequest) ProtoMessage() {} + +func (x *GetRunningServerRequest) ProtoReflect() protoreflect.Message { + mi := &file_JupyterServerHostService_v1_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRunningServerRequest.ProtoReflect.Descriptor instead. +func (*GetRunningServerRequest) Descriptor() ([]byte, []int) { + return file_JupyterServerHostService_v1_proto_rawDescGZIP(), []int{0} +} + +type GetRunningServerResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Result bool `protobuf:"varint,1,opt,name=Result,proto3" json:"Result,omitempty"` + Message string `protobuf:"bytes,2,opt,name=Message,proto3" json:"Message,omitempty"` + Port string `protobuf:"bytes,3,opt,name=Port,proto3" json:"Port,omitempty"` + ServerUrl string `protobuf:"bytes,4,opt,name=ServerUrl,proto3" json:"ServerUrl,omitempty"` +} + +func (x *GetRunningServerResponse) Reset() { + *x = GetRunningServerResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_JupyterServerHostService_v1_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetRunningServerResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetRunningServerResponse) ProtoMessage() {} + +func (x *GetRunningServerResponse) ProtoReflect() protoreflect.Message { + mi := &file_JupyterServerHostService_v1_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetRunningServerResponse.ProtoReflect.Descriptor instead. +func (*GetRunningServerResponse) Descriptor() ([]byte, []int) { + return file_JupyterServerHostService_v1_proto_rawDescGZIP(), []int{1} +} + +func (x *GetRunningServerResponse) GetResult() bool { + if x != nil { + return x.Result + } + return false +} + +func (x *GetRunningServerResponse) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +func (x *GetRunningServerResponse) GetPort() string { + if x != nil { + return x.Port + } + return "" +} + +func (x *GetRunningServerResponse) GetServerUrl() string { + if x != nil { + return x.ServerUrl + } + return "" +} + +var File_JupyterServerHostService_v1_proto protoreflect.FileDescriptor + +var file_JupyterServerHostService_v1_proto_rawDesc = []byte{ + 0x0a, 0x21, 0x4a, 0x75, 0x70, 0x79, 0x74, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x48, + 0x6f, 0x73, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x12, 0x2b, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2e, + 0x47, 0x72, 0x70, 0x63, 0x2e, 0x4a, 0x75, 0x70, 0x79, 0x74, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x48, 0x6f, 0x73, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x31, + 0x22, 0x19, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x7e, 0x0a, 0x18, 0x47, + 0x65, 0x74, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, + 0x18, 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x50, 0x6f, 0x72, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x50, 0x6f, 0x72, 0x74, 0x12, 0x1c, 0x0a, + 0x09, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x55, 0x72, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x55, 0x72, 0x6c, 0x32, 0xb5, 0x01, 0x0a, 0x11, + 0x4a, 0x75, 0x70, 0x79, 0x74, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x48, 0x6f, 0x73, + 0x74, 0x12, 0x9f, 0x01, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, + 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x44, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x73, 0x70, 0x61, + 0x63, 0x65, 0x73, 0x2e, 0x47, 0x72, 0x70, 0x63, 0x2e, 0x4a, 0x75, 0x70, 0x79, 0x74, 0x65, 0x72, + 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x48, 0x6f, 0x73, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, + 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x53, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x45, 0x2e, 0x43, + 0x6f, 0x64, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x73, 0x2e, 0x47, 0x72, 0x70, 0x63, 0x2e, 0x4a, + 0x75, 0x70, 0x79, 0x74, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x48, 0x6f, 0x73, 0x74, + 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x75, + 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x42, 0x0b, 0x5a, 0x09, 0x2e, 0x2f, 0x6a, 0x75, 0x70, 0x79, 0x74, 0x65, 0x72, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_JupyterServerHostService_v1_proto_rawDescOnce sync.Once + file_JupyterServerHostService_v1_proto_rawDescData = file_JupyterServerHostService_v1_proto_rawDesc +) + +func file_JupyterServerHostService_v1_proto_rawDescGZIP() []byte { + file_JupyterServerHostService_v1_proto_rawDescOnce.Do(func() { + file_JupyterServerHostService_v1_proto_rawDescData = protoimpl.X.CompressGZIP(file_JupyterServerHostService_v1_proto_rawDescData) + }) + return file_JupyterServerHostService_v1_proto_rawDescData +} + +var file_JupyterServerHostService_v1_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_JupyterServerHostService_v1_proto_goTypes = []interface{}{ + (*GetRunningServerRequest)(nil), // 0: Codespaces.Grpc.JupyterServerHostService.v1.GetRunningServerRequest + (*GetRunningServerResponse)(nil), // 1: Codespaces.Grpc.JupyterServerHostService.v1.GetRunningServerResponse +} +var file_JupyterServerHostService_v1_proto_depIdxs = []int32{ + 0, // 0: Codespaces.Grpc.JupyterServerHostService.v1.JupyterServerHost.GetRunningServer:input_type -> Codespaces.Grpc.JupyterServerHostService.v1.GetRunningServerRequest + 1, // 1: Codespaces.Grpc.JupyterServerHostService.v1.JupyterServerHost.GetRunningServer:output_type -> Codespaces.Grpc.JupyterServerHostService.v1.GetRunningServerResponse + 1, // [1:2] is the sub-list for method output_type + 0, // [0:1] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_JupyterServerHostService_v1_proto_init() } +func file_JupyterServerHostService_v1_proto_init() { + if File_JupyterServerHostService_v1_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_JupyterServerHostService_v1_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRunningServerRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_JupyterServerHostService_v1_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetRunningServerResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_JupyterServerHostService_v1_proto_rawDesc, + NumEnums: 0, + NumMessages: 2, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_JupyterServerHostService_v1_proto_goTypes, + DependencyIndexes: file_JupyterServerHostService_v1_proto_depIdxs, + MessageInfos: file_JupyterServerHostService_v1_proto_msgTypes, + }.Build() + File_JupyterServerHostService_v1_proto = out.File + file_JupyterServerHostService_v1_proto_rawDesc = nil + file_JupyterServerHostService_v1_proto_goTypes = nil + file_JupyterServerHostService_v1_proto_depIdxs = nil +} diff --git a/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1.proto b/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1.proto new file mode 100644 index 000000000..337e7cf41 --- /dev/null +++ b/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1.proto @@ -0,0 +1,19 @@ +syntax = "proto3"; + +option go_package = "./jupyter"; + +package Codespaces.Grpc.JupyterServerHostService.v1; + +service JupyterServerHost { + rpc GetRunningServer (GetRunningServerRequest) returns (GetRunningServerResponse); +} + +message GetRunningServerRequest { +} + +message GetRunningServerResponse { + bool Result = 1; + string Message = 2; + string Port = 3; + string ServerUrl = 4; +} diff --git a/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1_grpc.pb.go b/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1_grpc.pb.go new file mode 100644 index 000000000..8ba53014d --- /dev/null +++ b/internal/codespaces/grpc/jupyter/JupyterServerHostService.v1_grpc.pb.go @@ -0,0 +1,105 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.2.0 +// - protoc v3.21.3 +// source: JupyterServerHostService.v1.proto + +package jupyter + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +// JupyterServerHostClient is the client API for JupyterServerHost service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type JupyterServerHostClient interface { + GetRunningServer(ctx context.Context, in *GetRunningServerRequest, opts ...grpc.CallOption) (*GetRunningServerResponse, error) +} + +type jupyterServerHostClient struct { + cc grpc.ClientConnInterface +} + +func NewJupyterServerHostClient(cc grpc.ClientConnInterface) JupyterServerHostClient { + return &jupyterServerHostClient{cc} +} + +func (c *jupyterServerHostClient) GetRunningServer(ctx context.Context, in *GetRunningServerRequest, opts ...grpc.CallOption) (*GetRunningServerResponse, error) { + out := new(GetRunningServerResponse) + err := c.cc.Invoke(ctx, "/Codespaces.Grpc.JupyterServerHostService.v1.JupyterServerHost/GetRunningServer", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// JupyterServerHostServer is the server API for JupyterServerHost service. +// All implementations must embed UnimplementedJupyterServerHostServer +// for forward compatibility +type JupyterServerHostServer interface { + GetRunningServer(context.Context, *GetRunningServerRequest) (*GetRunningServerResponse, error) + mustEmbedUnimplementedJupyterServerHostServer() +} + +// UnimplementedJupyterServerHostServer must be embedded to have forward compatible implementations. +type UnimplementedJupyterServerHostServer struct { +} + +func (UnimplementedJupyterServerHostServer) GetRunningServer(context.Context, *GetRunningServerRequest) (*GetRunningServerResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetRunningServer not implemented") +} +func (UnimplementedJupyterServerHostServer) mustEmbedUnimplementedJupyterServerHostServer() {} + +// UnsafeJupyterServerHostServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to JupyterServerHostServer will +// result in compilation errors. +type UnsafeJupyterServerHostServer interface { + mustEmbedUnimplementedJupyterServerHostServer() +} + +func RegisterJupyterServerHostServer(s grpc.ServiceRegistrar, srv JupyterServerHostServer) { + s.RegisterService(&JupyterServerHost_ServiceDesc, srv) +} + +func _JupyterServerHost_GetRunningServer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetRunningServerRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(JupyterServerHostServer).GetRunningServer(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/Codespaces.Grpc.JupyterServerHostService.v1.JupyterServerHost/GetRunningServer", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(JupyterServerHostServer).GetRunningServer(ctx, req.(*GetRunningServerRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// JupyterServerHost_ServiceDesc is the grpc.ServiceDesc for JupyterServerHost service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var JupyterServerHost_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "Codespaces.Grpc.JupyterServerHostService.v1.JupyterServerHost", + HandlerType: (*JupyterServerHostServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "GetRunningServer", + Handler: _JupyterServerHost_GetRunningServer_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "JupyterServerHostService.v1.proto", +} diff --git a/internal/codespaces/grpc/test/channel.go b/internal/codespaces/grpc/test/channel.go new file mode 100644 index 000000000..eef42c4aa --- /dev/null +++ b/internal/codespaces/grpc/test/channel.go @@ -0,0 +1,34 @@ +package test + +import ( + "io" + "net" +) + +type Channel struct { + conn net.Conn +} + +func (c *Channel) Read(data []byte) (int, error) { + return c.conn.Read(data) +} + +func (c *Channel) Write(data []byte) (int, error) { + return c.conn.Write(data) +} + +func (c *Channel) Close() error { + return c.conn.Close() +} + +func (c *Channel) CloseWrite() error { + return nil +} + +func (c *Channel) SendRequest(name string, wantReply bool, payload []byte) (bool, error) { + return false, nil +} + +func (c *Channel) Stderr() io.ReadWriter { + return nil +} diff --git a/internal/codespaces/grpc/test/server.go b/internal/codespaces/grpc/test/server.go new file mode 100644 index 000000000..8af5efc29 --- /dev/null +++ b/internal/codespaces/grpc/test/server.go @@ -0,0 +1,62 @@ +package test + +import ( + "context" + "fmt" + "net" + "strconv" + + "github.com/cli/cli/v2/internal/codespaces/grpc/jupyter" + "google.golang.org/grpc" +) + +const ( + ServerPort = 50051 +) + +var ( + JupyterPort = 1234 + JupyterServerUrl = "http://localhost:1234?token=1234" + JupyterMessage = "" + JupyterResult = true +) + +type server struct { + jupyter.UnimplementedJupyterServerHostServer +} + +func (s *server) GetRunningServer(ctx context.Context, in *jupyter.GetRunningServerRequest) (*jupyter.GetRunningServerResponse, error) { + return &jupyter.GetRunningServerResponse{ + Port: strconv.Itoa(JupyterPort), + ServerUrl: JupyterServerUrl, + Message: JupyterMessage, + Result: JupyterResult, + }, nil +} + +// Starts the mock gRPC server listening on port 50051 +func StartServer(ctx context.Context) error { + listener, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", ServerPort)) + if err != nil { + return fmt.Errorf("failed to listen: %v", err) + } + defer listener.Close() + + s := grpc.NewServer() + jupyter.RegisterJupyterServerHostServer(s, &server{}) + + ch := make(chan error, 1) + go func() { + if err := s.Serve(listener); err != nil { + ch <- fmt.Errorf("failed to serve: %v", err) + } + }() + + select { + case <-ctx.Done(): + s.Stop() + return ctx.Err() + case err := <-ch: + return err + } +} diff --git a/internal/codespaces/grpc/test/session.go b/internal/codespaces/grpc/test/session.go new file mode 100644 index 000000000..aba0f17ee --- /dev/null +++ b/internal/codespaces/grpc/test/session.go @@ -0,0 +1,31 @@ +package test + +import ( + "context" + "fmt" + "net" + + "github.com/cli/cli/v2/pkg/liveshare" + "golang.org/x/crypto/ssh" +) + +type Session struct { + channel ssh.Channel +} + +func (s *Session) KeepAlive(reason string) { +} + +func (s *Session) StartSharing(ctx context.Context, sessionName string, port int) (liveshare.ChannelID, error) { + conn, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", ServerPort)) + if err != nil { + return liveshare.ChannelID{}, err + } + s.channel = &Channel{conn} + return liveshare.ChannelID{}, nil +} + +// Creates mock SSH channel connected to the mock gRPC server +func (s *Session) OpenStreamingChannel(ctx context.Context, id liveshare.ChannelID) (ssh.Channel, error) { + return s.channel, nil +} diff --git a/pkg/cmd/codespace/jupyter.go b/pkg/cmd/codespace/jupyter.go index 77bedb301..5c19c2ab1 100644 --- a/pkg/cmd/codespace/jupyter.go +++ b/pkg/cmd/codespace/jupyter.go @@ -6,6 +6,7 @@ import ( "net" "strings" + "github.com/cli/cli/v2/internal/codespaces/grpc" "github.com/cli/cli/v2/pkg/liveshare" "github.com/spf13/cobra" ) @@ -44,11 +45,17 @@ func (a *App) Jupyter(ctx context.Context, codespaceName string) (err error) { defer safeClose(session, &err) a.StartProgressIndicatorWithLabel("Starting JupyterLab on codespace") - serverPort, serverUrl, err := session.StartJupyterServer(ctx) - a.StopProgressIndicator() + client, err := connectToGRPCServer(ctx, session, codespace.Connection.SessionToken) + if err != nil { + return fmt.Errorf("failed to connect to internal server: %w", err) + } + defer safeClose(client, &err) + + serverPort, serverUrl, err := startJupyterServer(ctx, client) if err != nil { return fmt.Errorf("failed to start JupyterLab server: %w", err) } + a.StopProgressIndicator() // Pass 0 to pick a random port listen, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", 0)) @@ -80,3 +87,27 @@ func (a *App) Jupyter(ctx context.Context, codespaceName string) (err error) { return nil // success } } + +func connectToGRPCServer(ctx context.Context, session liveshareSession, token string) (*grpc.Client, error) { + ctx, cancel := context.WithTimeout(ctx, grpc.ConnectionTimeout) + defer cancel() + + client, err := grpc.Connect(ctx, session, token) + if err != nil { + return nil, fmt.Errorf("error connecting to internal server: %w", err) + } + + return client, nil +} + +func startJupyterServer(ctx context.Context, client *grpc.Client) (int, string, error) { + ctx, cancel := context.WithTimeout(ctx, grpc.RequestTimeout) + defer cancel() + + serverPort, serverUrl, err := client.StartJupyterServer(ctx) + if err != nil { + return 0, "", fmt.Errorf("failed to start JupyterLab server: %w", err) + } + + return serverPort, serverUrl, nil +}