fix TicketAuthProvider

Author: sp-yduck

rest/access.go

@@ -1,11 +1,7 @@
 package rest
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
 
 	"github.com/sp-yduck/proxmox-go/api"
 )
@@ -17,37 +13,3 @@ func (c *RESTClient) PostTicket(ctx context.Context, req TicketRequest) (*api.Se
 	}
 	return session, nil
 }
-
-func retrieveSessionTokens(baseUrl string, req TicketRequest) (*api.Session, error) {
-	endpoint := baseUrl + "/access/ticket"
-	jsonReq, err := json.Marshal(req)
-	if err != nil {
-		return nil, err
-	}
-	body := bytes.NewReader(jsonReq)
-	httpReq, err := http.NewRequestWithContext(context.Background(), http.MethodPost, endpoint, body)
-	if err != nil {
-		return nil, err
-	}
-	httpReq.Header.Add("Content-Type", "application/json")
-	httpRsp, err := http.DefaultClient.Do(httpReq)
-	if err != nil {
-		return nil, err
-	}
-	defer httpRsp.Body.Close()
-
-	buf, err := checkResponse(httpRsp)
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve session token: %v", err)
-	}
-	var datakey map[string]json.RawMessage
-	if err := json.Unmarshal(buf, &datakey); err != nil {
-		return nil, err
-	}
-	var session *api.Session
-	data := datakey["data"]
-	if err := json.Unmarshal(data, &session); err != nil {
-		return nil, err
-	}
-	return session, nil
-}

rest/authentication.go

@@ -1,6 +1,10 @@
 package rest
 
 import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"sync"
@@ -104,16 +108,20 @@ func (t *TokenProvider) addAuthHeader(header *http.Header) error {
 
 // AuthProvider implementation
 type TicketProvider struct {
-	baseUrl string
-	session *api.Session
-	expiry  time.Time
-	mu      sync.Mutex
+	baseUrl  string
+	username string
+	password string
+	session  *api.Session
+	expiry   time.Time
+	mu       sync.Mutex
 }
 
 func NewTicketProvider(baseUrl, username, password string) (*TicketProvider, error) {
 	t := &TicketProvider{
-		baseUrl: baseUrl,
-		mu:      sync.Mutex{},
+		baseUrl:  baseUrl,
+		username: username,
+		password: password,
+		mu:       sync.Mutex{},
 	}
 	req := TicketRequest{Username: username, Password: password}
 	if err := t.startNewSession(req); err != nil {
@@ -136,7 +144,7 @@ func (t *TicketProvider) Session() (*api.Session, error) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if t.ExpiryDelta() < 5*time.Minute {
-		req := TicketRequest{Username: "dummy", Password: "dummy"}
+		req := TicketRequest{Username: t.username, Password: t.password}
 		if err := t.startNewSession(req); err != nil {
 			return nil, err
 		}
@@ -145,7 +153,7 @@ func (t *TicketProvider) Session() (*api.Session, error) {
 }
 
 func (t *TicketProvider) startNewSession(req TicketRequest) error {
-	session, err := retrieveSessionTokens(t.baseUrl, req)
+	session, err := t.retrieveSessionTokens(req)
 	if err != nil {
 		return err
 	}
@@ -157,6 +165,47 @@ func (t *TicketProvider) startNewSession(req TicketRequest) error {
 	return nil
 }
 
+func (t *TicketProvider) retrieveSessionTokens(req TicketRequest) (*api.Session, error) {
+	endpoint := t.baseUrl + "/access/ticket"
+	jsonReq, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+	body := bytes.NewReader(jsonReq)
+	httpReq, err := http.NewRequestWithContext(context.Background(), http.MethodPost, endpoint, body)
+	if err != nil {
+		return nil, err
+	}
+	httpReq.Header.Add("Content-Type", "application/json")
+	// to do : client should be inherited from RESTClient or so
+	client := &http.Client{Transport: &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true,
+		},
+	},
+	}
+	httpRsp, err := client.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	defer httpRsp.Body.Close()
+
+	buf, err := checkResponse(httpRsp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve session token: %v", err)
+	}
+	var datakey map[string]json.RawMessage
+	if err := json.Unmarshal(buf, &datakey); err != nil {
+		return nil, err
+	}
+	var session *api.Session
+	data := datakey["data"]
+	if err := json.Unmarshal(data, &session); err != nil {
+		return nil, err
+	}
+	return session, nil
+}
+
 func (t *TicketProvider) addAuthHeader(header *http.Header) error {
 	session, err := t.Session()
 	if err != nil {

rest/client.go

@@ -25,7 +25,7 @@ type RESTClient struct {
 
 	httpClient *http.Client
 
-	transport Transport
+	transport *Transport
 
 	rateLimiter *rate.Limiter
 
@@ -49,15 +49,15 @@ func NewRESTClient(baseUrl string, opts ...ClientOption) (*RESTClient, error) {
 	client := &RESTClient{
 		endpoint:    complementURL(baseUrl),
 		httpClient:  &http.Client{},
+		transport:   &Transport{},
 		rateLimiter: rate.NewLimiter(rate.Every(1*time.Second), defaultQPS),
 	}
-
 	for _, option := range opts {
 		if err := option(client); err != nil {
 			return nil, err
 		}
 	}
-
+	client.httpClient = &http.Client{Transport: client.transport}
 	return client, nil
 }
 

rest/cluster_test.go

@@ -1,6 +1,8 @@
 package rest
 
-import "context"
+import (
+	"context"
+)
 
 func (s *TestSuite) TestGetNextID() {
 	nextid, err := s.restclient.GetNextID(context.TODO())