lbdeploy

type Action ¶

type Action struct {
	Type            ActionType          `json:"action"`
	Package         PackageID           `json:"package,omitempty"`
	Command         CommandID           `json:"command,omitempty"`
	Force           bool                `json:"force,omitempty"`
	Flow            FlowID              `json:"flow,omitempty"`
	SourceFile      FileResourceID      `json:"source-file,omitempty"`
	SourceDir       DirectoryResourceID `json:"source-directory,omitempty"`
	DestinationFile FileResourceID      `json:"destination-file,omitempty"`
	DestinationDir  DirectoryResourceID `json:"destination-directory,omitempty"`
}

Action describes an action to be taken as part of a flow.

type ActionType ¶

type ActionType string

ActionType identifies the type of action.

const (
	ActionStartFlow      ActionType = "start-flow"
	ActionPreparePackage ActionType = "prepare-package"
	ActionInvokeCommand  ActionType = "invoke-command"
	ActionCopyFile       ActionType = "copy-file"
	ActionDeleteFile     ActionType = "delete-file"
)

type AppDetection ¶

type AppDetection struct {
	Present ConditionID             `json:"present,omitempty"`
	Version RegistryValueResourceID `json:"version,omitempty"`
}

AppDetection describes how to detect the presence of an installed application and how to determine what version is installed.

type AppEvaluation ¶

type AppEvaluation struct {
	AlreadyInstalled   AppList
	AlreadyUninstalled AppList
	ToInstall          AppList
	ToUninstall        AppList
}

AppEvaluation is an evaluation of potential changes to the set of installed applications.

func (e AppEvaluation) ActionsNeeded() bool

func (e AppEvaluation) IsZero() bool

type AppID ¶

type AppID string

AppID is a unique identifier for an application within LeafBridge.

type AppList ¶

type AppList []AppID

AppList is a list of relevant applications for a deployment.

func (list AppList) Difference(other AppList) AppList

func (list AppList) String() string

type AppMap ¶

type AppMap map[AppID]Application

AppMap holds a set of applications mapped by their identifiers.

It is used to identify relevant applications for a deployment.

type AppSummary ¶

type AppSummary struct {
	Installed           AppList
	Uninstalled         AppList
	StillNotInstalled   AppList
	StillNotUninstalled AppList
}

AppSummary is a summary of changes to the set of installed applications.

func (s AppSummary) Err() error

func (s AppSummary) IsZero() bool

type Application ¶

type Application struct {
	Name         string               `json:"name"`
	Architecture appcode.Architecture `json:"architecture,omitempty"`
	Scope        appscope.Scope       `json:"scope,omitempty"`
	ProductCode  ProductCode          `json:"product-code,omitempty"`
	Detection    AppDetection         `json:"detection,omitempty"`
}

Application hold identifying information for an application.

If it defines an architecture, scope and unpackaged app ID, these will be used to determine if the application is installed in the Windows app registry.

Alternatively, a condition may be specified that determines whether the application is installed.

type Behavior ¶

type Behavior struct {
	OnError OnErrorBehavior `json:"on-error,omitempty"`
}

Behavior describes behavior modifications for a deployment or flow.

func OverlayBehavior(behaviors ...Behavior) Behavior

type Command ¶

type Command struct {
	// Installs is a list of applications that the command installs.
	Installs AppList `json:"installs,omitzero"`

	// Uninstalls is a list of applicaitons that the command uninstalls.
	Uninstalls AppList `json:"uninstalls,omitzero"`

	// Type is the type of command to be run.
	Type CommandType `json:"type,omitempty"`

	// WorkingDirectory specifies a working directory for a command. If no
	// working directory is specified, the directory containing the executable
	// will be used.
	WorkingDirectory DirectoryResourceID `json:"working-directory,omitempty"`

	// Executable identifies an executable file to be run.
	//
	// For commands applied to archive packages, it identifies the executable
	// file within the archive, and will be interpreted as a PackageFileID.
	//
	// For non-pacakge commands, it identifies the executable file to be
	// invoked, and will be interpreted as a FileResourceID.
	//
	// For msi-based commands, the file will be provided to the msiexec
	// utility.
	Executable ExecutableID `json:"executable,omitempty"`

	// Args is the set of arguments to be passed to the command.
	Args []string `json:"args,omitzero"`

	// ExitCodes provide a map of known exit codes for the command.
	ExitCodes ExitCodeMap `json:"exit-codes,omitzero"`
}

