Add pairing implementation

api/session.go

@@ -8,6 +8,8 @@ type Session struct {
 	ID          string
 	SessionURL  string
 	AgentMSH    string
+	PairingCode string `json:"PairingCode,omitempty"`
+	PairingURL  string `json:"PairingURL,omitempty"`
 	AgentConfig AgentConfig
 	ExpiresAt   time.Time
 }
@@ -29,3 +31,12 @@ type ListSessionsItem struct {
 	SessionPassword string `json:",omitempty"`
 	ExpiresAt       time.Time
 }
+
+type PairedSession struct {
+	AgentMSH        string
+	SupporterName   string
+	SupporterAvatar string
+	CompanyName     string
+	CompanyLogo     string
+	ExpiresAt       time.Time
+}

cmd/plexus/main.go

@@ -97,7 +97,8 @@ var serve = &cli.Command{
 		}
 
 		opt := &handler.Options{
-			Config:                  cfg.AsControlConfig(),
+			ControlConfig:           cfg.AsControlConfig(),
+			PairingConfig:           cfg.AsPairingConfig(),
 			Auth:                    auth,
 			Log:                     zerologger.Get(),
 			Prefix:                  cfg.PathPrefix,

config/config.go

@@ -11,6 +11,7 @@ import (
 	"github.com/rs/zerolog"
 
 	"github.com/cloudradar-monitoring/plexus/control"
+	"github.com/cloudradar-monitoring/plexus/pcpairing"
 )
 
 var (
@@ -40,6 +41,11 @@ type Config struct {
 
 	AuthUser string `split_words:"true"`
 	AuthPass string `split_words:"true"`
+
+	PairingURL  string `split_words:"true"`
+	PairingTTL  int    `split_words:"true"`
+	CompanyName string `split_words:"true"`
+	CompanyLogo string `split_words:"true"`
 }
 
 func (s *Config) AsControlConfig() *control.Config {
@@ -52,6 +58,15 @@ func (s *Config) AsControlConfig() *control.Config {
 	}
 }
 
+func (s *Config) AsPairingConfig() *pcpairing.Config {
+	return &pcpairing.Config{
+		PairingURL:  s.PairingURL,
+		PairingTTL:  s.PairingTTL,
+		CompanyName: s.CompanyName,
+		CompanyLogo: s.CompanyLogo,
+	}
+}
+
 func (s *Config) MeshCentralControlURL() string {
 	return s.MeshCentralURL + "/" + s.MeshCentralDomain + "/control.ashx"
 }

go.mod

@@ -9,4 +9,5 @@ require (
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/rs/zerolog v1.23.0
 	github.com/urfave/cli/v2 v2.3.0
+	golang.org/x/net v0.0.0-20201021035429-f5854403a974
 )

go.sum

@@ -30,6 +30,7 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974 h1:IX6qOQeG5uLjB/hjjwjedwfjND0hgjPMMyO1RoIXQNI=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

handler/create.go

@@ -23,6 +23,8 @@ import (
 // @Param ttl formData int true "the time to live for the session"
 // @Param username formData string true "the credentials to open the remote control interface & delete the session"
 // @Param password formData string true "the credentials to open the remote control interface & delete the session"
+// @Param supporter_name formData string true "the supporter name"
+// @Param supporter_avatar formData string true "the supporter avatar"
 // @Success 200 {object} api.Session
 // @Failure 400 {object} api.Error
 // @Failure 500 {object} api.Error
@@ -36,6 +38,8 @@ func (h *Handler) CreateSession(rw http.ResponseWriter, r *http.Request) {
 	ttlStr := r.FormValue("ttl")
 	user := r.FormValue("username")
 	pass := r.FormValue("password")
+	supName := r.FormValue("supporter_name")
+	supAvatar := r.FormValue("supporter_avatar")
 	ttl, err := strconv.ParseInt(ttlStr, 10, 64)
 	if err != nil {
 		api.WriteBadRequestJSON(rw, fmt.Sprintf("invalid ttl %s: %s", id, err))
@@ -55,13 +59,13 @@ func (h *Handler) CreateSession(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	mc, err := control.Connect(h.cfg, h.log)
+	mc, err := control.Connect(h.ccfg, h.log)
 	defer mc.Close()
 	if err != nil {
 		api.WriteBadGatewayJSON(rw, fmt.Sprintf("could not connect to mesh control: %s", err))
 		return
 	}
-	mesh, err := mc.CreateMesh(h.cfg.MeshCentralGroupPrefix + "/" + id + "/" + token.New(5))
+	mesh, err := mc.CreateMesh(h.ccfg.MeshCentralGroupPrefix + "/" + id + "/" + token.New(5))
 	if err != nil {
 		api.WriteBadGatewayJSON(rw, fmt.Sprintf("could not create mesh: %s", err))
 		return
@@ -88,6 +92,32 @@ func (h *Handler) CreateSession(rw http.ResponseWriter, r *http.Request) {
 			MeshType:   2,
 		},
 	}
+
+	if h.pcfg.PairingURL != "" {
+		h.log.Infof("pairing...")
+
+		if supName == "" || supAvatar == "" {
+			api.WriteJSONError(rw, http.StatusBadRequest, "You need to provide supporter_name and supporter_avatar for pairing")
+			return
+		}
+		pr, err := h.pcPair(r.Context(), h.pcfg.PairingURL, &Request{
+			Url: h.pcfg.PairingURL,
+		})
+		if err != nil {
+			api.WriteJSONError(rw, http.StatusBadGateway, "Unable to create session, failed to pair")
+			return
+		}
+
+		h.log.Infof("pairing succeeded")
+
+		session.PairingCode = pr.Code
+		session.PairingURL = pr.PairingURL
+		session.SupporterName = supName
+		session.SupporterAvatar = supAvatar
+
+		h.codes[pr.Code] = id
+	}
+
 	h.sessions[id] = session
 
 	go func() {
@@ -107,8 +137,10 @@ func (h *Handler) CreateSession(rw http.ResponseWriter, r *http.Request) {
 	rw.WriteHeader(http.StatusCreated)
 	_ = json.NewEncoder(rw).Encode(&api.Session{
 		ID:          id,
-		AgentMSH:    fmt.Sprintf("https://%s%s", r.Host, path.Join(h.prefix, "config", fmt.Sprintf("%s:%s", id, sessionToken))),
 		SessionURL:  fmt.Sprintf("https://%s%s", r.Host, path.Join(h.prefix, "session", id)),
+		AgentMSH:    fmt.Sprintf("https://%s%s", r.Host, path.Join(h.prefix, "config", fmt.Sprintf("%s:%s", id, sessionToken))),
+		PairingCode: session.PairingCode,
+		PairingURL:  session.PairingURL,
 		AgentConfig: session.AgentConfig,
 		ExpiresAt:   session.ExpiresAt,
 	})

handler/delete.go

@@ -38,7 +38,7 @@ func (h *Handler) deleteInternal(s *Session) error {
 		s.ProxyClose()
 	}
 
-	mc, err := control.Connect(h.cfg, h.log)
+	mc, err := control.Connect(h.ccfg, h.log)
 	if err != nil {
 		return err
 	}

handler/handler.go

@@ -11,12 +11,14 @@ import (
 	"github.com/cloudradar-monitoring/plexus/api"
 	"github.com/cloudradar-monitoring/plexus/control"
 	"github.com/cloudradar-monitoring/plexus/logger"
+	"github.com/cloudradar-monitoring/plexus/pcpairing"
 )
 
 type AuthChecker func(rw http.ResponseWriter, r *http.Request) bool
 
 type Options struct {
-	Config                  *control.Config
+	ControlConfig           *control.Config
+	PairingConfig           *pcpairing.Config
 	Log                     logger.Logger
 	Auth                    AuthChecker
 	Prefix                  string
@@ -31,7 +33,8 @@ func Register(r *mux.Router, opt *Options) {
 	h := &Handler{
 		log:                opt.Log,
 		auth:               opt.Auth,
-		cfg:                opt.Config,
+		ccfg:               opt.ControlConfig,
+		pcfg:               opt.PairingConfig,
 		prefix:             opt.Prefix,
 		sessionCredentials: opt.AllowSessionCredentials,
 		sessions:           make(map[string]*Session),
@@ -45,16 +48,19 @@ func Register(r *mux.Router, opt *Options) {
 	plexus.HandleFunc("/config/{id}:{token}", h.GetAgentMsh).Methods(http.MethodGet)
 	plexus.HandleFunc("/agent/{id}:{token}", h.ProxyAgent).Methods(http.MethodGet)
 	plexus.HandleFunc("/meshrelay.ashx", h.ProxyRelay).Methods(http.MethodGet)
+	plexus.HandleFunc("/pairing/{code}", h.Pair).Methods(http.MethodGet)
 	r.PathPrefix(h.ProxyMeshCentralURL()).Handler(h.ProxyMeshCentral())
 }
 
 type Handler struct {
 	log                logger.Logger
-	cfg                *control.Config
+	ccfg               *control.Config
+	pcfg               *pcpairing.Config
 	auth               AuthChecker
 	lock               sync.RWMutex
 	sessionCredentials bool
 	sessions           map[string]*Session
+	codes              map[string]string
 	prefix             string
 }
 type Session struct {
@@ -64,5 +70,9 @@ type Session struct {
 	Token              string
 	AgentConfig        api.AgentConfig
 	ShareURL           string
+	SupporterName      string
+	SupporterAvatar    string
+	PairingCode        string
+	PairingURL         string
 	ProxyClose         func()
 }

handler/pair.go

@@ -0,0 +1,47 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"path"
+
+	"github.com/gorilla/mux"
+
+	"github.com/cloudradar-monitoring/plexus/api"
+)
+
+// Pair godoc
+// @Summary Gets the pairing code info.
+// @Tags session
+// @Produce application/json
+// @Param code path string true "code"
+// @Security BasicAuth
+// @Success 200 {object} api.URLResponse
+// @Failure 401 {object} api.Error
+// @Failure 404 {object} api.Error
+// @Router /session/{code} [get]
+func (h *Handler) Pair(rw http.ResponseWriter, r *http.Request) {
+	h.lock.Lock()
+	defer h.lock.Unlock()
+	id, ok := h.codes[mux.Vars(r)["id"]]
+	if !ok {
+		api.WriteJSONResponse(rw, http.StatusNotFound, map[string]interface{}{
+			"message": "Code not found",
+		})
+		return
+	}
+
+	session, ok := h.checkSessionAuthentication(rw, r, id)
+	if !ok {
+		return
+	}
+
+	api.WriteJSONResponse(rw, http.StatusNotFound, api.PairedSession{
+		AgentMSH:        fmt.Sprintf("https://%s%s", r.Host, path.Join(h.prefix, "config", fmt.Sprintf("%s:%s", id, session.Token))),
+		SupporterName:   session.SupporterName,
+		SupporterAvatar: session.SupporterAvatar,
+		CompanyName:     h.pcfg.CompanyName,
+		CompanyLogo:     h.pcfg.CompanyLogo,
+		ExpiresAt:       session.ExpiresAt,
+	})
+}

handler/pcpair.go

@@ -0,0 +1,63 @@
+package handler
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"golang.org/x/net/context/ctxhttp"
+)
+
+const (
+	defaultTimeout = 5 * time.Second
+	contentType    = "application/json"
+)
+
+var ErrUnableToPair = errors.New("unable to pair")
+
+type Request struct {
+	Url string `json:"url"`
+}
+
+type Response struct {
+	Success     bool   `json:"success"`
+	Code        string `json:"code"`
+	PairingURL  string `json:"pairing_url"`
+	RedirectURL string `json:"redirect_url"`
+}
+
+func (h *Handler) pcPair(ctx context.Context, url string, req *Request) (*Response, error) {
+	jsonRequest, _ := json.Marshal(req)
+	client := &http.Client{
+		Timeout: defaultTimeout,
+	}
+
+	response, err := ctxhttp.Post(ctx, client, url, contentType, bytes.NewBuffer(jsonRequest))
+	if err != nil {
+		return nil, fmt.Errorf("post failed: %w", err)
+	}
+
+	defer response.Body.Close()
+	jsonResponse, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return nil, fmt.Errorf("reading body failed: %w", err)
+	}
+
+	if response.StatusCode != http.StatusOK {
+		h.log.Errorf("pairing request failed: status(%d) response(%s)", response.StatusCode, string(jsonResponse))
+		return nil, ErrUnableToPair
+	}
+
+	resp := Response{}
+	err = json.Unmarshal(jsonResponse, &resp)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshaling response failed: %w", err)
+	}
+
+	return &resp, nil
+}

handler/proxy.go

@@ -12,7 +12,7 @@ import (
 )
 
 func (h *Handler) ProxyMeshCentralURL() string {
-	return fmt.Sprintf("/%s/", h.cfg.MeshCentralDomain)
+	return fmt.Sprintf("/%s/", h.ccfg.MeshCentralDomain)
 }
 func (h *Handler) ProxyMeshCentral() http.Handler {
 	director := func(req *http.Request) {
@@ -21,7 +21,7 @@ func (h *Handler) ProxyMeshCentral() http.Handler {
 		} else {
 			req.URL.Scheme = "http"
 		}
-		req.URL.Host = h.cfg.MeshCentralURL.Host
+		req.URL.Host = h.ccfg.MeshCentralURL.Host
 		req.Header.Set("User-Agent", "plexus")
 	}
 	return &httputil.ReverseProxy{
@@ -35,7 +35,7 @@ func (h *Handler) ProxyMeshCentral() http.Handler {
 // @Success 200 {object} string
 // @Router /meshrelay.ashx [get]
 func (h *Handler) ProxyRelay(rw http.ResponseWriter, r *http.Request) {
-	proxyURL := fmt.Sprintf("%s?%s", h.cfg.MeshRelayURL(), r.URL.RawQuery)
+	proxyURL := fmt.Sprintf("%s?%s", h.ccfg.MeshRelayURL(), r.URL.RawQuery)
 	_, ok := proxy.Proxy(h.log, rw, r, proxyURL)
 	if ok {
 		h.log.Debugf("MeshRelay Connected: %s", r.URL.String())
@@ -62,7 +62,7 @@ func (h *Handler) ProxyAgent(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	agentClose, ok := proxy.Proxy(h.log, rw, r, h.cfg.MeshCentralAgentURL())
+	agentClose, ok := proxy.Proxy(h.log, rw, r, h.ccfg.MeshCentralAgentURL())
 	if ok {
 		session.ProxyClose = agentClose
 	}

handler/share.go

@@ -78,7 +78,7 @@ func (h *Handler) ShareSessionURL(rw http.ResponseWriter, r *http.Request) {
 }
 
 func (h *Handler) tryGetURL(rw http.ResponseWriter, session *Session) (string, bool) {
-	mc, err := control.Connect(h.cfg, h.log)
+	mc, err := control.Connect(h.ccfg, h.log)
 	if err != nil {
 		api.WriteBadGatewayJSON(rw, fmt.Sprintf("could not connect: %s", err))
 		return "", true

pcpairing/config.go

@@ -0,0 +1,8 @@
+package pcpairing
+
+type Config struct {
+	PairingURL  string
+	PairingTTL  int
+	CompanyName string
+	CompanyLogo string
+}