Example #1
0
/**
定时tick,把数据写入文件
**/
func EntityDump(tickTime time.Duration) {
	c := time.Tick(tickTime * time.Second)
	for _ = range c {
		//		Utils.LogInfo("%v\n", now)
		//如果在规定时间内没有更改,就不更新
		if dataChange == false {
			continue
		}
		//得到存储方式的句柄
		fd := DataStore.GetFd().(*os.File)
		//清空文件
		fd.Truncate(0)
		//得到gob转换出来的[]byte
		var wbuf bytes.Buffer
		egob := gob.NewEncoder(&wbuf)
		Utils.LogInfo("gob data=%#v\n", TaskData)
		err := egob.Encode(TaskData)
		if err != nil {
			Utils.LogInfo("data gob err")
			Utils.LogErr(err)
			continue
		}
		_, err = DataStore.Set(wbuf.Bytes())
		if err != nil {
			Utils.LogErr(err)
			continue
		}
		dataChange = false
	}
}
Example #2
0
/**
取出readyData和waitData数据
**/
func GetData() (*Entity.ReadyData, *Entity.WaitData, error) {
	//得到存储方式的句柄
	fd := DataStore.GetFd().(*os.File)
	//得到文件状态
	fileStat, err := fd.Stat()
	if err != nil {
		return nil, nil, Utils.LogErr(err)
	}
	//如果文件是空的,直接返回
	fileSize := fileStat.Size()
	if fileSize == 0 {
		return &Entity.ReadyData{}, &Entity.WaitData{}, nil
	}
	//得到文件大小的buf
	dataBuf := make([]byte, fileSize)
	//得到文件读取buf
	bufReader := DataStore.Get()
	_, err = bufReader.Read(dataBuf)
	Utils.LogInfo("read file data=%#v\n", dataBuf)
	if err != nil {
		Utils.LogInfo("err=%d\n", err)
		return nil, nil, err
	}
	//吧读到的[]byte转换成结构数据,使用全局变量TaskData
	rgob := gob.NewDecoder(bytes.NewBuffer(dataBuf))
	err = rgob.Decode(&TaskData)
	Utils.LogInfo("gob data =%v\n", TaskData)
	if err != nil {
		Utils.LogInfo("gob data err=%d\n", err)
		return nil, nil, Utils.LogErr(err)
	}
	return TaskData.ReadyData, TaskData.WaitData, nil
}
Example #3
0
/**
返回所有任务索引数组
**/
func GetAllTaskIndex() ([]Entity.TaskAddr, error) {
	bufReader := IndexStore.Get()
	var gobTypeList []Entity.TaskAddr
	for {
		var gobType Entity.TaskAddr
		dataLenBuf := make([]byte, 4)
		//得到数据体长度
		_, err := bufReader.Read(dataLenBuf)
		if err != nil {
			Utils.LogInfo("err=%d\n", err)
			if err == io.EOF {
				break
			}
			return nil, err
		}
		dataLen := Utils.BytesToUint32(dataLenBuf)
		dataBuf := make([]byte, dataLen)
		_, err = bufReader.Read(dataBuf)
		Utils.LogInfo("read file index=%#v\n", dataBuf)
		if err != nil {
			Utils.LogInfo("err=%d\n", err)
			return nil, err
		}
		rgob := gob.NewDecoder(bytes.NewBuffer(dataBuf))
		err = rgob.Decode(&gobType)
		if err != nil {
			Utils.LogInfo("gob index err=%d\n", err)
			return nil, Utils.LogErr(err)
		}
		gobTypeList = append(gobTypeList[:], gobType)
	}
	Utils.LogInfo("retn index=%#v\n", gobTypeList)
	return gobTypeList, nil
}
Example #4
0
/**
写入索引
**/
func AddIndex(dataAddr Entity.TaskAddr) (int, error) {
	//得到存储方式的句柄
	fd := IndexStore.GetFd().(*os.File)
	//得到文件状态
	fileStat, err := fd.Stat()
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	//	//得到文件大小,这个位置就是这条记录的起始位置
	dataAddr.FileAddr = fileStat.Size()
	dataAddr.EleAddr = nil
	gob.Register(dataAddr)
	//得到gob转换出来的[]byte
	var wbuf bytes.Buffer
	egob := gob.NewEncoder(&wbuf)
	Utils.LogInfo("gob index=%#v\n", dataAddr)
	err = egob.Encode(dataAddr)
	if err != nil {
		Utils.LogInfo("index gob err")
		return 0, Utils.LogErr(err)
	}
	//拼出最终存入文件的数据==数据长度+数据体
	var storeByte []byte
	storeByteBuf := bytes.NewBuffer(storeByte)
	//写入数据长度
	_, err = storeByteBuf.Write(Utils.Uint32ToBytes(uint32(wbuf.Len())))
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	_, err = storeByteBuf.Write(wbuf.Bytes())
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	wData := storeByteBuf.Bytes()
	Utils.LogInfo("len=%d\n", storeByteBuf.Len())
	Utils.LogInfo("data=%#v\n", wData)
	writeNum, err := IndexStore.Set(wData)
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	return writeNum, nil
}
Example #5
0
func (tc *TConn) ReadInt(num int) (int, error) {
	data, err := tc.Read(num)
	if err != nil {
		return 0, err
	}
	retn, err := strconv.Atoi(strings.Trim(string(data), "\r\n\t "))
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	return retn, nil
}
Example #6
0
func main() {

	tcpAddr, err := net.ResolveTCPAddr("ip4", ":9800")
	Utils.LogErr(err)

	listener, err := net.ListenTCP("tcp", tcpAddr)
	Utils.LogErr(err)
	i := 0
	readyData, waitData, err := Handle.LoadTask(Config.GetDataFile())
	if err != nil {
		Utils.LogErr(err)
		return
	}
	log.Println("load data=%v", readyData)
	for key, value := range *readyData {
		log.Printf("load ready key=%s, data=%v\n", key, value)
	}
	for key, value := range *waitData {
		log.Printf("load wait key=%s, data=%v\n", key, value)
	}

	//	taskList := make([]Entity.Task, Config.GetRoomMaxNum())
	runtime.GOMAXPROCS(runtime.NumCPU())
	//go 程处理数据写入文件
	go Store2.EntityDump(Config.GetTickTime())
	//go程处理waittask检索
	go Handle.CheckWaitTask(readyData, waitData)
	go signalHandle()
	for {
		conn, err := listener.Accept()
		if err != nil {
			Utils.LogErr(err)
			return
		}
		go Handle.HandleClient(readyData, waitData, conn)
		//		go Handle.Test(i,roomList, conn)
		//		roomChan <- roomList
		i++
	}
}
Example #7
0
/**
写入任意数据,都使用gob存入file,返回的int64,是该数据在文件中的起始位置
**/
func AddData(data Entity.TaskData) (int, error) {
	//得到存储方式的句柄
	fd := DataStore.GetFd().(*os.File)
	//得到文件状态
	fileStat, err := fd.Stat()
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	data.FileAddr = fileStat.Size()
	//得到gob转换出来的[]byte
	var wbuf bytes.Buffer
	egob := gob.NewEncoder(&wbuf)
	Utils.LogInfo("gob data=%#v\n", data)
	err = egob.Encode(data)
	if err != nil {
		Utils.LogInfo("data gob err")
		return 0, Utils.LogErr(err)
	}
	//拼出最终存入文件的数据==数据长度+数据体
	var storeByte []byte
	storeByteBuf := bytes.NewBuffer(storeByte)
	//写入数据长度
	_, err = storeByteBuf.Write(Utils.Uint32ToBytes(uint32(wbuf.Len())))
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	_, err = storeByteBuf.Write(wbuf.Bytes())
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	wData := storeByteBuf.Bytes()
	Utils.LogInfo("len=%d\n", storeByteBuf.Len())
	Utils.LogInfo("data=%#v\n", wData)
	writeNum, err := DataStore.Set(wData)
	if err != nil {
		return 0, Utils.LogErr(err)
	}
	return writeNum, nil
}
Example #8
0
func main() {
	service := ":843"
	tcpAddr, err := net.ResolveTCPAddr("ip4", service)
	Utils.LogErr(err)

	listener, err := net.ListenTCP("tcp", tcpAddr)
	Utils.LogErr(err)
	i := 0
	runtime.GOMAXPROCS(runtime.NumCPU())
	for {
		conn, err := listener.Accept()
		if err != nil {
			Utils.LogErr(err)
			return
		}
		Utils.LogInfo("start conn\n")
		go sendPolicy(conn)
		//		go Handle.Test(i,roomList, conn)
		//		roomChan <- roomList
		i++
	}
}
Example #9
0
/**
减少时间
**/
func DecExpired(readyData *Entity.ReadyData, waitData *Entity.WaitData, key string, expired uint) error {
	//如果任务已经在ready中,就不需要处理
	if readyData.Isset(key) {
		return nil
	}
	//在wait队列中的,只更新到期时间
	if waitData.Isset(key) {
		waitData.DecExpired(key, expired)
		//存储数据
		Store.SetData(readyData, waitData)
		return nil
	}
	return Utils.LogErr(1001)
}
Example #10
0
/**
删除一个任务,在两个列表里删,ready和wait
**/
func Del(readyData *Entity.ReadyData, waitData *Entity.WaitData, key string) error {
	if readyData.Isset(key) {
		readyData.Del(key)
		//存储数据
		Store.SetData(readyData, waitData)
		return nil
	}
	if waitData.Isset(key) {
		waitData.Del(key)
		//存储数据
		Store.SetData(readyData, waitData)
		return nil
	}
	return Utils.LogErr(1000)
}
Example #11
0
func sendPolicy(conn net.Conn) {
	defer conn.Close()
	str := "<cross-domain-policy><site-control permitted-cross-domain-policies=\"master-only\"/>  <allow-access-from domain=\"*\" to-ports=\"9876\" /></cross-domain-policy>"
	//	str+="\0"
	Utils.LogInfo("send data=%s\n", str)
	_, err := Utils.ReadConn(23, conn)
	if err != nil {
		Utils.LogErr(err)
	}
	bufk := bufio.NewWriter(conn)

	bufk.WriteString(str)
	//	bufk.WriteString("\\0")
	bufk.Flush()
}
Example #12
0
/**
增加任务到期时间
**/
func AddExpired(readyData *Entity.ReadyData, waitData *Entity.WaitData, key string, expired uint) error {
	//增加到期时间,就从就绪队列中删除,并添加到wait队列中
	if readyData.Isset(key) {
		waitData.Add(key, (*readyData)[key].Value, (*readyData)[key].Expired)
		readyData.Del(key)
		//存储数据
		Store.SetData(readyData, waitData)
		return nil
	}
	//在wait队列中的,只更新到期时间
	if waitData.Isset(key) {
		waitData.AddExpired(key, expired)
		//存储数据
		Store.SetData(readyData, waitData)
		return nil
	}
	return Utils.LogErr(1001)
}
Example #13
0
/**
解析从telnet发送过来的命令,每次调用,解析一个参数,以" "为分割
**/
func parseCommandWithTelnet(num int, conn net.Conn) ([]byte, error) {
	var buf [1]byte
	var data []byte
	for {
		_, err := conn.Read(buf[:])
		if err != nil {
			return nil, Utils.LogErr(err)
		}
		//		Utils.LogInfo("data=%siii\n",string(buf[:]))
		if string(buf[:]) == " " || string(buf[:]) == "\n" {
			break
		}
		data = append(data, buf[:]...)
		num--
	}
	return data, nil

}