Struct Cluster 

pub struct Cluster {
    pub datadir: PathBuf,
    pub strategy: Strategy,
}

Representation of a PostgreSQL cluster.

The cluster may not yet exist on disk. It may exist but be stopped, or it may be running. The methods here can be used to create, start, introspect, stop, and destroy the cluster. There’s no protection against concurrent changes to the cluster made by other processes, but the functions in the coordinate module may help.

Fields

datadir: PathBuf

The data directory of the cluster.

Corresponds to the PGDATA environment variable.

strategy: Strategy

How to select the PostgreSQL installation to use with this cluster.

Implementations

impl Cluster

pub fn new<P: AsRef<Path>, S: Into<Strategy>>( datadir: P, strategy: S, ) -> Result<Self, ClusterError>

Represent a cluster at the given path.

pub fn running(&self) -> Result<bool, ClusterError>

Check if this cluster is running.

Convenient call-through to status; only returns true when the cluster is definitely running.

pub fn status(&self) -> Result<ClusterStatus, ClusterError>

Check the status of this cluster.

Tries to distinguish carefully between “definitely running”, “definitely not running”, “missing”, and “don’t know”. The latter results in ClusterError.

pub fn pidfile(&self) -> PathBuf

Return the path to the PID file used in this cluster.

The PID file does not necessarily exist.

pub fn logfile(&self) -> PathBuf

Return the path to the log file used in this cluster.

The log file does not necessarily exist.

pub fn create(&self) -> Result<State, ClusterError>

Create the cluster if it does not already exist.

pub fn start( &self, options: &[(Parameter<'_>, Value)], ) -> Result<State, ClusterError>

Start the cluster if it’s not already running, with the given options.

Returns State::Unmodified if the cluster is already running, meaning the given options were NOT applied.

pub fn pool(&self, database: Option<&str>) -> Result<PgPool, ClusterError>

Create a lazy SQLx pool for this cluster.

Although it’s possible to call this anywhere, at runtime it needs a Tokio context to work, e.g.:

let tokio = tokio::runtime::Runtime::new()?;
let rows = tokio.block_on(async {
  let pool = cluster.pool(None)?;
  let rows = sqlx::query("SELECT 1").fetch_all(&pool).await?;
  Ok::<_, ClusterError>(rows)
})?;

When the database is not specified, connects to DATABASE_POSTGRES.

pub fn shell(&self, database: Option<&str>) -> Result<ExitStatus, ClusterError>

Run psql against this cluster, in the given database.

When the database is not specified, connects to DATABASE_POSTGRES.

pub fn exec<T: AsRef<OsStr>>( &self, database: Option<&str>, command: T, args: &[T], ) -> Result<ExitStatus, ClusterError>

Run the given command against this cluster.

The command is run with the PGDATA, PGHOST, and PGDATABASE environment variables set appropriately.

When the database is not specified, uses DATABASE_POSTGRES.

pub fn databases(&self) -> Result<Vec<String>, ClusterError>

The names of databases in this cluster.

pub fn createdb(&self, database: &str) -> Result<State, ClusterError>

Create the named database.

Returns Unmodified if the database already exists, otherwise it returns Modified.

pub fn dropdb(&self, database: &str) -> Result<State, ClusterError>

Drop the named database.

Returns Unmodified if the database does not exist, otherwise it returns Modified.

pub fn stop(&self) -> Result<State, ClusterError>

Stop the cluster if it’s running.

pub fn destroy(&self) -> Result<State, ClusterError>

Destroy the cluster if it exists, after stopping it.

Trait Implementations

impl AsRef<Path> for Cluster

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for Cluster

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FacetExclusive for Cluster

type FacetExclusive<'a> = ClusterExclusive<'a>

fn facet_exclusive(&self) -> Self::FacetExclusive<'_>

impl FacetFree for Cluster

type FacetFree<'a> = ClusterFree<'a>

fn facet_free(&self) -> Self::FacetFree<'_>

impl FacetShared for Cluster

type FacetShared<'a> = ClusterShared<'a>

fn facet_shared(&self) -> Self::FacetShared<'_>

impl Subject for Cluster

Cluster can be coordinated.

type Error = ClusterError

type Options<'a> = &'a [(Parameter<'a>, Value)]

fn start(&self, options: Self::Options<'_>) -> Result<State, Self::Error>

fn stop(&self) -> Result<State, Self::Error>

fn destroy(&self) -> Result<State, Self::Error>

fn exists(&self) -> Result<bool, Self::Error>

fn running(&self) -> Result<bool, Self::Error>