Disable(Uuid),

    Enable(Uuid),

        let session_id = match env::var("HISTDB_RS_SESSION_ID") {
            Err(err) => match err {
                env::VarError::NotPresent => Err(Error::MissingSessionID),
                env::VarError::NotUnicode(_) => Err(Error::InvalidSessionIDEnvVar(err)),
            },
            Ok(s) => Uuid::parse_str(&s).map_err(Error::InvalidSessionID),
        }?;

        let session_id = session_id_from_env()?;

        let session_id = match env::var("HISTDB_RS_SESSION_ID") {
            Err(err) => match err {
                env::VarError::NotPresent => Err(Error::MissingSessionID),
                env::VarError::NotUnicode(_) => Err(Error::InvalidSessionIDEnvVar(err)),
            },
            Ok(s) => Uuid::parse_str(&s).map_err(Error::InvalidSessionID),
        }?;

        let session_id = session_id_from_env()?;

    }
}
pub fn session_id_from_env() -> Result<Uuid, Error> {
    match env::var("HISTDB_RS_SESSION_ID") {
        Err(err) => match err {
            env::VarError::NotPresent => Err(Error::MissingSessionID),
            env::VarError::NotUnicode(_) => Err(Error::InvalidSessionIDEnvVar(err)),
        },
        Ok(s) => Uuid::parse_str(&s).map_err(Error::InvalidSessionID),

    /// Disable history recording for current session
    #[structopt(name = "disable")]
    Disable(Socket),
    /// Enable history recording for current session
    #[structopt(name = "enable")]
    Enable(Socket),

                SubCommand::Disable(o) => run::disable(o.socket_path),
                SubCommand::Enable(o) => run::enable(o.socket_path),

        session_id_from_env,

    Ok(())
}
pub fn disable(socket_path: PathBuf) -> Result<(), Error> {
    let session_id = session_id_from_env()?;
    client::new(socket_path).send(&Message::Disable(session_id))?;

pub fn enable(socket_path: PathBuf) -> Result<(), Error> {
    let session_id = session_id_from_env()?;
    client::new(socket_path).send(&Message::Enable(session_id))?;
    Ok(())
}

use serde::{
    Deserialize,
    Serialize,
};

    collections::HashMap,

    collections::{
        HashMap,
        HashSet,
    },

    DeserializeCacheEntries(serde_json::Error),

    DeserializeState(serde_json::Error),

    SerializeCacheEntries(serde_json::Error),

    SerializeState(serde_json::Error),

    #[error("not recording because session {0} is disabled")]
    DisabledSession(Uuid),

    entries: HashMap<Uuid, CommandStart>,

    state: State,

#[derive(Debug, Default, Serialize, Deserialize)]
struct State {
    entries: HashMap<Uuid, CommandStart>,
    disabled_session: HashSet<Uuid>,
}

            entries: HashMap::new(),

            state: State::default(),

    let entries = serde_json::from_reader(reader).map_err(Error::DeserializeCacheEntries)?;

    let state = serde_json::from_reader(reader).map_err(Error::DeserializeState)?;

        entries,

        state,

        serde_json::to_writer(writer, &self.entries).map_err(Error::SerializeCacheEntries)?;

        serde_json::to_writer(writer, &self.state).map_err(Error::SerializeState)?;

            Message::Disable(uuid) => self.disable_session(uuid),
            Message::Enable(uuid) => self.enable_session(uuid),

        if self.entries.contains_key(&start.session_id) {

        if self.state.entries.contains_key(&start.session_id) {

        self.entries.insert(start.session_id, start);

        if self.state.disabled_session.contains(&start.session_id) {
            return Err(Error::DisabledSession(start.session_id));
        }
        self.state.entries.insert(start.session_id, start);

        if !self.entries.contains_key(&finish.session_id) {

        if self.state.disabled_session.contains(&finish.session_id) {
            return Err(Error::DisabledSession(finish.session_id));
        }
        if !self.state.entries.contains_key(&finish.session_id) {

            .state

        self.entries.iter().for_each(|(session_id, entry)| {

        self.state.entries.iter().for_each(|(session_id, entry)| {

    fn disable_session(&mut self, session_id: Uuid) -> Result<RunState, Error> {
        self.state
            .entries
            .remove(&session_id)
            .expect("already tested if exists");
        self.state.disabled_session.insert(session_id);
        Ok(RunState::Continue)
    }
    fn enable_session(&mut self, session_id: Uuid) -> Result<RunState, Error> {
        self.state.disabled_session.remove(&session_id);
        Ok(RunState::Continue)
    }