oxen-server 0.48.1

Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::errors::OxenHttpError;
use crate::helpers::get_repo;
use crate::params::{app_data, parse_resource, path_param};

use liboxen::error::OxenError;

use liboxen::view::StatusMessage;
use liboxen::view::entries::EMetadataEntry;
use liboxen::view::entry_metadata::EMetadataEntryResponseView;
use liboxen::{current_function, repositories};

use actix_web::{HttpRequest, HttpResponse};
use utoipa;

/// Get file metadata
#[utoipa::path(
    get,
    path = "/api/repos/{namespace}/{repo_name}/metadata/{resource}",
    tag = "Metadata",
    description = "Get metadata for a file or directory entry, with optional workspace support.",
    params(
        ("namespace" = String, Path, description = "Namespace of the repository", example = "ox"),
        ("repo_name" = String, Path, description = "Name of the repository", example = "ImageNet-1k"),
        ("resource" = String, Path, description = "Path to the file/dir (including branch/commit info)", example = "main/images/train/dog_1.jpg"),
    ),
    responses(
        (status = 200, description = "Metadata for the entry found", body = EMetadataEntryResponseView),
        (status = 404, description = "Entry not found"),
        (status = 400, description = "Invalid resource path")
    )
)]
pub async fn file(req: HttpRequest) -> actix_web::Result<HttpResponse, OxenHttpError> {
    let app_data = app_data(&req)?;
    let namespace = path_param(&req, "namespace")?.to_string();
    let repo_name = path_param(&req, "repo_name")?.to_string();
    let repo = get_repo(&app_data.path, namespace, &repo_name)?;
    let resource = parse_resource(&req, &repo)?;
    let workspace_ref = resource.workspace.as_ref();

    let commit = if let Some(workspace) = workspace_ref {
        workspace.commit.clone()
    } else {
        resource.clone().commit.unwrap()
    };

    log::debug!(
        "{} resource {}/{}",
        current_function!(),
        repo_name,
        resource
    );

    let latest_commit = repositories::commits::get_by_id(&repo, &commit.id)?
        .ok_or_else(|| OxenError::RevisionNotFound(commit.id.as_str().into()))?;

    log::debug!(
        "{} resolve commit {} -> '{}'",
        current_function!(),
        latest_commit.id,
        latest_commit.message
    );

    let meta = if let Some(workspace) = resource.workspace.as_ref() {
        match repositories::entries::get_meta_entry(&repo, &commit, &resource.path) {
            Ok(entry) => {
                let mut entry = repositories::workspaces::populate_entry_with_workspace_data(
                    resource.path.as_ref(),
                    entry.clone(),
                    workspace,
                )?;
                entry.set_resource(Some(resource.clone()));
                EMetadataEntryResponseView {
                    status: StatusMessage::resource_found(),
                    entry,
                }
            }
            Err(_) => {
                let added_entry = repositories::workspaces::get_added_entry(
                    &repo,
                    &resource.path,
                    workspace,
                    &resource,
                )?;
                EMetadataEntryResponseView {
                    status: StatusMessage::resource_found(),
                    entry: added_entry,
                }
            }
        }
    } else {
        let mut entry = repositories::entries::get_meta_entry(&repo, &commit, &resource.path)?;
        entry.resource = Some(resource.clone());
        EMetadataEntryResponseView {
            status: StatusMessage::resource_found(),
            entry: EMetadataEntry::MetadataEntry(entry),
        }
    };

    Ok(HttpResponse::Ok().json(meta))
}

/// Update file metadata
#[utoipa::path(
    put,
    path = "/api/repos/{namespace}/{repo_name}/metadata/{resource}",
    tag = "Metadata",
    description = "Update metadata for a file version in the version store.",
    params(
        ("namespace" = String, Path, description = "Namespace of the repository", example = "ox"),
        ("repo_name" = String, Path, description = "Name of the repository", example = "ImageNet-1k"),
        ("resource" = String, Path, description = "Path to the file (including version to update)", example = "versions/files/b4/158b417c800c7322d711f1816f5c00e1215b4d7c001c9b6892556d11/data"),
    ),
    responses(
        (status = 200, description = "Metadata updated", body = StatusMessage),
        (status = 400, description = "Missing version in resource path"),
        (status = 404, description = "Repository not found")
    )
)]
pub async fn update_metadata(req: HttpRequest) -> actix_web::Result<HttpResponse, OxenHttpError> {
    let app_data = app_data(&req)?;
    let namespace = path_param(&req, "namespace")?.to_string();
    let repo_name = path_param(&req, "repo_name")?.to_string();
    let repo = get_repo(&app_data.path, &namespace, &repo_name)?;
    let resource = parse_resource(&req, &repo)?;

    let version_str = resource
        .version
        .to_str()
        .ok_or_else(|| OxenHttpError::BadRequest("Missing resource version".into()))?;

    repositories::entries::update_metadata(&repo, version_str)?;
    Ok(HttpResponse::Ok().json(StatusMessage::resource_updated()))
}