Command defines a command that can be invoked for a deployment or package.

TODO: Support variable expansion when building arguments.

type CommandID ¶

type CommandID string

CommandID is a unique identifier for a command.

type CommandMap ¶

type CommandMap map[CommandID]Command

CommandMap defines a set of commands that can be issued, mapped by their identifiers.

type CommandResult ¶

type CommandResult struct {
	ExitCode ExitCode
	Info     ExitCodeInfo
}

CommandResult stores information about an exit code returned by a command.

func (r CommandResult) String() string

type CommandType ¶

type CommandType string

CommandType identifies the type of a command.

func (t CommandType) IsAppBased() bool

func (t CommandType) IsMSI() bool

type Condition ¶

type Condition struct {
	Label      string             `json:"label,omitempty"`
	Type       ConditionType      `json:"type,omitempty"`
	Subject    string             `json:"subject,omitempty"`
	Comparison lbvalue.Comparison `json:"comparison,omitzero"`
	Value      lbvalue.Value      `json:"value,omitzero"`
	Negated    bool               `json:"negated,omitempty"`
	Any        []Condition        `json:"any,omitzero"`
	All        []Condition        `json:"all,omitzero"`
	Violation  string             `json:"violation,omitempty"`
}

Condition describes a condition that can be evaluated.

type ConditionCache ¶

type ConditionCache map[ConditionID]bool

ConditionCache holds a cache of evaluated conditions.

type ConditionElement ¶

type ConditionElement int

ConditionElement identifies an element of a condition.

const (
	ConditionElementSelf ConditionElement = iota
	ConditionElementAny
	ConditionElementAll
)

type ConditionError ¶

type ConditionError struct {
	ID           ConditionID
	Label        string
	Type         ConditionType
	Element      ConditionElement
	SubCondition int
	Err          error
}

ConditionError is returned when a condition fails due to an error.

func (e ConditionError) Error() string

func (e ConditionError) Unwrap() error

type ConditionID ¶

type ConditionID string

ConditionID is a unique identifier for a condition.

type ConditionList ¶

type ConditionList []ConditionID

ConditionList is a list of condition IDs.

func (list ConditionList) String() string

type ConditionMap ¶

type ConditionMap map[ConditionID]Condition

ConditionMap holds a set of conditions mapped by their identifiers.

type ConditionType ¶

type ConditionType string

ConditionType identifies a type of condition.

const (
	ConditionTypeSubcondition            ConditionType = "condition"
	ConditionTypeProcessIsRunning        ConditionType = "resource.process:running"
	ConditionTypeMutexExists             ConditionType = "resource.mutex:exists"
	ConditionTypeRegistryKeyExists       ConditionType = "resource.registry.key:exists"
	ConditionTypeRegistryValueExists     ConditionType = "resource.registry.value:exists"
	ConditionTypeRegistryValueComparison ConditionType = "resource.registry.value:comparison"
	ConditionTypeDirectoryExists         ConditionType = "resource.file-system.directory:exists"
	ConditionTypeFileExists              ConditionType = "resource.file-system.file:exists"
)

type ConditionUse ¶

type ConditionUse string

ConditionUse identifies common uses of a condition.

const (
	ConditionUseConstraint   ConditionUse = "constraint"
	ConditionUsePrecondition ConditionUse = "precondition"
)

func (use ConditionUse) Plural() string

func (use ConditionUse) String() string

