Merge pull request #5 from qurami/feat-proxy-support

HTTP Proxy support

Author: giefferre

README.md

@@ -0,0 +1,34 @@
+# gojsonrpc
+
+This package provides a client to JSON RPC services.
+
+## Usage example
+
+```go
+package main
+
+import (
+	"log"
+	"github.com/qurami/gojsonrpc"
+)
+
+func main() {
+	client := gojsonrpc.NewClient("http://mock.rpcservice.url")
+	
+	// you can optionally set a HTTP proxy for the connection
+	proxyURL, _ := "http://proxy.url:3128"
+	client.SetHTTPProxy(proxyURL)
+	
+	// you can also optionally set the connection timeout
+	client.SetTimeout(120)
+
+	args := map[string]interface{}{}
+	names := make([]string, 0)
+
+	err := client.Run("GetNames", args, &names)
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Println(names)
+}
+```

client.go

@@ -6,70 +6,56 @@ import (
 	"errors"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 )
 
+// Client executes JSON RPC calls to remote servers.
 type Client struct {
-	Url     string
-	Timeout int
+	serverURL  string
+	httpClient *http.Client
 }
 
+// NewClient returns a newly istantiated Client pointing to the given url.
 func NewClient(url string) *Client {
-	client := new(Client)
-
-	client.Url = url
-	client.Timeout = DEFAULT_TIMEOUT
-
-	return client
-}
-
-func (this *Client) sendJsonRequest(jsonRequest []byte) ([]byte, error) {
-	var jsonResponse []byte
-
 	httpClient := &http.Client{
-		Timeout: time.Duration(time.Duration(this.Timeout) * time.Second),
+		Timeout: time.Duration(time.Duration(defaultTimeout) * time.Second),
 		Transport: &http.Transport{
 			TLSClientConfig: &tls.Config{
 				InsecureSkipVerify: true,
 			},
+			Proxy: http.ProxyFromEnvironment,
 		},
 	}
 
-	httpRequest, err := http.NewRequest("POST", this.Url, strings.NewReader(string(jsonRequest)))
-	httpRequest.Header.Set("Content-Type", "application/json")
-	httpRequest.Header.Set("Content-Length", "")
-	httpRequest.Header.Set("Accept", "application/json")
-	httpRequest.Header.Set("Connection", "close")
-
-	httpResponse, err := httpClient.Do(httpRequest)
-	if err != nil {
-		return jsonResponse, err
-	}
-
-	defer httpResponse.Body.Close()
-
-	jsonResponse, err = ioutil.ReadAll(httpResponse.Body)
-	if err != nil {
-		return jsonResponse, err
+	return &Client{
+		serverURL:  url,
+		httpClient: httpClient,
 	}
+}
 
-	return jsonResponse, nil
+// SetTimeout sets the client timeout to the given value.
+func (c *Client) SetTimeout(timeout int) {
+	c.httpClient.Timeout = time.Duration(timeout) * time.Second
 }
 
-func (this *Client) SetTimeout(timeout int) {
-	this.Timeout = timeout
+// SetHTTPProxyURL tells the client to use the given proxyURL as proxy address.
+func (c *Client) SetHTTPProxyURL(proxyURL *url.URL) {
+	c.httpClient.Transport.(*http.Transport).Proxy = http.ProxyURL(proxyURL)
 }
 
-func (this *Client) Run(method string, params interface{}, result interface{}) error {
+// Run executes the given method having the given params setting the response
+// value in the given result interface.
+func (c *Client) Run(method string, params interface{}, result interface{}) error {
 	request := NewRequest(method, params, RandInt(10000000, 99999999))
 
 	jsonRequest, err := json.Marshal(request)
 	if err != nil {
 		return err
 	}
 
-	jsonResponse, err := this.sendJsonRequest(jsonRequest)
+	jsonResponse, err := c.sendJSONRequest(jsonRequest)
 	if err != nil {
 		return err
 	}
@@ -89,18 +75,44 @@ func (this *Client) Run(method string, params interface{}, result interface{}) e
 	return nil
 }
 
-func (this *Client) Notify(method string, params interface{}) error {
+// Notify executes the given method with the given parameters.
+// Doesn't expect any result.
+func (c *Client) Notify(method string, params interface{}) error {
 	request := NewRequest(method, params, 0)
 
-	requestJson, err := json.Marshal(request)
+	jsonRequest, err := json.Marshal(request)
 	if err != nil {
 		return err
 	}
 
-	_, err = this.sendJsonRequest(requestJson)
+	_, err = c.sendJSONRequest(jsonRequest)
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
+
+func (c *Client) sendJSONRequest(jsonRequest []byte) ([]byte, error) {
+	var jsonResponse []byte
+
+	httpRequest, err := http.NewRequest("POST", c.serverURL, strings.NewReader(string(jsonRequest)))
+	httpRequest.Header.Set("Content-Type", "application/json")
+	httpRequest.Header.Set("Content-Length", "")
+	httpRequest.Header.Set("Accept", "application/json")
+	httpRequest.Header.Set("Connection", "close")
+
+	httpResponse, err := c.httpClient.Do(httpRequest)
+	if err != nil {
+		return jsonResponse, err
+	}
+
+	defer httpResponse.Body.Close()
+
+	jsonResponse, err = ioutil.ReadAll(httpResponse.Body)
+	if err != nil {
+		return jsonResponse, err
+	}
+
+	return jsonResponse, nil
+}

client_test.go

@@ -0,0 +1,30 @@
+package gojsonrpc
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+)
+
+func TestThatSetHTTPProxyURLSetsAnHTTPProxyInClient(t *testing.T) {
+	proxyCalled := false
+
+	mockProxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		proxyCalled = true
+	}))
+
+	mockRPCServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	}))
+
+	sut := NewClient(mockRPCServer.URL)
+
+	mockHTTPProxyURL, _ := url.Parse(mockProxy.URL)
+
+	sut.SetHTTPProxyURL(mockHTTPProxyURL)
+	_ = sut.Notify("SometMethod", nil)
+
+	if !proxyCalled {
+		t.Fatal("expected proxy was not called")
+	}
+}

