private UndeploymentResult UndeployRemoveInternal( DeploymentInformation info, UndeploymentOptions undeploymentOptions) { var reverted = new DeploymentInformationItem[info.Items.Length]; for (int i = 0; i < info.Items.Length; i++) { reverted[i] = info.Items[info.Items.Length - 1 - i]; } var revertedStatements = new List <DeploymentInformationItem>(); if (undeploymentOptions.IsDestroyStatements) { var referencedTypes = new HashSet <string>(); Exception firstExceptionEncountered = null; foreach (DeploymentInformationItem item in reverted) { EPStatement statement = _epService.GetStatement(item.StatementName); if (statement == null) { Log.Debug("Deployment id '" + info.DeploymentId + "' statement name '" + item + "' not found"); continue; } referencedTypes.AddAll(_statementEventTypeRef.GetTypesForStatementName(statement.Name)); if (statement.IsDisposed) { continue; } try { statement.Dispose(); } catch (Exception ex) { Log.Warn("Unexpected exception destroying statement: " + ex.Message, ex); if (firstExceptionEncountered == null) { firstExceptionEncountered = ex; } } revertedStatements.Add(item); } EPLModuleUtil.UndeployTypes( referencedTypes, _statementEventTypeRef, _eventAdapterService, _filterService); revertedStatements.Reverse(); if (firstExceptionEncountered != null && _undeployRethrowPolicy == ConfigurationEngineDefaults.UndeployRethrowPolicy.RETHROW_FIRST) { throw firstExceptionEncountered; } } return(new UndeploymentResult(info.DeploymentId, revertedStatements)); }
private async Task <bool> ProcessDeployment(DeploymentInformation deployment) { try { var artifactLocation = Path.Join(deployment.DeploymentLocation, "artifacts"); var artifactFilePath = Path.Join(artifactLocation, $"{deployment.PackageName}-{deployment.Version}.zip"); // Update database status to unzipping, Unzip artifacts var updateStatusResult = await UpdateDeploymentStatus(deployment.Id, DeploymentStatus.Unzipping); if (!updateStatusResult.WasSuccessful) /** Log something... once we have a logger */ } { await UnzipArtifacts(artifactFilePath, deployment.DeploymentLocation); // Update deployment status to running script, Run the provided setup script updateStatusResult = await UpdateDeploymentStatus(deployment.Id, DeploymentStatus.RunningScript); if (!updateStatusResult.WasSuccessful) /** Log something... once we have a logger */ { } await RunScript(artifactFilePath); // Dump script logs to the webservice // Update the status to failed/succeeded. updateStatusResult = await UpdateDeploymentStatus(deployment.Id, DeploymentStatus.Done); if (!updateStatusResult.WasSuccessful) /** Log something... once we have a logger */ } { return(true); }
public void AddUpdateDeployment(DeploymentInformation descriptor) { using (_lock.Acquire()) { _deployments.Put(descriptor.DeploymentId, descriptor); } }
private void AddInternal(Module module, String deploymentId) { var now = DateTimeOffsetHelper.Now(_timeZone); var desc = new DeploymentInformation( deploymentId, module, now, now, new DeploymentInformationItem[0], DeploymentState.UNDEPLOYED); _deploymentStateService.AddUpdateDeployment(desc); }
private void AddInternal(Module module, string deploymentId) { var desc = new DeploymentInformation( deploymentId, module, DateTimeEx.GetInstance(_timeZone), DateTimeEx.GetInstance(_timeZone), new DeploymentInformationItem[0], DeploymentState.UNDEPLOYED); _deploymentStateService.AddUpdateDeployment(desc); }
/// <summary> /// deployes the given deployment information /// </summary> /// <param name="deployInfo">object containing all the needed deployment information</param> public void Deploy(DeploymentInformation deployInfo) { Show(); _deployInfo = deployInfo; Text = string.Format("Deploying {0} {1}", _deployInfo.NuSpecPackage.Metadata.Id, _deployInfo.NuSpecPackage.Metadata.Version); deployInfo.NuGetServer.LastAttemptedDeploy = DateTime.Now; OptionsManager.Instance.SaveSettings(); }
/// <summary> /// builds the nuPkg file /// </summary> /// <returns>true if the nuPkg file was build, false otherwise</returns> private void BuildNuGetPackage(DeploymentInformation deployInfo, ref string nuPkgFilePath) { LoggingManager.Instance.Logger.Debug("creating nupkg file"); //-----create the .nuPkg file in the folder //-----first delete any "current" versions of the .nuPkg file by wildcard ( because if revision == "0" that //----- 4:th position ".0" in the file name has probably been omitted by the "NuGet pack" command ) string nuPkgWildcard = string.Format("{0}.*.nupkg", deployInfo.NuSpecPackage.Metadata.Id); try { foreach (var f in Directory.GetFiles(deployInfo.Build.BuildPath, nuPkgWildcard)) { File.Delete(f); } } catch (Exception ex) { LoggingManager.Instance.Logger.Warn($@"Error deleting previous ""{nuPkgWildcard}"" files in ""{deployInfo.Build.BuildPath}""", ex); } var symbolsParam = (deployInfo.Build.DebugInfo == Resources.DebugInfoPdbOnly || deployInfo.Build.DebugInfo == Resources.DebugInfoFull) ? "-Symbols" : ""; var commands = new string[] { $@"cd /D ""{deployInfo.Build.BuildPath}""", $@"""{OptionsManager.Instance.Configuration.GeneralOptions.NuGetOptions.ExePath}"" pack ""{deployInfo.NuSpecFileFullName}"" {symbolsParam}" }; nuPkgFilePath = Execute(commands, out string error, expectedOutputFilePattern: nuPkgWildcard, path: deployInfo.Build.BuildPath); if (string.IsNullOrEmpty(nuPkgFilePath)) { throw new BuildNuGetPackageFailedExceptions(string.Format("Could not create nuPkg file: {0}.{1}.nupkg", deployInfo.NuSpecPackage.Metadata.Id, deployInfo.NuSpecPackage.Metadata.Version)); } //-----delete the nuSpec file is possible if (!deployInfo.ProjectOptions.NuGetOptions.NuSpecOptions.Metadata.UseAny && !deployInfo.ProjectOptions.NuGetOptions.NuSpecOptions.Files.UseFromSettings) { try { File.Delete(deployInfo.NuSpecFileFullName); } catch (Exception ex) { LoggingManager.Instance.Logger.Warn(ex); } } LoggingManager.Instance.Logger.Debug("creating nupkg file finished"); }
public void Remove(string deploymentId) { using (_iLock.Acquire()) { DeploymentInformation info = _deploymentStateService.GetDeployment(deploymentId); if (info == null) { throw new DeploymentNotFoundException("Deployment by id '" + deploymentId + "' could not be found"); } if (info.State == DeploymentState.DEPLOYED) { throw new DeploymentStateException( "Deployment by id '" + deploymentId + "' is in deployed state, please undeploy first"); } _deploymentStateService.Remove(deploymentId); } }
public DeploymentResult Deploy(string deploymentId, DeploymentOptions options) { using (_iLock.Acquire()) { DeploymentInformation info = _deploymentStateService.GetDeployment(deploymentId); if (info == null) { throw new DeploymentNotFoundException("Deployment by id '" + deploymentId + "' could not be found"); } if (info.State == DeploymentState.DEPLOYED) { throw new DeploymentStateException( "Module by deployment id '" + deploymentId + "' is already in deployed state"); } GetDeploymentOrder(Collections.SingletonList(info.Module), null); return(DeployInternal(info.Module, options, deploymentId, info.AddedDate)); } }
private UndeploymentResult UndeployInternal(String deploymentId, UndeploymentOptions undeploymentOptions) { var info = _deploymentStateService.GetDeployment(deploymentId); if (info == null) { throw new DeploymentNotFoundException("Deployment by id '" + deploymentId + "' could not be found"); } if (info.State == DeploymentState.UNDEPLOYED) { throw new DeploymentStateException("Deployment by id '" + deploymentId + "' is already in undeployed state"); } var result = UndeployRemoveInternal(info, undeploymentOptions); var updated = new DeploymentInformation(deploymentId, info.Module, info.AddedDate, DateTimeOffsetHelper.Now(_timeZone), new DeploymentInformationItem[0], DeploymentState.UNDEPLOYED); _deploymentStateService.AddUpdateDeployment(updated); return(result); }
/// <summary> /// builds the nuPkg file /// </summary> /// <returns>true if the nuPkg file was build, false otherwise</returns> private void BuildNuGetPackage(DeploymentInformation deployInfo, ref string nuPkgFilePath) { LoggingManager.Instance.Logger.Debug("creating nupkg file"); //-----create the .nuPkg file in the folder string result; string error; nuPkgFilePath = Path.Combine(deployInfo.Build.BuildPath, string.Format("{0}.{1}.nupkg", deployInfo.NuSpecPackage.Metadata.Id, deployInfo.NuSpecPackage.Metadata.Version)); string commandOne = string.Format(@"cd /D ""{0}"" ", deployInfo.Build.BuildPath); string commandTwo = string.Format(@" ""{0}"" pack ""{1}"" ", OptionsManager.Instance.Configuration.GeneralOptions.NuGetOptions.ExePath, deployInfo.NuSpecFileFullName); LoggingManager.Instance.Logger.Debug(string.Format("executing command [{0}] and [{1}]", commandOne, commandTwo)); CommandUtil.ExecuteCommands(new string[] { commandOne, commandTwo }, new string[] { "/C" }, out result, out error); //-----make sure the nuPkg file was build if (!string.IsNullOrEmpty(error) || !File.Exists(nuPkgFilePath)) { throw new BuildNuGetPackageFailedExceptions(!string.IsNullOrEmpty(error) ? string.Format("An Error occured while creating the nuPkg file: {0}", error) : string.Format("Could not create nuPkg file: {0}", nuPkgFilePath)); } //-----delete the nuSpec file is possible if (!deployInfo.ProjectOptions.NuGetOptions.NuSpecOptions.Metadata.UseAny && !deployInfo.ProjectOptions.NuGetOptions.NuSpecOptions.Files.UseFromSettings) { try { File.Delete(deployInfo.NuSpecFileFullName); } catch (Exception ex) { LoggingManager.Instance.Logger.Warn(ex); } } LoggingManager.Instance.Logger.Debug("creating nupkg file finished"); }
/// <summary> /// called when the worker is supposed to start /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected override void DoWork(object sender, DoWorkEventArgs e) { LoggingManager.Instance.Logger.Debug("saving changed started"); Project activeProject = (Project)((object[])e.Argument)[0]; DeploymentInformation transit = (DeploymentInformation)((object[])e.Argument)[1]; //-----save the nuspec file so all the changes can be applied try { XmlUtil.Serialize(transit.NuSpecFileFullName, transit.NuSpecPackage); if (transit.ProjectOptions.NuGetOptions.NuSpecOptions.Metadata.UseAny || transit.ProjectOptions.NuGetOptions.NuSpecOptions.Files.UseFromSettings) { activeProject.ProjectItems.AddFromFile(transit.NuSpecFileFullName); } } catch (Exception ex) { throw new IOException(string.Format("Could not serialize the nuspec file: {0}.", transit.NuSpecFileFullName), ex); } //-----make sure the project is supported ProjectInformation projectInformation = OptionsManager.Instance.SupportedProjectInformation.FirstOrDefault(p => activeProject.FullName.EndsWith(p.Extension)); if (projectInformation == null) { throw new ProjectNoSupportedException("project is not supported"); } SaveChangesAssembly(activeProject, transit, projectInformation); activeProject.Save(); LoggingManager.Instance.Logger.Debug("saving changed finished"); }
private UndeploymentResult UndeployRemoveInternal(string deploymentId, UndeploymentOptions options) { using (_iLock.Acquire()) { DeploymentInformation info = _deploymentStateService.GetDeployment(deploymentId); if (info == null) { throw new DeploymentNotFoundException("Deployment by id '" + deploymentId + "' could not be found"); } UndeploymentResult result; if (info.State == DeploymentState.DEPLOYED) { result = UndeployRemoveInternal(info, options); } else { result = new UndeploymentResult( deploymentId, Collections.GetEmptyList <DeploymentInformationItem>()); } _deploymentStateService.Remove(deploymentId); return(result); } }
public DeploymentOrder GetDeploymentOrder(ICollection <Module> modules, DeploymentOrderOptions options) { using (_iLock.Acquire()) { if (options == null) { options = new DeploymentOrderOptions(); } string[] deployments = _deploymentStateService.Deployments; var proposedModules = new List <Module>(); proposedModules.AddAll(modules); var availableModuleNames = new HashSet <string>(); foreach (Module proposedModule in proposedModules) { if (proposedModule.Name != null) { availableModuleNames.Add(proposedModule.Name); } } // Collect all uses-dependencies of existing modules var usesPerModuleName = new Dictionary <string, ISet <string> >(); foreach (string deployment in deployments) { DeploymentInformation info = _deploymentStateService.GetDeployment(deployment); if (info == null) { continue; } if ((info.Module.Name == null) || (info.Module.Uses == null)) { continue; } ISet <string> usesSet = usesPerModuleName.Get(info.Module.Name); if (usesSet == null) { usesSet = new HashSet <string>(); usesPerModuleName.Put(info.Module.Name, usesSet); } usesSet.AddAll(info.Module.Uses); } // Collect uses-dependencies of proposed modules foreach (Module proposedModule in proposedModules) { // check uses-dependency is available if (options.IsCheckUses) { if (proposedModule.Uses != null) { foreach (string uses in proposedModule.Uses) { if (availableModuleNames.Contains(uses)) { continue; } if (IsDeployed(uses)) { continue; } string message = "Module-dependency not found"; if (proposedModule.Name != null) { message += " as declared by module '" + proposedModule.Name + "'"; } message += " for uses-declaration '" + uses + "'"; throw new DeploymentOrderException(message); } } } if ((proposedModule.Name == null) || (proposedModule.Uses == null)) { continue; } ISet <string> usesSet = usesPerModuleName.Get(proposedModule.Name); if (usesSet == null) { usesSet = new HashSet <string>(); usesPerModuleName.Put(proposedModule.Name, usesSet); } usesSet.AddAll(proposedModule.Uses); } var proposedModuleNames = new Dictionary <string, ISet <int> >().WithNullSupport(); int count = 0; foreach (Module proposedModule in proposedModules) { ISet <int> moduleNumbers = proposedModuleNames.Get(proposedModule.Name); if (moduleNumbers == null) { moduleNumbers = new SortedSet <int>(); proposedModuleNames.Put(proposedModule.Name, moduleNumbers); } moduleNumbers.Add(count); count++; } var graph = new DependencyGraph(proposedModules.Count, false); int fromModule = 0; foreach (Module proposedModule in proposedModules) { if ((proposedModule.Uses == null) || (proposedModule.Uses.IsEmpty())) { fromModule++; continue; } var dependentModuleNumbers = new SortedSet <int>(); foreach (string use in proposedModule.Uses) { ISet <int> moduleNumbers = proposedModuleNames.Get(use); if (moduleNumbers == null) { continue; } dependentModuleNumbers.AddAll(moduleNumbers); } dependentModuleNumbers.Remove(fromModule); graph.AddDependency(fromModule, dependentModuleNumbers); fromModule++; } if (options.IsCheckCircularDependency) { var circular = graph.FirstCircularDependency; if (circular != null) { string message = ""; string delimiter = ""; foreach (int i in circular) { message += delimiter; message += "module '" + proposedModules[i].Name + "'"; delimiter = " uses (depends on) "; } throw new DeploymentOrderException( "Circular dependency detected in module uses-relationships: " + message); } } var reverseDeployList = new List <Module>(); var ignoreList = new HashSet <int>(); while (ignoreList.Count < proposedModules.Count) { // secondary sort according to the order of listing ICollection <int> rootNodes = new SortedSet <int>( new StandardComparer <int>((o1, o2) => - 1 * o1.CompareTo(o2))); rootNodes.AddAll(graph.GetRootNodes(ignoreList)); if (rootNodes.IsEmpty()) { // circular dependency could cause this for (int i = 0; i < proposedModules.Count; i++) { if (!ignoreList.Contains(i)) { rootNodes.Add(i); break; } } } foreach (int root in rootNodes) { ignoreList.Add(root); reverseDeployList.Add(proposedModules[root]); } } reverseDeployList.Reverse(); return(new DeploymentOrder(reverseDeployList)); } }
/// <summary> /// build the project using the given msbuild exe /// </summary> /// <param name="msBuildPath">full path to the msbuild exe to use</param> /// <returns>true if the build process was successful, false otherwise</returns> private void BuildProject(DeploymentInformation deployInfo) { LoggingManager.Instance.Logger.Debug("building project"); //-----start the build process of the project string result; string error; if (!Directory.Exists(deployInfo.Build.BuildPath)) { LoggingManager.Instance.Logger.Debug(string.Format("creating directory {0}", deployInfo.Build.BuildPath)); Directory.CreateDirectory(deployInfo.Build.BuildPath); } string buildFileFullname = Path.Combine(deployInfo.Build.BuildPath, deployInfo.OutputFileName); StringBuilder command = new StringBuilder(string.Format(@"{0} ""{1}"" ", deployInfo.MsBuildFullName, deployInfo.ProjectFullName)); command.Append(string.Format(@" /p:Configuration=""{0}"" ", deployInfo.Build.ConfigurationName)); command.Append(string.Format(@" /p:Platform=""{0}"" ", deployInfo.Build.PlatformName)); command.Append(string.Format(@" /p:OutputPath=""{0}"" ", deployInfo.Build.BuildPath)); if (deployInfo.ProjectOptions.MsBuildOptions.Usage.Optimize.Useage != Enumerations.Useage.None && deployInfo.Build.Optimize != null) { command.Append(string.Format(@" /p:Optimize={0} ", deployInfo.Build.Optimize.ToString())); } if (deployInfo.ProjectOptions.MsBuildOptions.Usage.DebugConstants.Useage != Enumerations.Useage.None && !string.IsNullOrEmpty(deployInfo.Build.DebugConstants)) { command.Append(string.Format(@" /p:DefineConstants=""{0}"" ", deployInfo.Build.DebugConstants)); } if (deployInfo.ProjectOptions.MsBuildOptions.Usage.DebugInfo.Useage != Enumerations.Useage.None && !string.IsNullOrEmpty(deployInfo.Build.DebugInfo)) { command.Append(string.Format(@" /p:DebugSymbols=true /p:DebugType={0} ", deployInfo.Build.DebugInfo.ToString())); } if (deployInfo.Build.DocumentationFile != null) { command.Append(string.Format(@" /p:DocumentationFile=""{0}"" ", deployInfo.Build.DocumentationFile.Source)); } LoggingManager.Instance.Logger.Debug(string.Format("executing command [{0}]", command.ToString())); CommandUtil.ExecuteCommand(command.ToString(), new string[] { "/C" }, out result, out error); //-----make sure the build process was successfull if (!string.IsNullOrEmpty(error) || !File.Exists(buildFileFullname)) { //HACK should be reworked since it is not very save, but currently the only way if (string.IsNullOrEmpty(error) && deployInfo.ProjectOptions.Identifier == Enumerations.ProjectIdentifier.CPP) { Xml.NuGet.NuSpec.File fileDll = deployInfo.NuSpecPackage.Files.FirstOrDefault(f => f.Source == buildFileFullname); Xml.NuGet.NuSpec.File filePdb = deployInfo.NuSpecPackage.Files.FirstOrDefault(f => f.Source == StringUtil.ReplaceLastOccurrence(buildFileFullname, Resources.ExtensionDLL, Resources.ExtensionPDB)); if (fileDll != null) { deployInfo.Build.BuildPath = Path.Combine(Path.GetDirectoryName(deployInfo.ProjectFullName), deployInfo.Build.PlatformName, deployInfo.Build.ConfigurationName); buildFileFullname = Path.Combine(deployInfo.Build.BuildPath, deployInfo.OutputFileName); LoggingManager.Instance.Logger.Warn(string.Format("could not create the orignal file for cpp project, checking if file {0} exists", buildFileFullname)); if (File.Exists(buildFileFullname)) { fileDll.Source = buildFileFullname; if (filePdb != null) { filePdb.Source = StringUtil.ReplaceLastOccurrence(buildFileFullname, Resources.ExtensionDLL, Resources.ExtensionPDB); } XmlUtil.Serialize(deployInfo.NuSpecFileFullName, deployInfo.NuSpecPackage); return; } } } throw new ProjectBuildFailedExceptions(!string.IsNullOrEmpty(error) ? string.Format("An Error occured during the build process: {0}", error) : string.Format("Could not create file: {0}", buildFileFullname)); } LoggingManager.Instance.Logger.Debug("building project finished"); }
private DeploymentResult DeployInternal(Module module, DeploymentOptions options, String deploymentId, DateTimeOffset addedDate) { if (options == null) { options = new DeploymentOptions(); } if (Log.IsDebugEnabled) { Log.Debug("Deploying module " + module); } IList <String> imports; if (module.Imports != null) { foreach (var imported in module.Imports) { if (Log.IsDebugEnabled) { Log.Debug("Adding import " + imported); } _epService.Configuration.AddImport(imported); } imports = new List <String>(module.Imports); } else { imports = Collections.GetEmptyList <string>(); } if (options.IsCompile) { var itemExceptions = new List <DeploymentItemException>(); foreach (var item in module.Items) { if (item.IsCommentOnly) { continue; } try { _epService.CompileEPL(item.Expression); } catch (Exception ex) { itemExceptions.Add(new DeploymentItemException(ex.Message, item.Expression, ex, item.LineNumber)); } } if (itemExceptions.IsNotEmpty()) { throw BuildException("Compilation failed", module, itemExceptions); } } if (options.IsCompileOnly) { return(null); } var exceptions = new List <DeploymentItemException>(); var statementNames = new List <DeploymentInformationItem>(); var statements = new List <EPStatement>(); var eventTypesReferenced = new HashSet <String>(); foreach (var item in module.Items) { if (item.IsCommentOnly) { continue; } String statementName = null; Object userObject = null; if (options.StatementNameResolver != null || options.StatementUserObjectResolver != null) { var ctx = new StatementDeploymentContext(item.Expression, module, item, deploymentId); statementName = options.StatementNameResolver != null?options.StatementNameResolver.GetStatementName(ctx) : null; userObject = options.StatementUserObjectResolver != null?options.StatementUserObjectResolver.GetUserObject(ctx) : null; } try { EPStatement stmt; if (_optionalStatementIdGenerator == null) { if (options.IsolatedServiceProvider == null) { stmt = _epService.CreateEPL(item.Expression, statementName, userObject); } else { var unit = _statementIsolationService.GetIsolationUnit(options.IsolatedServiceProvider, -1); stmt = unit.EPAdministrator.CreateEPL(item.Expression, statementName, userObject); } } else { var statementId = _optionalStatementIdGenerator.Invoke(); if (options.IsolatedServiceProvider == null) { stmt = _epService.CreateEPLStatementId(item.Expression, statementName, userObject, statementId); } else { var unit = _statementIsolationService.GetIsolationUnit(options.IsolatedServiceProvider, -1); var spi = (EPAdministratorIsolatedSPI)unit.EPAdministrator; stmt = spi.CreateEPLStatementId(item.Expression, statementName, userObject, statementId); } } statementNames.Add(new DeploymentInformationItem(stmt.Name, stmt.Text)); statements.Add(stmt); ICollection <String> types = _statementEventTypeRef.GetTypesForStatementName(stmt.Name); if (types != null) { eventTypesReferenced.AddAll(types); } } catch (EPException ex) { exceptions.Add(new DeploymentItemException(ex.Message, item.Expression, ex, item.LineNumber)); if (options.IsFailFast) { break; } } } if (exceptions.IsNotEmpty()) { if (options.IsRollbackOnFail) { Log.Debug("Rolling back intermediate statements for deployment"); foreach (var stmt in statements) { try { stmt.Dispose(); } catch (Exception ex) { Log.Debug("Failed to destroy created statement during rollback: " + ex.Message, ex); } } EPLModuleUtil.UndeployTypes(eventTypesReferenced, _statementEventTypeRef, _eventAdapterService, _filterService); } var text = "Deployment failed"; if (options.IsValidateOnly) { text = "Validation failed"; } throw BuildException(text, module, exceptions); } if (options.IsValidateOnly) { Log.Debug("Rolling back created statements for validate-only"); foreach (var stmt in statements) { try { stmt.Dispose(); } catch (Exception ex) { Log.Debug("Failed to destroy created statement during rollback: " + ex.Message, ex); } } EPLModuleUtil.UndeployTypes(eventTypesReferenced, _statementEventTypeRef, _eventAdapterService, _filterService); return(null); } var deploymentInfoArr = statementNames.ToArray(); var desc = new DeploymentInformation(deploymentId, module, addedDate.TranslateTo(_timeZone), DateTime.Now, deploymentInfoArr, DeploymentState.DEPLOYED); _deploymentStateService.AddUpdateDeployment(desc); if (Log.IsDebugEnabled) { Log.Debug("Module " + module + " was successfully deployed."); } return(new DeploymentResult(desc.DeploymentId, statements.AsReadOnlyList(), imports)); }
public Task RunScript(string scriptPath, DeploymentInformation deployment) { throw new NotImplementedException(); }
/// <summary> /// called when the worker is supposed to start /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected override void DoWork(object sender, DoWorkEventArgs e) { LoggingManager.Instance.Logger.Debug("staring deployment process"); DeploymentInformation deployInfo = (DeploymentInformation)e.Argument; int interval = 0; if (deployInfo.Step == Step.Deploy) { interval = 33; } else if (deployInfo.Step == Step.Package) { interval = 50; } else if (deployInfo.Step == Step.Build) { interval = 100; } bool isLocked = false; using (Mutex mutex = new Mutex(true, deployInfo.ProjectFullName.GetHashCode().ToString())) { //-----start the deployment process try { isLocked = mutex.WaitOne(); //-----build project if (!_worker.CancellationPending) { _worker.ReportProgress(0 * interval, "Building project..."); BuildProject(deployInfo); } //----check if only the build was needed if (deployInfo.Step == Step.Build) { e.Result = string.Format("project successfully build at location {0}", deployInfo.Build.BuildPath); return; } //-----build nuPkgfile from nuSpec file string nuPkgFilePath = null; if (!_worker.CancellationPending) { _worker.ReportProgress(1 * interval, "Creating NuGet package..."); BuildNuGetPackage(deployInfo, ref nuPkgFilePath); } //----check if only the packaing was needed if (deployInfo.Step == Step.Package) { e.Result = string.Format("project successfully packaged at location {0}", deployInfo.Build.BuildPath); return; } //-----push nuPkg file if (!_worker.CancellationPending) { _worker.ReportProgress(2 * interval, "Deploying NuGet package to server..."); PushNuGetPackage(deployInfo.NuGetServer.Url, ExtensionManager.Instance.Encryptor.Decrypt(deployInfo.NuGetServer.ApiKey), nuPkgFilePath); } e.Result = string.Format("package successfully pushed to server {0}", deployInfo.NuGetServer.Url); } catch (Exception) { throw; } finally { e.Cancel = _worker.CancellationPending; if (isLocked) { mutex.ReleaseMutex(); } } } }