type Deployment ¶

type Deployment struct {
	ID         DeploymentID `json:"id,omitempty"`
	Name       string       `json:"name,omitempty"`
	Behavior   Behavior     `json:"behavior,omitzero"`
	Apps       AppMap       `json:"apps,omitzero"`
	Conditions ConditionMap `json:"conditions,omitzero"`
	Commands   CommandMap   `json:"commands,omitzero"`
	Resources  Resources    `json:"resources,omitzero"`
	Flows      FlowMap      `json:"flows,omitzero"`
}

Deployment defines a deployment package.

func (dep Deployment) Validate() error

func (dep Deployment) ValidateCondition(condition ConditionID) error

type DeploymentID ¶

type DeploymentID string

DeploymentID is a unique identifier for a deployment.

func (id DeploymentID) Validate() error

type DirRef ¶

type DirRef struct {
	Root    KnownFolder
	Lineage []DirectoryResource
}

DirRef is a resolved reference to a directory on the local file system.

func (ref DirRef) Path() (string, error)

type DirectoryResource ¶

type DirectoryResource struct {
	Location DirectoryResourceID // A well-known directory, or another directory ID.
	Path     string              // Relative to location
}

FileResource describes a directory resource.

type DirectoryResourceID ¶

type DirectoryResourceID string

DirectoryResourceID is a unique identifier for a directory resource.

type DirectoryResourceMap ¶

type DirectoryResourceMap map[DirectoryResourceID]DirectoryResource

DirectoryResourceMap holds a set of directory resources mapped by their identifiers.

type DirectoryResourceSet ¶

type DirectoryResourceSet = idset.SetOf[DirectoryResourceID]

DirectoryResourceSet holds a set of directory resource IDs.

type DirectoryType ¶

type DirectoryType string

DirectoryType declares the type of a directory resource.

type ExecutableID ¶

type ExecutableID string

ExecutableID is either a FileResourceID or a PackageFileID, depending on whether the command is a regular command or a package command.

type ExitCode ¶

type ExitCode int

ExitCode is an exit code returned from a command.

type ExitCodeInfo ¶

type ExitCodeInfo struct {
	Name        string `json:"name,omitempty"`
	Description string `json:"description,omitempty"`
	OK          bool   `json:"ok,omitempty"`
}

ExitCodeInfo stores information about an exit code.

type ExitCodeMap ¶

type ExitCodeMap map[ExitCode]ExitCodeInfo

ExitCodeMap defines a set of expected exit codes.

type FileAttributes ¶

type FileAttributes struct {
	Size   int64        `json:"size"`
	Hashes filehash.Map `json:"hashes"`
}

FileAttributes store file size and cryptographic hash data for a file.

func (attr FileAttributes) Features() (features []string)

func (attr FileAttributes) Validate() error

type FileRef ¶

type FileRef struct {
	Root     KnownFolder
	Lineage  []DirectoryResource
	FileID   FileResourceID
	FilePath string
}

FileRef is a resolved reference to a file on the local file system.

func (ref FileRef) Dir() DirRef

func (ref FileRef) Path() (string, error)

type FileResource ¶

type FileResource struct {
	Location DirectoryResourceID // A well-known directory, or another directory ID.
	Path     string              // Relative to location
}

FileResource describes a file resource.

type FileResourceID ¶

type FileResourceID string

FileResourceID is a unique identifier for a file resource.

type FileResourceMap ¶

type FileResourceMap map[FileResourceID]FileResource

FileResourceMap holds a set of file resources mapped by their identifiers.

type FileSystemResources ¶

type FileSystemResources struct {
	Directories DirectoryResourceMap `json:"directories,omitempty"`
	Files       FileResourceMap      `json:"files,omitempty"`
}

FileSystemResources describes resources accessed through the file system, either local or remote.

func (fs FileSystemResources) ResolveDirectory(dir DirectoryResourceID) (ref DirRef, err error)