constants.go

@@ -1,5 +1,5 @@
 package gojsonrpc
 
 const (
-	DEFAULT_TIMEOUT = 300
+	defaultTimeout = 300
 )

pool.go

@@ -5,14 +5,16 @@ import (
 	"strings"
 )
 
+// Pool executes JSON RPC calls to remote servers using a pool of Clients.
 type Pool struct {
 	clients chan (*Client)
 }
 
+// NewPool returns a newly initialized Pool of clients pointing to the given url.
 func NewPool(url string, n int, additionalParameters ...interface{}) *Pool {
 	pool := new(Pool)
 	pool.clients = make(chan (*Client), n)
-	timeout := DEFAULT_TIMEOUT
+	timeout := defaultTimeout
 
 	if len(additionalParameters) == 1 {
 		timeoutIntVal, ok := additionalParameters[0].(int)
@@ -30,17 +32,19 @@ func NewPool(url string, n int, additionalParameters ...interface{}) *Pool {
 	return pool
 }
 
-func (this *Pool) getClient() *Client {
-	return <-this.clients
+func (p *Pool) getClient() *Client {
+	return <-p.clients
 }
 
-func (this *Pool) releaseClient(c *Client) {
-	this.clients <- c
+func (p *Pool) releaseClient(c *Client) {
+	p.clients <- c
 }
 
-func (this *Pool) Do(command, methodName string, params interface{}, result interface{}) error {
-	c := this.getClient()
-	defer this.releaseClient(c)
+// Do executes the given command (Run or Notify) using the given methodName and params
+// and building the response in the given result interface.
+func (p *Pool) Do(command, methodName string, params interface{}, result interface{}) error {
+	c := p.getClient()
+	defer p.releaseClient(c)
 
 	switch strings.ToLower(command) {
 	case "run":