protected void btnCreate_Click(object sender, EventArgs e)
{
IAction <PlanModel> actionobj = new PlanAction();
var model = new PlanModel();
model.PlanName = txtPlanName.Text;
model.Descr = txtDescr.Text;
if (txtDetuc.Text == string.Empty)
{
txtDetuc.Text = "";
}
int val;
var result = int.TryParse(txtDetuc.Text, out val);
if (!result)
{
return;
}
model.Deductable = Convert.ToDouble(txtDetuc.Text);
if (actionobj.Insert(model) == true)
{
lblResult.Text = "Plan Has Been Added Successfully! ";
}
else
{
lblResult.Text = "Plan Is Not Added ";
}
}
internal static PlanResult FromAction(PlanAction action)
{
return(new PlanResult()
{
Action = action
});
}
private void WorkerProgressChanged(object sender, ProgressChangedEventArgs e)
{
var actionsWorker = sender as BackgroundWorker;
Program.Invoke(Program.MainWindow, () =>
{
if (!actionsWorker.CancellationPending)
{
PlanAction action = (PlanAction)e.UserState;
if (action != null)
{
if (e.ProgressPercentage == 0)
{
inProgressActions.Add(action);
}
else
{
doneActions.Add(action);
inProgressActions.Remove(action);
progressBar.Value += (int)((float)e.ProgressPercentage / (float)backgroundWorkers.Count); //extend with error handling related numbers
}
}
UpdateStatusTextBox();
}
});
}
protected void OnReportException(Exception ex, PlanAction planAction, Host host)
{
if (ReportException != null)
{
ReportException(ex, planAction, host);
}
}
private void ReportException(Exception exception, PlanAction planAction, Host host)
{
Program.Invoke(this, () =>
{
if (host != null && !host.enabled && host.Connection != null && host.Connection.Session != null)
{
try
{
new EnableHostAction(host, false,
AddHostToPoolCommand.EnableNtolDialog).RunExternal(host.Connection.Session);
}
catch (Exception e)
{
log.Error("Exception while trying to re-enable the host", e);
}
}
});
Program.BeginInvoke(this, () =>
{
var row = planAction is UnwindProblemsAction
? FindRow(null)
: FindRow(host);
row.UpdateStatus(HostUpgradeState.Error, exception.Message);
UpgradeProgress(row.Index + 1);
});
}
public void RunPlanAction(PlanAction action, ref DoWorkEventArgs e, bool skip = false)
{
if (CancellationPending)
{
e.Cancel = true;
return;
}
// if this action is completed successfully, do not run it again
if (DoneActions.Contains(action) && action.Error == null)
{
return;
}
// if we retry a failed action, we need to firstly remove it from DoneActions and reset its Error
DoneActions.Remove(action);
action.Error = null;
if (skip)
{
//skip running it, but still need to report progress, mainly for the progress bar
PercentComplete += ProgressIncrement * 100;
ReportProgress((int)PercentComplete, action);
}
else
{
action.OnProgressChange += action_OnProgressChange;
action.Run();
action.OnProgressChange -= action_OnProgressChange;
}
}
private void actionsWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (!actionsWorker.CancellationPending)
{
PlanAction action = (PlanAction)e.UserState;
if (e.ProgressPercentage == 0)
{
textBoxLog.Text = completedActionsLog.ToString();
if (action.Visible)
{
textBoxLog.Text += action.ProgressDescription ?? action.ToString();
}
}
else
{
if (action.Visible)
{
completedActionsLog.Append(action.ProgressDescription ?? action.ToString());
completedActionsLog.AppendLine(Messages.DONE);
}
textBoxLog.Text = completedActionsLog.ToString();
progressBar.Value += e.ProgressPercentage;
}
}
}
protected void OnReportRunning(PlanAction planAction, Host host)
{
if (ReportRunning != null)
{
ReportRunning(planAction, host);
}
}
public void RunPlanAction(PlanAction action, ref DoWorkEventArgs e)
{
if (CancellationPending)
{
e.Cancel = true;
return;
}
// if this action is completed successfully, do not run it again
if (DoneActions.Contains(action) && action.Error == null)
{
return;
}
// if we retry a failed action, we need to firstly remove it from DoneActions and reset its Error
DoneActions.Remove(action);
action.Error = null;
if (action == FirstFailedSkippableAction)
{
FirstFailedSkippableAction = null;
action.Skipping = true;
}
action.OnProgressChange += action_OnProgressChange;
action.Run();
action.OnProgressChange -= action_OnProgressChange;
}
protected void btnUpdate_Click(object sender, EventArgs e)
{
var obj = new PlanModel();
obj.Descr = descr.Text;
obj.Deductable = Convert.ToDouble(dectVal.Text);
obj.PlanName = ddlPlan.SelectedItem.Text;
obj.PlanId = Convert.ToInt32(ViewState["Plan_id"]);
var result = new PlanAction().Update(obj);
if (result)
{
Label1.Text = "Plan Has Been Updated Successfully!";
}
else
{
Label1.Text = "Error to delete -> " + result;
}
BindData();
udp.Update();
}
private void action_statusUpdated(object sender, PlanActionStatusChangedEventArgs e)
{
Host senderHost = e.XenObject as Host;
if (senderHost == null)
{
return;
}
PlanAction plan = sender as PlanAction;
if (plan == null)
{
return;
}
List <DataGridViewRowUpgrade> rowsForHost = (from DataGridViewRowUpgrade row in dataGridView1.Rows
where row.RowIsForHost(senderHost)
select row).ToList();
foreach (DataGridViewRowUpgrade row in rowsForHost)
{
DataGridViewRowUpgrade closureRow = row;
Program.Invoke(this, () => closureRow.UpdateStatus(HostUpgradeState.Upgrading, plan.Status));
}
}
private static void InitializePlanAction(UpdateProgressBackgroundWorker bgw, PlanAction action)
{
if (action is IAvoidRestartHostsAware)
{
var avoidRestartAction = action as IAvoidRestartHostsAware;
avoidRestartAction.AvoidRestartHosts = bgw.AvoidRestartHosts;
}
}
public UpdateProgressBackgroundWorker(Pool pool, List <HostPlan> planActions, List <PlanAction> finalActions)
{
Pool = pool;
Name = pool.Name();
HostPlans = planActions ?? new List <HostPlan>();
FinalActions = finalActions ?? new List <PlanAction>();
CleanupActions = FinalActions.Where(a => a is RemoveUpdateFileFromMasterPlanAction).ToList();
FirstFailedSkippableAction = null;
}
public SemiAutomaticBackgroundThread(IEnumerable <Host> mastersToUpgrade, IDictionary <Host, List <PlanAction> > planActions, PlanAction revertAction)
{
_planActions = planActions;
_mastersToUpgrade = mastersToUpgrade;
_revertAction = revertAction;
_bw = new Thread(BworkerDoWork)
{
IsBackground = true
};
}
private void RunPlanAction(UpdateProgressBackgroundWorker bgw, PlanAction action)
{
action.OnProgressChange += action_OnProgressChange;
bgw.ReportProgress(0, action);
action.Run();
Thread.Sleep(1000);
action.OnProgressChange -= action_OnProgressChange;
bgw.ReportProgress(100 / bgw.ActionsCount, action);
}
private static void RunPlanAction(UpdateProgressBackgroundWorker bgw, PlanAction action)
{
InitializePlanAction(bgw, action);
bgw.ReportProgress(0, action);
action.Run();
Thread.Sleep(1000);
bgw.doneActions.Add(action);
bgw.ReportProgress((int)((1.0 / (double)bgw.ActionsCount) * 100), action);
}
public ComponentDeploymentVertex(string id, string name, SemVer version, PlanAction action, TimeSpan?deploymentDuration, bool exists = true)
{
Id = id;
Name = name;
Version = version;
DeploymentAction = action;
DeploymentDuration = deploymentDuration;
Exists = exists;
ComponentGroup = -1;
ProductGroup = -1;
ExecutionOrder = -1;
}
private void ReportRunning(PlanAction planAction, Host host)
{
Program.BeginInvoke(this, () =>
{
progressBar1.Value = progressBar1.Value < 100
? progressBar1.Value + 2
: progressBar1.Value;
var row = planAction is UnwindProblemsAction
? FindRow(null)
: FindRow(host);
if (row != null)
{
row.UpdateStatus(HostUpgradeState.Upgrading, planAction.TitlePlan);
}
});
}
private void actionsWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (!actionsWorker.CancellationPending)
{
PlanAction action = (PlanAction)e.UserState;
if (e.ProgressPercentage == 0)
{
textBoxLog.Text += action;
}
else
{
textBoxLog.Text += string.Format("{0}\r\n", Messages.DONE);
progressBar.Value += e.ProgressPercentage;
}
}
}
private void WorkerProgressChanged(object sender, ProgressChangedEventArgs e)
{
var bgw = sender as UpdateProgressBackgroundWorker;
if (bgw == null)
{
return;
}
if (!bgw.CancellationPending)
{
PlanAction action = (PlanAction)e.UserState;
if (action != null)
{
if (!action.IsComplete)
{
if (!bgw.InProgressActions.Contains(action))
{
bgw.InProgressActions.Add(action);
}
}
else
{
if (!bgw.DoneActions.Contains(action))
{
bgw.DoneActions.Add(action);
}
bgw.InProgressActions.Remove(action);
if (action.Error == null)
{
// remove the successful action from the cleanup actions (we are running the cleanup actions in case of failures or if the user cancelled the process, but we shouldn't re-run the actions that have already been run)
bgw.CleanupActions.Remove(action);
}
else
{
if (!failedWorkers.Contains(bgw))
{
failedWorkers.Add(bgw);
}
}
}
}
UpdateStatus();
}
}
private void planAction_StatusChanged(PlanAction plan, Host senderHost)
{
if (senderHost == null || plan == null)
{
return;
}
List <DataGridViewRowUpgrade> rowsForHost = (from DataGridViewRowUpgrade row in dataGridView1.Rows
where row.RowIsForHost(senderHost)
select row).ToList();
foreach (DataGridViewRowUpgrade row in rowsForHost)
{
DataGridViewRowUpgrade closureRow = row;
Program.Invoke(this, () => closureRow.UpdateStatus(HostUpgradeState.Upgrading, plan.Status));
}
}
private void actionsWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (!actionsWorker.CancellationPending)
{
PlanAction action = (PlanAction)e.UserState;
if (e.ProgressPercentage == 0)
{
textBoxLog.Text = completedActionsLog.ToString();
textBoxLog.Text += action.CurrentProgressStep;
}
else
{
completedActionsLog.AppendLine(action.CurrentProgressStep);
textBoxLog.Text = completedActionsLog.ToString();
int newVal = progressBar.Value + e.ProgressPercentage;
progressBar.Value = newVal > 100 ? 100 : newVal;
}
}
}
public static void UpdateDatacentreSuffix(Domain.Profile Profile, string ParametersString, string MaxRetries, string ContinueOnError, string Order)
{
#if DEBUG_ME
System.Diagnostics.Debug.WriteLine(
string.Format("UpdateDatacentreSuffix(ps:{0}, mr:{1}, coe:{2}, o:{3})", ParametersString, MaxRetries, ContinueOnError, Order),
DEBUG_CATEGORY);
#endif
int maxRetries = 0;
try
{
maxRetries = Convert.ToInt32(MaxRetries);
}
catch
{
return;
}
int order = 0;
try
{
order = Convert.ToInt32(Order);
}
catch
{
return;
}
List <PlanAction> planActions = Profile.ActiveProvisioningPlan.PlanActions;
PlanAction action = planActions.First((i) => i.ParametersString == ParametersString);
action.MaxRetries = maxRetries;
action.ContinueOnError = ContinueOnError;
action.Order = order;
planActions.Sort(PlanAction.CompareByOrder);
Profile.ActiveProvisioningPlan.PlanActions = planActions;
}
public static bool IsRestartRelatedPlanAction(this PlanAction a)
{
return
(a is EvacuateHostPlanAction || a is RebootHostPlanAction || a is BringBabiesBackAction);
}
//bool help_request;
void Awake()
{
navMeshAgent = this.GetComponent<NavMeshAgent> ();
endOfWorld = false;
foodAhead = false;
hasFood = false;
atBase = false;
enemyAhead = false;
agentAhead = false;
isFoodOnSight = false;
isEnemyOnSight = false;
isObstacleOnSight = false;
isSpecFoodOnSight = false;
currentPlan = null;
currentActionHasEnded = false;
//help_request = false;
currentAction = null;
//myColor = transform.GetChild (0).GetChild (0).gameObject.GetComponent<Renderer> ().material.color;
myDesires = new Dictionary<Desire,float> ();
InitializeDesires ();
commModule = GetComponent<ComunicationModule>();
Vector3 moveRand = MoveRandomly ();
myCurrentIntention = new IntentionDetails(Intention.SEARCH_FOOD, 1f, moveRand);
myBeliefs = new Dictionary<Vector3,string> (new Vector3Comparer());
}
private void WorkerDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var bgw = sender as UpdateProgressBackgroundWorker;
if (bgw == null)
{
return;
}
PlanAction action = null;
try
{
foreach (var hp in bgw.HostPlans)
{
var host = hp.Host;
// Step 1: InitialPlanActions (e.g. upgrade the host in the RPU case)
bgw.ProgressIncrement = bgw.InitialActionsIncrement(hp);
if (!SkipInitialPlanActions(host))
{
var initialActions = hp.InitialPlanActions;
foreach (var a in initialActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
}
DoAfterInitialPlanActions(bgw, host, bgw.HostPlans.Select(h => h.Host).ToList());
// Step 2: UpdatesPlanActions (priority update action)
bgw.ProgressIncrement = bgw.UpdatesActionsIncrement(hp);
var planActions = hp.UpdatesPlanActions;
foreach (var a in planActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
// Step 3: DelayedActions
bgw.ProgressIncrement = bgw.DelayedActionsIncrement(hp);
// running delayed actions, but skipping the ones that should be skipped
var delayedActions = hp.DelayedPlanActions;
var restartActions = delayedActions.Where(a => a is RestartHostPlanAction).ToList();
foreach (var a in restartActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
var otherActions = delayedActions.Where(a => !(a is RestartHostPlanAction)).ToList();
foreach (var a in otherActions)
{
action = a;
// any non-restart-alike delayed action needs to be run if:
// - this host is pre-Ely and there isn't any delayed restart plan action, or
// - this host is Ely or above and live patching must have succeeded or there isn't any delayed restart plan action
if (restartActions.Count <= 0 ||
(Helpers.ElyOrGreater(host) && host.Connection.TryResolveWithTimeout(new XenRef <Host>(host.opaque_ref)).updates_requiring_reboot.Count <= 0))
{
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
else
{
//skip running it, but still need to report progress, mainly for the progress bar
bgw.RunPlanAction(action, ref doWorkEventArgs, true);
}
}
}
// Step 4: FinalActions (eg. revert pre-checks)
bgw.ProgressIncrement = bgw.FinalActionsIncrement;
foreach (var a in bgw.FinalActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
}
catch (Exception e)
{
if (action.Error == null)
{
action.Error = new Exception(Messages.ERROR_UNKNOWN);
}
log.ErrorFormat("Failed to carry out plan. {0} {1}", action.CurrentProgressStep, e);
doWorkEventArgs.Result = new Exception(action.CurrentProgressStep, e);
}
}
/*
* Agent main loop
* BDI Agent
* The commitment is single-minded
*/
void Update()
{
// Decreases Agent life over time
// Value can be a public variable
DecreaseLife(0.5f);
//The Hybrid approach is a vertical one pass layered one, first see if
//the percepts in reactive approach and then pass to deliberative the control.
//The reactive layer is the one innerently connected to the sensors, although
//with the approach of using unity the deliberative one is also connected to the
//sensors. However, the lower one takes the decision (analgously with Subsumption)
if (UseReactiveLayer ()) {
currentPlan = null;
currentAction = null;
currentActionHasEnded = false;
if (EnemyAhead ()) {
HitEnemy ();
Queue<PlanAction> plan = new Queue<PlanAction> ();
plan.Enqueue(new PlanAction(Action.FIGHT_MONSTER));
currentPlan = plan;
//myCurrentIntention = new IntentionDetails(Intention.ATTACK_MONSTER_AT, 1.0f, enemy.transform.position);
} else if (FoodAhead ()) {
if(!HasFood ()) {
PickFood ();
Queue<PlanAction> plan = new Queue<PlanAction> ();
plan.Enqueue(new PlanAction(Action.MOVE_TO, myColonyPosition));
plan.Enqueue(new PlanAction(Action.DROP_FOOD, myColonyPosition));
currentPlan = plan;
}
}
} else {
if (currentPlan == null) {
Brf ();
Options ();
Filter ();
Planner planner = CreateNewPlan ();
currentPlan = planner.Plan ();
} else {
ChooseAction ();
bool impossible = Impossible ();
if (PlanIsEmpty () || Succeeded () || impossible) {
if (currentAction != null && impossible) {
bool removeBelief = (myBeliefs.ContainsKey (myCurrentIntention.Position ()) && myBeliefs [myCurrentIntention.Position ()] != "MyCol");
if (removeBelief) {
myBeliefs.Remove (myCurrentIntention.Position ());
}
}
currentPlan = null;
currentAction = null;
currentActionHasEnded = false;
return;
}
ExecuteAction ();
Brf ();
if (Reconsider ()) {
Options ();
Filter ();
}
}
}
}
private void WorkerDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var bgw = sender as UpdateProgressBackgroundWorker;
if (bgw == null)
{
return;
}
PlanAction action = null;
try
{
//running actions (non-delayed)
foreach (var a in bgw.PlanActions)
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
RunPlanAction(bgw, action);
}
// running delayed actions, but skipping the ones that should be skipped
// iterating through hosts, master first
var hostsOrdered = bgw.DelayedActionsByHost.Keys.ToList();
hostsOrdered.Sort(); //master first
foreach (var h in hostsOrdered)
{
var actions = bgw.DelayedActionsByHost[h];
var restartActions = actions.Where(a => a is RestartHostPlanAction).ToList();
//run all restart-alike plan actions
foreach (var a in restartActions)
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
RunPlanAction(bgw, action);
}
var otherActions = actions.Where(a => !(a is RestartHostPlanAction)).ToList();
//run the rest
foreach (var a in otherActions)
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
// any non-restart-alike delayed action needs to be run if:
// - this host is pre-Ely and there isn't any delayed restart plan action, or
// - this host is Ely or above and live patching must have succeeded or there isn't any delayed restart plan action
if (restartActions.Count <= 0 ||
(Helpers.ElyOrGreater(h) && h.Connection.TryResolveWithTimeout(new XenRef <Host>(h.opaque_ref)).updates_requiring_reboot.Count <= 0))
{
RunPlanAction(bgw, action);
}
else
{
//skip running it, but still need to report progress, mainly for the progress bar
action.Visible = false;
bgw.ReportProgress(100 / bgw.ActionsCount, action);
}
}
}
//running final actions (eg. revert pre-checks)
foreach (var a in bgw.FinalActions)
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
RunPlanAction(bgw, action);
}
}
catch (Exception e)
{
errorActions.Add(action);
inProgressActions.Remove(action);
log.Error("Failed to carry out plan.", e);
log.Debug(action.Title);
doWorkEventArgs.Result = new Exception(action.Title, e);
//this pool failed, we will stop here, but try to remove update files at least
try
{
var positionOfFailedAction = bgw.PlanActions.IndexOf(action);
// can try to clean up the host after a failed PlanAction from bgw.PlanActions only
if (positionOfFailedAction != -1 && !(action is DownloadPatchPlanAction || action is UploadPatchToMasterPlanAction))
{
int pos = positionOfFailedAction;
if (!(bgw.PlanActions[pos] is RemoveUpdateFileFromMasterPlanAction)) //can't do anything if the remove action has failed
{
while (++pos < bgw.PlanActions.Count)
{
if (bgw.PlanActions[pos] is RemoveUpdateFileFromMasterPlanAction) //find the next remove
{
bgw.PlanActions[pos].Run();
break;
}
}
}
}
}
catch (Exception ex2)
{
//already in an error case - best effort
log.Error("Failed to clean up (this was a best effort attempt)", ex2);
}
bgw.ReportProgress(0);
}
}
private void WorkerDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var bgw = sender as UpdateProgressBackgroundWorker;
PlanAction action = null;
try
{
//running actions (non-delayed)
foreach (var a in bgw.PlanActions)
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
RunPlanAction(bgw, action);
}
// running delayed actions, but skipping the ones that should be skipped
// iterating through hosts
foreach (var kvp in bgw.DelayedActionsByHost)
{
var h = kvp.Key;
var actions = kvp.Value;
//run all restart-alike plan actions
foreach (var a in actions.Where(a => a.IsRestartRelatedPlanAction()))
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
RunPlanAction(bgw, action);
}
//run the rest
foreach (var a in actions.Where(a => !a.IsRestartRelatedPlanAction()))
{
action = a;
if (bgw.CancellationPending)
{
doWorkEventArgs.Cancel = true;
return;
}
// any non-restart-alike delayed action needs to be run if:
// - this host is pre-Ely and there isn't any restart plan action among the delayed actions, or
// - this host is Ely or above and bgw.AvoidRestartHosts contains the host's uuid (shows that live patching must have succeeded) or there isn't any restart plan action among the delayed actions
if (!Helpers.ElyOrGreater(h) && !actions.Any(pa => pa.IsRestartRelatedPlanAction()) ||
Helpers.ElyOrGreater(h) && (bgw.AvoidRestartHosts != null && bgw.AvoidRestartHosts.Contains(h.uuid) || !actions.Any(pa => pa.IsRestartRelatedPlanAction())))
{
RunPlanAction(bgw, action);
}
else
{
//skip running it
action.Visible = false;
bgw.ReportProgress((int)((1.0 / (double)bgw.ActionsCount) * 100), action); //still need to report progress, mainly for the progress bar
}
}
}
}
catch (Exception e)
{
bgw.FailedWithExceptionAction = action;
errorActions.Add(action);
inProgressActions.Remove(action);
log.Error("Failed to carry out plan.", e);
log.Debug(action.Title);
doWorkEventArgs.Result = new Exception(action.Title, e);
//this pool failed, we will stop here, but try to remove update files at least
try
{
var positionOfFailedAction = bgw.PlanActions.IndexOf(action);
// can try to clean up the host after a failed PlanAction from bgw.PlanActions only
if (positionOfFailedAction != -1 && !(action is DownloadPatchPlanAction || action is UploadPatchToMasterPlanAction))
{
int pos = positionOfFailedAction;
if (!(bgw.PlanActions[pos] is RemoveUpdateFileFromMasterPlanAction)) //can't do anything if the remove action has failed
{
while (++pos < bgw.PlanActions.Count)
{
if (bgw.PlanActions[pos] is RemoveUpdateFileFromMasterPlanAction) //find the next remove
{
bgw.PlanActions[pos].Run();
break;
}
}
}
}
}
catch (Exception ex2)
{
//already in an error case - best effort
log.Error("Failed to clean up (this was a best effort attempt)", ex2);
}
bgw.ReportProgress(0);
}
}
/*
* Agent main loop
* BDI Agent
* The commitment is single-minded
*/
void Update()
{
// Decreases Agent life over time
// Value can be a public variable
DecreaseLife(0.5f);
//single commitment
foreach (var belief in myBeliefs.Keys) {
Debug.Log (belief + ":" + myBeliefs [belief]);
}
Debug.Log ("---------------");
if (currentPlan == null) {
Brf ();
Options ();
Filter ();
Planner planner = CreateNewPlan ();
currentPlan = planner.Plan ();
} else {
ChooseAction ();
/*Debug.Log (myCurrentIntention.Intention ());
if (currentAction != null) {
Debug.Log (currentAction.Action ());
Debug.Log (myCurrentIntention.Intention ());
}*/
bool impossible = Impossible ();
if(PlanIsEmpty () || Succeeded () || impossible) {
if(currentAction != null && impossible) {
bool removeBelief = (myBeliefs.ContainsKey(myCurrentIntention.Position ()) && myBeliefs [myCurrentIntention.Position ()] != "MyCol");
if (removeBelief) {
myBeliefs.Remove(myCurrentIntention.Position ());
}
}
currentPlan = null;
currentAction = null;
currentActionHasEnded = false;
return;
}
ExecuteAction ();
Brf ();
if (Reconsider ()) {
Options ();
Filter ();
}
}
}
private void action_OnProgressChange(PlanAction planAction)
{
PercentComplete += planAction.IsComplete ? ProgressIncrement * 100 : 0;
ReportProgress((int)PercentComplete, planAction);
}
private void WorkerDoWork(object sender, DoWorkEventArgs doWorkEventArgs)
{
var bgw = sender as UpdateProgressBackgroundWorker;
if (bgw == null)
{
return;
}
PlanAction action = null;
try
{
foreach (var hp in bgw.HostPlans)
{
var host = hp.Host;
// Step 1: InitialPlanActions (e.g. upgrade the host in the RPU case)
bgw.ProgressIncrement = bgw.InitialActionsIncrement(hp);
if (!SkipInitialPlanActions(host))
{
var initialActions = hp.InitialPlanActions;
foreach (var a in initialActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
}
DoAfterInitialPlanActions(bgw, host, bgw.HostPlans.Select(h => h.Host).ToList());
// Step 2: UpdatesPlanActions (priority update action)
bgw.ProgressIncrement = bgw.UpdatesActionsIncrement(hp);
var planActions = hp.UpdatesPlanActions;
foreach (var a in planActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
// Step 3: Rearrange DelayedActions
var suppPackPlanAction = (RpuUploadAndApplySuppPackPlanAction)planActions.FirstOrDefault(pa => pa is RpuUploadAndApplySuppPackPlanAction);
if (suppPackPlanAction != null)
{
foreach (var dpa in suppPackPlanAction.DelayedPlanActions)
{
if (!hp.DelayedPlanActions.Exists(a => a.GetType() == dpa.GetType()))
{
hp.DelayedPlanActions.Add(dpa);
}
}
}
var restartHostPlanAction = (RestartHostPlanAction)hp.DelayedPlanActions.FirstOrDefault(a => a is RestartHostPlanAction);
if (restartHostPlanAction != null)
{
if (restartHostPlanAction.SkipRestartHost(host))
{
log.Debug("Did not find patches requiring reboot (live patching succeeded)."
+ " Skipping scheduled restart.");
hp.DelayedPlanActions.RemoveAll(a => a is RestartHostPlanAction);
}
else
{
hp.DelayedPlanActions.RemoveAll(a => a is RestartAgentPlanAction);
}
}
// Step 4: DelayedActions
bgw.ProgressIncrement = bgw.DelayedActionsIncrement(hp);
// running delayed actions
var delayedActions = hp.DelayedPlanActions;
var restartActions = delayedActions.Where(a => a is RestartHostPlanAction).ToList();
foreach (var a in restartActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
var otherActions = delayedActions.Where(a => !(a is RestartHostPlanAction)).ToList();
foreach (var a in otherActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
}
// Step 5: FinalActions (eg. revert pre-checks)
bgw.ProgressIncrement = bgw.FinalActionsIncrement;
foreach (var a in bgw.FinalActions)
{
action = a;
bgw.RunPlanAction(action, ref doWorkEventArgs);
}
}
catch (Exception e)
{
if (action.Error == null)
{
action.Error = new Exception(Messages.ERROR_UNKNOWN);
}
log.ErrorFormat("Failed to carry out plan. {0} {1}", action.CurrentProgressStep, e);
doWorkEventArgs.Result = new Exception(action.CurrentProgressStep, e);
}
}
void ChooseAction()
{
if (currentAction == null && currentPlan.Count > 0) {
currentAction = currentPlan.Dequeue ();
} else {
if (CurrentActionHasEnded () && currentPlan.Count == 0) {
//currentAction = null;
return;
} else if(CurrentActionHasEnded () && currentPlan.Count > 0) {
currentAction = currentPlan.Dequeue ();
currentActionHasEnded = false;
}
}
}
private void BworkerDoWork()
{
Host currentHost = null;
try
{
List <Host> hosts = GetAllHosts(_mastersToUpgrade);
bool currentMasterFailed = false;
string poolHigherProductVersion = string.Empty;
for (int i = 0; i < hosts.Count; i++)
{
if (_cancel)
{
return;
}
//Skip hosts already upgraded
var host = currentHost = hosts[i];
if (host.IsMaster())
{
poolHigherProductVersion = host.LongProductVersion();
if (CheckMasterIsUpgraded(hosts, i))
{
log.Debug(string.Format("Skipping master '{0}' because it is upgraded", host.Name()));
continue;
}
}
else if (host.LongProductVersion() == poolHigherProductVersion)
{
log.Debug(string.Format("Skipping host '{0}' because it is upgraded", host.Name()));
continue;
}
log.Debug(string.Format("Starting to upgrade host '{0}'", host.Name()));
//Add subtasks for the current host
bool allActionsDone = true;
foreach (var planAction in _planActions[host])
{
//if the wizard has been cancelled, skip this action, unless it is a BringBabiesBackAction
if (_cancel && !(planAction is BringBabiesBackAction))
{
continue;
}
OnReportRunning(planAction, host);
try
{
if (planAction is UpgradeManualHostPlanAction)
{
var upgradeAction = (UpgradeManualHostPlanAction)planAction;
if (ManageSemiAutomaticPlanAction != null)
{
ManageSemiAutomaticPlanAction(upgradeAction);
}
if (host.IsMaster())
{
poolHigherProductVersion = upgradeAction.Host.LongProductVersion();
}
}
else
{
planAction.Run();
}
}
catch (Exception excep)
{
log.Error(string.Format("Exception in host '{0}' while it was upgraded", host.Name()), excep);
PlanAction action1 = planAction;
OnReportException(excep, action1, host);
if (host.IsMaster())
{
currentMasterFailed = true;
}
allActionsDone = false;
break;
}
}
if (allActionsDone)
{
OnReportHostDone(host);
}
//Skip slaves if master failed
if (currentMasterFailed)
{
i = SkipSlaves(hosts, i);
}
}
}
catch (Exception excep)
{
log.Error("Upgrade thread error: ", excep);
}
finally
{
//Revert resolved prechecks
try
{
log.Debug("Reverting prechecks");
OnReportRunning(_revertAction, currentHost);
_revertAction.Run();
OnReportRevertDone();
}
catch (Exception excep)
{
log.Error("Exception reverting prechecks", excep);
OnReportException(excep, _revertAction, currentHost);
}
OnCompleted();
}
}
