private async Task TryToDeleteRefactorLogInternal(IStateModel stateModel,
SqlProject project,
ConfigurationModel configuration,
PathCollection paths)
{
if (!configuration.DeleteRefactorlogAfterVersionedScriptGeneration)
{
stateModel.CurrentState = StateModelState.DeletedRefactorLog;
return;
}
await _logger.LogInfoAsync("Deleting refactorlog files ...");
var deletedFiles = _fileSystemAccess.TryToCleanDirectory(paths.Directories.ProjectDirectory, "*.refactorlog");
if (deletedFiles.Length == 0)
{
await _logger.LogTraceAsync("No files were deleted.");
}
else
{
foreach (var deletedFile in deletedFiles)
{
_visualStudioAccess.RemoveItemFromProjectRoot(project, deletedFile);
await _logger.LogTraceAsync($"Deleted file {deletedFile} ...");
}
}
stateModel.CurrentState = StateModelState.DeletedRefactorLog;
}
private async Task VerifyPathsInternal(IStateModel stateModel,
PathCollection paths)
{
await _logger.LogInfoAsync("Verifying paths ...");
if (string.IsNullOrWhiteSpace(paths.DeploySources.PublishProfilePath))
{
stateModel.Result = false;
stateModel.CurrentState = StateModelState.PathsVerified;
await _logger.LogErrorAsync("Failed to find publish profile. " +
$"The {nameof(ConfigurationModel.PublishProfilePath)} is set to \"{ConfigurationModel.UseSinglePublishProfileSpecialKeyword}\", but there's more than one publish profile in the directory. " +
$"Please read the documentation at {_logger.DocumentationBaseUrl}publish-profile-path for more details.");
return;
}
if (_fileSystemAccess.CheckIfFileExists(paths.DeploySources.PublishProfilePath))
{
stateModel.CurrentState = StateModelState.PathsVerified;
return;
}
stateModel.Result = false;
stateModel.CurrentState = StateModelState.PathsVerified;
await _logger.LogErrorAsync($"Failed to find publish profile at \"{paths.DeploySources.PublishProfilePath}\". " +
$"Please read the documentation at {_logger.DocumentationBaseUrl}publish-profile-path for more details.");
}
private async Task TryCopyInternal(IStateModel stateModel,
SqlProject project,
string newArtifactsDirectory)
{
if (!await _buildService.CopyBuildResultAsync(project, newArtifactsDirectory))
{
stateModel.Result = false;
}
stateModel.CurrentState = StateModelState.TriedToCopyBuildResult;
}
private async Task TryBuildInternal(IStateModel stateModel,
SqlProject project,
bool doBuild)
{
if (doBuild && !await _buildService.BuildProjectAsync(project))
{
stateModel.Result = false;
}
stateModel.CurrentState = StateModelState.TriedToBuildProject;
}
private async Task CleanArtifactsDirectoryInternal(IStateModel stateModel,
PathCollection paths)
{
await _logger.LogInfoAsync("Cleaning artifacts directory ...");
// Even if this operation fails, there's no reason to make the whole process fail.
// Therefore this will not set the stateModel.Result property.
_fileSystemAccess.TryToCleanDirectory(paths.Directories.NewArtifactsDirectory);
stateModel.CurrentState = StateModelState.TriedToCleanArtifactsDirectory;
}
private async Task TryLoadSqlProjectPropertiesInternal(IStateModel stateModel,
SqlProject project)
{
var loaded = await _sqlProjectService.TryLoadSqlProjectPropertiesAsync(project);
if (!loaded)
{
stateModel.Result = false;
}
stateModel.CurrentState = StateModelState.SqlProjectPropertiesLoaded;
}
/// <summary>
/// Returns the available triggers available given the current state of a model, and a state machine
/// </summary>
/// <typeparam name="TStateModel"></typeparam>
/// <param name="model">model containing current state</param>
/// <param name="stateMachine">state machine with which to process</param>
/// <returns></returns>
public static IEnumerable <Trigger> AvailableTriggers <TStateModel>(this IStateModel model,
IStateMachine <TStateModel> stateMachine) where TStateModel : IStateModel
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (stateMachine == null)
{
throw new ArgumentNullException("stateMachine");
}
return(stateMachine.AvailableTriggers((TStateModel)model));
}
private async Task CreateDeploymentFilesInternal(IStateModel stateModel,
PathCollection paths,
ConfigurationModel configuration,
bool createDocumentationWithScriptCreation)
{
var success = await CreateAndPersistDeployFiles(paths, configuration, createDocumentationWithScriptCreation);
if (!success)
{
await _logger.LogErrorAsync("Script creation aborted.");
stateModel.Result = false;
}
stateModel.CurrentState = StateModelState.TriedToCreateDeploymentFiles;
}
private async Task TryCopyInternal([NotNull] IStateModel stateModel,
[NotNull] string newDacpacPath,
[NotNull] string sharedDacpacRepositoryPath)
{
if (string.IsNullOrWhiteSpace(sharedDacpacRepositoryPath))
{
stateModel.CurrentState = StateModelState.TriedToCopyDacpacToSharedDacpacRepository;
return;
}
await _logger.LogInfoAsync("Copying DACPAC to shared DACPAC repository ...");
try
{
var fileName = Path.GetFileName(newDacpacPath);
var targetFile = Path.Combine(sharedDacpacRepositoryPath, fileName);
var directoryError = _fileSystemAccess.EnsureDirectoryExists(sharedDacpacRepositoryPath);
if (directoryError != null)
{
await _logger.LogErrorAsync($"Failed to ensure that the directory '{sharedDacpacRepositoryPath}' exists: {directoryError}");
stateModel.CurrentState = StateModelState.TriedToCopyDacpacToSharedDacpacRepository;
stateModel.Result = false;
return;
}
var copyError = _fileSystemAccess.CopyFile(newDacpacPath, targetFile);
stateModel.CurrentState = StateModelState.TriedToCopyDacpacToSharedDacpacRepository;
if (copyError == null)
{
return;
}
await _logger.LogErrorAsync($"Failed to copy DACPAC to shared DACPAC repository: {copyError}");
stateModel.Result = false;
}
catch (Exception e)
{
await _logger.LogErrorAsync($"Failed to copy DACPAC to shared DACPAC repository: {e.Message}");
stateModel.CurrentState = StateModelState.TriedToCopyDacpacToSharedDacpacRepository;
stateModel.Result = false;
}
}
private async Task CleanArtifactsDirectoryInternal(IStateModel stateModel,
ConfigurationModel configuration,
PathCollection paths)
{
if (!configuration.DeleteLatestAfterVersionedScriptGeneration)
{
stateModel.CurrentState = StateModelState.DeletedLatestArtifacts;
return;
}
await _logger.LogInfoAsync("Cleaning latest artifacts directory ...");
// Even if this operation fails, there's no reason to make the whole process fail.
// Therefore this will not set the stateModel.Result property.
_fileSystemAccess.TryToCleanDirectory(paths.Directories.LatestArtifactsDirectory);
stateModel.CurrentState = StateModelState.DeletedLatestArtifacts;
}
/// <summary>
/// Triggers a transition trigger on a model given triggername and machine
/// </summary>
/// <typeparam name="TStateModel"></typeparam>
/// <param name="model">model containing current state</param>
/// <param name="triggerName">name of trigger</param>
/// <param name="stateMachine">state machine to perform the transition</param>
public static void Trigger <TStateModel>(this IStateModel model,
string triggerName,
IStateMachine <TStateModel> stateMachine) where TStateModel : IStateModel
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (string.IsNullOrEmpty(triggerName))
{
throw new ArgumentNullException("triggerName");
}
if (stateMachine == null)
{
throw new ArgumentNullException("stateMachine");
}
stateMachine.Trigger(new Trigger(triggerName), (TStateModel)model);
}
/// <summary>
/// Triggers a transition trigger on a model given trigger instance and machine
/// </summary>
/// <typeparam name="TStateModel"></typeparam>
/// <param name="model">model containing current state</param>
/// <param name="trigger">trigger instance</param>
/// <param name="stateMachine">state machine to perform the transition</param>
public static void Trigger <TStateModel>(this IStateModel model,
Trigger trigger,
IStateMachine <TStateModel> stateMachine) where TStateModel : IStateModel
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (trigger == null)
{
throw new ArgumentNullException("trigger");
}
if (stateMachine == null)
{
throw new ArgumentNullException("stateMachine");
}
stateMachine.Trigger(trigger, (TStateModel)model);
}
private async Task ModifyCreatedScriptInternal(IStateModel stateModel,
SqlProject project,
ConfigurationModel configuration,
PathCollection paths,
Version previousVersion,
bool createLatest)
{
var modifiers = _scriptModifierProviderService.GetScriptModifiers(configuration);
if (!modifiers.Any())
{
stateModel.CurrentState = StateModelState.ModifiedDeploymentScript;
return;
}
var success = await ApplyAllModifiers(project, configuration, paths, previousVersion, createLatest, modifiers);
if (!success)
{
stateModel.Result = false;
}
stateModel.CurrentState = StateModelState.ModifiedDeploymentScript;
}
