Apply .gitignore rules

.svn/pristine/a1/a129a3135d09a29263d98fd0741ed447bf11db8a.svn-base

@@ -0,0 +1,90 @@
+package syncUtil
+
+import (
+	"fmt"
+	"runtime/debug"
+	"sync"
+	"time"
+)
+
+// 写锁对象
+type Locker struct {
+	locking   bool
+	prevStack []byte
+	mutex     sync.Mutex
+}
+
+// 内部锁
+// 返回值：
+// 加锁是否成功
+func (this *Locker) lock() bool {
+	this.mutex.Lock()
+	defer this.mutex.Unlock()
+
+	// 如果已经被锁定，则返回失败
+	if this.locking {
+		return false
+	}
+
+	// 否则进行锁定，并返回成功
+	this.locking = true
+
+	// 记录Stack信息
+	if if_record_stack_info {
+		this.prevStack = debug.Stack()
+	}
+
+	return true
+}
+
+// 尝试加锁，如果在指定的时间内失败，则会返回失败；否则返回成功
+// timeout:指定的毫秒数,timeout<=0则将会死等
+// 返回值：
+// 成功或失败
+// 如果失败，返回上一次成功加锁时的堆栈信息
+// 如果失败，返回当前的堆栈信息
+func (this *Locker) Lock(timeout int) (successful bool, prevStack string, currStack string) {
+	timeout = getTimeout(timeout)
+
+	// 遍历指定的次数（即指定的超时时间）
+	for i := 0; i < timeout; i++ {
+		// 如果锁定成功，则返回成功
+		if this.lock() {
+			successful = true
+			break
+		}
+
+		// 如果锁定失败，则休眠1ms，然后再重试
+		time.Sleep(time.Millisecond)
+	}
+
+	// 如果时间结束仍然是失败，则返回上次成功的堆栈信息，以及当前的堆栈信息
+	if successful == false {
+		if this.prevStack != nil && len(this.prevStack) > 0 {
+			prevStack = string(this.prevStack)
+		}
+		currStack = string(debug.Stack())
+	}
+
+	return
+}
+
+// 锁定（死等方式）
+func (this *Locker) WaitLock() {
+	successful, prevStack, currStack := this.Lock(0)
+	if successful == false {
+		fmt.Printf("Locker.WaitLock():{PrevStack:%s, currStack:%s}\n", prevStack, currStack)
+	}
+}
+
+// 解锁
+func (this *Locker) Unlock() {
+	this.mutex.Lock()
+	defer this.mutex.Unlock()
+	this.locking = false
+}
+
+// 创建新的锁对象
+func NewLocker() *Locker {
+	return &Locker{}
+}

.svn/pristine/a1/a17f97cdf3eaad407eb158ecc0426db56e71fddd.svn-base

@@ -0,0 +1,9 @@
+package sms
+
+type Sms interface {
+	// 发送
+	Send() (bool, error)
+
+	// 用于获取准确的返回数据
+	GetResponse() interface{}
+}

.svn/pristine/a1/a195f222cd7927b51252f194d902a32b20d0fe0d.svn-base

@@ -0,0 +1,124 @@
+package gameServerMgr
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"Framework/goroutineMgr"
+	. "Framework/managecenterModel"
+	"goutil/logUtil"
+	"goutil/webUtil"
+)
+
+const URL_SUFFIX string = "/API/UserWhiteList.ashx"
+
+var (
+	mUserWhiteListMap = make(map[int32]map[string]*WhiteList, 0)
+	mHashValue        string
+)
+
+// 获取白名单
+func GetWhiteListFromManageCenterServer() error {
+	//定义参数
+	requestParamMap := make(map[string]string, 0)
+	requestParamMap["HashValue"] = mHashValue
+
+	//构造url
+	url := fmt.Sprintf("%s/%s", mManageCenterServerAPIUrl, URL_SUFFIX)
+
+	//请求url,请求头
+	header := webUtil.GetFormHeader()
+	transport := webUtil.NewTransport()
+	transport.DisableKeepAlives = true
+	transport = webUtil.GetTimeoutTransport(transport, 30)
+
+	statusCode, returnBytes, err := webUtil.PostMapData(url, requestParamMap, header, transport)
+	//statusCode, returnBytes, err := webUtil.PostMapData(url, requestParamMap, 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" {
+			return nil
+		} else {
+			msg := fmt.Sprintf("获取白名单列表出错，返回状态：%d，信息为：%s", returnObj.Code, returnObj.Message)
+			logUtil.ErrorLog(msg)
+			return errors.New(msg)
+		}
+	}
+
+	// 解析Data
+	var tmpWhiteList []*WhiteList
+	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
+		}
+	}
+
+	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
+	mUserWhiteListMap = tmpWhiteListMap
+	mHashValue = returnObj.HashValue
+
+	return nil
+}
+
+// 判断用户是否在白名单里面
+// partnerId: 合作商ID
+// userId: userId
+func IsInWhiteList(partnerId int32, userId string) bool {
+	subWhiteListMap, exist := mUserWhiteListMap[partnerId]
+	if !exist {
+		return false
+	}
+
+	_, exist = subWhiteListMap[userId]
+	return exist
+}
+
+// 定时刷新白名单
+func StartRefreshWhiteListTread() {
+	// 定时刷新数据
+	go func() {
+		goroutineName := "gameServerMgr.StartRefreshWhiteListTread"
+		goroutineMgr.Monitor(goroutineName)
+		defer goroutineMgr.ReleaseMonitor(goroutineName)
+
+		for {
+			// 每30秒刷新一次
+			time.Sleep(30 * time.Second)
+
+			// 刷新白名单
+			GetWhiteListFromManageCenterServer()
+		}
+	}()
+}