public override bool TakeAction()
{
CacheServer cacheServer = new CacheServer();
serverList = cacheServer.GetClientServerList(gameID);
return true;
}
public override bool TakeAction()
{
CacheServer cacheServer = new CacheServer();
cacheServer.ServerStatus(_gameId, _serverid, _status);
return true;
}
public void AddServer(int gameID, int serverId, string serverName, string serverUrl, string status, string intranetAddress)
{
CacheServer cacheServer = new CacheServer();
cacheServer.AddToCache(new ServerInfo()
{
ID = serverId,
GameID = gameID,
ServerName = serverName,
ServerUrl = serverUrl,
Status = status,
IntranetAddress = intranetAddress
});
}
private string DoComboWrite(int gameId)
{
CacheServer cacheServer = new CacheServer();
var serverList = cacheServer.GetOfficialServerList(gameId);
List<ComboData> responseList = new List<ComboData>();
int index = 0;
foreach (var serverInfo in serverList)
{
ComboData item = new ComboData();
item.id = serverInfo.ID;
item.text = string.Format("{0}({1}服)", serverInfo.ServerName, serverInfo.ID);
if (index == 0)
{
item.selected = true;
}
responseList.Add(item);
index++;
}
JavaScriptSerializer serializer = new JavaScriptSerializer();
return serializer.Serialize(responseList);
}
public void SetServerEnableDate(int gameID, int serverID, DateTime enableDate)
{
CacheServer cacheServer = new CacheServer();
cacheServer.SetServerEnableDate(gameID, serverID, enableDate);
}
public void RemoveServer(int gameID, int serverID)
{
CacheServer cacheServer = new CacheServer();
cacheServer.RemoveServer(gameID, serverID);
}
public bool ReloadServer(int gameID)
{
CacheServer cacheServer = new CacheServer();
return cacheServer.ReloadServer(gameID);
}
public void SetServer(int serverID, int gameID, string serverName, string serverUrl, string status, int weight, string intranetAddress)
{
CacheServer cacheServer = new CacheServer();
cacheServer.SetServer(serverID, gameID, serverName, serverID, serverUrl, status, weight, intranetAddress);
}
public ServerInfo[] GetServers(int gameID, bool isSort, bool isEnable)
{
CacheServer cacheServer = new CacheServer();
return cacheServer.GetServers(gameID, isSort, isEnable).ToArray();
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return sorted set remove response</returns>
protected override async Task <SortedSetRemoveResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.SortedSetRemoveAsync(server, this).ConfigureAwait(false));
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return get all database response</returns>
protected override async Task <GetAllDataBaseResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.GetAllDataBaseAsync(server, this).ConfigureAwait(false));
}
protected override async Task <HashDecrementResponse <T> > ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.HashDecrementAsync(server, this).ConfigureAwait(false));
}
protected override async Task <SortedSetRangeByScoreResponse> ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.SortedSetRangeByScoreAsync(server, this).ConfigureAwait(false));
}
public void EnableServer(int gameID, int serverID, bool isEnable)
{
CacheServer cacheServer = new CacheServer();
cacheServer.EnableServer(gameID, serverID, isEnable);
}
public ServerHost(CacheServer server)
: base(server, CacheServer.ObjectUri)
{
CacheServer.Instance = server;
}
public string GetServerName(int gameID, int serverID)
{
CacheServer cacheServer = new CacheServer();
return cacheServer.GetServerName(gameID, serverID);
}
public ServerInfo[] GetServerList(int gameID)
{
CacheServer cacheServer = new CacheServer();
return cacheServer.GetServerList(gameID, false);
}
/// <summary> /// get execute handler /// </summary> /// <param name="cacheProvider">cache provider</param> /// <returns></returns> protected abstract Task <TR> ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server);
public void ServerStatus(int gameID, int serverID, int Status)
{
CacheServer cacheServer = new CacheServer();
cacheServer.ServerStatus(gameID, serverID, Status);
}
static RemoteCacheServer()
{
CacheServer.RegisterCompactTypes();
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return random response</returns>
protected override async Task <RandomResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.KeyRandomAsync(server, this).ConfigureAwait(false));
}
/// <summary>
/// Returns a running instance of CacheServer; does not start the service.
/// If user specifies in the client application an ip address to server channels to bind to
/// then this method creates the server channel bound to that ip. also the object uri then uses
/// the ip address instead of server name.
/// </summary>
/// <returns></returns>
#if !NETCORE
public override ICacheServer ConnectCacheServer()
{
string objectUri = "";
string protocol;
string ip = "";
try
{
if (_channel == null)
{
_channel = new RemotingChannels();
ip = ServiceConfiguration.BindToIP.ToString();
if (ip != null && ip.Length > 0)
{
if (_useTcp)
{
_channel.RegisterTcpChannels("NCC", ip, 0);
}
else
{
_channel.RegisterHttpChannels("NCC", ip, 0);
}
}
else
{
if (_useTcp)
{
_channel.RegisterTcpChannels("NCC", 0);
}
else
{
_channel.RegisterHttpChannels("NCC", 0);
}
}
}
protocol = _useTcp ? @"tcp://" : @"http://";
if (ip != null && ip.Length > 0)
{
objectUri = protocol + ip + ":" + _port + @"/" +
CacheHost.ApplicationName + @"/" + Alachisoft.NCache.Management.CacheServer.ObjectUri;
}
else
{
objectUri = protocol + _serverName + ":" + _port + @"/" +
CacheHost.ApplicationName + @"/" + Alachisoft.NCache.Management.CacheServer.ObjectUri;
}
CacheServer server = (CacheServer)
Activator.GetObject(typeof(CacheServer), objectUri, WellKnownObjectMode.Singleton);
int ccount = server.Caches.Count;
return(server);
}
catch (SocketException socketException)
{
throw;
}
catch (ManagementException mexp)
{
throw;
}
catch (Exception e)
{
throw new ManagementException(e.Message, e);
}
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return string length response</returns>
protected override async Task <IEnumerable <StringLengthResponse> > ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.StringLengthAsync(server, this).ConfigureAwait(false));
}
public ServerHandShakeHandler(TcpClient tcp, CacheServer server, Guid tempGuid) : base(tcp, server.Config)
{
this.TemporaryID = tempGuid;
this._server = server;
}
protected override async Task <SetCombineAndStoreResponse> ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.SetCombineAndStoreAsync(server, this).ConfigureAwait(false));
}
public void Init()
{
cacheSrv = CacheServer.Instance;
cfgSvc = CfgSvc.Instance;
PECommon.Log("GuideSystem Init Done");
}
public ServerInfo GetServerObj(int gameID, int serverId)
{
CacheServer cacheServer = new CacheServer();
return cacheServer.GetServers(gameID, serverId);
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return hash increment response</returns>
protected override async Task <HashIncrementResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.HashIncrementAsync(server, this).ConfigureAwait(false));
}
public ServerInfo[] GetServerSortList(int gameID)
{
CacheServer cacheServer = new CacheServer();
return cacheServer.GetServerList(gameID, true).ToArray();
}
/// <summary>
/// Get config connection
/// </summary>
/// <param name="cacheServer">Cache server</param>
/// <returns></returns>
public static ConnectionMultiplexer GetConfigConnection(CacheServer cacheServer)
{
ConnectionMultiplexers.TryGetValue(cacheServer?.Name, out var conn);
return(conn);
}
public void SetActiveNum(int serverID, int gameID, int activeNum)
{
CacheServer cacheServer = new CacheServer();
cacheServer.SetActiveNum(serverID, gameID, activeNum);
}
protected override async Task <StringSetBitResponse> ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.StringSetBitAsync(server, this).ConfigureAwait(false));
}
public string GetServerName(int gameID, int serverID)
{
CacheServer cacheServer = new CacheServer();
var info = cacheServer.GetServers(gameID, serverID);
return info == null ? "" : info.ServerName;
}
public LatentCacheServer(CacheServer cacheServer, int latencyInMilliSeconds)
{
_cacheServer = cacheServer;
LatencyInMilliSeconds = latencyInMilliSeconds;
}
public void EnableServer(int gameID, int serverID, bool isEnable)
{
CacheServer cacheServer = new CacheServer();
cacheServer.EnableServer(gameID, serverID, isEnable);
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return get key detail response</returns>
protected override async Task <IEnumerable <GetDetailResponse> > ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.GetKeyDetailAsync(server, this).ConfigureAwait(false));
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return sorted set decrement response</returns>
protected override async Task <IEnumerable <SortedSetDecrementResponse> > ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.SortedSetDecrementAsync(server, this).ConfigureAwait(false));
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return exists key response</returns>
protected override Task <ExistsResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
throw new NotImplementedException();
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return string append response</returns>
protected override async Task <StringAppendResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.StringAppendAsync(server, this).ConfigureAwait(false));
}
public void SetServerEnableDate(int gameID, int serverID, DateTime enableDate)
{
CacheServer cacheServer = new CacheServer();
cacheServer.SetServerEnableDate(gameID, serverID, enableDate);
}
protected override async Task <ClearDataResponse> ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.ClearDataAsync(server, this).ConfigureAwait(false));
}
public bool ReloadServer(int gameID)
{
CacheServer cacheServer = new CacheServer();
return(cacheServer.ReloadServer(gameID));
}
public void Init()
{
PECommon.Log("LoginSystem Init Done");
cacheSrv = CacheServer.Instance;
}
protected override async Task <ListSetByIndexResponse> ExecuteCommandAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.ListSetByIndexAsync(server, this).ConfigureAwait(false));
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return right pop left push response</returns>
protected override async Task <ListRightPopLeftPushResponse> ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.ListRightPopLeftPushAsync(server, this).ConfigureAwait(false));
}
public void ServerStatus(int gameID, int serverID, int Status)
{
CacheServer cacheServer = new CacheServer();
cacheServer.ServerStatus(gameID, serverID, Status);
}
/// <summary>
/// Execute cache operation
/// </summary>
/// <param name="cacheProvider">Cache provider</param>
/// <param name="server">Cache server</param>
/// <returns>Return insert before response</returns>
protected override async Task <IEnumerable <ListInsertBeforeResponse> > ExecuteCacheOperationAsync(ICacheProvider cacheProvider, CacheServer server)
{
return(await cacheProvider.ListInsertBeforeAsync(server, this).ConfigureAwait(false));
}
void conToCacheServer(string ip)
{
UriBuilder uriBuilder = new UriBuilder(ip);
uriBuilder.Port = Convert.ToInt32(ConfigurationManager.AppSettings["cacheServicePort"].ToString());
cs = new CacheServer(uriBuilder.Uri.ToString());
Console.WriteLine("Запущен клиент сервиса кэш-сервера");
string msmqName = ConfigurationManager.AppSettings["cacheMSMQName"];
cacheMSMQ = new MSMQClient(ip, msmqName);
}
