1246 lines
32 KiB
Go
1246 lines
32 KiB
Go
package hodu
|
|
|
|
import "container/list"
|
|
import "encoding/json"
|
|
import "fmt"
|
|
import "net/http"
|
|
import "strings"
|
|
import "sync"
|
|
import "time"
|
|
|
|
import "golang.org/x/net/websocket"
|
|
|
|
/*
|
|
* POST GET PUT DELETE
|
|
* /servers - create new server list all servers bulk update delete all servers
|
|
* /servers/1 - X get server 1 details update server 1 delete server 1
|
|
* /servers/1/xxx -
|
|
*
|
|
* /servers/1112123/peers
|
|
* POST add a new peer to a server
|
|
* GET list all peers
|
|
* PUT create/replace
|
|
* PATCH partial update
|
|
* /servers/1112123/peers/1231344
|
|
* GET get info
|
|
*/
|
|
|
|
type json_in_client_conn struct {
|
|
ServerAddrs []string `json:"server-addrs"` // multiple addresses for round-robin connection re-attempts
|
|
ClientToken string `json:"client-token"`
|
|
CloseOnConnErrorEvent bool `json:"close-on-conn-error-event"`
|
|
}
|
|
|
|
type json_in_client_route struct {
|
|
RId RouteId `json:"route-id"` // 0 for auto-assignement.
|
|
ClientPeerAddr string `json:"client-peer-addr"`
|
|
ClientPeerName string `json:"client-peer-name"`
|
|
ServerPeerOption string `json:"server-peer-option"`
|
|
|
|
// the following two fields in the input structure is the requested values.
|
|
// the actual values are returned in json_out_clinet_route and may be different from the requested ones
|
|
ServerPeerSvcAddr string `json:"server-peer-svc-addr"` // requested listening address on the server side - not actual
|
|
ServerPeerSvcNet string `json:"server-peer-svc-net"` // requested permitted network in prefix notation - not actual
|
|
|
|
Lifetime string `json:"lifetime"`
|
|
}
|
|
|
|
type json_in_client_route_update struct {
|
|
Lifetime string `json:"lifetime"`
|
|
}
|
|
|
|
type json_out_client_conn struct {
|
|
CId ConnId `json:"conn-id"`
|
|
ReqServerAddrs []string `json:"req-server-addrs"` // server addresses requested. may include a domain name
|
|
CurrentServerIndex int `json:"current-server-index"`
|
|
ServerAddr string `json:"server-addr"` // actual server address
|
|
ClientAddr string `json:"client-addr"`
|
|
ClientToken string `json:"client-token"`
|
|
CreatedMilli int64 `json:"created-milli"`
|
|
Routes []json_out_client_route `json:"routes,omitempty"`
|
|
}
|
|
|
|
type json_out_client_route struct {
|
|
CId ConnId `json:"conn-id"`
|
|
RId RouteId `json:"route-id"`
|
|
ClientPeerAddr string `json:"client-peer-addr"`
|
|
ClientPeerName string `json:"client-peer-name"`
|
|
ServerPeerOption string `json:"server-peer-option"`
|
|
|
|
// These two values are actual addresses and networks listening on peer service port
|
|
// and may be different from the requested values conveyed in json_in_client_route.
|
|
ServerPeerSvcAddr string `json:"server-peer-svc-addr"`
|
|
ServerPeerSvcNet string `json:"server-peer-svc-net"`
|
|
|
|
Lifetime string `json:"lifetime"`
|
|
LifetimeStart int64 `json:"lifetime-start"`
|
|
CreatedMilli int64 `json:"created-milli"`
|
|
}
|
|
|
|
type json_out_client_peer struct {
|
|
CId ConnId `json:"conn-id"`
|
|
RId RouteId `json:"route-id"`
|
|
PId PeerId `json:"peer-id"`
|
|
ClientPeerAddr string `json:"client-peer-addr"`
|
|
ClientLocalAddr string `json:"client-local-addr"`
|
|
ServerPeerAddr string `json:"server-peer-addr"`
|
|
ServerLocalAddr string `json:"server-local-addr"`
|
|
CreatedMilli int64 `json:"created-milli"`
|
|
}
|
|
|
|
type json_out_client_conn_id struct {
|
|
CId ConnId `json:"conn-id"`
|
|
}
|
|
|
|
type json_out_client_route_id struct {
|
|
CId ConnId `json:"conn-id"`
|
|
RId RouteId `json:"route-id"`
|
|
}
|
|
|
|
type json_out_client_peer_id struct {
|
|
CId ConnId `json:"conn-id"`
|
|
RId RouteId `json:"route-id"`
|
|
PId PeerId `json:"peer-id"`
|
|
}
|
|
|
|
|
|
type json_out_client_stats struct {
|
|
json_out_go_stats
|
|
ClientConns int64 `json:"client-conns"`
|
|
ClientRoutes int64 `json:"client-routes"`
|
|
ClientPeers int64 `json:"client-peers"`
|
|
}
|
|
// ------------------------------------
|
|
|
|
type client_ctl struct {
|
|
c *Client
|
|
id string
|
|
noauth bool // override the auth configuration if true
|
|
}
|
|
|
|
type client_ctl_token struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id_routes struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id_routes_id struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id_routes_spsp struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id_routes_id_peers struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id_routes_id_peers_id struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_conns_id_peers struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_routes struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_client_peers struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_notices struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_notices_id struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_stats struct {
|
|
client_ctl
|
|
}
|
|
|
|
type client_ctl_ws struct {
|
|
client_ctl
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl) Id() string {
|
|
return ctl.id
|
|
}
|
|
|
|
func (ctl *client_ctl) Cors(req *http.Request) bool {
|
|
return ctl.c.ctl_cors
|
|
}
|
|
|
|
func (ctl *client_ctl) Authenticate(req *http.Request) (int, string) {
|
|
if ctl.c.ctl_auth == nil { return http.StatusOK, "" }
|
|
return ctl.c.ctl_auth.Authenticate(req)
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_token) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var je *json.Encoder
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var jwt *JWT[ServerTokenClaim]
|
|
var claim ServerTokenClaim
|
|
var tok string
|
|
var now time.Time
|
|
|
|
if c.ctl_auth == nil || !c.ctl_auth.Enabled || c.ctl_auth.TokenRsaKey == nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusForbidden)
|
|
err = fmt.Errorf("auth not enabled or token rsa key not set")
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
now = time.Now()
|
|
claim.IssuedAt = now.Unix()
|
|
claim.ExpiresAt = now.Add(c.ctl_auth.TokenTtl).Unix()
|
|
jwt = NewJWT(c.ctl_auth.TokenRsaKey, &claim)
|
|
tok, err = jwt.SignRS512()
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusInternalServerError)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
err = je.Encode(json_out_token{ AccessToken: tok }) // TODO: refresh token
|
|
if err != nil { goto oops }
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusMethodNotAllowed)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var err error
|
|
var je *json.Encoder
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var js []json_out_client_conn
|
|
var ci ConnId
|
|
|
|
js = make([]json_out_client_conn, 0)
|
|
c.cts_mtx.Lock()
|
|
for _, ci = range c.cts_map.get_sorted_keys() {
|
|
var cts *ClientConn
|
|
var jsp []json_out_client_route
|
|
var ri RouteId
|
|
|
|
cts = c.cts_map[ci]
|
|
jsp = make([]json_out_client_route, 0)
|
|
cts.route_mtx.Lock()
|
|
for _, ri = range cts.route_map.get_sorted_keys() {
|
|
var r *ClientRoute
|
|
var lftsta time.Time
|
|
var lftdur time.Duration
|
|
|
|
r = cts.route_map[ri]
|
|
|
|
lftsta, lftdur = r.GetLifetimeInfo()
|
|
jsp = append(jsp, json_out_client_route{
|
|
CId: cts.Id,
|
|
RId: r.Id,
|
|
ClientPeerAddr: r.PeerAddr,
|
|
ClientPeerName: r.PeerName,
|
|
ServerPeerSvcAddr: r.ServerPeerSvcAddr.Get(),
|
|
ServerPeerSvcNet: r.ServerPeerSvcNet.Get(),
|
|
ServerPeerOption: r.ServerPeerOption.String(),
|
|
Lifetime: DurationToSecString(lftdur),
|
|
LifetimeStart: lftsta.Unix(),
|
|
CreatedMilli: r.Created.UnixMilli(),
|
|
})
|
|
}
|
|
cts.route_mtx.Unlock()
|
|
|
|
js = append(js, json_out_client_conn{
|
|
CId: cts.Id,
|
|
ReqServerAddrs: cts.cfg.ServerAddrs,
|
|
CurrentServerIndex: cts.cfg.Index,
|
|
ServerAddr: cts.remote_addr.Get(),
|
|
ClientAddr: cts.local_addr.Get(),
|
|
ClientToken: cts.Token.Get(),
|
|
CreatedMilli: cts.Created.UnixMilli(),
|
|
Routes: jsp,
|
|
})
|
|
}
|
|
c.cts_mtx.Unlock()
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(js); err != nil { goto oops }
|
|
|
|
case http.MethodPost:
|
|
// add a new client connection to a server with no client-side peers
|
|
// while the client code can accept one more more client-side peer address
|
|
// with the server added, i don't intentially accept peer addresses
|
|
// as it's tricky to handle erroneous cases in creating the client routes
|
|
// after hacing connected to the server. therefore, the json_in_client_conn
|
|
// type contains a server address field only.
|
|
var in_cc json_in_client_conn
|
|
var cc ClientConnConfig
|
|
var cts *ClientConn
|
|
|
|
err = json.NewDecoder(req.Body).Decode(&in_cc)
|
|
if err != nil || len(in_cc.ServerAddrs) <= 0 {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
goto done
|
|
}
|
|
|
|
cc.ServerAddrs = in_cc.ServerAddrs
|
|
cc.ClientToken = in_cc.ClientToken
|
|
cc.CloseOnConnErrorEvent = in_cc.CloseOnConnErrorEvent
|
|
cts, err = c.start_service(&cc) // TODO: this can be blocking. do we have to resolve addresses before calling this? also not good because resolution succeed or fail at each attempt. however ok as ServeHTTP itself is in a goroutine?
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusInternalServerError)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
} else {
|
|
status_code = WriteJsonRespHeader(w, http.StatusCreated)
|
|
if err = je.Encode(json_out_client_conn_id{CId: cts.Id}); err != nil { goto oops }
|
|
}
|
|
|
|
case http.MethodDelete:
|
|
// delete all client connections to servers. if we request to stop all
|
|
// client connections, they will remove themselves from the client.
|
|
// we do passive deletion rather than doing active deletion by calling
|
|
// c.RemoveAllClientConns()
|
|
c.ReqStopAllClientConns()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
// client-conns/{conn_id}
|
|
func (ctl *client_ctl_client_conns_id) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var je *json.Encoder
|
|
var cts *ClientConn
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
cts, err = c.FindClientConnByIdStr(conn_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var jsp []json_out_client_route
|
|
var js *json_out_client_conn
|
|
var ri RouteId
|
|
|
|
jsp = make([]json_out_client_route, 0)
|
|
cts.route_mtx.Lock()
|
|
for _, ri = range cts.route_map.get_sorted_keys() {
|
|
var r *ClientRoute
|
|
var lftsta time.Time
|
|
var lftdur time.Duration
|
|
|
|
r = cts.route_map[ri]
|
|
|
|
lftsta, lftdur = r.GetLifetimeInfo()
|
|
jsp = append(jsp, json_out_client_route{
|
|
CId: cts.Id,
|
|
RId: r.Id,
|
|
ClientPeerAddr: r.PeerAddr,
|
|
ClientPeerName: r.PeerName,
|
|
ServerPeerSvcAddr: r.ServerPeerSvcAddr.Get(),
|
|
ServerPeerSvcNet: r.ServerPeerSvcNet.Get(),
|
|
ServerPeerOption: r.ServerPeerOption.String(),
|
|
Lifetime: DurationToSecString(lftdur),
|
|
LifetimeStart: lftsta.Unix(),
|
|
CreatedMilli: r.Created.UnixMilli(),
|
|
})
|
|
}
|
|
cts.route_mtx.Unlock()
|
|
|
|
js = &json_out_client_conn{
|
|
CId: cts.Id,
|
|
ReqServerAddrs: cts.cfg.ServerAddrs,
|
|
CurrentServerIndex: cts.cfg.Index,
|
|
ServerAddr: cts.remote_addr.Get(),
|
|
ClientAddr: cts.local_addr.Get(),
|
|
ClientToken: cts.Token.Get(),
|
|
CreatedMilli: cts.Created.UnixMilli(),
|
|
Routes: jsp,
|
|
}
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(js); err != nil { goto oops }
|
|
|
|
case http.MethodDelete:
|
|
//c.RemoveClientConn(cts)
|
|
cts.ReqStop()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns_id_routes) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var je *json.Encoder
|
|
var cts *ClientConn
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
cts, err = c.FindClientConnByIdStr(conn_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var jsp []json_out_client_route
|
|
var ri RouteId
|
|
|
|
jsp = make([]json_out_client_route, 0)
|
|
cts.route_mtx.Lock()
|
|
for _, ri = range cts.route_map.get_sorted_keys() {
|
|
var r *ClientRoute
|
|
var lftsta time.Time
|
|
var lftdur time.Duration
|
|
|
|
r = cts.route_map[ri]
|
|
|
|
lftsta, lftdur = r.GetLifetimeInfo()
|
|
jsp = append(jsp, json_out_client_route{
|
|
CId: r.cts.Id,
|
|
RId: r.Id,
|
|
ClientPeerAddr: r.PeerAddr,
|
|
ClientPeerName: r.PeerName,
|
|
ServerPeerSvcAddr: r.ServerPeerSvcAddr.Get(),
|
|
ServerPeerSvcNet: r.ServerPeerSvcNet.Get(),
|
|
ServerPeerOption: r.ServerPeerOption.String(),
|
|
Lifetime: DurationToSecString(lftdur),
|
|
LifetimeStart: lftsta.Unix(),
|
|
CreatedMilli: r.Created.UnixMilli(),
|
|
})
|
|
}
|
|
cts.route_mtx.Unlock()
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(jsp); err != nil { goto oops }
|
|
|
|
case http.MethodPost:
|
|
var jcr json_in_client_route
|
|
var r *ClientRoute
|
|
var rc *ClientRouteConfig
|
|
var server_peer_option RouteOption
|
|
var lifetime time.Duration
|
|
|
|
err = json.NewDecoder(req.Body).Decode(&jcr)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
goto oops
|
|
}
|
|
|
|
if jcr.ClientPeerAddr == "" {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
err = fmt.Errorf("blank client-peer-addr")
|
|
goto oops
|
|
}
|
|
|
|
server_peer_option = StringToRouteOption(jcr.ServerPeerOption)
|
|
if server_peer_option == RouteOption(ROUTE_OPTION_UNSPEC) {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
err = fmt.Errorf("wrong server-peer-option value - %s", server_peer_option)
|
|
goto oops
|
|
}
|
|
|
|
lifetime, err = ParseDurationString(jcr.Lifetime)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
err = fmt.Errorf("wrong lifetime value %s - %s", jcr.Lifetime, err.Error())
|
|
goto oops
|
|
}
|
|
|
|
rc = &ClientRouteConfig{
|
|
Id: jcr.RId,
|
|
PeerAddr: jcr.ClientPeerAddr,
|
|
PeerName: jcr.ClientPeerName,
|
|
Option: server_peer_option,
|
|
ServiceAddr: jcr.ServerPeerSvcAddr,
|
|
ServiceNet: jcr.ServerPeerSvcNet,
|
|
Lifetime: lifetime,
|
|
Static: false,
|
|
}
|
|
|
|
r, err = cts.AddNewClientRoute(rc)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusInternalServerError)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
} else {
|
|
status_code = WriteJsonRespHeader(w, http.StatusCreated)
|
|
if err = je.Encode(json_out_client_route_id{RId: r.Id, CId: r.cts.Id}); err != nil { goto oops }
|
|
}
|
|
|
|
case http.MethodDelete:
|
|
//cts.RemoveAllClientRoutes()
|
|
cts.ReqStopAllClientRoutes()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns_id_routes_id) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var route_id string
|
|
var je *json.Encoder
|
|
var r *ClientRoute
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
route_id = req.PathValue("route_id")
|
|
r, err = c.FindClientRouteByIdStr(conn_id, route_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var lftsta time.Time
|
|
var lftdur time.Duration
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
|
|
lftsta, lftdur = r.GetLifetimeInfo()
|
|
err = je.Encode(json_out_client_route{
|
|
CId: r.cts.Id,
|
|
RId: r.Id,
|
|
ClientPeerAddr: r.PeerAddr,
|
|
ClientPeerName: r.PeerName,
|
|
ServerPeerSvcAddr: r.ServerPeerSvcAddr.Get(),
|
|
ServerPeerSvcNet: r.ServerPeerSvcNet.Get(),
|
|
ServerPeerOption: r.ServerPeerOption.String(),
|
|
Lifetime: DurationToSecString(lftdur),
|
|
LifetimeStart: lftsta.Unix(),
|
|
CreatedMilli: r.Created.UnixMilli(),
|
|
})
|
|
if err != nil { goto oops }
|
|
|
|
case http.MethodPut:
|
|
var jcr json_in_client_route_update
|
|
var lifetime time.Duration
|
|
|
|
err = json.NewDecoder(req.Body).Decode(&jcr)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
goto oops
|
|
}
|
|
|
|
lifetime, err = ParseDurationString(jcr.Lifetime)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
err = fmt.Errorf("wrong lifetime value %s - %s", jcr.Lifetime, err.Error())
|
|
goto oops
|
|
}
|
|
|
|
if strings.HasPrefix(jcr.Lifetime, "+") {
|
|
err = r.ExtendLifetime(lifetime)
|
|
} else {
|
|
err = r.ResetLifetime(lifetime)
|
|
}
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusForbidden)
|
|
goto oops
|
|
}
|
|
|
|
status_code = WriteEmptyRespHeader(w, http.StatusOK)
|
|
|
|
case http.MethodDelete:
|
|
r.ReqStop()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns_id_routes_spsp) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var port_id string
|
|
var je *json.Encoder
|
|
var r *ClientRoute
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
port_id = req.PathValue("port_id")
|
|
r, err = c.FindClientRouteByServerPeerSvcPortIdStr(conn_id, port_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var lftsta time.Time
|
|
var lftdur time.Duration
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
|
|
lftsta, lftdur = r.GetLifetimeInfo()
|
|
err = je.Encode(json_out_client_route{
|
|
CId: r.cts.Id,
|
|
RId: r.Id,
|
|
ClientPeerAddr: r.PeerAddr,
|
|
ClientPeerName: r.PeerName,
|
|
ServerPeerSvcAddr: r.ServerPeerSvcAddr.Get(),
|
|
ServerPeerSvcNet: r.ServerPeerSvcNet.Get(),
|
|
ServerPeerOption: r.ServerPeerOption.String(),
|
|
Lifetime: DurationToSecString(lftdur),
|
|
LifetimeStart: lftsta.Unix(),
|
|
})
|
|
if err != nil { goto oops }
|
|
|
|
case http.MethodPut:
|
|
var jcr json_in_client_route_update
|
|
var lifetime time.Duration
|
|
|
|
err = json.NewDecoder(req.Body).Decode(&jcr)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
goto oops
|
|
}
|
|
|
|
lifetime, err = ParseDurationString(jcr.Lifetime)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
err = fmt.Errorf("wrong lifetime value %s - %s", jcr.Lifetime, err.Error())
|
|
goto oops
|
|
} else if lifetime < 0 {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
err = fmt.Errorf("negative lifetime value %s", jcr.Lifetime)
|
|
goto oops
|
|
}
|
|
|
|
if strings.HasPrefix(jcr.Lifetime, "+") {
|
|
err = r.ExtendLifetime(lifetime)
|
|
} else {
|
|
err = r.ResetLifetime(lifetime)
|
|
}
|
|
if err != nil { goto oops }
|
|
|
|
case http.MethodDelete:
|
|
r.ReqStop()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns_id_routes_id_peers) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var route_id string
|
|
var je *json.Encoder
|
|
var r *ClientRoute
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
route_id = req.PathValue("route_id")
|
|
r, err = c.FindClientRouteByIdStr(conn_id, route_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var jcp []json_out_client_peer
|
|
var pi PeerId
|
|
|
|
jcp = make([]json_out_client_peer, 0)
|
|
r.ptc_mtx.Lock()
|
|
for _, pi = range r.ptc_map.get_sorted_keys() {
|
|
var p *ClientPeerConn
|
|
|
|
p = r.ptc_map[pi]
|
|
jcp = append(jcp, json_out_client_peer{
|
|
CId: r.cts.Id,
|
|
RId: r.Id,
|
|
PId: p.conn_id,
|
|
ClientPeerAddr: p.conn.RemoteAddr().String(),
|
|
ClientLocalAddr: p.conn.LocalAddr().String(),
|
|
ServerPeerAddr: p.pts_raddr,
|
|
ServerLocalAddr: p.pts_laddr,
|
|
CreatedMilli: p.Created.UnixMilli(),
|
|
})
|
|
}
|
|
r.ptc_mtx.Unlock()
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(jcp); err != nil { goto oops }
|
|
|
|
case http.MethodDelete:
|
|
r.ReqStopAllClientPeerConns()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns_id_routes_id_peers_id) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var route_id string
|
|
var peer_id string
|
|
var je *json.Encoder
|
|
var p *ClientPeerConn
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
route_id = req.PathValue("route_id")
|
|
peer_id = req.PathValue("peer_id")
|
|
p, err = c.FindClientPeerConnByIdStr(conn_id, route_id, peer_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var jcp *json_out_client_peer
|
|
|
|
jcp = &json_out_client_peer{
|
|
CId: p.route.cts.Id,
|
|
RId: p.route.Id,
|
|
PId: p.conn_id,
|
|
ClientPeerAddr: p.conn.RemoteAddr().String(),
|
|
ClientLocalAddr: p.conn.LocalAddr().String(),
|
|
ServerPeerAddr: p.pts_raddr,
|
|
ServerLocalAddr: p.pts_laddr,
|
|
CreatedMilli: p.Created.UnixMilli(),
|
|
}
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(jcp); err != nil { goto oops }
|
|
|
|
case http.MethodDelete:
|
|
p.ReqStop()
|
|
status_code = WriteEmptyRespHeader(w, http.StatusNoContent)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_conns_id_peers) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var err error
|
|
var conn_id string
|
|
var je *json.Encoder
|
|
var cts *ClientConn
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
cts, err = c.FindClientConnByIdStr(conn_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var jsp []json_out_client_peer
|
|
var e *list.Element
|
|
|
|
jsp = make([]json_out_client_peer, 0)
|
|
cts.ptc_mtx.Lock()
|
|
for e = cts.ptc_list.Front(); e != nil; e = e.Next() {
|
|
var ptc *ClientPeerConn
|
|
ptc = e.Value.(*ClientPeerConn)
|
|
jsp = append(jsp, json_out_client_peer{
|
|
CId: ptc.route.cts.Id,
|
|
RId: ptc.route.Id,
|
|
PId: ptc.conn_id,
|
|
ClientPeerAddr: ptc.conn.RemoteAddr().String(),
|
|
ClientLocalAddr: ptc.conn.LocalAddr().String(),
|
|
ServerPeerAddr: ptc.pts_raddr,
|
|
ServerLocalAddr: ptc.pts_laddr,
|
|
CreatedMilli: ptc.Created.UnixMilli(),
|
|
})
|
|
}
|
|
cts.ptc_mtx.Unlock()
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(jsp); err != nil { goto oops }
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusMethodNotAllowed)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_routes) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var je *json.Encoder
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var js []json_out_client_route
|
|
var e *list.Element
|
|
|
|
js = make([]json_out_client_route, 0)
|
|
c.route_mtx.Lock()
|
|
for e = c.route_list.Front(); e != nil; e = e.Next() {
|
|
var r *ClientRoute
|
|
var lftsta time.Time
|
|
var lftdur time.Duration
|
|
|
|
r = e.Value.(*ClientRoute)
|
|
|
|
lftsta, lftdur = r.GetLifetimeInfo()
|
|
js = append(js, json_out_client_route{
|
|
CId: r.cts.Id,
|
|
RId: r.Id,
|
|
ClientPeerAddr: r.PeerAddr,
|
|
ClientPeerName: r.PeerName,
|
|
ServerPeerSvcAddr: r.ServerPeerSvcAddr.Get(),
|
|
ServerPeerSvcNet: r.ServerPeerSvcNet.Get(),
|
|
ServerPeerOption: r.ServerPeerOption.String(),
|
|
Lifetime: DurationToSecString(lftdur),
|
|
LifetimeStart: lftsta.Unix(),
|
|
CreatedMilli: r.Created.UnixMilli(),
|
|
})
|
|
}
|
|
c.route_mtx.Unlock()
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(js); err != nil { goto oops }
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusMethodNotAllowed)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_client_peers) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var je *json.Encoder
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var js []json_out_client_peer
|
|
var e *list.Element
|
|
|
|
js = make([]json_out_client_peer, 0)
|
|
c.ptc_mtx.Lock()
|
|
for e = c.ptc_list.Front(); e != nil; e = e.Next() {
|
|
var ptc *ClientPeerConn
|
|
ptc = e.Value.(*ClientPeerConn)
|
|
js = append(js, json_out_client_peer{
|
|
CId: ptc.route.cts.Id,
|
|
RId: ptc.route.Id,
|
|
PId: ptc.conn_id,
|
|
ClientPeerAddr: ptc.conn.RemoteAddr().String(),
|
|
ClientLocalAddr: ptc.conn.LocalAddr().String(),
|
|
ServerPeerAddr: ptc.pts_raddr,
|
|
ServerLocalAddr: ptc.pts_laddr,
|
|
CreatedMilli: ptc.Created.UnixMilli(),
|
|
})
|
|
}
|
|
c.ptc_mtx.Unlock()
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(js); err != nil { goto oops }
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusMethodNotAllowed)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_notices) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var cts *ClientConn
|
|
var err error
|
|
|
|
c = ctl.c
|
|
|
|
switch req.Method {
|
|
case http.MethodPost:
|
|
var noti json_in_notice
|
|
|
|
err = json.NewDecoder(req.Body).Decode(¬i)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
goto oops
|
|
}
|
|
|
|
c.cts_mtx.Lock()
|
|
for _, cts = range c.cts_map {
|
|
cts.psc.Send(MakeConnNoticePacket(noti.Text))
|
|
// let's not care about an error when broacasting a notice to all connections
|
|
}
|
|
c.cts_mtx.Unlock()
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_notices_id) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var conn_id string
|
|
var cts *ClientConn
|
|
var je *json.Encoder
|
|
var err error
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
conn_id = req.PathValue("conn_id")
|
|
cts, err = c.FindClientConnByIdStr(conn_id)
|
|
if err != nil {
|
|
status_code = WriteJsonRespHeader(w, http.StatusNotFound)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
switch req.Method {
|
|
case http.MethodPost:
|
|
var noti json_in_notice
|
|
|
|
err = json.NewDecoder(req.Body).Decode(¬i)
|
|
if err != nil {
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
goto oops
|
|
}
|
|
|
|
// no check if noti.Text is empty as i want an empty message to be delivered too.
|
|
err = cts.psc.Send(MakeConnNoticePacket(noti.Text))
|
|
if err != nil {
|
|
err = fmt.Errorf("failed to send conn_notice text '%s' to %s - %s", noti.Text, cts.remote_addr, err.Error())
|
|
status_code = WriteJsonRespHeader(w, http.StatusInternalServerError)
|
|
je.Encode(JsonErrmsg{Text: err.Error()})
|
|
goto oops
|
|
}
|
|
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_stats) ServeHTTP(w http.ResponseWriter, req *http.Request) (int, error) {
|
|
var c *Client
|
|
var status_code int
|
|
var err error
|
|
var je *json.Encoder
|
|
|
|
c = ctl.c
|
|
je = json.NewEncoder(w)
|
|
|
|
switch req.Method {
|
|
case http.MethodGet:
|
|
var stats json_out_client_stats
|
|
stats.from_runtime_stats()
|
|
stats.ClientConns = c.stats.conns.Load()
|
|
stats.ClientRoutes = c.stats.routes.Load()
|
|
stats.ClientPeers = c.stats.peers.Load()
|
|
status_code = WriteJsonRespHeader(w, http.StatusOK)
|
|
if err = je.Encode(stats); err != nil { goto oops }
|
|
|
|
default:
|
|
status_code = WriteEmptyRespHeader(w, http.StatusBadRequest)
|
|
}
|
|
|
|
//done:
|
|
return status_code, nil
|
|
|
|
oops:
|
|
return status_code, err
|
|
}
|
|
|
|
// ------------------------------------
|
|
|
|
func (ctl *client_ctl_ws) ServeWebsocket(ws *websocket.Conn) (int, error) {
|
|
var c *Client
|
|
var wg sync.WaitGroup
|
|
var sbsc *ClientEventSubscription
|
|
var status_code int
|
|
var err error
|
|
var xerr error
|
|
|
|
c = ctl.c
|
|
|
|
// handle authentication using the first message.
|
|
// end this task if authentication fails.
|
|
if !ctl.noauth && c.ctl_auth != nil {
|
|
var req *http.Request
|
|
|
|
req = ws.Request()
|
|
if req.Header.Get("Authorization") == "" {
|
|
var token string
|
|
token = req.FormValue("token")
|
|
if token != "" {
|
|
// websocket doesn't actual have extra headers except a few fixed
|
|
// ones. add "Authorization" header from the query paramerer and
|
|
// compose a fake header to reuse the same Authentication() function
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
|
|
}
|
|
}
|
|
|
|
status_code, _ = c.ctl_auth.Authenticate(req)
|
|
if status_code != http.StatusOK {
|
|
goto done
|
|
}
|
|
}
|
|
|
|
sbsc, err = c.bulletin.Subscribe("")
|
|
if err != nil { goto done }
|
|
|
|
wg.Add(1)
|
|
go func() {
|
|
var c chan *ClientEvent
|
|
var err error
|
|
|
|
defer wg.Done()
|
|
c = sbsc.C
|
|
|
|
for c != nil {
|
|
var e *ClientEvent
|
|
var ok bool
|
|
var msg[] byte
|
|
|
|
e, ok = <- c
|
|
if ok {
|
|
msg, err = json.Marshal(e)
|
|
if err != nil {
|
|
xerr = fmt.Errorf("failed to marshal event - %+v - %s", e, err.Error())
|
|
c = nil
|
|
} else {
|
|
err = websocket.Message.Send(ws, msg)
|
|
if err != nil {
|
|
xerr = fmt.Errorf("failed to send message - %s", err.Error())
|
|
c = nil
|
|
}
|
|
}
|
|
} else {
|
|
// most likely sbcs.C is closed. if not readable, break the loop
|
|
c = nil
|
|
}
|
|
}
|
|
|
|
ws.Close() // hack to break the recv loop. don't care about double closes
|
|
}()
|
|
|
|
ws_recv_loop:
|
|
for {
|
|
var msg []byte
|
|
err = websocket.Message.Receive(ws, &msg)
|
|
if err != nil { break ws_recv_loop }
|
|
|
|
if len(msg) > 0 {
|
|
// do nothing. discard received messages
|
|
}
|
|
}
|
|
|
|
// Ubsubscribe() to break the internal event reception
|
|
// goroutine as well as for cleanup
|
|
c.bulletin.Unsubscribe(sbsc)
|
|
|
|
done:
|
|
ws.Close()
|
|
wg.Wait()
|
|
if err == nil && xerr != nil { err = xerr }
|
|
return http.StatusOK, err
|
|
}
|