TextureSync/server/texture-sync-server/src/persistency/mod.rs

// TODO: remove on implementation
#![allow(unused_imports)]
#![allow(unused_variables)]
#![allow(dead_code)]

use crate::model::*;

use std::collections::HashMap;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use std::sync::Arc;

use sha2::{self, Digest};

pub use self::search::Query;
mod collection_file;
mod image_convert;
mod search;

pub type TextureFileResult = Result<Arc<Vec<u8>>, TextureFileError>;
pub enum TextureFileError {
    NotFound,
    IoError(io::Error),
    ImageError(::image::ImageError),
}

pub struct DataStore {
    // private attributes
    // may change
    data_dir: PathBuf,
    texture: Vec<Texture>,
    preview_cache: HashMap<(TextureFormat, Sha256), Arc<Vec<u8>>>,
}

fn sha256(data: &[u8]) -> Sha256 {
    let mut hasher = sha2::Sha256::new();
    hasher.input(data);
    let hash_result = hasher.result();
    let hash_slice = hash_result.as_slice();
    let mut hash_arr = [0u8; 32];
    for i in 0..32 {
        hash_arr[i] = hash_slice[i];
    }
    Sha256(hash_arr)
}

impl DataStore {
    pub fn new(path: &Path) -> io::Result<DataStore> {
        let base_path = path.to_path_buf();
        let mut collection_file_path = base_path.clone();
        collection_file_path.push("collection.json");

        Ok(DataStore {
            data_dir: base_path,
            texture: collection_file::load_collection_file(&collection_file_path)?,
            preview_cache: HashMap::new(),
        })
    }

    pub fn garbage_collect(&mut self) -> io::Result<()> {
        unimplemented!()
    }

    pub fn query(&mut self, query: &self::search::Query) -> Vec<Texture> {
        unimplemented!();
        // calls self::search::search(... )
    }

    /// returns true if successful
    pub fn delete(&mut self, tex: &Texture) -> bool {
        // Find the texture
        let pos = self.texture.iter().position(|e| e == tex);
        match pos {
            // Remove it
            Some(idx) => {
                let removed = self.texture.remove(idx);
                let mut key = (TextureFormat::PNG, removed.texture_hash);
                self.preview_cache.remove(&key); // Delete png preview
                key.0 = TextureFormat::JPEG;
                self.preview_cache.remove(&key); // Delete jpeg preview
                true
            }
            // Texture not found
            None => false,
        }
    }

    /// * `data` The content of the texture file, if available.
    pub fn insert(
        &mut self,
        tex: Texture,
        data: Option<Arc<Vec<u8>>>,
    ) -> ProtocolResult<ReplaceTextureStatus> {
        use io::Write;

        // Check for collisions
        if self
            .texture
            .iter()
            .find(|e| e.id == tex.id || e.name == tex.name)
            .is_some()
        {
            // Name or id already in use
            Err(ProtocolError::Conflict(
                "Name or id is already in use.".to_string(),
            ))
        } else {
            // Insert it
            if self.has_hash(&tex.texture_hash)? {
                self.texture.push(tex);
                Ok(ReplaceTextureStatus::Ok)
            } else {
                match data {
                    None => Ok(ReplaceTextureStatus::NeedTextureData(tex.texture_hash)),
                    Some(blob) => {
                        if sha256(&blob) != tex.texture_hash {
                            return Err(ProtocolError::BadRequest(
                                "The texture does not have the given hash value.".to_string(),
                            ));
                        }
                        let mut tmp_image_path = self.data_dir.clone();
                        tmp_image_path.push("textures");
                        tmp_image_path.push(format!(
                            "{}_new",
                            tex.texture_hash.create_hex_string().to_lowercase()
                        ));
                        let mut final_image_path = self.data_dir.clone();
                        final_image_path.push("textures");
                        final_image_path.push(tex.texture_hash.create_hex_string().to_lowercase());
                        {
                            let mut writer = fs::File::create(&tmp_image_path)?;
                            writer.write_all(&blob)?;
                        }
                        fs::rename(tmp_image_path, final_image_path)?;
                        Ok(ReplaceTextureStatus::Ok)
                    }
                }
            }
        }
    }

    pub fn by_name<'a>(&'a self, name: &str) -> Option<&'a Texture> {
        self.texture.iter().find(|e| e.name == name)
    }

    pub fn by_id<'a, 'b>(&'a self, id: &'b str) -> Option<&'a Texture> {
        self.texture.iter().find(|e| e.id == id)
    }

    /// Check if the texture, given by hash, physically exists on the file system.
    pub fn has_hash(&self, hash: &Sha256) -> io::Result<bool> {
        let mut texture_path = self.data_dir.clone();
        texture_path.push("textures");
        texture_path.push(hash.create_hex_string().to_lowercase());
        match texture_path.metadata() {
            Ok(meta) => {
                if meta.is_file() {
                    Ok(true)
                } else {
                    Err(io::Error::new(
                        io::ErrorKind::Other,
                        format!("{:?} exists but is not a regular file.", texture_path),
                    ))
                }
            }
            Err(e) => {
                if e.kind() == io::ErrorKind::NotFound {
                    Ok(false)
                } else {
                    Err(e)
                }
            }
        }
    }

    pub fn get_texture_file(&mut self, hash: &Sha256) -> TextureFileResult {
        use io::Read;

        let mut file_path = self.data_dir.clone();
        file_path.push("textures");
        file_path.push(hash.create_hex_string().to_lowercase());
        let mut file = match fs::File::open(file_path) {
            Ok(f) => f,
            Err(e) => {
                if e.kind() == io::ErrorKind::NotFound {
                    return Err(TextureFileError::NotFound);
                } else {
                    return Err(TextureFileError::IoError(e));
                }
            }
        };
        let mut buffer = Vec::new();
        match file.read_to_end(&mut buffer) {
            Ok(_) => (),
            Err(e) => return Err(TextureFileError::IoError(e)),
        };
        Ok(Arc::new(buffer))
    }

    pub fn get_texture_preview(&mut self, hash: &Sha256) -> TextureFileResult {
        unimplemented!();
    }

    fn store_metadata(&self) -> io::Result<()> {
        let mut tmp_path = self.data_dir.clone();
        tmp_path.push("collection_new.json");
        collection_file::store_collection_file(&tmp_path, &self.texture)?;
        let mut final_path = self.data_dir.clone();
        final_path.push("collection.json");
        fs::rename(tmp_path, final_path)
    }
}