Merge pull request #112 from MysteriumNetwork/refactor/fix-linter-war…

…nings

Fix some of linter warnings

bytescount_client/stats_sender.go

@@ -9,11 +9,11 @@ import (
 
 type SessionStatsSender func(bytesSent, bytesReceived int) error
 
-func NewSessionStatsSender(mysteriumClient server.Client, sessionId session.SessionId, signer identity.Signer) SessionStatsSender {
-	sessionIdString := string(sessionId)
+func NewSessionStatsSender(mysteriumClient server.Client, sessionID session.SessionID, signer identity.Signer) SessionStatsSender {
+	sessionIDString := string(sessionID)
 	return func(bytesSent, bytesReceived int) error {
 		return mysteriumClient.SendSessionStats(
-			sessionIdString,
+			sessionIDString,
 			dto.SessionStats{
 				BytesSent:     bytesSent,
 				BytesReceived: bytesReceived,

client_connection/interface.go

@@ -16,7 +16,7 @@ const (
 
 type ConnectionStatus struct {
 	State     State
-	SessionId session.SessionId
+	SessionID session.SessionID
 	LastError error
 }
 

client_connection/manager.go

@@ -60,7 +60,7 @@ func (manager *connectionManager) Connect(id identity.Identity, nodeKey string)
 		return err
 	}
 
-	vpnSession, err := session.RequestSessionCreate(manager.dialog, proposal.Id)
+	vpnSession, err := session.RequestSessionCreate(manager.dialog, proposal.ID)
 	if err != nil {
 		manager.status = statusError(err)
 		return err
@@ -72,7 +72,7 @@ func (manager *connectionManager) Connect(id identity.Identity, nodeKey string)
 		return err
 	}
 
-	manager.status = statusConnected(vpnSession.Id)
+	manager.status = statusConnected(vpnSession.ID)
 	return nil
 }
 
@@ -110,8 +110,8 @@ func statusConnecting() ConnectionStatus {
 	return ConnectionStatus{Connecting, "", nil}
 }
 
-func statusConnected(sessionId session.SessionId) ConnectionStatus {
-	return ConnectionStatus{Connected, sessionId, nil}
+func statusConnected(sessionID session.SessionID) ConnectionStatus {
+	return ConnectionStatus{Connected, sessionID, nil}
 }
 
 func statusNotConnected() ConnectionStatus {
@@ -122,7 +122,7 @@ func statusDisconnecting() ConnectionStatus {
 	return ConnectionStatus{Disconnecting, "", nil}
 }
 
-func ConfigureVpnClientFactory(mysteriumApiClient server.Client, vpnClientRuntimeDirectory string, signerFactory identity.SignerFactory) VpnClientFactory {
+func ConfigureVpnClientFactory(mysteriumAPIClient server.Client, vpnClientRuntimeDirectory string, signerFactory identity.SignerFactory) VpnClientFactory {
 	return func(vpnSession session.SessionDto, id identity.Identity) (openvpn.Client, error) {
 		vpnConfig, err := openvpn.NewClientConfigFromString(
 			vpnSession.Config,
@@ -132,7 +132,7 @@ func ConfigureVpnClientFactory(mysteriumApiClient server.Client, vpnClientRuntim
 			return nil, err
 		}
 
-		statsSender := bytescount_client.NewSessionStatsSender(mysteriumApiClient, vpnSession.Id, signerFactory(id))
+		statsSender := bytescount_client.NewSessionStatsSender(mysteriumAPIClient, vpnSession.ID, signerFactory(id))
 		vpnMiddlewares := []openvpn.ManagementMiddleware{
 			bytescount_client.NewMiddleware(statsSender, 1*time.Minute),
 		}

client_connection/manager_test.go

@@ -15,25 +15,25 @@ import (
 	"testing"
 )
 
-type test_context struct {
+type testContext struct {
 	suite.Suite
 	connManager         *connectionManager
 	fakeDiscoveryClient *server.ClientFake
-	fakeOpenVpn         *fake_openvpn_client
+	fakeOpenVpn         *fakeOpenvpnClient
 }
 
-func (tc *test_context) SetupTest() {
+func (tc *testContext) SetupTest() {
 
 	tc.fakeDiscoveryClient = server.NewClientFake()
 
 	serviceProposal := service_discovery.NewServiceProposal(identity.FromAddress("vpn-node-1"), dto.Contact{})
 	tc.fakeDiscoveryClient.RegisterProposal(serviceProposal, nil)
 
 	dialogEstablisherFactory := func(identity identity.Identity) communication.DialogEstablisher {
-		return &fake_dialog{}
+		return &fakeDialog{}
 	}
 
-	tc.fakeOpenVpn = &fake_openvpn_client{
+	tc.fakeOpenVpn = &fakeOpenvpnClient{
 		false,
 		make(chan int, 1),
 		make(chan int, 1),
@@ -46,33 +46,33 @@ func (tc *test_context) SetupTest() {
 	tc.connManager = NewManager(tc.fakeDiscoveryClient, dialogEstablisherFactory, fakeVpnClientFactory)
 }
 
-func (tc *test_context) TestWhenNoConnectionIsMadeStatusIsNotConnected() {
+func (tc *testContext) TestWhenNoConnectionIsMadeStatusIsNotConnected() {
 	assert.Equal(tc.T(), ConnectionStatus{NotConnected, "", nil}, tc.connManager.Status())
 }
 
-func (tc *test_context) TestWithUnknownNodeKey() {
+func (tc *testContext) TestWithUnknownNodeKey() {
 	noProposalsError := errors.New("node has no service proposals")
 
 	assert.Error(tc.T(), tc.connManager.Connect(identity.FromAddress("identity-1"), "unknown-node"))
 	assert.Equal(tc.T(), ConnectionStatus{NotConnected, "", noProposalsError}, tc.connManager.Status())
 }
 
-func (tc *test_context) TestOnConnectErrorStatusIsNotConnectedAndLastErrorIsSet() {
+func (tc *testContext) TestOnConnectErrorStatusIsNotConnectedAndLastErrorIsSet() {
 	fatalVpnError := errors.New("fatal connection error")
 	tc.fakeOpenVpn.onConnectReturnError = fatalVpnError
 
 	assert.Error(tc.T(), tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1"))
 	assert.Equal(tc.T(), ConnectionStatus{NotConnected, "", fatalVpnError}, tc.connManager.Status())
 }
 
-func (tc *test_context) TestWhenManagerMadeConnectionStatusReturnsConnectedStateAndSessionId() {
+func (tc *testContext) TestWhenManagerMadeConnectionStatusReturnsConnectedStateAndSessionId() {
 	err := tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1")
 
 	assert.NoError(tc.T(), err)
 	assert.Equal(tc.T(), ConnectionStatus{Connected, "vpn-session-id", nil}, tc.connManager.Status())
 }
 
-func (tc *test_context) TestStatusReportsConnectingWhenConnectionIsInProgress() {
+func (tc *testContext) TestStatusReportsConnectingWhenConnectionIsInProgress() {
 	tc.fakeOpenVpn.delayableAction()
 	go func() {
 		tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1")
@@ -81,7 +81,7 @@ func (tc *test_context) TestStatusReportsConnectingWhenConnectionIsInProgress()
 	assert.Equal(tc.T(), ConnectionStatus{Connecting, "", nil}, tc.connManager.Status())
 }
 
-func (tc *test_context) TestStatusReportsDisconnectingThenNotConnected() {
+func (tc *testContext) TestStatusReportsDisconnectingThenNotConnected() {
 	err := tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1")
 
 	assert.NoError(tc.T(), err)
@@ -103,76 +103,76 @@ func (tc *test_context) TestStatusReportsDisconnectingThenNotConnected() {
 }
 
 func TestConnectionManagerSuite(t *testing.T) {
-	suite.Run(t, new(test_context))
+	suite.Run(t, new(testContext))
 }
 
-type fake_openvpn_client struct {
+type fakeOpenvpnClient struct {
 	delayAction               bool
 	delayStateEnteredNotifier chan int
 	resumeFromDelay           chan int
 	onConnectReturnError      error
 }
 
-func (foc *fake_openvpn_client) Start() error {
+func (foc *fakeOpenvpnClient) Start() error {
 	if foc.delayAction {
 		foc.delayStateEnteredNotifier <- 1
 		<-foc.resumeFromDelay
 	}
 	return foc.onConnectReturnError
 }
 
-func (foc *fake_openvpn_client) Wait() error {
+func (foc *fakeOpenvpnClient) Wait() error {
 	return nil
 }
 
-func (foc *fake_openvpn_client) Stop() error {
+func (foc *fakeOpenvpnClient) Stop() error {
 	if foc.delayAction {
 		foc.delayStateEnteredNotifier <- 1
 		<-foc.resumeFromDelay
 	}
 	return nil
 }
 
-func (foc *fake_openvpn_client) delayableAction() {
+func (foc *fakeOpenvpnClient) delayableAction() {
 	foc.delayAction = true
 }
 
-func (foc *fake_openvpn_client) waitForDelayState() {
+func (foc *fakeOpenvpnClient) waitForDelayState() {
 	<-foc.delayStateEnteredNotifier
 }
 
-func (foc *fake_openvpn_client) resumeAction() {
+func (foc *fakeOpenvpnClient) resumeAction() {
 	foc.resumeFromDelay <- 1
 }
 
-type fake_dialog struct {
+type fakeDialog struct {
 }
 
-func (fd *fake_dialog) CreateDialog(contact dto.Contact) (communication.Dialog, error) {
+func (fd *fakeDialog) CreateDialog(contact dto.Contact) (communication.Dialog, error) {
 	return fd, nil
 }
 
-func (fd *fake_dialog) Close() error {
+func (fd *fakeDialog) Close() error {
 	return nil
 }
 
-func (fd *fake_dialog) Receive(consumer communication.MessageConsumer) error {
+func (fd *fakeDialog) Receive(consumer communication.MessageConsumer) error {
 	return nil
 }
-func (fd *fake_dialog) Respond(consumer communication.RequestConsumer) error {
+func (fd *fakeDialog) Respond(consumer communication.RequestConsumer) error {
 	return nil
 }
 
-func (fd *fake_dialog) Send(producer communication.MessageProducer) error {
+func (fd *fakeDialog) Send(producer communication.MessageProducer) error {
 	return nil
 }
 
-func (fd *fake_dialog) Request(producer communication.RequestProducer) (responsePtr interface{}, err error) {
+func (fd *fakeDialog) Request(producer communication.RequestProducer) (responsePtr interface{}, err error) {
 	return &session.SessionCreateResponse{
 			Success: true,
 			Message: "Everything is great!",
 			Session: session.SessionDto{
-				Id:     "vpn-session-id",
+				ID:     "vpn-session-id",
 				Config: "vpn-session-config",
 			},
 		},

client_promise/dto/promise_body.go

@@ -6,7 +6,7 @@ import (
 
 type PromiseBody struct {
 	SerialNumber int
-	IssuerId     string
-	BenefiterId  string
+	IssuerID     string
+	BenefiterID  string
 	Amount       money.Money
 }

client_promise/promise_test.go

@@ -7,27 +7,27 @@ import (
 	"testing"
 )
 
-const CURRENCY_TOKEN = money.Currency("Token")
+const CurrencyToken = money.Currency("Token")
 
 func Test_PromiseBody(t *testing.T) {
 
 	amount := money.Money{
 		Amount:   uint64(5),
-		Currency: CURRENCY_TOKEN,
+		Currency: CurrencyToken,
 	}
 
 	promise := dto.PromiseBody{
 		SerialNumber: 1,
-		IssuerId:     "issuer1",
-		BenefiterId:  "benefiter1",
+		IssuerID:     "issuer1",
+		BenefiterID:  "benefiter1",
 		Amount:       amount,
 	}
 
 	assert.Equal(t, promise.SerialNumber, 1)
-	assert.Equal(t, promise.IssuerId, "issuer1")
-	assert.Equal(t, promise.BenefiterId, "benefiter1")
+	assert.Equal(t, promise.IssuerID, "issuer1")
+	assert.Equal(t, promise.BenefiterID, "benefiter1")
 	assert.Equal(t, promise.Amount.Amount, uint64(5))
-	assert.Equal(t, promise.Amount.Currency, CURRENCY_TOKEN)
+	assert.Equal(t, promise.Amount.Currency, CurrencyToken)
 }
 
 func Test_SignedPromise(t *testing.T) {

cmd/mysterium_client/run/command.go

@@ -46,23 +46,23 @@ func NewCommandWith(
 
 	connectionManager := client_connection.NewManager(mysteriumClient, dialogEstablisherFactory, vpnClientFactory)
 
-	router := tequilapi.NewApiRouter()
+	router := tequilapi.NewAPIRouter()
 	tequilapi_endpoints.AddRoutesForIdentities(router, identityManager, mysteriumClient, signerFactory)
 	tequilapi_endpoints.AddRoutesForConnection(router, connectionManager)
 	tequilapi_endpoints.AddRoutesForProposals(router, mysteriumClient)
 
-	httpApiServer := tequilapi.NewServer(options.TequilapiAddress, options.TequilapiPort, router)
+	httpAPIServer := tequilapi.NewServer(options.TequilapiAddress, options.TequilapiPort, router)
 
 	return &CommandRun{
 		connectionManager,
-		httpApiServer,
+		httpAPIServer,
 	}
 }
 
 //CommandRun represent entry point for MysteriumVpn client with top level components
 type CommandRun struct {
 	connectionManager client_connection.Manager
-	httpApiServer     tequilapi.ApiServer
+	httpApiServer     tequilapi.APIServer
 }
 
 //Run starts Tequilapi service - does not block

cmd/mysterium_fake/mysterium_fake.go

@@ -11,7 +11,7 @@ import (
 	"sync"
 )
 
-const NodeIp = "127.0.0.1"
+const NodeIP = "127.0.0.1"
 const NodeDirectoryConfig = "bin/tls"
 const ClientDirectoryRuntime = "build/fake"
 
@@ -25,7 +25,7 @@ func main() {
 			DirectoryRuntime: ClientDirectoryRuntime,
 		},
 		mysteriumClient,
-		ipify.NewClientFake(NodeIp),
+		ipify.NewClientFake(NodeIP),
 		nat.NewServiceFake(),
 	)
 	runServer(serverCommand, waiter)

cmd/mysterium_monitor/command_run/command.go

@@ -57,15 +57,15 @@ func (cmd *CommandRun) Run(options CommandOptions) error {
 
 		cmd.ipCheckWaiter.Wait()
 		cmd.clientCommand.Kill()
-		cmd.checkClientIpWhenDisconnected()
+		cmd.checkClientIPWhenDisconnected()
 	})
 
 	return nil
 }
 
-// This is ment to be registered as VpnClient middleware:
-//   state_client.NewMiddleware(cmd.checkClientIpWhenConnected)
-func (cmd *CommandRun) checkClientIpWhenConnected(state state_client.State) error {
+// This is meant to be registered as VpnClient middleware:
+//   state_client.NewMiddleware(cmd.checkClientIPWhenConnected)
+func (cmd *CommandRun) checkClientIPWhenConnected(state state_client.State) error {
 	if state == state_client.STATE_CONNECTED {
 		ipForwarded, err := cmd.IpifyClient.GetOutboundIP()
 		if err != nil {
@@ -93,7 +93,7 @@ func (cmd *CommandRun) checkClientHandleTimeout() {
 	cmd.ipCheckWaiter.Done()
 }
 
-func (cmd *CommandRun) checkClientIpWhenDisconnected() {
+func (cmd *CommandRun) checkClientIPWhenDisconnected() {
 	ipForwarded, err := cmd.IpifyClient.GetOutboundIP()
 	if err != nil {
 		cmd.resultWriter.NodeError("Disconnect IP not detected", err)