Skip to content

Commit 58a0556

Browse files
josebaliusjosebalius
committed
logs cmd spike and refactor of ssh tunnel methods
1 parent ebc8ce5 commit 58a0556

File tree

4 files changed

+260
-70
lines changed

4 files changed

+260
-70
lines changed

‎cmd/ghcs/logs.go‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
package main
2+
3+
import (
4+
"bufio"
5+
"context"
6+
"fmt"
7+
"os"
8+
9+
"github.com/github/ghcs/api"
10+
"github.com/github/ghcs/internal/codespaces"
11+
"github.com/spf13/cobra"
12+
)
13+
14+
func NewLogsCmd() *cobra.Command {
15+
return &cobra.Command{
16+
Use: "logs",
17+
Short: "Access Codespace logs",
18+
RunE: func(cmd *cobra.Command, args []string) error {
19+
var codespaceName string
20+
if len(args) > 0 {
21+
codespaceName = args[0]
22+
}
23+
return Logs(codespaceName)
24+
},
25+
}
26+
}
27+
28+
func init() {
29+
rootCmd.AddCommand(NewLogsCmd())
30+
}
31+
32+
func Logs(codespaceName string) error {
33+
apiClient := api.New(os.Getenv("GITHUB_TOKEN"))
34+
ctx := context.Background()
35+
36+
user, err := apiClient.GetUser(ctx)
37+
if err != nil {
38+
return fmt.Errorf("getting user: %v", err)
39+
}
40+
41+
codespace, token, err := codespaces.GetOrChooseCodespace(ctx, apiClient, user, codespaceName)
42+
if err != nil {
43+
return fmt.Errorf("get or choose codespace: %v", err)
44+
}
45+
46+
lsclient, err := codespaces.ConnectToLiveshare(ctx, apiClient, token, codespace)
47+
if err != nil {
48+
return fmt.Errorf("connecting to liveshare: %v", err)
49+
}
50+
51+
tunnelPort, connClosed, err := codespaces.MakeSSHTunnel(ctx, lsclient, 0)
52+
if err != nil {
53+
return fmt.Errorf("make ssh tunnel: %v", err)
54+
}
55+
56+
dst := fmt.Sprintf("%s@localhost", getSSHUser(codespace))
57+
stdout, err := codespaces.RunCommand(
58+
ctx, tunnelPort, dst, "cat /workspaces/.codespaces/.persistedshare/creation.log",
59+
)
60+
if err != nil {
61+
return fmt.Errorf("run command: %v", err)
62+
}
63+
64+
done := make(chan error)
65+
go func() {
66+
scanner := bufio.NewScanner(stdout)
67+
for scanner.Scan() {
68+
fmt.Println(scanner.Text())
69+
}
70+
71+
if err := scanner.Err(); err != nil {
72+
done <- fmt.Errorf("error scanning: %v", err)
73+
return
74+
}
75+
76+
if err := stdout.Close(); err != nil {
77+
done <- fmt.Errorf("close stdout: %v", err)
78+
return
79+
}
80+
done <- nil
81+
}()
82+
83+
select {
84+
case err := <-connClosed:
85+
if err != nil {
86+
return fmt.Errorf("connection closed: %v", err)
87+
}
88+
case err := <-done:
89+
if err != nil {
90+
return err
91+
}
92+
}
93+
94+
return nil
95+
}

‎cmd/ghcs/ssh.go‎

