ucp cr_write_step(FILE *file, cr_proc proc, ucp perm, ucp s, int length) {
ucp nextperm;
nextperm = (*proc)(perm, s, length);
cr_write(file, s, length);
cr_f(perm);
return nextperm;
}
static void
test_contentstating_multiwrite(Outputtest *outputtest,
G_GNUC_UNUSED gconstpointer test_data)
{
CR_FILE *f;
int ret;
cr_ContentStat *stat;
GError *tmp_err = NULL;
const char *content = "sdlkjowykjnhsadyhfsoaf\nasoiuyseahlndsf\n";
const int content_len = 39;
const char *content_sha256 = "c9d112f052ab86270bfb484817a513d6ce188133ddc0"
"7c0fc1ac32018b6da6c7";
// Gz compression
stat = cr_contentstat_new(CR_CHECKSUM_SHA256, &tmp_err);
g_assert(stat);
g_assert(!tmp_err);
f = cr_sopen(outputtest->tmp_filename,
CR_CW_MODE_WRITE,
CR_CW_GZ_COMPRESSION,
stat,
&tmp_err);
g_assert(f);
g_assert(!tmp_err);
ret = cr_write(f, content, 10, &tmp_err);
g_assert_cmpint(ret, ==, 10);
g_assert(!tmp_err);
ret = cr_write(f, content+10, 29, &tmp_err);
g_assert_cmpint(ret, ==, 29);
g_assert(!tmp_err);
cr_close(f, &tmp_err);
g_assert(!tmp_err);
g_assert_cmpint(stat->size, ==, content_len);
g_assert_cmpstr(stat->checksum, ==, content_sha256);
cr_contentstat_free(stat, &tmp_err);
g_assert(!tmp_err);
}
// write to client
static ssize_t rr_write(struct corerouter_peer *main_peer) {
ssize_t len = cr_write(main_peer, "rr_write()");
// end on empty write
if (!len) return 0;
// ok this response chunk is sent, let's start reading again
if (cr_write_complete(main_peer)) {
// reset the buffer
main_peer->out->pos = 0;
cr_reset_hooks(main_peer);
}
return len;
}
// write to backend
static ssize_t rr_instance_write(struct corerouter_peer *peer) {
ssize_t len = cr_write(peer, "rr_instance_write()");
// end on empty write
if (!len) return 0;
// the chunk has been sent, start (again) reading from client and instances
if (cr_write_complete(peer)) {
// reset the buffer
peer->out->pos = 0;
cr_reset_hooks(peer);
}
return len;
}
// send the uwsgi request header and vars
static ssize_t fr_instance_send_request(struct corerouter_peer *peer) {
ssize_t len = cr_write(peer, "fr_instance_send_request()");
// end on empty write
if (!len) return 0;
// the chunk has been sent, start (again) reading from client and instances
if (cr_write_complete(peer)) {
// reset the original read buffer
peer->out->pos = 0;
// start waiting for body
peer->session->main_peer->last_hook_read = fr_read_body;
cr_reset_hooks(peer);
}
return len;
}
void
test_helper_cw_output(int type,
const char *filename,
cr_CompressionType ctype,
const char *content,
int len)
{
int ret;
CR_FILE *file;
GError *tmp_err = NULL;
file = cr_open(filename, CR_CW_MODE_WRITE, ctype, &tmp_err);
g_assert(file);
g_assert(!tmp_err);
switch(type) {
case OUTPUT_TYPE_WRITE:
ret = cr_write(file, content, len, &tmp_err);
g_assert_cmpint(ret, ==, len);
g_assert(!tmp_err);
break;
case OUTPUT_TYPE_PUTS:
ret = cr_puts(file, content, &tmp_err);
g_assert_cmpint(ret, ==, len);
g_assert(!tmp_err);
break;
case OUTPUT_TYPE_PRINTF:
ret = cr_printf(&tmp_err, file, "%s", content);
g_assert_cmpint(ret, ==, len);
g_assert(!tmp_err);
break;
default:
break;
}
ret = cr_close(file, &tmp_err);
g_assert_cmpint(ret, ==, CRE_OK);
g_assert(!tmp_err);
// Read and compare
test_helper_cw_input(filename, ctype, content, len);
}
void cr_to_file(char *file_name, ucp buf, int length) {
FILE *file;
file = fopen(file_name, "wb");
cr_write(file, buf, length);
fclose(file);
}
int
cr_repomd_record_compress_and_fill(cr_RepomdRecord *record,
cr_RepomdRecord *crecord,
cr_ChecksumType checksum_type,
cr_CompressionType record_compression,
GError **err)
{
const char *suffix;
gchar *path, *cpath;
gchar *clocation_real, *clocation_href;
gchar *checksum, *cchecksum;
int readed;
char buf[BUFFER_SIZE];
CR_FILE *cw_plain;
CR_FILE *cw_compressed;
gint64 gf_size = -1, cgf_size = -1;
gint64 gf_time = -1, cgf_time = -1;
struct stat gf_stat, cgf_stat;
const char *checksum_str = cr_checksum_name_str(checksum_type);
GError *tmp_err = NULL;
assert(record);
assert(crecord);
assert(!err || *err == NULL);
if (!(record->location_real) || !strlen(record->location_real)) {
g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_BADARG,
"Empty locations in repomd record object");
return CRE_BADARG;
}
if (!g_file_test(record->location_real, G_FILE_TEST_IS_REGULAR)) {
// File doesn't exists
g_warning("%s: File %s doesn't exists", __func__, record->location_real);
g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_NOFILE,
"File %s doesn't exists or not a regular file",
record->location_real);
return CRE_NOFILE;;
}
// Paths
suffix = cr_compression_suffix(record_compression);
clocation_real = g_strconcat(record->location_real, suffix, NULL);
clocation_href = g_strconcat(record->location_href, suffix, NULL);
crecord->location_real = g_string_chunk_insert(crecord->chunk,
clocation_real);
crecord->location_href = g_string_chunk_insert(crecord->chunk,
clocation_href);
g_free(clocation_real);
g_free(clocation_href);
path = record->location_real;
cpath = crecord->location_real;
// Compress file + get size of non compressed file
cw_plain = cr_open(path,
CR_CW_MODE_READ,
CR_CW_NO_COMPRESSION,
&tmp_err);
if (!cw_plain) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err, "Cannot open %s: ", path);
return code;
}
cw_compressed = cr_open(cpath,
CR_CW_MODE_WRITE,
record_compression,
&tmp_err);
if (!cw_compressed) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err, "Cannot open %s: ", cpath);
return code;
}
while ((readed = cr_read(cw_plain, buf, BUFFER_SIZE, &tmp_err)) > 0) {
cr_write(cw_compressed, buf, (unsigned int) readed, &tmp_err);
if (tmp_err)
break;
}
cr_close(cw_plain, NULL);
if (tmp_err) {
int code = tmp_err->code;
cr_close(cw_compressed, NULL);
g_debug("%s: Error while repomd record compression: %s", __func__,
tmp_err->message);
g_propagate_prefixed_error(err, tmp_err,
"Error while compression %s -> %s:", path, cpath);
return code;
}
cr_close(cw_compressed, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err,
"Error while closing %s: ", path);
return code;
}
// Compute checksums
checksum = cr_checksum_file(path, checksum_type, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err,
"Error while checksum calculation:");
return code;
}
cchecksum = cr_checksum_file(cpath, checksum_type, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err,
"Error while checksum calculation:");
return code;
}
// Get stats
if (stat(path, &gf_stat)) {
g_debug("%s: Error while stat() on %s", __func__, path);
g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_IO,
"Cannot stat %s", path);
return CRE_IO;
} else {
gf_size = gf_stat.st_size;
gf_time = gf_stat.st_mtime;
}
if (stat(cpath, &cgf_stat)) {
g_debug("%s: Error while stat() on %s", __func__, cpath);
g_set_error(err, CR_REPOMD_RECORD_ERROR, CRE_IO,
"Cannot stat %s", cpath);
return CRE_IO;
} else {
cgf_size = cgf_stat.st_size;
cgf_time = cgf_stat.st_mtime;
}
// Results
record->checksum = g_string_chunk_insert(record->chunk, checksum);
record->checksum_type = g_string_chunk_insert(record->chunk, checksum_str);
record->checksum_open = NULL;
record->checksum_open_type = NULL;
record->timestamp = gf_time;
record->size = gf_size;
record->size_open = -1;
crecord->checksum = g_string_chunk_insert(crecord->chunk, cchecksum);
crecord->checksum_type = g_string_chunk_insert(crecord->chunk, checksum_str);
crecord->checksum_open = g_string_chunk_insert(record->chunk, checksum);
crecord->checksum_open_type = g_string_chunk_insert(record->chunk, checksum_str);
crecord->timestamp = cgf_time;
crecord->size = cgf_size;
crecord->size_open = gf_size;
g_free(checksum);
g_free(cchecksum);
return CRE_OK;
}
