func HandleAddCustomEventHandlers(e *tree_event.Event, api_cmd Command) {
var (
out = &WriterCallback{BufferMaxSize: 1024}
handler_data map[string]interface{}
err tree_lib.TreeError
ev_data []byte
)
err.From = tree_lib.FROM_ADD_CUSTOM_EVENT
err.Err = ffjson.Unmarshal(api_cmd.Data, &handler_data)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
out.OutCallback = func(data []byte, ended bool) {
cb_cmd := api_cmd
cb_cmd.Ended = ended
cb_cmd.Data = data
ev_data, err.Err = ffjson.Marshal(cb_cmd)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
SendCommandCallback(e, ev_data)
}
defer out.End()
event_name := handler_data["name"].(string)
handles_interfaces := handler_data["handlers"].([]interface{})
var (
handles_interfaces_data []byte
handlers []custom_event.Handler
)
handles_interfaces_data, err.Err = ffjson.Marshal(handles_interfaces)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
err.Err = ffjson.Unmarshal(handles_interfaces_data, &handlers)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
err = custom_event.ON(event_name, handlers...)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
}
}
func main() {
r := new(RetNode)
r.Name = "sunsc"
r.Sex = "male"
r.Age = 36
buf, err := json.Marshal(r)
log.Println("err==>", err, "| buf=>", string(buf))
secr := new(ReqCardInfoType)
secr.ApiName = "test"
secr.Id = "72789765231"
secr.BizApiCode = "0005000400000001"
buf, err = json.Marshal(secr)
log.Println("err==>", err, "| buf=>", string(buf))
}
// Executing some commands using exec.Command functionality from Go in OS
func HandleExecCommand(e *tree_event.Event, api_cmd Command) {
var (
out = &WriterCallback{BufferMaxSize: 1024}
cmd_str = string(api_cmd.Data)
cmd_options = strings.Split(cmd_str, " ")
cmd = exec.Command(cmd_options[0], cmd_options[1:]...)
err tree_lib.TreeError
ev_data []byte
)
err.From = tree_lib.FROM_HANDLE_EXEC_COMMAND
out.OutCallback = func(data []byte, ended bool) {
cb_cmd := api_cmd
cb_cmd.Ended = ended
cb_cmd.Data = data
ev_data, err.Err = ffjson.Marshal(cb_cmd)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
SendCommandCallback(e, ev_data)
}
defer out.End()
cmd.Stdout = out
cmd.Stderr = out
err.Err = cmd.Run()
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
}
}
func SendCommand(cmd *Command, path *tree_graph.Path, cb func(*tree_event.Event, Command) bool) (err tree_lib.TreeError) {
// If command ID not set just setting random string
if len(cmd.ID) == 0 {
cmd.ID = tree_lib.RandomString(10)
}
var (
cmd_data []byte
)
cmd_data, err.Err = ffjson.Marshal(cmd)
if !err.IsNull() {
err.From = tree_lib.FROM_SEND_COMMAND
return
}
e := &tree_event.Event{
Name: tree_event.ON_API_COMMAND,
Data: cmd_data,
FromApi: node_info.CurrentNodeInfo.Value,
From: path.From,
}
tree_event.Emit(e, path)
if cb != nil {
subscribed_command_callbacks[cmd.ID] = cb_str{f: cb, c: make(chan bool)}
<-subscribed_command_callbacks[cmd.ID].c
}
return
}
func HandleContainerCommand(ev *tree_event.Event, cmd Command) {
var (
out = &WriterCallback{BufferMaxSize: 1024}
docker_cmd = tree_docker.DockerCmd{}
err tree_lib.TreeError
ev_data []byte
)
err.From = tree_lib.FROM_HANDLE_CONTAINER_COMMAND
err.Err = ffjson.Unmarshal(cmd.Data, &docker_cmd)
if !err.IsNull() {
tree_log.Error(err.From, "unable to unmarshal command data as a docker command -> ", err.Error())
return
}
out.OutCallback = func(data []byte, ended bool) {
cb_cmd := cmd
cb_cmd.Ended = ended
cb_cmd.Data = data
ev_data, err.Err = ffjson.Marshal(cb_cmd)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
SendCommandCallback(ev, ev_data)
}
defer out.End()
tree_docker.ContainerCommands(&docker_cmd, out)
}
func FillDatabase(listApps []App) {
for _, app := range listApps {
appdb.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte("AppBucket"))
if err != nil {
return fmt.Errorf("create bucket: %s", err)
}
serialize, err := json.Marshal(app)
if err != nil {
return fmt.Errorf("Error Marshaling data: %s", err)
}
err = b.Put([]byte(app.Guid), serialize)
if err != nil {
return fmt.Errorf("Error inserting data: %s", err)
}
return nil
})
}
}
///从数据库pull消息
func GetMsgHandler(w http.ResponseWriter, req *http.Request) {
//获取客户端通过GET/POST方式传递的参数
var retmsg string
req.ParseForm()
param1, found1 := req.Form["topic"]
param2, _ := req.Form["limit"]
if !found1 {
retmsg = "请勿非法访问"
}
topic := param1[0]
limit, err := strconv.Atoi(param2[0])
if err != nil {
retmsg = "请勿非法访问"
}
if topic != "" {
dblist := models.GetMessagesForField("topic", topic, limit)
msgjson, _ := ffjson.Marshal(dblist)
retmsg = string(msgjson)
} else {
retmsg = "topic is null"
}
io.WriteString(w, retmsg)
}
func main() {
fmt.Println("helloworld")
DbaEnvrEx := buildEnvr()
var listCard = make([]TCARD, 0)
DbaEnvrEx.Select(&listCard, "SELECT * FROM TBL_CARD")
t0 := time.Now()
//result, _ := json.Marshal(listCard)
result, _ := ffjson.Marshal(listCard)
t1 := time.Since(t0)
fmt.Println(t1)
fmt.Println(string(result))
/*
icount, ERR := DbaEnvrEx.SelectInt("SELECT COUNT(*) AS ICOUNT FROM TBL_CARD") //select count(*) as icount from tbl_card
checkErr(ERR, "NULL")
fmt.Println(icount)
*/
/*
var listData = make([]TCARD, 0)
_, eror := DbaEnvrEx.Select(&listData, "SELECT CARD_CODE,CARD_NAME,CARD_ZCTM,CARD_ZCYZ FROM TBL_CARD ORDER BY CARD_CODE")
if eror != nil {
fmt.Println(len(listData))
}
*/
}
func PostMsgHandler(w http.ResponseWriter, req *http.Request) {
//获取客户端通过GET/POST方式传递的参数
req.ParseForm()
param1, found1 := req.Form["sendmsg"]
result := NewBaseJsonBean()
if !found1 {
result.Code = -99
result.Message = "请勿非法访问"
}
fdata := param1[0]
if fdata != "" {
faction := "POST"
furl := "http://nsq-ttthzygi35.tenxcloud.net:20157/put?topic=test"
result.Code = 100
result.Message = lib.HttpDo_NSQ(faction, furl, fdata)
} else {
result.Code = 101
result.Message = "消息不能为空，请重新发送！"
}
//向客户端返回JSON数据,用到了ffjson包，据说比自带的json效率高3倍
//bytes, _ := json.Marshal(result)
bytes, _ := ffjson.Marshal(result)
io.WriteString(w, string(bytes))
}
func NetworkEmmit(e *tree_event.Event, path *tree_graph.Path) (err tree_lib.TreeError) {
var (
sdata []byte
p *big.Int
)
err.From = tree_lib.FROM_NETWORK_EMIT
// Calling get value, because maybe some one will calculate this path before calling this functions
// If path is not calculated yet, it will be automatically calculated in GetValue function
p, err = path.GetValue()
if !err.IsNull() {
return
}
// If we emitting from API then we need to multiply path with connected node
// For sending data through him
if strings.Contains(node_info.CurrentNodeInfo.Name, tree_api.API_NAME_PREFIX) {
p.Mul(p, node_info.ChildsNodeValue[path.From])
}
// If from not set, setting it before network sending
if len(e.From) == 0 {
e.From = node_info.CurrentNodeInfo.Name
}
sdata, err.Err = ffjson.Marshal(e)
if !err.IsNull() {
return
}
SendToPath(sdata, p)
return
}
func SetPathValues() (err tree_lib.TreeError) {
var (
nodes []node_info.NodeInfo
prime int64
value []byte
)
err.From = tree_lib.FROM_SET_PATH_VALUES
nodes, err = ListNodeInfos()
if !err.IsNull() {
return
}
prime = 2
for _, n := range nodes {
n.Value = prime
value, err.Err = ffjson.Marshal(n)
if !err.IsNull() {
return
}
err = Set(DB_NODE, []byte(n.Name), value)
if !err.IsNull() {
return
}
prime = tree_lib.NextPrimeNumber(prime)
}
return
}
// 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 HandleTriggerCustomEvent(e *tree_event.Event, api_cmd Command) {
var (
out = &WriterCallback{BufferMaxSize: 1024}
event_name = string(api_cmd.Data)
err tree_lib.TreeError
ev_data []byte
)
err.From = tree_lib.FROM_TRIGGER_CUSTOM_EVENT
out.OutCallback = func(data []byte, ended bool) {
cb_cmd := api_cmd
cb_cmd.Ended = ended
cb_cmd.Data = data
ev_data, err.Err = ffjson.Marshal(cb_cmd)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
SendCommandCallback(e, ev_data)
}
defer out.End()
err = custom_event.Trigger(event_name, out)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
}
}
func toJSON(o interface{}) string {
bytes, err := ffjson.Marshal(o)
if err != nil {
log.Fatal(err)
}
return string(bytes)
}
func SendDockerCommand(cmd tree_docker.DockerCmd, node string, target []string, tag []string, group []string) {
var err tree_lib.TreeError
if !tree_api.API_INIT(node) {
fmt.Println("Unable to init api client")
fmt.Println("Exiting ...")
return
}
err.From = tree_lib.FROM_SEND_DOCKER_COMMAND
var (
api_cmd = tree_api.Command{}
wait = make(chan bool)
)
api_cmd.ID = tree_lib.RandomString(20)
api_cmd.Data, err.Err = ffjson.Marshal(cmd)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
api_cmd.CommandType = tree_api.COMMAND_CONTAINER
tree_event.ON(tree_event.ON_CHILD_CONNECTED, func(ev *tree_event.Event) {
path := &tree_graph.Path{From: node, Nodes: target, Groups: group, Tags: tag}
tree_api.SendCommand(&api_cmd, path, func(e *tree_event.Event, c tree_api.Command) bool {
fmt.Println(string(c.Data))
fmt.Println(c.Ended)
if c.Ended {
return false
}
return true
})
wait <- true
})
<-wait
}
func (this *Bucket) String() string {
str, err := ffjson.Marshal(this)
if err != nil {
return "Error encoding to JSON: " + err.Error()
} else {
return string(str)
}
}
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
}
///ESM推送
func RevMsgHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
//
bytes, _ := ffjson.Marshal(lib.RevMsg)
msg := "data:" + string(bytes) + "\n\n"
io.WriteString(w, msg)
}
func TestMarshalFaster(t *testing.T) {
record := newLogFFRecord()
_, err := ffjson.MarshalFast(record)
require.NoError(t, err)
r2 := newLogRecord()
_, err = ffjson.MarshalFast(r2)
require.Error(t, err, "Record should not support MarshalFast")
_, err = ffjson.Marshal(r2)
require.NoError(t, err)
}
func main() {
t1 := time.Now()
defer func() {
fmt.Println(time.Now().Sub(t1))
}()
m := mould.Input("input1.xml", "text1.htm")
json, err := ffjson.Marshal(m)
fmt.Println(string(json), err)
mould.Output(m, "output.xml", "test2.html")
}
func parseLine(line *[]byte) {
var f nf
var t time.Time
var realRegionName, regionName string
var record *geoip2.City
err := ffjson.Unmarshal(*line, &f)
if err != nil {
*line = []byte("")
log.Error(err, "couldn't unmarshal ", *line)
return
}
if f.Srcip == nil {
log.Error("Packet without source ip, shouldn't happen: ", string(*line))
return
}
// use LRU cache
if val, ok := geoipCache.Get(*f.Srcip); ok {
record = val.(*geoip2.City)
} else {
ip := net.ParseIP(*f.Srcip)
record, _ = geoipDB.City(ip)
geoipCache.Add(*f.Srcip, record)
}
// add @timestamp with zulu (ISO8601 time)
t, _ = time.ParseInLocation(nfLayout, *f.Timestamp, myLocation)
f.Ltimestamp = t.UTC().Format(time.RFC3339Nano)
if record.Location.Longitude != 0 && record.Location.Latitude != 0 {
mylen := len(record.Subdivisions)
if mylen > 0 {
mylen--
realRegionName = record.Subdivisions[mylen].Names["en"]
regionName = record.Subdivisions[mylen].IsoCode
}
f.GeoIP.Longitude = &record.Location.Longitude
f.GeoIP.Latitude = &record.Location.Latitude
f.GeoIP.CountryName = record.Country.Names["en"]
f.GeoIP.Timezone = &record.Location.TimeZone
f.GeoIP.ContinentCode = &record.Continent.Code
f.GeoIP.CityName = record.City.Names["en"]
f.GeoIP.CountryCode2 = &record.Country.IsoCode
f.GeoIP.RealRegionName = &realRegionName
f.GeoIP.RegionName = ®ionName
f.GeoIP.IP = f.Srcip
f.GeoIP.Location = &esGeoIPLocation{f.GeoIP.Longitude, f.GeoIP.Latitude}
f.GeoIP.Coordinates = f.GeoIP.Location
}
*line, _ = ffjson.Marshal(f)
}
func (kv *KV) Set(key string, data interface{}) error {
bts, e := ffjson.Marshal(data)
if e != nil {
return e
}
e = kv.levelDb.Put([]byte(key), bts, nil)
if e != nil {
return e
}
return nil
}
// MarshalJSON will be called by json.Marshal it will return json
// representation of server's status.
func (status ServerStatus) MarshalJSON() ([]byte, error) {
var (
buffer bytes.Buffer
data []byte
err error
)
if status.Role == "master" {
data, err = ffjson.Marshal(unencodable(status))
} else {
status.Role = "slave"
data, err = ffjson.Marshal(status.BasicServerStatus)
}
err = json.Indent(&buffer, data, "", ServerStatusResponseIndentation)
if err != nil {
logger.Errorf("can't indent json %s: %s", data, err)
return data, nil
}
return buffer.Bytes(), nil
}
func SendJson(v interface{}, conn *net.TCPConn) (len int, err TreeError) {
var (
s_data []byte
)
err.From = FROM_SEND_JSON
s_data, err.Err = ffjson.Marshal(v)
if !err.IsNull() {
return
}
len, err.Err = SendMessage(s_data, conn)
return
}
// 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
}
func SetNodeInfo(name string, nf node_info.NodeInfo) (err tree_lib.TreeError) {
var (
value []byte
)
err.From = tree_lib.FROM_SET_NODE_INFO
value, err.Err = ffjson.Marshal(nf)
if !err.IsNull() {
return
}
err = Set(DB_NODE, []byte(name), value)
return
}
// 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 Index(w http.ResponseWriter, r *http.Request) {
wg := sync.WaitGroup{}
data := Data{}
var res Respslice
var c chan Resp = make(chan Resp)
var temp Resp
var keyString string
keys := r.URL.Query().Get("key")
if len(keys) != 0 {
tmp := strings.Split(keys, ",")
for _, element := range tmp {
val, found := ch.Get(element)
if !found {
keyString += `'` + element + `'`
continue
}
data.ID = element
data.Path = val.(string)
wg.Add(1)
go computationWork(&wg, data, c)
temp = <-c
res.Resps = append(res.Resps, temp)
}
if len(keyString) != 0 {
keyString = strings.Replace(keyString, `''`, `','`, -1)
// keyString= `'`+strings.Replace(keys, `,`,`','`,-1)+`'`
rows, _ := db.Query("SELECT `id`, `file_name` FROM DB.table WHERE `id` IN (" + keyString + ")")
defer rows.Close()
for rows.Next() {
_ = rows.Scan(&data.ID, &data.Path)
ch.Set(data.ID, data.Path, cache.DefaultExpiration)
wg.Add(1)
go computationWork(&wg, data, c)
temp = <-c
res.Resps = append(res.Resps, temp)
}
}
wg.Wait()
b, _ := ffjson.Marshal(res)
w.Header().Set("Content-Type", "application/json")
w.Write(b)
// ffjson.Pool(b)
}
}
func UpdateNodeChange(info node_info.NodeInfo) {
var (
ev = &tree_event.Event{}
err tree_lib.TreeError
)
err.From = tree_lib.FROM_UPDATE_NODE_CHANGE
ev.Data, err.Err = ffjson.Marshal(info)
if !err.IsNull() {
tree_log.Error(err.From, err.Error())
return
}
path := &tree_graph.Path{From: node_info.CurrentNodeInfo.Name, Nodes: []string{"*"}}
ev.Name = tree_event.ON_UPDATE_NODE_INFO
tree_event.Trigger(ev)
tree_event.Emit(ev, path)
}
func CreateOrUpdateJob(url string, job Job) (resp JobResp, err error) {
buf, err := ffjson.Marshal(&job)
if err != nil {
return
}
body, err := sendPost(url+"v1/jobs", string(buf))
if err != nil {
return
}
data := []byte(body)
err = ffjson.Unmarshal(data, &resp)
return
}