Beispiel #1
0
        /// <summary>
        /// 获取单项配置
        /// </summary>
        /// <param name="serverName"></param>
        /// <param name="commandName"></param>
        public static ServerConfigItem GetItem(string serverName, string commandName)
        {
            var key = ServerCommand.BuildCommandKey(serverName, commandName);
            ServerConfigItem item = null;

            items.TryGetValue(key, out item);
            return(item);
        }
Beispiel #2
0
        /// <summary>
        /// 服务配置读取
        /// </summary>
        /// <param name="serverName"></param>
        /// <param name="serverExpire"></param>
        /// <param name="nodes"></param>
        private static void LoadServerConfig(string serverName, int serverExpire, XmlNodeList nodes)
        {
            var commandName       = string.Empty;
            var expires           = 0;
            var mixedsplit        = string.Empty;
            var version           = string.Empty;
            var cacheDeleteAction = string.Empty;
            var objectName        = string.Empty;

            foreach (XmlNode node in nodes)
            {
                commandName = XmlHelper.GetAttribute(node, "name", null);
                if (string.IsNullOrEmpty(commandName))
                {
                    continue;
                }
                if (Exists(serverName, commandName))
                {
                    throw new ConfigurationErrorsException(string.Format("Repeated Command Item {0}.{1} in {0}.config", serverName, commandName));
                }
                var commandInfo = ServerCommand.GetCommand(serverName, commandName);
                if (commandInfo == null)
                {
                    throw new ConfigurationErrorsException(string.Format("No Find Server Command {0}.{1} in {0}.config", serverName, commandName));
                }
                var settingItem = new ServerConfigItem();
                //cache expires
                settingItem.CacheExpires = int.TryParse(XmlHelper.GetAttribute(node, "expires", null), out expires) ? expires : serverExpire;
                //version
                version = XmlHelper.GetAttribute(node, "version");
                if (!string.IsNullOrEmpty(version))
                {
                    if (GetVersionExpires(serverName, version) == 0)
                    {
                        throw new ConfigurationErrorsException(string.Format("Not Find Version:{2} config node, version info {0}.{1} version attribute in {0}.config", serverName, commandName, version));
                    }
                    settingItem.CacheVersion = version;
                }
                settingItem.CacheKey = XmlHelper.GetAttribute(node, "key", null);
                if (string.IsNullOrEmpty(settingItem.CacheKey))
                {
                    settingItem.CacheKey = string.Concat(serverName, ".", commandName);
                }

                //deletes
                var deletes = node.SelectNodes("delete");
                if (deletes.Count > 0)
                {
                    settingItem.CacheDeletes = InitCacheDelete(commandInfo, deletes);
                }

                items.Add(ServerCommand.BuildCommandKey(serverName, commandName), settingItem);
            }
        }
Beispiel #3
0
        /// <summary>
        /// delete cache
        /// </summary>
        /// <param name="commandInfo"></param>
        /// <param name="parameters"></param>
        /// <param name="configItem"></param>
        private void DeleteCache(CommandInfo commandInfo, ServerConfigItem configItem, object[] parameters)
        {
            object[] deleteDatas = null;

            try
            {
                foreach (var cacheDelete in configItem.CacheDeletes)
                {
                    var deleteCommandConfig = ServerConfig.GetItem(cacheDelete.Server, cacheDelete.Command);
                    if (deleteCommandConfig == null)
                    {
                        this.logManager.Exception(new CsException("Not Find Cache Config {0}.{1} By {2}.{3} Cache Delete"
                                                                  , cacheDelete.Server, cacheDelete.Command
                                                                  , commandInfo.Server, commandInfo.Name
                                                                  ));
                        continue;
                    }
                    else if (null != deleteCommandConfig.CacheVersion)
                    {
                        var version = ServerCache.GetVersion();
                        //update version
                        ServerCache.Cache.Set(deleteCommandConfig.CacheVersion, version, ServerConfig.GetVersionExpires(commandInfo.Server, deleteCommandConfig.CacheVersion));

                        if (ServerCache.LogWriter.Enable)
                        {
                            ServerCache.LogWriter.WriteTimeLine("Delete Cache Version: " + deleteCommandConfig.CacheVersion);
                        }
                    }
                    else
                    {
                        //delete
                        deleteDatas = this.GetDeleteParametersDatas(cacheDelete, parameters);

                        var cacheKey = ServerCache.BuildKey(deleteCommandConfig.CacheKey, deleteDatas);
                        ServerCache.Cache.Delete(cacheKey);

                        if (ServerCache.LogWriter.Enable)
                        {
                            ServerCache.LogWriter.WriteTimeLine("Delete Cache: " + cacheKey);
                        }
                    }
                }
            }
            catch (CsException)
            {
                throw;
            }
            catch (Exception e)
            {
                this.logManager.Exception(e);
            }
        }
