Drop cache_mgr URI support, add squid-internal-mgr support

collector/client.go

@@ -2,12 +2,10 @@ package collector
 
 import (
 	"bufio"
-	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
 	"log"
-	"net"
 	"net/http"
 	"strconv"
 	"strings"
@@ -17,18 +15,10 @@ import (
 
 /*CacheObjectClient holds information about squid manager */
 type CacheObjectClient struct {
-	ch              connectionHandler
-	basicAuthString string
-	headers         []string
-}
-
-type connectionHandler interface {
-	connect() (net.Conn, error)
-}
-
-type connectionHandlerImpl struct {
-	hostname string
-	port     int
+	baseURL  string
+	username string
+	password string
+	headers  []string
 }
 
 /*SquidClient provides functionality to fetch squid metrics */
@@ -38,55 +28,36 @@ type SquidClient interface {
 	GetInfos() (types.Counters, error)
 }
 
-const (
-	requestProtocol = "GET cache_object://localhost/%s HTTP/1.0"
-)
-
-func buildBasicAuthString(login string, password string) string {
-	if len(login) == 0 {
-		return ""
-	} else {
-		return base64.StdEncoding.EncodeToString([]byte(login + ":" + password))
-	}
-}
-
-type CacheObjectRequest struct {
-	Hostname string
-	Port     int
-	Login    string
-	Password string
-	Headers  []string
-}
-
 /*NewCacheObjectClient initializes a new cache client */
-func NewCacheObjectClient(cor *CacheObjectRequest) *CacheObjectClient {
+func NewCacheObjectClient(hostname string, port int, username, password string, headers []string) *CacheObjectClient {
 	return &CacheObjectClient{
-		&connectionHandlerImpl{
-			cor.Hostname,
-			cor.Port,
-		},
-		buildBasicAuthString(cor.Login, cor.Password),
-		cor.Headers,
+		fmt.Sprintf("http://%s:%d/squid-internal-mgr/", hostname, port),
+		username,
+		password,
+		headers,
 	}
 }
 
 func (c *CacheObjectClient) readFromSquid(endpoint string) (*bufio.Reader, error) {
-	conn, err := c.ch.connect()
-
+	req, err := http.NewRequest(http.MethodGet, c.baseURL+endpoint, nil)
 	if err != nil {
 		return nil, err
 	}
-	r, err := get(conn, endpoint, c.basicAuthString, c.headers)
 
+	if c.username != "" && c.password != "" {
+		req.SetBasicAuth(c.username, c.password)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return nil, err
 	}
 
-	if r.StatusCode != 200 {
-		return nil, fmt.Errorf("Non success code %d while fetching metrics", r.StatusCode)
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("non-success code %d while fetching metrics", resp.StatusCode)
 	}
 
-	return bufio.NewReader(r.Body), err
+	return bufio.NewReader(resp.Body), err
 }
 
 func readLines(reader *bufio.Reader, lines chan<- string) {
@@ -206,29 +177,6 @@ func (c *CacheObjectClient) GetInfos() (types.Counters, error) {
 	return infos, err
 }
 
-func (ch *connectionHandlerImpl) connect() (net.Conn, error) {
-	return net.Dial("tcp", fmt.Sprintf("%s:%d", ch.hostname, ch.port))
-}
-
-func get(conn net.Conn, path string, basicAuthString string, headers []string) (*http.Response, error) {
-	rBody := append(headers, []string{
-		fmt.Sprintf(requestProtocol, path),
-		"Host: localhost",
-		"User-Agent: squidclient/3.5.12",
-	}...)
-
-	if len(basicAuthString) > 0 {
-		rBody = append(rBody, "Proxy-Authorization: Basic "+basicAuthString)
-		rBody = append(rBody, "Authorization: Basic "+basicAuthString)
-	}
-	rBody = append(rBody, "Accept: */*", "\r\n")
-	request := strings.Join(rBody, "\r\n")
-
-	fmt.Fprint(conn, request)
-
-	return http.ReadResponse(bufio.NewReader(conn), nil)
-}
-
 func decodeCounterStrings(line string) (types.Counter, error) {
 	if equal := strings.Index(line, "="); equal >= 0 {
 		if key := strings.TrimSpace(line[:equal]); len(key) > 0 {

collector/client_test.go

@@ -1,57 +1,31 @@
 package collector
 
 import (
-	"net"
+	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	"github.com/boynux/squid-exporter/types"
 	"github.com/stretchr/testify/assert"
 )
 
-type mockConnectionHandler struct {
-	server net.Conn
-
-	buffer []byte
-}
-
-func (c *mockConnectionHandler) connect() (net.Conn, error) {
-	var client net.Conn
-	c.server, client = net.Pipe()
-
-	return client, nil
-}
-
-func TestBuildBasicAuth(t *testing.T) {
-	u := "test_username"
-	p := "test_password"
-	expectedAuthString := "dGVzdF91c2VybmFtZTp0ZXN0X3Bhc3N3b3Jk"
-
-	ba := buildBasicAuthString(u, p)
-
-	assert.Equal(t, expectedAuthString, ba, "Basic Auth format doesn't match")
-}
-
 func TestReadFromSquid(t *testing.T) {
-	ch := &mockConnectionHandler{}
-
-	go func() {
-		b := make([]byte, 256)
-		n, _ := ch.server.Read(b)
-		ch.buffer = append(ch.buffer, b[:n]...)
-
-		ch.server.Write(b[n:])
-		ch.server.Close()
-	}()
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		assert.Equal(t, r.RequestURI, "/squid-internal-mgr/test")
+	}))
+	defer ts.Close()
 
 	coc := &CacheObjectClient{
-		ch,
+		ts.URL + "/squid-internal-mgr/",
+		"",
 		"",
 		[]string{},
 	}
-	expected := "GET cache_object://localhost/test HTTP/1.0\r\nHost: localhost\r\nUser-Agent: squidclient/3.5.12\r\nAccept: */*\r\n\r\n"
-	coc.readFromSquid("test")
 
-	assert.Equal(t, expected, string(ch.buffer))
+	_, err := coc.readFromSquid("test")
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestDecodeMetricStrings(t *testing.T) {

collector/metrics.go

@@ -52,13 +52,7 @@ func New(c *CollectorConfig) *Exporter {
 	infos = generateSquidInfos(c.Labels.Keys)
 
 	return &Exporter{
-		NewCacheObjectClient(&CacheObjectRequest{
-			c.Hostname,
-			c.Port,
-			c.Login,
-			c.Password,
-			c.Headers,
-		}),
+		NewCacheObjectClient(c.Hostname, c.Port, c.Login, c.Password, c.Headers),
 
 		c.Hostname,
 		c.Port,