public bool DeleteStackEvent(StackEvent entity)
{
if (entity == null) return false;
_unitOfWork.StackEventRepository.Delete(entity);
_unitOfWork.Save();
return true;
}
/// <summary>
/// Log an error if we expected success and got a rollback
/// </summary>
/// <param name="status">The status of the stack, or null if the stack does not exist</param>
/// <param name="expectSuccess">True if the status should indicate success</param>
/// <param name="missingIsFailure">True if the a missing stack indicates a failure, and false otherwise</param>
/// <param name="deployment">The current deployment</param>
private void LogRollbackError(
RunningDeployment deployment,
StackEvent status,
bool expectSuccess,
bool missingIsFailure)
{
Guard.NotNull(deployment, "deployment can not be null");
var isUnsuccessful = StatusIsUnsuccessfulResult(status, missingIsFailure);
var isStackType = status?.ResourceType.Equals("AWS::CloudFormation::Stack") ?? true;
if (expectSuccess && isUnsuccessful && isStackType)
{
Log.Warn(
"Stack was either missing, in a rollback state, or in a failed state. This means that the stack was not processed correctly. " +
"Review the stack in the AWS console to find any errors that may have occured during deployment.");
try
{
var progressStatus = StackEvent(stack => stack.ResourceStatusReason != null);
if (progressStatus != null)
{
Log.Warn(progressStatus.ResourceStatusReason);
}
}
catch (PermissionException)
{
// ignore, it just means we won't display any of the status reasons
}
throw new RollbackException(
"AWS-CLOUDFORMATION-ERROR-0001: CloudFormation stack finished in a rollback or failed state. " +
"For more information visit https://g.octopushq.com/AwsCloudFormationDeploy#aws-cloudformation-error-0001");
}
}
protected void PushEvent()
{
StackEvent e = onPush;
if (e != null)
{
e();
}
}
protected void PopEvent()
{
StackEvent e = onPop;
if (e != null)
{
e();
}
}
/// <summary>
/// Read a stack event
/// </summary>
/// <param name="from">Origin</param>
/// <param name="channel">Code channel where the stack event occurred</param>
/// <param name="stackDepth">New stack depth</param>
/// <param name="flags">Flags of the stack</param>
/// <param name="feedrate">Feedrate in mm/s</param>
/// <returns>Number of bytes read</returns>
/// <seealso cref="Request.StackEvent"/>
public static int ReadStackEvent(ReadOnlySpan <byte> from, out CodeChannel channel, out byte stackDepth, out StackFlags flags, out float feedrate)
{
StackEvent header = MemoryMarshal.Cast <byte, StackEvent>(from)[0];
channel = (CodeChannel)header.Channel;
stackDepth = header.StackDepth;
flags = (StackFlags)header.Flags;
feedrate = header.Feedrate;
return(Marshal.SizeOf(header));
}
public bool DeleteStackEvent(StackEvent entity)
{
if (entity == null)
{
return(false);
}
_unitOfWork.StackEventRepository.Delete(entity);
_unitOfWork.Save();
return(true);
}
public void Push(T obj)
{
data.Add(obj);
if (StackEvent != null)
{
StackEvent.Invoke(this, new StackEventData <T> {
IsPushed = true, Value = obj
});
}
}
public virtual StackEvent Dropoff(IStack stack)
{
var dropoff = new StackEvent(World.Environment, TriggerPickup, CancelDrop)
{
Stack = stack, Size = stack.Size
};
DropoffQueue.AddLast(dropoff);
TriggerDropoff();
return(dropoff);
}
public virtual StackEvent Pickup(int size)
{
var pickup = new StackEvent(World.Environment, TriggerDropoff, CancelPick)
{
Size = size
};
PickupQueue.AddLast(pickup);
TriggerPickup();
return(pickup);
}
/// <summary>
/// These status indicate that an update or create was not successful.
/// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html#w2ab2c15c15c17c11
/// </summary>
/// <param name="status">The status to check</param>
/// <param name="defaultValue">The default value if status is null</param>
/// <returns>true if the status indcates a failed create or update, and false otherwise</returns>
private bool StatusIsUnsuccessfulResult(StackEvent status, bool defaultValue)
{
return(new[]
{
"CREATE_ROLLBACK_COMPLETE", "CREATE_ROLLBACK_FAILED", "UPDATE_ROLLBACK_COMPLETE",
"UPDATE_ROLLBACK_FAILED", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED", "DELETE_FAILED",
"CREATE_FAILED"
}.Any(x =>
status?.ResourceStatus.Value.Equals(x, StringComparison.InvariantCultureIgnoreCase) ??
defaultValue));
}
public bool AddStackEvent(StackEvent entity)
{
try
{
_unitOfWork.StackEventRepository.Add(entity);
_unitOfWork.Save();
}
catch (Exception ex)
{
throw;
}
return(true);
}
/// <summary>
/// Write the state of the stack, but only if it changed since last time. If we are
/// writing the same message more than once, do it as verbose logging.
/// </summary>
/// <param name="status">The current status of the stack</param>
private void LogCurrentStates(StackEvent status)
{
var statusMessage =
$"{status?.ResourceType.Map(type => type + " ")}{status?.ResourceStatus.Value ?? "Does not exist"}";
if (statusMessage != lastMessage)
{
Log.Info($"Current stack state: {statusMessage}");
}
else
{
Log.Verbose($"Current stack state: {statusMessage}");
}
lastMessage = statusMessage;
}
public T Pop()
{
if (data.Count == 0)
{
throw new InvalidOperationException();
}
var result = data[data.Count - 1];
if (StackEvent != null)
{
StackEvent.Invoke(this, new StackEventData <T> {
IsPushed = false, Value = result
});
}
return(result);
}
/// <summary>
/// Stack events
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public override int OnStackEvent(StackEvent e)
{
short code = e.getCode();
String phrase = e.getPhrase();
if (code == tinyWRAP.tsip_event_code_stack_started)
{
this.sipService.SipStack.State = MySipStack.STACK_STATE.STARTED;
EventHandlerTrigger.TriggerEvent <StackEventArgs>(this.sipService.onStackEvent, this.sipService,
new StackEventArgs(StackEventTypes.START_OK, phrase));
}
else if (code == tinyWRAP.tsip_event_code_stack_failed_to_start)
{
EventHandlerTrigger.TriggerEvent <StackEventArgs>(this.sipService.onStackEvent, this.sipService,
new StackEventArgs(StackEventTypes.START_NOK, phrase));
}
else if (code == tinyWRAP.tsip_event_code_stack_failed_to_stop)
{
EventHandlerTrigger.TriggerEvent <StackEventArgs>(this.sipService.onStackEvent, this.sipService,
new StackEventArgs(StackEventTypes.STOP_NOK, phrase));
}
else if (code == tinyWRAP.tsip_event_code_stack_stopped)
{
this.sipService.SipStack.State = MySipStack.STACK_STATE.STOPPED;
// Reset contents
this.sipService.subWinfoContent = null;
this.sipService.subRegContent = null;
this.sipService.subRLSContent = null;
this.sipService.subMwiContent = null;
EventHandlerTrigger.TriggerEvent <StackEventArgs>(this.sipService.onStackEvent, this.sipService,
new StackEventArgs(StackEventTypes.STOP_OK, phrase));
}
return(0);
}
public bool AddStackEvent(StackEvent entity)
{
_unitOfWork.StackEventRepository.Add(entity);
_unitOfWork.Save();
return true;
}
/// <inheritdoc />
public void LogStackEvent(StackEvent @event)
{
}
public static bool StackIsUnrecoverable(this StackEvent status)
{
Guard.NotNull(status, "Status should not be null");
return(UnrecoverableStackStatuses.Contains(status.ResourceStatus.Value));
}
/// <summary>
/// Check the stack event status to determine whether it was successful.
/// http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html#w2ab2c15c15c17c11
/// </summary>
/// <param name="status">The status to check</param>
/// <returns>true if the status indicates a failed create or update, and false otherwise</returns>
public static Maybe <bool> MaybeIndicatesSuccess(this StackEvent status)
{
return(status.ToMaybe().Select(x => !UnsuccessfulStackEvents.Contains(x.ResourceStatus.Value)));
}
/// <summary>
/// Logs a stack event.
/// </summary>
/// <param name="event">The event.</param>
public override void LogStackEvent(StackEvent @event)
{
this.StackEvents.Add(@event);
}
private static bool IsFinalStackEvent(StackEvent evt) => (evt.ResourceType == "AWS::CloudFormation::Stack") && _finalStates.Contains(evt.ResourceStatus);
public void Publish(object sender, TEventArgs eventArg)
{
StackEvent?.Invoke(sender, eventArg);
}
/// <summary>
/// Logs a stack event.
/// </summary>
/// <param name="event">The event.</param>
public override void LogStackEvent(StackEvent @event)
{
const int TimeColWidth = 8;
var stackColWidth = Math.Max(9, Math.Min(this.StackNameColumnWidth, 40));
var resourceColWidth = Math.Max(11, Math.Min(this.ResourceNameColumnWidth, 40));
var ui = this.cmdlet.Host.UI;
var bg = ui.RawUI.BackgroundColor;
if (this.isFirstEvent)
{
var eventFormatString =
$"{{0,-{TimeColWidth}}} {{1,-{stackColWidth}}} {{2,-{resourceColWidth}}} {{3,-{this.StatusColumnWidth}}} {{4}}";
// Resize window to be wide enough for a reasonable amount of description per line
this.ResizeWindow(string.Format(eventFormatString, "x", "x", "x", "x", Padding30).Length);
this.isFirstEvent = false;
this.LogInformation(eventFormatString, "Time", "StackName", "Logical ID", "Status", "Status Reason");
this.LogInformation(eventFormatString, "----", "---------", "----------", "------", "-------------");
}
var leftIndent = GetLeftMarginForLastColumn(
TimeColWidth,
stackColWidth,
resourceColWidth,
this.StatusColumnWidth);
var maxLineLength = ui.RawUI.WindowSize.Width - leftIndent;
ui.Write($"{@event.Timestamp:HH:mm:ss} ");
ui.Write(this.EllipsisString(@event.StackName, stackColWidth).PadRight(stackColWidth + 1));
ui.Write(this.EllipsisString(@event.LogicalResourceId, resourceColWidth).PadRight(resourceColWidth + 1));
var fg = ui.RawUI.ForegroundColor;
var status = @event.ResourceStatus.Value;
if (status.Contains("ROLLBACK") || ErrorStatus.IsMatch(status))
{
fg = ConsoleColor.Red;
}
else if (status.EndsWith("IN_PROGRESS"))
{
fg = ConsoleColor.Cyan;
}
else if (status.EndsWith("COMPLETE"))
{
fg = ConsoleColor.Green;
}
ui.Write(fg, bg, status.PadRight(this.StatusColumnWidth + 1));
if (string.IsNullOrEmpty(@event.ResourceStatusReason))
{
ui.WriteLine("-");
}
else
{
fg = ErrorStatus.IsMatch(status) ? ConsoleColor.Red : ui.RawUI.ForegroundColor;
// Split text to fit in space we have in the window
var charCount = 0;
var lines = @event.ResourceStatusReason.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
.GroupBy(w => (charCount += w.Length + 1) / (maxLineLength - 1)).Select(g => string.Join(" ", g))
.ToList();
ui.WriteLine(fg, bg, lines.First());
foreach (var line in lines.Skip(1))
{
ui.WriteLine(fg, bg, new string(' ', leftIndent) + line);
}
}
}
/// <summary> /// Logs a stack event. /// </summary> /// <param name="event">The event.</param> /// <remarks> /// Not implemented here as the client may want to do funky things like coloring the output /// </remarks> public abstract void LogStackEvent(StackEvent @event);
public bool EditStackEvent(StackEvent entity)
{
_unitOfWork.StackEventRepository.Edit(entity);
_unitOfWork.Save();
return true;
}
public bool AddStackEvent(StackEvent entity)
{
_unitOfWork.StackEventRepository.Add(entity);
_unitOfWork.Save();
return(true);
}
private static bool IsSuccessfulFinalStackEvent(StackEvent evt) => (evt.ResourceType == "AWS::CloudFormation::Stack") && ((evt.ResourceStatus == "CREATE_COMPLETE") || (evt.ResourceStatus == "UPDATE_COMPLETE"));
public bool EditStackEvent(StackEvent entity)
{
_unitOfWork.StackEventRepository.Edit(entity);
_unitOfWork.Save();
return(true);
}
