func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
userkey := util.FormatUserKey(args.UserID)
_, userErr := ts.libstore.Get(userkey)
if userErr != nil {
reply.Status = tribrpc.NoSuchUser
} else {
delErr := ts.libstore.Delete(args.PostKey)
if delErr != nil {
reply.Status = tribrpc.NoSuchPost
return nil
}
tribkey := util.FormatTribListKey(args.UserID)
delListErr := ts.libstore.RemoveFromList(tribkey, args.PostKey)
if delListErr != nil {
reply.Status = tribrpc.NoSuchPost
return nil
}
reply.Status = tribrpc.OK
}
return nil
}
func (ts *tribServer) GetAllTribblesByUser(UserID string) ([]tribrpc.Tribble, error) {
tribblesID, err := ts.ls.GetList(util.FormatTribListKey(UserID))
if err != nil {
return make([]tribrpc.Tribble, 0), err
}
if tribblesID == nil {
return make([]tribrpc.Tribble, 0), nil
}
if len(tribblesID) <= 0 {
return make([]tribrpc.Tribble, 0), nil
}
var tribble tribrpc.Tribble
tribbles := make([]tribrpc.Tribble, len(tribblesID))
mychan := make(chan string, 1000)
for i := 0; i < len(tribblesID); i++ {
fmt.Println("Get getTribbleParallel")
go ts.getTribbleParallel(tribblesID[i], mychan)
}
// tribbleByte, err := ts.ls.Get(tribblesID[i])
for i := 0; i < len(tribblesID); i++ {
val := <-mychan
json.Unmarshal([]byte(val), &tribble)
tribbles[i] = tribble
}
return tribbles, nil
}
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
key := util.FormatUserKey(args.UserID)
if ts.checkIfKnown(key) {
newTrib := tribrpc.Tribble{args.UserID, time.Now(), args.Contents}
tribStr, err := json.Marshal(newTrib)
if err != nil {
return err
}
id := newTrib.UserID
time := newTrib.Posted.UnixNano()
post_key := util.FormatPostKey(id, time)
for ts.checkIfKnown(post_key) {
post_key = util.FormatPostKey(id, time)
}
err = ts.storage.Put(post_key, string(tribStr))
if err != nil {
return err
}
triblist_key := util.FormatTribListKey(args.UserID)
err = ts.storage.AppendToList(triblist_key, post_key)
if err != nil {
return err
}
reply.PostKey = post_key
reply.Status = tribrpc.OK
} else {
reply.Status = tribrpc.NoSuchUser
}
return nil
}
func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
key := util.FormatUserKey(args.UserID)
post_key := args.PostKey
if !ts.checkIfKnown(key) {
reply.Status = tribrpc.NoSuchUser
} else if !ts.checkIfKnown(post_key) {
reply.Status = tribrpc.NoSuchPost
} else {
err := ts.storage.Delete(post_key)
if err != nil {
return err
}
triblist_key := util.FormatTribListKey(args.UserID)
err = ts.storage.RemoveFromList(triblist_key, post_key)
if err != nil {
return err
}
reply.Status = tribrpc.OK
}
return nil
}
func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
user_id := util.FormatUserKey(args.UserID)
// If the user_id doesn't exist
// Reture NoSuchUser
_, err := ts.lib_store.Get(user_id)
if err != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
user_trib_list_key := util.FormatTribListKey(args.UserID)
err = ts.lib_store.RemoveFromList(user_trib_list_key, args.PostKey)
if err != nil {
reply.Status = tribrpc.NoSuchPost
fmt.Println(2)
return nil
}
err = ts.lib_store.Delete(args.PostKey)
if err != nil {
reply.Status = tribrpc.NoSuchPost
return nil
}
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
if ts.userExist(args.UserID) == false {
reply.Status = tribrpc.NoSuchUser
return nil
}
reply.Status = tribrpc.OK
t := time.Now()
tribble := &tribrpc.Tribble{
UserID: args.UserID,
Posted: t,
Contents: args.Contents,
}
tribbleByte, err := json.Marshal(tribble)
tribbleString := string(tribbleByte)
tribbleID := t.UTC().UnixNano()
reply.PostKey = util.FormatPostKey(args.UserID, tribbleID)
if err != nil {
return errors.New("Error Marshal")
}
err = ts.ls.Put(reply.PostKey, tribbleString)
if err != nil {
return errors.New("Error Put")
}
err = ts.ls.AppendToList(util.FormatTribListKey(args.UserID), reply.PostKey)
if err != nil {
return errors.New("Error AppendToList: " + err.Error())
}
return nil
}
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
userkey := util.FormatUserKey(args.UserID)
_, userErr := ts.libstore.Get(userkey)
if userErr != nil {
reply.Status = tribrpc.NoSuchUser
} else {
postTime := time.Now()
tribble := &tribrpc.Tribble{
UserID: args.UserID,
Posted: postTime,
Contents: args.Contents,
}
marshalTribble, _ := json.Marshal(tribble)
unixTime := int64(postTime.UnixNano())
postKey := util.FormatPostKey(args.UserID, unixTime)
putErr := ts.libstore.Put(postKey, string(marshalTribble))
if putErr != nil {
return errors.New("Fail to put postkey and tribble")
}
tribListKey := util.FormatTribListKey(args.UserID)
appendErr := ts.libstore.AppendToList(tribListKey, postKey)
if appendErr != nil {
return errors.New("Fail to append tribble to user")
}
reply.Status = tribrpc.OK
reply.PostKey = postKey
}
return nil
}
/*
-format sublist
*/
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
if DBG {
fmt.Println("-----> GetTribblesBySubscription")
}
var usrID string = args.UserID
//check if user present in server
_, err := ts.libStore.Get(util.FormatUserKey(usrID))
if err != nil {
switch err.Error() {
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
case KEY_NOT_FOUND:
reply.Status = tribrpc.NoSuchUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
}
//get list of subscribers
subscrList, err := ts.libStore.GetList(util.FormatSubListKey(usrID))
if err != nil {
//return err
fmt.Println("No subscribers, or error getting list of subscribers")
reply.Status = tribrpc.OK
return nil
}
//initialise empty slice of all postKeys from subscribers
var allPostKeys []string = make([]string, 0)
//populate allPostKeys
for _, currUser := range subscrList {
currPostKeys, err := ts.libStore.GetList(util.FormatTribListKey(currUser))
if err == nil {
allPostKeys = append(allPostKeys, currPostKeys...)
} else {
//fmt.Println("0 tribs for user detected")
}
}
sort.Sort(PostByTime(allPostKeys))
//choose most recent posts, and get tribbles
var tribList []tribrpc.Tribble = ts.getTribbleList(allPostKeys)
reply.Tribbles = tribList
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
if args == nil {
return errors.New("ts: Can't delete nil")
}
if reply == nil {
return errors.New("ts: Can't reply with nil in Delete")
}
_, err := ts.ls.Get(util.FormatUserKey(args.UserID))
if err != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
err = ts.ls.RemoveFromList(util.FormatTribListKey(args.UserID), args.PostKey)
if err != nil {
reply.Status = tribrpc.NoSuchPost
return nil
}
if ts.ls.Delete(args.PostKey) != nil {
reply.Status = tribrpc.NoSuchPost
return errors.New("Fatal, failed to delete a key")
}
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
key := util.FormatUserKey(args.UserID)
if ts.checkIfKnown(key) {
triblist_key := util.FormatTribListKey(args.UserID)
post_ids, err := ts.storage.GetList(triblist_key)
if err != nil {
post_ids = []string{}
}
sort.Sort(ByChrono(post_ids))
bound := min(100, len(post_ids))
tribs := make([]tribrpc.Tribble, bound)
for i, v := range post_ids[0:bound] {
postStr, err := ts.storage.Get(v)
if err != nil {
return err
}
trib := tribrpc.Tribble{}
json.Unmarshal([]byte(postStr), &trib)
tribs[i] = trib
}
reply.Tribbles = tribs
reply.Status = tribrpc.OK
} else {
reply.Status = tribrpc.NoSuchUser
}
return nil
}
func (ts *tribServer) GetTribblesOneUser(userId string) []tribrpc.Tribble {
tribkey := util.FormatTribListKey(userId)
tribIdList, err := ts.libstore.GetList(tribkey)
if err != nil {
return nil
}
var tribble tribrpc.Tribble
length := len(tribIdList)
if length > 100 {
length = 100
}
tribList := make([]tribrpc.Tribble, 0, length)
i := 0
for len(tribList) < length && len(tribIdList) >= 1+i {
tribId := tribIdList[len(tribIdList)-1-i]
tribbleString, err := ts.libstore.Get(tribId)
if err == nil {
json.Unmarshal([]byte(tribbleString), &tribble)
tribList = append(tribList, tribble)
}
i++
}
return tribList
}
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
if args == nil {
return errors.New("ts: Can't getSubscription nil")
}
if reply == nil {
return errors.New("ts: Can't reply with nil in getSubscription")
}
_, err := ts.ls.Get(util.FormatUserKey(args.UserID))
if err != nil {
reply.Status = tribrpc.NoSuchUser
reply.Tribbles = make([]tribrpc.Tribble, 0, 0)
return nil
}
users, err := ts.ls.GetList(util.FormatSubListKey(args.UserID))
if err != nil {
reply.Status = tribrpc.OK
reply.Tribbles = make([]tribrpc.Tribble, 0, 0)
return nil
}
postIDs := make([]string, 0)
for _, userID := range users {
lst, err := ts.ls.GetList(util.FormatTribListKey(userID))
if err == nil {
postIDs = append(postIDs, lst...)
}
}
tmp := tribbleIDs(postIDs)
sort.Sort(tmp)
tribbleIdsChrono := []string(tmp)
length := 100
if len(tribbleIdsChrono) < 100 {
length = len(tribbleIdsChrono)
}
tribbles := make([]tribrpc.Tribble, length)
var tribTmp tribrpc.Tribble
i := 0
for i < length {
trib, err := ts.ls.Get(tribbleIdsChrono[i])
if err == nil {
json.Unmarshal([]byte(trib), &tribTmp)
tribbles[i] = tribTmp
i += 1 // If error occurs, we do NOT increment i
}
}
reply.Status = tribrpc.OK
reply.Tribbles = tribbles
return nil
}
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
// Getsublist by key
// Get tribble list by user_ids in sublist
// sort the tribble list by the timestamp
// retrive the first 100 tribble (Be careful about the delete operation)
user_id := util.FormatUserKey(args.UserID)
// If the user_id doesn't exist
// Reture NoSuchUser
_, err := ts.lib_store.Get(user_id)
if err != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
// Get user's subscription_list
user_id_list := util.FormatSubListKey(args.UserID)
// list of IDs
user_list, _ := ts.lib_store.GetList(user_id_list)
if user_list == nil {
reply.Status = tribrpc.OK
return nil
}
// Get tribble_ids from the user_ids in the subscription list
tribble_id_list := make([]string, 0)
for _, usr_id := range user_list {
t_id_list, err := ts.lib_store.GetList(util.FormatTribListKey(usr_id))
if err == nil {
tribble_id_list = append(tribble_id_list, t_id_list...)
}
}
sort.Sort(SortTribbleByTimestamp(tribble_id_list))
counter := 0
tribble_list := make([]tribrpc.Tribble, 100)
for _, tid := range tribble_id_list {
tribble, err := ts.lib_store.Get(tid)
if err == nil {
json.Unmarshal([]byte(tribble), &tribble_list[counter])
counter += 1
}
if counter >= 100 {
break
}
}
reply.Status = tribrpc.OK
reply.Tribbles = tribble_list[:counter]
return nil
}
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
if args == nil {
return errors.New("ts: Can't post nil")
}
if reply == nil {
return errors.New("ts: Can't reply with nil in Post")
}
curTime := time.Now()
_, err := ts.ls.Get(util.FormatUserKey(args.UserID))
if err != nil {
reply.Status = tribrpc.NoSuchUser
reply.PostKey = ""
return nil
}
newTribID := util.FormatPostKey(args.UserID, curTime.UnixNano())
for ts.ls.AppendToList(util.FormatTribListKey(args.UserID), newTribID) != nil {
newTribID = util.FormatPostKey(args.UserID, curTime.UnixNano())
}
trb := &tribrpc.Tribble{
UserID: args.UserID,
Posted: curTime,
Contents: args.Contents,
}
marshaled, _ := json.Marshal(trb)
if ts.ls.Put(newTribID, string(marshaled[:])) != nil {
ts.ls.RemoveFromList(util.FormatTribListKey(args.UserID), newTribID)
reply.Status = tribrpc.NoSuchUser
reply.PostKey = ""
return errors.New("Fatal, failed to add new post")
}
reply.Status = tribrpc.OK
reply.PostKey = newTribID
return nil
}
/*
-getList, formatTribListKey to get all the post keys
-Slice it off at 100
-reverse it or wtv (if needed)
-Get() with that post key, and get the marshalled tribble
*/
func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
if DBG {
fmt.Println("-----> GetTribbles")
}
var usrID string = args.UserID
//check if user present in server
_, err := ts.libStore.Get(util.FormatUserKey(usrID))
if err != nil {
switch err.Error() {
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
case KEY_NOT_FOUND:
reply.Status = tribrpc.NoSuchUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
}
postKeysList, err := ts.libStore.GetList(util.FormatTribListKey(usrID))
if err != nil {
//fmt.Println("Could not get list of postKeys for user")
//return empty tribble list, as the list is not yet created (0 tribbles)
switch err.Error() {
case KEY_NOT_FOUND:
reply.Status = tribrpc.OK
reply.Tribbles = make([]tribrpc.Tribble, 0)
return nil
case WRONG_SERVER:
fmt.Println("WRONG SERVER CONTACTED!")
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received!")
return nil
}
}
reply.Status = tribrpc.OK
reply.Tribbles = ts.getTribbleList(postKeysList)
return nil
}
func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
if ts.userExist(args.UserID) == false {
reply.Status = tribrpc.NoSuchUser
return nil
}
reply.Status = tribrpc.OK
err := ts.ls.Delete(args.PostKey)
if err != nil {
reply.Status = tribrpc.NoSuchPost
}
err = ts.ls.RemoveFromList(util.FormatTribListKey(args.UserID), args.PostKey)
if err != nil {
reply.Status = tribrpc.NoSuchPost
}
return nil
}
func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
userid := args.UserID
useridkey := util.FormatUserKey(userid)
_, userExists := ts.ls.Get(useridkey)
if userExists != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
userTribListKey := util.FormatTribListKey(userid)
tribbleIdList, err := ts.ls.GetList(userTribListKey)
if err != nil {
reply.Status = tribrpc.OK
reply.Tribbles = nil
return nil
}
tmp := tribbleIDs(tribbleIdList)
sort.Sort(tmp)
tribbleIdsChrono := []string(tmp)
// Calculate the length of the tribbles we want to get
length := 100
if len(tribbleIdsChrono) < 100 {
length = len(tribbleIdsChrono)
}
allTribbles := make([]tribrpc.Tribble, length)
var tribTmp tribrpc.Tribble
i := 0
for i < length {
trib, err := ts.ls.Get(tribbleIdsChrono[i])
if err == nil {
json.Unmarshal([]byte(trib), &tribTmp)
allTribbles[i] = tribTmp
i += 1 // If error occurs, we do NOT increment i
}
}
reply.Status = tribrpc.OK
reply.Tribbles = allTribbles
return nil
}
func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
user_id := util.FormatUserKey(args.UserID)
// If the user_id doesn't exist
// Reture NoSuchUser
_, err := ts.lib_store.Get(user_id)
if err != nil {
fmt.Println(1)
reply.Status = tribrpc.NoSuchUser
return nil
}
// Return a list of tribble_ids
raw_tribble_list, _ := ts.lib_store.GetList(util.FormatTribListKey(args.UserID))
if raw_tribble_list == nil {
reply.Status = tribrpc.OK
return nil
}
// Sort the tribble_ids by timestamp reversely
sort.Sort(SortTribbleByTimestamp(raw_tribble_list))
counter := 0
tribble_list := make([]tribrpc.Tribble, 100)
for _, tid := range raw_tribble_list {
tribble, err := ts.lib_store.Get(tid)
if err == nil {
// var t tribrpc.Tribble
json.Unmarshal([]byte(tribble), &tribble_list[counter])
counter += 1
}
if counter >= 100 {
break
}
}
reply.Status = tribrpc.OK
reply.Tribbles = tribble_list[:counter]
return nil
}
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
user_id := util.FormatUserKey(args.UserID)
// If the user_id doesn't exist
// Reture NoSuchUser
_, err := ts.lib_store.Get(user_id)
if err != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
now := time.Now()
tribble := &tribrpc.Tribble{
UserID: args.UserID,
Posted: now,
Contents: args.Contents,
}
tribble_str, _ := json.Marshal(tribble)
post_key := util.FormatPostKey(args.UserID, time.Now().UnixNano())
err = ts.lib_store.Put(post_key, string(tribble_str))
//if err != nil {
// reply.Status = tribrpc.NoSuchUser
// fmt.Println(1)
// return nil
//}
user_trib_list_key := util.FormatTribListKey(args.UserID)
err = ts.lib_store.AppendToList(user_trib_list_key, post_key)
//if err != nil {
// reply.Status = tribrpc.NoSuchUser
// fmt.Println(2)
// return nil
//}
reply.Status = tribrpc.OK
reply.PostKey = post_key
return nil
}
func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
userkey := util.FormatUserKey(args.UserID)
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
// Store list of marshalled Tribbles in lst. Return empty list if user had no subscriptions.
var lst []string
var err error
if lst, err = ts.ls.GetList(util.FormatTribListKey(args.UserID)); err != nil {
reply.Status = tribrpc.OK
reply.Tribbles = make([]tribrpc.Tribble, 0)
return nil
}
// Find out how many posts we will return
var recentPosts []string
if len(lst) > 100 {
recentPosts = lst[len(lst)-100:]
} else {
recentPosts = lst
}
// Loop through this users Tribbles in reverse order and grab up to 100
tribbles := make([]tribrpc.Tribble, len(recentPosts))
var mtribble string
var tribble tribrpc.Tribble
for i := 0; i < len(tribbles); i++ {
mtribble, _ = ts.ls.Get(recentPosts[len(tribbles)-1-i])
json.Unmarshal([]byte(mtribble), &tribble)
tribbles[i] = tribble
}
reply.Status = tribrpc.OK
reply.Tribbles = tribbles
return nil
}
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
userkey := util.FormatUserKey(args.UserID)
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
postkey := util.FormatPostKey(args.UserID, time.Now().UnixNano())
// make sure postkey is unique
for {
if _, err := ts.ls.Get(postkey); err == nil {
postkey = util.FormatPostKey(args.UserID, time.Now().UnixNano())
continue
}
break
}
// Create the Tribble
tribble := tribrpc.Tribble{UserID: args.UserID, Posted: time.Now(),
Contents: args.Contents}
value, err := json.Marshal(tribble)
if err != nil {
return errors.New("Couldn't create Tribble")
}
// Hash the Tribble and add the postkey to the user's TribList
if ep := ts.ls.Put(postkey, string(value)); ep != nil {
return errors.New("Couldn't post Tribble")
}
if ea := ts.ls.AppendToList(util.FormatTribListKey(args.UserID), postkey); ea != nil {
return errors.New("Couldn't add TribbleID to user list")
}
reply.PostKey = postkey
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
key := util.FormatUserKey(args.UserID)
if ts.checkIfKnown(key) {
sublist_key := util.FormatSubListKey(args.UserID)
sublist_ids, err := ts.storage.GetList(sublist_key)
if err != nil {
sublist_ids = []string{}
}
post_ids := []string{}
for _, userid := range sublist_ids {
triblist_key := util.FormatTribListKey(userid)
local_post_ids, err := ts.storage.GetList(triblist_key)
if err != nil {
sublist_ids = []string{}
}
post_ids = append(post_ids, local_post_ids...)
}
sort.Sort(ByChrono(post_ids))
tribs := []tribrpc.Tribble{}
for _, v := range post_ids[0:min(100, len(post_ids))] {
postStr, err := ts.storage.Get(v)
if err != nil {
return err
}
trib := tribrpc.Tribble{}
json.Unmarshal([]byte(postStr), &trib)
tribs = append(tribs, trib)
}
reply.Tribbles = tribs
reply.Status = tribrpc.OK
} else {
reply.Status = tribrpc.NoSuchUser
}
return nil
}
func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
userkey := util.FormatUserKey(args.UserID)
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
postkey := args.PostKey
// Make sure the Tribble exists
if err := ts.ls.Delete(postkey); err != nil {
reply.Status = tribrpc.NoSuchPost
return nil
}
// Make sure the Tribble is in this user's list
if err := ts.ls.RemoveFromList(util.FormatTribListKey(args.UserID), postkey); err != nil {
reply.Status = tribrpc.NoSuchPost
return nil
}
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
userkey := util.FormatUserKey(args.UserID)
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
// Get list of subscriptions. return empty list if user has no subscriptions.
var subs []string
var esubs error
if subs, esubs = ts.ls.GetList(util.FormatSubListKey(args.UserID)); esubs != nil {
reply.Status = tribrpc.OK
reply.Tribbles = make([]tribrpc.Tribble, 0)
return nil
}
numTribbles := 0
// Get the last 100 tribble IDs from each subscribed user
tribIDs := make([][]string, len(subs))
for i := 0; i < len(subs); i++ {
if lst, err := ts.ls.GetList(util.FormatTribListKey(subs[i])); err == nil {
if len(lst) > 100 {
tribIDs[i] = lst[len(lst)-100:]
} else {
tribIDs[i] = lst
}
numTribbles += len(lst)
}
}
// lastTribs is the most recent tribble seen from each subscribed user
lastTribs := make([]tribrpc.Tribble, len(subs))
// index is the list of indexes into tribIDs for each subscribed user
index := make([]int, len(subs))
if numTribbles > 100 {
numTribbles = 100
}
finalTribbles := make([]tribrpc.Tribble, numTribbles)
var mtribble string
var tribble tribrpc.Tribble
// valid[i] marks if an unused Tribble is located at lastTribs[i]
valid := make([]bool, len(lastTribs))
for j := 0; j < numTribbles; j++ {
minIndex := -1
for check := 0; check < len(lastTribs); check++ {
// If this user has more tribbles left
if index[check] < len(tribIDs[check]) {
// If we need to get a new tribble for this user
if valid[check] == false {
mtribble, _ = ts.ls.Get(tribIDs[check][len(tribIDs[check])-1-index[check]])
json.Unmarshal([]byte(mtribble), &tribble)
lastTribs[check] = tribble
valid[check] = true
}
// This tribble is more
if minIndex == -1 || cmpLessTribble(lastTribs[check], lastTribs[minIndex]) {
minIndex = check
}
}
}
copyTribble := lastTribs[minIndex]
finalTribbles[j] = copyTribble
valid[minIndex] = false
index[minIndex] += 1
}
reply.Status = tribrpc.OK
reply.Tribbles = finalTribbles
return nil
}
func (ts *tribServer) DeleteTribble(args *tribrpc.DeleteTribbleArgs, reply *tribrpc.DeleteTribbleReply) error {
if DBG {
fmt.Println("-----> Delete(), postKey: ", args.PostKey)
}
var usrID string = args.UserID
var postKey string = args.PostKey
if DBG {
fmt.Println("Delete(), postKey: ", postKey)
}
//check if user present in server
_, err := ts.libStore.Get(util.FormatUserKey(usrID))
if err != nil {
switch err.Error() {
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
case KEY_NOT_FOUND:
reply.Status = tribrpc.NoSuchUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
}
//check if postKey is stored
_, err = ts.libStore.Get(postKey)
if err != nil {
switch err.Error() {
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
case KEY_NOT_FOUND:
reply.Status = tribrpc.NoSuchPost
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
return nil
}
}
errDelPost := ts.libStore.Delete(postKey)
errDelKey :=
ts.libStore.RemoveFromList(util.FormatTribListKey(usrID), postKey)
if errDelPost != nil {
fmt.Println("Error deleting post")
return nil
}
if errDelKey != nil {
fmt.Println("Error removing key from list")
return nil
}
reply.Status = tribrpc.OK
return nil
}
/*
-Check if user is present
-Create the tribble
-timestamp: go time
-create a tribble
-marshal it
-Appendto list that post key to the usrID
-Add to the map from post key -> marshalled tribble
*/
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
if DBG {
fmt.Println("-----> PostTribble")
}
var thisUsrId string = args.UserID
var content string = args.Contents
//check if user present in server
_, err := ts.libStore.Get(util.FormatUserKey(thisUsrId))
if err != nil {
switch err.Error() {
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
case KEY_NOT_FOUND:
reply.Status = tribrpc.NoSuchUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
//user not found
reply.Status = tribrpc.NoSuchUser
return nil
}
var timeNow time.Time = time.Now()
newTribble := tribrpc.Tribble{
UserID: thisUsrId,
Posted: timeNow,
Contents: content,
}
marshalTrib, err := json.Marshal(&newTribble)
if err != nil {
fmt.Println("Error marshalling")
//return err
}
var postKey string = util.FormatPostKey(thisUsrId, timeNow.UnixNano())
//store the tribble itself
err = ts.libStore.Put(postKey, string(marshalTrib))
if err != nil {
fmt.Println("Error putting tribble contents")
//return err
}
//store the postkey
err = ts.libStore.AppendToList(util.FormatTribListKey(thisUsrId), postKey)
if err != nil {
fmt.Println("Error putting postKey")
//return err
}
reply.PostKey = postKey
reply.Status = tribrpc.OK
return nil
}
