private Dictionary <string, string> stats(HostNode pool)
{
if (pool == null)
{
return(null);
}
Dictionary <string, string> dic = new Dictionary <string, string>();
hostServer.Execute(pool, delegate(MSocket socket)
{
using (RedisCommand cmd = new RedisCommand(socket, 1, "info"))
{
}
string result = socket.ReadResponse();
if (!string.IsNullOrEmpty(result) && (result[0] == '$' || result == "+OK"))
{
string line = null;
while (true)
{
line = socket.ReadLine();
if (line == null)
{
break;
}
string[] s = line.Split(':');
dic.Add(s[0], s[1]);
}
}
});
return(dic);
}
public MSocket(HostNode socketPool, IPEndPoint endPoint)
{
this.socketPool = socketPool;
CreateTime = DateTime.Now;
//Set up the socket.
socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.NoDelay, true);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, sendReceiveTimeout);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, sendReceiveTimeout);
socket.ReceiveTimeout = sendReceiveTimeout;
socket.SendTimeout = sendReceiveTimeout;
//socket.SendBufferSize = 1024 * 1024;
//Do not use Nagle's Algorithm
//socket.NoDelay = true;
//Establish connection asynchronously to enable connect timeout.
IAsyncResult result = socket.BeginConnect(endPoint, null, null);
bool success = result.AsyncWaitHandle.WaitOne(connectTimeout, false);
if (!success)
{
try { socket.Close(); }
catch { }
throw new SocketException();
}
socket.EndConnect(result);
//Wraps two layers of streams around the socket for communication.
stream = new BufferedStream(new NetworkStream(socket, false));
}
internal void Execute(HostNode host, UseSocket use)
{
MSocket sock = null;
try
{
//Acquire a socket
sock = host.Acquire();
//Use the socket as a parameter to the delegate and return its result.
if (sock != null)
{
use(sock);
}
}
catch (Exception e)
{
logger.Error("Error in Execute: " + host.Host, e);
//Socket is probably broken
if (sock != null)
{
sock.Close();
}
}
finally
{
if (sock != null)
{
sock.ReturnPool();
}
}
}
private Dictionary <string, string> GetInfoByHost(HostNode host, bool isBackup)
{
Dictionary <string, string> result = new Dictionary <string, string>();
if (!host.IsEndPointDead)
{
if (!isBackup)
{
OkServer++;
}
result.Add("Status", "Ok");
result.Add("Sockets in pool", host.Poolsize.ToString());
result.Add("Acquired sockets", host.Acquired.ToString());
result.Add("Sockets reused", host.ReusedSockets.ToString());
result.Add("New sockets created", host.NewSockets.ToString());
result.Add("New sockets failed", host.FailedNewSockets.ToString());
result.Add("Sockets died in pool", host.DeadSocketsInPool.ToString());
result.Add("Sockets died on return", host.DeadSocketsOnReturn.ToString());
}
else
{
if (!isBackup)
{
ErrorServer++;
}
result.Add("Status", "Dead , next retry at : " + host.DeadEndPointRetryTime);
result.Add("Error", host.Error);
if (host.HostNodeBak != null)
{
result.Add("Backup - " + host.HostNodeBak.Host, JsonHelper.ToJson(GetInfoByHost(host.HostNodeBak, true)));
}
}
return(result);
}
private void AddHost(MList <string> hosts)
{
foreach (string host in hosts.List)
{
HostNode instance = new HostNode(this, host);
instance.OnAfterSocketCreateEvent += new HostNode.OnAfterSocketCreateDelegate(instance_OnAfterSocketCreateEvent);
hostList.Add(host, instance);
}
}
public MSocket(HostNode socketPool, string host)
{
this.hostNode = socketPool;
CreateTime = DateTime.Now;
socket = SocketCreate.New(host);
//Wraps two layers of streams around the socket for communication.
stream = new BufferedStream(new NetworkStream(socket, false));
}
//internal HostInstance GetSocketPool(string host)
//{
// return Array.Find(HostList, delegate(HostInstance socketPool) { return socketPool.Host == host; });
//}
/// <summary>
/// This method executes the given delegate on a socket from the server that corresponds to the given hash.
/// If anything causes an error, the given defaultValue will be returned instead.
/// This method takes care of disposing the socket properly once the delegate has executed.
/// </summary>
internal T Execute <T>(uint hash, T defaultValue, UseSocket <T> use)
{
HostNode node = GetHost(hash);
if (node.HostNodeBak == null && hostServerBak != null)
{
//为主Socket池挂接备份的Socket池
node.HostNodeBak = hostServerBak.GetHost(hash, node.Host);
}
return(Execute(node, defaultValue, use));
}
public bool FlushAll()
{
foreach (KeyValuePair <string, HostNode> item in hostServer.HostList)
{
HostNode pool = item.Value;
hostServer.Execute(pool, delegate(MSocket socket)
{
using (RedisCommand cmd = new RedisCommand(socket, 1, "flushall"))
{
cmd.Send();
socket.SkipToEndOfLine();
}
});
}
return(true);
}
private Dictionary <string, string> stats(HostNode pool)
{
if (pool == null)
{
return(null);
}
Dictionary <string, string> result = new Dictionary <string, string>();
hostServer.Execute(pool, delegate(MSocket socket)
{
socket.Write("stats\r\n");
string line;
while (!(line = socket.ReadResponse().TrimEnd('\0', '\r', '\n')).StartsWith("END"))
{
string[] s = line.Split(' ');
result.Add(s[1], s[2]);
}
});
return(result);
}
public bool FlushAll(TimeSpan delay, bool staggered)
{
bool noerrors = true;
uint count = 0;
foreach (KeyValuePair <string, HostNode> item in hostServer.HostList)
{
HostNode pool = item.Value;
hostServer.Execute(pool, delegate(MSocket socket)
{
uint delaySeconds = (staggered ? (uint)delay.TotalSeconds * count : (uint)delay.TotalSeconds);
//Funnily enough, "flush_all 0" has no effect, you have to send "flush_all" to flush immediately.
socket.Write("flush_all " + (delaySeconds == 0 ? "" : delaySeconds.ToString()) + "\r\n");
if (!socket.ReadResponse().StartsWith("OK"))
{
noerrors = false;
}
count++;
});
}
return(noerrors);
}
private object[] get(string command, string[] keys, bool keysAreChecked, uint[] hashes, out ulong[] uniques)
{
//Check arguments.
if (keys == null || hashes == null)
{
throw new ArgumentException("Keys and hashes arrays must not be null.");
}
if (keys.Length != hashes.Length)
{
throw new ArgumentException("Keys and hashes arrays must be of the same length.");
}
uniques = new ulong[keys.Length];
//Avoid going through the server grouping if there's only one key.
if (keys.Length == 1)
{
return(new object[] { get(command, keys[0], keysAreChecked, hashes[0], out uniques[0]) });
}
//Check keys.
if (!keysAreChecked)
{
for (int i = 0; i < keys.Length; i++)
{
checkKey(keys[i]);
}
}
//Group the keys/hashes by server(pool)
Dictionary <HostNode, Dictionary <string, List <int> > > dict = new Dictionary <HostNode, Dictionary <string, List <int> > >();
for (int i = 0; i < keys.Length; i++)
{
Dictionary <string, List <int> > getsForServer;
HostNode pool = hostServer.GetHost(hashes[i]);
if (!dict.TryGetValue(pool, out getsForServer))
{
dict[pool] = getsForServer = new Dictionary <string, List <int> >();
}
List <int> positions;
if (!getsForServer.TryGetValue(keys[i], out positions))
{
getsForServer[keys[i]] = positions = new List <int>();
}
positions.Add(i);
}
//Get the values
object[] returnValues = new object[keys.Length];
ulong[] _uniques = new ulong[keys.Length];
foreach (KeyValuePair <HostNode, Dictionary <string, List <int> > > kv in dict)
{
hostServer.Execute(kv.Key, delegate(MSocket socket)
{
//Build the get request
StringBuilder getRequest = new StringBuilder(command);
foreach (KeyValuePair <string, List <int> > key in kv.Value)
{
getRequest.Append(" ");
getRequest.Append(key.Key);
}
getRequest.Append("\r\n");
//Send get request
socket.Write(getRequest.ToString());
//Read values, one by one
object gottenObject;
string gottenKey;
ulong unique;
while (readValue(socket, out gottenObject, out gottenKey, out unique))
{
foreach (int position in kv.Value[gottenKey])
{
returnValues[position] = gottenObject;
_uniques[position] = unique;
}
}
});
}
uniques = _uniques;
return(returnValues);
}