func (fs FileSystemResources) ResolveFile(file FileResourceID) (ref FileRef, err error)

type Flow ¶

type Flow struct {
	Constraints   ConditionList `json:"constraints,omitzero"`
	Preconditions ConditionList `json:"preconditions,omitzero"`
	Locks         []LockID      `json:"locks,omitzero"`
	Behavior      Behavior      `json:"behavior,omitzero"`
	Actions       []Action      `json:"actions,omitzero"`
}

Flow is a flow of actions within a deployment.

TODO: Consider renaming "Preconditions" to "Requirements".

type FlowID ¶

type FlowID string

FlowID is a unique identifier for a flow within a deployment.

type FlowMap ¶

type FlowMap map[FlowID]Flow

FlowMap holds a set of deployment flows mapped by their identifiers.

type FlowStats ¶

type FlowStats struct {
	ActionsCompleted int
	ActionsFailed    int
}

FlowStats hold statistics about a flow that has been invoked.

type KnownFolder ¶

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

KnownFolder is a folder with a known location.

func GetKnownFolder(id DirectoryResourceID) (folder KnownFolder, ok bool)

func (kf KnownFolder) GUID() *windows.KNOWNFOLDERID

func (kf KnownFolder) ID() DirectoryResourceID

func (kf KnownFolder) IsZero() bool

func (kf KnownFolder) Path() (path string, err error)

func (kf KnownFolder) Protected() bool

type KnownFolderMap ¶

type KnownFolderMap map[DirectoryResourceID]KnownFolder

KnownFolderMap is a map of predefined directory resource IDs to known folder locations.

type Lock ¶

type Lock struct {
	Description   string            `json:"description,omitempty"`
	Mutex         MutexID           `json:"mutex,omitempty"`
	ConflictRules LockConflictRules `json:"conflict,omitzero"`
}

Lock is a lockable resource that can be used to prevent invocations from competing or interfering with each other.

type LockConflictRules ¶

type LockConflictRules struct {
	Message string `json:"message,omitempty"`
}

LockConflictRules provide guidance for what to do when a conflict is encountered on a lockable resource.

type LockID ¶

type LockID string

LockID is a unique identifier for a lockable resource.

type LockMap ¶

type LockMap map[LockID]Lock

LockMap holds a set of lockable resources mapped by their identifiers.

type MatchType ¶

type MatchType string

MatchType defines the type of match to use for a field.

const (
	MatchEquals   MatchType = "equals"
	MatchContains MatchType = "contains"
)

type Mutex ¶

type Mutex struct {
	Description string         `json:"description,omitempty"`
	Name        MutexName      `json:"name"`
	Namespace   MutexNamespace `json:"namespace"`
}

Mutex is a system-wide mutex that can be evaluated by conditions or used by locks.

func (mutex Mutex) ObjectName() (string, error)

type MutexID ¶

type MutexID string

MutexID is a unique identifier for a system-wide mutex resource.

type MutexMap ¶

type MutexMap map[MutexID]Mutex

MutexMap holds a set of mutex resources mapped by their identifiers.

type MutexName ¶

type MutexName string

MutexName is the name of a system-wide mutex on the machine a deployment is running on.

type MutexNamespace ¶

type MutexNamespace string

MutexNamespace is the namespace within a mutex exists. It can be "leafbridge", "global" or "system".

const (
	LeafBridgeMutex MutexNamespace = "leafbridge"
	GlobalMutex     MutexNamespace = "global"
	SessionMutex    MutexNamespace = "session"
)

type OnErrorBehavior ¶

type OnErrorBehavior string

OnErrorBehavior identifies a response to take when an error is encountered.

const (
	OnErrorUnspecified OnErrorBehavior = ""
	OnErrorStop        OnErrorBehavior = "stop"
	OnErrorContinue    OnErrorBehavior = "continue"
)

type Package ¶

