コード例 #1
0
ファイル: ForeverTransport.cs プロジェクト: ajeelee/SignalR
        public virtual Task Send(object value)
        {
            JsonSerializer.Stringify(value, OutputWriter);
            OutputWriter.Flush();

            return(Context.Response.FlushAsync());
        }
コード例 #2
0
        /// <summary>
        /// Reads from the stream until the external program is ended.
        /// </summary>
        private void StreamReaderThread_Output()
        {
            StreamReader reader   = _stdOut;
            bool         doAppend = OutputAppend;

            while (true)
            {
                string logContents = reader.ReadLine();
                if (logContents == null)
                {
                    break;
                }

                // ensure only one thread writes to the log at any time
                lock (_lockObject) {
                    if (Output != null)
                    {
                        StreamWriter writer = new StreamWriter(Output.FullName, doAppend);
                        writer.WriteLine(logContents);
                        doAppend = true;
                        writer.Close();
                    }
                    else
                    {
                        OutputWriter.WriteLine(logContents);
                    }
                }
            }

            lock (_lockObject) {
                OutputWriter.Flush();
            }
        }
コード例 #3
0
 public void Dispose()
 {
     if (OutputWriter != null)
     {
         OutputWriter.Flush();
         OutputWriter.Close();
     }
 }
コード例 #4
0
ファイル: XmlLogger.cs プロジェクト: nathanscottdaniels/pnant
        /// <summary>
        /// Signals that the last target has finished.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">A <see cref="BuildEventArgs" /> object that contains the event data.</param>
        /// <remarks>
        /// This event will still be fired if an error occurred during the build.
        /// </remarks>
        public void BuildLoggingFinished(object sender, BuildEventArgs e)
        {
            lock (_xmlWriter)
            {
                if (e.Exception != null)
                {
                    _xmlWriter.WriteStartElement("failure");
                    WriteErrorNode(e.Exception);
                    _xmlWriter.WriteEndElement();
                }

                WriteDuration(e.Stopwatch);

                // close buildresults node
                _xmlWriter.WriteEndElement();
                _xmlWriter.Flush();
            }

            // remove an item from the project stack
            _projectStack.Pop();

            // check if there are still nested projects executing
            if (_projectStack.Count != 0)
            {
                // do not yet persist build results, as the main project is
                // not finished yet
                return;
            }

            try
            {
                // write results to file
                if (OutputWriter != null)
                {
                    OutputWriter.Write(_buffer.ToString());
                    OutputWriter.Flush();
                }
                else
                { // Xmlogger is used as BuildListener
                    string outFileName = e.Project.GetGlobalProperty("XmlLogger.file");
                    if (outFileName == null)
                    {
                        outFileName = "log.xml";
                    }
                    // convert to full path relative to project base directory
                    outFileName = e.Project.GetFullPath(outFileName);
                    // write build log to file
                    using (StreamWriter writer = new StreamWriter(new FileStream(outFileName, FileMode.Create, FileAccess.Write, FileShare.Read), Encoding.UTF8))
                    {
                        writer.Write(_buffer.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                throw new BuildException("Unable to write to log file.", ex);
            }
        }
コード例 #5
0
        public override Task KeepAlive()
        {
            OutputWriter.Write("data: {}");
            OutputWriter.WriteLine();
            OutputWriter.WriteLine();
            OutputWriter.Flush();

            return(Context.Response.FlushAsync());
        }
コード例 #6
0
        public override Task KeepAlive()
        {
            OutputWriter.Write("<script>r(c, {});</script>");
            OutputWriter.WriteLine();
            OutputWriter.WriteLine();
            OutputWriter.Flush();

            return(Context.Response.FlushAsync());
        }
コード例 #7
0
        public virtual Task Send(object value)
        {
            Context.Response.ContentType = Json.MimeType;

            JsonSerializer.Stringify(value, OutputWriter);
            OutputWriter.Flush();

            return(Context.Response.EndAsync());
        }
コード例 #8
0
        public void Play(int i)
        {
            var outputWriter = new OutputWriter(i, _output);

            foreach (var analyzer in _analyzers)
            {
                analyzer.Process(outputWriter, i);
            }
            outputWriter.Flush();
        }
コード例 #9
0
        public override Task Send(PersistentResponse response)
        {
            OnSendingResponse(response);

            OutputWriter.Write("<script>r(c, ");
            JsonSerializer.Serialize(response, OutputWriter);
            OutputWriter.Write(");</script>\r\n");
            OutputWriter.Flush();

            return(Context.Response.FlushAsync().Catch(IncrementErrorCounters));
        }
コード例 #10
0
        public override Task Send(PersistentResponse response)
        {
            OnSendingResponse(response);

            OutputWriter.Write("<script>r(c, ");
            JsonSerializer.Stringify(response, OutputWriter);
            OutputWriter.Write(");</script>\r\n");
            OutputWriter.Flush();

            return(Context.Response.FlushAsync());
        }
コード例 #11
0
        public virtual Task Send(object value)
        {
            Context.Response.ContentType = Json.MimeType;

            return(EnqueueOperation(() =>
            {
                JsonSerializer.Serialize(value, OutputWriter);
                OutputWriter.Flush();

                return Context.Response.EndAsync().Catch(IncrementErrorCounters);
            }));
        }
コード例 #12
0
        public override Task KeepAlive()
        {
            return(EnqueueOperation(() =>
            {
                OutputWriter.Write("data: {}");
                OutputWriter.WriteLine();
                OutputWriter.WriteLine();
                OutputWriter.Flush();

                return Context.Response.FlushAsync();
            }));
        }
コード例 #13
0
        public override Task KeepAlive()
        {
            return(EnqueueOperation(() =>
            {
                OutputWriter.Write("<script>r(c, {});</script>");
                OutputWriter.WriteLine();
                OutputWriter.WriteLine();
                OutputWriter.Flush();

                return Context.Response.FlushAsync();
            }));
        }
コード例 #14
0
        protected override Task InitializeResponse(ITransportConnection connection)
        {
            return(base.InitializeResponse(connection)
                   .Then(initScript =>
            {
                Context.Response.ContentType = "text/html";
                OutputWriter.Write(initScript);
                OutputWriter.Flush();

                return Context.Response.FlushAsync();
            },
                         _initPrefix + Context.Request.QueryString["frameId"] + _initSuffix));
        }
コード例 #15
0
        public override Task Send(PersistentResponse response)
        {
            OnSendingResponse(response);

            OutputWriter.Write("id: ");
            OutputWriter.Write(response.MessageId);
            OutputWriter.WriteLine();
            OutputWriter.Write("data: ");
            JsonSerializer.Serialize(response, OutputWriter);
            OutputWriter.WriteLine();
            OutputWriter.WriteLine();
            OutputWriter.Flush();

            return(Context.Response.FlushAsync().Catch(IncrementErrorCounters));
        }
コード例 #16
0
        public override Task Send(PersistentResponse response)
        {
            OnSendingResponse(response);

            return(EnqueueOperation(() =>
            {
                OutputWriter.Write("data: ");
                JsonSerializer.Serialize(response, OutputWriter);
                OutputWriter.WriteLine();
                OutputWriter.WriteLine();
                OutputWriter.Flush();

                return Context.Response.FlushAsync().Catch(IncrementErrorCounters);
            }));
        }
コード例 #17
0
        bool Processing(HttpListenerContext context)
        {
            var finished = false;

            var request  = context.Request;
            var response = "OK";

            var stream = request.InputStream;
            var data   = string.Empty;

            using (var reader = new StreamReader(stream))
                data = reader.ReadToEnd();
            stream.Close();

            switch (request.RawUrl)
            {
            case "/Start":
                if (!connected_once)
                {
                    connected_once = true;
                    Connected(request.RemoteEndPoint.ToString());
                }
                break;

            case "/Finish":
                if (!finished)
                {
                    OutputWriter.Write(data);
                    OutputWriter.Flush();
                    finished = true;
                }
                break;

            default:
                Log.WriteLine("Unknown upload url: {0}", request.RawUrl);
                response = $"Unknown upload url: {request.RawUrl}";
                break;
            }

            var buf = System.Text.Encoding.UTF8.GetBytes(response);

            context.Response.ContentLength64 = buf.Length;
            context.Response.OutputStream.Write(buf, 0, buf.Length);
            context.Response.OutputStream.Close();
            context.Response.Close();

            return(finished);
        }
コード例 #18
0
        protected override Task InitializeResponse(ITransportConnection connection)
        {
            return(base.InitializeResponse(connection)
                   .Then(() =>
            {
                Context.Response.ContentType = "text/event-stream";

                // "data: initialized\n\n"
                OutputWriter.Write("data: initialized");
                OutputWriter.WriteLine();
                OutputWriter.WriteLine();
                OutputWriter.Flush();

                return Context.Response.FlushAsync();
            }));
        }
コード例 #19
0
        /// <summary>
        /// Reads from the stream until the external program is ended.
        /// </summary>
        protected virtual void StreamReaderThread_Output()
        {
            StreamReader  reader   = _stdOut;
            bool          doAppend = OutputAppend;
            StringBuilder Capture  = new StringBuilder();

            while (true)
            {
                string logContents = reader.ReadLine();
                if (logContents == null)
                {
                    break;
                }

                // ensure only one thread writes to the log at any time
                lock (_lockObject) {
                    OutputWriter.WriteLine(logContents);
                    if (!String.IsNullOrEmpty(this.OutputProperty))
                    {
                        Capture.AppendLine(logContents);
                    }
                    if (Output != null)
                    {
                        StreamWriter writer = new StreamWriter(Output.FullName, doAppend);
                        writer.WriteLine(logContents);
                        doAppend = true;
                        writer.Close();
                    }
                }
            }

            if (!String.IsNullOrEmpty(this.OutputProperty))
            {
                if (!this.Properties.Contains(this.OutputProperty))
                {
                    this.Properties.Add(this.OutputProperty, string.Empty);
                }
                this.Properties[this.OutputProperty] = Capture.ToString();
            }

            OutputWriter.Flush();
        }
コード例 #20
0
        public virtual Task Send(object value)
        {
            Context.Response.ContentType = IsJsonp ? Json.JsonpMimeType : Json.MimeType;

            if (IsJsonp)
            {
                OutputWriter.Write(JsonpCallback);
                OutputWriter.Write("(");
            }

            _jsonSerializer.Stringify(value, OutputWriter);

            if (IsJsonp)
            {
                OutputWriter.Write(");");
            }

            OutputWriter.Flush();
            return(Context.Response.EndAsync());
        }
コード例 #21
0
 protected void Finished(bool early_termination = false)
 {
     if (stopped.TrySetResult(early_termination))
     {
         if (early_termination)
         {
             Log.WriteLine("Tests were terminated before completion");
         }
         else
         {
             Log.WriteLine("Tests have finished executing");
         }
         if (xml_data != null)
         {
             OutputWriter.WriteLine($"<!-- \n{xml_data}\n -->");
             OutputWriter.Flush();
             xml_data = null;
         }
     }
 }
コード例 #22
0
        public virtual Task Send(object value)
        {
            Context.Response.ContentType = IsJsonp ? Json.JsonpMimeType : Json.MimeType;

            return(EnqueueOperation(() =>
            {
                if (IsJsonp)
                {
                    OutputWriter.Write(JsonpCallback);
                    OutputWriter.Write("(");
                }

                _jsonSerializer.Serialize(value, OutputWriter);

                if (IsJsonp)
                {
                    OutputWriter.Write(");");
                }

                OutputWriter.Flush();
                return Context.Response.EndAsync();
            }));
        }
コード例 #23
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Reads from the stream until the external program is ended.
        /// </summary>
        /// ------------------------------------------------------------------------------------
        private void StreamReaderThread_Output()
        {
            try
            {
                var reader = m_StdOut;

                while (true)
                {
                    var logContents = reader.ReadLine();
                    if (logContents == null)
                    {
                        break;
                    }

                    // ensure only one thread writes to the log at any time
                    lock (LockObject)
                    {
                        if (Verbose)
                        {
                            OutputWriter.WriteLine(logContents);
                        }
                        MemoryWriter.WriteLine(logContents);
                    }
                }

                lock (LockObject)
                {
                    OutputWriter.Flush();
                    MemoryWriter.Flush();
                }
            }
            catch (Exception)
            {
                // just ignore any errors
            }
        }