private static string Read(Stream stream)
{
var type = RedisReader.ReadType(stream);
if (type == RedisMessage.Bulk)
{
return(RedisReader.ReadBulkString(stream, false));
}
RedisReader.ReadMultiBulk(stream, false);
return(null);
}
static RedisSentinelRole ParseSentinel(int num, string role, RedisReader reader)
{
reader.ExpectSize(2, num);
reader.ExpectType(RedisMessage.MultiBulk);
string[] masters = new string[reader.ReadInt(false)];
for (int i = 0; i < masters.Length; i++)
{
masters[i] = reader.ReadBulkString();
}
return(new RedisSentinelRole(role, masters));
}
private static DateTime ParseStream(Stream stream)
{
string[] parts = RedisReader.ReadMultiBulkString(stream);
int timestamp = Int32.Parse(parts[0]);
int microseconds = Int32.Parse(parts[1]);
long ticks = microseconds * (TimeSpan.TicksPerMillisecond / 1000);
return(RedisArgs.Epoch
+ TimeSpan.FromSeconds(timestamp)
+ TimeSpan.FromTicks(ticks));
}
public override long?Parse(RedisReader reader)
{
RedisMessage type = reader.ReadType();
if (type == RedisMessage.Int)
{
return(reader.ReadInt(false));
}
reader.ReadBulkString(false);
return(null);
}
public override string Parse(RedisReader reader)
{
RedisMessage type = reader.ReadType();
if (type == RedisMessage.Bulk)
{
return(reader.ReadBulkString(false));
}
reader.ReadMultiBulk(false);
return(null);
}
private static long?ParseStream(Stream stream)
{
RedisMessage type = RedisReader.ReadType(stream);
if (type == RedisMessage.Int)
{
return(RedisReader.ReadInt(stream, false));
}
RedisReader.ReadBulkUTF8(stream, false);
return(null);
}
private static Dictionary <string, string>[] ParseStream(Stream stream)
{
object[] response = RedisReader.ReadMultiBulk(stream);
Dictionary <string, string>[] dicts = new Dictionary <string, string> [response.Length];
for (int i = 0; i < response.Length; i++)
{
object[] hash = response[i] as object[];
dicts[i] = HashMapper.ToDict(hash);
}
return(dicts);
}
public override Tuple <string, string> Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
long count = reader.ReadInt(false);
if (count != 2)
{
return(null); //使用 BLPop 命令在 RedisArray.cs 中报错的解决办法。 #22
}
//reader.ExpectSize(2);
return(Tuple.Create(reader.ReadBulkString(), reader.ReadBulkString()));
}
public override T Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
long count = reader.ReadInt(false);
T[] array = new T[count];
for (int i = 0; i < array.Length; i++)
{
array[i] = _command.Parse(reader);
}
return(array[_index]);
}
public override Tuple <T1, T2> Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
long count = reader.ReadInt(false);
if (count != 2)
{
throw new RedisProtocolException("Expected 2 items");
}
return(Create(reader));
}
void InitReader()
{
if (_stream != null)
{
_stream.Dispose();
}
_stream = new BufferedStream(new NetworkStream(_socket));
_reader = new RedisReader(_encoding, _stream);
_pipeline = new RedisPipeline(_stream, _encoding, _reader);
_connectionTaskSource.SetResult(_socket.Connected);
OnConnected();
}
public StockTickRepository(QuantitativeAnalysis.DataAccess.Infrastructure.ConnectionType type, IDataSource ds, bool redis = false)
{
transDateRepo = new TransactionDateTimeRepository(type);
sqlReader = new SqlServerReader(type);
sqlWriter = new SqlServerWriter(type);
dataSource = ds;
this.redis = redis;
if (redis == true)
{
redisWriter = new RedisWriter();
redisReader = new RedisReader();
}
}
protected virtual T[] Read(long count, RedisReader reader)
{
if (count < 0)
{
return(null);
}
T[] array = new T[count];
for (int i = 0; i < array.Length; i++)
{
array[i] = _memberCommand.Parse(reader);
}
return(array);
}
public override RedisScan <T> Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
if (reader.ReadInt(false) != 2)
{
throw new RedisProtocolException("Expected 2 items");
}
long cursor = Int64.Parse(reader.ReadBulkString());
T[] items = _command.Parse(reader);
return(new RedisScan <T>(cursor, items));
}
static RedisSubscriptionMessage ParseMessage(string type, RedisReader reader)
{
if (type == "message")
{
return(new RedisSubscriptionMessage(type, reader.ReadBulkString(), reader.ReadBulkString()));
}
else if (type == "pmessage")
{
return(new RedisSubscriptionMessage(type, reader.ReadBulkString(), reader.ReadBulkString(), reader.ReadBulkString()));
}
throw new RedisProtocolException("Unexpected type " + type);
}
public StockDailyRepository(QuantitativeAnalysis.DataAccess.Infrastructure.ConnectionType type, IDataSource dataSource, bool redis = false)
{
sqlReader = new SqlServerReader(type);
sqlWriter = new SqlServerWriter(type);
dateRepo = new TransactionDateTimeRepository(type);
sqlReader170 = new SqlServerReader(Infrastructure.ConnectionType.Server170);
this.dataSource = dataSource;
this.redis = redis;
if (redis == true)
{
RedisReader redisReader = new RedisReader();
RedisWriter redisWriter = new RedisWriter();
}
}
static RedisSubscriptionChannel ParseChannel(string type, RedisReader reader)
{
switch (type)
{
case "subscribe":
case "unsubscribe":
return(new RedisSubscriptionChannel(type, reader.ReadBulkString(), null, reader.ReadInt()));
case "psubscribe":
case "punsubscribe":
return(new RedisSubscriptionChannel(type, null, reader.ReadBulkString(), reader.ReadInt()));
}
throw new RedisProtocolException("Unexpected type " + type);
}
private static Dictionary <string, string>[] ParseStream(Stream stream, string[] fields)
{
string[] response = RedisReader.ReadMultiBulkString(stream);
Dictionary <string, string>[] dicts = new Dictionary <string, string> [response.Length / fields.Length];
for (int i = 0; i < response.Length; i += fields.Length)
{
dicts[i / fields.Length] = new Dictionary <string, string>();
for (int j = 0; j < fields.Length; j++)
{
dicts[i / fields.Length][fields[j]] = response[i + j];
}
}
return(dicts);
}
public override string Parse(RedisReader reader)
{
RedisMessage type = reader.ReadType();
if ((int)type == -1)
{
return(String.Empty);
}
else if (type == RedisMessage.Error)
{
throw new RedisException(reader.ReadStatus(false));
}
throw new RedisProtocolException("Unexpected type: " + type);
}
private static string ParseStream(Stream stream)
{
RedisMessage type = RedisReader.ReadType(stream);
if (type == RedisMessage.Status)
{
return(RedisReader.ReadStatus(stream, false));
}
object[] result = RedisReader.ReadMultiBulk(stream, false);
if (result != null)
{
throw new RedisProtocolException("Expecting null MULTI BULK response. Received: " + result.ToString());
}
return(null);
}
public override T Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
long count = reader.ReadInt(false);
if (count == -1)
{
return(default(T)); //使用 BLPop 命令在 RedisArray.cs 中报错的解决办法。 #22
}
T[] array = new T[count];
for (int i = 0; i < array.Length; i++)
{
array[i] = _command.Parse(reader);
}
return(array[_index]);
}
public override RedisSlowLogEntry Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
reader.ExpectSize(4);
long id = reader.ReadInt();
long timestamp = reader.ReadInt();
long microseconds = reader.ReadInt();
reader.ExpectType(RedisMessage.MultiBulk);
string[] arguments = new string[reader.ReadInt(false)];
for (int i = 0; i < arguments.Length; i++)
{
arguments[i] = reader.ReadBulkString();
}
return(new RedisSlowLogEntry(id, RedisDate.FromTimestamp(timestamp), RedisDate.Micro.FromMicroseconds(microseconds), arguments));
}
static RedisScanPair ParseStream(Stream stream)
{
object[] parts = RedisReader.ReadMultiBulk(stream);
object[] values = parts[1] as object[];
RedisScanPair result = new RedisScanPair
{
Cursor = ParseCursor(parts[0]),
Items = new Dictionary <string, object>(),
};
for (int i = 0; i < values.Length; i += 2)
{
result.Items[values[i] as String] = values[i + 1];
}
return(result);
}
static RedisScan ParseStream(Stream stream)
{
RedisReader.ExpectType(stream, RedisMessage.MultiBulk);
long count = RedisReader.ReadInt(stream, false);
RedisScan scan = new RedisScan();
scan.Cursor = Int64.Parse(RedisReader.Read(stream).ToString());
RedisReader.ExpectType(stream, RedisMessage.MultiBulk);
scan.Items = new string[RedisReader.ReadInt(stream, false)];
for (int i = 0; i < scan.Items.Length; i++)
{
scan.Items[i] = RedisReader.Read(stream).ToString();
}
return(scan);
}
public override string Parse(RedisReader reader)
{
RedisMessage type = reader.ReadType();
if (type == RedisMessage.Status)
{
return(reader.ReadStatus(false));
}
object[] result = reader.ReadMultiBulk(false);
if (result != null && result.Length > 0)
{
throw new RedisProtocolException("Expecting null MULTI BULK response for command '" + this.Command + "'. Received: " + String.Join(", ", result));
}
return(null);
}
public override string Parse(RedisReader reader)
{
RedisMessage type = reader.ReadType();
if (type == RedisMessage.Status)
{
return(reader.ReadStatus(false));
}
object[] result = reader.ReadMultiBulk(false);
if (result != null)
{
throw new RedisProtocolException("Expecting null MULTI BULK response. Received: " + result.ToString());
}
return(null);
}
public MockConnector(string host, int port, params byte[][] mockResponses)
{
_host = host;
_port = port;
_encoding = new RedisEncoding();
_written = new MemoryStream();
_responses = new MemoryStream();
_writer = new RedisWriter(_encoding);
_reader = new RedisReader(_encoding, _responses);
_messages = new ConcurrentQueue <Tuple <long, int> >();
_pipeline = new RedisPipeline(_written, _encoding, _reader);
for (int i = 0; i < mockResponses.Length; i++)
{
_responses.Write(mockResponses[i], 0, mockResponses[i].Length);
}
_responses.Position = 0;
}
static RedisMasterRole ParseMaster(int num, string role, RedisReader reader)
{
reader.ExpectSize(3, num);
long offset = reader.ReadInt();
reader.ExpectType(RedisMessage.MultiBulk);
var slaves = new Tuple <string, int, int> [reader.ReadInt(false)];
for (int i = 0; i < slaves.Length; i++)
{
reader.ExpectType(RedisMessage.MultiBulk);
reader.ExpectSize(3);
string ip = reader.ReadBulkString();
int port = Int32.Parse(reader.ReadBulkString());
int slave_offset = Int32.Parse(reader.ReadBulkString());
slaves[i] = new Tuple <string, int, int>(ip, port, slave_offset);
}
return(new RedisMasterRole(role, offset, slaves));
}
public override Dictionary <string, string> Parse(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
long count = reader.ReadInt(false);
var dict = new Dictionary <string, string>();
string key = string.Empty;
for (int i = 0; i < count; i++)
{
if (i % 2 == 0)
{
key = reader.ReadBulkString();
}
else
{
dict[key] = reader.ReadBulkString();
}
}
return(dict);
}
static Dictionary <string, byte[]> ToDict(RedisReader reader)
{
reader.ExpectType(RedisMessage.MultiBulk);
long count = reader.ReadInt(false);
var dict = new Dictionary <string, byte[]>();
string key = String.Empty;
for (int i = 0; i < count; i++)
{
if (i % 2 == 0)
{
key = reader.ReadBulkString();
}
else
{
dict[key] = reader.ReadBulkBytes();
}
}
return(dict);
}
