lobo/isync
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4ae0159132
isync/src/drv_proxy.c

417 lines
11 KiB
C
Raw Normal View History

convert licensing to SPDX while at it, add/fix some licenses/copyrights/comments: - it makes no sense to have a GPL exception in scripts - ted did not contribute to the man page - tst_timers is not part of the mbsync executable - explicitly put the build system under GPL and add copyrights
2022-06-16 10:44:35 +00:00
// SPDX-FileCopyrightText: 2017-2022 Oswald Buddenhagen <ossi@users.sf.net>
// SPDX-License-Identifier: GPL-2.0-or-later WITH LicenseRef-isync-GPL-exception
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
/*
* mbsync - mailbox synchronizer
*/
turn debug() functions into macros this makes calling them with more expensive arguments efficient without wrapping them into additional conditionals.
2021-12-21 17:44:39 +00:00
#define DEBUG_FLAG DEBUG_DRV
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
#include "driver.h"
add debug pretty-printing for OPEN_* flags as well
2022-06-05 08:49:21 +00:00
BIT_FORMATTER_FUNCTION(opts, OPEN)
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
typedef struct gen_cmd gen_cmd_t;
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
typedef union proxy_store {
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
store_t gen;
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
struct {
STORE(union proxy_store)
const char *label; // foreign
uint ref_count;
driver_t *real_driver;
store_t *real_store;
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
gen_cmd_t *pending_cmds, **pending_cmds_append;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
gen_cmd_t *check_cmds, **check_cmds_append;
wakeup_t wakeup;
test also one-sided async operation this tests only the common case of the far side being async - adding 100% instead of 50% to the runtime of the test to cover a corner case didn't seem worth it.
2022-06-01 11:54:48 +00:00
char force_async;
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
void (*expunge_callback)( message_t *msg, void *aux );
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
void (*bad_callback)( void *aux );
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
void *callback_aux;
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
};
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
} proxy_store_t;
static void
proxy_store_deref( proxy_store_t *ctx )
{
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
if (!--ctx->ref_count) {
assert( !pending_wakeup( &ctx->wakeup ) );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
free( ctx );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
}
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
}
static int curr_tag;
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
#define GEN_CMD \
uint ref_count; \
int tag; \
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
proxy_store_t *ctx; \
gen_cmd_t *next; \
void (*queued_cb)( gen_cmd_t *gcmd );
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
struct gen_cmd {
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
GEN_CMD
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
};
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
static gen_cmd_t *
fix lots of sign conversion warnings ... by making a lot of objects unsigned, and some signed. casts which lose precision and change the sign in one go (ssize_t and time_t to uint on LP64) are made explicit as well.
2020-07-08 15:27:37 +00:00
proxy_cmd_new( proxy_store_t *ctx, uint sz )
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
{
gen_cmd_t *cmd = nfmalloc( sz );
cmd->ref_count = 2;
cmd->tag = ++curr_tag;
cmd->ctx = ctx;
ctx->ref_count++;
return cmd;
}
static void
proxy_cmd_done( gen_cmd_t *cmd )
{
if (!--cmd->ref_count) {
proxy_store_deref( cmd->ctx );
free( cmd );
}
}
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
static void
proxy_wakeup( void *aux )
{
proxy_store_t *ctx = (proxy_store_t *)aux;
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
gen_cmd_t *cmd = ctx->pending_cmds;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
assert( cmd );
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
if (!(ctx->pending_cmds = cmd->next))
ctx->pending_cmds_append = &ctx->pending_cmds;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
else
conf_wakeup( &ctx->wakeup, 0 );
cmd->queued_cb( cmd );
proxy_cmd_done( cmd );
}
static void
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_invoke( gen_cmd_t *cmd, int checked, const char *name )
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
{
test also one-sided async operation this tests only the common case of the far side being async - adding 100% instead of 50% to the runtime of the test to cover a corner case didn't seem worth it.
2022-06-01 11:54:48 +00:00
proxy_store_t *ctx = cmd->ctx;
if (ctx->force_async) {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
debug( "%s[% 2d] Queue %s%s\n", ctx->label, cmd->tag, name, checked ? " (checked)" : "" );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
cmd->next = NULL;
if (checked) {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
*ctx->check_cmds_append = cmd;
ctx->check_cmds_append = &cmd->next;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
} else {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
*ctx->pending_cmds_append = cmd;
ctx->pending_cmds_append = &cmd->next;
conf_wakeup( &ctx->wakeup, 0 );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
}
} else {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
cmd->queued_cb( cmd );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
proxy_cmd_done( cmd );
}
}
static void
proxy_flush_checked_cmds( proxy_store_t *ctx )
{
if (ctx->check_cmds) {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
*ctx->pending_cmds_append = ctx->check_cmds;
ctx->pending_cmds_append = ctx->check_cmds_append;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
ctx->check_cmds_append = &ctx->check_cmds;
ctx->check_cmds = NULL;
conf_wakeup( &ctx->wakeup, 0 );
}
}
static void
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_cancel_queued_cmds( proxy_store_t *ctx )
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
{
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
if (ctx->pending_cmds || ctx->check_cmds) {
// This would involve directly invoking the result callbacks with
// DRV_CANCEL, for which we'd need another set of dispatch functions.
// The autotest doesn't need that, so save the effort.
error( "Fatal: Faking asynchronous cancelation is not supported.\n" );
abort();
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
}
}
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
#if 0
//# TEMPLATE GETTER
static @type@proxy_@name@( store_t *gctx )
{
proxy_store_t *ctx = (proxy_store_t *)gctx;
@type@rv = ctx->real_driver->@name@( ctx->real_store );
debug( "%sCalled @name@, ret=@fmt@\n", ctx->label, rv );
return rv;
}
//# END
//# TEMPLATE REGULAR
static @type@proxy_@name@( store_t *gctx@decl_args@ )
{
proxy_store_t *ctx = (proxy_store_t *)gctx;
@pre_print_args@
debug( "%sEnter @name@@print_fmt_args@\n", ctx->label@print_pass_args@ );
@print_args@
@type@rv = ctx->real_driver->@name@( ctx->real_store@pass_args@ );
add debug pretty-printing for OPEN_* flags as well
2022-06-05 08:49:21 +00:00
debug( "%sLeave @name@, ret=@print_fmt_ret@\n", ctx->label, @print_pass_ret@ );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
return rv;
}
//# END
//# TEMPLATE REGULAR_VOID
add some error checking to proxy template processor debugging is a lot easier when the unconsumed (and therefore likely mistyped) replacements are complained about.
2020-12-17 21:03:06 +00:00
static @type@proxy_@name@( store_t *gctx@decl_args@ )
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
{
proxy_store_t *ctx = (proxy_store_t *)gctx;
@pre_print_args@
debug( "%sEnter @name@@print_fmt_args@\n", ctx->label@print_pass_args@ );
@print_args@
ctx->real_driver->@name@( ctx->real_store@pass_args@ );
debug( "%sLeave @name@\n", ctx->label );
@action@
}
//# END
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
//# TEMPLATE CALLBACK_VOID
debug( "%s[% 2d] Callback enter @name@\n", ctx->label, cmd->tag );
@print_cb_args@
//# END
//# TEMPLATE CALLBACK_STS
debug( "%s[% 2d] Callback enter @name@, sts=%d\n", ctx->label, cmd->tag, sts );
//# END
//# TEMPLATE CALLBACK_STS_PRN
debug( "%s[% 2d] Callback enter @name@, sts=%d\n", ctx->label, cmd->tag, sts );
if (sts == DRV_OK) {
@print_cb_args@
}
//# END
//# TEMPLATE CALLBACK_STS_FMT
if (sts == DRV_OK) {
debug( "%s[% 2d] Callback enter @name@, sts=" stringify(DRV_OK) "@print_fmt_cb_args@\n", ctx->label, cmd->tag@print_pass_cb_args@ );
@print_cb_args@
} else {
debug( "%s[% 2d] Callback enter @name@, sts=%d\n", ctx->label, cmd->tag, sts );
}
//# END
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# TEMPLATE CALLBACK
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
typedef union {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
gen_cmd_t gen;
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
struct {
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
GEN_CMD
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
void (*callback)( @decl_cb_args@void *aux );
void *callback_aux;
@decl_state@
};
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
} @name@_cmd_t;
static void
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_@name@_cb( @decl_cb_args@void *aux )
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
{
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
@name@_cmd_t *cmd = (@name@_cmd_t *)aux;
proxy_store_t *ctx = cmd->ctx;
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
@count_step@
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
@print_cb_args_tpl@
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
cmd->callback( @pass_cb_args@cmd->callback_aux );
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
debug( "%s[% 2d] Callback leave @name@\n", ctx->label, cmd->tag );
proxy_cmd_done( &cmd->gen );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
}
static void
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_do_@name@( gen_cmd_t *gcmd )
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
{
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
@name@_cmd_t *cmd = (@name@_cmd_t *)gcmd;
proxy_store_t *ctx = cmd->ctx;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
@pre_print_args@
debug( "%s[% 2d] Enter @name@@print_fmt_args@\n", ctx->label, cmd->tag@print_pass_args@ );
@print_args@
ctx->real_driver->@name@( ctx->real_store@pass_args@, proxy_@name@_cb, cmd );
debug( "%s[% 2d] Leave @name@\n", ctx->label, cmd->tag );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
}
add some error checking to proxy template processor debugging is a lot easier when the unconsumed (and therefore likely mistyped) replacements are complained about.
2020-12-17 21:03:06 +00:00
static @type@proxy_@name@( store_t *gctx@decl_args@, void (*cb)( @decl_cb_args@void *aux ), void *aux )
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
{
proxy_store_t *ctx = (proxy_store_t *)gctx;
@name@_cmd_t *cmd = (@name@_cmd_t *)proxy_cmd_new( ctx, sizeof(@name@_cmd_t) );
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
cmd->queued_cb = proxy_do_@name@;
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
cmd->callback = cb;
cmd->callback_aux = aux;
@assign_state@
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_invoke( &cmd->gen, @checked@, "@name@" );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
}
//# END
//# UNDEFINE list_store_print_fmt_cb_args
//# UNDEFINE list_store_print_pass_cb_args
//# DEFINE list_store_print_cb_args
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
for (string_list_t *box = boxes; box; box = box->next)
debug( " %s\n", box->string );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# END
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
//# DEFINE create_box_counted 1
//# DEFINE delete_box_counted 1
add debug pretty-printing for OPEN_* flags as well
2022-06-05 08:49:21 +00:00
//# DEFINE prepare_load_box_print_fmt_args , opts=%s
//# DEFINE prepare_load_box_print_pass_args , fmt_opts( opts ).str
//# DEFINE prepare_load_box_print_fmt_ret %s
//# DEFINE prepare_load_box_print_pass_ret fmt_opts( rv ).str
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE load_box_pre_print_args
make some string buffers non-static this was clearly bogus; these are short-lived local variables. amends 4cc5ad5a.
2021-12-23 22:12:11 +00:00
char ubuf[12];
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# END
fix loading of some messages' sizes in some partial sync scenarios we need to pass a different "boundary" UID to driver_t::load_box() for every OPEN_* flag that queries a partial range: - OPEN_FIND refers to messages newer than all we know about - OPEN_OLD_IDS refers to messages which are paired - OPEN_{OLD,NEW}_SIZE refers to messages (not) above the committed boundary of already propagated messages we treated the 3rd like the 2nd, which was just wrong - the actual boundary may be lower or higher, so we'd produce wrong results when MaxSize was set and only one of New and ReNew was requested.
2019-12-29 10:52:26 +00:00
//# DEFINE load_box_print_fmt_args , [%u,%s] (find >= %u, paired <= %u, new > %u)
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
//# DEFINE load_box_print_pass_args , cmd->minuid, (cmd->maxuid == UINT_MAX) ? "inf" : (nfsnprintf( ubuf, sizeof(ubuf), "%u", cmd->maxuid ), ubuf), cmd->finduid, cmd->pairuid, cmd->newuid
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE load_box_print_args
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
if (cmd->excs.size) {
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
debugn( " excs:" );
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
for (uint t = 0; t < cmd->excs.size; t++)
debugn( " %u", cmd->excs.data[t] );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
debug( "\n" );
}
//# END
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
//# DEFINE load_box_print_fmt_cb_args , total=%d, recent=%d
//# DEFINE load_box_print_pass_cb_args , total_msgs, recent_msgs
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE load_box_print_cb_args
heed M_DEAD more thoroughly this doesn't really fix anything under current conditions, as so far only Maildir driver functions that modify known messages can cause concurrent expunges to be detected, and we don't call any of these before the so far unchecked loops.
2022-01-03 15:53:43 +00:00
for (message_t *msg = msgs; msg; msg = msg->next) {
if (msg->status & M_DEAD)
continue;
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
debug( " uid=%-5u flags=%-4s size=%-6u tuid=%." stringify(TUIDL) "s\n",
msg->uid, (msg->status & M_FLAGS) ? fmt_flags( msg->flags ).str : "?", msg->size, *msg->tuid ? msg->tuid : "?" );
heed M_DEAD more thoroughly this doesn't really fix anything under current conditions, as so far only Maildir driver functions that modify known messages can cause concurrent expunges to be detected, and we don't call any of these before the so far unchecked loops.
2022-01-03 15:53:43 +00:00
}
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# END
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
//# UNDEFINE find_new_msgs_print_fmt_cb_args
//# UNDEFINE find_new_msgs_print_pass_cb_args
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE find_new_msgs_print_cb_args
heed M_DEAD more thoroughly this doesn't really fix anything under current conditions, as so far only Maildir driver functions that modify known messages can cause concurrent expunges to be detected, and we don't call any of these before the so far unchecked loops.
2022-01-03 15:53:43 +00:00
for (message_t *msg = msgs; msg; msg = msg->next) {
if (msg->status & M_DEAD)
continue;
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
debug( " uid=%-5u tuid=%." stringify(TUIDL) "s\n", msg->uid, msg->tuid );
heed M_DEAD more thoroughly this doesn't really fix anything under current conditions, as so far only Maildir driver functions that modify known messages can cause concurrent expunges to be detected, and we don't call any of these before the so far unchecked loops.
2022-01-03 15:53:43 +00:00
}
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# END
make UIDs unsigned complies with the IMAP spec, thus removing the (not really) arbitrary limitation to INT_MAX for UIDs.
2017-03-21 19:05:29 +00:00
//# DEFINE fetch_msg_print_fmt_args , uid=%u, want_flags=%s, want_date=%s
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
//# DEFINE fetch_msg_print_pass_args , cmd->msg->uid, !(cmd->msg->status & M_FLAGS) ? "yes" : "no", cmd->data->date ? "yes" : "no"
fix lots of sign conversion warnings ... by making a lot of objects unsigned, and some signed. casts which lose precision and change the sign in one go (ssize_t and time_t to uint on LP64) are made explicit as well.
2020-07-08 15:27:37 +00:00
//# DEFINE fetch_msg_print_fmt_cb_args , flags=%s, date=%lld, size=%u
streamline pretty-printing of message flags wrap make_flags() into fmt_flags() which returns a (struct-wrapped) string, so the calls can be inlined into the printf statements, without reserving buffers. we locally force optimization, so copy elision is always done, as debug builds would otherwise suffer a somewhat unreasonable performance hit.
2022-06-15 15:17:23 +00:00
//# DEFINE fetch_msg_print_pass_cb_args , fmt_flags( cmd->data->flags ).str, (long long)cmd->data->date, cmd->data->len
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE fetch_msg_print_cb_args
fix invalid data accesses in proxy driver callbacks all printing of auxiliary callback arguments must be conditional on the command having actually succeeded. this affected fetch_msg() most, which outright crashed due to a null pointer deref. to fix this for good, we automate the generation of the status printing and checking. as a side effect, this fixes the fetch_msg() callback not printing the status at all. amends 4cc5ad5a.
2021-12-23 22:51:42 +00:00
if (DFlags & DEBUG_DRV_ALL) {
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
printf( "%s=========\n", cmd->ctx->label );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
fwrite( cmd->data->data, cmd->data->len, 1, stdout );
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
printf( "%s=========\n", cmd->ctx->label );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
fflush( stdout );
}
//# END
fix lots of sign conversion warnings ... by making a lot of objects unsigned, and some signed. casts which lose precision and change the sign in one go (ssize_t and time_t to uint on LP64) are made explicit as well.
2020-07-08 15:27:37 +00:00
//# DEFINE store_msg_print_fmt_args , flags=%s, date=%lld, size=%u, to_trash=%s
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
//# DEFINE store_msg_print_pass_args , fmt_flags( cmd->data->flags ).str, (long long)cmd->data->date, cmd->data->len, cmd->to_trash ? "yes" : "no"
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE store_msg_print_args
if (DFlags & DEBUG_DRV_ALL) {
printf( "%s>>>>>>>>>\n", ctx->label );
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
fwrite( cmd->data->data, cmd->data->len, 1, stdout );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
printf( "%s>>>>>>>>>\n", ctx->label );
fflush( stdout );
}
//# END
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
//# DEFINE store_msg_counted 1
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
//# DEFINE set_msg_flags_checked 1
make UIDs unsigned complies with the IMAP spec, thus removing the (not really) arbitrary limitation to INT_MAX for UIDs.
2017-03-21 19:05:29 +00:00
//# DEFINE set_msg_flags_print_fmt_args , uid=%u, add=%s, del=%s
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
//# DEFINE set_msg_flags_print_pass_args , cmd->uid, fmt_flags( cmd->add ).str, fmt_flags( cmd->del ).str
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
//# DEFINE set_msg_flags_counted 1
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
make UIDs unsigned complies with the IMAP spec, thus removing the (not really) arbitrary limitation to INT_MAX for UIDs.
2017-03-21 19:05:29 +00:00
//# DEFINE trash_msg_print_fmt_args , uid=%u
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
//# DEFINE trash_msg_print_pass_args , cmd->msg->uid
rework interrupt-resume autotesting instead of doing two runs for each journal entry, do one run for each "write" operation, be it a journal entry or a writing driver call. this saves runs between which no visible change occurred, which yields a 33% improvement in runtime. we now also exclude the final entry purge from the test, as it's really kinda pointless, and we'd have to jump through additional hoops (simulate an atomic commit of the state) to make it reliable in all cases. note that this also adds a few steps, which actually uncovered a bug in the expunge sequencing. amends efd72b85.
2022-03-01 14:16:07 +00:00
//# DEFINE trash_msg_counted 1
//# DEFINE close_box_counted 1
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
//# DEFINE commit_cmds_print_args
proxy_flush_checked_cmds( ctx );
//# END
//# DEFINE cancel_cmds_print_cb_args
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_cancel_queued_cmds( ctx );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
//# END
//# DEFINE free_store_print_args
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_cancel_queued_cmds( ctx );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
//# END
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE free_store_action
proxy_store_deref( ctx );
//# END
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
//# DEFINE cancel_store_print_args
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
proxy_cancel_queued_cmds( ctx );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
//# END
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
//# DEFINE cancel_store_action
proxy_store_deref( ctx );
//# END
#endif
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
//# SPECIAL set_callbacks
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
static void
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
proxy_set_callbacks( store_t *gctx, void (*exp_cb)( message_t *, void * ),
void (*bad_cb)( void * ), void *aux )
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
{
proxy_store_t *ctx = (proxy_store_t *)gctx;
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
ctx->expunge_callback = exp_cb;
ctx->bad_callback = bad_cb;
ctx->callback_aux = aux;
}
static void
proxy_invoke_expunge_callback( message_t *msg, proxy_store_t *ctx )
{
ctx->ref_count++;
debug( "%sCallback enter expunged message %u\n", ctx->label, msg->uid );
ctx->expunge_callback( msg, ctx->callback_aux );
debug( "%sCallback leave expunged message %u\n", ctx->label, msg->uid );
proxy_store_deref( ctx );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
}
static void
proxy_invoke_bad_callback( proxy_store_t *ctx )
{
don't crash in proxy_invoke_bad_callback() we need to hold a ref to the proxy store, as after the bad_callback() it's otherwise likely gone.
2020-08-03 10:39:33 +00:00
ctx->ref_count++;
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
debug( "%sCallback enter bad store\n", ctx->label );
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
ctx->bad_callback( ctx->callback_aux );
don't crash in proxy_invoke_bad_callback() we need to hold a ref to the proxy store, as after the bad_callback() it's otherwise likely gone.
2020-08-03 10:39:33 +00:00
debug( "%sCallback leave bad store\n", ctx->label );
proxy_store_deref( ctx );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
}
//# EXCLUDE alloc_store
store_t *
test also one-sided async operation this tests only the common case of the far side being async - adding 100% instead of 50% to the runtime of the test to cover a corner case didn't seem worth it.
2022-06-01 11:54:48 +00:00
proxy_alloc_store( store_t *real_ctx, const char *label, int force_async )
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
{
proxy_store_t *ctx;
rename nfcalloc() => nfzalloc() the signature is like that of zalloc() (as found in the linux kernel; not to be confused with zone allocators, etc.), not like that of calloc().
2022-04-12 11:00:54 +00:00
ctx = nfzalloc( sizeof(*ctx) );
introduce new inheritance model based on C11 anonymous structs the struct declarations got uglier, but their usage requires a lot fewer explicit references to the parent struct (though some are added where using the derived struct is more practical now). we also use something i'd term "covariant members": derivatives of store_t also reference derivatives of store_conf_t, etc., which drastically cuts down the number of casts. fwiw, to achieve this with "proper" inheritance in C++, we'd use covariant getter functions which hide the still existing casts. C11 is almost a decade old now, and compilers supported that feature even longer than that, so i don't expect this to be a problem.
2020-12-17 14:53:40 +00:00
ctx->driver = &proxy_driver;
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
ctx->gen.conf = real_ctx->conf;
ctx->ref_count = 1;
ctx->label = label;
test also one-sided async operation this tests only the common case of the far side being async - adding 100% instead of 50% to the runtime of the test to cover a corner case didn't seem worth it.
2022-06-01 11:54:48 +00:00
ctx->force_async = force_async;
fake async drivers more convincingly instead of delaying the callback, delay the actual driver call. this is in line with how the IMAP driver would behave, as since commit 6c08f568 it queues the socket writes (the network upstream latency goes on top, but that doesn't alter the result). amends 4423a932.
2022-02-07 11:53:58 +00:00
ctx->pending_cmds_append = &ctx->pending_cmds;
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
ctx->check_cmds_append = &ctx->check_cmds;
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
ctx->real_driver = real_ctx->driver;
ctx->real_store = real_ctx;
fix possible attempts to set flags of M_DEAD messages so far, we checked for M_DEAD only in loops over messages. but we should have checked srec->msg uses as well. this would make the code a mess, so instead call back from the drivers when messages are expunged, so we can reset the pointers. the only case where this really matters so far is the flag setting loop, which may cause the concurrent expunge of not yet handled messages to be detected by the maildir driver.
2022-01-07 21:58:38 +00:00
ctx->real_driver->set_callbacks( ctx->real_store,
(void (*)( message_t *, void * ))proxy_invoke_expunge_callback,
(void (*)( void * ))proxy_invoke_bad_callback, ctx );
add forced async mode to proxy driver to test async operation of the syncing core while using the synchronous maildir driver, we add a mode to the proxy driver where it queues callback invocations to the next main loop iteration.
2020-12-14 22:16:01 +00:00
init_wakeup( &ctx->wakeup, proxy_wakeup, ctx );
introduce driver call debugging do that by wrapping the actual stores into proxies. the proxy driver's code is auto-generated from function templates, some parameters, and the declarations of the driver functions themselves. attempts to do it with CPP macros turned out to be a nightmare.
2017-04-02 12:57:17 +00:00
return &ctx->gen;
}
//# EXCLUDE parse_store
//# EXCLUDE cleanup
//# EXCLUDE get_fail_state
#include "drv_proxy.inc"
Reference in New Issue Copy Permalink