Golang ffjson.Pool函数代码示例

// Perform a B2 API request with the provided request and response objects
func (c *B2) apiRequest(apiPath string, request interface{}, response interface{}) error {
	body, err := ffjson.Marshal(request)
	if err != nil {
		return err
	}
	defer ffjson.Pool(body)

	if c.Debug {
		log.Println("----")
		log.Printf("apiRequest: %s %s", apiPath, body)
	}

	err = c.tryAPIRequest(apiPath, body, response)

	// Retry after non-fatal errors
	if b2err, ok := err.(*B2Error); ok {
		if !b2err.IsFatal() && !c.NoRetry {
			if c.Debug {
				log.Printf("Retrying request %q due to error: %v", apiPath, err)
			}

			return c.tryAPIRequest(apiPath, body, response)
		}
	}
	return err
}

func StartMQTTSender(MQTTServerAddress string, MQTTSendChan chan *lib.PostMessage, channel_name string) chan bool {
	close_chan := make(chan bool)
	go func() {
		defer func() {
			if err := recover(); err != nil {
				utils.Log.Println(err)
				debug.PrintStack()
			}
		}()

		var post_message *lib.PostMessage
		var cli *client.Client
		var err error

		cli, err = ConnectToMQTTServer(MQTTServerAddress)
		if err != nil {
			utils.Log.Println("Connect to MQTT Server failed:", err)
			return
		}

		for {
			select {
			case <-close_chan:
				close_chan <- true
				utils.Log.Printf("Quit MQTT Sender worker.")
				return

			case post_message = <-MQTTSendChan:
				message_json_buffer, err := ffjson.Marshal(post_message)
				if err != nil {
					utils.Log.Println()
				}

				err = cli.Publish(&client.PublishOptions{
					QoS:       mqtt.QoS0,
					TopicName: []byte(channel_name),
					Message:   []byte(message_json_buffer),
				})

				if err != nil {
					utils.Log.Println("Publish to MQTT Failed:", err)
					utils.Log.Println("Try to connect MQTT Server.")
					cli, err = ConnectToMQTTServer(MQTTServerAddress)
					if err != nil {
						utils.Log.Println("Connect to MQTT Server failed:", err)
					}
				}

				utils.Log.Printf("Send message to MQTT Server: %s, Length: %d\n", MQTTServerAddress, len(message_json_buffer))

				ffjson.Pool(message_json_buffer)
			}
		}
	}()

	return close_chan
}

// Enqueue adds job to the queue.
func (c *Client) Enqueue(queue string, data ...interface{}) error {
	buf, err := ffjson.Marshal(backJob{Class: queue, Args: data})
	if err != nil {
		return err
	}
	rc := c.pool.Get()
	defer rc.Close()
	defer ffjson.Pool(buf)

	_, err = rc.Do("RPUSH", fmt.Sprintf("%vqueue:%v", c.prefix, queue), buf)
	return err

}

// send a million documents
func ffmillion(w http.ResponseWriter, r *http.Request) {

	for i := 0; i < 10000000; i++ {
		docId := i % docs.number
		item := docs.docMap[docs.docList[docId]]
		bytes, err := ffjson.Marshal(item)
		if err != nil {
			fmt.Fprintf(w, "Failed to marshal document %v", err)
			return
		}
		fmt.Fprintf(w, string(bytes)) // send data to client side
		fmt.Fprintf(w, "\n\n")
		ffjson.Pool(bytes)
	}
}

func BenchmarkMarshalJSONNativePool(b *testing.B) {
	record := newLogFFRecord()

	buf, err := json.Marshal(&record)
	if err != nil {
		b.Fatalf("Marshal: %v", err)
	}
	b.SetBytes(int64(len(buf)))

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bytes, err := ffjson.MarshalFast(record)
		if err != nil {
			b.Fatalf("Marshal: %v", err)
		}
		ffjson.Pool(bytes)
	}
}

func OnlineUsersSimpleHandler(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "channel, tourid, tag")

	var online_users_simple lib.OnlineUsersSimple
	var channel_name string

	all_channel.RLock.RLock()
	defer all_channel.RLock.RUnlock()

	channel_name = req.Header.Get("channel")
	channel_name = strings.Trim(channel_name, " ")
	if channel_name == "" {
		utils.Log.Printf("[%s] channel name not in header\n", req.RemoteAddr)
		http.Error(w, "channel name not in header", 400)
		return
	}

	channel := GetChannel(channel_name)

	online_users_simple.Length = atomic.LoadUint64(&channel.RealUserCount)
	online_users_simple.Result = 0

	buf, err := ffjson.Marshal(online_users_simple)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(buf)

	ffjson.Pool(buf)
}

