Golang tribrpc.PostTribbleReply类代码示例

func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
	user := args.UserID

	_, err := ts.Libstore.Get(user)
	switch err {
	case nil: // expected case, do nothing
	case libstore.ErrorKeyNotFound:
		reply.Status = tribrpc.NoSuchUser
		return nil
	default:
		return err
	}

	tribValue := makeTribValue(args.Contents)

	tribHash := makeTribHash(tribValue)
	tribListKey := makeTribListKey(user)

	// insert hash value as tribble ID to user tribbles list
	err = ts.Libstore.AppendToList(tribListKey, tribHash)
	if err != nil {
		return err
	}

	// then insert mapping from unique Id in each user to tribble value
	tribId := makeTribId(user, tribHash)

	err = ts.Libstore.Put(tribId, tribValue)
	if err != nil {
		return err
	}

	reply.Status = tribrpc.OK
	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
}

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 {
	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
}

/*A well-written implementation will not store a gigantic list of all
Tribbles for a user in a single key/value entry. Your system should be able to handle
users with thousands of Tribbles without excessive bloat or slowdown. We suggest
storing a list of Tribble IDs (which you will have to define) in some way, and then
storing each Tribble as a separate key/value item stored on the same partition as the
user ID.
Assuming you implement your storage server in this way, we recommend using the Get/Put methods
to store Tribbles and the AppendToList/RemoveFromList methods to store lists of IDs that reference the
actual Tribble objects.*/
func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
	LOGE.Printf("PostTribble:: args=%s\n", string(marshal(*args)))
	userIDKey := GetUserKey(args.UserID)
	_, err := ts.lib.Get(userIDKey)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	var trible tribrpc.Tribble
	trible.UserID = args.UserID
	trible.Posted = time.Now()
	trible.Contents = args.Contents

	tribleIDKey := GetTribelPutKey(args.UserID, strconv.Itoa(ts.index), ts.hostPort)
	tribleValue, err := json.Marshal(trible)

	err = ts.lib.Put(tribleIDKey, string(tribleValue))
	if err != nil {
		reply.Status = tribrpc.Exists
		return nil
	}
	userTribleListKey := GetsTribleListKey(args.UserID)

	err = ts.lib.AppendToList(userTribleListKey, tribleIDKey)
	if err != nil {
		reply.Status = tribrpc.Exists
		return nil
	}

	reply.Status = tribrpc.OK
	ts.index++
	LOGE.Printf("PostTribble:: reply=%s\n", string(marshal(reply)))
	return nil
}

func (ts *tribServer) PostTribble(args *tribrpc.PostTribbleArgs, reply *tribrpc.PostTribbleReply) error {
	fmt.Println(args.Contents)
	UserKey := GenerateUserKey(args.UserID)

	_, err := ts.lib.Get(UserKey)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	TribListKey := GenerateTribListKey(args.UserID)

	//err = ts.lib.AppendToList(TribListKey, strconv.Itoa(ts.id))
	//if err != nil {
	//	reply.Status = tribrpc.Exists
	//	return nil
	//}

	var trib tribrpc.Tribble
	trib.UserID = args.UserID
	trib.Posted = time.Now()
	trib.Contents = args.Contents

	TribIDKey := GenerateTribIDKey(args.UserID, strconv.Itoa(ts.id), ts.hostport)
	val, _ := json.Marshal(trib)

	err = ts.lib.Put(TribIDKey, string(val))
	if err != nil {
		reply.Status = tribrpc.Exists
		fmt.Println("trib id already exist!")
		return nil
	}

	err = ts.lib.AppendToList(TribListKey, TribIDKey)
	if err != nil {
		reply.Status = tribrpc.Exists
		return nil
	}

	reply.Status = tribrpc.OK
	ts.id++
	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) 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) 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
}

/*
	-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
}