Beispiel #4
0
        /// <summary>
        /// delete cache
        /// </summary>
        /// <param name="commandInfo"></param>
        /// <param name="parameters"></param>
        /// <param name="configItem"></param>
        private void DeleteCache(CommandInfo commandInfo, ServerConfigItem configItem, object[] parameters)
        {
            object[] deleteDatas = null;

            try
            {
                foreach (var cacheDelete in configItem.CacheDeletes)
                {
                    var deleteCommandConfig = ServerConfig.GetItem(cacheDelete.Server, cacheDelete.Command);
                    if (deleteCommandConfig == null)
                    {
                        this.serverLogger.CommandCacheDelete(commandInfo.Server, commandInfo.Name, cacheDelete.Server, cacheDelete.Command, "Not Find");
                        continue;
                    }
                    else if (null != deleteCommandConfig.CacheVersion)
                    {
                        var version = ServerCache.GetVersion();
                        //update version
                        ServerCache.Cache.Set(deleteCommandConfig.CacheVersion, version, ServerConfig.GetVersionExpires(commandInfo.Server, deleteCommandConfig.CacheVersion));
                    }
                    else
                    {
                        //delete
                        deleteDatas = this.GetDeleteParametersDatas(cacheDelete, parameters);

                        var cacheKey = ServerCache.BuildKey(deleteCommandConfig.CacheKey, deleteDatas);
                        ServerCache.Cache.Delete(cacheKey);
                    }
                }
            }
            catch (CsException)
            {
                throw;
            }
            catch (Exception e)
            {
                this.serverLogger.CommandCacheException(commandInfo.Server, commandInfo.Name, e);
            }
        }
Beispiel #5
0
        /// <summary>
        /// invoke
        /// </summary>
        /// <param name="commandInfo"></param>
        /// <param name="parameters"></param>
        /// <param name="valueBuffer"></param>
        /// <param name="cacheType"></param>
        /// <returns></returns>
        private CsResult Invoke(CommandInfo commandInfo, object[] parameters, out byte[] valueBuffer, out ServerCacheType cacheType)
        {
            /*
             * this method ,try catch, safe cache error
             */

            //variable init
            string cacheKey     = null;
            string cacheVersion = null;
            object invokeValue  = null;
            var    result       = CsResult.Fail;
            //bool hasContent = false;

            //
            ServerConfigItem configItem = null;
            bool             isCache    = false;

            if (ServerCache.Enable)
            {
                configItem = ServerConfig.GetItem(commandInfo.Server, commandInfo.Name);
                isCache    = configItem != null && configItem.CacheExpires > 0;
            }

            //init out
            valueBuffer = null;
            cacheType   = ServerCacheType.NoCache;

            //cache get
            if (isCache)
            {
                //mode = version
                if (configItem.CacheVersion != null)
                {
                    cacheVersion = ServerCache.Cache.Get(configItem.CacheVersion);
                }
                //get cache
                cacheKey = ServerCache.BuildKey(configItem.CacheKey, cacheVersion, parameters);

                try
                {
                    valueBuffer = ServerCache.Cache.Get <byte[]>(cacheKey);
                    result      = CsResult.Success;
                }
                catch (Exception e)
                {
                    this.serverLogger.CommandCacheException(commandInfo.Server, commandInfo.Name, e);
                }

                cacheType = valueBuffer != null && result == CsResult.Success ? ServerCacheType.Cached : ServerCacheType.NoCache;
            }

            //invoke
            if (valueBuffer == null)
            {
                cacheType = ServerCacheType.NoCache;
                result    = CsResult.Success;

                //no ObjectCache
                if (invokeValue == null)
                {
                    invokeValue = commandInfo.Method.Invoke(commandInfo.Instance, parameters);
                }

                //是否有内容
                //hasContent = invokeValue != null;

                //buffer = bodylength+body, parameter index + parameter length + parameter

                using (var m = new MemoryStream(CsSocket.BODY_BUFFER_SIZE))
                {
                    //body
                    using (var m2 = new MemoryStream(CsSocket.BODY_BUFFER_SIZE))
                    {
                        if (invokeValue == null)
                        {
                            //length
                            m.Write(BitConverter.GetBytes((int)-1), 0, CsSocket.LENGTH_BUFFER_SIZE);
                        }
                        else
                        {
                            CsSerializer.Serialize(m2, invokeValue);
                            //length
                            m.Write(BitConverter.GetBytes((int)m2.Length), 0, CsSocket.LENGTH_BUFFER_SIZE);
                            //body
                            m2.WriteTo(m);
                        }
                    }
                    //parameters
                    // count
                    m.Write(BitConverter.GetBytes((int)commandInfo.OutsIndexLength), 0, CsSocket.LENGTH_BUFFER_SIZE);
                    using (var m2 = new MemoryStream(CsSocket.BODY_BUFFER_SIZE))
                    {
                        for (int i = 0, index = 0; i < commandInfo.OutsIndexLength; i++)
                        {
                            m2.SetLength(0);
                            m2.Position = 0;
                            //
                            index = (int)commandInfo.OutsIndex[i];
                            //index
                            m.Write(BitConverter.GetBytes(index), 0, CsSocket.LENGTH_BUFFER_SIZE);
                            //
                            if (parameters[index] == null)
                            {
                                //length
                                m.Write(BitConverter.GetBytes((int)-1), 0, CsSocket.LENGTH_BUFFER_SIZE);
                            }
                            else
                            {
                                CsSerializer.Serialize(m2, parameters[index]);
                                //length
                                m.Write(BitConverter.GetBytes((int)m2.Length), 0, CsSocket.LENGTH_BUFFER_SIZE);
                                //body
                                m2.WriteTo(m);
                            }
                        }
                    }
                    //
                    valueBuffer = m.ToArray();
                }
            }

            //cache set
            //if (result == CsResult.Success && cacheType == CacheType.NoCache && hasContent && commandInfo.CacheExpires > 0)
            if (isCache && result == CsResult.Success && cacheType == ServerCacheType.NoCache)
            {
                try
                {
                    //set cache
                    ServerCache.Cache.Set(cacheKey, valueBuffer, configItem.CacheExpires);
                    cacheType = ServerCacheType.NewCache;
                }
                catch (Exception e)
                {
                    this.serverLogger.CommandCacheException(commandInfo.Server, commandInfo.Name, e);
                }
            }

            //delete cache
            if (ServerCache.Enable && isCache && configItem.CacheDeletes != null)
            {
                this.DeleteCache(commandInfo, configItem, parameters);
            }

            return(result);
        }
