Beispiel #1
0
        public RunbookRunResource Run(RunbookResource runbook, RunbookRunResource runbookRun)
        {
            var serverSupportsRunbookRunParameters = ServerSupportsRunbookRunParameters(Repository.LoadRootDocument().Version);

            return(serverSupportsRunbookRunParameters
                ? Run(runbook, RunbookRunParameters.MapFrom(runbookRun)).FirstOrDefault()
                : Client.Post <object, RunbookRunResource>(runbook.Link("CreateRunbookRun"), runbookRun));
        }
Beispiel #2
0
        public RunbookRunResource[] Run(RunbookResource runbook, RunbookRunParameters runbookRunParameters)
        {
            var serverVersion = Repository.LoadRootDocument().Version;
            var serverSupportsRunbookRunParameters = ServerSupportsRunbookRunParameters(serverVersion);

            if (serverSupportsRunbookRunParameters == false)
            {
                throw new UnsupportedApiVersionException($"This Octopus Deploy server is an older version ({serverVersion}) that does not yet support RunbookRunParameters. " +
                                                         "Please update your Octopus Deploy server to 2020.3.* or newer to access this feature.");
            }

            return(Client.Post <object, RunbookRunResource[]>(runbook.Link("CreateRunbookRun"), runbookRunParameters));
        }
        public async Task Request()
        {
            var project = await Repository.Projects.FindByNameOrIdOrFail(ProjectNameOrId).ConfigureAwait(false);

            var runbook = await Repository.Runbooks.FindByNameOrIdOrFail(RunbookNameOrId, project).ConfigureAwait(false);

            var environments = await Repository.Environments.FindByNamesOrIdsOrFail(EnvironmentNamesOrIds).ConfigureAwait(false);

            var tenants = await RetrieveTenants();

            LogScheduledDeployment();

            var payload = new RunbookRunParameters
            {
                RunbookId               = runbook.Id,
                ProjectId               = project.Id,
                EnvironmentIds          = environments.Select(env => env.Id).ToArray(),
                RunbookSnapshotNameOrId = Snapshot,
                UseDefaultSnapshot      = UseDefaultSnapshot,
                ForcePackageDownload    = ForcePackageDownload,
                SpecificMachineIds      = IncludedMachineIds.ToArray(),
                ExcludedMachineIds      = ExcludedMachineIds.ToArray(),
                SkipActions             = StepNamesToSkip.ToArray(),
                UseGuidedFailure        = GuidedFailure,
                TenantIds               = tenants,
                TenantTagNames          = TenantTagNames.ToArray(),
                QueueTime               = RunAt,
                QueueTimeExpiry         = NoRunAfter,
                FormValues              = Variables
            };

            RunbookRuns = await Repository.Runbooks.Run(runbook, payload);

            if (RunbookRuns.Any() && WaitForRun)
            {
                var waiter = executionResourceWaiterFactory(Repository, ServerBaseUrl);
                await waiter.WaitForRunbookRunToComplete(
                    RunbookRuns,
                    project,
                    Progress,
                    NoRawLog,
                    RawLogFile,
                    CancelOnTimeout,
                    RunCheckSleepCycle,
                    RunTimeout)
                .ConfigureAwait(false);
            }
        }