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 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> /// 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"); }
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)); } }
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; }