FilesExpand file tree

coder-link

/

httpserver.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

114 lines (103 loc) · 3.16 KB

coder-link

/

httpserver.ts

Copy path

Top

File metadata and controls

• Code
• Blame

114 lines (103 loc) · 3.16 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

import { logger } from "@coder/logger"

import * as express from "express"

import * as http from "http"

import * as net from "net"

import * as nodeFetch from "node-fetch"

import Websocket from "ws"

import * as util from "../../src/common/util"

import { ensureAddress } from "../../src/node/app"

import { handleUpgrade } from "../../src/node/wsRouter"

// Perhaps an abstraction similar to this should be used in app.ts as well.

export class HttpServer {

private readonly sockets = new Set<net.Socket>()

private cleanupTimeout?: NodeJS.Timeout

// See usage in test/integration.ts

public constructor(private readonly hs = http.createServer()) {

this.hs.on("connection", (socket) => {

this.sockets.add(socket)

socket.on("close", () => {

this.sockets.delete(socket)

if (this.cleanupTimeout && this.sockets.size === 0) {

clearTimeout(this.cleanupTimeout)

this.cleanupTimeout = undefined

}

})

})

}

/**

* listen starts the server on a random localhost port.

* Use close to cleanup when done.

*/

public listen(fn: http.RequestListener): Promise<void> {

this.hs.on("request", fn)

let resolved = false

return new Promise((res, rej) => {

this.hs.listen(0, "localhost", () => {

res()

resolved = true

})

this.hs.on("error", (err) => {

if (!resolved) {

rej(err)

} else {

// Promise resolved earlier so this is some other error.

util.logError(logger, "http server error", err)

}

})

})

}

/**

* Send upgrade requests to an Express app.

*/

public listenUpgrade(app: express.Express): void {

handleUpgrade(app, this.hs)

}

/**

* close cleans up the server.

*/

public close(): Promise<void> {

return new Promise((res, rej) => {

// Close will not actually close anything; it just waits until everything

// is closed.

this.hs.close((err) => {

if (err) {

rej(err)

return

}

res()

})

// If there are sockets remaining we might need to force close them or

// this promise might never resolve.

if (this.sockets.size > 0) {

// Give sockets a chance to close up shop.

this.cleanupTimeout = setTimeout(() => {

this.cleanupTimeout = undefined

for (const socket of this.sockets.values()) {

console.warn("a socket was left hanging")

socket.destroy()

}

}, 1000)

}

})

}

/**

* fetch fetches the request path.

* The request path must be rooted!

*/

public fetch(requestPath: string, opts?: nodeFetch.RequestInit): Promise<nodeFetch.Response> {

return nodeFetch.default(`${ensureAddress(this.hs)}${requestPath}`, opts)

}

/**

* Open a websocket against the requset path.

*/

public ws(requestPath: string): Websocket {

return new Websocket(`${ensureAddress(this.hs).replace("http:", "ws:")}${requestPath}`)

}

public port(): number {

const addr = this.hs.address()

if (addr && typeof addr === "object") {

return addr.port

}

throw new Error("server not listening or listening on unix socket")

}

}