type Package struct {
	Name       string          `json:"name,omitempty"`
	Type       PackageType     `json:"type,omitempty"`
	Format     PackageFormat   `json:"format,omitempty"`
	Sources    []PackageSource `json:"sources,omitempty"`
	Attributes FileAttributes  `json:"attributes,omitzero"`
	Files      PackageFileMap  `json:"files,omitzero"`
	Commands   CommandMap      `json:"commands,omitzero"`
}

Package defines a deployment package.

TODO: Add support for a destination directory where an archive's extracted files will be extracted to. If a destination is not provided, then fall back to the current approach that extracts files to a temporary directory.

func (pkg Package) FileExtension() string

func (pkg Package) FileName() string

func (pkg Package) Validate() error

type PackageContent ¶

type PackageContent struct {
	ID          PackageID
	PrimaryHash filehash.Entry
}

PackageContent is a content-addressable identifier for a package.

func (content PackageContent) String() string

type PackageFile ¶

type PackageFile struct {
	Path       string         `json:"path"`
	Attributes FileAttributes `json:"attributes,omitzero"`
}

PackageFile describes a set of files that are expected to be present within an archive package.

type PackageFileID ¶

type PackageFileID string

PackageFileID is a unique identifier for a file within a package.

type PackageFileMap ¶

type PackageFileMap map[PackageFileID]PackageFile

PackageFileMap holds a set of package files mapped by their identifiers.

It is used by archive packages to verify the presence of important files within the archive.

type PackageFormat ¶

type PackageFormat string

PackageFormat declares the format of a package.

type PackageID ¶

type PackageID string

PackageID is a unique identifier for a deployment package.

func (id PackageID) Validate() error

type PackageMap ¶

type PackageMap map[PackageID]Package

PackageMap holds a set of packages mapped by their identifiers.

type PackageSource ¶

type PackageSource struct {
	Type PackageSourceType
	URL  string
}

PackageSource defines a potential source for retrieval of a package.

func (source PackageSource) Validate() error

type PackageSourceType ¶

type PackageSourceType string

PackageSourceType declares the type of source for a package.

const (
	PackageSourceHTTP PackageSourceType = "http"
)

type PackageType ¶

type PackageType string

PackageType declares the type of a package.

func (t PackageType) IsArchive() bool

type ProcessAttributeID ¶

type ProcessAttributeID string

ProcessAttributeID identifies an attribute of a process.

const (
	ProcessName ProcessAttributeID = "name"
)

type ProcessMatch ¶

type ProcessMatch struct {
	Label     string             `json:"label,omitempty"`
	Attribute ProcessAttributeID `json:"attribute,omitempty"`
	Type      MatchType          `json:"type,omitempty"`
	Value     string             `json:"value,omitempty"`
	Any       []ProcessMatch     `json:"any,omitzero"`
	All       []ProcessMatch     `json:"all,omitzero"`
}

ProcessMatch holds information used to identify processes running on a local machine.

type ProcessResource ¶

type ProcessResource struct {
	// Description of the process that is identified.
	Description string `json:"description,omitempty"`

	// Match describes criteria for identification of a running process.
	Match ProcessMatch `json:"match,omitzero"`
}

ProcessResource describes a process resource.

type ProcessResourceID ¶

type ProcessResourceID string

ProcessResourceID is a unique identifier for a process resource.

type ProcessResourceMap ¶

type ProcessResourceMap map[ProcessResourceID]ProcessResource

ProcessResourceMap holds a set of process resources mapped by their identifiers.

type ProductCode ¶

type ProductCode = unpackaged.AppID

ProductCode is an application's product code that uniquely identifies it to the operating system.

type RegistryKeyRef ¶

type RegistryKeyRef struct {
	Root    RegistryRoot
	Lineage []RegistryKeyResource
}

RegistryKeyRef is a resolved reference to a registry key on the local system.

func (ref RegistryKeyRef) Path() (string, error)

type RegistryKeyResource ¶

