path: root/src/lib.rs

//! Shiplift is a multi-transport utility for maneuvering [docker](https://www.docker.com/) containers
//!
//! # examples
//!
//! ```no_run
//! extern crate shiplift;
//!
//! let docker = shiplift::Docker::new();
//! let images = docker.images().list(&Default::default()).unwrap();
//! println!("docker images in stock");
//! for i in images {
//!   println!("{:?}", i.RepoTags);
//! }
//! ```

extern crate hyper;
extern crate hyperlocal;
extern crate jed;
extern crate openssl;
extern crate rustc_serialize;
extern crate url;

pub mod builder;
pub mod rep;
pub mod transport;
pub mod errors;

pub use errors::Error;
pub use builder::{ContainerListOptions, ContainerFilter, EventsOptions, ImageFilter,
                  ImageListOptions, LogsOptions};

// fixme: remove this here
use builder::ContainerBuilder;
use hyper::{Client, Url};
use hyper::net::{HttpsConnector, Openssl};
use hyper::method::Method;
use hyperlocal::UnixSocketConnector;
use openssl::x509::X509FileType;
use openssl::ssl::{SslContext, SslMethod};
use rep::Image as ImageRep;
use rep::{Change, ContainerDetails, Container as ContainerRep, Event, Exit, History, ImageDetails,
          Info, SearchResult, Stats, Status, Top, Version};
use rustc_serialize::json::{self, Json};
use std::env::{self, VarError};
use std::io::Read;
use std::iter::IntoIterator;
use std::path::Path;
use std::sync::Arc;
use std::time::Duration;
use transport::{Body, Transport};
use url::{form_urlencoded, Host, RelativeSchemeData, SchemeData};

/// Represents the result of all docker operations
pub type Result<T> = std::result::Result<T, Error>;

/// Entrypoint interface for communicating with docker daemon
pub struct Docker {
    transport: Transport,
}

/// Interface for accessing and manipulating a named docker image
pub struct Image<'a, 'b> {
    docker: &'a Docker,
    name: &'b str,
}

impl<'a, 'b> Image<'a, 'b> {
    /// Exports an interface for operations that may be performed against a named image
    pub fn new(docker: &'a Docker, name: &'b str) -> Image<'a, 'b> {
        Image {
            docker: docker,
            name: name,
        }
    }

    /// Inspects a named image's details
    pub fn inspect(&self) -> Result<ImageDetails> {
        let raw = try!(self.docker.get(&format!("/images/{}/json", self.name)[..]));
        Ok(try!(json::decode::<ImageDetails>(&raw)))
    }

    /// Lists the history of the images set of changes
    pub fn history(&self) -> Result<Vec<History>> {
        let raw = try!(self.docker.get(&format!("/images/{}/history", self.name)[..]));
        Ok(try!(json::decode::<Vec<History>>(&raw)))
    }

    /// Delete's an image
    pub fn delete(&self) -> Result<Vec<Status>> {
        let raw = try!(self.docker.delete(&format!("/images/{}", self.name)[..]));
        Ok(match try!(Json::from_str(&raw)) {
               Json::Array(ref xs) => {
                   xs.iter().map(|j| {
                       let obj = j.as_object().expect("expected json object");
                       obj.get("Untagged")
                          .map(|sha| {
                              Status::Untagged(sha.as_string()
                                                  .expect("expected Untagged to be a string")
                                                  .to_owned())
                          })
                          .or(obj.get("Deleted")
                                 .map(|sha| {
                                     Status::Deleted(sha.as_string()
                                                        .expect("expected Deleted to be a string")
                                                        .to_owned())
                                 }))
                          .expect("expected Untagged or Deleted")
                   })
               }
               _ => unreachable!(),
           }
           .collect())
    }

    /// Export this image to a tarball
    pub fn export(&self) -> Result<Box<Read>> {
        self.docker.stream_get(&format!("/images/{}/get", self.name)[..])
    }
}

/// Interface for docker images
pub struct Images<'a> {
    docker: &'a Docker,
}

impl<'a> Images<'a> {
    /// Exports an interface for interacting with docker images
    pub fn new(docker: &'a Docker) -> Images<'a> {
        Images { docker: docker }
    }

    /// Lists the docker images on the current docker host
    pub fn list(&self, opts: &ImageListOptions) -> Result<Vec<ImageRep>> {
        let mut path = vec!["/images/json".to_owned()];
        if let Some(query) = opts.serialize() {
            path.push(query);
        }
        let raw = try!(self.docker.get(&path.join("?")));
        Ok(try!(json::decode::<Vec<ImageRep>>(&raw)))
    }

    /// Returns a reference to a set of operations available for a named image
    pub fn get(&'a self, name: &'a str) -> Image {
        Image::new(self.docker, name)
    }

    /// Search for docker images by term
    pub fn search(&self, term: &str) -> Result<Vec<SearchResult>> {
        let query = form_urlencoded::serialize(vec![("term", term)]);
        let raw = try!(self.docker.get(&format!("/images/search?{}", query)[..]));
        Ok(try!(json::decode::<Vec<SearchResult>>(&raw)))
    }

    /// Create a new docker images from an existing image
    pub fn create(&self, from: &str) -> Result<Box<Read>> {
        let query = form_urlencoded::serialize(vec![("fromImage", from)]);
        self.docker.stream_post(&format!("/images/create?{}", query)[..])
    }

    /// exports a collection of named images,
    /// either by name, name:tag, or image id, into a tarball
    pub fn export(&self, names: Vec<&str>) -> Result<Box<Read>> {
        let params = names.iter()
                          .map(|n| ("names", *n))
                          .collect::<Vec<(&str, &str)>>();
        let query = form_urlencoded::serialize(params);
        self.docker.stream_get(&format!("/images/get?{}", query)[..])
    }

    // pub fn import(self, tarball: Box<Read>) -> Result<()> {
    //  self.docker.post
    // }
}

/// Interface for accessing and manipulating a docker container
pub struct Container<'a, 'b> {
    docker: &'a Docker,
    id: &'b str,
}

impl<'a, 'b> Container<'a, 'b> {
    /// Exports an interface exposing operations against a container instance
    pub fn new(docker: &'a Docker, id: &'b str) -> Container<'a, 'b> {
        Container {
            docker: docker,
            id: id,
        }
    }

    /// Inspects the current docker container instance's details
    pub fn inspect(&self) -> Result<ContainerDetails> {
        let raw = try!(self.docker.get(&format!("/containers/{}/json", self.id)[..]));
        Ok(try!(json::decode::<ContainerDetails>(&raw)))
    }

    /// Returns a `top` view of information about the container process
    pub fn top(&self, psargs: Option<&str>) -> Result<Top> {
        let mut path = vec![format!("/containers/{}/top",