HostKit.Project (host_kit v0.1.0-beta.6)

@type t() :: %HostKit.Project{
  conventions: map(),
  hosts: [HostKit.Host.t()],
  instances: [HostKit.Instance.t()],
  meta: map(),
  name: atom(),
  provider_configs: %{optional(atom()) => HostKit.ProviderConfig.t()},
  providers: [module()],
  proxies: [HostKit.Proxy.t()],
  resources: [struct()],
  services: [HostKit.Service.t()],
  tenants: [HostKit.Tenant.t()]
}

Functions

add_host(project, host)

@spec add_host(t(), HostKit.Host.t()) :: t()

add_instance(project, instance)

@spec add_instance(t(), HostKit.Instance.t()) :: t()

add_proxy(project, proxy)

@spec add_proxy(t(), HostKit.Proxy.t()) :: t()

add_resource(project, resource)

@spec add_resource(
  t(),
  struct()
) :: t()

add_service(project, service)

@spec add_service(t(), HostKit.Service.t()) :: t()

add_tenant(project, tenant)

@spec add_tenant(t(), HostKit.Tenant.t()) :: t()

audit(project, opts \\ [])

@spec audit(
  t(),
  keyword()
) :: {:ok, HostKit.Plan.t()} | {:error, term()}

Audits this project by building a plan against the selected target.

fetch_host(project, name)

@spec fetch_host(t(), atom()) :: {:ok, HostKit.Host.t()} | :error

@spec fetch_host(t(), String.t()) :: {:ok, HostKit.Host.t()} | :error

fetch_instance(project, name)

@spec fetch_instance(t(), atom() | String.t()) :: {:ok, HostKit.Instance.t()} | :error

new(name, opts \\ [])

@spec new(
  atom(),
  keyword()
) :: t()

put_convention_prefix(project, name, prefix)

@spec put_convention_prefix(t(), atom(), String.t()) :: t()

put_convention_root(project, name, path)

@spec put_convention_root(t(), atom(), String.t()) :: t()

put_provider_config(project, config)

@spec put_provider_config(t(), HostKit.ProviderConfig.t()) :: t()

put_providers(project, providers)

@spec put_providers(t(), [module()]) :: t()

read(project, opts \\ [])

@spec read(
  t(),
  keyword()
) :: {:ok, [struct() | nil]} | {:error, term()}

Reads current target state for this project's desired resources.

resolve_services(project, selectors)

@spec resolve_services(t(), [atom() | String.t()] | nil) ::
  {:ok, [atom()] | nil} | {:error, term()}

Resolves service selectors against service name, identity, or path.

resolve_services!(project, selectors)

@spec resolve_services!(t(), [atom() | String.t()] | nil) :: [atom()] | nil

Resolves service selectors or raises on unknown/ambiguous selectors.

resources(project, opts \\ [])

@spec resources(
  t(),
  keyword()
) :: [struct()]

Returns project resources, optionally scoped to selected services.