type RegistryKeyResource struct {
	// Location is a well-known registry root ID, or another key's
	// resource ID.
	Location RegistryKeyResourceID `json:"location,omitempty"`

	// Name is the name of the key within its location.
	Name string `json:"name,omitempty"`

	// Path is the relative path of the key within its location.
	// Both forward slashes and backslashes will be interpreted as path
	// separators.
	Path string `json:"path,omitempty"`
}

RegistryKeyResource describes a registry key in the Windows registry.

Its name and path fields are mutually exclusive.

type RegistryKeyResourceID ¶

type RegistryKeyResourceID string

RegistryKeyResourceID is a unique identifier for a registry key.

type RegistryKeyResourceMap ¶

type RegistryKeyResourceMap map[RegistryKeyResourceID]RegistryKeyResource

RegistryKeyResourceMap holds a set of registry key resources mapped by their identifiers.

type RegistryKeyResourceSet ¶

type RegistryKeyResourceSet = idset.SetOf[RegistryKeyResourceID]

RegistryKeyResourceSet holds a set of registry key resource IDs.

type RegistryResources ¶

type RegistryResources struct {
	Keys   RegistryKeyResourceMap   `json:"keys,omitempty"`
	Values RegistryValueResourceMap `json:"values,omitempty"`
}

RegistryResources describes resources accessed through the Windows registry.

func (reg RegistryResources) ResolveKey(key RegistryKeyResourceID) (ref RegistryKeyRef, err error)

func (reg RegistryResources) ResolveValue(value RegistryValueResourceID) (ref RegistryValueRef, err error)

type RegistryRoot ¶

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

RegistryRoot is a root location within the Windows registry.

func GetRegistryRoot(id RegistryKeyResourceID) (root RegistryRoot, ok bool)

func (root RegistryRoot) AbsolutePath() (path string, err error)

func (root RegistryRoot) ID() RegistryKeyResourceID

func (root RegistryRoot) IsZero() bool

func (root RegistryRoot) Key() registry.Key

func (root RegistryRoot) Path() (path string)

type RegistryRootMap ¶

type RegistryRootMap map[RegistryKeyResourceID]RegistryRoot

RegistryRootMap holds a set of registry roots mapped by their well-known identifiers.

type RegistryValueRef ¶

type RegistryValueRef struct {
	Root    RegistryRoot
	Lineage []RegistryKeyResource
	ID      RegistryValueResourceID
	Name    string
	Type    lbvalue.Kind
}

RegistryValueRef is a resolved reference to a registry key on the local system.

func (ref RegistryValueRef) Key() RegistryKeyRef

type RegistryValueResource ¶

type RegistryValueResource struct {
	// Key is the registry key resource ID of the key to which the value
	// belongs, or the well-known resource ID of a registry root.
	Key RegistryKeyResourceID `json:"key"`

	// Name is the name of the value within its registry key.
	Name string `json:"name"`

	// Type is the type of data the value holds.
	Type lbvalue.Kind `json:"type"`
}

RegistryValueResource describes a value within the Windows registry.

type RegistryValueResourceID ¶

type RegistryValueResourceID string

RegistryValueResourceID is a unique identifier for a registry value.

type RegistryValueResourceMap ¶

type RegistryValueResourceMap map[RegistryValueResourceID]RegistryValueResource

RegistryValueResourceMap holds a set of registry value resources mapped by their identifiers.

type Resources ¶

type Resources struct {
	Processes  ProcessResourceMap  `json:"processes,omitzero"`
	Mutexes    MutexMap            `json:"mutexes,omitzero"`
	Locks      LockMap             `json:"locks,omitzero"`
	Registry   RegistryResources   `json:"registry,omitzero"`
	FileSystem FileSystemResources `json:"file-system,omitzero"`
	Packages   PackageMap          `json:"packages,omitzero"`
}

Resources defines the set of resources used by a deployment, both local and remote.

func (resources Resources) Validate() error