MYST 532 Tequilapi new Location Endpoint

client/connection/openvpn.go

@@ -1,7 +1,6 @@
 package connection
 
 import (
-	log "github.com/cihub/seelog"
 	"github.com/mysterium/node/identity"
 	"github.com/mysterium/node/location"
 	"github.com/mysterium/node/openvpn"
@@ -21,7 +20,7 @@ func ConfigureVpnClientFactory(
 	openvpnBinary, configDirectory, runtimeDirectory string,
 	signerFactory identity.SignerFactory,
 	statsKeeper bytescount.SessionStatsKeeper,
-	locationDetector location.Detector,
+	locationCache location.Cache,
 ) VpnClientCreator {
 	return func(vpnSession session.SessionDto, consumerID identity.Identity, providerID identity.Identity, stateCallback state.Callback) (openvpn.Client, error) {
 		vpnClientConfig, err := openvpn.NewClientConfigFromString(
@@ -38,19 +37,14 @@ func ConfigureVpnClientFactory(
 
 		statsSaver := bytescount.NewSessionStatsSaver(statsKeeper)
 
-		consumerCountry, err := locationDetector.DetectCountry()
-		if err != nil {
-			log.Warn("Failed to detect country", err)
-		} else {
-			log.Info("Country detected: ", consumerCountry)
-		}
+		originalLocation, _ := locationCache.Get()
 
 		statsSender := bytescount.NewSessionStatsSender(
 			mysteriumAPIClient,
 			vpnSession.ID,
 			providerID,
 			signer,
-			consumerCountry,
+			originalLocation.Country,
 		)
 		asyncStatsSender := func(stats bytescount.SessionStats) error {
 			go statsSender(stats)

cmd/commands/client/command_client.go

@@ -61,14 +61,16 @@ func NewCommandWith(
 		filepath.Join(options.DirectoryConfig, options.LocationDatabase),
 	)
 
+	locationCache := location.NewLocationCache(locationDetector)
+
 	vpnClientFactory := connection.ConfigureVpnClientFactory(
 		mysteriumClient,
 		options.OpenvpnBinary,
 		options.DirectoryConfig,
 		options.DirectoryRuntime,
 		signerFactory,
 		statsKeeper,
-		locationDetector,
+		locationCache,
 	)
 	connectionManager := connection.NewManager(mysteriumClient, dialogFactory, vpnClientFactory, statsKeeper)
 
@@ -82,10 +84,12 @@ func NewCommandWith(
 		checkOpenvpn: func() error {
 			return openvpn.CheckOpenvpnBinary(options.OpenvpnBinary)
 		},
+		locationCache: locationCache,
 	}
 
 	tequilapi_endpoints.AddRoutesForIdentities(router, identityManager, mysteriumClient, signerFactory)
 	tequilapi_endpoints.AddRoutesForConnection(router, connectionManager, ipResolver, statsKeeper)
+	tequilapi_endpoints.AddRoutesForLocation(router, locationDetector, locationCache)
 	tequilapi_endpoints.AddRoutesForProposals(router, mysteriumClient)
 	tequilapi_endpoints.AddRouteForStop(router, node_cmd.NewApplicationStopper(command.Kill))
 
@@ -97,9 +101,10 @@ type Command struct {
 	connectionManager connection.Manager
 	httpAPIServer     tequilapi.APIServer
 	checkOpenvpn      func() error
+	locationCache     location.Cache
 }
 
-// Start starts Tequilapi service - does not block
+// Start starts Tequilapi service, fetches location
 func (cmd *Command) Start() error {
 	log.Info("[Client version]", version.AsString())
 	err := cmd.checkOpenvpn()
@@ -118,6 +123,13 @@ func (cmd *Command) Start() error {
 	}
 	log.Infof("Api started on: %d", port)
 
+	originalLocation, err := cmd.locationCache.RefreshAndGet()
+	if err != nil {
+		log.Warn("Failed to detect country", err)
+	} else {
+		log.Info("Country detected: ", originalLocation.Country)
+	}
+
 	return nil
 }
 

cmd/commands/server/command_server.go

@@ -71,12 +71,12 @@ func (cmd *Command) Start() (err error) {
 		return err
 	}
 
-	serviceCountry, err := cmd.locationDetector.DetectCountry()
+	location, err := cmd.locationDetector.DetectLocation()
 	if err != nil {
 		return err
 	}
-	log.Info("Country detected: ", serviceCountry)
-	serviceLocation := dto_discovery.Location{Country: serviceCountry}
+	log.Info("Country detected: ", location.Country)
+	serviceLocation := dto_discovery.Location{Country: location.Country}
 
 	proposal := discovery.NewServiceProposalWithLocation(providerID, providerContact, serviceLocation, cmd.protocol)
 

location/detector.go

@@ -23,16 +23,17 @@ func NewDetectorWithLocationResolver(ipResolver ip.Resolver, locationResolver Re
 }
 
 // Maps current ip to country
-func (d *detector) DetectCountry() (string, error) {
+func (d *detector) DetectLocation() (Location, error) {
 	ip, err := d.ipResolver.GetPublicIP()
 	if err != nil {
-		return "", err
+		return Location{}, err
 	}
 
 	country, err := d.locationResolver.ResolveCountry(ip)
 	if err != nil {
-		return "", err
+		return Location{}, err
 	}
 
-	return country, nil
+	location := Location{Country: country, IP: ip}
+	return location, nil
 }

location/detector_test.go

@@ -10,26 +10,27 @@ import (
 func TestNewDetector(t *testing.T) {
 	ipResolver := ip.NewFakeResolver("8.8.8.8")
 	detector := NewDetector(ipResolver, "../bin/client_package/config/GeoLite2-Country.mmdb")
-	country, err := detector.DetectCountry()
-	assert.Equal(t, "US", country)
+	location, err := detector.DetectLocation()
+	assert.Equal(t, "US", location.Country)
+	assert.Equal(t, "8.8.8.8", location.IP)
 	assert.NoError(t, err)
 }
 
 func TestWithIpResolverFailing(t *testing.T) {
 	ipErr := errors.New("ip resolver error")
 	ipResolver := ip.NewFailingFakeResolver(ipErr)
 	detector := NewDetectorWithLocationResolver(ipResolver, NewResolverFake(""))
-	country, err := detector.DetectCountry()
+	location, err := detector.DetectLocation()
 	assert.EqualError(t, ipErr, err.Error())
-	assert.Equal(t, "", country)
+	assert.Equal(t, Location{}, location)
 }
 
 func TestWithLocationResolverFailing(t *testing.T) {
 	ipResolver := ip.NewFakeResolver("")
 	locationErr := errors.New("location resolver error")
 	locationResolver := NewFailingResolverFake(locationErr)
 	detector := NewDetectorWithLocationResolver(ipResolver, locationResolver)
-	country, err := detector.DetectCountry()
+	location, err := detector.DetectLocation()
 	assert.EqualError(t, locationErr, err.Error())
-	assert.Equal(t, "", country)
-}
+	assert.Equal(t, Location{}, location)
+}

location/interface.go

@@ -7,5 +7,11 @@ type Resolver interface {
 
 // Detector allows detecting location by current ip
 type Detector interface {
-	DetectCountry() (string, error)
+	DetectLocation() (Location, error)
+}
+
+// Cache allows caching location
+type Cache interface {
+	Get() (Location, error)
+	RefreshAndGet() (Location, error)
 }

location/location.go

@@ -0,0 +1,6 @@
+package location
+
+type Location struct {
+	IP string `json:"ip"`
+	Country string `json:"country"`
+}

location/location_cache.go

@@ -0,0 +1,27 @@
+package location
+
+type locationCache struct {
+	locationDetector Detector
+	location Location
+	err error
+}
+
+// NewLocationCache constructs Cache
+func NewLocationCache(locationDetector Detector) Cache {
+	return &locationCache{
+		locationDetector: locationDetector,
+	}
+}
+
+// Gets location from cache
+func (lc *locationCache) Get() (Location, error) {
+	return lc.location, lc.err
+}
+
+// Stores location to cache
+func (lc *locationCache) RefreshAndGet() (Location, error)  {
+	location, err := lc.locationDetector.DetectLocation()
+	lc.location = location
+	lc.err = err
+	return lc.location, lc.err
+}

location/location_cache_test.go

@@ -0,0 +1,45 @@
+package location
+
+import (
+	"testing"
+	"errors"
+	"github.com/mysterium/node/ip"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLocationCacheFirstCall(t *testing.T) {
+	ipResolver := ip.NewFakeResolver("100.100.100.100")
+	locationResolver := NewResolverFake("country")
+	locationDetector := NewDetectorWithLocationResolver(ipResolver, locationResolver)
+	locationCache := NewLocationCache(locationDetector)
+	location, err := locationCache.Get()
+	assert.Equal(t, Location{}, location)
+	assert.NoError(t, err)
+}
+
+func TestLocationCacheFirstSecondCalls(t *testing.T) {
+	ipResolver := ip.NewFakeResolver("100.100.100.100")
+	locationResolver := NewResolverFake("country")
+	locationDetector := NewDetectorWithLocationResolver(ipResolver, locationResolver)
+	locationCache := NewLocationCache(locationDetector)
+	location, err := locationCache.RefreshAndGet()
+	assert.Equal(t, "country", location.Country)
+	assert.Equal(t, "100.100.100.100", location.IP)
+	assert.NoError(t, err)
+
+	locationSecondCall, err := locationCache.Get()
+	assert.Equal(t, location, locationSecondCall)
+	assert.NoError(t, err)
+}
+
+func TestLocationCacheWithError(t *testing.T) {
+	ipResolver := ip.NewFakeResolver("")
+	locationErr := errors.New("location resolver error")
+	locationResolver := NewFailingResolverFake(locationErr)
+	locationDetector := NewDetectorWithLocationResolver(ipResolver, locationResolver)
+	locationCache := NewLocationCache(locationDetector)
+	locationCache.RefreshAndGet()
+	location, err := locationCache.Get()
+	assert.EqualError(t, locationErr, err.Error())
+	assert.Equal(t, Location{}, location)
+}

tequilapi/endpoints/connection_test.go

@@ -49,9 +49,8 @@ func TestAddRoutesForConnectionAddsRoutes(t *testing.T) {
 	router := httprouter.New()
 	fakeManager := fakeManager{}
 	settableClock := utils.SettableClock{}
-	ipResolver := ip.NewFakeResolver("123.123.123.123")
 	statsKeeper := bytescount.NewSessionStatsKeeper(settableClock.GetTime)
-
+	ipResolver := ip.NewFakeResolver("123.123.123.123")
 	sessionStart := time.Date(2000, time.January, 0, 10, 0, 0, 0, time.UTC)
 	settableClock.SetTime(sessionStart)
 	statsKeeper.MarkSessionStart()

tequilapi/endpoints/location.go

@@ -0,0 +1,52 @@
+package endpoints
+
+import (
+	"github.com/julienschmidt/httprouter"
+	"github.com/mysterium/node/location"
+	"github.com/mysterium/node/tequilapi/utils"
+	"net/http"
+)
+
+// LocationEndpoint struct represents /location resource and it's subresources
+type LocationEndpoint struct {
+	locationDetector location.Detector
+	locationCache location.Cache
+}
+
+// NewLocationEndpoint creates and returns location endpoint
+func NewLocationEndpoint(locationDetector location.Detector, locationCache location.Cache) *LocationEndpoint {
+	return &LocationEndpoint{
+		locationDetector: locationDetector,
+		locationCache: locationCache,
+	}
+}
+
+// GetLocation responds with original and current countries
+func (ce *LocationEndpoint) GetLocation(writer http.ResponseWriter, request *http.Request, params httprouter.Params) {
+	originalLocation, err := ce.locationCache.Get()
+	if err != nil {
+		utils.SendError(writer, err, http.StatusServiceUnavailable)
+		return
+	}
+
+	currentLocation, err := ce.locationDetector.DetectLocation()
+	if err != nil {
+		utils.SendError(writer, err, http.StatusServiceUnavailable)
+		return
+	}
+
+	response := struct {
+		Original location.Location `json:"original"`
+		Current location.Location `json:"current"`
+	}{
+		Original: originalLocation,
+		Current: currentLocation,
+	}
+	utils.WriteAsJSON(response, writer)
+}
+
+// AddRoutesForLocation adds location routes to given router
+func AddRoutesForLocation(router *httprouter.Router, locationDetector location.Detector, locationCache location.Cache) {
+	locationEndpoint := NewLocationEndpoint(locationDetector, locationCache)
+	router.GET("/location", locationEndpoint.GetLocation)
+}