public void Start(IObserver <StreamingMessage> observer, StreamingApi client, StreamingType type, KeyValuePair <string, object>[] parameters)
        {
            var token = this.cancel.Token;

            client.IncludedTokens.SendStreamingRequestAsync(GetMethodType(type), client.GetUrl(type), parameters, token)
            .Done(res => res.GetResponseStreamAsync(), token)
            .Unwrap()
            .Done(stream =>
            {
                using (var reader = new StreamReader(stream))
                    using (token.Register(reader.Dispose))
                    {
                        foreach (var s in reader.EnumerateLines().Where(x => !string.IsNullOrEmpty(x)))
                        {
                            try
                            {
                                observer.OnNext(StreamingMessage.Parse(s));
                            }
                            catch (ParsingException ex)
                            {
                                observer.OnNext(RawJsonMessage.Create(s, ex));
                            }
                        }
                    }
                observer.OnCompleted();
            }, token, true)
            .ContinueWith(t =>
            {
                if (!token.IsCancellationRequested)
                {
                    if (t.Exception != null)
                    {
                        observer.OnError(t.Exception.InnerExceptions.Count == 1 ? t.Exception.InnerException : t.Exception);
                    }
                    else if (t.IsCanceled)
                    {
                        observer.OnError(new TaskCanceledException(t));
                    }
                }
            });
        }
Exemple #2
0
 private static IEnumerable <StreamingMessage> EnumerateMessages(Stream stream)
 {
     using (var reader = new StreamReader(stream))
     {
         foreach (var s in reader.EnumerateLines())
         {
             if (!string.IsNullOrEmpty(s))
             {
                 StreamingMessage m;
                 try
                 {
                     m = StreamingMessage.Parse(s);
                 }
                 catch (ParsingException ex)
                 {
                     m = RawJsonMessage.Create(s, ex);
                 }
                 yield return(m);
             }
         }
     }
 }
Exemple #3
0
        /// <summary>
        /// Starts the twitter stream.
        /// </summary>
        /// <returns>
        /// The stream messages.
        /// </returns>
        /// <param name='type'>
        /// Type of streaming.
        /// </param>
        /// <param name='parameters'>
        /// Parameters of streaming.
        /// </param>
        public IEnumerable <StreamingMessage> StartStream(StreamingType type, StreamingParameters parameters = null)
        {
            if (parameters == null)
            {
                parameters = new StreamingParameters();
            }

            var url = type == StreamingType.User ? "https://userstream.twitter.com/1.1/user.json" :
                      type == StreamingType.Site ? " https://sitestream.twitter.com/1.1/site.json " :
                      type == StreamingType.Filter ? "https://stream.twitter.com/1.1/statuses/filter.json" :
                      type == StreamingType.Sample ? "https://stream.twitter.com/1.1/statuses/sample.json" :
                      type == StreamingType.Firehose ? "https://stream.twitter.com/1.1/statuses/firehose.json" : "";

            var str = this.Connect(parameters, type == StreamingType.Filter ? MethodType.Post : MethodType.Get, url)
                      .Where(x => !string.IsNullOrEmpty(x));

            foreach (var s in str)
            {
                yield return(RawJsonMessage.Create(this.Tokens, s));

                yield return(StreamingMessage.Parse(this.Tokens, s));
            }
        }