func SysStatusHandler(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	var key string
	var channel *Channel
	var channel_status lib.ChannelStatus
	var channel_status_reply lib.ChannelStatusReply

	all_channel.RLock.RLock()
	defer all_channel.RLock.RUnlock()

	for key = range all_channel.Channels {
		channel = all_channel.Channels[key]
		channel_status.Name = channel.Name
		channel_status.UserCount = atomic.LoadUint64(&channel.UserCount)
		channel_status.RealUserCount = atomic.LoadUint64(&channel.RealUserCount)
		channel_status_reply.Data = append(channel_status_reply.Data, channel_status)
	}

	if len(channel_status_reply.Data) == 0 {
		channel_status_reply.Result = 0
		channel_status_reply.Data = []lib.ChannelStatus{}
	}

	buf, err := ffjson.Marshal(channel_status_reply)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s]\n", req.RemoteAddr, err)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.Write(buf)

	ffjson.Pool(buf)
}

func OnlineUsersHandlerWithTag(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "channel, tourid, tag")

	var channel_name string
	var user_state_tag_map *lib.OnlineUsersWithTag
	var ok bool

	channel_name = req.Header.Get("channel")
	if channel_name == "" {
		utils.Log.Printf("[%s] channel name not in header\n", req.RemoteAddr)
		http.Error(w, "channel name not in header", 400)
		return
	}

	channel := GetChannel(channel_name)

	channel.OnlineUsersLock.RLock()

	general_online_users := channel.GeneralOnlineUsersPool.Get().(*lib.GeneralOnlineUsers)
	temp_tag_map := general_online_users.UserTags

	for username := range channel.OnlineUsers {
		state := channel.OnlineUsers[username]

		if ServerDebug {
			utils.Log.Printf("/api/users/tags: got state: %v\n", state)
		}

		if user_state_tag_map, ok = temp_tag_map[state.Tag]; !ok {
			user_state_tag_map = channel.OnlineUsersTagPool.Get().(*lib.OnlineUsersWithTag)
			temp_tag_map[state.Tag] = user_state_tag_map
		}

		temp_tag_map[state.Tag].Length += 1
		temp_tag_map[state.Tag].UserList = append(temp_tag_map[state.Tag].UserList, username)
	}
	channel.OnlineUsersLock.RUnlock()

	general_online_users.Result = 0
	general_online_users.UserTags = temp_tag_map
	general_online_users.Timestamp = time.Now().Unix()

	buf, err := ffjson.Marshal(general_online_users)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(buf)

	ffjson.Pool(buf)

	for key := range general_online_users.UserTags {
		general_online_users.UserTags[key].Length = 0
		general_online_users.UserTags[key].UserList = make([]string, 0)
		channel.OnlineUsersTagPool.Put(general_online_users.UserTags[key])
		// delete is safe
		// because we put general_online_users into pool in the below
		delete(general_online_users.UserTags, key)
	}

	channel.GeneralOnlineUsersPool.Put(general_online_users)
}

func OnlineUsersHandler(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	var online_users lib.OnlineUsers
	var channel_name string
	var user *User
	var key string
	var now int64

	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "channel, tourid, tag")

	channel_name = req.Header.Get("channel")
	channel_name = strings.Trim(channel_name, " ")
	if channel_name == "" {
		utils.Log.Printf("[%s] channel name not in header\n", req.RemoteAddr)
		http.Error(w, "channel name not in header", 400)
		return
	}

	channel := GetChannel(channel_name)

	if USE_FASE_ONLINE_MAP == false {
		channel.ChannelRLock.RLock()

		channel_user_length := len(channel.Users)
		if channel_user_length > 0 {

			for key = range channel.Users {
				now = time.Now().Unix()
				user = channel.Users[key]
				if now-user.LastUpdate < DELAY_USER_ONLINE {
					online_users.UserList = append(online_users.UserList, key)
				}
			}

			if len(online_users.UserList) == 0 {
				online_users.UserList = []string{}
			}

		} else {
			online_users.UserList = []string{}
		}

		channel.ChannelRLock.RUnlock()

	} else {
		channel.OnlineUsersLock.RLock()
		for key = range channel.OnlineUsers {
			online_users.UserList = append(online_users.UserList, key)
		}
		channel.OnlineUsersLock.RUnlock()
	}

	online_users.Result = 0
	online_users.Length = len(online_users.UserList)

	if online_users.Length == 0 {
		online_users.UserList = []string{}
	}

	buf, err := ffjson.Marshal(online_users)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(buf)

	ffjson.Pool(buf)
}

