初始化项目

trunk/framework/managecenterMgr/area.go

@@ -0,0 +1,174 @@
+package managecenterMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"Framework/managecenterModel"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+var (
+	areaMap  = make(map[int32]*Area, 128)
+	areaHash string
+)
+
+// 重新加载大区数据
+func reloadArea(isInit bool) error {
+	//logUtil.DebugLog("开始刷新大区列表")
+
+	// 连接服务器，以获取数据
+	url := getManageCenterUrl("/API/AreaList.ashx")
+
+	// 定义请求参数
+	postDict := make(map[string]string)
+	postDict["HashValue"] = areaHash
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, nil)
+	if err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取大区列表出错，url:%s,错误信息为:%s", url, err))
+		return err
+	}
+	if statusCode != 200 {
+		logUtil.ErrorLog(fmt.Sprintf("获取大区列表出错，url:%s,错误码为:%d", url, statusCode))
+		return err
+	}
+
+	// 解析返回值
+	returnObj := new(ReturnObject)
+	if err = json.Unmarshal(returnBytes, &returnObj); err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取大区列表出错，反序列化返回值出错，错误信息为：%s, str:%s", err, string(returnBytes)))
+		return err
+	}
+
+	// 判断返回状态是否为成功
+	if returnObj.Code != 0 {
+		// 数据没有变化，所以没有获取到新的数据，不能算错误。
+		if returnObj.Code == 47 || returnObj.Message == "DataNotChanged" {
+			//如果本地集合为空，且数据又没变化时，重新初始化一下本地hash值
+			if len(areaMap) == 0 {
+				areaHash = ""
+			}
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取大区列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	tmpAreaList := make([]*Area, 0, 128)
+	if data, ok := returnObj.Data.(string); !ok {
+		msg := "获取大区列表出错，返回的数据不是string类型"
+		logUtil.ErrorLog(msg)
+		return errors.New(msg)
+	} else {
+		if err = json.Unmarshal([]byte(data), &tmpAreaList); err != nil {
+			logUtil.ErrorLog(fmt.Sprintf("获取大区列表出错，反序列化数据出错，错误信息为：%s", err))
+			return err
+		}
+	}
+
+	//logUtil.DebugLog(fmt.Sprintf("刷新大区信息结束，大区数量:%d", len(tmpAreaList)))
+
+	tmpAreaMap := make(map[int32]*Area)
+	for _, item := range tmpAreaList {
+		tmpAreaMap[item.AreaId] = item
+	}
+
+	// 赋值给最终的areaMap
+	areaMap = tmpAreaMap
+	areaHash = returnObj.HashValue
+
+	// 通知变更
+	mcDataChangeCallBack(managecenterModel.AreaData, isInit)
+
+	return nil
+}
+
+// 根据区服ID获取所属大区ID
+func GetAreaIdByServerId(serverId int32) (areaId int32, exist bool) {
+	for _, item := range areaMap {
+		if item.CheckServerIdIsInRange(serverId) {
+			areaId = item.AreaId
+			exist = true
+			return
+		}
+	}
+
+	return
+}
+
+// 根据服务器组id获取大区对象数据
+func GetAreaDBByGroupId(groupId int32) (areaDB *Area, exist bool) {
+	//如果没有大区数据，返回空
+	exist = false
+	if areaMap == nil || len(areaMap) < 1 {
+		return
+	}
+
+	for _, item := range areaMap {
+		if item.CheckServerIdIsInRange(groupId) {
+			areaDB = item
+			exist = true
+			break
+		}
+	}
+	return
+}
+
+// 获取所有大区信息
+func GetAllAreaDB() []*Area {
+	tempList := make([]*Area, 8)
+	for _, item := range areaMap {
+		tempList = append(tempList, item)
+	}
+	return tempList
+}
+
+// 根据大区ID获取大区信息
+func GetAreaDBbyAreaID(areaId int32) (areaDB *Area, exist bool) {
+	//如果没有大区数据，返回空
+	exist = false
+	if areaMap == nil || len(areaMap) < 1 {
+		return
+	}
+
+	if item, ok := areaMap[areaId]; ok {
+		areaDB = item
+		exist = true
+	}
+	return
+}
+
+// 根据服务器ID获取大区页签信息
+func GetAreaLabelDBByGroupId(groupId int32) (areaLabelDB *AreaLabel, exist bool) {
+	areaDB, exist := GetAreaDBByGroupId(groupId)
+	if !exist {
+		return nil, false
+	}
+	if areaDB.AreaLabelList == nil || len(areaDB.AreaLabelList) < 1 {
+		return nil, false
+
+	}
+	//校服务器ID是否在大区页签服务器范围内
+	for _, item := range areaDB.AreaLabelList {
+		if exist := item.CheckServerIdIsInLabelRange(groupId); exist {
+			return item, true
+		}
+	}
+
+	//如果没找到，则返回空
+	return nil, false
+}

trunk/framework/managecenterMgr/doc.go

@@ -0,0 +1,7 @@
+package managecenterMgr
+
+// ManageCenter的管理包，提供管理合作商、服务器、服务器组、游戏资源、白名单等功能
+
+// 使用方法：
+// 首先调用Start方法，这样会进行初始化，后续就可以使用提供的其它方法
+// 内部会定时去ManageCenter刷新最新的数据

trunk/framework/managecenterMgr/managecenter.go

@@ -0,0 +1,137 @@
+package managecenterMgr
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"Framework/goroutineMgr"
+	"Framework/initMgr"
+	"Framework/managecenterModel"
+	"goutil/logUtil"
+)
+
+var (
+	mcAPIUrl        string
+	mcDataSwitchObj *ManageCenterDataSwitch
+	initSuccessObj  = initMgr.NewInitSuccess("managecenterMgr")
+
+	//数据变更通知回调
+	mDataChangeCallBackFunc func(managecenterModel.MCDataType) error
+)
+
+// 注册初始化成功的通道
+// name:模块名称
+// ch:通道对象
+func RegisterInitSuccess(name string, ch chan bool) {
+	initSuccessObj.Register(name, ch)
+}
+
+// 注册MC数据变更通知回调函数
+// handler:回调方法
+func RegisterDataChangeCallBackFunc(handler func(managecenterModel.MCDataType) error) {
+	mDataChangeCallBackFunc = handler
+}
+
+// Start ...启动ManageCenter管理器
+// manageCenterAPIUrl:ManageCenter对外提供的API
+// manageCenterDataSwitchObj:ManageCenter数据获取开关对象
+func Start(manageCenterAPIUrl string, manageCenterDataSwitchObj *ManageCenterDataSwitch) {
+	mcAPIUrl = manageCenterAPIUrl
+	mcDataSwitchObj = manageCenterDataSwitchObj
+
+	// 先初始化一次数据
+	if err := reload(true); err != nil {
+		panic(err)
+	}
+
+	// 通知初始化成功
+	initSuccessObj.Notify()
+
+	// 定时刷新数据
+	go func() {
+		goroutineName := "managecenterMgr.timelyRefresh"
+		goroutineMgr.Monitor(goroutineName)
+		defer goroutineMgr.ReleaseMonitor(goroutineName)
+
+		for {
+			// 每5秒刷新一次
+			time.Sleep(5 * time.Second)
+
+			// 刷新服务器组
+			reload(false)
+		}
+	}()
+}
+
+// 重新加载/初始化
+func reload(isInit bool) error {
+	var err error
+
+	// 加载合作商数据
+	if mcDataSwitchObj.AllDataSwitch || mcDataSwitchObj.PartnerDataSwitch {
+		if err = reloadPartner(isInit); err != nil && isInit {
+			return err
+		}
+	}
+
+	// 加载服务器数据
+	if mcDataSwitchObj.AllDataSwitch || mcDataSwitchObj.ServerDataSwitch {
+		if err = reloadServer(isInit); err != nil && isInit {
+			return err
+		}
+	}
+
+	// 加载服务器组数据
+	if mcDataSwitchObj.AllDataSwitch || mcDataSwitchObj.ServerGroupDataSwitch {
+		if err = reloadServerGroup(isInit); err != nil && isInit {
+			return err
+		}
+	}
+
+	// 加载资源数据
+	if mcDataSwitchObj.AllDataSwitch || mcDataSwitchObj.ResourceVersionDataSwitch {
+		if err = reloadResourceVersion(isInit); err != nil && isInit {
+			return err
+		}
+	}
+
+	// 加载玩家白名单数据
+	if mcDataSwitchObj.AllDataSwitch || mcDataSwitchObj.WhiteListDataSwitch {
+		if err = reloadWhiteList(isInit); err != nil && isInit {
+			return err
+		}
+	}
+
+	// 加载大区数据
+	if mcDataSwitchObj.AllDataSwitch || mcDataSwitchObj.AreaDataSwitch {
+		if err = reloadArea(isInit); err != nil && isInit {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// 获取可访问的ManageCenter地址
+// suffix:Url后缀
+// 返回值:
+// 可访问的ManageCenter地址
+func getManageCenterUrl(suffix string) string {
+	return fmt.Sprintf("%s/%s", strings.TrimRight(mcAPIUrl, "/"), strings.TrimLeft(suffix, "/"))
+}
+
+// 回调
+// dataType:数据类型
+// isInit:是否初始化
+func mcDataChangeCallBack(dataType managecenterModel.MCDataType, isInit bool) {
+	//如果没注册回调函数，或者是数据初始化，则不回调
+	if mDataChangeCallBackFunc == nil || isInit {
+		return
+	}
+
+	//回调
+	err := mDataChangeCallBackFunc(dataType)
+
+	logUtil.ErrorLog(fmt.Sprintf("通知回调出错，DataType:%d,错误信息为:%s", dataType, err))
+}

trunk/framework/managecenterMgr/managecenterDataSwitch.go

@@ -0,0 +1,25 @@
+package managecenterMgr
+
+// ManageCenter数据获取开关(每一类数据一个开关)
+type ManageCenterDataSwitch struct {
+	// 获取所有数据开关（只要这个开关值为true，则不论各类数据的开关是否打开，都获取数据）
+	AllDataSwitch bool
+
+	// 获取合作商数据开关
+	PartnerDataSwitch bool
+
+	// 获取服务器数据开关
+	ServerDataSwitch bool
+
+	// 获取服务器组数开关
+	ServerGroupDataSwitch bool
+
+	// 获取资源包版本数据开关
+	ResourceVersionDataSwitch bool
+
+	// 获取白名单数据开关
+	WhiteListDataSwitch bool
+
+	// 获取大区数据开关
+	AreaDataSwitch bool
+}

trunk/framework/managecenterMgr/managecenter_test.go

@@ -0,0 +1,132 @@
+package managecenterMgr
+
+import (
+	"fmt"
+	"testing"
+)
+
+func init() {
+	manageCenterDataSwitchObj := &ManageCenterDataSwitch{
+		AllDataSwitch: true,
+	}
+	Start("https://managecenterapi-sd3.7qule.com/", manageCenterDataSwitchObj)
+
+	item, exist := GetAreaLabelDBByGroupId(82)
+	if exist {
+		fmt.Printf("%v", item)
+	}
+}
+
+func TestPartner(t *testing.T) {
+	partnerList := GetPartnerList()
+	fmt.Printf("PartnerList count:%v\n", len(partnerList))
+	if len(partnerList) == 0 {
+		t.Errorf("There is no partner.")
+		return
+	}
+
+	firstPartner := partnerList[0]
+	_, exist := GetPartner(firstPartner.Id)
+	if !exist {
+		t.Errorf("Partner with Id:%d should exist, but now it doesn't.", firstPartner.Id)
+		return
+	}
+
+	_, exist = GetPartnerByAlias(firstPartner.Alias)
+	if !exist {
+		t.Errorf("Partner with Alias:%s should exist, but now it doesn't.", firstPartner.Alias)
+		return
+	}
+
+	_, exist, err := GetOtherConfigInfo(firstPartner.Id, "LoginHandler")
+	if err != nil {
+		t.Errorf("There should no error for Partner:%d, but now there is one:%v", err, firstPartner.Id)
+		return
+	}
+	if !exist {
+		t.Errorf("Partner with Id:%d should have an other config named LoginHandler, but now there isn't.", firstPartner.Id)
+		return
+	}
+}
+
+func TestServer(t *testing.T) {
+	serverGroupList := GetServerGroupList()
+	if len(serverGroupList) == 0 {
+		t.Errorf("There is no ServerGroup.")
+		return
+	}
+	firstServerGroup := serverGroupList[0]
+
+	serverList := GetServerListByGroupId(firstServerGroup.Id)
+	fmt.Printf("There are %d servers of GroupId:%d\n", len(serverList), firstServerGroup.Id)
+
+	firstServer := serverList[0]
+	serverList = GetServerListByPartnerId(firstServer.PartnerId)
+	fmt.Printf("There are %d servers of PartnerId:%d\n", len(serverList), firstServer.PartnerId)
+
+	_, exist := GetServerItem(firstServer.PartnerId, firstServer.Id)
+	if !exist {
+		t.Errorf("There is no server with PartnerId:%d, ServerId:%d.", firstServer.PartnerId, firstServer.Id)
+		return
+	}
+
+	distinctServerIdList := GetDistinctServerIdList()
+	fmt.Printf("There are %d distinct ServerId\n", len(distinctServerIdList))
+}
+
+func TestServerGroup(t *testing.T) {
+	serverGroupList := GetServerGroupList()
+	if len(serverGroupList) == 0 {
+		t.Errorf("There is no ServerGroup.")
+		return
+	}
+
+	firstServerGroup := serverGroupList[0]
+	_, exist := GetServerGroupItem(firstServerGroup.Id)
+	if !exist {
+		t.Errorf("The ServerGroup with Id:%d should exist, but now it doesn't.", firstServerGroup.Id)
+		return
+	}
+
+	serverList := GetServerListByGroupId(firstServerGroup.Id)
+	if len(serverList) == 0 {
+		t.Errorf("There is no server of ServerGroupId:%d", firstServerGroup.Id)
+		return
+	}
+	firstServer := serverList[0]
+	_, _, exist = GetServerGroup(firstServer.PartnerId, firstServer.Id)
+	if !exist {
+		t.Errorf("The ServerGroup with PartnerId:%d, ServerId:%d should exist, but now it doesn't.", firstServer.PartnerId, firstServer.Id)
+		return
+	}
+}
+
+func TestResourceVersion(t *testing.T) {
+	list := GetResourceVersionList()
+	fmt.Printf("There are %d resource versions.\n", len(list))
+}
+
+func TestUserWhiteList(t *testing.T) {
+	fmt.Printf("There are %d whiteLists.\n", len(whiteListMap))
+	if len(whiteListMap) == 0 {
+		return
+	}
+
+	var partnerId int32
+	var userId string
+	for _, v := range whiteListMap {
+		for _, _v := range v {
+			partnerId = _v.PartnerId
+			userId = _v.UserId
+			break
+		}
+		break
+	}
+
+	expected := true
+	got := IsInWhiteList(partnerId, userId)
+	if got != expected {
+		t.Errorf("Expected to get %t, but got %t", expected, got)
+		return
+	}
+}

trunk/framework/managecenterMgr/partner.go

@@ -0,0 +1,158 @@
+package managecenterMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"Framework/managecenterModel"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+var (
+	partnerMap  = make(map[int32]*Partner, 128)
+	partnerHash string
+)
+
+// 重新加载合作商
+func reloadPartner(isInit bool) error {
+	//logUtil.DebugLog("开始刷新合作商列表")
+
+	// 连接服务器，以获取数据
+	url := getManageCenterUrl("/API/PartnerList.ashx")
+
+	// 定义请求参数
+	postDict := make(map[string]string)
+	postDict["HashValue"] = partnerHash
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, nil)
+	if err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取合作商列表出错，url:%s,错误信息为:%s", url, err))
+		return err
+	}
+	if statusCode != 200 {
+		logUtil.ErrorLog(fmt.Sprintf("获取合作商列表出错，url:%s,错误码为:%d", url, statusCode))
+		return err
+	}
+
+	// 解析返回值
+	returnObj := new(ReturnObject)
+	if err = json.Unmarshal(returnBytes, &returnObj); err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取合作商列表出错，反序列化返回值出错，错误信息为：%s, str:%s", err, string(returnBytes)))
+		return err
+	}
+
+	// 判断返回状态是否为成功
+	if returnObj.Code != 0 {
+		// 数据没有变化，所以没有获取到新的数据，不能算错误。
+		if returnObj.Code == 47 || returnObj.Message == "DataNotChanged" {
+			//如果本地集合为空，且数据又没变化时，重新初始化一下本地hash值
+			if len(partnerMap) == 0 {
+				partnerHash = ""
+			}
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取合作商列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	tmpPartnerList := make([]*Partner, 0, 128)
+	if data, ok := returnObj.Data.(string); !ok {
+		msg := "获取合作商列表出错，返回的数据不是string类型"
+		logUtil.ErrorLog(msg)
+		return errors.New(msg)
+	} else {
+		if err = json.Unmarshal([]byte(data), &tmpPartnerList); err != nil {
+			logUtil.ErrorLog(fmt.Sprintf("获取合作商列表出错，反序列化数据出错，错误信息为：%s", err))
+			return err
+		}
+	}
+
+	//logUtil.DebugLog(fmt.Sprintf("刷新合作商信息结束，合作商数量:%d", len(tmpPartnerList)))
+
+	tmpPartnerMap := make(map[int32]*Partner)
+	for _, item := range tmpPartnerList {
+		tmpPartnerMap[item.Id] = item
+	}
+
+	// 赋值给最终的partnerMap
+	partnerMap = tmpPartnerMap
+	partnerHash = returnObj.HashValue
+
+	//通知变更
+	mcDataChangeCallBack(managecenterModel.PartnerData, isInit)
+	return nil
+}
+
+// 获取合作商对象列表
+// 返回值:
+// 合作商对象列表
+func GetPartnerList() (partnerList []*Partner) {
+	for _, item := range partnerMap {
+		partnerList = append(partnerList, item)
+	}
+
+	return
+}
+
+// 根据合作商Id获取合作商对象
+// id：合作商Id
+// 返回值：
+// 合作商对象
+// 是否存在
+func GetPartner(id int32) (partnerObj *Partner, exist bool) {
+	partnerObj, exist = partnerMap[id]
+	return
+}
+
+// 根据合作商别名获取合作商对象
+// alias:合作商别名
+// 返回值：
+// 合作商对象
+// 是否存在
+func GetPartnerByAlias(alias string) (partnerObj *Partner, exist bool) {
+	for _, item := range partnerMap {
+		if item.Alias == alias {
+			partnerObj = item
+			exist = true
+			return
+		}
+	}
+
+	return
+}
+
+// 获取合作商的其它配置信息
+// id:合作商Id
+// configKey:其它配置Key
+// 返回值
+// 配置内容
+// 是否存在
+// 错误对象
+func GetOtherConfigInfo(id int32, configKey string) (configValue string, exist bool, err error) {
+	partnerObj, exist := GetPartner(id)
+	if !exist {
+		return
+	}
+
+	var otherConfigMap map[string]string
+	otherConfigMap, err = partnerObj.ResolveOtherConfig()
+	if err != nil {
+		return
+	}
+
+	configValue, exist = otherConfigMap[configKey]
+	return
+}

trunk/framework/managecenterMgr/resourceVersion.go

@@ -0,0 +1,100 @@
+package managecenterMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"Framework/managecenterModel"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+var (
+	resourceVersionList = make([]*ResourceVersion, 128)
+	resourceVersionHash string
+)
+
+// 重新加载资源列表
+func reloadResourceVersion(isInit bool) error {
+	//logUtil.DebugLog("开始刷新资源列表")
+
+	// 连接服务器，以获取数据
+	url := getManageCenterUrl("/API/ResourceVersionList.ashx")
+
+	// 定义请求参数
+	postDict := make(map[string]string)
+	postDict["HashValue"] = resourceVersionHash
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, nil)
+	if err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取资源列表出错，url:%s,错误信息为:%s", url, err))
+		return err
+	}
+	if statusCode != 200 {
+		logUtil.ErrorLog(fmt.Sprintf("获取资源列表出错，url:%s,错误码为:%d", url, statusCode))
+		return err
+	}
+
+	// 解析返回值
+	returnObj := new(ReturnObject)
+	if err = json.Unmarshal(returnBytes, &returnObj); err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取资源列表出错，反序列化返回值出错，错误信息为：%s, str:%s", err, string(returnBytes)))
+		return err
+	}
+
+	// 判断返回状态是否为成功
+	if returnObj.Code != 0 {
+		// 数据没有变化，所以没有获取到新的数据，不能算错误。
+		if returnObj.Code == 47 || returnObj.Message == "DataNotChanged" {
+			//如果本地集合为空，且数据又没变化时，重新初始化一下本地hash值
+			if len(resourceVersionList) == 0 {
+				resourceVersionHash = ""
+			}
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取资源列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	tmpResourceVersionList := make([]*ResourceVersion, 0, 128)
+	if data, ok := returnObj.Data.(string); !ok {
+		msg := "获取资源列表出错，返回的数据不是string类型"
+		logUtil.ErrorLog(msg)
+		return errors.New(msg)
+	} else {
+		if err = json.Unmarshal([]byte(data), &tmpResourceVersionList); err != nil {
+			logUtil.ErrorLog(fmt.Sprintf("获取资源列表出错，反序列化数据出错，错误信息为：%s", err))
+			return err
+		}
+	}
+
+	//logUtil.DebugLog(fmt.Sprintf("刷新资源信息结束，资源数量:%d", len(tmpResourceVersionList)))
+
+	// 赋值给最终的partnerMap
+	resourceVersionList = tmpResourceVersionList
+	resourceVersionHash = returnObj.HashValue
+
+	//通知变更
+	mcDataChangeCallBack(managecenterModel.ResourceVersionData, isInit)
+
+	return nil
+}
+
+// 获取资源包列表
+// 返回值:
+// 获取资源包列表
+func GetResourceVersionList() []*ResourceVersion {
+	return resourceVersionList
+}

trunk/framework/managecenterMgr/server.go

@@ -0,0 +1,175 @@
+package managecenterMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"Framework/managecenterModel"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+var (
+	serverMap         = make(map[int32]map[int32]*Server, 128)
+	serverDistinctMap = make(map[int32]*Server, 1024)
+	serverHash        string
+)
+
+// 重新加载服务器
+func reloadServer(isInit bool) error {
+	//logUtil.DebugLog("开始刷新服务器列表")
+
+	url := getManageCenterUrl("/API/ServerList.ashx")
+
+	// 定义请求参数
+	postDict := make(map[string]string)
+	postDict["GroupType"] = "Mix"
+	postDict["HashValue"] = serverHash
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, nil)
+	if err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取服务器列表出错，url:%s,错误信息为:%s", url, err))
+		return err
+	}
+	if statusCode != 200 {
+		logUtil.ErrorLog(fmt.Sprintf("获取服务器列表出错，url:%s,错误码为:%d", url, statusCode))
+		return err
+	}
+
+	// 解析返回值
+	returnObj := new(ReturnObject)
+	if err = json.Unmarshal(returnBytes, &returnObj); err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取服务器列表出错，反序列化返回值出错，错误信息为：%s, str:%s", err, string(returnBytes)))
+		return err
+	}
+
+	// 判断返回状态是否成功
+	if returnObj.Code != 0 {
+		// 数据没有变化，所以没有获取到新的数据，不能算错误。
+		if returnObj.Code == 47 || returnObj.Message == "DataNotChanged" {
+			//如果本地集合为空，且数据又没变化时，重新初始化一下本地hash值
+			if len(serverMap) == 0 {
+				serverHash = ""
+			}
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取服务器列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	tmpServerList := make([]*Server, 0, 1024)
+	if data, ok := returnObj.Data.(string); !ok {
+		msg := "获取服务器列表出错，返回的数据不是string类型"
+		logUtil.ErrorLog(msg)
+		return errors.New(msg)
+	} else {
+		if err = json.Unmarshal([]byte(data), &tmpServerList); err != nil {
+			logUtil.ErrorLog(fmt.Sprintf("获取服务器列表出错，反序列化数据出错，错误信息为：%s", err))
+			return err
+		}
+	}
+
+	//logUtil.DebugLog(fmt.Sprintf("刷新服务器信息结束，服务器数量:%d", len(tmpServerList)))
+
+	tmpServerMap := make(map[int32]map[int32]*Server, 128)
+	tmpServerDistinctMap := make(map[int32]*Server, 1024)
+	for _, item := range tmpServerList {
+		// 构造tmpServerMap数据
+		if _, ok := tmpServerMap[item.PartnerId]; !ok {
+			tmpServerMap[item.PartnerId] = make(map[int32]*Server, 1024)
+		}
+		tmpServerMap[item.PartnerId][item.Id] = item
+
+		// 构造tmpServerDistinctMap数据
+		tmpServerDistinctMap[item.Id] = item
+	}
+
+	// 赋值给最终的serverMap、serverDistinctMap
+	serverMap = tmpServerMap
+	serverDistinctMap = tmpServerDistinctMap
+	serverHash = returnObj.HashValue
+
+	//通知变更
+	mcDataChangeCallBack(managecenterModel.ServerData, isInit)
+
+	return nil
+}
+
+// 根据服务器组Id获取对应的服务器列表
+// serverGroupId:服务器组Id
+// 返回值:
+// 服务器列表
+func GetServerListByGroupId(serverGroupId int32) (serverList []*Server) {
+	for _, subServerMap := range serverMap {
+		for _, item := range subServerMap {
+			if item.GroupId == serverGroupId {
+				serverList = append(serverList, item)
+			}
+		}
+	}
+
+	return
+}
+
+// 根据合作商Id获取对应的服务器列表
+// partnerId:合作商Id
+// 返回值:
+// 服务器列表
+func GetServerListByPartnerId(partnerId int32) (serverList []*Server) {
+	for _, item := range serverMap[partnerId] {
+		serverList = append(serverList, item)
+	}
+
+	return
+}
+
+// 根据合作商对象、服务器Id获取服务器对象
+// partnerObj：合作商对象
+// serverId：服务器Id
+// 返回值：
+// 服务器对象
+// 是否存在
+func GetServer(partnerObj *Partner, serverId int32) (serverObj *Server, exist bool) {
+	if subServerMap, exist1 := serverMap[partnerObj.Id]; exist1 {
+		serverObj, exist = subServerMap[serverId]
+	}
+
+	return
+}
+
+// 根据合作商Id、服务器Id获取服务器对象
+// partnerId：合作商Id
+// serverId：服务器Id
+// 返回值：
+// 服务器对象
+// 是否存在
+func GetServerItem(partnerId, serverId int32) (serverObj *Server, exist bool) {
+	if subServerMap, exist1 := serverMap[partnerId]; exist1 {
+		serverObj, exist = subServerMap[serverId]
+	}
+
+	return
+}
+
+// 获取不重复的服务器Id列表
+// 返回值:
+// 不重复的服务器Id列表
+func GetDistinctServerIdList() (distinctServerIdList []int32) {
+	for _, item := range serverDistinctMap {
+		distinctServerIdList = append(distinctServerIdList, item.Id)
+	}
+
+	return
+}

trunk/framework/managecenterMgr/servergroup.go

@@ -0,0 +1,247 @@
+package managecenterMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sort"
+
+	"Framework/ipMgr"
+	"Framework/managecenterModel"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+var (
+	// 服务器组集合
+	serverGroupMap  = make(map[int32]*ServerGroup, 512)
+	serverGroupHash string
+
+	// 服务器组变化方法集合 (完整列表，新增列表，删除列表，更新列表)
+	serverGroupChangeFuncMap = make(map[string]func([]*ServerGroup, []*ServerGroup, []*ServerGroup, []*ServerGroup))
+)
+
+func init() {
+	ipMgr.RegisterIpCheckFunc("ServerGroupIpCheck", isIpValid)
+}
+
+// 重新加载服务器组
+func reloadServerGroup(isInit bool) error {
+	//logUtil.DebugLog("开始刷新服务器组信息")
+
+	url := getManageCenterUrl("/API/ServerGroupList.ashx")
+
+	// 定义请求参数
+	postDict := make(map[string]string)
+	postDict["GroupType"] = "Mix"
+	postDict["HashValue"] = serverGroupHash
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, nil)
+	if err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取服务器组列表出错，url:%s,错误信息为:%s", url, err))
+		return err
+	}
+	if statusCode != 200 {
+		logUtil.ErrorLog(fmt.Sprintf("获取服务器组列表出错，url:%s,错误码为:%d", url, statusCode))
+		return err
+	}
+
+	// 解析返回值
+	returnObj := new(ReturnObject)
+	if err = json.Unmarshal(returnBytes, &returnObj); err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取服务器组列表出错，反序列化返回值出错，错误信息为：%s", err))
+		return err
+	}
+
+	// 判断返回状态是否为成功
+	if returnObj.Code != 0 {
+		// 数据没有变化，所以没有获取到新的数据，不能算错误。
+		if returnObj.Code == 47 || returnObj.Message == "DataNotChanged" {
+			//如果本地集合为空，且数据又没变化时，重新初始化一下本地hash值
+			if len(serverGroupMap) == 0 {
+				serverGroupHash = ""
+			}
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取服务器组列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	tmpServerGroupList := make([]*ServerGroup, 0, 512)
+	if data, ok := returnObj.Data.(string); !ok {
+		msg := "获取服务器组列表出错，返回的数据不是string类型"
+		logUtil.ErrorLog(msg)
+		return errors.New(msg)
+	} else {
+		if err = json.Unmarshal([]byte(data), &tmpServerGroupList); err != nil {
+			logUtil.ErrorLog(fmt.Sprintf("获取服务器组列表出错，反序列化数据出错，错误信息为：%s", err))
+			return err
+		}
+	}
+
+	//logUtil.DebugLog(fmt.Sprintf("刷新服务器组信息结束,服务器组数量:%d", len(tmpServerGroupList)))
+
+	tmpServerGroupMap := make(map[int32]*ServerGroup, 512)
+	for _, item := range tmpServerGroupList {
+		tmpServerGroupMap[item.Id] = item
+	}
+
+	// 处理服务器组是否变化情况
+	addList, deleteList, updateList := handleServerGroupChange(GetServerGroupMap(), tmpServerGroupMap)
+	triggerServerGroupChangeFunc(tmpServerGroupList, addList, deleteList, updateList)
+
+	// 赋值给最终的ServerGroupMap
+	serverGroupMap = tmpServerGroupMap
+	serverGroupHash = returnObj.HashValue
+
+	//通知变更
+	mcDataChangeCallBack(managecenterModel.ServerGroupData, isInit)
+
+	return nil
+}
+
+// 处理服务器组是否变化情况
+// originalServerGroupMap: 当前服务器组集合
+// newServerGroupMap: 新的服务器组集合
+func handleServerGroupChange(currServerGroupMap, newServerGroupMap map[int32]*ServerGroup) (
+	addList []*ServerGroup, deleteList []*ServerGroup, updateList []*ServerGroup) {
+
+	// 判断是否有新增的数据
+	for k, v := range newServerGroupMap {
+		if _, exist := currServerGroupMap[k]; !exist {
+			addList = append(addList, v)
+		}
+	}
+
+	// 判断是否有删除的数据
+	for k, v := range currServerGroupMap {
+		if _, exist := newServerGroupMap[k]; !exist {
+			deleteList = append(deleteList, v)
+		}
+	}
+
+	// 判断是否有更新的数据
+	for k, currItem := range currServerGroupMap {
+		if newItem, exist := newServerGroupMap[k]; exist {
+			if currItem.IsEqual(newItem) == false {
+				updateList = append(updateList, newItem)
+			}
+		}
+	}
+
+	return
+}
+
+// 触发服务器组变化的方法
+func triggerServerGroupChangeFunc(allList []*ServerGroup, addList []*ServerGroup, deleteList []*ServerGroup, updateList []*ServerGroup) {
+	// 如果有注册服务器组变化的方法
+	if len(serverGroupChangeFuncMap) > 0 {
+		for _, serverGroupChangeFunc := range serverGroupChangeFuncMap {
+			serverGroupChangeFunc(allList, addList, deleteList, updateList)
+		}
+	}
+}
+
+// 注册服务器组变化方法
+// funcName：方法名称
+// serverGroupChangeFunc：服务器组变化方法
+func RegisterServerGroupChangeFunc(funcName string, serverGroupChangeFunc func([]*ServerGroup, []*ServerGroup, []*ServerGroup, []*ServerGroup)) {
+	if _, exists := serverGroupChangeFuncMap[funcName]; exists {
+		panic(fmt.Errorf("RegisterServerGroupChange:%s已经存在，请检查", funcName))
+	}
+	serverGroupChangeFuncMap[funcName] = serverGroupChangeFunc
+
+	logUtil.DebugLog(fmt.Sprintf("注册服务器组变化方法 funcName:%s，当前共有%d个注册", funcName, len(serverGroupChangeFuncMap)))
+}
+
+// 获取服务器组集合
+// 返回值：
+// 服务器组集合
+func GetServerGroupMap() (retServerGroupMap map[int32]*ServerGroup) {
+	retServerGroupMap = make(map[int32]*ServerGroup, 128)
+	for k, v := range serverGroupMap {
+		retServerGroupMap[k] = v
+	}
+
+	return
+}
+
+// 获取服务器组列表
+// 返回值：
+// 服务器组列表
+func GetServerGroupList() (serverGroupList []*ServerGroup) {
+	for _, item := range serverGroupMap {
+		serverGroupList = append(serverGroupList, item)
+	}
+
+	sort.Slice(serverGroupList, func(i, j int) bool {
+		return serverGroupList[i].SortByIdAsc(serverGroupList[j])
+	})
+
+	return
+}
+
+// 获取服务器组项
+// id
+// 返回值：
+// 服务器组对象
+// 是否存在
+func GetServerGroupItem(id int32) (serverGroupObj *ServerGroup, exist bool) {
+	serverGroupObj, exist = serverGroupMap[id]
+	return
+}
+
+// 根据合作商Id、服务器Id获取服务器组对象
+// partnerId：合作商Id
+// serverId：服务器Id
+// 返回值：
+// 服务器组对象
+// 服务器对象
+// 是否存在
+func GetServerGroup(partnerId, serverId int32) (serverGroupObj *ServerGroup, serverObj *Server, exist bool) {
+	var partnerObj *Partner
+
+	// 获取合作商对象
+	partnerObj, exist = GetPartner(partnerId)
+	if !exist {
+		return
+	}
+
+	// 获取服务器对象
+	serverObj, exist = GetServer(partnerObj, serverId)
+	if !exist {
+		return
+	}
+
+	// 获取服务器组对象
+	serverGroupObj, exist = GetServerGroupItem(serverObj.GroupId)
+	return
+}
+
+// 判断IP是否有效
+// ip：指定IP地址
+// 返回值：
+// IP是否有效
+func isIpValid(ip string) (exist bool) {
+	for _, v := range serverGroupMap {
+		for _, item := range v.GetIPList() {
+			if ip == item {
+				exist = true
+				return
+			}
+		}
+	}
+
+	return
+}

trunk/framework/managecenterMgr/userWhiteList.go

@@ -0,0 +1,114 @@
+package managecenterMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"Framework/managecenterModel"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+var (
+	whiteListMap  = make(map[int32]map[string]*WhiteList, 64)
+	whiteListHash string
+)
+
+// 重新加载白名单
+func reloadWhiteList(isInit bool) error {
+	//logUtil.DebugLog("开始刷新白名单列表")
+
+	url := getManageCenterUrl("/API/UserWhiteList.ashx")
+
+	// 定义请求参数
+	postDict := make(map[string]string)
+	postDict["HashValue"] = whiteListHash
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, postDict, header, nil)
+	if err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取白名单列表出错，url:%s,错误信息为:%s", url, err))
+		return err
+	}
+	if statusCode != 200 {
+		logUtil.ErrorLog(fmt.Sprintf("获取白名单列表出错，url:%s,错误码为:%d", url, statusCode))
+		return err
+	}
+
+	// 解析返回值
+	returnObj := new(ReturnObject)
+	if err = json.Unmarshal(returnBytes, &returnObj); err != nil {
+		logUtil.ErrorLog(fmt.Sprintf("获取白名单列表出错，反序列化返回值出错，错误信息为：%s, str:%s", err, string(returnBytes)))
+		return err
+	}
+
+	// 判断返回状态是否为成功
+	if returnObj.Code != 0 {
+		// 数据没有变化，所以没有获取到新的数据，不能算错误。
+		if returnObj.Code == 47 || returnObj.Message == "DataNotChanged" {
+			//如果本地集合为空，且数据又没变化时，重新初始化一下本地hash值
+			if len(whiteListMap) == 0 {
+				whiteListHash = ""
+			}
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取白名单列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	tmpWhiteList := make([]*WhiteList, 0, 128)
+	if data, ok := returnObj.Data.(string); !ok {
+		msg := "获取白名单列表出错，返回的数据不是string类型"
+		logUtil.ErrorLog(msg)
+		return errors.New(msg)
+	} else {
+		if err = json.Unmarshal([]byte(data), &tmpWhiteList); err != nil {
+			logUtil.ErrorLog(fmt.Sprintf("获取白名单列表出错，反序列化数据出错，错误信息为：%s", err))
+			return err
+		}
+	}
+
+	//logUtil.DebugLog(fmt.Sprintf("刷新白名单信息结束，白名单数量:%d", len(tmpWhiteList)))
+
+	tmpWhiteListMap := make(map[int32]map[string]*WhiteList, 64)
+	for _, item := range tmpWhiteList {
+		if _, exist := tmpWhiteListMap[item.PartnerId]; !exist {
+			tmpWhiteListMap[item.PartnerId] = make(map[string]*WhiteList, 8)
+		}
+
+		tmpWhiteListMap[item.PartnerId][item.UserId] = item
+	}
+
+	// 赋值给最终的whiteListMap
+	whiteListMap = tmpWhiteListMap
+	whiteListHash = returnObj.HashValue
+
+	//通知变更
+	mcDataChangeCallBack(managecenterModel.UserWhiteListData, isInit)
+
+	return nil
+}
+
+// 判断用户是否在白名单里面
+// partnerId: 合作商ID
+// userId: userId
+func IsInWhiteList(partnerId int32, userId string) bool {
+	subWhiteListMap, exist := whiteListMap[partnerId]
+	if !exist {
+		return false
+	}
+
+	_, exist = subWhiteListMap[userId]
+	return exist
+}