/// <summary>
/// Deploys all assets (i.e., external systems, entity types, and feeds)
/// represented by types denoted with the appropriate attributes from all currently
/// loaded assemblies.
/// </summary>
/// <param name="context">
/// The <see cref="IDeploymentContext" /> instance to use.
/// </param>
public void Execute(IDeploymentContext context)
{
AssetSuite assetSuite = this.assetAssembler.AssembleAssets();
this.DeployExternalSystems(context, assetSuite.ExternalSystems);
this.DeployFeeds(context, assetSuite.Feeds);
}
public AdvancedViewModel(ILumiaSettingsService lumiaSettingsService, IFileSystemOperations fileSystemOperations,
UIServices uiServices, IDeploymentContext context, IOperationContext operationContext, IOperationProgress progress,
IList <Meta <IDiskLayoutPreparer> > diskPreparers,
ILogCollector logCollector)
{
this.lumiaSettingsService = lumiaSettingsService;
this.uiServices = uiServices;
this.context = context;
this.logCollector = logCollector;
DiskPreparers = diskPreparers;
DeleteDownloadedWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(() => DeleteDownloaded(fileSystemOperations)), progress, this, uiServices.ContextDialog, operationContext);
ForceDualBootWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(ForceDualBoot), progress, this, uiServices.ContextDialog, operationContext);
ForceSingleBootWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(ForceDisableDualBoot), progress, this, uiServices.ContextDialog, operationContext);
CollectLogsCommmandWrapper = new ProgressViewModel(ReactiveCommand.CreateFromTask(CollectLogs), progress, this, uiServices.ContextDialog, operationContext);
IsBusyObservable = Observable.Merge(DeleteDownloadedWrapper.Command.IsExecuting,
ForceDualBootWrapper.Command.IsExecuting, ForceSingleBootWrapper.Command.IsExecuting,
CollectLogsCommmandWrapper.Command.IsExecuting);
preparerUpdater = this.WhenAnyValue(x => x.SelectedPreparer)
.Where(x => x != null)
.Subscribe(x =>
{
context.DiskLayoutPreparer = x.Value;
lumiaSettingsService.DiskPreparer = (string)x.Metadata["Name"];
});
SelectedPreparer = GetInitialDiskPreparer();
}
/// <summary>
/// Entry point for execution of the step.
/// </summary>
/// <param name="context">The step context that can be used to access project related CKSProperties.</param>
/// <remarks>
/// This method is executed in a background thread.
/// </remarks>
public void Execute(IDeploymentContext context)
{
if (context.IsDeploying)
{
new ProcessUtilities().RestartIIS(context.Project);
}
}
public FetchGitHubBranch(string repositoryUrl, string branchName,
IZipExtractor zipExtractor, IDownloader downloader, IGitHubClient gitHubClient,
IOperationProgress progressObserver, IDeploymentContext deploymentContext,
IFileSystemOperations fileSystemOperations, IOperationContext operationContext) :
base(repositoryUrl, branchName, zipExtractor, downloader, gitHubClient, progressObserver, deploymentContext, fileSystemOperations, operationContext)
{
}
public DeployWindows(IDeploymentContext deploymentContext, IWindowsDeployer deployer, IOperationProgress progressObserver,
IFileSystemOperations fileSystemOperations, IOperationContext operationContext) : base(deploymentContext, fileSystemOperations, operationContext)
{
this.deploymentContext = deploymentContext;
this.deployer = deployer;
this.progressObserver = progressObserver;
}
public RunScript(string scriptPath, IFileSystemOperations fileSystemOperations,
IDeploymentContext deploymentContext, IOperationContext operationContext, IScriptRunner scriptRunner, IScriptParser scriptParser) : base(deploymentContext, fileSystemOperations, operationContext)
{
this.scriptPath = scriptPath;
this.scriptRunner = scriptRunner;
this.scriptParser = scriptParser;
}
protected DeploymentTask(IDeploymentContext deploymentContext, IFileSystemOperations fileSystemOperations,
IOperationContext operationContext)
{
DeploymentContext = deploymentContext;
FileSystemOperations = fileSystemOperations;
OperationContext = operationContext;
}
public CopyDirectory(string origin, string destination, IFileSystemOperations fileSystemOperations,
IDeploymentContext deploymentContext, IOperationContext operationContext) : base(deploymentContext, fileSystemOperations, operationContext)
{
this.origin = origin;
this.destination = destination;
this.fileSystemOperations = fileSystemOperations;
}
// Implements IDeploymentStep.CanExecute. Specifies whether the solution can be upgraded.
public bool CanExecute(IDeploymentContext context)
{
// SharePoint returns all the installed solutions names in lower case.
solutionName = (context.Project.Package.Model.Name + ".wsp").ToLower();
solutionFullPath = context.Project.Package.OutputPath;
bool solutionExists = context.Project.SharePointConnection.ExecuteCommand <string, bool>(
"Contoso.Commands.IsSolutionDeployed", solutionName);
// Throw exceptions in error cases because deployment cannot proceed.
if (context.Project.IsSandboxedSolution)
{
string sandboxMessage = "Cannot upgrade the solution. The upgrade deployment configuration " +
"does not support Sandboxed solutions.";
context.Logger.WriteLine(sandboxMessage, LogCategory.Error);
throw new InvalidOperationException(sandboxMessage);
}
else if (!solutionExists)
{
string notDeployedMessage = string.Format("Cannot upgrade the solution. The IsSolutionDeployed " +
"command cannot find the following solution: {0}.", solutionName);
context.Logger.WriteLine(notDeployedMessage, LogCategory.Error);
throw new InvalidOperationException(notDeployedMessage);
}
// Execute step and continue with deployment.
return(true);
}
public DeploymentViewModel(
IDeploymentContext context,
IOperationContext operationContext,
IWoaDeployer deployer, UIServices uiServices, AdvancedViewModel advancedViewModel,
WimPickViewModel wimPickViewModel, IFileSystemOperations fileSystemOperations, IRaspberryPiSettingsService raspberryPiSettingsService,
IDiskRoot diskRoot)
{
this.context = context;
this.deployer = deployer;
this.uiServices = uiServices;
this.advancedViewModel = advancedViewModel;
this.wimPickViewModel = wimPickViewModel;
this.fileSystemOperations = fileSystemOperations;
this.raspberryPiSettingsService = raspberryPiSettingsService;
var isSelectedWim = wimPickViewModel.WhenAnyObservable(x => x.WimMetadata.SelectedImageObs)
.Select(metadata => metadata != null);
FullInstallWrapper = new CommandWrapper <Unit, Unit>(this,
ReactiveCommand.CreateFromTask(Deploy, isSelectedWim), uiServices.ContextDialog, operationContext);
IsBusyObservable = FullInstallWrapper.Command.IsExecuting;
isBusyHelper = IsBusyObservable.ToProperty(this, model => model.IsBusy);
RefreshDisksCommandWrapper = new CommandWrapper <Unit, IList <IDisk> >(this,
ReactiveCommand.CreateFromTask(diskRoot.GetDisks), uiServices.ContextDialog, operationContext);
disks = RefreshDisksCommandWrapper.Command
.Select(x => x.Select(disk => new DiskViewModel(disk)))
.ToProperty(this, x => x.Disks);
this.WhenAnyValue(x => x.SelectedDisk).Where(x => x != null).Subscribe(x => context.Device = new RaspberryPi(x.IDisk));
}
/// <summary>
/// Executes the deployment step.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
public void Execute(IDeploymentContext context)
{
if (context.IsDeploying)
{
SharePointPackageArtefact item = new SharePointPackageArtefact(context.Project);
item.QuickCopy(item, false);
}
}
public Flash(string imagePath, IImageFlasher flasher, IDeploymentContext deploymentContext,
IOperationContext operationContext, IFileSystemOperations fileSystemOperations, IOperationProgress progress) : base(deploymentContext,
fileSystemOperations, operationContext)
{
this.imagePath = imagePath;
this.flasher = flasher;
this.progress = progress;
}
/// <summary>
/// Executes the deployment step.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
public void Execute(IDeploymentContext context)
{
Uri url = context.Project.SiteUrl;
WebRequest request = HttpWebRequest.Create(url);
request.BeginGetResponse(
a => request.EndGetResponse(a), null);
}
/// <summary>
/// Executes the deployment step.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
public void Execute(IDeploymentContext context)
{
foreach (ISharePointProjectFeature feature in context.Project.Package.Features)
{
string relativePath = Path.Combine(feature.UnTokenize(feature.Model.DeploymentPath), "Feature.xml");
context.Project.SharePointConnection.ExecuteCommand <string>(DeploymentSharePointCommandIds.InstallFeature, relativePath);
}
}
public InjectDrivers(string origin, IDeploymentContext context, IWindowsImageService imageService,
IDeploymentContext deploymentContext, IFileSystemOperations fileSystemOperations,
IOperationContext operationContext) : base(deploymentContext, fileSystemOperations, operationContext)
{
this.origin = origin;
this.context = context;
this.imageService = imageService;
this.fileSystemOperations = fileSystemOperations;
}
/// <summary>
/// Elevate all commands to the Superuser.
/// </summary>
/// <param name="context">Deployment context.</param>
/// <param name="administratorPassword">Superuser (Admin) password.</param>
public Sudo(IDeploymentContext context, SecureString administratorPassword)
: base(context)
{
throw new NotImplementedException(); // TODO Figure out how to give password to sudo
administratorPassword.MakeReadOnly();
_administratorPassword = administratorPassword;
_previousValue = Context.RemoteEnv.IsElevated;
Context.RemoteEnv.IsElevated = true;
}
public void Apply(IDeploymentContext deploymentContext)
{
var pathToWinApp = deploymentContext.CustomData[this] as string;
if (pathToWinApp != null)
{
_winApp = Process.Start(pathToWinApp);
}
}
/// <summary>
/// Determines whether the deployment step can be executed in the current context.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
/// <returns>
/// true if the deployment step can be executed; otherwise, false.
/// </returns>
public bool CanExecute(IDeploymentContext context)
{
bool canExecute = false;
ProjectProperties.ProjectProperties properties = context.Project.Annotations.GetValue <ProjectProperties.ProjectProperties>();
bool hasScript = properties != null && String.IsNullOrEmpty(properties.ScriptName) == false;
if (hasScript)
{
string powershellKeyPath = @"SOFTWARE\Microsoft\PowerShell\1";
try
{
RegistryKey powerShellKey = Registry.LocalMachine.OpenSubKey(powershellKeyPath);
if (powerShellKey != null)
{
object installValueObject = powerShellKey.GetValue("Install");
try
{
int installValue = Convert.ToInt32(installValueObject);
canExecute = installValue == 1;
}
catch (FormatException)
{
context.Logger.WriteLine(
@"Unexpected data in PowerShell registry subkey.",
LogCategory.Error);
}
}
else
{
context.Logger.WriteLine(
@"PowerShell not installed.",
LogCategory.Warning);
}
}
catch (SecurityException)
{
context.Logger.WriteLine(
@"Access to registry key denied: HKLM\" + powershellKeyPath,
LogCategory.Error);
}
}
else
{
context.Logger.WriteLine(
@"No PowerShell script configured for execution.",
LogCategory.Warning);
}
if (canExecute == false)
{
context.Logger.WriteLine(
"Skipping PowerShell script deployment step.",
LogCategory.Warning);
}
return(canExecute);
}
public WoaDeployer(IScriptRunner scriptRunner, IScriptParser parser, ITooling tooling,
IDeploymentContext context,
IFileSystemOperations fileSystemOperations)
{
this.scriptRunner = scriptRunner;
this.parser = parser;
this.tooling = tooling;
this.context = context;
this.fileSystemOperations = fileSystemOperations;
}
/// <summary>
/// Determines whether the deployment step can be executed in the current context.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
/// <returns>
/// true if the deployment step can be executed; otherwise, false.
/// </returns>
public bool CanExecute(IDeploymentContext context)
{
bool canExecute = context.Project.IsSandboxedSolution == false;
if (canExecute == false)
{
context.Logger.WriteLine("Skipping step because the project is configured to deploy into the solution sandbox.", LogCategory.Status);
}
return(canExecute);
}
private void DeployExternalSystems(
IDeploymentContext context, IEnumerable <ExternalSystemAsset> externalSystems)
{
foreach (ExternalSystemAsset externalSystem in externalSystems)
{
context.ExternalSystem(externalSystem.Id, externalSystem.Name);
this.SetExternalSystemParameters(context, externalSystem);
this.DeployExternalSystemEntityTypes(context, externalSystem);
}
}
public Fetch(string url, string destination, IZipExtractor extractor,
IDownloader downloader, IOperationProgress progressObserver, IDeploymentContext deploymentContext,
IFileSystemOperations fileSystemOperations, IOperationContext operationContext) : base(deploymentContext, fileSystemOperations, operationContext)
{
this.url = url;
this.destination = destination;
this.extractor = extractor;
this.fileSystemOperations = fileSystemOperations;
this.downloader = downloader;
this.progressObserver = progressObserver;
}
public async Task Deploy(IDeploymentContext deploymentContext)
{
context = deploymentContext;
await EnsureFullyUnlocked();
await DownloadDeploymentScripts();
await RunDeploymentScript();
await PatchBootManagerIfNeeded();
await MoveMetadataToPhone();
await PreparePhoneDiskForSafeRemoval();
}
/// <summary>
/// Executes the deployment step.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
public void Execute(IDeploymentContext context)
{
context.Project.SharePointConnection.ExecuteCommand <SolutionInfo>(
DeploymentSharePointCommandIds.UpgradeSolution,
new SolutionInfo()
{
IsSandboxedSolution = context.Project.IsSandboxedSolution,
LocalPath = context.Project.Package.OutputPath,
Name = context.Project.Package.Model.Name + ".wsp"
});
}
/// <summary>
/// Determines if the step can be executed in the current context.
/// </summary>
/// <param name="context">The step context that can be used to access project related CKSProperties.</param>
/// <returns></returns>
/// <exception cref="System.InvalidOperationException"></exception>
/// <remarks>
/// This method is executed in a background thread.
/// </remarks>
public bool CanExecute(IDeploymentContext context)
{
if (context.IsRetracting)
{
string sandboxMessage = "Restart IIS cannot Retract.";
context.Logger.WriteLine(sandboxMessage, LogCategory.Error);
throw new InvalidOperationException(sandboxMessage);
}
return(true);
}
private void DeployFeeds(IDeploymentContext context, IEnumerable <FeedAsset> feeds)
{
foreach (FeedAsset feed in feeds)
{
context.Feed(
feed.EntityType.Id,
feed.SourceSystem.Id,
feed.FeedType);
this.SetEntityTypeSourceSystemParameters(context, feed);
}
}
private void SetEntityTypeSharedSourceSystemIdentifiers(
IDeploymentContext context, EntityTypeAsset entityType)
{
foreach (IEnumerable <ExternalSystemAsset> sourceSystems
in entityType.SharedIdentifierSourceSystems)
{
context.SharedSourceSystemIdentifiers(
entityType.Id,
sourceSystems.Select(ss => ss.Id).ToArray());
}
}
/// <summary>
/// Executes the deployment step.
/// </summary>
/// <param name="context">An object that provides information you can use to determine the context in which the deployment step is executing.</param>
public void Execute(IDeploymentContext context)
{
ProjectProperties.ProjectProperties properties = context.Project.Annotations.GetValue <ProjectProperties.ProjectProperties>();
string script = properties.ScriptName;
context.Logger.WriteLine("Executing script " + script, LogCategory.Status);
// Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell");
//powershell c:\pathtoscript\SingFile.ps1
//TODO: complete this code as it appears to be missing
}
public FetchGitHubLatestReleaseAssetFile(string repoUrl, string assetName,
IGitHubClient gitHubClient, IDownloader downloader, IOperationProgress progressObserver,
IDeploymentContext deploymentContext, IFileSystemOperations fileSystemOperations,
IOperationContext operationContext) : base(deploymentContext,
fileSystemOperations, operationContext)
{
this.repoUrl = repoUrl ?? throw new ArgumentNullException(nameof(repoUrl));
this.assetName = assetName ?? throw new ArgumentNullException(nameof(assetName));
this.gitHubClient = gitHubClient ?? throw new ArgumentNullException(nameof(gitHubClient));
this.downloader = downloader ?? throw new ArgumentNullException(nameof(downloader));
this.progressObserver = progressObserver ?? throw new ArgumentNullException(nameof(progressObserver));
}
public async Task DeployAsync(IDeploymentContext context,
IEnumerable <IDeploymentResource> resources,
CancellationToken cancellationToken)
{
//
// Create a map between resources and activities, so we can easily
// map dependencies later on
//
var order = 0;
var map = new Dictionary <IDeploymentResource, IDeploymentActivity>();
foreach (var resource in resources)
{
order++;
var t = typeof(IDeploymentResourceProvider <>);
var x = t.MakeGenericType(resource.GetType());
var provider = context.DeploymentServices.GetService(x);
var adaptor = new DeploymentResourceProviderAdaptor(provider);
Expression <Func <Task> > expression = () => adaptor.SetAsync(context, resource, cancellationToken);
var activity = new DeploymentActivity(resource.Key, expression, order);
map.Add(resource, activity);
}
//
// Add all the acitivies to the graph
//
var activityGraph = new Graph <IDeploymentActivity>();
foreach (var value in map.Values)
{
activityGraph.Add(value);
}
//
// Create dependencies between activities
//
foreach (var pair in map)
{
var resource = pair.Key;
var activity = pair.Value;
foreach (var antecedent in resource.Antecedents)
{
var antecedentActivity = map[antecedent];
activityGraph.SetAntecedent(activity, antecedentActivity);
}
}
//
// Execute the activities
//
await activityGraph.Walk(activity => activity.ExecuteAsync(), context.Parallel);
}
/// <summary>
/// Sets the orphan mapping behavior for the specified entity type.
/// </summary>
/// <param name="context">The deployment context.</param>
/// <param name="entityTypeId">The ID of the entity type.</param>
/// <param name="behavior">The orphan mapping behavior.</param>
public static void EntityTypeOrphanMappingBehavior(
this IDeploymentContext context,
Guid entityTypeId,
OrphanMappingBehavior behavior)
{
ArgumentValidator.EnsureArgumentNotNull(context, nameof(context));
ArgumentValidator.EnsureArgumentNotEmpty(entityTypeId, nameof(entityTypeId));
ValidateOrphanMappingBehavior(behavior);
context.EntityTypeParameter(
entityTypeId,
OrphanMappingBehaviorParameterName,
behavior.ToString());
}
internal BasicRemoteOperations(IDeploymentContext context, IHost host)
{
Context = context;
Sftp = new SftpClient(host.Hostname, host.Username, host.Password)
{
OperationTimeout = TimeSpan.FromMinutes(2),
ConnectionInfo = {Timeout = TimeSpan.FromMinutes(2)},
BufferSize = 1024*16
};
Sftp.Connect();
Shell = new SshClient(host.Hostname, host.Username, host.Password);
Shell.Connect();
ShellStream = Shell.CreateShellStream(
String.Format("{0}@{1}", host.Username, host.Hostname), 0, 0, 0, 0, 1024);
}
/// <summary>
/// Create a ContextManager with the current
/// DeploymentContext setup and teardown should apply
/// to the given context only.
/// </summary>
/// <param name="context"></param>
protected ContextManager(IDeploymentContext context)
{
Context = context;
}
/// <summary>
/// Add a new prefix to all commands.
/// </summary>
/// <param name="context">Deployment context.</param>
/// <param name="prefix">Prefix content.</param>
public Prefix(IDeploymentContext context, string prefix)
: base(context)
{
Context.RemoteEnv.PushPrefix(prefix);
}
public ConsoleSessionUserInfo(IDeploymentContext context)
{
AutoRespondYN = AutoResponse.AlwaysAsk;
}
internal LoopbackRemoteOperations(IDeploymentContext context, ILocalOperations localOperations)
{
Context = context;
LocalOps = localOperations;
}
internal LoopbackRemoteOperations(IDeploymentContext context)
: this(context, new BasicLocalOperations(context))
{
}
internal BasicLocalOperations(IDeploymentContext context)
{
Context = context;
_lock = new object();
}
/// <summary>
/// Change to the given directory on the remote machine.
/// </summary>
/// <param name="context">Deployment context.</param>
/// <param name="path">New current directory.</param>
public Cd(IDeploymentContext context, IPurePath path)
: base(context)
{
Context.RemoteEnv.Pushd(
Context.RemoteEnv.CurrentDirectory.Join(path));
}
public static void Task2(IDeploymentContext context)
{
}
public void InitializeDeployment(IDeploymentContext context, NullConfig config)
{
Config = config;
Context = context;
}
