cgserver 7.10.2113 → 7.11.2113

package/src/Framework/Database/RedisManager.ts

@@ -1,544 +0,0 @@
-import { GLog } from '../Logic/Log';
-import * as redis from 'redis';
-
-export let GRedisMgr:RedisManager = null
-export class RedisManager
-{
-    protected _redis:redis.RedisClient = null
-    get redis()
-    {
-        return this._redis
-    }
-    protected _resis_init_succ:boolean=false
-    protected _redisCfg:{open:boolean,
-        host:string,
-        port:number,
-        database:number,
-        password:string}=null
-    constructor()
-    {
-
-    }
-    async init(redisCfg:{open:boolean,
-        host:string,
-        port:number,
-        database:number,
-        password:string})
-    {
-        return new Promise((resolve)=>{
-            if(!redisCfg||!redisCfg.open)
-            {
-                resolve(null)
-                return
-            }
-            if(this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redisCfg=redisCfg
-            GLog.info("begin conect redis="+JSON.stringify(redisCfg))
-            this._redis = redis.createClient(redisCfg.port, redisCfg.host, { parser: "javascript", return_buffers: false, connect_timeout: 3000,password:redisCfg.password })
-            this._redis.on("connect", ()=>
-            {
-                this.onConnect()
-                resolve(null)
-            })
-            this._redis.on("end", this.onEnd.bind(this))
-            this._redis.on("error", this.onError.bind(this))
-        })
-    }
-    onConnect()
-    {
-        if(this._redisCfg.database)
-        {
-            this._redis.select(this._redisCfg.database)
-        }
-        this._resis_init_succ = true
-        GLog.info("redis has connected!")
-    }
-    onEnd()
-    {
-        this._resis_init_succ = false
-        this._redis = null
-        this.init(this._redisCfg)//重连
-    }
-    onError(err)
-    {
-        GLog.info("Error connected="+this._redis.connected+": "+ err)
-    }
-    expire(key,seconds)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.expire(key,seconds,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    incr(key)
-    {
-        return new Promise<number>((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.incr(key,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    set(key, value)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.set(key, value,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    get(key):Promise<string>
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.get(key,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    /**
-     * 
-     * @param key 
-     * @param cb 有表示异步
-     */
-    del(key,cb?)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.del(key,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    hset(h, key, value)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.hset(h, key, value,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    hget(h, key)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.hget(h, key,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    hdel(key,sub_key)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.hdel(key,sub_key,(err, reply)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(reply)
-            })
-        })
-    }
-    /**
-     * hash值，能转换位整数的就自动转换为整数
-     * @param h key
-     */
-    hgetall(h):Promise<{ [key: string]: any }>
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.hgetall(h,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                    resolve(replys)
-                    return
-                }
-                let value={}
-                for(let k in replys)
-                {
-                    let v = replys[k]
-                    let iv=parseInt(v)
-                    if(v==""+iv)
-                    {
-                        value[k] = iv
-                    }
-                    else
-                    {
-                        value[k]=v
-                    }
-                }
-                if(!replys)
-                {
-                    value=null
-                }
-                resolve(value)
-            })
-        })
-    }
-    /**
-     * 
-     * @param h 
-     * @param array 
-     */
-    hmset(h,array)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.hmset(h, array,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    lpush(key,array)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.lpush(key, array,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    lrange(key:string,start?:number,end?:number)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            if(!this._redis)
-            {
-                return null
-            }
-            if(!start)
-            {
-                start = 0
-            }
-            if(!end)
-            {
-                end = -1
-            }
-            this._redis.lrange(key, start, end,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    ltrim(key:string,start:number,end?:number)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            if(!this._redis)
-            {
-                return null
-            }
-            if(!start)
-            {
-                start = 0
-            }
-            if(!end)
-            {
-                end = -1
-            }
-            this._redis.ltrim(key, start, end,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    sadd(key,array)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.sadd(key, array,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    smembers(key)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.smembers(key,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    srem(key,array)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.srem(key,array,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    keys(key)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.keys(key,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    multi()
-    {
-        if(!this._redis)
-        {
-            return null
-        }
-        return this._redis.multi()
-    }
-    exists(key:string)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.exists(key,(err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    exec(multi:redis.Multi):Promise<Array<any>>
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis||!multi)
-            {
-                resolve(null)
-                return
-            }
-            multi.exec((err, replys)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(replys)
-            })
-        })
-    }
-    publish(channel:string,value:string)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.publish(channel,value,(err,num)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(num)
-            })
-        })
-    }
-    subscribe(channel:string)
-    {
-        return new Promise((resolve,reject)=>
-        {
-            if(!this._redis)
-            {
-                resolve(null)
-                return
-            }
-            this._redis.subscribe(channel,(err,msg)=>
-            {
-                if(err)
-                {
-                    GLog.error(err)
-                }
-                resolve(msg)
-            })
-        })
-    }
-    on(message:string,cb:any)
-    {
-        if(!this._redis)
-        {
-            return
-        }
-        this._redis.on(message,cb)
-    }
-}
-GRedisMgr = new RedisManager()

package/src/Framework/Logic/CacheTool.ts

@@ -1,85 +0,0 @@
-import * as _ from "underscore";
-
-export let GCacheTool:CacheTool = null
-class CacheItem
-{
-    key:string = ""
-    value:any=null
-    milliseconds:number=0
-    expire_time=-1
-}
-class CacheTool
-{
-    protected _items:{[key:string]:CacheItem}={}
-    constructor()
-    {
-        //一个小时清除一次过期缓存
-        setInterval(this._refresh.bind(this),60*60*1000)
-    }
-    /**
-     * 定时清除缓存
-     */
-    protected _refresh()
-    {
-        let time = new Date().getTime()
-        let keys = _.clone(this._items.keys)
-        for(let i in keys)
-        {
-            let key = keys[i]
-            let item = this._items[key]
-            if(!item)
-            {
-                delete this._items[key]
-                continue
-            }
-            if(time>item.expire_time)
-            {
-                this.remove(key)
-            }
-        }
-    }
-    get(key,refresh?:boolean)
-    {
-        let item:CacheItem = this._items[key]
-        if(!item)
-        {
-            return
-        }
-        let time = new Date().getTime()
-        if(time>item.expire_time)
-        {
-            this.remove(key)
-            return
-        }
-        if(refresh)
-        {
-            item.expire_time=time+item.milliseconds
-        }
-        return item.value
-    }
-    /**
-     * 
-     * @param key 
-     * @param value 
-     * @param time 缓存的毫秒数
-     */
-    add(key,value,milliseconds)
-    {
-        let item:CacheItem = this._items[key]
-        if(!item)
-        {
-            item = new CacheItem()
-            item.key = key
-            this._items[key] = item
-        }
-        item.value = value
-        item.milliseconds = milliseconds
-        item.expire_time = new Date().getTime()+milliseconds
-    }
-    remove(key)
-    {
-        this._items[key] = null
-        delete this._items[key]
-    }
-}
-GCacheTool = new CacheTool()

package/src/Framework/Logic/EventTool.ts

@@ -1,31 +0,0 @@
-import * as EventEmitter from "events";
-class EventTool
-{
-    protected _event_emitter=new EventEmitter()
-    constructor()
-    {
-        this._event_emitter.setMaxListeners(0)
-    }
-    on(event:string,func:(...args: any[]) => void)
-    {
-        this._event_emitter.on(event,func)
-    }
-    off(event:string,func:(...args: any[]) => void)
-    {
-        this._event_emitter.off(event,func)
-    }
-    once(event:string,func:(...args: any[]) => void)
-    {
-        this._event_emitter.once(event,func)
-    }
-    emit(event:string,...args: any[])
-    {
-        this._event_emitter.emit(event,...args)
-    }
-    listenerCount(event:string)
-    {
-        let count = this._event_emitter.listenerCount(event)||0
-        return count
-    }
-}
-export let GEventTool=new EventTool()