private void Log(ILogMessage message, LogLevel level) { switch (level) { case LogLevel.Error: _log.LogError(message.Message); break; case LogLevel.Warning: _log.LogWarning(message.Message); break; case LogLevel.Minimal: _log.LogMessage(MessageImportance.Low, message.Message); break; case LogLevel.Information: _log.LogMessage(MessageImportance.Normal, message.Message); break; case LogLevel.Debug: case LogLevel.Verbose: default: _log.LogMessage(MessageImportance.High, message.Message); break; } return; }
public void Run(string site, TaskLoggingHelper log, int maxPages, bool strict) { this.MaxPages = maxPages; this.Strict = strict; this.log = log; log.LogMessage("Starting site at " + site); using (var iis = new IisConfiguration(site, log)) { var tokill = iis.StartWebsites(); foreach (var process in tokill) PipeProcessToLog(process); // Create a URI class var startUrl = new Uri("http://localhost:" + iis.Port); log.LogMessage("##teamcity[testSuiteStarted name='SiteVerification']"); var report = RunAnalysis(startUrl); // Run a few queries... LogSeoViolations(report); LogBrokenLinks(report); LogResponseTimes(report); log.LogMessage("##teamcity[testSuiteFinished name='SiteVerification']"); foreach (var process in tokill) { SendStopMessageToProcess(process.Id); } } }
public static bool RemoveSelectors(TaskLoggingHelper log, HtmlDocument document, IEnumerable<SelectorInfo> selectors) { bool updatedItem = false; HtmlNodeCollection collection = document.DocumentNode.SelectNodes("//style"); int nodeNumber = 0; foreach (HtmlNode node in collection) { log.LogMessage(MessageImportance.Normal, "Processing <style/> tag #{0}", nodeNumber++); List<SelectorInfo> foundSelectors = selectors.Where(item => item.Expression.IsMatch(node.InnerText)).ToList(); foreach (SelectorInfo foundSelector in foundSelectors) { log.LogMessage(MessageImportance.Normal, "Found '{0}' selector. Removing all occurrences.", foundSelector.Name); node.InnerHtml = foundSelector.Expression.Replace(node.InnerHtml, string.Empty); updatedItem = true; } if (string.IsNullOrWhiteSpace(node.InnerHtml)) { log.LogMessage(MessageImportance.Normal, "No CSS Styles remain. Removing <style/>"); node.Remove(); updatedItem = true; } } return updatedItem; }
public async Task <bool> CheckIfBlobExists(string blobPath) { string url = $"{FeedContainerUrl}/{blobPath}?comp=metadata"; using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Clear(); var request = AzureHelper.RequestMessage("GET", url, AccountName, AccountKey).Invoke(); using (HttpResponseMessage response = await client.SendAsync(request)) { if (response.IsSuccessStatusCode) { Log.LogMessage( MessageImportance.Low, $"Blob {blobPath} exists for {AccountName}: Status Code:{response.StatusCode} Status Desc: {await response.Content.ReadAsStringAsync()}"); } else { Log.LogMessage( MessageImportance.Low, $"Blob {blobPath} does not exist for {AccountName}: Status Code:{response.StatusCode} Status Desc: {await response.Content.ReadAsStringAsync()}"); } return(response.IsSuccessStatusCode); } } }
public IEnumerable<string> GetAppBuildOrder(string sourceDirectory, string startAppPath, string uniqueSourceDirectoryPath, TaskLoggingHelper log) { _log = log; _uniqueSourceDirectoryPath = uniqueSourceDirectoryPath; var sourceDirectoryPath = sourceDirectory.Trim('\'', '"'); var appList = GetAppListWithReferences(sourceDirectoryPath); var appPath = startAppPath.Trim('\'', '"'); var startApps = appPath.Split('|').ToList(); foreach (var app in startApps) { if (!string.IsNullOrEmpty(app)) { _log.LogMessage("Application path: {0}", app); var startApp = appList[Path.GetFullPath(app.ToUpper().Replace(sourceDirectoryPath.ToUpper(), _uniqueSourceDirectoryPath)).ToUpper()]; if (startApp == null) { log.LogError("Application {0} could not be found.", app); } else { _orderedAppList.Add(Path.GetFullPath(app.ToUpper().Replace(sourceDirectoryPath.ToUpper(), _uniqueSourceDirectoryPath)).ToUpper()); LoopReferences(startApp, appList); } } } _orderedAppList.ForEach(a => _log.LogMessage(a)); return _orderedAppList; }
public void UpdateProperties(string propertyOverrides, ITaskItem project, TaskLoggingHelper log) { log.LogMessage(MessageImportance.Normal, "Updating properties in file {0}", resourceFile.FullName); if (string.IsNullOrWhiteSpace(propertyOverrides)) return; var properties = propertyOverrides.ToDictionary(';', '='); // Scan meta data for project-specific overrides var metaDataNames = project.MetadataNames; foreach (string metaDataName in metaDataNames) { properties[metaDataName] = project.GetMetadata(metaDataName); } var lines = File.ReadLines(resourceFile.FullName).ToList(); var results = new List<string>(lines.Count); // Now process each line in the file) foreach (var line in lines) { var key = GetKey(line); if (key == null) { results.Add(line); } else { var isValueKey = false; if (key.Equals("VALUE", StringComparison.OrdinalIgnoreCase)) { key = GetValueKey(line); if (string.IsNullOrEmpty(key)) { results.Add(line); continue; } isValueKey = true; } if (properties.ContainsKey(key)) { log.LogMessage(MessageImportance.Low, "Setting \"{0}\" to \"{1}\"", key, properties[key]); results.Add(string.Format(isValueKey ? "VALUE \"{0}\", \"{1}\\0\"" : "{0} {1}", key, properties[key])); } else { results.Add(line); } } } File.WriteAllLines(resourceFile.FullName, results); }
//------------------------------------------------------ // // Internal Helper Methods // //------------------------------------------------------ #region Internal Methods // <summary> // Output the Logo information to the logger for a given task // (Console or registered Loggers). // </summary> internal static void DisplayLogo(TaskLoggingHelper log, string taskName) { string acPath = Assembly.GetExecutingAssembly().Location; FileVersionInfo acFileVersionInfo = FileVersionInfo.GetVersionInfo(acPath); string avalonFileVersion = acFileVersionInfo.FileVersion; log.LogMessage(MessageImportance.Low,Environment.NewLine); log.LogMessageFromResources(MessageImportance.Low, SRID.TaskLogo, taskName, avalonFileVersion); log.LogMessageFromResources(MessageImportance.Low, SRID.TaskRight); log.LogMessage(MessageImportance.Low, Environment.NewLine); }
public static ServiceTable GetServiceTable(string ConnString, int ServiceTableID, TaskLoggingHelper Log) { ServiceTable result = new ServiceTable(); SqlConnection conn = new SqlConnection(ConnString); conn.Open(); SqlCommand cmd = new SqlCommand("select ServiceTableID, DescServiceTable, Value, CreationDate, StringField1, StringField2 " + "from ServiceTable where ServiceTableID = @ServiceTableID", conn); using (conn) { SqlParameter p1 = cmd.Parameters.Add("@ServiceTableID", SqlDbType.Int); p1.Value = ServiceTableID; SqlDataReader rd = cmd.ExecuteReader(); rd.Read(); using (rd) { result.ServiceTableID = rd.GetInt32(0); result.DescServiceTable = rd.GetString(1); result.Value = (float)rd.GetDouble(2); result.CreationDate = rd.GetDateTime(3); result.StringField1 = rd.GetString(4); result.StringField2 = rd.GetString(5); } } if (Log != null) Log.LogMessage("Getting ServiceTableID: " + ServiceTableID.ToString()); return result; }
public bool Execute() { var rand = new Random(); int i = rand.Next(0, FamousQuotes.Count); string quote = String.Format("{0}\r\n{1}", FamousQuotes[i].Saying, FamousQuotes[i].Author); var loggingHelper = new TaskLoggingHelper(this); loggingHelper.LogMessage(MessageImportance.Normal, quote); return true; }
public static void RequireDirectory(TaskLoggingHelper log, string directory) { string fullDirectory = Path.GetFullPath(directory); if (File.Exists(fullDirectory)) throw new ArgumentException("Not a directory", "directory"); if (!Directory.Exists(fullDirectory)) { Directory.CreateDirectory(fullDirectory); log.LogMessage(MessageImportance.Low, "Created directory '{0}'", fullDirectory); } }
private async Task UploadAsync(CancellationToken ct, string item, string uploadPath, SemaphoreSlim clientThrottle, bool isLeaseRequired) { if (!File.Exists(item)) { throw new Exception(string.Format("The file '{0}' does not exist.", item)); } await clientThrottle.WaitAsync(); string leaseId = string.Empty; AzureBlobLease blobLease = new AzureBlobLease(feed.AccountName, feed.AccountKey, string.Empty, feed.ContainerName, uploadPath, Log, "60", "10"); if (isLeaseRequired) { try { leaseId = blobLease.Acquire(); } catch (Exception) { Log.LogError($"Unable to obtain lease on {uploadPath}"); } } try { Log.LogMessage($"Uploading {item} to {uploadPath}."); UploadClient uploadClient = new UploadClient(Log); await uploadClient.UploadBlockBlobAsync( ct, feed.AccountName, feed.AccountKey, feed.ContainerName, item, uploadPath, leaseId); } catch (Exception) { Log.LogError($"Unable to upload to {uploadPath}"); } finally { if (isLeaseRequired) { blobLease.Release(); } clientThrottle.Release(); } }
/// <summary> /// Log NUnit environment information. /// </summary> /// <param name="log">The logger.</param> public static void logEnvironmentInfo(TaskLoggingHelper log) { log.LogMessage(MessageImportance.Low, "AssemblyName: {0}", AssemblyName); log.LogMessage(MessageImportance.Low, "AssemblyCodeBase: {0}", AssemblyCodeBase); log.LogMessage(MessageImportance.Low, "AssemblyDirectory: {0}", AssemblyDirectory); log.LogMessage(MessageImportance.Low, "IsInteractive: {0}", IsInteractive); log.LogMessage(MessageImportance.Low, "CalledInBuildDirectory: {0}", CalledInBuildDirectory); log.LogMessage(MessageImportance.Low, "TestDirectory: {0}", TestDirectory); }
private static Version ParseVersionFromCandidate(TaskLoggingHelper logger, string pathToBaseVersionFile, string versionLineCandidate) { try { //keep it simple. no regex or other fancy ways would be overkill. var assemblyVersion = versionLineCandidate.Split('"')[1]; logger.LogMessage(MessageImportance.Normal, "Using base version: {0}.", assemblyVersion); Version version = new Version(assemblyVersion); return version; } catch (Exception exception) { throw new FormatException(pathToBaseVersionFile + " Assembly version declaration is in invalid format: '" + versionLineCandidate + "'.", exception); } }
public async Task <bool> PushItemsToFeedAsync(IEnumerable <string> items, bool allowOverwrite) { Log.LogMessage(MessageImportance.Low, $"START pushing items to feed"); Random rnd = new Random(); try { bool result = await PushAsync(items.ToList(), allowOverwrite); return(result); } catch (Exception e) { Log.LogErrorFromException(e); } return(!Log.HasLoggedErrors); }
public static bool InstallPackages(string packagesDirectory, string packagesConfigPath, string nugetExePath, TaskLoggingHelper log) { var nugetArguments = @"install -o " + packagesDirectory + " -Prerelease -NonInteractive " + packagesConfigPath; log.LogMessage("Installing: " + nugetExePath + " " + nugetArguments); ProcessStartInfo psi = new ProcessStartInfo(); psi.UseShellExecute = false; psi.FileName = nugetExePath; psi.Arguments = nugetArguments; psi.CreateNoWindow = true; var process = Process.Start(psi); if (!process.WaitForExit(20000)) { log.LogError("Packages installation timed out."); return false; } return true; }
public async Task <bool> PushItemsToFeedAsync( IEnumerable <string> items, PushOptions options) { Log.LogMessage(MessageImportance.Low, $"START pushing items to feed"); if (!items.Any()) { Log.LogMessage("No items to push found in the items list."); return(true); } try { return(await PushAsync(items, options)); } catch (Exception e) { Log.LogErrorFromException(e); } return(!Log.HasLoggedErrors); }
internal static Version Extract(TaskLoggingHelper logger, ITaskItem baseVersionItem) { if (baseVersionItem == null) { throw new ArgumentNullException("baseVersionItem"); } var pathToBaseVersionFile = baseVersionItem.ItemSpec; if (!File.Exists(pathToBaseVersionFile)) { logger.LogMessage(MessageImportance.Low, "Working in directory: " + Environment.CurrentDirectory); throw new InvalidOperationException("No base assembly info file exists with name " + pathToBaseVersionFile + "."); } // find assemblyVersion value from file: simplification, but since it is generated file, should be sufficient: string versionLineCandidate = File.ReadAllLines(pathToBaseVersionFile) .Where(line => !line.StartsWith("//")) .FirstOrDefault(line => line.Contains("AssemblyVersion")); if (versionLineCandidate == null) { throw new InvalidOperationException(pathToBaseVersionFile + " did not contain expected AssemblyVersionAttribute declaration."); } return ParseVersionFromCandidate(logger, pathToBaseVersionFile, versionLineCandidate); }
public bool Initialize(string taskName, IDictionary<string, TaskPropertyInfo> parameterGroup, string taskBody, IBuildEngine taskFactoryLoggingHost) { TaskLoggingHelper log = new TaskLoggingHelper(taskFactoryLoggingHost, taskName); // We use the property group for the declaration taskProperties = (from c in parameterGroup select c.Value).ToArray(); // Compile chunk try { log.LogMessage("Compile script."); task = lua.CompileChunk(taskBody, taskName, LuaDeskop.StackTraceCompileOptions, new KeyValuePair<string, Type>("engine", typeof(IBuildEngine)), new KeyValuePair<string, Type>("log", typeof(TaskLoggingHelper)) ); return true; } catch (LuaParseException e) { log.LogError("{0} (at line {1},{2})", e.Message, taskName, e.Line); return false; } } // func Initialize
private static string GetWindowsJavaSdkLocation (TaskLoggingHelper log) { string subkey = @"SOFTWARE\JavaSoft\Java Development Kit"; log.LogMessage ("Looking for Java SDK.."); foreach (var wow64 in new[] { RegistryEx.Wow64.Key32, RegistryEx.Wow64.Key64 }) { string key_name = string.Format (@"{0}\{1}\{2}", "HKLM", subkey, "CurrentVersion"); var currentVersion = RegistryEx.GetValueString (RegistryEx.LocalMachine, subkey, "CurrentVersion", wow64); if (!string.IsNullOrEmpty (currentVersion)) { log.LogMessage (" Key {0} found: {1}.", key_name, currentVersion); if (CheckRegistryKeyForExecutable (RegistryEx.LocalMachine, subkey + "\\" + currentVersion, "JavaHome", wow64, "bin", JarSignerTool, log)) return RegistryEx.GetValueString (RegistryEx.LocalMachine, subkey + "\\" + currentVersion, "JavaHome", wow64); } log.LogMessage (" Key {0} not found.", key_name); } // We ran out of things to check.. return null; }
/// <summary> /// Helper method for checking filename extensions when resolving references. /// </summary> /// <param name="reference">The reference being resolved.</param> /// <param name="basePath">Full filename path without extension.</param> /// <param name="filenameExtensions">Filename extensions to check.</param> /// <param name="log">Logging helper.</param> /// <returns>True if the item was resolved, else false.</returns> private static bool ResolveFilenameExtensions(ITaskItem reference, string basePath, string[] filenameExtensions, TaskLoggingHelper log) { foreach (string filenameExtension in filenameExtensions) { string path = basePath + filenameExtension; log.LogMessage(MessageImportance.Low, "Trying path {0}", path); if (File.Exists(path)) { reference.ItemSpec = path; return true; } } return false; }
private static bool CheckRegistryKeyForExecutable (UIntPtr key, string subkey, string valueName, MonoDroid.RegistryEx.Wow64 wow64, string subdir, string exe, TaskLoggingHelper log) { string key_name = string.Format (@"{0}\{1}\{2}", key == RegistryEx.CurrentUser ? "HKCU" : "HKLM", subkey, valueName); var path = NullIfEmpty (RegistryEx.GetValueString (key, subkey, valueName, wow64)); if (path == null) { log.LogMessage (" Key {0} not found.", key_name); return false; } if (!File.Exists (Path.Combine (path, subdir, exe))) { log.LogMessage (" Key {0} found:\n Path does not contain {1} in \\{2} ({3}).", key_name, exe, subdir, path); return false; } log.LogMessage (" Key {0} found:\n Path contains {1} in \\{2} ({3}).", key_name, exe, subdir, path); return true; }
public static void ProcessClientBigRequest(string ConnString, Stream requestStream, Stream responseStream, bool dispose, FlushDelegate flushDelegate, TaskLoggingHelper log) { XmlTextReader xr = new XmlTextReader(requestStream); XmlTextWriter xw = new XmlTextWriter(responseStream, Encoding.UTF8); xw.WriteStartDocument(); xw.WriteStartElement("table"); bool first = true; //using (xr) //{ xr.Read(); xr.Read(); xr.ReadStartElement("request"); while (xr.Name == "id") { int serviceTableID = Convert.ToInt32(xr.ReadElementString("id")); ServiceTable st = DAO.GetServiceTable(ConnString, serviceTableID); if (first) { if (log != null) log.LogMessage("Processing ID " + serviceTableID.ToString() + " response " + st.ServiceTableID.ToString()); first = false; } xw.WriteStartElement("record"); xw.WriteElementString("ServiceTableID", st.ServiceTableID.ToString()); xw.WriteElementString("DescServiceTable", st.DescServiceTable); xw.WriteElementString("Value", st.Value.ToString("0.00")); xw.WriteElementString("CreationDate", st.CreationDate.ToString("dd/MM/yyyy hh:mm:ss")); xw.WriteElementString("StringField1", st.StringField1); xw.WriteElementString("StringField2", st.StringField2); xw.WriteEndElement(); if (flushDelegate != null) flushDelegate(); } xr.ReadEndElement(); //} xr.Dispose(); xw.WriteEndElement(); xw.Flush(); if (dispose) xw.Close(); }
/// <summary> /// Resolves a single reference item by searcheing for referenced items using the specified SearchPaths. /// This method is made public so the resolution logic can be reused by other tasks. /// </summary> /// <param name="reference">The referenced item.</param> /// <param name="searchPaths">The paths to search.</param> /// <param name="searchFilenameExtensions">Filename extensions to check.</param> /// <param name="log">Logging helper.</param> /// <returns>The resolved reference item, or the original reference if it could not be resolved.</returns> public static ITaskItem ResolveReference(ITaskItem reference, string[] searchPaths, string[] searchFilenameExtensions, TaskLoggingHelper log) { if (reference == null) { throw new ArgumentNullException("reference"); } if (searchPaths == null) { // Nothing to search, so just return the original reference item. return reference; } if (searchFilenameExtensions == null) { searchFilenameExtensions = new string[] { }; } // Copy all the metadata from the source TaskItem resolvedReference = new TaskItem(reference); log.LogMessage(MessageImportance.Low, "WixReference: {0}", reference.ItemSpec); // Now find the resolved path based on our order of precedence foreach (string searchPath in searchPaths) { log.LogMessage(MessageImportance.Low, "Trying {0}", searchPath); if (searchPath.Equals(HintPathToken, StringComparison.Ordinal)) { string path = reference.GetMetadata("HintPath"); log.LogMessage(MessageImportance.Low, "Trying path {0}", path); if (File.Exists(path)) { resolvedReference.ItemSpec = path; break; } } else if (searchPath.Equals(RawFileNameToken, StringComparison.Ordinal)) { log.LogMessage(MessageImportance.Low, "Trying path {0}", resolvedReference.ItemSpec); if (File.Exists(resolvedReference.ItemSpec)) { break; } if (ResolveWixReferences.ResolveFilenameExtensions(resolvedReference, resolvedReference.ItemSpec, searchFilenameExtensions, log)) { break; } } else { string path = Path.Combine(searchPath, Path.GetFileName(reference.ItemSpec)); log.LogMessage(MessageImportance.Low, "Trying path {0}", path); if (File.Exists(path)) { resolvedReference.ItemSpec = path; break; } if (ResolveWixReferences.ResolveFilenameExtensions(resolvedReference, path, searchFilenameExtensions, log)) { break; } } } // Normalize the item path resolvedReference.ItemSpec = resolvedReference.GetMetadata("FullPath"); return resolvedReference; }
private static RegexCompilationInfo LoadRegexCompilationInfo(TaskLoggingHelper log, string regexFilePath) { log.LogMessage("Loading RegexCompilationInfo from \"{0}\".", regexFilePath); bool isPublic = false; string name = null; string @namespace = null; string pattern = null; RegexOptions regexOptions = RegexOptions.Compiled; FileInfo fileInfo = new FileInfo(regexFilePath); using (FileStream fileStream = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, (int)fileInfo.Length, FileOptions.SequentialScan)) { using (XmlReader xmlReader = XmlReader.Create(fileStream, XmlReaderSettings)) { while (xmlReader.MoveToNextAttribute() || xmlReader.Read()) { switch (xmlReader.NodeType) { case XmlNodeType.Element: case XmlNodeType.Attribute: switch (xmlReader.LocalName) { case "IsPublic": isPublic = xmlReader.ReadContentAsBoolean(); break; case "Name": name = xmlReader.ReadContentAsString(); break; case "Namespace": @namespace = xmlReader.ReadContentAsString(); break; case "CultureInvariant": regexOptions |= RegexOptions.CultureInvariant; break; case "ECMAScript": regexOptions |= RegexOptions.ECMAScript; break; case "ExplicitCapture": regexOptions |= RegexOptions.ExplicitCapture; break; case "IgnoreCase": regexOptions |= RegexOptions.IgnoreCase; break; case "IgnorePatternWhitespace": regexOptions |= RegexOptions.IgnorePatternWhitespace; break; case "Multiline": regexOptions |= RegexOptions.Multiline; break; case "RightToLeft": regexOptions |= RegexOptions.RightToLeft; break; case "Singleline": regexOptions |= RegexOptions.Singleline; break; case "Pattern": pattern = xmlReader.ReadElementContentAsString(); break; } break; } } } } RegexCompilationInfo regexCompilationInfo = new RegexCompilationInfo(pattern, regexOptions, name, @namespace, isPublic); log.LogMessage("RegexCompilationInfo loaded with settings:", null); log.LogMessage("\tNamespace:\t\t{0}", regexCompilationInfo.Namespace); log.LogMessage("\tName:\t\t\t{0}", regexCompilationInfo.Name); log.LogMessage("\tIsPublic:\t\t{0}", regexCompilationInfo.IsPublic); log.LogMessage("\tRegexOptions:\t{0}", regexCompilationInfo.Options); return regexCompilationInfo; }
/// <summary> /// Logs a message of the given importance using the specified string. /// </summary> /// <remarks>This method is not thread-safe.</remarks> /// <param name="Log">The Log to log to.</param> /// <param name="importance">The importance level of the message.</param> /// <param name="message">The message string.</param> /// <param name="messageArgs">Optional arguments for formatting the message string.</param> /// <exception cref="ArgumentNullException">Thrown when <c>message</c> is null.</exception> internal static void LogMessage(TaskLoggingHelper Log, MessageImportance importance, string message, params object[] messageArgs) { // Only log when we have been passed a TaskLoggingHelper Log?.LogMessage(importance, message, messageArgs); }
public async Task <bool> CheckIfBlobExistsAsync(string blobPath) { string url = $"{FeedContainerUrl}/{blobPath}?comp=metadata"; using (HttpClient client = new HttpClient()) { const int MaxAttempts = 15; // add a bit of randomness to the retry delay. var rng = new Random(); int retryCount = MaxAttempts; // Used to make sure TaskCancelledException comes from timeouts. CancellationTokenSource cancelTokenSource = new CancellationTokenSource(); while (true) { try { client.DefaultRequestHeaders.Clear(); var request = AzureHelper.RequestMessage("GET", url, AccountName, AccountKey).Invoke(); using (HttpResponseMessage response = await client.SendAsync(request, cancelTokenSource.Token)) { if (response.IsSuccessStatusCode) { Log.LogMessage( MessageImportance.Low, $"Blob {blobPath} exists for {AccountName}: Status Code:{response.StatusCode} Status Desc: {await response.Content.ReadAsStringAsync()}"); } else { Log.LogMessage( MessageImportance.Low, $"Blob {blobPath} does not exist for {AccountName}: Status Code:{response.StatusCode} Status Desc: {await response.Content.ReadAsStringAsync()}"); } return(response.IsSuccessStatusCode); } } catch (HttpRequestException toLog) { if (retryCount <= 0) { Log.LogError($"Unable to check for existence of blob {blobPath} in {AccountName} after {MaxAttempts} retries."); throw; } else { Log.LogWarning("Exception thrown while trying to detect if blob already exists in feed:"); Log.LogWarningFromException(toLog, true); } } catch (TaskCanceledException possibleTimeoutToLog) { // Detect timeout. if (possibleTimeoutToLog.CancellationToken != cancelTokenSource.Token) { if (retryCount <= 0) { Log.LogError($"Unable to check for existence of blob {blobPath} in {AccountName} after {MaxAttempts} retries."); throw; } else { Log.LogWarning("Exception thrown while trying to detect if blob already exists in feed:"); Log.LogWarningFromException(possibleTimeoutToLog, true); } } else { throw; } } --retryCount; Log.LogWarning($"Failed to check for existence of blob {blobPath}. {retryCount} attempts remaining"); int delay = (MaxAttempts - retryCount) * rng.Next(1, 7); await Task.Delay(delay * 1000); } } }
void BeginAssembly(object sender, AssemblyEventArgs e) { log.LogMessage(MessageImportance.Normal, "Processing '{0}'...", e.Assembly.FullName); }
public static async Task<HttpResponseMessage> RequestWithRetry(TaskLoggingHelper loggingHelper, HttpClient client, Func<HttpRequestMessage> createRequest, Func<HttpResponseMessage, bool> validationCallback = null, int retryCount = 5, int retryDelaySeconds = 5) { if (loggingHelper == null) throw new ArgumentNullException(nameof(loggingHelper)); if (client == null) throw new ArgumentNullException(nameof(client)); if (createRequest == null) throw new ArgumentNullException(nameof(createRequest)); if (retryCount < 1) throw new ArgumentException(nameof(retryCount)); if (retryDelaySeconds < 1) throw new ArgumentException(nameof(retryDelaySeconds)); int retries = 0; HttpResponseMessage response = null; // add a bit of randomness to the retry delay var rng = new Random(); while (retries < retryCount) { if (retries > 0) { if (response != null) { response.Dispose(); response = null; } int delay = retryDelaySeconds * retries * rng.Next(1, 5); loggingHelper.LogMessage(MessageImportance.Low, "Waiting {0} seconds before retry", delay); await System.Threading.Tasks.Task.Delay(delay * 1000); } try { using (var request = createRequest()) response = await client.SendAsync(request); } catch (Exception e) { loggingHelper.LogWarningFromException(e, true); // if this is the final iteration let the exception bubble up if (retries + 1 == retryCount) throw; } // response can be null if we fail to send the request if (response != null) { if (validationCallback == null) { // check if the response code is within the range of failures if (IsWithinRetryRange(response.StatusCode)) { loggingHelper.LogWarning("Request failed with status code {0}", response.StatusCode); } else { loggingHelper.LogMessage(MessageImportance.Low, "Response completed with status code {0}", response.StatusCode); return response; } } else { bool isSuccess = validationCallback(response); if (!isSuccess) { loggingHelper.LogMessage("Validation callback returned retry for status code {0}", response.StatusCode); } else { loggingHelper.LogMessage("Validation callback returned success for status code {0}", response.StatusCode); return response; } } } ++retries; } // retry count exceeded loggingHelper.LogWarning("Retry count {0} exceeded", retryCount); // set some default values in case response is null var statusCode = "None"; var contentStr = "Null"; if (response != null) { statusCode = response.StatusCode.ToString(); contentStr = await response.Content.ReadAsStringAsync(); response.Dispose(); } throw new HttpRequestException(string.Format("Request failed with status {0} response {1}", statusCode, contentStr)); }
public static bool ValidateNdkPlatform(TaskLoggingHelper log, string ndkPath, AndroidTargetArch arch, bool requireLibm) { // Check that we have a compatible NDK version for the targeted ABIs. NdkUtil.NdkVersion ndkVersion; bool hasNdkVersion = NdkUtil.GetNdkToolchainRelease (ndkPath, out ndkVersion); if (NdkUtil.IsNdk64BitArch(arch) && hasNdkVersion && ndkVersion.Version < 10) { log.LogMessage (MessageImportance.High, "The detected Android NDK version is incompatible with the targeted 64-bit architecture, " + "please upgrade to NDK r10 or newer."); } // NDK r10d is buggy and cannot link x86_64 ABI shared libraries because they are 32-bits. // See https://code.google.com/p/android/issues/detail?id=161421 if (requireLibm && ndkVersion.Version == 10 && ndkVersion.Revision == "d" && arch == AndroidTargetArch.X86_64) { log.LogCodedError ("XA3004", "Android NDK r10d is buggy and provides an incompatible x86_64 libm.so. " + "See https://code.google.com/p/android/issues/detail?id=161422."); return false; } return true; }
internal static void LogMessage(TaskLoggingHelper Log, MessageImportance importance, string message, params object[] messageArgs) { if (Log != null) { Log.LogMessage(importance, message, messageArgs); } }
private static string GetWindowsAndroidSdkLocation (TaskLoggingHelper log) { var roots = new[] { RegistryEx.CurrentUser, RegistryEx.LocalMachine }; var wow = RegistryEx.Wow64.Key32; log.LogMessage ("Looking for Android SDK.."); // Check for the key written by the Android SDK installer first foreach (var root in roots) if (CheckRegistryKeyForExecutable (root, ANDROID_INSTALLER_PATH, ANDROID_INSTALLER_KEY, wow, "platform-tools", AdbTool, log)) return RegistryEx.GetValueString (root, ANDROID_INSTALLER_PATH, ANDROID_INSTALLER_KEY, wow); // Check for the key the user gave us in the VS options foreach (var root in roots) if (CheckRegistryKeyForExecutable (root, MDREG_KEY, MDREG_ANDROID, wow, "platform-tools", AdbTool, log)) return RegistryEx.GetValueString (root, MDREG_KEY, MDREG_ANDROID, wow); // Check 2 default locations var program_files = GetProgramFilesX86 (); var installerLoc = Path.Combine (program_files, @"\Android\android-sdk-windows"); var unzipLoc = Path.Combine (program_files, @"C:\android-sdk-windows"); if (ValidateAndroidSdkLocation (installerLoc)) { log.LogMessage (" adb.exe found in {0}", installerLoc); return installerLoc; } if (ValidateAndroidSdkLocation (unzipLoc)) { log.LogMessage (" adb.exe found in {0}", unzipLoc); return unzipLoc; } // We ran out of things to check.. return null; }
public SelectorInfo(TaskLoggingHelper log, string selector) { Name = selector; string expression; if (selector.StartsWith("@")) { log.LogMessage(MessageImportance.Normal, "Processing <style/> tag #{0}"); expression = string.Concat(selector, @"[^\;]*\;"); } else { expression = string.Concat(selector, @"\s*\{[^\}]*\}"); } Expression = new Regex(expression); log.LogMessage(MessageImportance.Normal, "Style '{0}' Expression: \n{1}", Name, expression); }
/// <summary> /// Executes a tool, logs standard error and a nonzero exit code as errors, returns the output and optionally logs that /// as well. /// </summary> /// <param name="log">used for logging</param> /// <param name="executable">the name of the executable</param> /// <param name="args">the command line arguments</param> /// <param name="logOutput">should we log the output in real time</param> /// <returns>the output of the tool</returns> public static string ExecuteWithLogging(TaskLoggingHelper log, string executable, string args, bool logOutput) { if (log == null) { throw new ArgumentNullException("log"); } log.LogMessage(MessageImportance.Low, "Executing tool: {0} {1}", executable, args); var exec = new ShellWrapper(executable, args); // stderr is logged as errors exec.ErrorDataReceived += (sender, e) => { if (e.Data != null) { log.LogError(e.Data); } }; // stdout is logged normally if requested if (logOutput) { exec.OutputDataReceived += (sender, e) => { if (e.Data != null) { log.LogMessage(MessageImportance.Normal, e.Data); } }; } // execute the process exec.Execute(); // check the exit code if (exec.ExitCode != 0) { log.LogError("The tool {0} exited with error code {1}", executable, exec.ExitCode); } return exec.StandardOutput; }
public static void ImportarStream(string connString, Stream stream, TaskLoggingHelper log) { XmlTextReader rd = new XmlTextReader(stream); CultureInfo c = new CultureInfo("pt-BR"); c.DateTimeFormat.ShortDatePattern = "dd/MM/yyyy hh:mm:ss"; bool first = true; using (rd) { rd.Read(); rd.Read(); rd.ReadStartElement("table"); while (rd.Name == "record") { rd.ReadStartElement("record"); ServiceTable st = new ServiceTable(); st.ServiceTableID = Convert.ToInt32(rd.ReadElementContentAsString("ServiceTableID", "")); if (first) { if (log != null) log.LogMessage("Importing ID " + st.ServiceTableID.ToString()); first = false; } st.DescServiceTable = rd.ReadElementContentAsString("DescServiceTable", ""); st.Value = Convert.ToSingle(rd.ReadElementContentAsString("Value", "")); st.CreationDate = Convert.ToDateTime(rd.ReadElementContentAsString("CreationDate", ""), c.DateTimeFormat); st.StringField1 = rd.ReadElementContentAsString("StringField1", ""); st.StringField2 = rd.ReadElementContentAsString("StringField2", ""); rd.ReadEndElement(); /*if (Log != null) Log.LogMessage("ServiceTableID: " + st.ServiceTableID.ToString());*/ DAO.ProcessServiceTable(connString, st); } rd.ReadEndElement(); } }
/// <summary> /// Logs a message of the given importance using the specified resource string. To the specified Log. /// </summary> /// <remarks>This method is not thread-safe.</remarks> /// <param name="Log">The Log to log to.</param> /// <param name="importance">The importance level of the message.</param> /// <param name="messageResourceName">The name of the string resource to load.</param> /// <param name="messageArgs">Optional arguments for formatting the loaded string.</param> /// <exception cref="ArgumentNullException">Thrown when <c>messageResourceName</c> is null.</exception> internal static void LogMessageFromResources(TaskLoggingHelper Log, MessageImportance importance, string messageResourceName, params object[] messageArgs) { // Only log when we have been passed a TaskLoggingHelper if (Log != null) { ErrorUtilities.VerifyThrowArgumentNull(messageResourceName, "messageResourceName"); Log.LogMessage(importance, AssemblyResources.FormatResourceString(messageResourceName, messageArgs)); } }
public void Log(LogLevel level, string data) { _log.LogMessage(data, level); }
public static bool IsUpToDate(TaskLoggingHelper Log, UpToDateCheckType upToDateCheckType, FlatTrackingData inputs, FlatTrackingData outputs) { bool flag = false; ResourceManager taskResources = Log.TaskResources; Log.TaskResources = AssemblyResources.PrimaryResources; inputs.UpdateFileEntryDetails(); outputs.UpdateFileEntryDetails(); if ((!inputs.TlogsAvailable || !outputs.TlogsAvailable) || (inputs.DependencyTable.Count == 0)) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_LogFilesNotAvailable", new object[0]); } else if ((inputs.MissingFiles.Count > 0) || (outputs.MissingFiles.Count > 0)) { if (inputs.MissingFiles.Count > 0) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_MissingInputs", new object[0]); } if (inputs.MissingFiles.Count > 100) { FileTracker.LogMessageFromResources(Log, MessageImportance.Low, "Tracking_InputsNotShown", new object[] { inputs.MissingFiles.Count }); } else { foreach (string str in inputs.MissingFiles) { FileTracker.LogMessage(Log, MessageImportance.Low, "\t" + str, new object[0]); } } if (outputs.MissingFiles.Count > 0) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_MissingOutputs", new object[0]); } if (outputs.MissingFiles.Count > 100) { FileTracker.LogMessageFromResources(Log, MessageImportance.Low, "Tracking_OutputsNotShown", new object[] { outputs.MissingFiles.Count }); } else { foreach (string str2 in outputs.MissingFiles) { FileTracker.LogMessage(Log, MessageImportance.Low, "\t" + str2, new object[0]); } } } else if ((upToDateCheckType == UpToDateCheckType.InputOrOutputNewerThanTracking) && (inputs.NewestFileTimeUtc > inputs.NewestTLogTimeUtc)) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_DependencyWasModifiedAt", new object[] { inputs.NewestFileName, inputs.NewestFileTimeUtc }); } else if ((upToDateCheckType == UpToDateCheckType.InputOrOutputNewerThanTracking) && (outputs.NewestFileTimeUtc > outputs.NewestTLogTimeUtc)) { Log.LogMessage(MessageImportance.Low, "Tracking_DependencyWasModifiedAt", new object[] { outputs.NewestFileName, outputs.NewestFileTimeUtc }); } else if ((upToDateCheckType == UpToDateCheckType.InputNewerThanOutput) && (inputs.NewestFileTimeUtc > outputs.NewestFileTimeUtc)) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_DependencyWasModifiedAt", new object[] { inputs.NewestFileName, inputs.NewestFileTimeUtc }); } else if ((upToDateCheckType == UpToDateCheckType.InputNewerThanTracking) && (inputs.NewestFileTimeUtc > inputs.NewestTLogTimeUtc)) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_DependencyWasModifiedAt", new object[] { inputs.NewestFileName, inputs.NewestFileTimeUtc }); } else if ((upToDateCheckType == UpToDateCheckType.InputNewerThanTracking) && (inputs.NewestFileTimeUtc > outputs.NewestTLogTimeUtc)) { Log.LogMessageFromResources(MessageImportance.Low, "Tracking_DependencyWasModifiedAt", new object[] { inputs.NewestFileName, inputs.NewestFileTimeUtc }); } else { flag = true; Log.LogMessageFromResources(MessageImportance.Normal, "Tracking_UpToDate", new object[0]); } Log.TaskResources = taskResources; return flag; }
/// <summary> /// Logs a message of the given importance using the specified string. /// </summary> /// <remarks>This method is not thread-safe.</remarks> /// <param name="importance">The importance level of the message.</param> /// <param name="message">The message string.</param> /// <param name="messageArgs">Optional arguments for formatting the message string.</param> /// <exception cref="ArgumentNullException">Thrown when <c>message</c> is null.</exception> internal static void LogMessage(TaskLoggingHelper Log, MessageImportance importance, string message, params object[] messageArgs) { // Only log when we have been passed a TaskLoggingHelper if (Log != null) { Log.LogMessage(importance, message, messageArgs); } }