func (ts *tribServer) RemoveSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
userkey := util.FormatUserKey(args.UserID)
targetkey := util.FormatUserKey(args.TargetUserID)
usersubs := util.FormatSubListKey(args.UserID)
target := args.TargetUserID
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
// Make sure target exists
if _, et := ts.ls.Get(targetkey); et != nil {
reply.Status = tribrpc.NoSuchTargetUser
return nil
}
// Make sure user is subscribed to target
if err := ts.ls.RemoveFromList(usersubs, target); err != nil {
reply.Status = tribrpc.NoSuchTargetUser
} else {
reply.Status = tribrpc.OK
}
return nil
}
// AddSubscription adds TargerUserID to UserID's list of subscriptions.
// Replies with status NoSuchUser if the specified UserID does not exist, and NoSuchTargerUser
// if the specified TargerUserID does not exist.
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
userId := args.UserID
targetId := args.TargetUserID
userIdKey := util.FormatUserKey(userId)
targetIdKey := util.FormatUserKey(targetId)
_, ok_user := ts.libstore.Get(userIdKey)
_, ok_target := ts.libstore.Get(targetIdKey)
if ok_user != nil {
reply.Status = tribrpc.NoSuchUser
} else if ok_target != nil {
reply.Status = tribrpc.NoSuchTargetUser
} else {
subKey := util.FormatSubListKey(userId)
err := ts.libstore.AppendToList(subKey, targetId)
if err != nil {
reply.Status = tribrpc.Exists
} else {
reply.Status = tribrpc.OK
}
}
return nil
}
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
userkey := util.FormatUserKey(args.UserID)
targetkey := util.FormatUserKey(args.TargetUserID)
usersubs := util.FormatSubListKey(args.UserID)
target := args.TargetUserID
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
// Make sure targetUser exists
if _, et := ts.ls.Get(targetkey); et != nil {
reply.Status = tribrpc.NoSuchTargetUser
return nil
}
// Make sure user isn't already subscribed to target
err := ts.ls.AppendToList(usersubs, target)
if err == nil {
reply.Status = tribrpc.OK
} else {
reply.Status = tribrpc.Exists
}
return nil
}
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
userid := args.UserID
targetid := args.TargetUserID
useridkey := util.FormatUserKey(userid)
targetidkey := util.FormatUserKey(targetid)
_, userExists := ts.ls.Get(useridkey)
if userExists != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
_, targetExists := ts.ls.Get(targetidkey)
if targetExists != nil {
reply.Status = tribrpc.NoSuchTargetUser
return nil
}
userSubListKey := util.FormatSubListKey(userid)
appendErr := ts.ls.AppendToList(userSubListKey, targetid)
if appendErr != nil {
reply.Status = tribrpc.Exists
return nil
}
reply.Status = tribrpc.OK
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) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
if ts.userExist(args.UserID) == false {
reply.Status = tribrpc.NoSuchUser
return nil
}
subscriptions, err := ts.ls.GetList(util.FormatSubListKey(args.UserID))
if err != nil {
reply.Status = tribrpc.OK
reply.Tribbles = make([]tribrpc.Tribble, 0)
return nil
}
reply.Tribbles = make([]tribrpc.Tribble, 0)
mychan := make(chan []tribrpc.Tribble, 1000)
go func() {
for i := 0; i < len(subscriptions); i++ {
user := subscriptions[i]
go func() {
tribbles, _ := ts.GetAllTribblesByUser(user)
mychan <- tribbles
}()
}
}()
for i := 0; i < len(subscriptions); i++ {
tribbles := <-mychan
reply.Tribbles = append(reply.Tribbles, tribbles...)
}
reply.Status = tribrpc.OK
reply.Tribbles = prepareTribbles(reply.Tribbles)
return nil
}
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
user_id := util.FormatUserKey(args.UserID)
target_user_id := util.FormatUserKey(args.TargetUserID)
// If the user_id doesn't exist
// Return error
_, err := ts.lib_store.Get(user_id)
if err != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
// If the target_user_id doesn't exist
// Return error
_, err = ts.lib_store.Get(target_user_id)
if err != nil {
reply.Status = tribrpc.NoSuchTargetUser
return nil
}
user_sub := util.FormatSubListKey(args.UserID)
err = ts.lib_store.AppendToList(user_sub, args.TargetUserID)
if err != nil {
reply.Status = tribrpc.Exists
return nil
}
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
userkey := util.FormatUserKey(args.UserID)
_, userErr := ts.libstore.Get(userkey)
if userErr != nil {
reply.Status = tribrpc.NoSuchUser
} else {
reply.Status = tribrpc.OK
subskey := util.FormatSubListKey(args.UserID)
subsList, _ := ts.libstore.GetList(subskey)
totalTribList := make(Tribbles, 0)
for i := 0; i < len(subsList); i++ {
curUser := subsList[i]
curtribList := ts.GetTribblesOneUser(curUser)
for j := 0; j < len(curtribList); j++ {
totalTribList = append(totalTribList, curtribList[j])
}
//totalTribList = append(totalTribList, curtribList)
}
sort.Sort(totalTribList)
totalLen := len(totalTribList)
if totalLen > 100 {
totalLen = 100
}
reply.Tribbles = make(Tribbles, totalLen)
for j := 0; j < totalLen; j++ {
reply.Tribbles[j] = totalTribList[j]
}
}
return nil
}
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) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) error {
subkey := util.FormatSubListKey(args.UserID)
userkey := util.FormatUserKey(args.UserID)
_, userErr := ts.libstore.Get(userkey)
if userErr != nil {
reply.Status = tribrpc.NoSuchUser
} else {
list, _ := ts.libstore.GetList(subkey)
reply.Status = tribrpc.OK
reply.UserIDs = list
}
return nil
}
func (ts *tribServer) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) error {
if ts.userExist(args.UserID) == false {
reply.Status = tribrpc.NoSuchUser
return nil
}
UserIDs, err := ts.ls.GetList(util.FormatSubListKey(args.UserID))
if err == nil {
reply.Status = tribrpc.OK
reply.UserIDs = UserIDs
} else {
reply.Status = tribrpc.OK
reply.UserIDs = make([]string, 0)
}
return nil
}
func (ts *tribServer) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) error {
key := util.FormatUserKey(args.UserID)
if ts.checkIfKnown(key) {
sublist_key := util.FormatSubListKey(args.UserID)
sub_ids, err := ts.storage.GetList(sublist_key)
if err != nil {
sub_ids = []string{}
}
reply.UserIDs = sub_ids
reply.Status = tribrpc.OK
} else {
reply.Status = tribrpc.NoSuchUser
}
return nil
}
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
if ts.userExist(args.UserID) == false {
reply.Status = tribrpc.NoSuchUser
return nil
}
if ts.userExist(args.TargetUserID) == false {
reply.Status = tribrpc.NoSuchTargetUser
return nil
}
err := ts.ls.AppendToList(util.FormatSubListKey(args.UserID), args.TargetUserID)
if err == nil {
reply.Status = tribrpc.OK
} else {
reply.Status = tribrpc.Exists
}
return nil
}
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
user_key := util.FormatUserKey(args.UserID)
target_key := util.FormatUserKey(args.TargetUserID)
if !ts.checkIfKnown(user_key) {
reply.Status = tribrpc.NoSuchUser
} else if !ts.checkIfKnown(target_key) {
reply.Status = tribrpc.NoSuchTargetUser
} else {
sublist_key := util.FormatSubListKey(args.UserID)
err := ts.storage.AppendToList(sublist_key, args.TargetUserID)
if err != nil {
reply.Status = tribrpc.Exists
} else {
reply.Status = tribrpc.OK
}
}
return nil
}
func (ts *tribServer) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) 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("===========", err, "============")
reply.Status = tribrpc.NoSuchUser
return nil
}
user_id_list := util.FormatSubListKey(args.UserID)
user_list, err := ts.lib_store.GetList(user_id_list)
//if err != nil {
// reply.Status = tribrpc.NoSuchUser
// return nil
// }
reply.UserIDs = user_list
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) error {
userkey := util.FormatUserKey(args.UserID)
usersubs := util.FormatSubListKey(args.UserID)
// Make sure user exists
if _, eu := ts.ls.Get(userkey); eu != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
if lst, err := ts.ls.GetList(usersubs); err == nil {
reply.Status = tribrpc.OK
reply.UserIDs = lst
return nil
} else {
// The user has no subscriptions yet
reply.Status = tribrpc.OK
reply.UserIDs = make([]string, 0)
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) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) error {
userid := args.UserID
useridkey := util.FormatUserKey(userid)
_, userExists := ts.ls.Get(useridkey)
if userExists != nil {
reply.Status = tribrpc.NoSuchUser
return nil
}
userSubListKey := util.FormatSubListKey(userid)
nodes, err := ts.ls.GetList(userSubListKey)
if err != nil {
reply.Status = tribrpc.OK
reply.UserIDs = nil
return nil
}
reply.Status = tribrpc.OK
reply.UserIDs = nodes
return nil
}
func (ts *tribServer) AddSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
if DBG {
fmt.Println("-----> AddSubscription")
}
/*
-Check if user present
-Check if user being subscribed to is present
-append to list: sublist key formatter,
*/
var thisUsrId string = args.UserID
var subscrId string = args.TargetUserID
//check if this 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")
return nil
}
}
//check if subscribe user is present
_, err = ts.libStore.Get(util.FormatUserKey(subscrId))
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.NoSuchTargetUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
}
//add to list of subscribers
err = ts.libStore.AppendToList(util.FormatSubListKey(thisUsrId), subscrId)
if err != nil {
//TODO after checkpoint, case on err
reply.Status = tribrpc.Exists
return nil
}
/* no error */
reply.Status = tribrpc.OK
return nil
}
func (ts *tribServer) GetSubscriptions(args *tribrpc.GetSubscriptionsArgs, reply *tribrpc.GetSubscriptionsReply) error {
if DBG {
fmt.Println("-----> GetSubscriptions")
}
/*
formatsublistkey
*/
var thisUsrId string = args.UserID
//check if user present in server
_, err := ts.libStore.Get(util.FormatUserKey(thisUsrId))
if err != nil {
switch err.Error() {
case KEY_NOT_FOUND:
reply.Status = tribrpc.NoSuchUser
return nil
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
default:
fmt.Println("ERROR in tribserver: wrong error message received")
return errors.New("WRONG error message")
}
//user not found
reply.Status = tribrpc.NoSuchUser
//return err
return nil
}
subscrList, err := ts.libStore.GetList(util.FormatSubListKey(thisUsrId))
if err == nil {
reply.Status = tribrpc.OK
reply.UserIDs = subscrList
return nil
}
//error not nil
switch err.Error() {
case KEY_NOT_FOUND:
//User present, no subscriptions
reply.Status = tribrpc.OK
//Empty list of user IDs
reply.UserIDs = make([]string, 0)
return nil
break
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return nil
break
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
return nil
}
/*
check if both values exist, then delete the sub
*/
func (ts *tribServer) RemoveSubscription(args *tribrpc.SubscriptionArgs, reply *tribrpc.SubscriptionReply) error {
if DBG {
fmt.Println("-----> RemoveSubscription")
}
var thisUsrId string = args.UserID
var subscrId string = args.TargetUserID
//check if this 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")
}
}
//check if subscribe user is present
_, err = ts.libStore.Get(util.FormatUserKey(subscrId))
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.NoSuchTargetUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
return nil
}
}
//retrieve list of subsriber user IDs
err = ts.libStore.RemoveFromList(util.FormatSubListKey(thisUsrId), subscrId)
if err == nil {
reply.Status = tribrpc.OK
return nil
}
switch err.Error() {
case ITEM_NOT_FOUND:
//User present, no subscriptions
reply.Status = tribrpc.NoSuchTargetUser
//Empty list of user IDs
return nil
case WRONG_SERVER:
fmt.Println("ERROR: WRONG SERVER in tribserver")
return errors.New("Wrong server contacted!")
case KEY_NOT_FOUND:
fmt.Println("TribServ: Key was not found!")
reply.Status = tribrpc.NoSuchTargetUser
return nil
default:
fmt.Println("ERROR in tribserver: wrong error message received")
}
if err != nil {
//TODO after checkpoint, case on err
reply.Status = tribrpc.NoSuchTargetUser
return nil
}
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
}
