932 lines
30 KiB
Rust
932 lines
30 KiB
Rust
use crate::common::PIPESIZE;
|
|
use crate::compression_engine::{CompressionType, get_compression_engine};
|
|
use crate::config::Settings;
|
|
use crate::db::{self, Meta};
|
|
use crate::filter_plugin;
|
|
use crate::modes::common::settings_compression_type;
|
|
use crate::services::compression_service::CompressionService;
|
|
use crate::services::error::CoreError;
|
|
use crate::services::filter_service::FilterService;
|
|
use crate::services::meta_service::MetaService;
|
|
use crate::services::types::{ItemWithContent, ItemWithMeta};
|
|
use clap::Command;
|
|
use log::debug;
|
|
use rusqlite::Connection;
|
|
use std::collections::HashMap;
|
|
use std::fs;
|
|
use std::io::{IsTerminal, Read, Write};
|
|
use std::path::PathBuf;
|
|
|
|
/// Service for managing items in the Keep application.
|
|
///
|
|
/// This service handles CRUD operations for items, including saving content,
|
|
/// retrieving items with metadata and content, applying filters, and managing
|
|
/// compression. It integrates with the database, file system, compression engines,
|
|
/// metadata plugins, and filters to provide a complete item management interface.
|
|
pub struct ItemService {
|
|
/// Path to the data storage directory.
|
|
data_path: PathBuf,
|
|
/// Service for handling compression and decompression.
|
|
compression_service: CompressionService,
|
|
/// Service for managing metadata plugins.
|
|
meta_service: MetaService,
|
|
/// Service for applying content filters.
|
|
filter_service: FilterService,
|
|
}
|
|
|
|
impl ItemService {
|
|
/// Creates a new `ItemService` instance.
|
|
///
|
|
/// Initializes the service with the specified data directory path.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `data_path` - Path to the directory where item files are stored.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A new `ItemService` instance.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let service = ItemService::new(PathBuf::from("/data"));
|
|
/// ```
|
|
pub fn new(data_path: PathBuf) -> Self {
|
|
debug!(
|
|
"ITEM_SERVICE: Creating new ItemService with data_path: {:?}",
|
|
data_path
|
|
);
|
|
Self {
|
|
data_path,
|
|
compression_service: CompressionService::new(),
|
|
meta_service: MetaService::new(),
|
|
filter_service: FilterService::new(),
|
|
}
|
|
}
|
|
|
|
/// Retrieves an item with its associated metadata and tags.
|
|
///
|
|
/// Fetches the item from the database by ID and loads its tags and metadata.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `id` - Item ID to retrieve.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<ItemWithMeta, CoreError>` - Item with metadata and tags, or an error if not found.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(id)` - If the item does not exist.
|
|
/// * Database-related errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let item_with_meta = item_service.get_item(&conn, 1)?;
|
|
/// assert_eq!(item_with_meta.item.id, Some(1));
|
|
/// ```
|
|
pub fn get_item(&self, conn: &Connection, id: i64) -> Result<ItemWithMeta, CoreError> {
|
|
debug!("ITEM_SERVICE: Getting item with id: {}", id);
|
|
let item = db::get_item(conn, id)?.ok_or(CoreError::ItemNotFound(id))?;
|
|
debug!("ITEM_SERVICE: Found item: {:?}", item);
|
|
let tags = db::get_item_tags(conn, &item)?;
|
|
debug!("ITEM_SERVICE: Found {} tags for item {}", tags.len(), id);
|
|
let meta = db::get_item_meta(conn, &item)?;
|
|
debug!(
|
|
"ITEM_SERVICE: Found {} meta entries for item {}",
|
|
meta.len(),
|
|
id
|
|
);
|
|
Ok(ItemWithMeta { item, tags, meta })
|
|
}
|
|
|
|
/// Retrieves an item with its content, metadata, and tags.
|
|
///
|
|
/// Loads the item, its metadata/tags, and decompresses the full content.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `id` - Item ID to retrieve.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<ItemWithContent, CoreError>` - Item with content, or an error if not found.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(id)` - If the item does not exist.
|
|
/// * `CoreError::Io(...)` - If file read or decompression fails.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let item_with_content = item_service.get_item_content(&conn, 1)?;
|
|
/// assert!(!item_with_content.content.is_empty());
|
|
/// ```
|
|
pub fn get_item_content(
|
|
&self,
|
|
conn: &Connection,
|
|
id: i64,
|
|
) -> Result<ItemWithContent, CoreError> {
|
|
debug!("ITEM_SERVICE: Getting item content for id: {}", id);
|
|
let item_with_meta = self.get_item(conn, id)?;
|
|
let item_id = item_with_meta
|
|
.item
|
|
.id
|
|
.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;
|
|
|
|
if item_id <= 0 {
|
|
return Err(CoreError::InvalidInput(format!(
|
|
"Invalid item ID: {}",
|
|
item_id
|
|
)));
|
|
}
|
|
|
|
let mut item_path = self.data_path.clone();
|
|
item_path.push(item_id.to_string());
|
|
debug!("ITEM_SERVICE: Reading content from path: {:?}", item_path);
|
|
|
|
let content = self
|
|
.compression_service
|
|
.get_item_content(item_path, &item_with_meta.item.compression)?;
|
|
debug!(
|
|
"ITEM_SERVICE: Read {} bytes of content for item {}",
|
|
content.len(),
|
|
id
|
|
);
|
|
|
|
Ok(ItemWithContent {
|
|
item_with_meta,
|
|
content,
|
|
})
|
|
}
|
|
|
|
/// Retrieves item content with binary detection and optional filtering.
|
|
///
|
|
/// Loads content, applies filters if specified, and determines MIME type and binary status.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `id` - Item ID.
|
|
/// * `filter` - Optional filter string to apply to content.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<(Vec<u8>, String, bool), CoreError>` - (content, MIME type, is_binary).
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(id)` - If item not found.
|
|
/// * Filter or compression errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let (content, mime, is_binary) = item_service.get_item_content_info(&conn, 1, Some("head_lines(10)"))?;
|
|
/// ```
|
|
pub fn get_item_content_info(
|
|
&self,
|
|
conn: &Connection,
|
|
id: i64,
|
|
filter: Option<String>,
|
|
) -> Result<(Vec<u8>, String, bool), CoreError> {
|
|
// Use streaming approach to handle all filtering options consistently
|
|
let (mut reader, mime_type, is_binary) =
|
|
self.get_item_content_info_streaming(conn, id, filter)?;
|
|
|
|
// Read all the filtered content into a buffer
|
|
let mut content = Vec::new();
|
|
reader.read_to_end(&mut content)?;
|
|
|
|
Ok((content, mime_type, is_binary))
|
|
}
|
|
|
|
/// Determines if item content is binary based on metadata or sampling.
|
|
///
|
|
/// Checks existing "text" metadata first; if absent, samples the first 8192 bytes.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `item_path` - Path to the item file.
|
|
/// * `compression` - Compression type.
|
|
/// * `metadata` - Item metadata.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<bool, CoreError>` - True if binary, false if text.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * File or compression errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let is_bin = item_service.is_content_binary(path, "gzip", &meta)?;
|
|
/// ```
|
|
fn is_content_binary(
|
|
&self,
|
|
item_path: PathBuf,
|
|
compression: &str,
|
|
metadata: &HashMap<String, String>,
|
|
) -> Result<bool, CoreError> {
|
|
// Check if we already have text metadata
|
|
if let Some(text_val) = metadata.get("text") {
|
|
return Ok(text_val == "false");
|
|
}
|
|
|
|
// Read only the first 8192 bytes for binary detection
|
|
let mut sample_reader = self
|
|
.compression_service
|
|
.stream_item_content(item_path, compression)?;
|
|
let mut sample_buffer = vec![0; 8192];
|
|
let bytes_read = sample_reader.read(&mut sample_buffer)?;
|
|
Ok(crate::common::is_binary::is_binary(
|
|
&sample_buffer[..bytes_read],
|
|
))
|
|
}
|
|
|
|
/// Retrieves a streaming reader for item content with optional filtering.
|
|
///
|
|
/// Returns a boxed reader that applies compression decompression and filters.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `id` - Item ID.
|
|
/// * `filter` - Optional filter string.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<(Box<dyn Read + Send>, String, bool), CoreError>` - (reader, MIME type, is_binary).
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(id)` - If item not found.
|
|
/// * Filter parsing or compression errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let (reader, mime, is_bin) = item_service.get_item_content_info_streaming(&conn, 1, Some("grep(error)"))?;
|
|
/// ```
|
|
pub fn get_item_content_info_streaming(
|
|
&self,
|
|
conn: &Connection,
|
|
id: i64,
|
|
filter: Option<String>,
|
|
) -> Result<(Box<dyn Read + Send>, String, bool), CoreError> {
|
|
// Convert filter string to FilterChain if provided
|
|
let filter_chain = if let Some(filter_str) = filter {
|
|
self.filter_service
|
|
.create_filter_chain(Some(&filter_str))
|
|
.map_err(|e| {
|
|
CoreError::InvalidInput(format!("Failed to create filter chain: {}", e))
|
|
})?
|
|
} else {
|
|
None
|
|
};
|
|
|
|
self.get_item_content_info_streaming_with_chain(conn, id, filter_chain.as_ref())
|
|
}
|
|
|
|
/// Retrieves a streaming reader with a pre-built filter chain.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `id` - Item ID.
|
|
/// * `filter_chain` - Optional pre-parsed filter chain.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<(Box<dyn Read + Send>, String, bool), CoreError>` - (reader, MIME type, is_binary).
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(id)` - If item not found.
|
|
/// * Compression or filtering errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let chain = parse_filter_string("head(100)")?;
|
|
/// let (reader, mime, is_bin) = item_service.get_item_content_info_streaming_with_chain(&conn, 1, Some(&chain))?;
|
|
/// ```
|
|
pub fn get_item_content_info_streaming_with_chain(
|
|
&self,
|
|
conn: &Connection,
|
|
id: i64,
|
|
filter_chain: Option<&filter_plugin::FilterChain>,
|
|
) -> Result<(Box<dyn Read + Send>, String, bool), CoreError> {
|
|
let item_with_meta = self.get_item(conn, id)?;
|
|
let item_id = item_with_meta
|
|
.item
|
|
.id
|
|
.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;
|
|
|
|
if item_id <= 0 {
|
|
return Err(CoreError::InvalidInput(format!(
|
|
"Invalid item ID: {}",
|
|
item_id
|
|
)));
|
|
}
|
|
|
|
let mut item_path = self.data_path.clone();
|
|
item_path.push(item_id.to_string());
|
|
|
|
let reader = self
|
|
.compression_service
|
|
.stream_item_content(item_path.clone(), &item_with_meta.item.compression)?;
|
|
|
|
// Wrap the reader with filtering
|
|
let filtered_reader = Box::new(FilteringReader::new(reader, filter_chain.cloned()));
|
|
|
|
let metadata = item_with_meta.meta_as_map();
|
|
let mime_type = metadata
|
|
.get("mime_type")
|
|
.map(|s| s.to_string())
|
|
.unwrap_or_else(|| "application/octet-stream".to_string());
|
|
|
|
// Check if content is binary
|
|
let is_binary =
|
|
self.is_content_binary(item_path, &item_with_meta.item.compression, &metadata)?;
|
|
|
|
Ok((filtered_reader, mime_type, is_binary))
|
|
}
|
|
|
|
/// Finds an item by ID or tags/metadata criteria.
|
|
///
|
|
/// Supports lookup by ID, last item, or search by tags/metadata.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `ids` - Vector of IDs (if non-empty, uses first ID).
|
|
/// * `tags` - Vector of tags (all must match if provided).
|
|
/// * `meta` - HashMap of metadata key-value pairs (exact match).
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<ItemWithMeta, CoreError>` - The found item or error.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(...)` - If no matching item.
|
|
/// * Database errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let item = item_service.find_item(&conn, vec![1], &vec![], &HashMap::new())?;
|
|
/// ```
|
|
pub fn find_item(
|
|
&self,
|
|
conn: &Connection,
|
|
ids: &[i64],
|
|
tags: &[String],
|
|
meta: &HashMap<String, String>,
|
|
) -> Result<ItemWithMeta, CoreError> {
|
|
debug!(
|
|
"ITEM_SERVICE: Finding item with ids: {:?}, tags: {:?}, meta: {:?}",
|
|
ids, tags, meta
|
|
);
|
|
let item_maybe = match (ids.is_empty(), tags.is_empty() && meta.is_empty()) {
|
|
(false, _) => {
|
|
debug!("ITEM_SERVICE: Finding by ID: {}", ids[0]);
|
|
db::get_item(conn, ids[0])?
|
|
}
|
|
(true, true) => {
|
|
debug!("ITEM_SERVICE: Finding last item");
|
|
db::get_item_last(conn)?
|
|
}
|
|
(true, false) => {
|
|
debug!("ITEM_SERVICE: Finding by tags/meta");
|
|
db::get_item_matching(conn, &tags.to_vec(), meta)?
|
|
}
|
|
};
|
|
|
|
let item = item_maybe.ok_or(CoreError::ItemNotFoundGeneric)?;
|
|
debug!("ITEM_SERVICE: Found matching item: {:?}", item);
|
|
|
|
// Get tags and meta directly instead of calling get_item which makes redundant queries
|
|
let item_id = item
|
|
.id
|
|
.ok_or_else(|| CoreError::InvalidInput("Item missing ID".to_string()))?;
|
|
let tags = db::get_item_tags(conn, &item)?;
|
|
debug!(
|
|
"ITEM_SERVICE: Found {} tags for item {}",
|
|
tags.len(),
|
|
item_id
|
|
);
|
|
let meta = db::get_item_meta(conn, &item)?;
|
|
debug!(
|
|
"ITEM_SERVICE: Found {} meta entries for item {}",
|
|
meta.len(),
|
|
item_id
|
|
);
|
|
|
|
Ok(ItemWithMeta { item, tags, meta })
|
|
}
|
|
|
|
/// Lists items matching tags and metadata criteria.
|
|
///
|
|
/// Filters by tags (all must match) and exact metadata values, then loads full details.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Database connection.
|
|
/// * `tags` - Vector of tags (all must match).
|
|
/// * `meta` - HashMap of metadata key-value pairs (exact match).
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<Vec<ItemWithMeta>, CoreError>` - List of matching items.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * Database query errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let items = item_service.list_items(&conn, &vec!["work"], &HashMap::new())?;
|
|
/// ```
|
|
pub fn list_items(
|
|
&self,
|
|
conn: &Connection,
|
|
tags: &[String],
|
|
meta: &HashMap<String, String>,
|
|
) -> Result<Vec<ItemWithMeta>, CoreError> {
|
|
debug!(
|
|
"ITEM_SERVICE: Listing items with tags: {:?}, meta: {:?}",
|
|
tags, meta
|
|
);
|
|
let items = db::get_items_matching(conn, &tags.to_vec(), meta)?;
|
|
debug!("ITEM_SERVICE: Found {} matching items", items.len());
|
|
|
|
let item_ids: Vec<i64> = items.iter().filter_map(|item| item.id).collect();
|
|
if item_ids.is_empty() {
|
|
debug!("ITEM_SERVICE: No items found, returning empty list");
|
|
return Ok(Vec::new());
|
|
}
|
|
|
|
debug!(
|
|
"ITEM_SERVICE: Getting tags and meta for {} items",
|
|
item_ids.len()
|
|
);
|
|
let tags_map = db::get_tags_for_items(conn, &item_ids)?;
|
|
let meta_map_db = db::get_meta_for_items(conn, &item_ids)?;
|
|
|
|
let mut result = Vec::new();
|
|
for item in items {
|
|
let item_id = item.id.unwrap();
|
|
let tags = tags_map.get(&item_id).cloned().unwrap_or_default();
|
|
let meta_hm = meta_map_db.get(&item_id).cloned().unwrap_or_default();
|
|
let meta = meta_hm
|
|
.into_iter()
|
|
.map(|(name, value)| Meta {
|
|
id: item_id,
|
|
name,
|
|
value,
|
|
})
|
|
.collect();
|
|
|
|
result.push(ItemWithMeta { item, tags, meta });
|
|
}
|
|
|
|
debug!(
|
|
"ITEM_SERVICE: Returning {} items with full metadata",
|
|
result.len()
|
|
);
|
|
Ok(result)
|
|
}
|
|
|
|
/// Deletes an item by ID from database and storage.
|
|
///
|
|
/// Removes the item row, associated tags/metadata, and the physical file.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `conn` - Mutable database connection.
|
|
/// * `id` - Item ID to delete.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<(), CoreError>` - Success or error.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::ItemNotFound(id)` - If item does not exist.
|
|
/// * File deletion errors (non-fatal if not found).
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// item_service.delete_item(&mut conn, 1)?;
|
|
/// ```
|
|
pub fn delete_item(&self, conn: &mut Connection, id: i64) -> Result<(), CoreError> {
|
|
debug!("ITEM_SERVICE: Deleting item with id: {}", id);
|
|
if id <= 0 {
|
|
return Err(CoreError::InvalidInput(format!("Invalid item ID: {}", id)));
|
|
}
|
|
let item = db::get_item(conn, id)?.ok_or(CoreError::ItemNotFound(id))?;
|
|
debug!("ITEM_SERVICE: Found item to delete: {:?}", item);
|
|
|
|
let mut item_path = self.data_path.clone();
|
|
item_path.push(id.to_string());
|
|
debug!("ITEM_SERVICE: Deleting file at path: {:?}", item_path);
|
|
|
|
db::delete_item(conn, item)?;
|
|
fs::remove_file(&item_path).or_else(|e| {
|
|
if e.kind() == std::io::ErrorKind::NotFound {
|
|
Ok(())
|
|
} else {
|
|
Err(e)
|
|
}
|
|
})?;
|
|
debug!("ITEM_SERVICE: Successfully deleted item {}", id);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Saves content from a reader to a new item.
|
|
///
|
|
/// Reads from the input reader (e.g., stdin), applies metadata plugins,
|
|
/// compresses the content, and stores it with tags. Echoes input to stdout via TeeReader.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `input` - Reader providing the content to save (e.g., stdin).
|
|
/// * `cmd` - Mutable Clap command for error handling.
|
|
/// * `settings` - Application settings.
|
|
/// * `tags` - Tags to associate (defaults to "none" if empty).
|
|
/// * `conn` - Mutable database connection.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<i64, CoreError>` - The ID of the new item.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::InvalidInput(...)` - If validation fails.
|
|
/// * Database or file I/O errors.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let reader = std::io::stdin();
|
|
/// let id = item_service.save_item(reader, &mut cmd, &settings, &mut vec![], &mut conn)?;
|
|
/// ```
|
|
pub fn save_item<R: Read>(
|
|
&self,
|
|
mut input: R,
|
|
cmd: &mut Command,
|
|
settings: &Settings,
|
|
tags: &mut Vec<String>,
|
|
conn: &mut Connection,
|
|
) -> Result<i64, CoreError> {
|
|
debug!("ITEM_SERVICE: Starting save_item with tags: {:?}", tags);
|
|
if tags.is_empty() {
|
|
tags.push("none".to_string());
|
|
debug!("ITEM_SERVICE: No tags provided, using default 'none' tag");
|
|
}
|
|
|
|
let compression_type = settings_compression_type(cmd, settings);
|
|
debug!(
|
|
"ITEM_SERVICE: Using compression type: {:?}",
|
|
compression_type
|
|
);
|
|
let compression_engine = get_compression_engine(compression_type.clone())?;
|
|
|
|
let item_id;
|
|
let mut item;
|
|
{
|
|
item = db::create_item(conn, compression_type.clone())?;
|
|
item_id = item.id.unwrap();
|
|
debug!("ITEM_SERVICE: Created new item with id: {}", item_id);
|
|
db::set_item_tags(conn, item.clone(), tags)?;
|
|
debug!("ITEM_SERVICE: Set tags for item {}", item_id);
|
|
let item_meta = self.meta_service.collect_initial_meta();
|
|
debug!(
|
|
"ITEM_SERVICE: Collected {} initial meta entries",
|
|
item_meta.len()
|
|
);
|
|
for (k, v) in item_meta.iter() {
|
|
db::add_meta(conn, item_id, k, v)?;
|
|
}
|
|
}
|
|
|
|
// Print the "KEEP: New item" message before starting to read input
|
|
if !settings.quiet {
|
|
if std::io::stderr().is_terminal() {
|
|
let mut t = term::stderr().unwrap();
|
|
let _ = t.reset();
|
|
let _ = t.attr(term::Attr::Bold);
|
|
let _ = write!(t, "KEEP:");
|
|
let _ = t.reset();
|
|
let _ = write!(t, " New item ");
|
|
let _ = t.attr(term::Attr::Bold);
|
|
let _ = write!(t, "{item_id}");
|
|
let _ = t.reset();
|
|
let _ = write!(t, " tags: ");
|
|
let _ = t.attr(term::Attr::Bold);
|
|
let _ = write!(t, "{}", tags.join(" "));
|
|
let _ = t.reset();
|
|
let _ = writeln!(t);
|
|
let _ = std::io::stderr().flush();
|
|
} else {
|
|
let mut t = std::io::stderr();
|
|
let _ = writeln!(t, "KEEP: New item: {} tags: {:?}", item_id, tags);
|
|
}
|
|
}
|
|
|
|
let mut plugins = self.meta_service.get_plugins(cmd, settings);
|
|
debug!("ITEM_SERVICE: Got {} meta plugins", plugins.len());
|
|
self.meta_service
|
|
.initialize_plugins(&mut plugins, conn, item_id);
|
|
|
|
let mut item_path = self.data_path.clone();
|
|
item_path.push(item_id.to_string());
|
|
debug!("ITEM_SERVICE: Writing item to path: {:?}", item_path);
|
|
|
|
let mut item_out = compression_engine.create(item_path.clone())?;
|
|
|
|
let mut buffer = [0; PIPESIZE];
|
|
let mut total_bytes = 0;
|
|
|
|
debug!("ITEM_SERVICE: Starting to read and process input data");
|
|
loop {
|
|
let n = input.read(&mut buffer)?;
|
|
if n == 0 {
|
|
break;
|
|
}
|
|
|
|
total_bytes += n as i64;
|
|
item_out.write_all(&buffer[..n])?;
|
|
self.meta_service
|
|
.process_chunk(&mut plugins, &buffer[..n], conn, item_id);
|
|
}
|
|
debug!("ITEM_SERVICE: Processed {} bytes total", total_bytes);
|
|
|
|
item_out.flush()?;
|
|
drop(item_out);
|
|
|
|
debug!("ITEM_SERVICE: Finalizing meta plugins");
|
|
self.meta_service
|
|
.finalize_plugins(&mut plugins, conn, item_id);
|
|
|
|
item.size = Some(total_bytes);
|
|
db::update_item(conn, item.clone())?;
|
|
|
|
debug!("ITEM_SERVICE: Save completed successfully");
|
|
|
|
Ok(item_id)
|
|
}
|
|
|
|
/// Saves pre-loaded content as a new item, typically from MCP (Machine-Common-Processing) sources.
|
|
///
|
|
/// Bypasses streaming read, directly writes content and applies metadata/plugins.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `content` - Byte slice of content to save.
|
|
/// * `tags` - Tags to associate.
|
|
/// * `metadata` - Initial metadata key-value pairs.
|
|
/// * `cmd` - Mutable command.
|
|
/// * `settings` - Settings.
|
|
/// * `conn` - Mutable database connection.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `Result<ItemWithMeta, CoreError>` - The saved item with full details.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// * `CoreError::Database(...)` - If DB insert fails.
|
|
/// * `CoreError::Io(...)` - If file write fails.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let content = b"Hello, world!";
|
|
/// let tags = vec!["mcp".to_string()];
|
|
/// let meta = HashMap::from([("source".to_string(), "api".to_string())]);
|
|
/// let item = service.save_item_from_mcp(content, &tags, &meta, &mut cmd, &settings, &mut conn)?;
|
|
/// ```
|
|
pub fn save_item_from_mcp(
|
|
&self,
|
|
content: &[u8],
|
|
tags: &Vec<String>,
|
|
metadata: &HashMap<String, String>,
|
|
cmd: &mut Command,
|
|
settings: &Settings,
|
|
conn: &mut Connection,
|
|
) -> Result<ItemWithMeta, CoreError> {
|
|
debug!(
|
|
"ITEM_SERVICE: Starting save_item_from_mcp with {} bytes, {} tags, {} metadata entries",
|
|
content.len(),
|
|
tags.len(),
|
|
metadata.len()
|
|
);
|
|
let compression_type = CompressionType::LZ4;
|
|
let compression_engine = get_compression_engine(compression_type.clone())?;
|
|
|
|
let item_id;
|
|
let mut item;
|
|
|
|
{
|
|
item = db::create_item(conn, compression_type.clone())?;
|
|
item_id = item.id.unwrap();
|
|
debug!("ITEM_SERVICE: Created MCP item with id: {}", item_id);
|
|
|
|
// Add tags
|
|
for tag in tags {
|
|
db::add_tag(conn, item_id, tag)?;
|
|
}
|
|
debug!("ITEM_SERVICE: Added {} tags to MCP item", tags.len());
|
|
|
|
// Add custom metadata
|
|
for (key, value) in metadata {
|
|
db::add_meta(conn, item_id, key, value)?;
|
|
}
|
|
debug!(
|
|
"ITEM_SERVICE: Added {} custom metadata entries to MCP item",
|
|
metadata.len()
|
|
);
|
|
}
|
|
|
|
let mut item_path = self.data_path.clone();
|
|
item_path.push(item_id.to_string());
|
|
debug!("ITEM_SERVICE: Writing MCP item to path: {:?}", item_path);
|
|
|
|
let mut writer = compression_engine.create(item_path.clone())?;
|
|
writer.write_all(content)?;
|
|
drop(writer);
|
|
|
|
let mut plugins = self.meta_service.get_plugins(cmd, settings);
|
|
debug!(
|
|
"ITEM_SERVICE: Got {} configured meta plugins for MCP item",
|
|
plugins.len()
|
|
);
|
|
|
|
self.meta_service
|
|
.initialize_plugins(&mut plugins, conn, item_id);
|
|
self.meta_service
|
|
.process_chunk(&mut plugins, content, conn, item_id);
|
|
self.meta_service
|
|
.finalize_plugins(&mut plugins, conn, item_id);
|
|
debug!("ITEM_SERVICE: Processed MCP item through configured meta plugins");
|
|
|
|
item.size = Some(content.len() as i64);
|
|
db::update_item(conn, item.clone())?;
|
|
|
|
debug!("ITEM_SERVICE: MCP item saved successfully");
|
|
|
|
self.get_item(conn, item_id)
|
|
}
|
|
|
|
/// Returns a reference to the internal compression service.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// Reference to `CompressionService`.
|
|
pub fn get_compression_service(&self) -> &CompressionService {
|
|
&self.compression_service
|
|
}
|
|
|
|
/// Returns a reference to the data directory path.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// Reference to `PathBuf`.
|
|
pub fn get_data_path(&self) -> &PathBuf {
|
|
&self.data_path
|
|
}
|
|
}
|
|
|
|
/// A reader that applies a filter chain to the data as it's read.
|
|
///
|
|
/// Wraps an underlying reader and applies a filter chain to the data during read operations.
|
|
/// Buffers data as needed for filter processing.
|
|
///
|
|
/// # Fields
|
|
///
|
|
/// * `reader` - The underlying reader providing the data source.
|
|
/// * `filter_chain` - Optional filter chain to apply.
|
|
/// * `buffer` - Internal buffer for holding filtered data.
|
|
/// * `buffer_pos` - Current position in the internal buffer.
|
|
struct FilteringReader<R: Read> {
|
|
reader: R,
|
|
filter_chain: Option<filter_plugin::FilterChain>,
|
|
buffer: Vec<u8>,
|
|
buffer_pos: usize,
|
|
}
|
|
|
|
impl<R: Read> FilteringReader<R> {
|
|
/// Creates a new `FilteringReader` with the given reader and filter chain.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `reader` - The underlying reader.
|
|
/// * `filter_chain` - Optional filter chain to apply.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// A new `FilteringReader`.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let reader = std::io::Cursor::new(b"data");
|
|
/// let filter_chain = parse_filter_string("head(10)")?;
|
|
/// let filtered = FilteringReader::new(reader, Some(filter_chain));
|
|
/// ```
|
|
pub fn new(reader: R, filter_chain: Option<filter_plugin::FilterChain>) -> Self {
|
|
Self {
|
|
reader,
|
|
filter_chain,
|
|
buffer: Vec::new(),
|
|
buffer_pos: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<R: Read> Read for FilteringReader<R> {
|
|
/// Reads data, applying the filter chain if present.
|
|
///
|
|
/// If buffered data exists, serves it first. Otherwise, reads a chunk, filters it,
|
|
/// and serves the output. Handles EOF properly.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `buf` - Buffer to fill with filtered data.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// * `io::Result<usize>` - Number of bytes read, or I/O error.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// Propagates errors from underlying reader or filter operations.
|
|
///
|
|
/// # Examples
|
|
///
|
|
/// ```
|
|
/// let mut filtered = FilteringReader::new(std::io::Cursor::new(b"Hello"), None);
|
|
/// let mut buf = [0; 5];
|
|
/// let n = filtered.read(&mut buf).unwrap();
|
|
/// assert_eq!(n, 5);
|
|
/// ```
|
|
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
|
|
// If we have data in our buffer, serve that first
|
|
if self.buffer_pos < self.buffer.len() {
|
|
let bytes_to_copy = std::cmp::min(buf.len(), self.buffer.len() - self.buffer_pos);
|
|
buf[..bytes_to_copy]
|
|
.copy_from_slice(&self.buffer[self.buffer_pos..self.buffer_pos + bytes_to_copy]);
|
|
self.buffer_pos += bytes_to_copy;
|
|
return Ok(bytes_to_copy);
|
|
}
|
|
|
|
// Reset buffer for new data
|
|
self.buffer.clear();
|
|
self.buffer_pos = 0;
|
|
|
|
// Read from the original reader into a temporary buffer
|
|
let mut temp_buf = vec![0; buf.len()];
|
|
let bytes_read = self.reader.read(&mut temp_buf)?;
|
|
|
|
if bytes_read == 0 {
|
|
return Ok(0);
|
|
}
|
|
|
|
// Process through the filter chain if it exists
|
|
if let Some(ref mut chain) = self.filter_chain {
|
|
// Use a cursor to read the input data
|
|
let mut input_cursor = std::io::Cursor::new(&temp_buf[..bytes_read]);
|
|
// Write filtered output to our buffer
|
|
chain.filter(&mut input_cursor, &mut self.buffer)?;
|
|
|
|
if !self.buffer.is_empty() {
|
|
let bytes_to_copy = std::cmp::min(buf.len(), self.buffer.len());
|
|
buf[..bytes_to_copy].copy_from_slice(&self.buffer[..bytes_to_copy]);
|
|
self.buffer_pos = bytes_to_copy;
|
|
Ok(bytes_to_copy)
|
|
} else {
|
|
// No data produced by filter, try reading more
|
|
Ok(0)
|
|
}
|
|
} else {
|
|
// No filter chain, just pass through
|
|
buf[..bytes_read].copy_from_slice(&temp_buf[..bytes_read]);
|
|
Ok(bytes_read)
|
|
}
|
|
}
|
|
}
|