imterah/hermes
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases 1 Packages Wiki Activity Actions

feature: Refactors backend runtime's communication mechanism to be more stable.

Browse source
This commit is contained in:
Tera << 8 2025-01-06 01:24:11 -05:00
parent 93f2f9cbee
commit 1e1a330a4b
Signed by: imterah
GPG key ID: 8FA7DD57BA6CEA37
10 changed files with 254 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

28
backend/api/controllers/v1/backends/create.go
View file

@ -125,16 +125,13 @@ func CreateBackend(c *gin.Context) {
return
}
backend.RuntimeCommands <- &commonbackend.CheckServerParameters{
backendParamCheckResponse, err := backend.ProcessCommand(&commonbackend.CheckServerParameters{
Type: "checkServerParameters",
Arguments: backendParameters,
}
})
backendParamCheckResponse := <-backend.RuntimeCommands
switch responseMessage := backendParamCheckResponse.(type) {
case error:
log.Warnf("Failed to get response for backend: %s", responseMessage.Error())
if err != nil {
log.Warnf("Failed to get response for backend: %s", err.Error())
err = backend.Stop()
@ -147,6 +144,9 @@ func CreateBackend(c *gin.Context) {
})
return
}
switch responseMessage := backendParamCheckResponse.(type) {
case *commonbackend.CheckParametersResponse:
if responseMessage.InResponseTo != "checkServerParameters" {
log.Errorf("Got illegal response to CheckServerParameters: %s", responseMessage.InResponseTo)
@ -215,16 +215,13 @@ func CreateBackend(c *gin.Context) {
return
}
backend.RuntimeCommands <- &commonbackend.Start{
backendStartResponse, err := backend.ProcessCommand(&commonbackend.Start{
Type: "start",
Arguments: backendParameters,
}
})
backendStartResponse := <-backend.RuntimeCommands
switch responseMessage := backendStartResponse.(type) {
case error:
log.Warnf("Failed to get response for backend: %s", responseMessage.Error())
if err != nil {
log.Warnf("Failed to get response for backend: %s", err.Error())
err = backend.Stop()
@ -237,6 +234,9 @@ func CreateBackend(c *gin.Context) {
})
return
}
switch responseMessage := backendStartResponse.(type) {
case *commonbackend.BackendStatusResponse:
if !responseMessage.IsRunning {
err = backend.Stop()

14
backend/api/controllers/v1/proxies/connections.go
View file

@ -118,19 +118,19 @@ func GetConnections(c *gin.Context) {
return
}
backendRuntime.RuntimeCommands <- &commonbackend.ProxyConnectionsRequest{
backendResponse, err := backendRuntime.ProcessCommand(&commonbackend.ProxyConnectionsRequest{
Type: "proxyConnectionsRequest",
}
})
backendResponse := <-backendRuntime.RuntimeCommands
switch responseMessage := backendResponse.(type) {
case error:
log.Warnf("Failed to get response for backend: %s", responseMessage.Error())
if err != nil {
log.Warnf("Failed to get response for backend: %s", err.Error())
c.JSON(http.StatusInternalServerError, gin.H{
"error": "Failed to get status response from backend",
})
}
switch responseMessage := backendResponse.(type) {
case *commonbackend.ProxyConnectionsResponse:
sanitizedConnections := []*SanitizedConnection{}

14
backend/api/controllers/v1/proxies/create.go
View file

@ -139,25 +139,25 @@ func CreateProxy(c *gin.Context) {
return
}
backend.RuntimeCommands <- &commonbackend.AddProxy{
backendResponse, err := backend.ProcessCommand(&commonbackend.AddProxy{
Type: "addProxy",
SourceIP: proxy.SourceIP,
SourcePort: proxy.SourcePort,
DestPort: proxy.DestinationPort,
Protocol: proxy.Protocol,
}
})
backendResponse := <-backend.RuntimeCommands
switch responseMessage := backendResponse.(type) {
case error:
log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, responseMessage.Error())
if err != nil {
log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
c.JSON(http.StatusInternalServerError, gin.H{
"error": "failed to get response from backend",
})
return
}
switch responseMessage := backendResponse.(type) {
case *commonbackend.ProxyStatusResponse:
if !responseMessage.IsActive {
log.Warnf("Failed to start proxy for backend #%d", proxy.BackendID)

14
backend/api/controllers/v1/proxies/remove.go
View file

@ -110,25 +110,25 @@ func RemoveProxy(c *gin.Context) {
return
}
backend.RuntimeCommands <- &commonbackend.RemoveProxy{
backendResponse, err := backend.ProcessCommand(&commonbackend.RemoveProxy{
Type: "removeProxy",
SourceIP: proxy.SourceIP,
SourcePort: proxy.SourcePort,
DestPort: proxy.DestinationPort,
Protocol: proxy.Protocol,
}
})
backendResponse := <-backend.RuntimeCommands
switch responseMessage := backendResponse.(type) {
case error:
log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, responseMessage.Error())
if err != nil {
log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
c.JSON(http.StatusInternalServerError, gin.H{
"error": "Failed to get response from backend. Proxy was still successfully deleted",
})
return
}
switch responseMessage := backendResponse.(type) {
case *commonbackend.ProxyStatusResponse:
if responseMessage.IsActive {
c.JSON(http.StatusInternalServerError, gin.H{

6
backend/api/controllers/v1/proxies/start.go
View file

@ -100,15 +100,13 @@ func StartProxy(c *gin.Context) {
return
}
backend.RuntimeCommands <- &commonbackend.AddProxy{
backendResponse, err := backend.ProcessCommand(&commonbackend.AddProxy{
Type: "addProxy",
SourceIP: proxy.SourceIP,
SourcePort: proxy.SourcePort,
DestPort: proxy.DestinationPort,
Protocol: proxy.Protocol,
}
backendResponse := <-backend.RuntimeCommands
})
switch responseMessage := backendResponse.(type) {
case error:

14
backend/api/controllers/v1/proxies/stop.go
View file

@ -100,25 +100,25 @@ func StopProxy(c *gin.Context) {
return
}
backend.RuntimeCommands <- &commonbackend.RemoveProxy{
backendResponse, err := backend.ProcessCommand(&commonbackend.RemoveProxy{
Type: "removeProxy",
SourceIP: proxy.SourceIP,
SourcePort: proxy.SourcePort,
DestPort: proxy.DestinationPort,
Protocol: proxy.Protocol,
}
})
backendResponse := <-backend.RuntimeCommands
switch responseMessage := backendResponse.(type) {
case error:
log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, responseMessage.Error())
if err != nil {
log.Warnf("Failed to get response for backend #%d: %s", proxy.BackendID, err.Error())
c.JSON(http.StatusInternalServerError, gin.H{
"error": "failed to get response from backend",
})
return
}
switch responseMessage := backendResponse.(type) {
case *commonbackend.ProxyStatusResponse:
if responseMessage.IsActive {
c.JSON(http.StatusInternalServerError, gin.H{