protected TValue Call <TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
_redisSocket.Write(cmd);
var rt = _redisSocket.Read(false);
return(parse(rt));
}
protected T2 Call <T1, T2>(CommandPacket cmd, Func <RedisResult <T1>, T2> parse)
{
_redisSocket.Write(cmd);
var result = cmd.Read <T1>();
return(parse(result));
}
protected TValue Call <TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
_redisSocket.Write(cmd);
var result = cmd.Read <string>();
return(parse(result));
}
public override TValue AdapaterCall <TReadTextOrStream, TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
_redisSocket.Write(cmd);
var rt = cmd.Read <TReadTextOrStream>();
rt.IsErrorThrow = TopOwner._isThrowRedisSimpleError;
return(parse(rt));
}
public override TValue AdapterCall <TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
TryMulti();
return(TopOwner.LogCall(cmd, () =>
{
_redisSocket.Write(cmd);
_redisSocket.Read(cmd._flagReadbytes).ThrowOrValue <TValue>(useDefaultValue: true);
_commands.Add(new TransactionCommand
{
Command = cmd,
Parse = obj => parse(new RedisResult(obj, true, RedisMessageType.SimpleString)
{
Encoding = _redisSocket.Encoding
})
});
return default(TValue);
}));
}
public override TValue AdapaterCall <TReadTextOrStream, TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
TryMulti();
return(TopOwner.LogCall(cmd, () =>
{
_redisSocket.Write(cmd);
cmd.Read <TReadTextOrStream>().ThrowOrValue <TValue>();
cmd._readed = false; //exec 还需要再读一次
_commands.Add(new TransactionCommand
{
Command = cmd,
Parse = obj => parse(new RedisResult(obj, true, RedisMessageType.SimpleString)
{
Encoding = _redisSocket.Encoding
})
});
return default(TValue);
}));
}
public override T2 AdapaterCall <T1, T2>(CommandPacket cmd, Func <RedisResult <T1>, T2> parse)
{
return(_cli.LogCall(cmd, () =>
{
_redisSocket.Write(cmd);
var rt = cmd.Read <T1>();
rt.IsErrorThrow = _cli._isThrowRedisSimpleError;
return parse(rt);
}));
}
public override T2 AdapaterCall <T1, T2>(CommandPacket cmd, Func <RedisResult <T1>, T2> parse)
{
TryMulti();
return(_cli.LogCall(cmd, () =>
{
_redisSocket.Write(cmd);
cmd.Read <T1>().ThrowOrValue();
cmd._readed = false; //exec 还需要再读一次
_commands.Add(new TransactionCommand
{
Command = cmd,
Parse = obj => parse(new RedisResult <T1>(obj.ConvertTo <T1>(), null, true, RedisMessageType.SimpleString)
{
Encoding = _redisSocket.Encoding
})
});
return default(T2);
}));
}
public override TValue AdapterCall <TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
return(TopOwner.LogCall(cmd, () =>
{
_redisSocket.Write(cmd);
var rt = _redisSocket.Read(cmd);
if (cmd._command == "QUIT")
{
_redisSocket.ReleaseSocket();
}
return parse(rt);
}));
}
public override TValue AdapterCall <TValue>(CommandPacket cmd, Func <RedisResult, TValue> parse)
{
return(TopOwner.LogCall(cmd, () =>
{
_redisSocket.Write(cmd);
var rt = _redisSocket.Read(cmd._flagReadbytes);
if (cmd._command == "QUIT")
{
_redisSocket.ReleaseSocket();
}
rt.IsErrorThrow = TopOwner._isThrowRedisSimpleError;
return parse(rt);
}));
}
internal void Call(CommandPacket cmd)
{
_topOwner.LogCall <object>(cmd, () =>
{
if (IsSubscribed == false)
{
throw new RedisClientException($"Subscription not opened, unable to execute");
}
if (_stoped == false && _redisSocket?.IsConnected == true)
{
lock (_lock)
_redisSocket?.Write(cmd);
}
return(null);
});
}
internal void Call(CommandPacket cmd)
{
_topOwner.LogCall <object>(cmd, () =>
{
if (_redisSocket != null)
{
lock (_lock)
if (_redisSocket != null)
{
_redisSocket.Write(cmd);
}
}
if (_redisSocket == null)
{
throw new Exception($"Subscription not opened, unable to execute");
}
return(null);
});
}
internal IDisposable Subscribe(bool psub, string[] channels, Action <string, string, object> handler)
{
if (_stoped)
{
return(new PubSubSubscribeDisposable(this, null));
}
channels = channels?.Distinct().Where(a => !string.IsNullOrEmpty(a)).ToArray(); //In case of external modification
if (channels?.Any() != true)
{
return(new PubSubSubscribeDisposable(this, null));
}
var id = Guid.NewGuid();
var time = DateTime.Now;
var regkeys = channels.Select(a => psub ? $"{_psub_regkey_prefix}{a}" : a).ToArray();
for (var a = 0; a < regkeys.Length; a++)
{
ConcurrentDictionary <Guid, RegisterInfo> dict = null;
lock (_lock) dict = _registers.GetOrAdd(regkeys[a], k1 => new ConcurrentDictionary <Guid, RegisterInfo>());
dict.TryAdd(id, new RegisterInfo(id, handler, time));
}
lock (_lock)
_cancels.TryAdd(id, regkeys);
var isnew = false;
if (IsSubscribed == false)
{
lock (_lock)
{
if (IsSubscribed == false)
{
_redisSocket = _topOwner.Adapter.GetRedisSocket(null);
IsSubscribed = isnew = true;
}
}
}
if (isnew)
{
new Thread(() =>
{
_redisSocketReceiveTimeoutOld = _redisSocket.ReceiveTimeout;
_redisSocket.ReceiveTimeout = TimeSpan.Zero;
var timer = new Timer(state =>
{
_topOwner.Adapter.Refersh(_redisSocket); //防止 IdleBus 超时回收
try { _redisSocket.Write("PING"); } catch { }
}, null, 10000, 10000);
var readCmd = "PubSubRead".SubCommand(null).FlagReadbytes(false);
while (_stoped == false)
{
RedisResult rt = null;
try
{
rt = _redisSocket.Read(readCmd);
}
catch
{
Thread.CurrentThread.Join(100);
if (_cancels.Any())
{
continue;
}
break;
}
var val = rt.Value as object[];
if (val == null)
{
continue; //special case
}
var val1 = val[0].ConvertTo <string>();
switch (val1)
{
case "pong":
case "punsubscribe":
case "unsubscribe":
continue;
case "pmessage":
OnData(val[1].ConvertTo <string>(), val[2].ConvertTo <string>(), val[3]);
continue;
case "message":
OnData(null, val[1].ConvertTo <string>(), val[2]);
continue;
}
}
timer.Dispose();
lock (_lock)
{
IsSubscribed = false;
_redisSocket.ReceiveTimeout = _redisSocketReceiveTimeoutOld;
_redisSocket.ReleaseSocket();
_redisSocket.Dispose();
_redisSocket = null;
}
}).Start();
}
Call((psub ? "PSUBSCRIBE" : "SUBSCRIBE").Input(channels));
return(new PubSubSubscribeDisposable(this, () => Cancel(id)));
}