func OnlineUsersSimpleHandler(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "channel, tourid, tag")

	var online_users_simple lib.OnlineUsersSimple
	var channel_name string
	var mqtt_users lib.MQTTSingleTopicUsers

	all_channel.RLock.RLock()
	defer all_channel.RLock.RUnlock()

	channel_name = req.Header.Get("channel")
	channel_name = strings.Trim(channel_name, " ")
	if channel_name == "" {
		utils.Log.Printf("[%s] channel name not in header\n", req.RemoteAddr)
		http.Error(w, "channel name not in header", 400)
		return
	}

	if Config.MQTTServerEnable == true {
		resp, err := http.Get("http://" + Config.MQTTServerAddress + ":18088/api/simple_topic/" + channel_name)
		if resp != nil {
			defer resp.Body.Close()
		}

		if err != nil {
			utils.Log.Printf("[%s] Get MQTT online users failed: %s, channel: [%s]\n", req.RemoteAddr, err, channel_name)
			http.Error(w, "failed to get MQTT users", 500)
			return
		}

		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			utils.Log.Printf("[%s] Read MQTT response failed: %s, channel: [%s]\n", req.RemoteAddr, err, channel_name)
			http.Error(w, "read MQTT users failed", 500)
			return
		}

		err = json.Unmarshal(body, &mqtt_users)
		if err != nil {
			utils.Log.Printf("[%s] Unmarshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
			http.Error(w, "Unmarshal json failed", 500)
			return
		}

		online_users_simple.Length = mqtt_users.Length
	}

	channel := GetChannel(channel_name)

	online_users_simple.Length += atomic.LoadUint64(&channel.RealUserCount)
	online_users_simple.Result = 0

	buf, err := ffjson.Marshal(online_users_simple)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(buf)

	ffjson.Pool(buf)
}

// 处理POST消息
func MessagePostHandler(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	var channel_name string
	var channel *Channel
	var err error
	var buf []byte

	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "channel, tourid, tag")
	w.Header().Set("Access-Control-Allow-Credentials", "true")

	channel_name = req.Header.Get("channel")
	if channel_name == "" {
		utils.Log.Printf("[%s] channel name not in header\n", req.RemoteAddr)
		http.Error(w, "channel name not in header", 400)
		return
	}

	// use byte pool
	buffer := byte_pool.Checkout()
	defer buffer.Close()
	buffer.ReadFrom(req.Body)
	body := buffer.Bytes()

	channel = GetChannel(channel_name)

	//post_message := channel.PostMessagePool.Get().(*lib.PostMessage)
	post_message := new(lib.PostMessage)

	err = ffjson.Unmarshal(body, post_message)
	if err != nil {
		utils.Log.Printf("[%s] Unmarshal json failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Unmarshal json failed", 500)
		return
	}

	if channel.PrepareClose == true {
		utils.Log.Printf("[%s] Channel: [%s] will be closed.\n", req.RemoteAddr, channel_name)
		http.Error(w, "channel will be closed or not exists", 500)
		return
	}

	message_id := utils.MakeRandomID()
	post_message.MessageID = message_id

	send_finished := false
	if post_message.Delay == 0 {
		send_finished = PostMessage(channel, post_message)
	} else {
		go PostMessage(channel, post_message)
		send_finished = true
	}

	post_reply := channel.PostReplyPool.Get().(*lib.PostReply)
	if send_finished {
		post_reply.Result = 0
		post_reply.MessageID = message_id
	} else {
		post_reply.Result = 1
		post_reply.MessageID = "message buffer of channel is full."
	}

	buf, err = ffjson.Marshal(*post_reply)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	if ServerDebug {
		utils.Log.Printf("Got message from [%s], message: [%s], message_id: [%s], channel: [%s]\n", req.RemoteAddr, string(body), message_id, channel_name)
	}

	w.Header().Set("Content-Type", "application/json")
	w.Write(buf)

	channel.PostReplyPool.Put(post_reply)
	ffjson.Pool(buf)
}

