MYST-102 client connection manager

client_connection/interface.go

@@ -0,0 +1,31 @@
+package client_connection
+
+import (
+	"errors"
+	"github.com/mysterium/node/identity"
+)
+
+type State string
+
+const (
+	NOT_CONNECTED = State("NOT_CONNECTED")
+	NEGOTIATING   = State("NEGOTIATING")
+	CONNECTED     = State("CONNECTED")
+)
+
+var (
+	ALREADY_CONNECTED = errors.New("already connected")
+)
+
+type ConnectionStatus struct {
+	State     State
+	SessionId string
+	LastError error
+}
+
+type Manager interface {
+	Connect(identity identity.Identity, NodeKey string) error
+	Status() ConnectionStatus
+	Disconnect() error
+	Wait() error
+}

client_connection/manager.go

@@ -1,55 +1,99 @@
 package client_connection
 
 import (
-	"errors"
-    "github.com/mysterium/node/identity"
+	"github.com/mysterium/node/communication"
+	"github.com/mysterium/node/identity"
+	"github.com/mysterium/node/openvpn"
+	vpn_session "github.com/mysterium/node/openvpn/session"
+	"github.com/mysterium/node/server"
+	"github.com/mysterium/node/server/dto"
 )
 
-type State string
+type DialogEstablisherFactory func(identity identity.Identity) communication.DialogEstablisher
 
-const (
-	NOT_CONNECTED = State("NOT_CONNECTED")
-	NEGOTIATING   = State("NEGOTIATING")
-	CONNECTED     = State("CONNECTED")
-)
-
-var (
-	ALREADY_CONNECTED = errors.New("already connected")
-)
+type VpnClientFactory func(vpnSession *vpn_session.VpnSession, session *dto.Session) (openvpn.Client, error)
 
