public ClientHandler(IConnectionService connectionService, IStreamHandler streamHandler,
ILogger <ClientHandler> logger)
{
this.connectionService = connectionService;
this.streamHandler = streamHandler;
this.logger = logger;
}
public when_WriteMemoryStreamToFile()
{
_unitTestFilePath = System.AppDomain.CurrentDomain.BaseDirectory;
_unitTestFilePath += "awdawd.data";
_buffer = new byte[80000000]; // 80 MB
_streamHandler = new StreamHandler();
}
public when_CopyStreamToByteBuffer()
{
_streamHandler = new StreamHandler();
var bytearray = new byte[666];
_stream = new MemoryStream(bytearray);
}
private void SetupStorage()
{
if (m_stream != null)
{
return;
}
m_stream = m_streamCreator.OpenStream();
m_streamCreator = null;
List <Declaration> declarations = m_unifiedObjectCreator.GetDeclarations();
if (m_fromExistingStream)
{
m_reader = new IntermediateFormatReader(m_stream, m_unifiedObjectCreator, m_globalIdsFromOtherStream, m_scalabilityCache);
if (m_stream.CanWrite)
{
m_writer = new IntermediateFormatWriter(m_stream, m_stream.Length, declarations, m_scalabilityCache, m_rifCompatVersion, m_prohibitSerializableValues);
m_writerSetup = true;
}
m_atEnd = false;
}
else
{
m_writer = new IntermediateFormatWriter(m_stream, declarations, m_scalabilityCache, m_rifCompatVersion, m_prohibitSerializableValues);
m_writerSetup = true;
m_reader = new IntermediateFormatReader(m_stream, m_unifiedObjectCreator, m_globalIdsFromOtherStream, m_scalabilityCache, declarations, Microsoft.ReportingServices.ReportIntermediateFormat.Persistence.IntermediateFormatVersion.Current, PersistenceFlags.Seekable);
m_atEnd = true;
}
m_fromExistingStream = true;
}
public when_WriteMemoryStreamToFile()
{
_unitTestFilePath = System.AppDomain.CurrentDomain.BaseDirectory;
_unitTestFilePath += "awdawd.data";
_buffer = new byte[80000000]; // 80 MB
_streamHandler = new StreamHandler();
}
public Form1()
{
InitializeComponent();
processHandler = new ProcessHandler();
streamHandler = new StreamHandler(processHandler);
processHandler.TranscriptDataAvailable += ProcessHandler_TranscriptDataAvailable;
}
public when_handleUpload()
{
_streamHandler = A.Fake<IStreamHandler>();
_hostingEnvironment = A.Fake<IHostingEnvironment>();
_fileUploadHandler = new FileUploadHandler(_streamHandler, _hostingEnvironment);
}
/// <summary>从配置文件中加载工厂</summary>
static void LoadConfig()
{
try
{
Dictionary <String, List <Type> > ts = GetHandler();
if (ts == null || ts.Count < 1)
{
return;
}
foreach (String item in ts.Keys)
{
// 倒序。后注册的处理器先处理，为了迎合写在前面的处理器优先处理，故倒序！
for (int i = ts[item].Count - 1; i >= 0; i--)
{
IStreamHandler handler = Activator.CreateInstance(ts[item][i]) as IStreamHandler;
Register(item, handler, true);
}
}
}
catch (Exception ex)
{
XTrace.WriteLine("从配置文件加载数据流处理器出错！" + ex.ToString());
}
}
/// <summary>处理数据流。Http、Tcp、Udp等所有数据流都将到达这里，多种传输方式汇聚于此，由数据流总线统一处理！</summary>
/// <param name="name"></param>
/// <param name="stream"></param>
public static void Process(String name, Stream stream)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
IStreamHandler[] fs = QueryRegister(name);
if (fs == null || fs.Length < 1)
{
throw new InvalidOperationException("没有找到" + name + "的处理器！");
}
foreach (IStreamHandler item in fs)
{
IStreamHandler handler = item;
if (!handler.IsReusable)
{
handler = item.Clone() as IStreamHandler;
}
stream = handler.Process(stream);
if (stream == null)
{
break;
}
}
}
private async Task Run(IStreamHandler handler, IOptions <BlobStorageOptions> options, BlobItem item, CancellationToken stoppingToken)
{
try
{
_logger.LogInformation(item.Name);
var leaseId = await _blobStorage.LeaseBlobAsync(options.Value.ContainerName, item, stoppingToken).ConfigureAwait(false);
var blob = _blobStorage.GetBlobClient(options.Value.ContainerName, item);
using var blobStream = await blob.OpenReadAsync(cancellationToken : stoppingToken).ConfigureAwait(false);
var result = await handler.HandleAsync(blob.Name, blobStream).ConfigureAwait(false);
if (result.HasSucceeded)
{
await _blobStorage.MoveBlobAsync(options.Value.ContainerName, item, leaseId, options.Value.ProcessedBlobs, stoppingToken).ConfigureAwait(false);
}
else
{
await _blobStorage.MoveBlobAsync(options.Value.ContainerName, item, leaseId, options.Value.RejectedBlobs, stoppingToken).ConfigureAwait(false);
}
}
catch (Exception e)
{
_logger.LogError($"An error occurred while processing blob {item.Name}: {e.Message}");
}
}
public when_DecryptData()
{
_streamHandler = new StreamHandler();
_encryptedData = new byte[16] {
230, 209, 2, 165, 181, 156, 96, 240, 38, 66, 226, 208, 109, 1, 108, 82
};
}
public when_handleUpload()
{
_streamHandler = A.Fake <IStreamHandler>();
_hostingEnvironment = A.Fake <IHostingEnvironment>();
_fileUploadHandler = new FileUploadHandler(_streamHandler, _hostingEnvironment);
}
/// <summary>
/// Parse streamed twitter event
/// </summary>
/// <param name="ev">event name</param>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">result handler</param>
private static void ParseStreamEvent(string ev, JsonValue graph, IStreamHandler handler)
{
try
{
var source = new TwitterUser(graph[EventSourceKey]);
var target = new TwitterUser(graph[EventTargetKey]);
var timestamp = graph[EventCreatedAtKey].AsString().ParseTwitterDateTime();
switch (ev)
{
case StreamStatusEvent.FavoriteEventKey:
case StreamStatusEvent.UnfavoriteEventKey:
case StreamStatusEvent.QuotedTweetEventKey:
case StreamStatusEvent.FavoritedRetweetEventKey:
case StreamStatusEvent.RetweetedRetweetEventKey:
handler.OnMessage(new StreamStatusEvent(source, target,
new TwitterStatus(graph[EventTargetObjectKey]), ev, timestamp));
break;
case StreamUserEvent.BlockEventKey:
case StreamUserEvent.UnblockEventKey:
case StreamUserEvent.FollowEventKey:
case StreamUserEvent.UnfollowEventKey:
case StreamUserEvent.UserMuteEventKey:
case StreamUserEvent.UserUnmuteEventKey:
case StreamUserEvent.UserUpdateEventKey:
case StreamUserEvent.UserDeleteEventKey:
case StreamUserEvent.UserSuspendEventKey:
handler.OnMessage(new StreamUserEvent(source, target,
ev, timestamp));
break;
case StreamListEvent.ListCreatedEventKey:
case StreamListEvent.ListDestroyedEventKey:
case StreamListEvent.ListUpdatedEventKey:
case StreamListEvent.ListMemberAddedEventKey:
case StreamListEvent.ListMemberRemovedEventKey:
case StreamListEvent.ListUserSubscribedEventKey:
case StreamListEvent.ListUserUnsubscribedEventKey:
handler.OnMessage(new StreamListEvent(source, target,
new TwitterList(graph[EventTargetObjectKey]), ev, timestamp));
break;
case StreamAccessInformationEvent.AccessRevokedEventKey:
case StreamAccessInformationEvent.AccessUnrevokedEventKey:
handler.OnMessage(new StreamAccessInformationEvent(source, target,
new AccessInformation(graph[EventTargetObjectKey]), ev, timestamp));
break;
default:
Debug.WriteLine("unknown event: " + ev);
break;
}
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"Event parse failed:" + ev, graph.ToString(), ex));
}
}
/// <summary>
/// Check parse streamed JSON line as normal (not direct-message) status
/// </summary>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">stream handler</param>
/// <returns></returns>
internal static bool ParseStreamLineAsStatus(dynamic graph, IStreamHandler handler)
{
if (!graph.text())
{
return(false);
}
handler.OnStatus(new TwitterStatus(graph));
return(true);
}
public static void EnsureGroupTreeStorageSetup(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory, GlobalIDOwnerCollection globalIDOwnerCollection, bool openExisting, int rifCompatVersion, bool prohibitSerializableValues)
{
if (odpMetadata.GroupTreeScalabilityCache == null)
{
IStreamHandler streamHandler = OnDemandProcessingManager.BuildChunkStreamHandler("GroupTree", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Main, chunkFactory, openExisting);
IStorage storage = new RIFAppendOnlyStorage(streamHandler, (IScalabilityObjectCreator)(object)default(GroupTreeRIFObjectCreator), GroupTreeReferenceCreator.Instance, globalIDOwnerCollection, openExisting, rifCompatVersion, prohibitSerializableValues);
odpMetadata.GroupTreeScalabilityCache = new GroupTreeScalabilityCache(odpMetadata.GroupTreePartitionManager, storage);
}
}
/// <summary>
/// Check parse streamed JSON line as normal (not direct-message) status
/// </summary>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">stream handler</param>
/// <returns></returns>
internal static bool ParseStreamLineAsStatus(JsonValue graph, IStreamHandler handler)
{
if (!graph.ContainsKey("text"))
{
return(false);
}
handler.OnStatus(new TwitterStatus(graph));
return(true);
}
public UserStreamsReceiver(TwitterAccount account)
{
_stateUpdater = new StateUpdater();
_handler = InitializeHandler();
_receiverTokenSource = new CancellationTokenSource();
_account = account;
_cancellationTokenSource = null;
ConnectionState = UserStreamsConnectionState.Disconnected;
}
public static void EnsureLookupStorageSetup(OnDemandMetadata odpMetadata, IChunkFactory chunkFactory, bool openExisting, int rifCompatVersion, bool prohibitSerializableValues)
{
if (odpMetadata.LookupScalabilityCache == null)
{
new AppendOnlySpaceManager();
IStreamHandler streamHandler = OnDemandProcessingManager.BuildChunkStreamHandler("LookupInfo", AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.LookupInfo, chunkFactory, openExisting);
IStorage storage = new RIFAppendOnlyStorage(streamHandler, (IScalabilityObjectCreator)(object)default(LookupRIFObjectCreator), LookupReferenceCreator.Instance, null, openExisting, rifCompatVersion, prohibitSerializableValues);
odpMetadata.LookupScalabilityCache = new LookupScalabilityCache(odpMetadata.LookupPartitionManager, storage);
}
}
public StreamSubscriber(ILogger <StreamSubscriber> logger,
IEventStoreDb eventStoreDb,
IStreamManager streamManager,
IStreamHandler streamHandler)
{
_logger = logger;
_streamManager = streamManager;
_streamHandler = streamHandler;
_eventStoreClient = eventStoreDb.GetClient();
}
internal RIFAppendOnlyStorage(IStreamHandler streamHandler, IScalabilityObjectCreator appObjectCreator, IReferenceCreator appReferenceCreator, GlobalIDOwnerCollection globalIdsFromOtherStream, bool fromExistingStream, int rifCompatVersion, bool prohibitSerializableValues)
{
m_streamCreator = streamHandler;
m_scalabilityCache = null;
m_stream = null;
m_unifiedObjectCreator = new UnifiedObjectCreator(appObjectCreator, appReferenceCreator);
m_referenceCreator = new UnifiedReferenceCreator(appReferenceCreator);
m_fromExistingStream = fromExistingStream;
m_globalIdsFromOtherStream = globalIdsFromOtherStream;
m_prohibitSerializableValues = prohibitSerializableValues;
m_rifCompatVersion = rifCompatVersion;
}
/// <summary>
/// Send and receive files from client.
/// </summary>
void ExchangeFiles(IStreamHandler streamHandler)
{
for (int i = 0; i < downloadList.Count; i++)
{
streamHandler.ReceiveData(folderToSync.FolderPath);
}
foreach (var file in uploadList)
{
streamHandler.SendData(folderToSync.FolderPath + @"\" + file);
}
}
public static void ParseStreamLine(JsonStringParser parser, string line, IStreamHandler handler)
{
try
{
var element = parser.Parse(line);
ParseStreamLine(element, handler);
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"JSON parse failed.", line, ex));
}
}
private static void PreparePartitionedTreeForAsyncSerialization(PartitionedTreeScalabilityCache scaleCache, OnDemandProcessingContext odpContext, string chunkName, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType)
{
if (scaleCache != null)
{
RIFAppendOnlyStorage rIFAppendOnlyStorage = scaleCache.Storage as RIFAppendOnlyStorage;
if (rIFAppendOnlyStorage != null)
{
IStreamHandler streamHandler = OnDemandProcessingManager.BuildChunkStreamHandler(chunkName, chunkType, odpContext.ChunkFactory, rIFAppendOnlyStorage.FromExistingStream);
rIFAppendOnlyStorage.Reset(streamHandler);
}
scaleCache.PrepareForFlush();
}
}
public static IDisposable SubscribeWithHandler(this IObservable<string> streamElements,
IStreamHandler handler, Action<Exception> onError = null,
Action onCompleted = null)
{
if (streamElements == null) throw new ArgumentNullException("streamElements");
if (handler == null) throw new ArgumentNullException("handler");
return streamElements
.Where(s => !String.IsNullOrWhiteSpace(s))
.ObserveOn(TaskPoolScheduler.Default)
.Select(s => DynamicJson.Parse(s))
.Subscribe(s => DispatchStreamingElements(s, handler),
onError ?? (ex => { }), onCompleted ?? (() => { }));
}
public UserStreamReceiver(ApiAccessor accessor, IStreamHandler handler)
{
_accessor = accessor;
_handler = handler;
ChangeState(StreamState.Disconnected);
// set default values to parameters
StallWarnings = true;
StreamFilterLevel = StreamFilterLevel.None;
_currentState = StreamState.Connected;
_backoffMode = BackoffMode.None;
_backoffWait = 0;
_hardErrorCount = 0;
}
/// <summary>
/// Parse streamed JSON line
/// </summary>
/// <param name="line">JSON line</param>
/// <param name="handler">result handler</param>
public static void ParseStreamLine(string line, IStreamHandler handler)
{
try
{
var element = DynamicJson.Parse(line);
ParseStreamLine(element, handler);
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"JSON parse failed.", line, ex));
}
}
/// <summary>
/// Parse streamed twitter event
/// </summary>
/// <param name="ev">event name</param>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">result handler</param>
private static void ParseStreamEvent(string ev, dynamic graph, IStreamHandler handler)
{
try
{
var source = new TwitterUser(graph.source);
var target = new TwitterUser(graph.target);
var timestamp = ((string)graph.created_at).ParseTwitterDateTime();
switch (ev)
{
case "favorite":
case "unfavorite":
case "quoted_tweet":
case "favorited_retweet":
case "retweeted_retweet":
handler.OnMessage(new StreamStatusEvent(source, target,
new TwitterStatus(graph.target_object), ev, timestamp));
break;
case "block":
case "unblock":
case "follow":
case "unfollow":
case "user_update":
case "mute":
case "unmute":
handler.OnMessage(new StreamUserEvent(source, target,
ev, timestamp));
break;
case "list_created":
case "list_destroyed":
case "list_updated":
case "list_member_added":
case "list_member_removed":
case "list_user_subscribed":
case "list_user_unsubscribed":
handler.OnMessage(new StreamListEvent(source, target,
new TwitterList(graph.target_object), ev, timestamp));
break;
default:
break;
}
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"Event parse failed:" + ev, graph.ToString(), ex));
}
}
public AesEncryption(byte[] key = null, byte[] iv = null)
{
streamHandler = new StreamHandler();
aesNative = new AesManaged();
if (key != null)
{
aesNative.Key = key;
}
if (iv != null)
{
aesNative.IV = iv;
}
}
public RIFStorage(IStreamHandler streamHandler, int bufferPageSize, int bufferPageCount, int tempStreamSize, ISpaceManager spaceManager, IScalabilityObjectCreator appObjectCreator, IReferenceCreator appReferenceCreator, GlobalIDOwnerCollection globalIdsFromOtherStream, bool fromExistingStream, int rifCompatVersion)
{
this.m_streamCreator = streamHandler;
this.m_scalabilityCache = null;
this.m_bufferPageSize = bufferPageSize;
this.m_bufferPageCount = bufferPageCount;
this.m_tempStreamSize = tempStreamSize;
this.m_stream = null;
this.m_spaceManager = spaceManager;
this.m_unifiedObjectCreator = new UnifiedObjectCreator(appObjectCreator, appReferenceCreator);
this.m_referenceCreator = new UnifiedReferenceCreator(appReferenceCreator);
this.m_fromExistingStream = fromExistingStream;
this.m_globalIdsFromOtherStream = globalIdsFromOtherStream;
this.m_rifCompatVersion = rifCompatVersion;
}
/// <summary>
/// Parse streamed JSON line
/// </summary>
/// <param name="line">JSON line</param>
/// <param name="handler">result handler</param>
public static void ParseStreamLine(string line, IStreamHandler handler)
{
try
{
var element = MeteorJson.Parse(line);
if (!ParseStreamLineAsStatus(element, handler))
{
ParseNotStatusStreamLine(element, handler);
}
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"JSON parse failed.", line, ex));
}
}
/// <summary>
/// Parse streamed JSON line
/// </summary>
/// <param name="line">JSON line</param>
/// <param name="handler">result handler</param>
public static void ParseStreamLine(string line, IStreamHandler handler)
{
try
{
var element = MeteorJson.Parse(line);
if (!ParseStreamLineAsStatus(element, handler))
{
ParseNotStatusStreamLine(element, handler);
}
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"JSON parse failed.", line, ex));
}
}
/// <summary>
/// Starts synhcronisation session.
/// </summary>
public void Synchronise(IStreamHandler streamHandler)
{
CheckLocalChanges();
streamHandler.ReceiveData(Directory.GetCurrentDirectory());
CompareDevicesSyncData();
if (ConflictExist())
{
streamHandler.SendData(CreateConflictFile());
streamHandler.ReceiveData(Directory.GetCurrentDirectory());
}
streamHandler.SendData(CreateExchangeFile());
ExchangeFiles(streamHandler);
DisposeSyncResources();
}
public IndexTable(IStreamHandler streamCreator, int pageSize, int cacheSize)
{
if (pageSize % 8 != 0)
{
Global.Tracer.Assert(false, "Page size must be divisible by value size: {0}", 8);
}
this.m_streamCreator = streamCreator;
this.m_stream = null;
this.m_nextTempId = -1L;
this.m_pageSize = pageSize;
this.m_cacheSize = cacheSize;
this.m_pageCache = new Dictionary <int, IndexTablePage>(this.m_cacheSize);
this.m_queueFirstPage = null;
this.m_queueLastPage = null;
this.m_slotsPerPage = this.m_pageSize / 8;
this.m_idShift = (int)Math.Log((double)this.m_slotsPerPage, 2.0);
}
private IndexTablePage GetPage(long id)
{
int num = this.CalcPageNum(id);
IndexTablePage indexTablePage = null;
if (!this.m_pageCache.TryGetValue(num, out indexTablePage))
{
if (this.m_pageCache.Count == this.m_cacheSize)
{
if (this.m_stream == null)
{
this.m_stream = this.m_streamCreator.OpenStream();
this.m_streamCreator = null;
if (!this.m_stream.CanSeek || !this.m_stream.CanRead || !this.m_stream.CanWrite)
{
Global.Tracer.Assert(false, "Must be able to Seek, Read, and Write stream");
}
}
indexTablePage = this.QueueExtractFirst();
int pageNumber = indexTablePage.PageNumber;
this.m_pageCache.Remove(pageNumber);
if (indexTablePage.Dirty)
{
long offset = this.CalcPageOffset(pageNumber);
this.m_stream.Seek(offset, SeekOrigin.Begin);
indexTablePage.Write(this.m_stream);
}
long offset2 = this.CalcPageOffset(num);
this.m_stream.Seek(offset2, SeekOrigin.Begin);
indexTablePage.Read(this.m_stream);
}
else
{
indexTablePage = new IndexTablePage(this.m_pageSize);
}
indexTablePage.PageNumber = num;
this.m_pageCache[num] = indexTablePage;
this.QueueAppendPage(indexTablePage);
}
return(indexTablePage);
}
private IndexTablePage GetPage(long id)
{
int num = CalcPageNum(id);
IndexTablePage value = null;
if (!m_pageCache.TryGetValue(num, out value))
{
if (m_pageCache.Count == m_cacheSize)
{
if (m_stream == null)
{
m_stream = m_streamCreator.OpenStream();
m_streamCreator = null;
if (!m_stream.CanSeek || !m_stream.CanRead || !m_stream.CanWrite)
{
Global.Tracer.Assert(condition: false, "Must be able to Seek, Read, and Write stream");
}
}
value = QueueExtractFirst();
int pageNumber = value.PageNumber;
m_pageCache.Remove(pageNumber);
if (value.Dirty)
{
long offset = CalcPageOffset(pageNumber);
m_stream.Seek(offset, SeekOrigin.Begin);
value.Write(m_stream);
}
long offset2 = CalcPageOffset(num);
m_stream.Seek(offset2, SeekOrigin.Begin);
value.Read(m_stream);
}
else
{
value = new IndexTablePage(m_pageSize);
}
value.PageNumber = num;
m_pageCache[num] = value;
QueueAppendPage(value);
}
return(value);
}
public static IDisposable SubscribeWithHandler(this IObservable <string> streamElements,
IStreamHandler handler, Action <Exception> onError = null,
Action onCompleted = null)
{
if (streamElements == null)
{
throw new ArgumentNullException("streamElements");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
return(streamElements
.Where(s => !String.IsNullOrWhiteSpace(s))
.ObserveOn(TaskPoolScheduler.Default)
.Select(s => DynamicJson.Parse(s))
.Subscribe(
s => DispatchStreamingElements(s, handler),
onError ?? (ex => { }),
onCompleted ?? (() => { })));
}
public Session(IStreamHandler streamHandler, Socket socket, Guid sessionId)
{
SessionId = sessionId;
Socket = socket;
StreamHandler = streamHandler;
_outgoingBuffer = new BytesRingBuffer(64 * 1024);
_receiveEventArgs = new SocketAsyncEventArgs { UserToken = this };
_sendEventArgs = new SocketAsyncEventArgs { UserToken = this, RemoteEndPoint = socket.RemoteEndPoint };
_sendObservable = _sendEventArgs.ToObservable();
_sendSubscription = _sendObservable.SubscribeOn(ThreadPoolScheduler.Instance).Subscribe(OnSendCompleted);
IObservable<byte[]> dataToSend = Observable.FromEventPattern<byte[]>(this, "OnSendAsync").Select(pattern => pattern.EventArgs);
dataToSend.Subscribe(data =>
{
if (_outgoingBuffer.FreeBytes >= data.Length)
{
WriteToSendBuffer(data);
}
else
{
_outgoingBuffer.NotifyFreeSpace(data.Length, _freeSpaceHandler);
if (!_freeSpaceHandler.WaitOne(5000) && _outgoingBuffer.FreeBytes < data.Length)
{
//Slow consumer
Trace.TraceError("Slow consumer detected. Closing Socket to {0}.", Socket.RemoteEndPoint);
Close();
}
else
{
WriteToSendBuffer(data);
}
}
});
}
/// <summary>
/// 注册数据流处理器。
/// 数据流到达时将进入指定通道的每一个处理器。
/// 不同通道名称的处理器互不干扰。
/// 不提供注册到指定位置的功能，如果需要，再以多态方式实现。
/// </summary>
/// <param name="name">通道名称，用于区分数据流总线</param>
/// <param name="handler">数据流处理器</param>
/// <param name="cover">是否覆盖原有同类型处理器</param>
public static void Register(String name, IStreamHandler handler, Boolean cover)
{
LinkedList<IStreamHandler> list = null;
// 在字典中查找
if (!maps.TryGetValue(name, out list))
{
lock (maps)
{
if (!maps.TryGetValue(name, out list))
{
list = new LinkedList<IStreamHandler>();
maps.Add(name, list);
}
}
}
// 修改处理器链表
lock (list)
{
if (list.Contains(handler))
{
if (cover)
{
// 一个处理器，只用一次，如果原来使用过，需要先移除。
// 一个处理器的多次注册，可用于改变处理顺序，使得自己排在更前面。
list.Remove(handler);
list.AddFirst(handler);
}
}
else
{
list.AddFirst(handler);
}
}
}
/// <summary>
/// Parse streamed twitter event
/// </summary>
/// <param name="ev">event name</param>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">result handler</param>
private static void ParseStreamEvent(string ev, JsonValue graph, IStreamHandler handler)
{
try
{
var source = new TwitterUser(graph[EventSourceKey]);
var target = new TwitterUser(graph[EventTargetKey]);
var timestamp = graph[EventCreatedAtKey].AsString().ParseTwitterDateTime();
switch (ev)
{
case "favorite":
case "unfavorite":
case "quoted_tweet":
case "favorited_retweet":
case "retweeted_retweet":
handler.OnMessage(new StreamStatusEvent(source, target,
new TwitterStatus(graph[EventTargetObjectKey]), ev, timestamp));
break;
case "block":
case "unblock":
case "follow":
case "unfollow":
case "mute":
case "unmute":
case "user_update":
case "user_delete":
case "user_suspend":
handler.OnMessage(new StreamUserEvent(source, target,
ev, timestamp));
break;
case "list_created":
case "list_destroyed":
case "list_updated":
case "list_member_added":
case "list_member_removed":
case "list_user_subscribed":
case "list_user_unsubscribed":
handler.OnMessage(new StreamListEvent(source, target,
new TwitterList(graph[EventTargetObjectKey]), ev, timestamp));
break;
case "access_revoked":
case "access_unrevoked":
handler.OnMessage(new StreamAccessInformationEvent(source, target,
new AccessInformation(graph[EventTargetObjectKey]), ev, timestamp));
break;
}
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"Event parse failed:" + ev, graph.ToString(), ex));
}
}
public when_encrypt_then_decrypt()
{
_streamHandler = new StreamHandler();
_nonEncryptedSourceData = Encoding.UTF8.GetBytes("Servanda");
}
public when_DecryptData()
{
_streamHandler = new StreamHandler();
_encryptedData = new byte[16] { 230, 209, 2, 165, 181, 156, 96, 240, 38, 66, 226, 208, 109, 1, 108, 82 };
}
private static void DispatchStreamingElements(dynamic element, IStreamHandler handler)
{
if (element.text())
{
// standard status receiving
handler.OnStatus(new TwitterStatus(element));
}
// element.foo() -> element.IsDefined("foo")
if (element.delete())
{
// delete handler
handler.OnDeleted(new StreamDelete
{
Id = Int64.Parse(element.delete.status.id_str),
UserId = Int64.Parse(element.delete.status.user_id_str)
});
return;
}
if (element.scrub_geo())
{
// TODO: Not implemented.(Location deletion notices)
return;
}
if (element.limit())
{
handler.OnTrackLimit(new StreamTrackLimit
{
UndeliveredCount = (long)element.limit.track
});
return;
}
if (element.status_withheld() || element.user_withheld())
{
// TODO: Not implemented.(???)
return;
}
if (element.disconnect())
{
handler.OnDisconnect(new StreamDisconnect
{
Code = (DisconnectCode)element.disconnect.code,
Reason = element.disconnect.reason,
StreamName = element.disconnect.stream_name
});
}
if (element.warning())
{
// TODO: Not implemented.(stall warning)
return;
}
if (element.friends())
{
handler.OnEnumerationReceived(new StreamEnumeration
{
Friends = (long[])element.friends
});
}
if (element.IsDefined("event"))
{
string ev = ((string)element["event"]).ToLower();
switch (ev)
{
case "favorite":
case "unfavorite":
handler.OnStatusActivity(new StreamStatusActivity
{
Target = new TwitterUser(element.target),
Source = new TwitterUser(element.source),
Event = StreamStatusActivity.ToEnumEvent(ev),
EventRawString = ev,
Status = new TwitterStatus(element.target_object),
CreatedAt = ((string)element.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat),
});
return;
case "block":
case "unblock":
case "follow":
case "unfollow":
case "user_update":
handler.OnUserActivity(new StreamUserActivity
{
Target = new TwitterUser(element.target),
Source = new TwitterUser(element.source),
Event = StreamUserActivity.ToEnumEvent(ev),
EventRawString = ev,
CreatedAt = ((string)element.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat),
});
return;
case "list_created":
case "list_destroyed":
case "list_updated":
case "list_member_added":
case "list_member_removed":
case "list_user_subscribed":
case "list_user_unsubscribed":
handler.OnListActivity(new StreamListActivity
{
Target = new TwitterUser(element.target),
Source = new TwitterUser(element.source),
Event = StreamListActivity.ToEnumEvent(ev),
EventRawString = ev,
List = new TwitterList(element.target_object),
CreatedAt = ((string)element.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat),
});
break;
}
}
}
/// <summary>
/// Parse streamed JSON line
/// </summary>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">result handler</param>
public static void ParseStreamLine(JsonValue graph, IStreamHandler handler)
{
try
{
// element.foo() -> element.IsDefined("foo")
//
// fast path: first, identify standard status payload
////////////////////////////////////////////////////////////////////////////////////
if (TwitterStreamParser.ParseStreamLineAsStatus(graph, handler))
{
return;
}
//
// parse stream-specific elements
//
// friends lists
var friends = graph["friends"].AsArrayOrNull();
if (friends != null)
{
// friends enumeration
var friendsIds = friends.Select(v => v.AsLong()).ToArray();
handler.OnMessage(new StreamEnumeration(friendsIds));
return;
}
friends = graph["friends_str"].AsArrayOrNull();
if (friends != null)
{
// friends enumeration(stringified)
var friendsIds = friends.Select(v => v.AsString().ParseLong()).ToArray();
handler.OnMessage(new StreamEnumeration(friendsIds));
return;
}
var @event = graph["event"].AsString();
if (@event != null)
{
ParseStreamEvent(@event.ToLower(), graph, handler);
return;
}
// too many follows warning
var warning = graph["warning"].AsObjectOrNull();
if (warning != null)
{
var code = warning["code"].AsString();
if (code == "FOLLOWS_OVER_LIMIT")
{
handler.OnMessage(new StreamTooManyFollowsWarning(
code,
warning["message"].AsString(),
warning["user_id"].AsLong(),
TwitterStreamParser.GetTimestamp(warning)));
return;
}
}
// fallback to default stream handler
TwitterStreamParser.ParseNotStatusStreamLine(graph, handler);
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"Stream graph parse failed.", graph.ToString(), ex));
}
}
/// <summary>
/// Check parse streamed JSON line as normal (not direct-message) status
/// </summary>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">stream handler</param>
/// <returns></returns>
internal static bool ParseStreamLineAsStatus(JsonValue graph, IStreamHandler handler)
{
if (!graph.ContainsKey("text")) return false;
handler.OnStatus(new TwitterStatus(graph));
return true;
}
/// <summary>查询注册，返回指定通道的处理器数组。</summary>
/// <param name="name"></param>
/// <returns></returns>
public static IStreamHandler[] QueryRegister(String name)
{
if (maps == null || maps.Count < 1) return null;
LinkedList<IStreamHandler> list = null;
if (!maps.TryGetValue(name, out list)) return null;
lock (maps)
{
if (!maps.TryGetValue(name, out list)) return null;
IStreamHandler[] fs = new IStreamHandler[list.Count];
list.CopyTo(fs, 0);
return fs;
}
}
private static void DispatchStreamingElements(dynamic element, IStreamHandler handler)
{
var type = "initialize";
try
{
// element.foo() -> element.IsDefined("foo")
if (element.text())
{
// standard status receiving
type = "status";
handler.OnStatus(new TwitterStatus(element));
return;
}
if (element.direct_message())
{
// direct message
type = "message";
handler.OnStatus(new TwitterStatus(element.direct_message));
return;
}
if (element.delete())
{
type = "delete";
// status or message is deleted
if (element.delete.status())
{
// status is deleted
handler.OnDeleted(new StreamDelete
{
Id = Int64.Parse(element.delete.status.id_str),
UserId = Int64.Parse(element.delete.status.user_id_str)
});
}
if (element.delete.direct_message())
{
// message is deleted
handler.OnDeleted(new StreamDelete
{
Id = Int64.Parse(element.delete.direct_message.id_str),
// UserId = Int64.Parse(element.delete.status.user_id_str) // user_id_str field is not exist.
UserId = Int64.Parse(element.delete.direct_message.user_id.ToString())
});
}
return;
}
if (element.scrub_geo())
{
type = "geolocation";
// TODO: Not implemented.(Location deletion notices)
return;
}
if (element.limit())
{
type = "tracklimit";
handler.OnTrackLimit(new StreamTrackLimit
{
UndeliveredCount = (long)element.limit.track
});
return;
}
if (element.status_withheld() || element.user_withheld())
{
type = "withheld";
// TODO: Not implemented.(???)
return;
}
if (element.disconnect())
{
type = "discon";
handler.OnDisconnect(new StreamDisconnect
{
Code = (DisconnectCode)element.disconnect.code,
Reason = element.disconnect.reason,
StreamName = element.disconnect.stream_name
});
return;
}
if (element.warning())
{
type = "warning";
// TODO: Not implemented.(stall warning)
return;
}
if (element.friends())
{
type = "friends";
handler.OnEnumerationReceived(new StreamEnumeration
{
Friends = (long[])element.friends
});
return;
}
if (element.IsDefined("event"))
{
type = "event";
string ev = ((string)element["event"]).ToLower();
type = "event:" + ev;
switch (ev)
{
case "favorite":
case "unfavorite":
handler.OnStatusActivity(new StreamStatusActivity
{
Target = new TwitterUser(element.target),
Source = new TwitterUser(element.source),
Event = StreamStatusActivity.ToEnumEvent(ev),
EventRawString = ev,
Status = new TwitterStatus(element.target_object),
CreatedAt =
((string)element.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat),
});
return;
case "block":
case "unblock":
case "follow":
case "unfollow":
case "user_update":
handler.OnUserActivity(new StreamUserActivity
{
Target = new TwitterUser(element.target),
Source = new TwitterUser(element.source),
Event = StreamUserActivity.ToEnumEvent(ev),
EventRawString = ev,
CreatedAt =
((string)element.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat),
});
return;
case "list_created":
case "list_destroyed":
case "list_updated":
case "list_member_added":
case "list_member_removed":
case "list_user_subscribed":
case "list_user_unsubscribed":
handler.OnListActivity(new StreamListActivity
{
Target = new TwitterUser(element.target),
Source = new TwitterUser(element.source),
Event = StreamListActivity.ToEnumEvent(ev),
EventRawString = ev,
List = new TwitterList(element.target_object),
CreatedAt =
((string)element.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat),
});
return;
default:
handler.OnExceptionThrownDuringParsing(new Exception("Unknown event: " + ev + " / " + element.ToString()));
return;
}
}
handler.OnExceptionThrownDuringParsing(new Exception("Unknown data: " + element.ToString()));
}
catch (Exception ex)
{
string elemstr = element.ToString();
System.Diagnostics.Debug.WriteLine("!exception thrown!" + Environment.NewLine + elemstr);
handler.OnExceptionThrownDuringParsing(new Exception("type:" + type, ex));
}
}
public when_EncryptData()
{
_dataToEncrypt = Encoding.UTF8.GetBytes("Servanda");
_streamHandler = new StreamHandler();
}
/// <summary>
/// Parse streamed JSON line (which is not a status)
/// </summary>
/// <param name="graph">JSON object graph</param>
/// <param name="handler">result handler</param>
internal static void ParseNotStatusStreamLine(JsonValue graph, IStreamHandler handler)
{
try
{
// element.foo() -> element.IsDefined("foo")
// direct message
JsonValue directMessage;
if (graph.TryGetValue("direct_message", out directMessage))
{
handler.OnStatus(new TwitterStatus(graph["direct_message"]));
return;
}
// delete
JsonValue delete;
if (graph.TryGetValue("delete", out delete))
{
var timestamp = GetTimestamp(delete);
JsonValue status;
if (delete.TryGetValue("status", out status))
{
handler.OnMessage(new StreamDelete(
Int64.Parse(status["id_str"].AsString()),
Int64.Parse(status["user_id_str"].AsString()),
timestamp));
return;
}
if (delete.TryGetValue("direct_message", out directMessage))
{
handler.OnMessage(new StreamDelete(
Int64.Parse(directMessage["id_str"].AsString()),
Int64.Parse(directMessage["user_id"].AsString()),
timestamp));
return;
}
}
// scrub_geo
JsonValue scrubGeo;
if (graph.TryGetValue("scrub_geo", out scrubGeo))
{
handler.OnMessage(new StreamScrubGeo(
Int64.Parse(scrubGeo["user_id_str"].AsString()),
Int64.Parse(scrubGeo["up_to_status_id_str"].AsString()),
GetTimestamp(scrubGeo)));
return;
}
// limit
JsonValue limit;
if (graph.TryGetValue("limit", out limit))
{
handler.OnMessage(new StreamLimit(
limit["track"].AsLong(),
GetTimestamp(limit)));
return;
}
// withheld
JsonValue statusWithheld;
if (graph.TryGetValue("status_withheld", out statusWithheld))
{
handler.OnMessage(new StreamWithheld(
statusWithheld["user_id"].AsLong(),
statusWithheld["id"].AsLong(),
((JsonArray)statusWithheld["withheld_in_countries"]).Select(s => s.AsString()).ToArray(),
GetTimestamp(statusWithheld)));
return;
}
JsonValue userWithheld;
if (graph.TryGetValue("user_withheld", out userWithheld))
{
handler.OnMessage(new StreamWithheld(
userWithheld["id"].AsLong(),
((JsonArray)statusWithheld["withheld_in_countries"]).Select(s => s.AsString()).ToArray(),
GetTimestamp(statusWithheld)));
return;
}
// disconnect
JsonValue disconnect;
if (graph.TryGetValue("disconnect", out disconnect))
{
handler.OnMessage(new StreamDisconnect(
(DisconnectCode)disconnect["code"].AsLong(),
disconnect["stream_name"].AsString(),
disconnect["reason"].AsString(),
GetTimestamp(disconnect)));
return;
}
// stall warning
JsonValue warning;
if (graph.TryGetValue("warning", out warning))
{
var timestamp = GetTimestamp(warning);
var code = warning["code"].AsString();
if (code == "FALLING_BEHIND")
{
handler.OnMessage(new StreamStallWarning(
code,
warning["message"].AsString(),
(int)warning["percent_full"].AsLong(),
timestamp));
return;
}
}
// user update
JsonValue @event;
if (graph.TryGetValue("event", out @event))
{
var ev = @event.AsString().ToLower();
if (ev == "user_update")
{
// parse user_update only in generic streams.
handler.OnMessage(new StreamUserEvent(
new TwitterUser(graph["source"]),
new TwitterUser(graph["target"]),
ev, graph["created_at"].AsString().ParseTwitterDateTime()));
return;
}
// unknown event...
handler.OnMessage(new StreamUnknownMessage("event: " + ev, graph.ToString()));
}
// unknown event-type...
handler.OnMessage(new StreamUnknownMessage(null, graph.ToString()));
}
catch (Exception ex)
{
handler.OnException(new StreamParseException(
"Stream graph parse failed.", graph.ToString(), ex));
}
}
public when_CopyStreamToByteBuffer()
{
_streamHandler = new StreamHandler();
var bytearray = new byte[666];
_stream = new MemoryStream(bytearray);
}
protected override IStreamHandler StreamHandlerFactory(Guid sessionId)
{
return StreamHandler ?? (StreamHandler = new StreamHandler(MessageProcessor, sessionId));
}
// NOTE: protected , so that inheritors can reach it
/// <summary>
/// Construct with a stream given.
/// IMPORTANT : of stream is not valid we will throw an exception from a constructor!
/// <seealso cref="isValid()"/>
/// NOTE: this class is (just) kind-of-a stream handler, so operations like
/// closing a stream are not performed here
/// </summary>
/// <param name="stream_"></param>
public StreamVector(Stream stream_)
{
if (!StreamUtil.isValid(stream_))
throw new ArgumentException("Stream given is not valid? It can not be seek-ed or read from or written to.", "stream_");
if ( ! StreamUtil.isLegacy( stream_ )) {
engine_ = new StreamHadler( stream_ ) ;
} else {
engine_ = new LegacyStreamHandler( stream_ ) ;
}
}
public FileUploadHandler(IStreamHandler streamHandler, IHostingEnvironment hostingEnvironment)
{
_streamHandler = streamHandler;
_hostingEnvironment = hostingEnvironment;
}
