Function odb_transaction_files_write_object_stream

object-file.c:1299–1356

* This writes the specified object to a packfile. Objects written here * during the same transaction are written to the same packfile. The * packfile is not flushed until the transaction is flushed. The caller * is expected to ensure a valid transaction is setup for objects to be * recorded to. * * This also bypasses the usual "convert-to-git" dance, and that is on * purpose. We could write

 * callers should avoid this code path when filters are requested.
 */
static int odb_transaction_files_write_object_stream(struct odb_transaction *base,
						     struct odb_write_stream *stream,
						     size_t size,
						     struct object_id *result_oid)
{
	struct odb_transaction_files *transaction = container_of(base,
								 struct odb_transaction_files,
								 base);
	struct transaction_packfile *state = &transaction->packfile;
	struct git_hash_ctx ctx;
	unsigned char obuf[16384];
	unsigned header_len;
	struct hashfile_checkpoint checkpoint;
	struct pack_idx_entry *idx;

	header_len = format_object_header((char *)obuf, sizeof(obuf),
					  OBJ_BLOB, size);
	transaction->base.source->odb->repo->hash_algo->init_fn(&ctx);
	git_hash_update(&ctx, obuf, header_len);

	/*
	 * If writing another object to the packfile could result in it
	 * exceeding the configured size limit, flush the current packfile
	 * transaction.
	 *
	 * Note that this uses the inflated object size as an approximation.
	 * Blob objects written in this manner are not delta-compressed, so
	 * the difference between the inflated and on-disk size is limited
	 * to zlib compression and is sufficient for this check.
	 */
	if (state->nr_written && pack_size_limit_cfg &&
	    pack_size_limit_cfg < state->offset + size)
		flush_packfile_transaction(transaction);

	CALLOC_ARRAY(idx, 1);
	prepare_packfile_transaction(transaction);
	hashfile_checkpoint_init(state->f, &checkpoint);

	hashfile_checkpoint(state->f, &checkpoint);
	idx->offset = state->offset;
	crc32_begin(state->f);
	stream_blob_to_pack(state, &ctx, size, stream);
	git_hash_final_oid(result_oid, &ctx);

	idx->crc32 = crc32_end(state->f);
	if (already_written(transaction, result_oid)) {
		hashfile_truncate(state->f, &checkpoint);
		state->offset = checkpoint.offset;
		free(idx);
	} else {
		oidcpy(&idx->oid, result_oid);
		ALLOC_GROW(state->written,
			   state->nr_written + 1,
			   state->alloc_written);
		state->written[state->nr_written++] = idx;
	}
	return 0;
}