Struct ContainerLog 

pub(crate) struct ContainerLog {
    drivers: Vec<Driver>,
    lines: LineBuffer,
    buffers_lines: bool,
}

The log drivers of a container.

Fields

drivers: Vec<Driver>

lines: LineBuffer

Collects whole lines for the journald drivers, the only ones which take them.

buffers_lines: bool

Whether any driver takes whole lines.

Implementations

impl ContainerLog

pub(crate) fn new() -> Arc<Mutex<ContainerLog>>

Create a new default SharedContainerLog.

pub(crate) fn has_drivers(&self) -> bool

Check if this logger has any drivers configured.

pub(crate) fn from_request( id: &str, reader: Reader<'_, Owned>, ) -> Result<Arc<Mutex<ContainerLog>>>

Create a new SharedContainerLog for the container id from the requested drivers.

fn path<'a>(driver: &Reader<'a>) -> Result<&'a Path>

The path of a requested driver, which has to be absolute.

fn max_size(driver: &Reader<'_>) -> Option<usize>

The maximum log size of a requested driver, zero means unlimited.

pub(crate) async fn init(&mut self) -> Result<()>

Asynchronously initialize all loggers.

pub(crate) async fn reopen(&mut self) -> Result<()>

Reopen the container logs. All drivers get reopened even if one fails, the first error is returned.

pub(crate) async fn write(&mut self, pipe: Pipe, bytes: &[u8]) -> Result<()>

Write the contents of the provided bytes into all loggers. All of them get the chunk even if one fails, the first error is returned.

pub(crate) fn has_pending(&self, pipe: Pipe) -> bool

Whether a line of the pipe waits for its ending.

pub(crate) async fn flush(&mut self, pipe: Pipe) -> Result<()>

Write the line of the pipe which waits for its ending as a partial one, because the output paused.

pub(crate) async fn finish(&mut self, pipe: Pipe) -> Result<()>

The output of the pipe ended, write the line which still waits for its ending.

pub(crate) async fn sync(log: &Arc<Mutex<ContainerLog>>) -> Result<()>

Sync the data of the log files to disk, like conmon does once the container exited. The log is not locked while the files sync, they get synced even if one fails, the first error is returned. A file which cannot be synced, like a device, has nothing to sync. Only a few logs sync at a time, syncs which hang on a stuck disk keep a quarter of the threads of the blocking pool at most, see Server::MAX_BLOCKING_THREADS. Tests, which share the static, do not wait for each other.

async fn write_lines(&mut self, pipe: Pipe, lines: &[Line<'_>]) -> Result<()>

Hand the lines to every driver which takes them. All of them get the lines even if one fails, the first error is returned.

Trait Implementations

impl Debug for ContainerLog

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

Formats the value using the given formatter.

impl Default for ContainerLog

fn default() -> Self

Returns the “default value” for a type.