public void SendSuccess(string extraData1, string extraData2, bool ed2IsRtf) { UpdateHelperData updateHelperData = new UpdateHelperData(Response.Succeeded, UpdateStep.CheckForUpdate, extraData1, extraData2); updateHelperData.ExtraDataIsRTF[1] = ed2IsRtf; pipeServer.SendMessage(updateHelperData.GetByteArray()); }
public void StartPipeServer(Control OwnerHandle) { owner = OwnerHandle; pipeServer = new PipeServer(); pipeServer.MessageReceived += pipeServer_MessageReceived; pipeServer.ClientDisconnected += pipeServer_ClientDisconnected; pipeServer.Start(UpdateHelperData.PipenameFromFilename(VersionTools.SelfLocation)); }
public void SendNewWyUpdate(string pipeName, int processID) { UpdateHelperData updateHelperData = new UpdateHelperData(UpdateAction.NewWyUpdateProcess); updateHelperData.ProcessID = processID; UpdateHelperData updateHelperData2 = updateHelperData; updateHelperData2.ExtraData.Add(pipeName); updateHelperData2.ExtraDataIsRTF.Add(item: false); pipeServer.SendMessage(updateHelperData2.GetByteArray()); }
void ServerReceivedData(byte[] message) { UpdateHelperData data = UpdateHelperData.FromByteArray(message); if (data.Action == UpdateAction.GetwyUpdateProcessID) { // send ProcessID pipeServer.SendMessage(new UpdateHelperData(UpdateAction.GetwyUpdateProcessID) { ProcessID = Process.GetCurrentProcess().Id }.GetByteArray()); return; } UpdateStep step = data.UpdateStep; if (step == UpdateStep.RestartInfo) { RestartInfoSent = true; // load the pre-install info if (data.ExtraData.Count > 0) { FileOrServiceToExecuteAfterUpdate = data.ExtraData[0]; IsAService = data.ExtraDataIsRTF[0]; } // load the AutoUpdateID (for writing to file whether the update failed or Succeeded) if (data.ExtraData.Count > 1) { AutoUpdateID = data.ExtraData[1]; } if (data.ExtraData.Count > 2) { ExecutionArguments = data.ExtraData[2]; } } else if (step == UpdateStep.Install) { // if we're already installing, don't bother to process the message again if (Installing) { return; } Installing = true; } if (RequestReceived != null) { RequestReceived(this, data.Action, step); } }
public void SendNewWyUpdate(string pipeName, int processID) { UpdateHelperData uh = new UpdateHelperData(UpdateAction.NewWyUpdateProcess) { ProcessID = processID }; uh.ExtraData.Add(pipeName); uh.ExtraDataIsRTF.Add(false); pipeServer.SendMessage(uh.GetByteArray()); }
public static UpdateHelperData FromByteArray(byte[] data) { UpdateHelperData updateHelperData = new UpdateHelperData(); using (MemoryStream memoryStream = new MemoryStream(data)) { byte b = (byte)memoryStream.ReadByte(); while (!ReadFiles.ReachedEndByte(memoryStream, b, byte.MaxValue)) { switch (b) { case 1: updateHelperData.Action = (UpdateAction)ReadFiles.ReadInt(memoryStream); break; case 2: updateHelperData.UpdateStep = (UpdateStep)ReadFiles.ReadInt(memoryStream); break; case 128: updateHelperData.ExtraDataIsRTF.Add(item: true); break; case 3: updateHelperData.ExtraData.Add(ReadFiles.ReadString(memoryStream)); if (updateHelperData.ExtraDataIsRTF.Count != updateHelperData.ExtraData.Count) { updateHelperData.ExtraDataIsRTF.Add(item: false); } break; case 4: updateHelperData.ProcessID = ReadFiles.ReadInt(memoryStream); break; case 5: updateHelperData.Progress = ReadFiles.ReadInt(memoryStream); break; case 6: updateHelperData.ResponseType = (Response)ReadFiles.ReadInt(memoryStream); break; default: ReadFiles.SkipField(memoryStream, b); break; } b = (byte)memoryStream.ReadByte(); } return(updateHelperData); } }
public void StartPipeServer(Control OwnerHandle) { //Note: this function can only be called once. Explosions otherwise. owner = OwnerHandle; pipeServer = new PipeServer(); pipeServer.MessageReceived += pipeServer_MessageReceived; pipeServer.ClientDisconnected += pipeServer_ClientDisconnected; pipeServer.Start(UpdateHelperData.PipenameFromFilename(VersionTools.SelfLocation)); }
private void ServerReceivedData(byte[] message) { UpdateHelperData updateHelperData = UpdateHelperData.FromByteArray(message); if (updateHelperData.Action == UpdateAction.GetwyUpdateProcessID) { pipeServer.SendMessage(new UpdateHelperData(UpdateAction.GetwyUpdateProcessID) { ProcessID = Process.GetCurrentProcess().Id }.GetByteArray()); return; } UpdateStep updateStep = updateHelperData.UpdateStep; switch (updateStep) { case UpdateStep.RestartInfo: RestartInfoSent = true; if (updateHelperData.ExtraData.Count > 0) { FileOrServiceToExecuteAfterUpdate = updateHelperData.ExtraData[0]; IsAService = updateHelperData.ExtraDataIsRTF[0]; } if (updateHelperData.ExtraData.Count > 1) { AutoUpdateID = updateHelperData.ExtraData[1]; } if (updateHelperData.ExtraData.Count > 2) { ExecutionArguments = updateHelperData.ExtraData[2]; } break; case UpdateStep.Install: if (Installing) { return; } Installing = true; break; } if (this.RequestReceived != null) { this.RequestReceived(this, updateHelperData.Action, updateStep); } }
public static UpdateHelperData FromByteArray(byte[] data) { UpdateHelperData uhData = new UpdateHelperData(); using (MemoryStream ms = new MemoryStream(data)) { byte bType = (byte)ms.ReadByte(); //read until the end byte is detected while (!ReadFiles.ReachedEndByte(ms, bType, 0xFF)) { switch (bType) { case 0x01: uhData.Action = (UpdateAction)ReadFiles.ReadInt(ms); break; case 0x02: // update step we're on uhData.UpdateStep = (UpdateStep)ReadFiles.ReadInt(ms); break; case 0x80: uhData.ExtraDataIsRTF.Add(true); break; case 0x03: // extra data uhData.ExtraData.Add(ReadFiles.ReadString(ms)); // keep the 'ExtraDataIsRTF' same length as ExtraData if (uhData.ExtraDataIsRTF.Count != uhData.ExtraData.Count) { uhData.ExtraDataIsRTF.Add(false); } break; case 0x04: uhData.ProcessID = ReadFiles.ReadInt(ms); break; case 0x05: uhData.Progress = ReadFiles.ReadInt(ms); break; case 0x06: uhData.ResponseType = (Response)ReadFiles.ReadInt(ms); break; // 0x07, 0x08, and 0x09 used to be links data - obsolete default: ReadFiles.SkipField(ms, bType); break; } bType = (byte)ms.ReadByte(); } } return(uhData); }
void updateHelper_ProgressChanged(object sender, UpdateHelperData e) { switch (e.ResponseType) { case Response.Failed: // show the error icon & menu // and set last successful step UpdateStepFailed(UpdateStepToUpdateStepOn(e.UpdateStep), new FailArgs { ErrorTitle = e.ExtraData[0], ErrorMessage = e.ExtraData[1] }); break; case Response.Succeeded: switch (e.UpdateStep) { case UpdateStep.CheckForUpdate: AutoUpdaterInfo.LastCheckedForUpdate = DateTime.Now; // there's an update available if (e.ExtraData.Count != 0) { version = e.ExtraData[0]; // if there are changes, save them if (e.ExtraData.Count > 1) { changes = e.ExtraData[1]; changesAreRTF = e.ExtraDataIsRTF[1]; } // save the changes to the AutoUpdateInfo file AutoUpdaterInfo.UpdateVersion = version; AutoUpdaterInfo.ChangesInLatestVersion = changes; AutoUpdaterInfo.ChangesIsRTF = changesAreRTF; } else { // Clear saved version details for cases where we're // continuing an update (the version details filled // in from the AutoUpdaterInfo file) however, // wyUpdate reports your app has since been updated. // Thus we need to clear the saved info. version = null; changes = null; changesAreRTF = false; AutoUpdaterInfo.ClearSuccessError(); } break; case UpdateStep.DownloadUpdate: UpdateStepOn = UpdateStepOn.UpdateDownloaded; break; case UpdateStep.RestartInfo: // close this application so it can be updated if (UseCloseAppNow) { // show client & send the "begin update" message updateHelper.InstallNow(); // close this application so it can be updated if (CloseAppNow != null) CloseAppNow(this, EventArgs.Empty); } else { // show client & send the "begin update" message updateHelper.InstallNow(); // Use this since we are a console app (or Windows service) Environment.Exit(0); } return; } StartNextStep(e.UpdateStep); break; case Response.Progress: // call the progress changed event if (ProgressChanged != null) ProgressChanged(this, e.Progress); break; } }
void updateHelper_PipeServerDisconnected(object sender, UpdateHelperData e) { // wyUpdate should only ever exit after success or failure // otherwise it is a premature exit (and needs to be treated as an error) if (UpdateStepOn == UpdateStepOn.Checking || UpdateStepOn == UpdateStepOn.DownloadingUpdate || UpdateStepOn == UpdateStepOn.ExtractingUpdate) { // wyUpdate premature exit error UpdateStepFailed(UpdateStepOn, new FailArgs { wyUpdatePrematureExit = true, ErrorTitle = e.ExtraData[0], ErrorMessage = e.ExtraData[1] }); } }
public static UpdateHelperData FromByteArray(byte[] data) { UpdateHelperData uhData = new UpdateHelperData(); using (MemoryStream ms = new MemoryStream(data)) { byte bType = (byte)ms.ReadByte(); //read until the end byte is detected while (!ReadFiles.ReachedEndByte(ms, bType, 0xFF)) { switch (bType) { case 0x01: uhData.Action = (UpdateAction)ReadFiles.ReadInt(ms); break; case 0x02: // update step we're on uhData.UpdateStep = (UpdateStep)ReadFiles.ReadInt(ms); break; case 0x80: uhData.ExtraDataIsRTF.Add(true); break; case 0x03: // extra data uhData.ExtraData.Add(ReadFiles.ReadString(ms)); // keep the 'ExtraDataIsRTF' same length as ExtraData if (uhData.ExtraDataIsRTF.Count != uhData.ExtraData.Count) uhData.ExtraDataIsRTF.Add(false); break; case 0x04: uhData.ProcessID = ReadFiles.ReadInt(ms); break; case 0x05: uhData.Progress = ReadFiles.ReadInt(ms); break; case 0x06: uhData.ResponseType = (Response)ReadFiles.ReadInt(ms); break; // 0x07, 0x08, and 0x09 used to be links data - obsolete default: ReadFiles.SkipField(ms, bType); break; } bType = (byte)ms.ReadByte(); } } return uhData; }
void SendAsync(UpdateHelperData uhd) { // if currently working, add the new message to the stack if (bw != null) { sendBuffer.Push(uhd); } else { RecreateBackgroundWorker(); // process immediately UpdateStep = uhd.UpdateStep == UpdateStep.ForceRecheckForUpdate ? UpdateStep.CheckForUpdate : uhd.UpdateStep; // begin sending to the client bw.RunWorkerAsync(uhd); } }
void ProcessReceivedMessage(UpdateHelperData data) { if (data.Action == UpdateAction.GetwyUpdateProcessID) { ClientProcess = Process.GetProcessById(data.ProcessID); return; } if (data.Action == UpdateAction.NewWyUpdateProcess) { // disconnect from the existing pipeclient pipeClient.Disconnect(); CreateNewPipeClient(); try { ClientProcess = Process.GetProcessById(data.ProcessID); } catch (Exception) { // inform the AutomaticUpdater that wyUpdate is no longer running if (PipeServerDisconnected != null) PipeServerDisconnected(this, new UpdateHelperData(Response.Failed, UpdateStep, AUTranslation.C_PrematureExitTitle, "Failed to connect to the new version of wyUpdate.exe")); } TryToConnectToPipe(data.ExtraData[0]); // if the process is running - try to kill it if (!pipeClient.Connected) { // inform the AutomaticUpdater that wyUpdate is no longer running if (PipeServerDisconnected != null) PipeServerDisconnected(this, new UpdateHelperData(Response.Failed, UpdateStep, AUTranslation.C_PrematureExitTitle, "Failed to connect to the new version of wyUpdate.exe")); } // begin where we left off // if update step == RestartInfo, we need to send the restart info as well if (ResendRestartInfo != null && UpdateStep == UpdateStep.RestartInfo) ResendRestartInfo(this, EventArgs.Empty); else SendAsync(new UpdateHelperData(UpdateStep)); return; } if (data.UpdateStep != UpdateStep) { // this occurs when wyUpdate is on a separate step from the AutoUpdater UpdateStep prev = UpdateStep; // set new update step UpdateStep = data.UpdateStep; // tell AutoUpdater that the message we sent didn't respond in kind // e.g. we sent RestartInfo, and wyUpdate responded with DownloadUpdate // meaning we can't update yet, we're just begginning downloading the update if (UpdateStepMismatch != null) UpdateStepMismatch(this, data.ResponseType, prev); } // wyUpdate will give us its main Window Handle so we can pass focus to it if (data.Action == UpdateAction.UpdateStep && data.UpdateStep == UpdateStep.RestartInfo) ClientWindowHandleToShow = data.ProcessID; if (data.ResponseType != Response.Nothing && ProgressChanged != null) ProgressChanged(this, data); }
public void RestartInfo(string fileToExecute, string autoUpdateID, string argumentsForFiles, bool isAService) { UpdateHelperData uhd = new UpdateHelperData(UpdateStep.RestartInfo); uhd.ExtraData.Add(fileToExecute); uhd.ExtraDataIsRTF.Add(isAService); if (!string.IsNullOrEmpty(autoUpdateID)) { uhd.ExtraData.Add(autoUpdateID); uhd.ExtraDataIsRTF.Add(false); if (!string.IsNullOrEmpty(argumentsForFiles)) { uhd.ExtraData.Add(argumentsForFiles); uhd.ExtraDataIsRTF.Add(false); } } SendAsync(uhd); }
void updateHelper_PipeServerDisconnected(object sender, UpdateHelperData e) { // wyUpdate should only ever exit after success or failure // otherwise it is a premature exit (and needs to be treated as an error) if (UpdateStepOn == UpdateStepOn.Checking || UpdateStepOn == UpdateStepOn.DownloadingUpdate || UpdateStepOn == UpdateStepOn.ExtractingUpdate || e.UpdateStep == UpdateStep.RestartInfo) { if (e.UpdateStep == UpdateStep.RestartInfo) { if (ClosingAborted != null) ClosingAborted(this, EventArgs.Empty); ClosingForInstall = false; } // wyUpdate premature exit error UpdateStepFailed(UpdateStepOn, new FailArgs { wyUpdatePrematureExit = true, ErrorTitle = e.ExtraData[0], ErrorMessage = e.ExtraData[1] }); } }
public void SendSuccess(string extraData1, string extraData2, bool ed2IsRtf) { UpdateHelperData uh = new UpdateHelperData(Response.Succeeded, UpdateStep.CheckForUpdate, extraData1, extraData2); uh.ExtraDataIsRTF[1] = ed2IsRtf; pipeServer.SendMessage(uh.GetByteArray()); }
public void SendNewWyUpdate(string pipeName, int processID) { UpdateHelperData uh = new UpdateHelperData(UpdateAction.NewWyUpdateProcess) { ProcessID = processID }; uh.ExtraData.Add(pipeName); uh.ExtraDataIsRTF.Add(false); pipeServer.SendMessage(uh.GetByteArray()); }