//.........这里部分代码省略.........

	user, err := channel.GetUser(user_id)
	if err != nil {
		user, err = channel.AddUser(user_id, user_tag)
		if err != nil {
			utils.Log.Printf("[%s] AddUser failed: [%s]\n", req.RemoteAddr, err)
		}
	}

	// if no new message, we wait for it
	if wait == "yes" {
		if user.NotifyChan != nil {
			select {
			case <-wheel_seconds.After(time.Duration(POLL_WAIT_TIME) * time.Second):
			case <-user.NotifyChan:
			}
		}
	}

	message_list_size := 0
	user.SpinLock.Lock()

	if user.MessageBuffer != nil {
		for i := 0; i < Config.PollMessageSize; i++ {
			if user.MessageBuffer.Len() == 0 {
				break
			}
			e := user.MessageBuffer.Front()
			if e != nil {
				if post_message, ok := user.MessageBuffer.Remove(e).(*lib.PostMessage); ok {
					if atomic.LoadUint64(&post_message.Count) > 0 {
						// got message, decrement message reference count
						message_list = append(message_list, post_message)
						message_list_size += 1
						atomic.AddUint64(&post_message.Count, ^uint64(0))

						if atomic.LoadUint64(&post_message.Count) == 0 {
							// delete message in channel's global message cache
							post_message.Lock.Lock()
							delete(channel.MessageCache, post_message.MessageID)
							post_message.Lock.Unlock()
						}
					}
				}
			}
		}
	}

	// update user's tag when tag was changed
	if CHANGE_USER_STATE_IN_REAL_TIME && user_tag != "" {
		if user_tag != user.Tag || user.Tag == "" {
			if ServerDebug {
				utils.Log.Printf("Change user [%s] tag %s->%s\n", user_id, user.Tag, user_tag)
			}
			state := channel.UserStatePool.Get().(*UserState)
			state.ID = user_id
			state.Tag = user_tag
			state.State = true
			state.From = 1
			channel.UserStateChan <- state
		}

		user.Tag = user_tag
	}

	user.LastUpdate = time.Now().Unix()
	user.SpinLock.Unlock()

	poll_message := channel.PollMessagePool.Get().(*lib.PollMessage)
	poll_message.Result = 0
	poll_message.MessageLength = len(message_list)
	if len(message_list) == 0 {
		poll_message.MessageList = []*lib.PostMessage{}
	} else {
		poll_message.MessageList = message_list
	}

	buf, err := ffjson.Marshal(*poll_message)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	if ServerDebug == true {
		utils.Log.Printf("Send message to [%s], message: [%s], channel: [%s], user_id: [%s]\n", req.RemoteAddr, string(buf), channel_name, user_id)
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(buf)

	/*
		for idx := range message_list {
			channel.PostMessagePool.Put(message_list[idx])
		}
	*/

	channel.PollMessagePool.Put(poll_message)
	ffjson.Pool(buf)
}

func MessageDeleteHandler(w http.ResponseWriter, req *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	var channel_name string
	var user_id string
	var delete_message_reply lib.DeleteMessageReply

	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "channel, tourid, tag, token, versionCode, appId")

	channel_name = req.Header.Get("channel")
	if channel_name == "" {
		utils.Log.Printf("[%s] channel name not in header\n", req.RemoteAddr)
		http.Error(w, "channel name not in header", 400)
		return
	}

	user_id = req.Header.Get("tourid")
	if user_id == "" {
		utils.Log.Printf("[%s] user_id not in header\n", req.RemoteAddr)
		http.Error(w, "user_id name not in header", 400)
		return
	}

	user_tag := req.Header.Get("tag")
	user_tag = strings.Trim(user_tag, " ")
	if user_tag == "" {
		user_tag = "UNKNOW"
		utils.Log.Printf("[%s] user: [%s] user_tag not in header\n", req.RemoteAddr, user_id)
	}

	if ServerDebug {
		utils.Log.Printf("Client [%s]: User [%s] with tag [%s]\n", req.RemoteAddr, user_id, user_tag)
	}

	channel := GetChannel(channel_name)

	user, err := channel.GetUser(user_id)
	if err != nil {
		user, err = channel.AddUser(user_id, user_tag)
		if err != nil {
			utils.Log.Printf("[%s] AddUser failed: [%s]\n", req.RemoteAddr, err)
		}
	}

	user.SpinLock.Lock()
	if user.MessageBuffer != nil {
		decr_message_ref(channel, user.MessageBuffer)
		user.MessageBuffer = user.MessageBuffer.Init()
	}

	// update user's tag when tag was changed
	if CHANGE_USER_STATE_IN_REAL_TIME && user_tag != "" {
		if user_tag != user.Tag || user.Tag == "" {
			if ServerDebug {
				utils.Log.Printf("Change user [%s] tag %s->%s\n", user_id, user.Tag, user_tag)
			}
			state := channel.UserStatePool.Get().(*UserState)
			state.ID = user_id
			state.Tag = user_tag
			state.State = true
			state.From = 1
			channel.UserStateChan <- state
		}

		user.Tag = user_tag
	}

	user.SpinLock.Unlock()

	delete_message_reply.Result = 0

	buf, err := ffjson.Marshal(delete_message_reply)
	if err != nil {
		utils.Log.Printf("[%s] Marshal JSON failed: [%s], channel: [%s]\n", req.RemoteAddr, err, channel_name)
		http.Error(w, "Marshal json failed", 500)
		return
	}

	message_buffer_len := user.MessageBuffer.Len()
	if ServerDebug == true {
		utils.Log.Printf("Delete message for [%s], channel: [%s], user_id: [%s], length: [%d]\n", req.RemoteAddr, channel_name, user_id, message_buffer_len)
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.Write(buf)

	ffjson.Pool(buf)
}