-type ConnectionStatus struct {
-	State     State
-	SessionId string
+type connectionManager struct {
+	//these are passed on creation
+	mysteriumClient          server.Client
+	dialogEstablisherFactory DialogEstablisherFactory
+	vpnClientFactory         VpnClientFactory
+	//these are populated by Connect at runtime
+	dialog    communication.Dialog
+	vpnClient openvpn.Client
+	status    ConnectionStatus
 }
 
-type Manager interface {
-	Connect(identity identity.Identity, NodeKey string) error
-	Status() ConnectionStatus
-	Disconnect() error
-	Wait() error
+func NewManager(mysteriumClient server.Client, dialogEstablisherFactory DialogEstablisherFactory, vpnClientFactory VpnClientFactory) *connectionManager {
+	return &connectionManager{
+		mysteriumClient,
+		dialogEstablisherFactory,
+		vpnClientFactory,
+		nil,
+		nil,
+		statusNotConnected(),
+	}
 }
 
-type fakeManager struct {
-	errorChannel chan error
+func (manager *connectionManager) Connect(identity identity.Identity, NodeKey string) error {
+	manager.status = statusConnecting()
+	session, err := manager.mysteriumClient.SessionCreate(NodeKey)
+	if err != nil {
+		manager.status = statusError(err)
+		return err
+	}
+
+	proposal := session.ServiceProposal
+
+	dialogEstablisher := manager.dialogEstablisherFactory(identity)
+	manager.dialog, err = dialogEstablisher.CreateDialog(proposal.ProviderContacts[0])
+	if err != nil {
+		manager.status = statusError(err)
+		return err
+	}
+
+	vpnSession, err := vpn_session.RequestSessionCreate(manager.dialog, proposal.Id)
+	if err != nil {
+		manager.status = statusError(err)
+		return err
+	}
+
+	manager.vpnClient, err = manager.vpnClientFactory(vpnSession, &session)
+
+	if err := manager.vpnClient.Start(); err != nil {
+		manager.status = statusError(err)
+		return err
+	}
+	manager.status = statusConnected(session.Id)
+	return nil
 }
 
-func NewManager() *fakeManager {
-	return &fakeManager{make(chan error)}
+func (manager *connectionManager) Status() ConnectionStatus {
+	return manager.status
 }
 
-func (nm *fakeManager) Connect(identity identity.Identity, NodeKey string) error {
+func (manager *connectionManager) Disconnect() error {
+	manager.dialog.Close()
+	manager.vpnClient.Stop()
 	return nil
 }
 
-func (nm *fakeManager) Status() ConnectionStatus {
-	return ConnectionStatus{NOT_CONNECTED, ""}
+func (manager *connectionManager) Wait() error {
+	return manager.vpnClient.Wait()
 }
 
-func (nm *fakeManager) Disconnect() error {
-	nm.errorChannel <- errors.New("disconnected")
-	return nil
+func statusError(err error) ConnectionStatus {
+	return ConnectionStatus{NOT_CONNECTED, "", err}
+}
+
+func statusConnecting() ConnectionStatus {
+	return ConnectionStatus{NEGOTIATING, "", nil}
+}
+
+func statusConnected(sessionId string) ConnectionStatus {
+	return ConnectionStatus{CONNECTED, sessionId, nil}
 }
 
-func (nm *fakeManager) Wait() error {
-	return <-nm.errorChannel
+func statusNotConnected() ConnectionStatus {
+	return ConnectionStatus{NOT_CONNECTED, "", nil}
 }

client_connection/manager_test.go

@@ -0,0 +1,141 @@
+package client_connection
+
+import (
+	"errors"
+	"github.com/mysterium/node/communication"
+	"github.com/mysterium/node/identity"
+	"github.com/mysterium/node/openvpn"
+	"github.com/mysterium/node/openvpn/service_discovery"
+	"github.com/mysterium/node/openvpn/session"
+	"github.com/mysterium/node/server"
+	mysterium_api_client "github.com/mysterium/node/server/dto"
+	"github.com/mysterium/node/service_discovery/dto"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"sync"
+	"testing"
+)
+
+type test_context struct {
+	suite.Suite
+	connManager         *connectionManager
+	fakeDiscoveryClient server.Client
+	fakeOpenVpn         *fake_openvpn_client
+}
+
+func (tc *test_context) SetupTest() {
+
+	tc.fakeDiscoveryClient = server.NewClientFake()
+
+	serviceProposal := service_discovery.NewServiceProposal(identity.FromAddress("vpn-node-1"), dto.Contact{})
+	tc.fakeDiscoveryClient.NodeRegister(serviceProposal)
+
+	dialogEstablisherFactory := func(identity identity.Identity) communication.DialogEstablisher {
+		return &fake_dialog{}
+	}
+
+	tc.fakeOpenVpn = &fake_openvpn_client{make(chan int, 1), nil}
+	fakeVpnClientFactory := func(vpnSession *session.VpnSession, session *mysterium_api_client.Session) (openvpn.Client, error) {
+		return tc.fakeOpenVpn, nil
+	}
+
+	tc.connManager = NewManager(tc.fakeDiscoveryClient, dialogEstablisherFactory, fakeVpnClientFactory)
+}
+
+func (tc *test_context) TestWhenNoConnectionIsMadeStatusIsNotConnected() {
+	assert.Equal(tc.T(), ConnectionStatus{NOT_CONNECTED, "", nil}, tc.connManager.Status())
+}
+
+func (tc *test_context) TestOnConnectErrorStatusIsNotConnectedAndLastErrorIsSet() {
+	fatalVpnError := errors.New("fatal connection error")
+	tc.fakeOpenVpn.onConnectReturnError = fatalVpnError
+	tc.fakeOpenVpn.resumeStart()
+
+	assert.Error(tc.T(), tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1"))
+	assert.Equal(tc.T(), ConnectionStatus{NOT_CONNECTED, "", fatalVpnError}, tc.connManager.Status())
+}
+
+func (tc *test_context) TestWhenManagerMadeConnectionStatusReturnsConnectedStateAndSessionId() {
+	tc.fakeOpenVpn.resumeStart()
+
+	err := tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1")
+
+	assert.NoError(tc.T(), err)
+	assert.Equal(tc.T(), ConnectionStatus{CONNECTED, "vpn-node-1-session", nil}, tc.connManager.Status())
+}
+
+func (tc *test_context) TestStatusReportsConnectingWhenConnectionIsInProgress() {
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		wg.Done()
+		tc.connManager.Connect(identity.FromAddress("identity-1"), "vpn-node-1")
+	}()
+	//wait for go function actually start, to avoid race condition, when we query Status before Connect call even begins.
+	wg.Wait()
+	assert.Equal(tc.T(), ConnectionStatus{NEGOTIATING, "", nil}, tc.connManager.Status())
+	tc.fakeOpenVpn.resumeStart()
+}
+
+func (tc *test_context) TearDownTest() {
+
+}
+
+func TestConnectionManagerSuite(t *testing.T) {
+	suite.Run(t, new(test_context))
+}
+
+type fake_openvpn_client struct {
+	connectionDelay      chan int
+	onConnectReturnError error
+}
+
+func (foc *fake_openvpn_client) resumeStart() {
+	foc.connectionDelay <- 1
+}
+
+func (foc *fake_openvpn_client) Start() error {
+	<-foc.connectionDelay
+	return foc.onConnectReturnError
+}
+
+func (foc *fake_openvpn_client) Wait() error {
+	return nil
+}
+
+func (foc *fake_openvpn_client) Stop() error {
+	return nil
+}
+
+type fake_dialog struct {
+}
+
+func (fd *fake_dialog) CreateDialog(contact dto.Contact) (communication.Dialog, error) {
+	return fd, nil
+}
+
+func (fd *fake_dialog) Close() error {
+	return nil
+}
+
+func (fd *fake_dialog) Receive(consumer communication.MessageConsumer) error {
+	return nil
+}
+func (fd *fake_dialog) Respond(consumer communication.RequestConsumer) error {
+	return nil
+}
+
+func (fd *fake_dialog) Send(producer communication.MessageProducer) error {
+	return nil
+}
+
+func (fd *fake_dialog) Request(producer communication.RequestProducer) (responsePtr interface{}, err error) {
+	return &session.SessionCreateResponse{
+			true,
+			"Everything is great!",
+			session.VpnSession{
+				"vpn-session-id",
+				"vpn-session-config"},
+		},
+		nil
+}