Beispiel #6
0
        private void NewCommandInvoke(Socket socket, byte parameterLength, string serverName, string commandName, int commandStart)
        {
            object value = null;

            object[] parameters = null;

            var commandInfo = ServerCommand.GetCommand(serverName, commandName);

            if (commandInfo == null)
            {
                value = string.Format("Not Find Command:{0}.{1}", serverName, commandName);
            }

            else if (commandInfo.Parameters.Length != parameterLength)
            {
                value = string.Format("{0}.{1} Client Command  Parameters And Server Parameters No Match", serverName, commandName);
            }
            else
            {
                //get parameter
                if (parameterLength > 0)
                {
                    parameters = new object[parameterLength];
                    for (var i = 0; i < parameterLength; i++)
                    {
                        if (commandInfo.Parameters[i].IsOut)
                        {
                            CsSocket.Receive(socket);
                        }
                        else
                        {
                            parameters[i] = CsSocket.Receive(socket, commandInfo.Parameters[i].ParameterType);
                        }
                    }
                }
            }

            //cache
            byte[]           cacheBuffer = null;
            String           cacheVersion = null, cacheKey = null;
            var              cacheType   = ServerCacheType.NoCache;
            ServerConfigItem configItem  = null;
            bool             cacheEnable = false;

            //no error & get cache
            if (value == null)
            {
                if (ServerCache.Enable)
                {
                    configItem  = ServerConfig.GetItem(commandInfo.Server, commandInfo.Name);
                    cacheEnable = configItem != null && configItem.CacheExpires > 0;
                }

                //cache get
                if (cacheEnable)
                {
                    //mode = version
                    if (configItem.CacheVersion != null)
                    {
                        try
                        {
                            cacheVersion = ServerCache.Cache.Get(configItem.CacheVersion);
                            if (cacheVersion != null && cacheVersion != "")
                            {
                                //get cache
                                cacheKey = ServerCache.BuildKey(configItem.CacheKey, cacheVersion, parameters);
                                //value = ServerCache.Cache.Get(cacheKey, commandInfo.Method.ReturnType);
                                cacheBuffer = ServerCache.Cache.Get <byte[]>(cacheKey);
                                cacheType   = cacheBuffer != null ? ServerCacheType.Cached : ServerCacheType.NoCache;
                            }
                            else
                            {
                                //no version , set no cache
                                cacheEnable = false;
                            }
                        }
                        catch (Exception e)
                        {
                            this.logManager.Exception(e);
                        }
                    }
                    else
                    {
                        //get cache
                        cacheKey = ServerCache.BuildKey(configItem.CacheKey, null, parameters);
                        try
                        {
                            //value = ServerCache.Cache.Get(cacheKey, commandInfo.Method.ReturnType);
                            cacheBuffer = ServerCache.Cache.Get <byte[]>(cacheKey);
                            cacheType   = cacheBuffer != null ? ServerCacheType.Cached : ServerCacheType.NoCache;
                        }
                        catch (Exception e)
                        {
                            this.logManager.Exception(e);
                        }
                    }
                }
            }

            var result = false;

            //cached
            if (cacheType == ServerCacheType.Cached)
            {
                socket.Send(cacheBuffer);
                result = true;
            }
            //no error ,invoke
            else if (value == null)
            {
                //var invokeStart = DateTime.Now;
                try
                {
                    value  = commandInfo.Method.Invoke(commandInfo.Instance, parameters);
                    result = true;
                }
                catch (TargetInvocationException exception)
                {
                    result = false;
                    this.logManager.Exception(exception.GetBaseException());
                    value = exception.GetBaseException().Message;
                }
                catch (Exception exception)
                {
                    result = false;
                    this.logManager.Exception(exception);
                    value = exception.Message;
                }
                //invokeSeconds = DateTime.Now.Subtract(invokeStart).TotalSeconds;

                //build  value Buffer
                if (result)
                {
                    using (var m = new MemoryStream())
                    {
                        //write result
                        m.WriteByte((byte)CsResult.Success);

                        //send out parameter length

                        //buffer parameter length , parameter index + parameter length + parameter body + bodylength + body
                        //parameter count writer
                        m.WriteByte(commandInfo.OutsIndexLength);
                        //parameter write
                        if (commandInfo.OutsIndexLength > 0)
                        {
                            for (byte i = 0, l = commandInfo.OutsIndexLength; i < l; i++)
                            {
                                //write index
                                m.WriteByte(commandInfo.OutsIndex[i]);
                                //write parameter
                                CsSocket.WriteDataItem(m, parameters[commandInfo.OutsIndex[i]]);
                            }
                        }
                        //body
                        CsSocket.WriteDataItem(m, value);

                        //build value buffer completed

                        //svae value buffer to cache
                        //if (result == CsResult.Success && cacheType == CacheType.NoCache && hasContent && commandInfo.CacheExpires > 0)
                        if (cacheEnable && cacheType == ServerCacheType.NoCache)
                        {
                            cacheBuffer = m.ToArray();
                            try
                            {
                                //set cache
                                ServerCache.Cache.Set(cacheKey, cacheBuffer, configItem.CacheExpires);
                                cacheType = ServerCacheType.NewCache;
                            }
                            catch (Exception e)
                            {
                                this.logManager.Exception(e);
                            }
                        }

                        //delete cache
                        if (ServerCache.Enable && cacheEnable && configItem.CacheDeletes != null)
                        {
                            this.DeleteCache(commandInfo, configItem, parameters);
                        }

                        //send value
                        if (cacheType == ServerCacheType.NewCache)
                        {
                            socket.Send(cacheBuffer);
                        }
                        else
                        {
                            socket.Send(m.GetBuffer(), 0, (int)m.Length, SocketFlags.None);
                        }
                    }
                }
            }
            else
            {
                //parameter error
                result = false;
                //value = "parameter error";
            }

            //send error
            if (result == false)
            {
                using (var m = new MemoryStream())
                {
                    m.WriteByte((byte)CsResult.Fail);
                    //write failure message
                    CsSocket.WriteDataItem(m, (string)value);
                    //
                    socket.Send(m.GetBuffer(), 0, (int)m.Length, SocketFlags.None);
                }
            }

            //
            if (this.logMessage.Enable)
            {
                //this.logMessage.WriteTimeLine("{0}: {1}.{2}:{3}, Cache:{4}, InvokeSeconds:{5},Seconds:{6}",
                //    this.id, serverName, commandName, result ? "Success" : "Failure", cacheType, invokeSeconds, DateTime.Now.Subtract(start).TotalSeconds);
                //stopwatch.Stop();
                //var elapsedMilliseconds = stopwatch.ElapsedMilliseconds;

                var elapsedMilliseconds = Environment.TickCount - commandStart;

                //this.logMessage.WriteTimeLine("{0}: {1}.{2}:{3}, Cache:{4}, Elapsed:{5}",
                //    this.id, serverName, commandName, result ? "Success" : "Failure", cacheType, stopwatch.Elapsed.TotalSeconds);
                this.logMessage.WriteTimeLine("{0}\t{1}\t{2}.{3}\t{4}\t{5}",
                                              this.id
                                              , cacheType
                                              , serverName
                                              , commandName
                                              , elapsedMilliseconds
                                              , (result ? "OK" : (string)value));
            }
        }