mapimpl fixes

notifications/ephemeral_test.go

+package notifications
+
+import "testing"
+
+func TestHandleQuantization(t *testing.T) {
+	// should handlequantization move to prims?
+}
+
+func TestImpl_AddEphemerals(t *testing.T) {
+
+}
+
+func TestImpl_DeleteEphemerals(t *testing.T) {
+	// test basic functionality of deleteephemerals
+}
+
+func TestEphemerals(t *testing.T) {
+	// Do a test of adding ephemerals, incrementing time by ephemeral period, deleting ephemerals
+}

notifications/notifications.go

@@ -25,7 +25,6 @@ import (
 	"gitlab.com/xx_network/primitives/ndf"
 	"gitlab.com/xx_network/primitives/utils"
 	"strings"
-	"sync"
 	"time"
 )
 
@@ -54,7 +53,6 @@ type Impl struct {
 	fcm              *messaging.Client
 	gwId             *id.ID
 
-	offsets                map[int64]*sync.Once
 	updateChan, deleteChan chan int64
 }
 
@@ -99,7 +97,6 @@ func (nb *Impl) RunNotificationLoop(loopDuration int, killChan chan struct{}, er
 // StartNotifications creates an Impl from the information passed in
 func StartNotifications(params Params, noTLS, noFirebase bool) (*Impl, error) {
 	impl := &Impl{
-		offsets:    map[int64]*sync.Once{},
 		updateChan: make(chan int64),
 		deleteChan: make(chan int64),
 	}

storage/database.go

@@ -33,8 +33,8 @@ type MapImpl struct {
 	usersByRsaHash   map[string]*User
 	usersByOffset    map[int64][]*User
 	allUsers         []*User
+	allEphemerals    map[uint]*Ephemeral
 	ephemeralsByUser map[string][]*Ephemeral
-	ephemeralsByOffset map[int64][]*Ephemeral
 	ephIDSeq         uint
 }
 
@@ -97,7 +97,7 @@ func newDatabase(username, password, dbName, address,
 			usersByOffset:    map[int64][]*User{},
 			allUsers:         nil,
 			ephemeralsByUser: map[string][]*Ephemeral{},
-			ephemeralsByOffset: map[int64][]*Ephemeral{},
+			allEphemerals:    map[uint]*Ephemeral{},
 			ephIDSeq:         0,
 		}
 

storage/mapImpl.go

@@ -87,7 +87,7 @@ func (m *MapImpl) upsertEphemeral(ephemeral *Ephemeral) error {
 	ephemeral.ID = m.ephIDSeq
 	m.ephIDSeq++
 	m.ephemeralsByUser[string(ephemeral.TransmissionRSAHash)] = append(m.ephemeralsByUser[string(ephemeral.TransmissionRSAHash)], ephemeral)
-	m.ephemeralsByOffset[ephemeral.Offset] = append(m.ephemeralsByOffset[ephemeral.Offset], ephemeral)
+	m.allEphemerals[ephemeral.ID] = ephemeral
 	return nil
 }
 
@@ -104,18 +104,23 @@ func (m *MapImpl) getUsersByOffset(offset int64) ([]*User, error) {
 }
 
 func (m *MapImpl) DeleteOldEphemerals(epoch int32) error {
-	// TODO: update this
-	//cutoff := time.Now().Add(time.Minute * -1)
-	//	//var newEphemerals []*Ephemeral
-	//	//for _, e := range m.ephemeralsByOffset[offset] {
-	//	//	if e.ValidUntil.After(cutoff) {
-	//	//		newEphemerals = append(newEphemerals, e)
-	//	//	}
-	//	//}
-	//	//m.ephemeralsByOffset[offset] = newEphemerals
+	for k, es := range m.ephemeralsByUser {
+		for i, e := range es {
+			if e.Epoch < epoch {
+				delete(m.allEphemerals, m.ephemeralsByUser[k][i].ID)
+				m.ephemeralsByUser[k] = append(m.ephemeralsByUser[k][:i], m.ephemeralsByUser[k][i+1:]...)
+			}
+		}
+	}
 	return nil
 }
 
 func (m *MapImpl) GetLatestEphemeral() (*Ephemeral, error) {
-	return &Ephemeral{}, nil
+	cur := m.ephIDSeq
+	var res *Ephemeral
+	var ok bool
+	for res, ok = m.allEphemerals[cur]; !ok; {
+		cur++
+	}
+	return res, nil
 }

storage/mapImpl_test.go

@@ -2,82 +2,78 @@ package storage
 
 import (
 	"bytes"
-	"gitlab.com/xx_network/primitives/id"
-	"gitlab.com/xx_network/primitives/id/ephemeral"
 	"testing"
-	"time"
 )
 
 // This file contains testing for mapImpl.go
 
-func TestDatabaseImpl(t *testing.T) {
-	s, err := NewStorage("jonahhusson", "", "nbtest", "0.0.0.0", "5432")
-	if err != nil {
-		t.Errorf("Failed to create db: %+v", err)
-		t.FailNow()
-	}
-	sig := []byte("sig")
-	uid := id.NewIdFromString("zezima", id.User, t)
-	iid, err := ephemeral.GetIntermediaryId(uid)
-	if err != nil {
-		t.Errorf("Failed to make iid: %+v", err)
-	}
-	token1 := "i'm a token"
-	_, err = s.AddUser(iid, []byte("rsa"), sig, token1)
-	if err != nil {
-		t.Errorf("Failed to upsert user: %+v", err)
-	}
-
-	u, err := s.GetUser(iid)
-	if err != nil {
-		t.Errorf("Failed to get user: %+v", err)
-	}
-	if u.Token != token1 {
-		t.Errorf("Expected user with token %s.  Instead got %s.", token1, u.Token)
-	}
-
-	token2 := "you're a token"
-	u1, err := s.AddUser(iid, []byte("rsa"), sig, token2)
-	if err != nil {
-		t.Errorf("Failed to upsert updated user: %+v", err)
-	}
-
-	u, err = s.GetUser(iid)
-	if err != nil {
-		t.Errorf("Failed to get user: %+v", err)
-	}
-	if u.Token != token2 {
-		t.Errorf("Expected user with token %s.  Instead got %s.", token1, u.Token)
-	}
-
-	u2, err := s.AddUser([]byte("jakexx360"), []byte("rsa2"), sig, token2)
-	if err != nil {
-		t.Errorf("Failed to upsert updated user: %+v", err)
-	}
-
-	err = s.AddLatestEphemeral(u2)
-	if err != nil {
-		t.Errorf("Failed to add latest ephemeral: %+v", err)
-	}
-	_, end, _ := ephemeral.GetOffsetBounds(u1.Offset, time.Now().UnixNano())
-	err = s.AddEphemeralsForOffset(u1.Offset, end)
-	if err != nil {
-		t.Errorf("failed to update ephemerals for offset: %+v", err)
-	}
-
-	err = s.DeleteOldEphemerals(u1.Offset)
-	if err != nil {
-		t.Errorf("Failed to delete old ephemerals: %+v", err)
-	}
-
-	us, err := s.GetAllUsers()
-	if err != nil {
-		t.Errorf("Failed to get all users: %+v", err)
-	}
-	if len(us) != 2 {
-		t.Errorf("Did not get enough users: %+v", us)
-	}
-}
+//func TestDatabaseImpl(t *testing.T) {
+//	s, err := NewStorage("jonahhusson", "", "nbtest", "0.0.0.0", "5432")
+//	if err != nil {
+//		t.Errorf("Failed to create db: %+v", err)
+//		t.FailNow()
+//	}
+//	sig := []byte("sig")
+//	uid := id.NewIdFromString("zezima", id.User, t)
+//	iid, err := ephemeral.GetIntermediaryId(uid)
+//	if err != nil {
+//		t.Errorf("Failed to make iid: %+v", err)
+//	}
+//	token1 := "i'm a token"
+//	_, err = s.AddUser(iid, []byte("rsa"), sig, token1)
+//	if err != nil {
+//		t.Errorf("Failed to upsert user: %+v", err)
+//	}
+//
+//	u, err := s.GetUser(iid)
+//	if err != nil {
+//		t.Errorf("Failed to get user: %+v", err)
+//	}
+//	if u.Token != token1 {
+//		t.Errorf("Expected user with token %s.  Instead got %s.", token1, u.Token)
+//	}
+//
+//	token2 := "you're a token"
+//	u1, err := s.AddUser(iid, []byte("rsa"), sig, token2)
+//	if err != nil {
+//		t.Errorf("Failed to upsert updated user: %+v", err)
+//	}
+//
+//	u, err = s.GetUser(iid)
+//	if err != nil {
+//		t.Errorf("Failed to get user: %+v", err)
+//	}
+//	if u.Token != token2 {
+//		t.Errorf("Expected user with token %s.  Instead got %s.", token1, u.Token)
+//	}
+//
+//	u2, err := s.AddUser([]byte("jakexx360"), []byte("rsa2"), sig, token2)
+//	if err != nil {
+//		t.Errorf("Failed to upsert updated user: %+v", err)
+//	}
+//	err = s.AddLatestEphemeral(u2, 5)
+//	if err != nil {
+//		t.Errorf("Failed to add latest ephemeral: %+v", err)
+//	}
+//	_, _, _ = ephemeral.GetOffsetBounds(u1.Offset, time.Now().UnixNano())
+//	err = s.AddEphemeralsForOffset(u1.Offset, 5)
+//	if err != nil {
+//		t.Errorf("failed to update ephemerals for offset: %+v", err)
+//	}
+//
+//	err = s.DeleteOldEphemerals(6)
+//	if err != nil {
+//		t.Errorf("Failed to delete old ephemerals: %+v", err)
+//	}
+//
+//	us, err := s.GetAllUsers()
+//	if err != nil {
+//		t.Errorf("Failed to get all users: %+v", err)
+//	}
+//	if len(us) != 2 {
+//		t.Errorf("Did not get enough users: %+v", us)
+//	}
+//}
 
 // This tests getting a user that does exist in the database
 func TestMapImpl_GetUser_Happy(t *testing.T) {
@@ -256,10 +252,163 @@ func TestMapImpl_UpsertUser_HappyTwice(t *testing.T) {
 	}
 }
 
+func TestMapImpl_UpsertEphemeral(t *testing.T) {
+	m := &MapImpl{
+		ephIDSeq:         0,
+		ephemeralsByUser: map[string][]*Ephemeral{},
+		allEphemerals:    map[uint]*Ephemeral{},
+		allUsers:         nil,
+		usersByRsaHash:   map[string]*User{},
+		usersById:        map[string]*User{},
+		usersByOffset:    map[int64][]*User{},
+	}
+	trsaHash := []byte("TransmissionRSAHash")
+	u := User{IntermediaryId: []byte("test"), Token: "token", TransmissionRSAHash: trsaHash}
+
+	err := m.upsertUser(&u)
+
+	if err != nil {
+		t.Errorf("TestMapImpl_UpsertUser_HappyTwice: function returned an error\n\tGot: %s", err)
+	}
+
+	err = m.upsertEphemeral(&Ephemeral{
+		Offset:              0,
+		TransmissionRSAHash: trsaHash,
+		EphemeralId:         []byte("eid"),
+		Epoch:               17,
+	})
+	if err != nil {
+		t.Errorf("Failed to upsert ephemeral: %+v", err)
+	}
+
+	if m.ephIDSeq != 1 {
+		t.Error("sequence did not increment")
+	}
+	if m.allEphemerals[0] == nil {
+		t.Error("Did not insert to allEphemerals")
+	}
+	if len(m.ephemeralsByUser[string(trsaHash)]) != 1 {
+		t.Error("Did not insert to ephemeralsByUser")
+	}
+}
+
 func TestMapImpl_GetEphemeral(t *testing.T) {
+	m := &MapImpl{
+		ephIDSeq:         0,
+		ephemeralsByUser: map[string][]*Ephemeral{},
+		allEphemerals:    map[uint]*Ephemeral{},
+		allUsers:         nil,
+		usersByRsaHash:   map[string]*User{},
+		usersById:        map[string]*User{},
+		usersByOffset:    map[int64][]*User{},
+	}
+	trsaHash := []byte("TransmissionRSAHash")
+
+	u := User{IntermediaryId: []byte("test"), Token: "token", TransmissionRSAHash: trsaHash}
+
+	err := m.upsertUser(&u)
 
+	if err != nil {
+		t.Errorf("TestMapImpl_UpsertUser_HappyTwice: function returned an error\n\tGot: %s", err)
+	}
+
+	err = m.upsertEphemeral(&Ephemeral{
+		Offset:              0,
+		TransmissionRSAHash: trsaHash,
+		EphemeralId:         []byte("eid"),
+		Epoch:               17,
+	})
+	if err != nil {
+		t.Errorf("Failed to upsert ephemeral: %+v", err)
+	}
+
+	e, err := m.GetEphemeral(trsaHash)
+	if err != nil {
+		t.Errorf("Failed to get ephemeral: %+v", err)
+	}
+	if bytes.Compare(e.TransmissionRSAHash, trsaHash) != 0 {
+		t.Errorf("Did not receive expected ephemeral: %+v", e)
+	}
 }
 
 func TestMapImpl_DeleteOldEphemerals(t *testing.T) {
+	m := &MapImpl{
+		ephIDSeq:         0,
+		ephemeralsByUser: map[string][]*Ephemeral{},
+		allEphemerals:    map[uint]*Ephemeral{},
+		allUsers:         nil,
+		usersByRsaHash:   map[string]*User{},
+		usersById:        map[string]*User{},
+		usersByOffset:    map[int64][]*User{},
+	}
+	trsaHash := []byte("TransmissionRSAHash")
+
+	u := User{IntermediaryId: []byte("test"), Token: "token", TransmissionRSAHash: trsaHash}
+
+	err := m.upsertUser(&u)
+
+	if err != nil {
+		t.Errorf("TestMapImpl_UpsertUser_HappyTwice: function returned an error\n\tGot: %s", err)
+	}
+
+	err = m.upsertEphemeral(&Ephemeral{
+		Offset:              0,
+		TransmissionRSAHash: trsaHash,
+		EphemeralId:         []byte("eid"),
+		Epoch:               17,
+	})
+	if err != nil {
+		t.Errorf("Failed to upsert ephemeral: %+v", err)
+	}
 
+	e, err := m.GetEphemeral(trsaHash)
+	if err != nil {
+		t.Errorf("Failed to get ephemeral: %+v", err)
+	}
+
+	err = m.DeleteOldEphemerals(18)
+	if err != nil {
+		t.Errorf("Failed to delete old ephemerals: %+v", err)
+	}
+
+	_, ok := m.allEphemerals[e.ID]
+	if ok {
+		t.Errorf("Did not delete properly")
+	}
+}
+
+func TestMapImpl_GetLatestEphemeral(t *testing.T) {
+	m := &MapImpl{
+		ephIDSeq:         0,
+		ephemeralsByUser: map[string][]*Ephemeral{},
+		allEphemerals:    map[uint]*Ephemeral{},
+		allUsers:         nil,
+		usersByRsaHash:   map[string]*User{},
+		usersById:        map[string]*User{},
+		usersByOffset:    map[int64][]*User{},
+	}
+	trsaHash := []byte("TransmissionRSAHash")
+
+	u := User{IntermediaryId: []byte("test"), Token: "token", TransmissionRSAHash: trsaHash}
+
+	err := m.upsertUser(&u)
+
+	if err != nil {
+		t.Errorf("TestMapImpl_UpsertUser_HappyTwice: function returned an error\n\tGot: %s", err)
+	}
+
+	err = m.upsertEphemeral(&Ephemeral{
+		Offset:              0,
+		TransmissionRSAHash: trsaHash,
+		EphemeralId:         []byte("eid"),
+		Epoch:               17,
+	})
+	if err != nil {
+		t.Errorf("Failed to upsert ephemeral: %+v", err)
+	}
+
+	_, err = m.GetLatestEphemeral()
+	if err != nil {
+		t.Errorf("Failed to get latest ephemeral: %+v", err)
+	}
 }

storage/storage_test.go

@@ -56,9 +56,9 @@ func TestStorage_AddLatestEphemeral(t *testing.T) {
 	if err != nil {
 		t.Errorf("Failed to add user: %+v", err)
 	}
-	err = s.AddLatestEphemeral(u)
+	err = s.AddLatestEphemeral(u, 5)
 	if err != nil {
-		t.Errorf("Failed to add latest ephemeral: %+V", err)
+		t.Errorf("Failed to add latest ephemeral: %+v", err)
 	}
 }