private void PrepareUploadActions()
{
OnPageUpdated();
SuppPackVdis.Clear();
uploadActions.Clear();
//Upload the patches to the masters if it is necessary
List <Host> masters = SelectedMasters;
foreach (Host selectedServer in masters)
{
AsyncAction action = null;
switch (SelectedUpdateType)
{
case UpdateType.Legacy:
if (CanUploadUpdateOnHost(SelectedNewPatchPath, selectedServer))
{
bool deleteFileOnCancel = AllDownloadedPatches.ContainsValue(SelectedNewPatchPath);
action = new UploadPatchAction(selectedServer.Connection, SelectedNewPatchPath, true, deleteFileOnCancel);
}
break;
case UpdateType.ISO:
if (CanUploadUpdateOnHost(SelectedNewPatchPath, selectedServer))
{
_poolUpdate = null;
_patch = null;
action = new UploadSupplementalPackAction(
selectedServer.Connection,
SelectedServers.Where(s => s.Connection == selectedServer.Connection).ToList(),
SelectedNewPatchPath,
true);
}
break;
}
if (action != null)
{
action.Changed += singleAction_Changed;
action.Completed += singleAction_Completed;
}
else
{
_poolUpdate = GetUpdateFromUpdatePath();
_patch = GetPatchFromPatchPath();
}
uploadActions.Add(selectedServer, action);
}
foreach (KeyValuePair <Host, AsyncAction> uploadAction in uploadActions)
{
flickerFreeListBox1.Items.Add(uploadAction);
}
flickerFreeListBox1.Refresh();
OnPageUpdated();
}
private void PrepareUploadActions()
{
OnPageUpdated();
SuppPackVdis.Clear();
uploadActions.Clear();
//Upload the patches to the masters if it is necessary
List <Host> masters = SelectedMasters;
foreach (Host selectedServer in masters)
{
AsyncAction action = null;
switch (SelectedUpdateType)
{
case UpdateType.NewRetail:
if (_patch == null || !PatchExistsOnPool(_patch, selectedServer))
{
action = new UploadPatchAction(selectedServer.Connection, SelectedNewPatch, true);
}
break;
case UpdateType.Existing:
if (!PatchExistsOnPool(_patch, selectedServer))
{
//Download patch from server Upload in the selected server
action = new CopyPatchFromHostToOther(SelectedExistingPatch.Connection, selectedServer,
SelectedExistingPatch);
}
break;
case UpdateType.NewSuppPack:
action = new UploadSupplementalPackAction(
selectedServer.Connection,
SelectedServers.Where(s => s.Connection == selectedServer.Connection).ToList(),
SelectedNewPatch,
true);
break;
}
if (action != null)
{
action.Changed += singleAction_Changed;
action.Completed += singleAction_Completed;
}
uploadActions.Add(selectedServer, action);
}
foreach (KeyValuePair <Host, AsyncAction> uploadAction in uploadActions)
{
flickerFreeListBox1.Items.Add(uploadAction);
}
flickerFreeListBox1.Refresh();
OnPageUpdated();
}
private void UploadLegacyPatch(IXenConnection conn, Session session, string path)
{
if (!skipDiskSpaceCheck)
{
CheckDiskSpace(conn, session, path);
}
var uploadPatchAction = new UploadPatchAction(conn, path, true, false);
uploadPatchAction.Changed += uploadAction_Changed;
uploadPatchAction.Completed += uploadAction_Completed;
inProgressAction = uploadPatchAction;
uploadPatchAction.RunExternal(session);
// this has to be run again to refresh poolPatches (to get the recently uploaded one as well)
var poolPatches = new List <Pool_patch>(conn.Cache.Pool_patches);
Pool_patch poolPatch;
if (xenServerPatch != null)
{
poolPatch = poolPatches.Find(p => string.Equals(p.uuid, xenServerPatch.Uuid, StringComparison.OrdinalIgnoreCase));
if (poolPatch == null)
{
log.ErrorFormat("Upload finished successfully, but Pool_patch object has not been found for patch (uuid={0}) on host (uuid={1}).",
xenServerPatch.Uuid, conn);
throw new Exception(Messages.ACTION_UPLOADPATCHTOMASTERPLANACTION_FAILED);
}
var newMapping = new PoolPatchMapping(xenServerPatch, poolPatch, Helpers.GetMaster(conn));
if (!mappings.Contains(newMapping))
{
mappings.Add(newMapping);
}
}
else
{
poolPatch = uploadPatchAction.Patch;
if (poolPatch == null)
{
log.ErrorFormat("Upload finished successfully, but Pool_patch object has not been found for patch {0} on host (uuid={1}).",
updateFilePath, conn);
throw new Exception(Messages.ACTION_UPLOADPATCHTOMASTERPLANACTION_FAILED);
}
var newMapping = new OtherLegacyMapping(updateFilePath, poolPatch, Helpers.GetMaster(conn));
if (!mappings.Contains(newMapping))
{
mappings.Add(newMapping);
}
}
}
private void UploadAndApplyPatch(Host host, Session session)
{
var patch = host.Connection.Cache.Find_By_Uuid <Pool_patch>(UUID);
if (patch == null)
{
var master = Helpers.GetMaster(host.Connection);
var filePath = Path.Combine(Program.AssemblyDir, String.Format("{0}.{1}", Filename, Branding.Update));
var action = new UploadPatchAction(master.Connection, filePath, false, false);
action.RunExternal(session);
patch = action.Patch;
}
new ApplyPatchAction(patch, host).RunExternal(session);
}
protected override void RunWithSession(ref Session session)
{
var path = AllDownloadedPatches[patch];
var poolPatches = new List <Pool_patch>(session.Connection.Cache.Pool_patches);
var conn = session.Connection;
var master = Helpers.GetMaster(conn);
var existingMapping = mappings.Find(m => m.MasterHost != null && master != null &&
m.MasterHost.uuid == master.uuid && m.Pool_patch != null && m.XenServerPatch.Equals(patch));
if (existingMapping == null ||
!poolPatches.Any(p => string.Equals(p.uuid, existingMapping.Pool_patch.uuid, StringComparison.OrdinalIgnoreCase)))
{
//free space check for upload:
try
{
var checkSpaceForUpload = new CheckDiskSpaceForPatchUploadAction(Helpers.GetMaster(conn), path, true);
inProgressAction = checkSpaceForUpload;
checkSpaceForUpload.RunExternal(session);
var uploadPatchAction = new UploadPatchAction(session.Connection, path, true, false);
inProgressAction = uploadPatchAction;
uploadPatchAction.RunExternal(session);
// this has to be run again to refresh poolPatches (to get the recently uploaded one as well)
poolPatches = new List <Pool_patch>(session.Connection.Cache.Pool_patches);
var poolPatch = poolPatches.Find(p => string.Equals(p.uuid, patch.Uuid, StringComparison.OrdinalIgnoreCase));
if (poolPatch == null)
{
log.ErrorFormat("Upload finished successfully, but Pool_patch object has not been found for patch (uuid={0}) on host (uuid={1}).", patch.Uuid, session.Connection);
throw new Exception(Messages.ACTION_UPLOADPATCHTOMASTERPLANACTION_FAILED);
}
var newMapping = new PoolPatchMapping(patch, poolPatch, Helpers.GetMaster(session.Connection));
if (!mappings.Contains(newMapping))
{
mappings.Add(newMapping);
}
}
catch (Exception ex)
{
Error = ex;
throw;
}
}
}
private void InstallOEMUpdates()
{
List <AsyncAction> actions = new List <AsyncAction>();
progressBar.Maximum = SelectedMasters.Count * 100;
//Upload the patches using patch-upload to the master
foreach (Host selectedServer in SelectedMasters)
{
AsyncAction action = new UploadPatchAction(selectedServer.Connection, SelectedNewPatch);
actions.Add(action);
}
oemWorker = new BackgroundWorker();
oemWorker.WorkerReportsProgress = true;
oemWorker.DoWork += new DoWorkEventHandler(oemWorker_DoWork);
oemWorker.ProgressChanged += new ProgressChangedEventHandler(oemWorker_ProgressChanged);
oemWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(oemWorker_RunWorkerCompleted);
oemWorker.RunWorkerAsync(actions);
}
protected override void RunWithSession(ref Session session)
{
var path = AllDownloadedPatches.ContainsKey(patch)
? AllDownloadedPatches[patch]
: patchFromDisk.Key == patch ? patchFromDisk.Value : null;
var poolPatches = new List <Pool_patch>(session.Connection.Cache.Pool_patches);
var poolUpdates = new List <Pool_update>(session.Connection.Cache.Pool_updates);
var conn = session.Connection;
var master = Helpers.GetMaster(conn);
var existingMapping = mappings.Find(m => m.MasterHost != null && master != null &&
m.MasterHost.uuid == master.uuid && (m.Pool_patch != null || m.Pool_update != null) && m.XenServerPatch.Equals(patch));
if (existingMapping == null ||
!(existingMapping.Pool_patch != null && poolPatches.Any(p => string.Equals(p.uuid, existingMapping.Pool_patch.uuid, StringComparison.OrdinalIgnoreCase))) &&
!(existingMapping.Pool_update != null && poolUpdates.Any(p => string.Equals(p.uuid, existingMapping.Pool_update.uuid, StringComparison.OrdinalIgnoreCase)))
)
{
AddProgressStep(string.Format(Messages.UPDATES_WIZARD_UPLOADING_UPDATE, patch.Name, conn.Name));
PoolPatchMapping newMapping;
if (Helpers.ElyOrGreater(master))
{
var uploadIsoAction = new UploadSupplementalPackAction(session.Connection, new List <Host>()
{
master
}, path, true);
uploadIsoAction.Changed += uploadAction_Changed;
uploadIsoAction.Completed += uploadAction_Completed;
inProgressAction = uploadIsoAction;
uploadIsoAction.RunExternal(session);
var poolupdate = uploadIsoAction.PoolUpdate;
if (poolupdate == null)
{
log.ErrorFormat("Upload finished successfully, but Pool_update object has not been found for update (uuid={0}) on host (uuid={1}).", patch.Uuid, session.Connection);
throw new Exception(Messages.ACTION_UPLOADPATCHTOMASTERPLANACTION_FAILED);
}
newMapping = new PoolPatchMapping(patch, poolupdate, Helpers.GetMaster(session.Connection));
}
else
{
var checkSpaceForUpload = new CheckDiskSpaceForPatchUploadAction(Helpers.GetMaster(conn), path, true);
inProgressAction = checkSpaceForUpload;
checkSpaceForUpload.RunExternal(session);
var uploadPatchAction = new UploadPatchAction(session.Connection, path, true, false);
uploadPatchAction.Changed += uploadAction_Changed;
uploadPatchAction.Completed += uploadAction_Completed;
inProgressAction = uploadPatchAction;
uploadPatchAction.RunExternal(session);
// this has to be run again to refresh poolPatches (to get the recently uploaded one as well)
poolPatches = new List <Pool_patch>(session.Connection.Cache.Pool_patches);
var poolPatch = poolPatches.Find(p => string.Equals(p.uuid, patch.Uuid, StringComparison.OrdinalIgnoreCase));
if (poolPatch == null)
{
log.ErrorFormat("Upload finished successfully, but Pool_patch object has not been found for patch (uuid={0}) on host (uuid={1}).", patch.Uuid, session.Connection);
throw new Exception(Messages.ACTION_UPLOADPATCHTOMASTERPLANACTION_FAILED);
}
newMapping = new PoolPatchMapping(patch, poolPatch, Helpers.GetMaster(session.Connection));
}
if (!mappings.Contains(newMapping))
{
mappings.Add(newMapping);
}
}
}
public override void PageLeave(PageLoadedDirection direction, ref bool cancel)
{
try
{
if (direction == PageLoadedDirection.Forward)
{
if (!AllSelectedHostsConnected())
{
foreach (PatchingHostsDataGridViewRow row in dataGridViewHosts.Rows)
{
row.UpdateIcon();
}
dataGridViewHosts.Invalidate();
cancel = true;
return;
}
//Upload the patches to the masters if it is necessary
List <Host> masters = SelectedMasters;
//Do RBAC check
foreach (Host master in masters)
{
if (Helpers.MidnightRideOrGreater(master.Connection) && !(Role.CanPerform(new RbacMethodList("pool_patch.apply"), master.Connection)))
{
string nameLabel = master.Name;
Pool pool = Helpers.GetPoolOfOne(master.Connection);
if (pool != null)
{
nameLabel = pool.Name;
}
new ThreeButtonDialog(new ThreeButtonDialog.Details(SystemIcons.Warning, string.Format(Messages.RBAC_UPDATES_WIZARD, master.Connection.Username, nameLabel), Messages.UPDATES_WIZARD)).ShowDialog(this);
cancel = true;
base.PageLeave(direction, ref cancel);
return;
}
}
switch (SelectedUpdateType)
{
case UpdateType.NewRetail:
foreach (Host selectedServer in masters)
{
Host master = Helpers.GetMaster(selectedServer.Connection);
UploadPatchAction action = new UploadPatchAction(master.Connection, SelectedNewPatch);
new ActionProgressDialog(action, ProgressBarStyle.Blocks).ShowDialog();
if (action.Succeeded)
{
_patch = action.PatchRefs[master];
NewUploadedPatches.Add(_patch);
}
else
{
cancel = true;
break;
}
}
break;
case UpdateType.Existing:
foreach (Host selectedServer in masters)
{
List <Pool_patch> poolPatches = new List <Pool_patch>(selectedServer.Connection.Cache.Pool_patches);
if (poolPatches.Find(patch => patch.uuid == SelectedExistingPatch.uuid) == null)
{
//Download patch from server Upload in the selected server
var actionCopyPatch = new CopyPatchFromHostToOther(SelectedExistingPatch.Connection, selectedServer, SelectedExistingPatch);
new ActionProgressDialog(actionCopyPatch, ProgressBarStyle.Blocks).ShowDialog();
if (!actionCopyPatch.Succeeded)
{
cancel = true;
break;
}
}
}
break;
}
}
base.PageLeave(direction, ref cancel);
}
catch (Exception e)
{
log.Debug(e);
throw;//better throw an exception rather than closing the wizard suddenly and silently
}
}
