internal override void WriteWarning( PSEventId id, PSOpcode opcode, PSTask task, params object[] args) { }
/// <summary> /// Writes a log entry. /// </summary> /// <param name="eventId">The event id of the log entry.</param> /// <param name="channel">The channel to log.</param> /// <param name="task">The task for the log entry.</param> /// <param name="opcode">The operation for the log entry.</param> /// <param name="level">The logging level.</param> /// <param name="keyword">The keyword(s) for the event.</param> /// <param name="args">The payload for the log message.</param> public void Log(PSEventId eventId, PSChannel channel, PSTask task, PSOpcode opcode, PSLevel level, PSKeyword keyword, params object[] args) { if (ShouldLog(level, keyword, channel)) { int threadId = Thread.CurrentThread.ManagedThreadId; StringBuilder sb = MessageBuilder; sb.Clear(); // add the message preamble sb.AppendFormat(CultureInfo.InvariantCulture, "({0}:{1:X}:{2:X}) [{3:G}:{4:G}.{5:G}.{6:G}] ", PSVersionInfo.GitCommitId, threadId, channel, eventId, task, opcode, level); // add the message GetEventMessage(sb, eventId, args); NativeMethods.SysLogPriority priority; if ((int)level <= _levels.Length) { priority = _levels[(int)level]; } else { priority = NativeMethods.SysLogPriority.Info; } // log it. NativeMethods.SysLog(priority, sb.ToString()); } }
/// <summary> /// Provider interface function for logging command lifecycle event /// </summary> /// <param name="getLogContext"></param> /// <param name="newState"></param> /// internal override void LogCommandLifecycleEvent(Func <LogContext> getLogContext, CommandState newState) { if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic)) { LogContext logContext = getLogContext(); StringBuilder payload = PayloadBuilder; payload.Clear(); if (logContext.CommandType != null) { if (logContext.CommandType.Equals(StringLiterals.Script, StringComparison.OrdinalIgnoreCase)) { payload.AppendLine(StringUtil.Format(EtwLoggingStrings.ScriptStateChange, newState.ToString())); } else { payload.AppendLine(StringUtil.Format(EtwLoggingStrings.CommandStateChange, logContext.CommandName, newState.ToString())); } } PSTask task = PSTask.CommandStart; if (newState == CommandState.Stopped || newState == CommandState.Terminated) { task = PSTask.CommandStop; } WriteEvent(PSEventId.Command_Lifecycle, PSChannel.Analytic, PSOpcode.Method, task, logContext, payload.ToString()); } }
internal override void WriteInformation( PSEventId id, PSOpcode opcode, PSTask task, params object[] args) { }
/// <summary> /// Writes a single event /// </summary> /// <param name="id">event id</param> /// <param name="channel"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="logContext">log context</param> /// <param name="payLoad"></param> internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { s_provider.Log(id, channel, task, opcode, GetPSLevelFromSeverity(logContext.Severity), DefaultKeywords, LogContextToString(logContext), GetPSLogUserData(logContext.ExecutionContext), payLoad); }
internal override void LogCommandLifecycleEvent(Func <LogContext> getLogContext, CommandState newState) { if (this.IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic)) { LogContext logContext = getLogContext(); StringBuilder builder = new StringBuilder(); if (logContext.CommandType != null) { if (logContext.CommandType.Equals("SCRIPT", StringComparison.OrdinalIgnoreCase)) { builder.AppendLine(StringUtil.Format(EtwLoggingStrings.ScriptStateChange, newState.ToString())); } else { builder.AppendLine(StringUtil.Format(EtwLoggingStrings.CommandStateChange, logContext.CommandName, newState.ToString())); } } PSTask commandStart = PSTask.CommandStart; if ((newState == CommandState.Stopped) || (newState == CommandState.Terminated)) { commandStart = PSTask.CommandStop; } this.WriteEvent(PSEventId.Command_Lifecycle, PSChannel.Analytic, PSOpcode.Method, commandStart, logContext, builder.ToString()); } }
internal override void WriteCritialError( PSEventId id, PSOpcode opcode, PSTask task, params object[] args) { }
public async Task <IActionResult> PutPSTask(int id, PSTask pSTask) { if (id != pSTask.Id) { return(BadRequest()); } _context.Entry(pSTask).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PSTaskExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
internal override void ReplaceActivityIdForCurrentThread( Guid newActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { }
internal override void WriteTransferEvent( Guid relatedActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { }
internal override void WriteEvent( PSEventId id, PSLevel level, PSOpcode opcode, PSTask task, params object[] args) { }
static internal void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, Int64 objectId, Int64 fragmentId, int isStartFragment, int isEndFragment, UInt32 fragmentLength, PSETWBinaryBlob fragmentData) { }
internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, long objectId, long fragmentId, int isStartFragment, int isEndFragment, int fragmentLength, PSETWBinaryBlob fragmentData) { if (provider.IsEnabled(PSLevel.Verbose, keyword)) { string str = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length); str = string.Format(CultureInfo.InvariantCulture, "0x{0}", new object[] { str.Replace("-", "") }); provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword, new object[] { objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength, str }); } }
public async Task <ActionResult <PSTask> > PostPSTask(PSTask pSTask) { if (pSTask.User != null && pSTask.User.Id != 0) { return(BadRequest()); } _context.PSTask.Add(pSTask); await _context.SaveChangesAsync(); return(CreatedAtAction("GetPSTask", new { id = pSTask.Id }, pSTask)); }
internal override void LogEngineLifecycleEvent(LogContext logContext, EngineState newState, EngineState previousState) { if (this.IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic)) { StringBuilder builder = new StringBuilder(); builder.AppendLine(StringUtil.Format(EtwLoggingStrings.EngineStateChange, previousState.ToString(), newState.ToString())); PSTask engineStart = PSTask.EngineStart; if (((newState == EngineState.Stopped) || (newState == EngineState.OutOfService)) || ((newState == EngineState.None) || (newState == EngineState.Degraded))) { engineStart = PSTask.EngineStop; } this.WriteEvent(PSEventId.Engine_Lifecycle, PSChannel.Analytic, PSOpcode.Method, engineStart, logContext, builder.ToString()); } }
internal override void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState) { if (this.IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic)) { StringBuilder builder = new StringBuilder(); builder.AppendLine(StringUtil.Format(EtwLoggingStrings.ProviderStateChange, providerName, newState.ToString())); PSTask providerStart = PSTask.ProviderStart; if (newState == ProviderState.Stopped) { providerStart = PSTask.ProviderStop; } this.WriteEvent(PSEventId.Provider_Lifecycle, PSChannel.Analytic, PSOpcode.Method, providerStart, logContext, builder.ToString()); } }
/// <summary> /// Logs remoting fragment data to verbose channel. /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="objectId"></param> /// <param name="fragmentId"></param> /// <param name="isStartFragment"></param> /// <param name="isEndFragment"></param> /// <param name="fragmentLength"></param> /// <param name="fragmentData"></param> internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, Int64 objectId, Int64 fragmentId, int isStartFragment, int isEndFragment, UInt32 fragmentLength, PSETWBinaryBlob fragmentData) { if (provider.IsEnabled(PSLevel.Verbose, keyword)) { string payLoadData = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length); payLoadData = string.Format(CultureInfo.InvariantCulture, "0x{0}", payLoadData.Replace("-", string.Empty)); provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword, objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength, payLoadData); } }
/// <summary> /// Provider interface function for logging provider lifecycle event /// </summary> /// <param name="logContext"></param> /// <param name="providerName"></param> /// <param name="newState"></param> internal override void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState) { if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic)) { StringBuilder payload = PayloadBuilder; payload.Clear(); payload.AppendLine(StringUtil.Format(EtwLoggingStrings.ProviderStateChange, providerName, newState.ToString())); PSTask task = PSTask.ProviderStart; if (newState == ProviderState.Stopped) { task = PSTask.ProviderStop; } WriteEvent(PSEventId.Provider_Lifecycle, PSChannel.Analytic, PSOpcode.Method, task, logContext, payload.ToString()); } }
/// <summary> /// Provider interface function for logging engine lifecycle event /// </summary> /// <param name="logContext"></param> /// <param name="newState"></param> /// <param name="previousState"></param> internal override void LogEngineLifecycleEvent(LogContext logContext, EngineState newState, EngineState previousState) { if (IsEnabled(PSLevel.Informational, PSKeyword.Cmdlets | PSKeyword.UseAlwaysAnalytic)) { StringBuilder payload = new StringBuilder(); payload.AppendLine(StringUtil.Format(EtwLoggingStrings.EngineStateChange, previousState.ToString(), newState.ToString())); PSTask task = PSTask.EngineStart; if (newState == EngineState.Stopped || newState == EngineState.OutOfService || newState == EngineState.None || newState == EngineState.Degraded) { task = PSTask.EngineStop; } WriteEvent(PSEventId.Engine_Lifecycle, PSChannel.Analytic, PSOpcode.Method, task, logContext, payload.ToString()); } }
/// <summary> /// Writes a log entry. /// </summary> /// <param name="eventId">The event id of the log entry.</param> /// <param name="channel">The channel to log.</param> /// <param name="task">The task for the log entry.</param> /// <param name="opcode">The operation for the log entry.</param> /// <param name="level">The logging level.</param> /// <param name="keyword">The keyword(s) for the event.</param> /// <param name="args">The payload for the log message.</param> public void Log(PSEventId eventId, PSChannel channel, PSTask task, PSOpcode opcode, PSLevel level, PSKeyword keyword, params object[] args) { if (keyword == PSKeyword.UseAlwaysAnalytic) { // Use the 'DefaultKeywords' to work around the default keyword filter. // Note that the PSKeyword argument is not really used in writing SysLog. keyword = PSSysLogProvider.DefaultKeywords; } if (ShouldLog(level, keyword, channel)) { int threadId = Thread.CurrentThread.ManagedThreadId; StringBuilder sb = MessageBuilder; sb.Clear(); // add the message preamble sb.AppendFormat(CultureInfo.InvariantCulture, "({0}:{1:X}:{2:X}) [{3:G}:{4:G}.{5:G}.{6:G}] ", PSVersionInfo.GitCommitId, threadId, channel, eventId, task, opcode, level); // add the message GetEventMessage(sb, eventId, args); NativeMethods.SysLogPriority priority; if ((int)level <= _levels.Length) { priority = _levels[(int)level]; } else { priority = NativeMethods.SysLogPriority.Info; } // log it. NativeMethods.SysLog(priority, sb.ToString()); } }
/// <summary> /// Logs error message to the operational channel. /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="logContext"></param> /// <param name="payLoad"></param> internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { provider.WriteEvent(id, PSChannel.Operational, opcode, task, logContext, payLoad); }
internal static void ReplaceActivityIdForCurrentThread(Guid newActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { // set the new activity id provider.SetActivityIdForCurrentThread(newActivityId); // Once the activity id is set, write the transfer event WriteTransferEvent(newActivityId, eventForOperationalChannel, eventForAnalyticChannel, keyword, task); }
/// <summary> /// Logs informational message to the analytic channel. /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="args"></param> internal static void LogAnalyticInformational(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Informational, task, keyword, args); }
/// <summary> /// Logs error message to operation channel. /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="args"></param> internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { provider.WriteEvent(id, PSChannel.Operational, opcode, PSLevel.Error, task, keyword, args); }
static internal void LogOperationalInformation(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { }
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args) { long keywords = 0L; if ((keyword == PSKeyword.UseAlwaysAnalytic) || (keyword == PSKeyword.UseAlwaysOperational)) { keywords = 0L; } else { keywords = (long) keyword; } System.Diagnostics.Eventing.EventDescriptor eventDescriptor = new System.Diagnostics.Eventing.EventDescriptor((int) id, 1, (byte) channel, (byte) level, (byte) opcode, (int) task, keywords); etwProvider.WriteEvent(ref eventDescriptor, args); }
internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args) { long keywords = 0L; if ((keyword == PSKeyword.UseAlwaysAnalytic) || (keyword == PSKeyword.UseAlwaysOperational)) { keywords = 0L; } else { keywords = (long)keyword; } System.Diagnostics.Eventing.EventDescriptor eventDescriptor = new System.Diagnostics.Eventing.EventDescriptor((int)id, 1, (byte)channel, (byte)level, (byte)opcode, (int)task, keywords); etwProvider.WriteEvent(ref eventDescriptor, args); }
/// <summary> /// Writes an event /// </summary> /// <param name="id"></param> /// <param name="channel"></param> /// <param name="opcode"></param> /// <param name="level"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="args"></param> internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args) { long longKeyword = 0x00; if (keyword == PSKeyword.UseAlwaysAnalytic || keyword == PSKeyword.UseAlwaysOperational) { longKeyword = 0x00; } else { longKeyword = (long)keyword; } EventDescriptor desc = new EventDescriptor((int)id, (byte)PSEventVersion.One, (byte)channel, (byte)level, (byte)opcode, (int)task, longKeyword); etwProvider.WriteEvent(ref desc, args); }
static internal void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { }
static internal void ReplaceActivityIdForCurrentThread(Guid newActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { }
static internal void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { }
/// <summary> /// Writes a transfer event mapping current activity id /// with a related activity id /// This function writes a transfer event for both the /// operational and analytic channels. /// </summary> /// <param name="relatedActivityId"></param> /// <param name="eventForOperationalChannel"></param> /// <param name="eventForAnalyticChannel"></param> /// <param name="keyword"></param> /// <param name="task"></param> internal static void WriteTransferEvent(Guid relatedActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { provider.WriteEvent(eventForOperationalChannel, PSChannel.Operational, PSOpcode.Method, PSLevel.Informational, task, PSKeyword.UseAlwaysOperational); provider.WriteEvent(eventForAnalyticChannel, PSChannel.Analytic, PSOpcode.Method, PSLevel.Informational, task, PSKeyword.UseAlwaysAnalytic); }
static void Main(string[] args) { Console.WriteLine("Main function's AppDomain: " + AppDomain.CurrentDomain.FriendlyName); PSTaskManager TaskManager = new PSTaskManager(); while (true) { StringBuilder output = new StringBuilder(); // 1. Check for any pending commands (new job, kill job(s), list job(s), checkin on job) string input = RecieveInput(); // 2. Execute incoming command (new job, status, stop, exit, etc.) List <PSTask> tasks = TaskManager.GetAllTasks(); if (input == "status") { foreach (PSTask task in tasks) { Console.WriteLine(task.ID + "\t" + task.GetStatus()); } } else if (input == "exit") { try { TaskManager.KillAllTasks(); } catch (Exception e) { // Do something with the error... SendOutput(e.ToString()); } // TODO: Return the output of any tasks here... break; } else if (input != String.Empty) { int TaskID = TaskManager.Execute(input); // 2b. Return the TaskID } // 3. Remove stopped/completed jobs and store output // Count backwards so we don't skip anything in case we have to remove something for (int i = tasks.Count - 1; i >= 0; i--) { PSTask t = tasks[i]; PipelineState status = t.GetStatus(); if (status == PipelineState.Completed || status == PipelineState.Failed || status == PipelineState.Stopped) { // Step 3b. - Create the return data structure output.Append("\n\n\n************ Task " + t.ID + " Output ************\n"); output.Append("Status: " + t.GetStatus() + "\n"); output.Append("Output: " + t.GetOutput()); // Step 3c. - Destroy/remove the job try { TaskManager.KillTask(t.ID); } catch (Exception e) { // Do something with the error... SendOutput(e.ToString()); } } } // Step 3b - Manually invoke the garbage collector to free decrease memory usage... InvokeGarbageCollector(); // 4. Return output (output from steps 2 and 3) SendOutput(output.ToString()); } }
/// <summary> /// Writes a single event /// </summary> /// <param name="id">event id.</param> /// <param name="channel"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="logContext">log context.</param> /// <param name="payLoad"></param> internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { WriteEvent(id, channel, opcode, GetPSLevelFromSeverity(logContext.Severity), task, (PSKeyword)0x0, LogContextToString(logContext), GetPSLogUserData(logContext.ExecutionContext), payLoad); }
/// <summary> /// Writes an event /// </summary> /// <param name="id"></param> /// <param name="channel"></param> /// <param name="opcode"></param> /// <param name="level"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="args"></param> internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSLevel level, PSTask task, PSKeyword keyword, params object[] args) { s_provider.Log(id, channel, task, opcode, level, keyword, args); }
/// <summary> /// Logs remoting fragment data to verbose channel. /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="objectId"></param> /// <param name="fragmentId"></param> /// <param name="isStartFragment"></param> /// <param name="isEndFragment"></param> /// <param name="fragmentLength"></param> /// <param name="fragmentData"></param> internal static void LogAnalyticVerbose(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, Int64 objectId, Int64 fragmentId, int isStartFragment, int isEndFragment, UInt32 fragmentLength, PSETWBinaryBlob fragmentData) { if (provider.IsEnabled(PSLevel.Verbose, keyword)) { string payLoadData = BitConverter.ToString(fragmentData.blob, fragmentData.offset, fragmentData.length); payLoadData = string.Format(CultureInfo.InvariantCulture, "0x{0}", payLoadData.Replace("-", "")); provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Verbose, task, keyword, objectId, fragmentId, isStartFragment, isEndFragment, fragmentLength, payLoadData); } }
/// <summary> /// Logs informational message to the analytic channel /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="keyword"></param> /// <param name="args"></param> internal static void LogAnalyticInformational(PSEventId id, PSOpcode opcode, PSTask task, PSKeyword keyword, params object[] args) { provider.WriteEvent(id, PSChannel.Analytic, opcode, PSLevel.Informational, task, keyword, args); }
/// <summary> /// Logs error message to the operational channel /// </summary> /// <param name="id"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="logContext"></param> /// <param name="payLoad"></param> internal static void LogOperationalError(PSEventId id, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { provider.WriteEvent(id, PSChannel.Operational, opcode, task, logContext, payLoad); }
/// <summary> /// Writes a single event /// </summary> /// <param name="id">event id</param> /// <param name="channel"></param> /// <param name="opcode"></param> /// <param name="task"></param> /// <param name="logContext">log context</param> /// <param name="payLoad"></param> internal void WriteEvent(PSEventId id, PSChannel channel, PSOpcode opcode, PSTask task, LogContext logContext, string payLoad) { WriteEvent(id, channel, opcode, GetPSLevelFromSeverity(logContext.Severity), task, (PSKeyword)0x0, LogContextToString(logContext), GetPSLogUserData(logContext.ExecutionContext), payLoad); }
/// <summary> /// Writes a transfer event mapping current activity id /// with a related activity id /// This function writes a transfer event for both the /// operational and analytic channels /// </summary> /// <param name="relatedActivityId"></param> /// <param name="eventForOperationalChannel"></param> /// <param name="eventForAnalyticChannel"></param> /// <param name="keyword"></param> /// <param name="task"></param> internal static void WriteTransferEvent(Guid relatedActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { provider.WriteEvent(eventForOperationalChannel, PSChannel.Operational, PSOpcode.Method, PSLevel.Informational, task, PSKeyword.UseAlwaysOperational); provider.WriteEvent(eventForAnalyticChannel, PSChannel.Analytic, PSOpcode.Method, PSLevel.Informational, task, PSKeyword.UseAlwaysAnalytic); }
internal static void ReplaceActivityIdForCurrentThread(Guid newActivityId, PSEventId eventForOperationalChannel, PSEventId eventForAnalyticChannel, PSKeyword keyword, PSTask task) { provider.SetActivityIdForCurrentThread(newActivityId); WriteTransferEvent(newActivityId, eventForOperationalChannel, eventForAnalyticChannel, keyword, task); }