cmd

type DeployAction ¶

type DeployAction struct {
	// contains filtered or unexported fields
}

func (da *DeployAction) Run(ctx context.Context) (*actions.ActionResult, error)

type DeployFlags ¶

type DeployFlags struct {
	ServiceName string
	All         bool
	Timeout     int

	*internal.EnvFlag
	// contains filtered or unexported fields
}

func NewDeployFlags(cmd *cobra.Command, global *internal.GlobalCommandOptions) *DeployFlags

func NewDeployFlagsFromEnvAndOptions(envFlag *internal.EnvFlag, global *internal.GlobalCommandOptions) *DeployFlags

func (d *DeployFlags) Bind(local *pflag.FlagSet, global *internal.GlobalCommandOptions)

func (d *DeployFlags) BindNonCommon(
	local *pflag.FlagSet,
	global *internal.GlobalCommandOptions)

func (d *DeployFlags) SetCommon(envFlag *internal.EnvFlag)

type DeploymentPreviewResult ¶ added in v1.35.0

type DeploymentPreviewResult struct {
	Timestamp time.Time                                      `json:"timestamp"`
	Services  map[string]*project.ServiceDeployPreviewResult `json:"services"`
}

DeploymentPreviewResult is the JSON output of `azd deploy --preview`.

type DeploymentResult ¶

type DeploymentResult struct {
	Timestamp time.Time                               `json:"timestamp"`
	Services  map[string]*project.ServiceDeployResult `json:"services"`
	Messages  []commandresult.ServiceEventMessage     `json:"messages,omitempty"`
}

type ProvisionAction ¶

type ProvisionAction struct {
	// contains filtered or unexported fields
}

func (p *ProvisionAction) Run(ctx context.Context) (*actions.ActionResult, error)

func (p *ProvisionAction) SetFlags(flags *ProvisionFlags)

type ProvisionFlags ¶

type ProvisionFlags struct {
	*internal.EnvFlag
	// contains filtered or unexported fields
}

func NewProvisionFlags(cmd *cobra.Command, global *internal.GlobalCommandOptions) *ProvisionFlags

func NewProvisionFlagsFromEnvAndOptions(envFlag *internal.EnvFlag, global *internal.GlobalCommandOptions) *ProvisionFlags

func (i *ProvisionFlags) Bind(local *pflag.FlagSet, global *internal.GlobalCommandOptions)

func (i *ProvisionFlags) BindNonCommon(local *pflag.FlagSet, global *internal.GlobalCommandOptions)

func (i *ProvisionFlags) Location() string

func (i *ProvisionFlags) SetCommon(envFlag *internal.EnvFlag)

func (i *ProvisionFlags) Subscription() string

type PublishAction ¶

type PublishAction struct {
	// contains filtered or unexported fields
}

func (pa *PublishAction) Run(ctx context.Context) (*actions.ActionResult, error)

type PublishFlags ¶

type PublishFlags struct {
	ServiceName string
	All         bool
	To          string
	FromPackage string

	*internal.EnvFlag
	// contains filtered or unexported fields
}

func NewPublishFlags(cmd *cobra.Command, global *internal.GlobalCommandOptions) *PublishFlags

func (f *PublishFlags) Bind(local *pflag.FlagSet, global *internal.GlobalCommandOptions)

type PublishResult ¶

type PublishResult struct {
	Timestamp time.Time                                `json:"timestamp"`
	Services  map[string]*project.ServicePublishResult `json:"services"`
}

type UpGraphAction ¶ added in v1.25.0

type UpGraphAction struct {
	// contains filtered or unexported fields
}

UpGraphAction is the single implementation of `azd up`'s default path: it builds a unified execution graph covering project-level command hooks (`preprovision`, `postprovision`, `predeploy`, `postdeploy`), every provision layer, every service's package → publish → deploy chain, and the project-level deploy lifecycle events.

The graph structure for `n` provision layers and `m` services is:

cmdhook-preprovision ──▶ provision-<L0..Ln> ──▶ cmdhook-postprovision
   ──▶ cmdhook-predeploy ──▶ event-predeploy ──▶ publish-<svc>
   ──▶ deploy-<svc> ──▶ event-postdeploy ──▶ cmdhook-postdeploy
                                                ▲
  cmdhook-prepackage ──▶ event-prepackage ──▶ package-<svc>
     ──▶ event-postpackage ──▶ cmdhook-postpackage
         (cmdhook-postpackage gates event-predeploy so prepackage→
          postpackage→predeploy ordering matches the old workflow)

Hook semantics:

• Middleware fires `preup`/`postup` around this action. The graph never duplicates those.
• `cmdhook-*` nodes fire the project-level shell hooks that the cobra hooks middleware fires for stand-alone `azd package` / `azd provision` / `azd deploy` invocations. They are no-ops (~µs) when the project declares no such hooks — structurally identical to the existing `event-*` nodes.
• `event-prepackage`/`event-postpackage` fire project.ProjectEventPackage pre/post handlers (the Go event dispatcher path that stand-alone `azd package` invokes via projectConfig.Invoke).
• `event-predeploy`/`event-postdeploy` fire project.ProjectEventDeploy pre/post handlers (the Go event dispatcher path used by e.g. the .NET Aspire publisher).
• `provisionSingleLayer` continues to fire layer hooks + per-layer `ProjectEventProvision` events internally.

func NewUpGraphAction(
	projectConfig *project.ProjectConfig,
	env *environment.Environment,
	envManager environment.Manager,
	console input.Console,
	alphaFeatureManager *alpha.FeatureManager,
	importManager *project.ImportManager,
	serviceManager project.ServiceManager,
	projectManager project.ProjectManager,
	serviceLocator ioc.ServiceLocator,
	defaultProvider provisioning.DefaultProviderResolver,
	fileShareService storage.FileShareService,
	cloud *cloud.Cloud,
	commandRunner exec.CommandRunner,
	formatter output.Formatter,
	writer io.Writer,
	provisionManager *provisioning.Manager,
) *UpGraphAction

func (u *UpGraphAction) Run(
	ctx context.Context,
	layers []provisioning.Options,
	deployFlags *DeployFlags,
	parentFlags *pflag.FlagSet,
	startTime time.Time,
) (*actions.ActionResult, error)