public void MillisAreSerializedWithNoPeriodAttribute() { Timeout period = new Timeout(100); StringWriter stringWriter = new StringWriter(); serializer.Write(new XmlTextWriter(stringWriter), period); Assert.AreEqual("<timeout>100</timeout>", stringWriter.ToString()); }
public override object Read(XmlNode node, NetReflectorTypeTable types) { Timeout timeout = Timeout.DefaultTimeout; if (node is XmlAttribute) { XmlAttribute a = (XmlAttribute) node; try { timeout = new Timeout(Int32.Parse(a.Value)); } catch (Exception) { Log.Warning("Could not parse timeout string. Using default timeout."); } } else if (node is XmlElement) { XmlElement e = (XmlElement) node; try { TimeUnits units = TimeUnits.MILLIS; string unitsString = e.GetAttribute("units"); if (unitsString != null && unitsString != "") { units = TimeUnits.Parse(unitsString); } timeout = new Timeout(Int32.Parse(e.InnerText), units); } catch (Exception) { Log.Warning("Could not parse timeout string. Using default timeout."); } } return timeout; }
public void MinutesAreSerializedWithAPeriodAttribute() { Timeout period = new Timeout(100, TimeUnits.MINUTES); StringWriter stringWriter = new StringWriter(); serializer.Write(new XmlTextWriter(stringWriter), period); Assert.AreEqual("<timeout units=\"minutes\">100</timeout>", stringWriter.ToString()); }
/// <summary> /// Reads the specified node. /// </summary> /// <param name="node">The node.</param> /// <param name="types">The types.</param> /// <returns></returns> /// <remarks></remarks> public override object Read(XmlNode node, NetReflectorTypeTable types) { if (node == null) { // NetReflector should do this check, but doesn't if (this.Attribute.Required) { throw new NetReflectorItemRequiredException(Attribute.Name + " is required"); } else { return null; } } Timeout timeout = Timeout.DefaultTimeout; XmlAttribute a = node as XmlAttribute; if (a != null) { try { timeout = new Timeout(Int32.Parse(a.Value, CultureInfo.CurrentCulture)); } catch (Exception) { Log.Warning("Could not parse timeout string. Using default timeout."); } } else { var e = node as XmlElement; if (e != null) { try { TimeUnits units = TimeUnits.MILLIS; string unitsString = e.GetAttribute("units"); if (unitsString != null && !(unitsString != null && unitsString.Length == 0)) { units = TimeUnits.Parse(unitsString); } timeout = new Timeout(Int32.Parse(e.InnerText, CultureInfo.CurrentCulture), units); } catch (Exception) { Log.Warning("Could not parse timeout string. Using default timeout."); } } } return timeout; }
private static void AssertTimeoutIs(Timeout expected, string xml) { StubSourceControl sc = new StubSourceControl(null, null); NetReflector.Read(xml, sc); Assert.AreEqual(expected, sc.Timeout); }
/// <summary> /// Gets the request status. /// </summary> /// <param name="settings">The settings.</param> /// <returns>A <see cref="HttpRequestStatus"/>.</returns> protected HttpRequestStatus GetRequestStatus(HttpRequestSettings settings) { HttpRequestStatus ret = new HttpRequestStatus { Settings = settings, Success = false }; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(settings.Uri); HttpWebResponse response = null; if (settings.HasHeaders) { foreach (HttpRequestHeader header in settings.Headers) { request.Headers.Set(header.Name, header.Value); } } if (settings.HasTimeout || settings.HasOverrideTimeout) { request.Timeout = (settings.OverrideTimeout ?? settings.Timeout).Millis; } if (settings.HasReadWriteTimeout) { request.ReadWriteTimeout = settings.ReadWriteTimeout.Millis; } request.Method = settings.Method; if (settings.HasCredentials) { request.Credentials = settings.Credentials; } else { request.UseDefaultCredentials = settings.UseDefaultCredentials; } ret.RequestTime = DateTime.Now; long start = Stopwatch.GetTimestamp(); Timeout timeout = new Timeout(request.Timeout); timeout.Normalize(); Timeout readWriteTimeout = new Timeout(request.ReadWriteTimeout); readWriteTimeout.Normalize(); Log.Debug("Requesting uri (timeout: {0}, read/write-timeout: {1})...", timeout.ToString(), readWriteTimeout.ToString()); try { // TODO this could be better, support chunked transfer etc? if (settings.HasBody || settings.HasSendFile) { using (Stream requestStream = request.GetRequestStream()) { if (settings.HasBody) { using (TextWriter writer = new StreamWriter(requestStream, new UTF8Encoding(false, true))) { writer.Write(settings.Body); } } else { using (FileStream inputFile = File.OpenRead(settings.SendFile)) { int read; byte[] buff = new byte[16384]; do { read = inputFile.Read(buff, 0, buff.Length); requestStream.Write(buff, 0, read); } while (read > 0); } } requestStream.Close(); } } response = (HttpWebResponse)request.GetResponse(); } catch (WebException wEx) { ret.Exception = wEx; if (wEx.Status == WebExceptionStatus.Timeout) { ret.TimedOut = true; } if (wEx.Response is HttpWebResponse) { response = (HttpWebResponse)wEx.Response; } } if (response != null) { ret.StatusCode = response.StatusCode; ret.StatusDescription = response.StatusDescription; ret.ContentEncoding = response.ContentEncoding; ret.CharacterSet = response.CharacterSet; ret.ContentType = response.ContentType; ret.Headers = response.Headers; if (this.IncludeContent) { try { using (Stream responseStream = response.GetResponseStream()) { try { ret.ResponseEncoding = Encoding.GetEncoding(response.CharacterSet); } catch (ArgumentException) { ret.ResponseEncoding = null; } if (ret.ResponseEncoding != null) { using (TextReader reader = new StreamReader(responseStream, ret.ResponseEncoding)) { ret.Content = reader.ReadToEnd(); } } else { // BASE64 encode a blob using (MemoryStream memBuffer = new MemoryStream()) { int read; byte[] buff = new byte[512]; do { read = responseStream.Read(buff, 0, buff.Length); memBuffer.Write(buff, 0, read); } while (read > 0); if (memBuffer.Length > 0) { ret.ContentIsBase64Encoded = true; ret.Content = Convert.ToBase64String( memBuffer.ToArray(), Base64FormattingOptions.InsertLineBreaks); } } } } } catch (Exception ex) { // keep the first exception if (ret.Exception == null) { ret.Exception = ex; } ret.Content = null; } } ret.Success = true; } ret.Duration = TimeSpan.FromSeconds((double)(Stopwatch.GetTimestamp() - start) / Stopwatch.Frequency); return ret; }
/// <summary> /// Execute the actual task functionality. /// </summary> /// <param name="result">The current build result.</param> /// <returns> /// True if the task was successful, false otherwise. /// </returns> protected override bool Execute(IIntegrationResult result) { Log.Debug("HttpStatusTask is executing"); bool taskTimedOut = false; string msg = string.Format("Checking http status of URI: '{0}'", this.RequestSettings.Uri.ToString()); if (!String.IsNullOrEmpty(Description)) { msg = Description + " (" + msg + ")"; } Log.Debug(msg); result.BuildProgressInformation.SignalStartRunTask(msg); XmlTaskResult taskResult = new XmlTaskResult(); List<HttpRequestStatus> resp = new List<HttpRequestStatus>(); long startTimeStamp = -1; bool keepTrying; int attempt = 0; if (this.HasTimeout) { startTimeStamp = Stopwatch.GetTimestamp(); } do { try { if (this.HasTimeout) { long taskDurationTicks = Stopwatch.GetTimestamp() - startTimeStamp; long taskDurationMilliSecs = (long)Math.Round(((double)taskDurationTicks / Stopwatch.Frequency) * 1000.0); long msecsLeft = this.Timeout.Millis - taskDurationMilliSecs; if (msecsLeft < 0) { taskTimedOut = true; break; } if (msecsLeft < this.RequestSettings.Timeout.Millis) { this.RequestSettings.Timeout = new Timeout((int)msecsLeft, TimeUnits.MILLIS); } Log.Debug("Task timeout in T-{0:N1} seconds", msecsLeft / 1000.0); } HttpRequestStatus status = this.GetRequestStatus(this.RequestSettings); if (status.Success) { Log.Debug("Checking returned status code ({0}) against success status codes: {1}", ((int)status.StatusCode).ToString(), this.SuccessStatusCodes); for (int i = 0; i < this.successStatusCodes.Length; i++) { if ((int)status.StatusCode == this.successStatusCodes[i]) { Log.Debug("Success, exiting..."); taskResult.Success = true; break; } } } resp.Add(status); } catch (Exception ex) { throw new BuilderException(this, String.Format("An exception occured in HttpStatusTask while checking status for: '{0}'", this.RequestSettings.Uri), ex); } // sleeping keepTrying = !taskResult.Success && (this.Retries == -1 || (this.Retries - attempt++) > 0); if (keepTrying) { var delay = this.RetryDelay ?? new Timeout(5000); if (delay.Millis > 0) { delay.Normalize(); Log.Debug("Retrying in {0}...", delay.ToString()); System.Threading.Thread.Sleep(delay.Millis); } else { Log.Debug("Retrying..."); } } } while (keepTrying); if (taskTimedOut) { throw new BuilderException(this, String.Format("HttpStatusTask timed out while checking status for: '{0}'", this.RequestSettings.Uri)); } Log.Debug("Writing output..."); XmlWriter writer = taskResult.GetWriter(); writer.WriteStartElement("httpStatus"); writer.WriteAttributeString("uri", this.RequestSettings.Uri.ToString()); writer.WriteAttributeString("success", XmlConvert.ToString(taskResult.Success)); if (!String.IsNullOrEmpty(this.Description)) { writer.WriteElementString("description", this.Description); } foreach (HttpRequestStatus status in resp) { status.WriteTo(writer, this.IncludeContent); } writer.WriteEndElement(); writer.Close(); result.AddTaskResult(taskResult); Log.Debug("HttpStatusTask finished, return value: {0}", taskResult.Success.ToString()); return taskResult.Success; }
public void DefaultTimeoutIsInMillis() { Timeout timeout = new Timeout(100); Assert.AreEqual(100, timeout.Millis); Assert.AreEqual(new Timeout(100, TimeUnits.MILLIS), timeout); }
public void CanSpecifyTimeoutInHours() { Timeout period = new Timeout(1, TimeUnits.HOURS); Assert.AreEqual(60*60*1000, period.Millis); Assert.AreEqual(new Timeout(60*60*1000, TimeUnits.MILLIS), period); }
public void CanSpecifyTimeoutInMinutes() { Timeout period = new Timeout(1, TimeUnits.MINUTES); Assert.AreEqual(60*1000, period.Millis); Assert.AreEqual(new Timeout(60*1000, TimeUnits.MILLIS), period); }
public void CanSpecifyTimeoutInSeconds() { Timeout period = new Timeout(1, TimeUnits.SECONDS); Assert.AreEqual(1000, period.Millis); Assert.AreEqual(new Timeout(1000, TimeUnits.MILLIS), period); }