diff options
author | Vicent Marti <tanoku@gmail.com> | 2012-05-19 03:46:11 +0400 |
---|---|---|
committer | Vicent Marti <tanoku@gmail.com> | 2012-05-19 03:46:11 +0400 |
commit | 5b9fac39d8a76b9139667c26a63e6b3f204b3977 (patch) | |
tree | e6ba28025f92c16563c4ffa8bc60b95f17d69691 /src/blob.c | |
parent | 7ef9f1b5606c2672105ecbbf34c022a71ef212fe (diff) | |
parent | ad5df35a47d56c3d716d7a56eac4aeb611987c11 (diff) |
Merge branch 'development'v0.17.0
Conflicts:
.travis.yml
Diffstat (limited to 'src/blob.c')
-rw-r--r-- | src/blob.c | 233 |
1 files changed, 165 insertions, 68 deletions
diff --git a/src/blob.c b/src/blob.c index 7497ba7bf..e25944b91 100644 --- a/src/blob.c +++ b/src/blob.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2009-2011 the libgit2 contributors + * Copyright (C) 2009-2012 the libgit2 contributors * * This file is part of libgit2, distributed under the GNU GPL v2 with * a Linking Exception. For full terms see the included COPYING file. @@ -11,6 +11,7 @@ #include "common.h" #include "blob.h" +#include "filter.h" const void *git_blob_rawcontent(git_blob *blob) { @@ -24,6 +25,12 @@ size_t git_blob_rawsize(git_blob *blob) return blob->odb_object->raw.len; } +int git_blob__getbuf(git_buf *buffer, git_blob *blob) +{ + return git_buf_set( + buffer, blob->odb_object->raw.data, blob->odb_object->raw.len); +} + void git_blob__free(git_blob *blob) { git_odb_object_free(blob->odb_object); @@ -35,7 +42,7 @@ int git_blob__parse(git_blob *blob, git_odb_object *odb_obj) assert(blob); git_cached_obj_incref((git_cached_obj *)odb_obj); blob->odb_object = odb_obj; - return GIT_SUCCESS; + return 0; } int git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *buffer, size_t len) @@ -44,99 +51,189 @@ int git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *b git_odb *odb; git_odb_stream *stream; - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) + if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 || + (error = git_odb_open_wstream(&stream, odb, len, GIT_OBJ_BLOB)) < 0) return error; - if ((error = git_odb_open_wstream(&stream, odb, len, GIT_OBJ_BLOB)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to create blob"); + if ((error = stream->write(stream, buffer, len)) == 0) + error = stream->finalize_write(oid, stream); - if ((error = stream->write(stream, buffer, len)) < GIT_SUCCESS) { - stream->free(stream); + stream->free(stream); + return error; +} + +static int write_file_stream( + git_oid *oid, git_odb *odb, const char *path, git_off_t file_size) +{ + int fd, error; + char buffer[4096]; + git_odb_stream *stream = NULL; + + if ((error = git_odb_open_wstream( + &stream, odb, (size_t)file_size, GIT_OBJ_BLOB)) < 0) return error; + + if ((fd = git_futils_open_ro(path)) < 0) { + stream->free(stream); + return -1; } - error = stream->finalize_write(oid, stream); - stream->free(stream); + while (!error && file_size > 0) { + ssize_t read_len = p_read(fd, buffer, sizeof(buffer)); + + if (read_len < 0) { + giterr_set( + GITERR_OS, "Failed to create blob. Can't read whole file"); + error = -1; + } + else if (!(error = stream->write(stream, buffer, read_len))) + file_size -= read_len; + } + + p_close(fd); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to create blob"); + if (!error) + error = stream->finalize_write(oid, stream); - return GIT_SUCCESS; + stream->free(stream); + return error; } -int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path) +static int write_file_filtered( + git_oid *oid, + git_odb *odb, + const char *full_path, + git_vector *filters) { - int error = GIT_SUCCESS; - int islnk = 0; - int fd = 0; - git_buf full_path = GIT_BUF_INIT; - char buffer[2048]; - git_off_t size; - git_odb_stream *stream = NULL; - struct stat st; - const char *workdir; - git_odb *odb; - - workdir = git_repository_workdir(repo); - if (workdir == NULL) - return git__throw(GIT_ENOTFOUND, "Failed to create blob. (No working directory found)"); + int error; + git_buf source = GIT_BUF_INIT; + git_buf dest = GIT_BUF_INIT; - error = git_buf_joinpath(&full_path, workdir, path); - if (error < GIT_SUCCESS) + if ((error = git_futils_readbuffer(&source, full_path)) < 0) return error; - error = p_lstat(full_path.ptr, &st); - if (error < 0) { - error = git__throw(GIT_EOSERR, "Failed to stat blob. %s", strerror(errno)); - goto cleanup; - } + error = git_filters_apply(&dest, &source, filters); - islnk = S_ISLNK(st.st_mode); - size = st.st_size; + /* Free the source as soon as possible. This can be big in memory, + * and we don't want to ODB write to choke */ + git_buf_free(&source); - error = git_repository_odb__weakptr(&odb, repo); - if (error < GIT_SUCCESS) - goto cleanup; + /* Write the file to disk if it was properly filtered */ + if (!error) + error = git_odb_write(oid, odb, dest.ptr, dest.size, GIT_OBJ_BLOB); - if (!islnk) { - if ((fd = p_open(full_path.ptr, O_RDONLY)) < 0) { - error = git__throw(GIT_ENOTFOUND, "Failed to create blob. Could not open '%s'", full_path.ptr -); - goto cleanup; - } + git_buf_free(&dest); + return error; +} + +static int write_symlink( + git_oid *oid, git_odb *odb, const char *path, size_t link_size) +{ + char *link_data; + ssize_t read_len; + int error; + + link_data = git__malloc(link_size); + GITERR_CHECK_ALLOC(link_data); + + read_len = p_readlink(path, link_data, link_size); + if (read_len != (ssize_t)link_size) { + giterr_set(GITERR_OS, "Failed to create blob. Can't read symlink '%s'", path); + git__free(link_data); + return -1; } - if ((error = git_odb_open_wstream(&stream, odb, (size_t)size, GIT_OBJ_BLOB)) < GIT_SUCCESS) - goto cleanup; + error = git_odb_write(oid, odb, (void *)link_data, link_size, GIT_OBJ_BLOB); + git__free(link_data); + return error; +} - while (size > 0) { - ssize_t read_len; +static int blob_create_internal(git_oid *oid, git_repository *repo, const char *path) +{ + int error; + struct stat st; + git_odb *odb = NULL; + git_off_t size; - if (!islnk) - read_len = p_read(fd, buffer, sizeof(buffer)); - else - read_len = p_readlink(full_path.ptr, buffer, sizeof(buffer)); + if ((error = git_path_lstat(path, &st)) < 0 || (error = git_repository_odb__weakptr(&odb, repo)) < 0) + return error; - if (read_len < 0) { - error = git__throw(GIT_EOSERR, "Failed to create blob. Can't read full file"); - goto cleanup; + size = st.st_size; + + if (S_ISLNK(st.st_mode)) { + error = write_symlink(oid, odb, path, (size_t)size); + } else { + git_vector write_filters = GIT_VECTOR_INIT; + int filter_count; + + /* Load the filters for writing this file to the ODB */ + filter_count = git_filters_load( + &write_filters, repo, path, GIT_FILTER_TO_ODB); + + if (filter_count < 0) { + /* Negative value means there was a critical error */ + error = filter_count; + } else if (filter_count == 0) { + /* No filters need to be applied to the document: we can stream + * directly from disk */ + error = write_file_stream(oid, odb, path, size); + } else { + /* We need to apply one or more filters */ + error = write_file_filtered(oid, odb, path, &write_filters); } - stream->write(stream, buffer, read_len); - size -= read_len; + git_filters_free(&write_filters); + + /* + * TODO: eventually support streaming filtered files, for files + * which are bigger than a given threshold. This is not a priority + * because applying a filter in streaming mode changes the final + * size of the blob, and without knowing its final size, the blob + * cannot be written in stream mode to the ODB. + * + * The plan is to do streaming writes to a tempfile on disk and then + * opening streaming that file to the ODB, using + * `write_file_stream`. + * + * CAREFULLY DESIGNED APIS YO + */ } - error = stream->finalize_write(oid, stream); + return error; +} -cleanup: - if (stream) - stream->free(stream); - if (!islnk && fd) - p_close(fd); - git_buf_free(&full_path); +int git_blob_create_fromfile(git_oid *oid, git_repository *repo, const char *path) +{ + git_buf full_path = GIT_BUF_INIT; + const char *workdir; + int error; + + workdir = git_repository_workdir(repo); + assert(workdir); /* error to call this on bare repo */ + + if (git_buf_joinpath(&full_path, workdir, path) < 0) { + git_buf_free(&full_path); + return -1; + } - return error == GIT_SUCCESS ? GIT_SUCCESS : - git__rethrow(error, "Failed to create blob"); + error = blob_create_internal(oid, repo, git_buf_cstr(&full_path)); + + git_buf_free(&full_path); + return error; } +int git_blob_create_fromdisk(git_oid *oid, git_repository *repo, const char *path) +{ + int error; + git_buf full_path = GIT_BUF_INIT; + + if ((error = git_path_prettify(&full_path, path, NULL)) < 0) { + git_buf_free(&full_path); + return error; + } + + error = blob_create_internal(oid, repo, git_buf_cstr(&full_path)); + + git_buf_free(&full_path); + return error; +} |