Lines changed: 17 additions & 70 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,7 @@ import (
44
"bufio"
55
"context"
66
"fmt"
7-
"math/rand"
87
"os"
9-
"os/exec"
10-
"strconv"
118
"strings"
129
"time"
1310

@@ -49,37 +46,9 @@ func SSH(sshProfile, codespaceName string, sshServerPort int) error {
4946
return fmt.Errorf("error getting user: %v", err)
5047
}
5148

52-
var (
53-
codespace *api.Codespace
54-
token string
55-
)
56-
57-
if codespaceName == "" {
58-
codespace, err = codespaces.ChooseCodespace(ctx, apiClient, user)
59-
if err != nil {
60-
if err == codespaces.ErrNoCodespaces {
61-
fmt.Println(err.Error())
62-
return nil
63-
}
64-
65-
return fmt.Errorf("error choosing codespace: %v", err)
66-
}
67-
codespaceName = codespace.Name
68-
69-
token, err = apiClient.GetCodespaceToken(ctx, user.Login, codespaceName)
70-
if err != nil {
71-
return fmt.Errorf("error getting codespace token: %v", err)
72-
}
73-
} else {
74-
token, err = apiClient.GetCodespaceToken(ctx, user.Login, codespaceName)
75-
if err != nil {
76-
return fmt.Errorf("error getting codespace token: %v", err)
77-
}
78-
79-
codespace, err = apiClient.GetCodespace(ctx, token, user.Login, codespaceName)
80-
if err != nil {
81-
return fmt.Errorf("error getting full codespace details: %v", err)
82-
}
49+
codespace, token, err := codespaces.GetOrChooseCodespace(ctx, apiClient, user, codespaceName)
50+
if err != nil {
51+
return fmt.Errorf("get or choose codespace: %v")
8352
}
8453

8554
lsclient, err := codespaces.ConnectToLiveshare(ctx, apiClient, token, codespace)
@@ -106,56 +75,34 @@ func SSH(sshProfile, codespaceName string, sshServerPort int) error {
10675
fmt.Printf("\n")
10776
}
10877

109-
server, err := liveshare.NewServer(lsclient)
78+
tunnelPort, tunnelClosed, err := codespaces.MakeSSHTunnel(ctx, lsclient, sshServerPort)
11079
if err != nil {
111-
return fmt.Errorf("error creating server: %v", err)
112-
}
113-
114-
rand.Seed(time.Now().Unix())
115-
port := rand.Intn(9999-2000) + 2000 // improve this obviously
116-
if sshServerPort != 0 {
117-
port = sshServerPort
118-
}
119-
120-
if err := server.StartSharing(ctx, "sshd", 2222); err != nil {
121-
return fmt.Errorf("error sharing sshd port: %v", err)
80+
return fmt.Errorf("make ssh tunnel: %v", err)
12281
}
12382

124-
portForwarder := liveshare.NewPortForwarder(lsclient, server, port)
125-
go func() {
126-
if err := portForwarder.Start(ctx); err != nil {
127-
panic(fmt.Errorf("error forwarding port: %v", err))
128-
}
129-
}()
130-
13183
connectDestination := sshProfile
13284
if connectDestination == "" {
13385
connectDestination = fmt.Sprintf("%s@localhost", getSSHUser(codespace))
13486
}
13587

88+
usingCustomPort := tunnelPort == sshServerPort
89+
connClosed := codespaces.ConnectToTunnel(ctx, tunnelPort, connectDestination, usingCustomPort)
90+
13691
fmt.Println("Ready...")
137-
if err := connect(ctx, port, connectDestination, port == sshServerPort); err != nil {
138-
return fmt.Errorf("error connecting via SSH: %v", err)
92+
select {
93+
case err := <-tunnelClosed:
94+
if err != nil {
95+
return fmt.Errorf("tunnel closed: %v", err)
96+
}
97+
case err := <-connClosed:
98+
if err != nil {
99+
return fmt.Errorf("connection closed: %v", err)
100+
}
139101
}
140102

141103
return nil
142104
}
143105

144-
func connect(ctx context.Context, port int, destination string, setServerPort bool) error {
145-
connectionDetailArgs := []string{"-p", strconv.Itoa(port), "-o", "NoHostAuthenticationForLocalhost=yes"}
146-
147-
if setServerPort {
148-
fmt.Println("Connection Details: ssh " + destination + " " + strings.Join(connectionDetailArgs, " "))
149-
}
150-
151-
args := []string{destination, "-X", "-Y", "-C"} // X11, X11Trust, Compression
152-
cmd := exec.CommandContext(ctx, "ssh", append(args, connectionDetailArgs...)...)
153-
cmd.Stdout = os.Stdout
154-
cmd.Stdin = os.Stdin
155-
cmd.Stderr = os.Stderr
156-
return cmd.Run()
157-
}
158-
159106
func getContainerID(ctx context.Context, terminal *liveshare.Terminal) (string, error) {
160107
fmt.Print(".")
161108
cmd := terminal.NewCommand(

‎internal/codespaces/codespaces.go‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -111,3 +111,35 @@ func ConnectToLiveshare(ctx context.Context, apiClient *api.API, token string, c
111111

112112
return lsclient, nil
113113
}
114+
115+
func GetOrChooseCodespace(ctx context.Context, apiClient *api.API, user *api.User, codespaceName string) (codespace *api.Codespace, token string, err error) {
116+
if codespaceName == "" {
117+
codespace, err = ChooseCodespace(ctx, apiClient, user)
118+
if err != nil {
119+
if err == ErrNoCodespaces {
120+
fmt.Println(err.Error())
121+
return nil, "", nil
122+
}
123+
124+
return nil, "", fmt.Errorf("choosing codespace: %v", err)
125+
}
126+
codespaceName = codespace.Name
127+
128+
token, err = apiClient.GetCodespaceToken(ctx, user.Login, codespaceName)
129+
if err != nil {
130+
return nil, "", fmt.Errorf("getting codespace token: %v", err)
131+
}
132+
} else {
133+
token, err = apiClient.GetCodespaceToken(ctx, user.Login, codespaceName)
134+
if err != nil {
135+
return nil, "", fmt.Errorf("getting codespace token for given codespace: %v", err)
136+
}
137+
138+
codespace, err = apiClient.GetCodespace(ctx, token, user.Login, codespaceName)
139+
if err != nil {
140+
return nil, "", fmt.Errorf("getting full codespace details: %v", err)
141+
}
142+
}
143+
144+
return codespace, token, nil
145+
}

‎internal/codespaces/ssh.go‎

Lines changed: 116 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
package codespaces
2+
3+
import (
4+
"context"
5+
"fmt"
6+
"io"
7+
"math/rand"
8+
"os"
9+
"os/exec"
10+
"strconv"
11+
"strings"
12+
"time"
13+
14+
"github.com/github/go-liveshare"
15+
)
16+
17+
func MakeSSHTunnel(ctx context.Context, lsclient *liveshare.Client, serverPort int) (int, <-chan error, error) {
18+
tunnelClosed := make(chan error)
19+
20+
server, err := liveshare.NewServer(lsclient)
21+
if err != nil {
22+
return 0, nil, fmt.Errorf("new liveshare server: %v", err)
23+
}
24+
25+
rand.Seed(time.Now().Unix())
26+
port := rand.Intn(9999-2000) + 2000 // improve this obviously
27+
if serverPort != 0 {
28+
port = serverPort
29+
}
30+
31+
// TODO(josebalius): This port won't always be 2222
32+
if err := server.StartSharing(ctx, "sshd", 2222); err != nil {
33+
return 0, nil, fmt.Errorf("sharing sshd port: %v", err)
34+
}
35+
36+
go func() {
37+
portForwarder := liveshare.NewPortForwarder(lsclient, server, port)
38+
if err := portForwarder.Start(ctx); err != nil {
39+
tunnelClosed <- fmt.Errorf("forwarding port: %v", err)
40+
return
41+
}
42+
tunnelClosed <- nil
43+
}()
44+
45+
return port, tunnelClosed, nil
46+
}
47+
48+
func makeSSHArgs(port int, dst, cmd string) ([]string, []string) {
49+
connArgs := []string{"-p", strconv.Itoa(port), "-o", "NoHostAuthenticationForLocalhost=yes"}
50+
cmdArgs := append([]string{dst, "-X", "-Y", "-C"}, connArgs...) // X11, X11Trust, Compression
51+
52+
if cmd != "" {
53+
cmdArgs = append(cmdArgs, cmd)
54+
}
55+
56+
return cmdArgs, connArgs
57+
}
58+
59+
func ConnectToTunnel(ctx context.Context, port int, destination string, usingCustomPort bool) <-chan error {
60+
connClosed := make(chan error)
61+
args, connArgs := makeSSHArgs(port, destination, "")
62+
63+
if usingCustomPort {
64+
fmt.Println("Connection Details: ssh " + destination + " " + strings.Join(connArgs, " "))
65+
}
66+
67+
cmd := exec.CommandContext(ctx, "ssh", args...)
68+
cmd.Stdout = os.Stdout
69+
cmd.Stdin = os.Stdin
70+
cmd.Stderr = os.Stderr
71+
72+
go func() {
73+
connClosed <- cmd.Run()
74+
}()
75+
76+
return connClosed
77+
}
78+
79+
type command struct {
80+
Cmd *exec.Cmd
81+
StdoutPipe io.ReadCloser
82+
}
83+
84+
func newCommand(cmd *exec.Cmd) (*command, error) {
85+
stdoutPipe, err := cmd.StdoutPipe()
86+
if err != nil {
87+
return nil, fmt.Errorf("create stdout pipe: %v", err)
88+
}
89+
90+
if err := cmd.Start(); err != nil {
91+
return nil, fmt.Errorf("cmd start: %v", err)
92+
}
93+
94+
return &command{
95+
Cmd: cmd,
96+
StdoutPipe: stdoutPipe,
97+
}, nil
98+
}
99+
100+
func (c *command) Read(p []byte) (int, error) {
101+
return c.StdoutPipe.Read(p)
102+
}
103+
104+
func (c *command) Close() error {
105+
if err := c.StdoutPipe.Close(); err != nil {
106+
return fmt.Errorf("close stdout: %v", err)
107+
}
108+
109+
return c.Cmd.Wait()
110+
}
111+
112+
func RunCommand(ctx context.Context, tunnelPort int, destination, cmdString string) (io.ReadCloser, error) {
113+
args, _ := makeSSHArgs(tunnelPort, destination, cmdString)
114+
cmd := exec.CommandContext(ctx, "ssh", args...)
115+
return newCommand(cmd)
116+
}

0 commit comments

Comments
 (0)