static void copy_helper(abts_case *tc, const char *from, const char * to,
apr_fileperms_t perms, int append, apr_pool_t *p)
{
apr_status_t rv;
apr_status_t dest_rv;
apr_finfo_t copy;
apr_finfo_t orig;
apr_finfo_t dest;
dest_rv = apr_stat(&dest, to, APR_FINFO_SIZE, p);
if (!append) {
rv = apr_file_copy(from, to, perms, p);
}
else {
rv = apr_file_append(from, to, perms, p);
}
APR_ASSERT_SUCCESS(tc, "Error copying file", rv);
rv = apr_stat(&orig, from, APR_FINFO_SIZE, p);
APR_ASSERT_SUCCESS(tc, "Couldn't stat original file", rv);
rv = apr_stat(©, to, APR_FINFO_SIZE, p);
APR_ASSERT_SUCCESS(tc, "Couldn't stat copy file", rv);
if (!append) {
ABTS_ASSERT(tc, "File size differs", orig.size == copy.size);
}
else {
ABTS_ASSERT(tc, "File size differs",
((dest_rv == APR_SUCCESS)
? dest.size : 0) + orig.size == copy.size);
}
}
void gpdb_import_alert_log(apr_pool_t *pool)
{
// Get alert log files to be imported.
apr_array_header_t* tail_files = apr_array_make(pool, 10, sizeof(char*));
apr_array_header_t* success_append_files = apr_array_make(pool, 10, sizeof(char*));
get_alert_log_tail_files(tail_files, pool);
// Create or truncate stage file.
char *dst_file = apr_pstrcat(pool, GPMON_LOG, "/", GPMON_ALERT_LOG_STAGE, NULL);
apr_status_t status = truncate_file(dst_file, pool);
if (status != APR_SUCCESS)
{
gpmon_warningx(FLINE, 0, "failed truncating stage file:%s", dst_file);
return;
}
// Append alert log tail file to stage file
void *tail_file = NULL;
while ((tail_file = apr_array_pop(tail_files)))
{
char *filename = *(char**)tail_file;
void *success_file_slot = apr_array_push(success_append_files);
if (!success_file_slot)
{
gpmon_warningx(
FLINE, 0, "failed appending file:%s to stage file:%s due to out of memory",
filename, dst_file);
continue;
}
(*(char**)success_file_slot) = NULL;
status = apr_file_append(filename, dst_file, APR_FILE_SOURCE_PERMS, pool);
if (status != APR_SUCCESS)
{
gpmon_warningx(FLINE, status, "failed appending file:%s to stage file:%s", filename, dst_file);
continue;
}
else
{
(*(char**)success_file_slot) = filename;
TR1(("success appending file:%s to stage file:%s\n", filename, dst_file));
}
}
// Insert tail file to history table.
if (gpdb_insert_alert_log())
{
// Delete tail file
gpdb_remove_success_files(success_append_files, pool);
truncate_file(dst_file, pool);
}
}
int lua_apr_file_append(lua_State *L)
{
const char *source, *target;
apr_fileperms_t permissions;
apr_status_t status;
source = luaL_checkstring(L, 1);
target = luaL_checkstring(L, 2);
permissions = check_permissions(L, 3, 1);
status = apr_file_append(source, target, permissions, to_pool(L));
return push_status(L, status);
}
/* append stage data to _tail file */
static apr_status_t append_to_harvest(const char* tbl, apr_pool_t* pool, PGconn* conn)
{
char srcfn[PATH_MAX];
char dstfn[PATH_MAX];
apr_status_t status;
/* make the file names */
snprintf(srcfn, PATH_MAX, "%s%s_stage.dat", GPMON_DIR, tbl);
snprintf(dstfn, PATH_MAX, "%s_%s_tail.dat", GPMON_DIR, tbl);
status = apr_file_append(srcfn, dstfn, APR_FILE_SOURCE_PERMS, pool);
if (status != APR_SUCCESS)
{
gpmon_warningx(FLINE, status, "harvest failed appending %s to %s", srcfn, dstfn);
}
else
{
TR1(("harvest append %s to %s: ok\n", srcfn, dstfn));
}
return status;
}
/* append one file to another. */
void MVM_file_append(MVMThreadContext *tc, MVMString *src, MVMString *dest) {
apr_status_t rv;
char *a, *b, *afull, *bfull;
MVMuint32 len;
apr_pool_t *tmp_pool;
/* need a temporary pool */
if ((rv = apr_pool_create(&tmp_pool, POOL(tc))) != APR_SUCCESS) {
MVM_exception_throw_apr_error(tc, rv, "Failed to append file: ");
}
afull = MVM_file_get_full_path(tc, tmp_pool, a = MVM_string_utf8_encode_C_string(tc, src));
bfull = MVM_file_get_full_path(tc, tmp_pool, b = MVM_string_utf8_encode_C_string(tc, dest));
free(a); free(b);
if ((rv = apr_file_append((const char *)afull, (const char *)bfull,
APR_FPROT_FILE_SOURCE_PERMS, tmp_pool)) != APR_SUCCESS) {
apr_pool_destroy(tmp_pool);
MVM_exception_throw_apr_error(tc, rv, "Failed to append file: ");
}
/* note: destroying the pool deallocates afull, bfull */
apr_pool_destroy(tmp_pool);
}
void nx_expr_proc__xm_fileop_file_append(nx_expr_eval_ctx_t *eval_ctx,
nx_module_t *module,
nx_expr_arg_list_t *args)
{
nx_expr_arg_t *src, *dst;
nx_value_t srcval, dstval;
nx_exception_t e;
apr_status_t rv;
apr_pool_t *pool;
ASSERT(module != NULL);
ASSERT(args != NULL);
src = NX_DLIST_FIRST(args);
ASSERT(src != NULL);
ASSERT(src->expr != NULL);
dst = NX_DLIST_NEXT(src, link);
ASSERT(dst != NULL);
ASSERT(dst->expr != NULL);
nx_expr_evaluate(eval_ctx, &srcval, src->expr);
if ( srcval.defined != TRUE )
{
throw_msg("'src' is undef");
}
if ( srcval.type != NX_VALUE_TYPE_STRING )
{
nx_value_kill(&srcval);
throw_msg("string type required for 'src'");
}
try
{
nx_expr_evaluate(eval_ctx, &dstval, dst->expr);
}
catch(e)
{
nx_value_kill(&srcval);
rethrow(e);
}
if ( dstval.defined != TRUE )
{
nx_value_kill(&srcval);
throw_msg("'dst' is undef");
}
if ( dstval.type != NX_VALUE_TYPE_STRING )
{
nx_value_kill(&dstval);
nx_value_kill(&srcval);
throw_msg("string type required for 'dst'");
}
pool = nx_pool_create_core();
if ( (rv = apr_file_append(srcval.string->buf, dstval.string->buf, APR_FILE_SOURCE_PERMS,
pool)) != APR_SUCCESS )
{
log_aprerror(rv, "failed to append file from '%s' to '%s'",
srcval.string->buf, dstval.string->buf);
}
apr_pool_destroy(pool);
nx_value_kill(&srcval);
nx_value_kill(&dstval);
}
