/*
- * todo
- * - manpage: document control master stuff
- *
* debugging rune:
* build-lfs/backends/innduct --connection-timeout=30 --no-daemon -C ../inn.conf -f `pwd`/fee sit localhost
*/
+/*--
+flow control notes
+to ensure articles go away eventually
+separate queue for each input file
+ queue expiry
+ every period, check head of backlog queue for expiry with SMretrieve
+ if too old: discard, and check next article
+ also check every backlog article as we read it
+ flush expiry
+ after too long in SEPARATED/DROPPING ie Separated/Finishing/Dropping
+ one-off: eat queued articles from flushing and write them to defer
+ one-off: connfail all connections which have any articles from flushing
+ newly read articles from flushing go straight to defer
+ this should take care of it and get us out of this state
+to avoid filling up ram needlessly
+ input control
+ limit number of queued articles for each ipf
+ pause/resume inputfile tailing
+--*/
+
/*
* Newsfeeds file entries should look like this:
* host.name.of.site[/exclude,exclude,...]\
static void spawn_inndcomm_flush(const char *why); /* Moved => Flushing */
static int trigger_flush_ok(void); /* => Flushing,FLUSHING, ret 1; or ret 0 */
-static void article_done(Conn *conn, Article *art, int whichcount);
+static void article_done(Article *art, int whichcount);
static void check_assign_articles(void);
static void queue_check_input_done(void);
+static void check_reading_pause_resume(InputFile *ipf);
static void statemc_check_flushing_done(void);
static void statemc_check_backlog_done(void);
static void inputfile_reading_start(InputFile *ipf);
static void inputfile_reading_stop(InputFile *ipf);
+static void inputfile_reading_pause(InputFile *ipf);
+static void inputfile_reading_resume(InputFile *ipf);
+ /* pause and resume are idempotent, and no-op if not done _reading_start */
static void filemon_start(InputFile *ipf);
static void filemon_stop(InputFile *ipf);
static int target_max_feedfile_size=100000;
static int period_seconds=60;
static int filepoll_seconds=5;
+static int max_queue_per_ipf=-1;
static int connection_setup_timeout=200;
static int inndcomm_flush_timeout=100;
static int backlog_retry_minperiods=50;
static int backlog_spontrescan_periods=300;
static int spontaneous_flush_periods=100000;
+static int max_separated_periods=2000;
static int need_activity_periods=1000;
static double max_bad_data_ratio= 1; /* conv'd from percentage by main */
#define CONNIOVS 128
typedef enum {
- xk_Malloc, xk_Const, xk_Artdata
+ xk_Const, xk_Artdata
} XmitKind;
struct XmitDetails {
XmitKind kind;
union {
- char *malloc_tofree;
ARTHANDLE *sm_art;
} info;
};
Filemon_Perfile *filemon;
oop_read *rd; /* non-0: reading; 0: constructing, or had EOF */
- long inprogress; /* no. of articles read but not processed */
off_t offset;
- int skippinglong;
+ int skippinglong, paused;
+
+ ArticleList queue;
+ long inprogress; /* includes queue.count and also articles in conns */
+ long autodefer; /* -1 means not doing autodefer */
int counts[art_MaxState][RCI_max];
- int readcount_ok, readcount_blank, readcount_err;
+ int readcount_ok, readcount_blank, readcount_err, count_nooffer_missing;
char path[];
};
/* main initialises */
static oop_source *loop;
static ConnList conns;
-static ArticleList queue;
static char *path_lock, *path_flushing, *path_defer;
static char *path_control, *path_dump;
static char *globpat_backlog;
/* statemc_init initialises */
static StateMachineState sms;
-static int sm_period_counter;
+static int until_flush;
static InputFile *main_input_file, *flushing_input_file, *backlog_input_file;
static FILE *defer;
const ControlCommand *ccmd;
for (ccmd=control_commands; ccmd->cmd; ccmd++)
fprintf(cc->out, " %s\n", ccmd->cmd);
+ fputs("NB: permissible arguments are not shown above."
+ " Not all commands listed are safe. See innduct(8).\n", cc->out);
}
CCMD(flush) {
{ "p", ccmd_period },
#define POKES(cmd,func) \
- { cmd "sm", func, &sm_period_counter, 1 }, \
+ { cmd "flush", func, &until_flush, 1 }, \
{ cmd "conn", func, &until_connect, 0 }, \
{ cmd "blscan", func, &until_backlog_nextscan, 0 },
-POKES("prod ", ccmd_setint_period)
POKES("next ", ccmd_setint)
+POKES("prod ", ccmd_setint_period)
{ "pretend flush", ccmd_setintarg, &simulate_flush },
{ "wedge blscan", ccmd_setint, &until_backlog_nextscan, -1 },
memset(requeue,0,sizeof(requeue));
Article *art;
- while ((art= LIST_REMHEAD(conn->priority))) LIST_ADDTAIL(queue, art);
- while ((art= LIST_REMHEAD(conn->waiting))) LIST_ADDTAIL(queue, art);
+
+ while ((art= LIST_REMHEAD(conn->priority)))
+ LIST_ADDTAIL(art->ipf->queue, art);
+
+ while ((art= LIST_REMHEAD(conn->waiting)))
+ LIST_ADDTAIL(art->ipf->queue, art);
+
while ((art= LIST_REMHEAD(conn->sent))) {
requeue[art->state]++;
if (art->state==art_Unsolicited) art->state= art_Unchecked;
- LIST_ADDTAIL(queue,art);
+ LIST_ADDTAIL(art->ipf->queue,art);
+ check_reading_pause_resume(art->ipf);
}
int i;
/*---------- assigning articles to conns, and transmitting ----------*/
+static Article *dequeue_from(int peek, InputFile *ipf) {
+ if (!ipf) return 0;
+ if (peek) return LIST_HEAD(ipf->queue);
+
+ Article *art= LIST_REMHEAD(ipf->queue);
+ if (!art) return 0;
+ check_reading_pause_resume(ipf);
+ return art;
+}
+
+static Article *dequeue(int peek) {
+ Article *art;
+ art= dequeue_from(peek, flushing_input_file); if (art) return art;
+ art= dequeue_from(peek, backlog_input_file); if (art) return art;
+ art= dequeue_from(peek, main_input_file); if (art) return art;
+ return 0;
+}
+
static void check_assign_articles(void) {
for (;;) {
- if (!queue.count)
+ if (!dequeue(1))
break;
Conn *walk, *use=0;
if (use) {
if (!inqueue) use->since_activity= 0; /* reset idle counter */
while (spare>0) {
- Article *art= LIST_REMHEAD(queue);
+ Article *art= dequeue(0);
if (!art) break;
LIST_ADDTAIL(use->waiting, art);
spare--;
}
}
+/*---------- expiry, flow control and deferral ----------*/
+
+static void check_reading_pause_resume(InputFile *ipf) {
+ if (ipf->queue.count >= max_queue_per_ipf)
+ inputfile_reading_pause(ipf);
+ else
+ inputfile_reading_resume(ipf);
+}
+
+static void article_defer(Article *art /* not on a queue */, int whichcount) {
+ open_defer();
+ if (fprintf(defer, "%s %s\n", TokenToText(art->token), art->messageid) <0
+ || fflush(defer))
+ sysfatal("write to defer file %s",path_defer);
+ article_done(art, whichcount);
+}
+
+static int article_check_expired(Article *art /* must be queued, not conn */) {
+ ARTHANDLE *artdata= SMretrieve(art->token, RETR_STAT);
+ if (artdata) { SMfreearticle(artdata); return 0; }
+
+ LIST_REMOVE(art->ipf->queue, art);
+ art->missing= 1;
+ art->ipf->count_nooffer_missing++;
+ article_done(art,-1);
+ return 1;
+}
+
+static void inputfile_queue_check_expired(InputFile *ipf) {
+ if (!ipf) return;
+
+ for (;;) {
+ Article *art= LIST_HEAD(ipf->queue);
+ int exp= article_check_expired(art);
+ if (!exp) break;
+ }
+ check_reading_pause_resume(ipf);
+}
+
+static void article_autodefer(InputFile *ipf, Article *art) {
+ ipf->autodefer++;
+ article_defer(art,-1);
+}
+
+static int has_article_in(const ArticleList *al, InputFile *ipf) {
+ Article *art;
+ for (art=LIST_HEAD(*al); art; art=LIST_NEXT(art))
+ if (art->ipf == ipf) return 1;
+ return 0;
+}
+
+static void autodefer_input_file_articles(InputFile *ipf) {
+ Article *art;
+ while ((art= LIST_REMHEAD(ipf->queue)))
+ article_autodefer(ipf, art);
+}
+
+static void autodefer_input_file(InputFile *ipf) {
+ ipf->autodefer= 0;
+
+ autodefer_input_file_articles(ipf);
+
+ if (ipf->inprogress) {
+ Conn *walk;
+ FOR_CONN(walk) {
+ if (has_article_in(&walk->waiting, ipf) ||
+ has_article_in(&walk->priority, ipf) ||
+ has_article_in(&walk->sent, ipf))
+ walk->quitting= -1;
+ }
+ while (ipf->inprogress) {
+ FOR_CONN(walk)
+ if (walk->quitting < 0) goto found;
+ abort(); /* where are they ?? */
+
+ found:
+ connfail(walk, "connection is stuck or crawling,"
+ " and we need to finish flush");
+ autodefer_input_file_articles(ipf);
+ }
+ }
+
+ check_reading_pause_resume(ipf);
+}
+
/*========== article transmission ==========*/
static XmitDetails *xmit_core(Conn *conn, const char *data, int len,
static void xmit_free(XmitDetails *d) {
switch (d->kind) {
- case xk_Malloc: free(d->info.malloc_tofree); break;
case xk_Artdata: SMfreearticle(d->info.sm_art); break;
case xk_Const: break;
default: abort();
XMIT_LITERAL("\r\n");
xmit_artbody(conn, artdata);
} else {
- article_done(conn, art, -1);
+ article_done(art, -1);
continue;
}
} else {
}
}
-
/*========== handling responses from peer ==========*/
static const oop_rd_style peer_rd_style= {
nocheck= new_nocheck;
}
-static void article_done(Conn *conn, Article *art, int whichcount) {
- if (!art->missing) art->ipf->counts[art->state][whichcount]++;
+static void article_done(Article *art, int whichcount) {
+ if (whichcount>=0 && !art->missing)
+ art->ipf->counts[art->state][whichcount]++;
if (whichcount == RC_accepted) update_nocheck(1);
else if (whichcount == RC_unwanted) update_nocheck(0);
#define ARTICLE_DEALTWITH(streaming,musthavesent,how) do{ \
code_streaming= (streaming); \
GET_ARTICLE(musthavesent); \
- article_done(conn, art, RC_##how); \
+ article_done(art, RC_##how); \
goto dealtwith; \
}while(0)
switch (code) {
- case 400: PEERBADMSG("peer stopped accepting articles");
default: PEERBADMSG("peer sent unexpected message");
- case 503:
- if (conn_busy) PEERBADMSG("peer timed us out");
+ case 400:
+ if (conn_busy)
+ PEERBADMSG("peer timed us out or stopped accepting articles");
+
notice("C%d idle connection closed by peer", conn->fd);
LIST_REMOVE(conns,conn);
conn_dispose(conn);
code_streaming= 1;
case 436: /* IHAVE says try later */
GET_ARTICLE(0);
- open_defer();
- if (fprintf(defer, "%s %s\n", TokenToText(art->token), art->messageid) <0
- || fflush(defer))
- sysfatal("write to defer file %s",path_defer);
- article_done(conn, art, RC_deferred);
+ article_defer(art, RC_deferred);
break;
}
memset(ipf,0,sizeof(*ipf));
ipf->fd= fd;
+ ipf->autodefer= -1;
+ LIST_INIT(ipf->queue);
strcpy(ipf->path, path);
return ipf;
ipf->readcount_ok++;
art= xmalloc(sizeof(*art) - 1 + midlen + 1);
- memset(art,0,sizeof(art));
+ memset(art,0,sizeof(*art));
art->state= art_Unchecked;
art->midlen= midlen;
art->ipf= ipf; ipf->inprogress++;
art->offset= old_offset;
art->blanklen= recsz;
strcpy(art->messageid, space+1);
- LIST_ADDTAIL(queue, art);
+ LIST_ADDTAIL(ipf->queue, art);
+
+ if (ipf->autodefer >= 0)
+ article_autodefer(ipf, art);
+ else if (ipf==backlog_input_file)
+ article_check_expired(art);
if (sms==sm_NORMAL && ipf==main_input_file &&
ipf->offset >= target_max_feedfile_size)
statemc_start_flush("feed file size");
- check_assign_articles();
+ check_assign_articles(); /* may destroy conn but that's OK */
+ check_reading_pause_resume(ipf);
return OOP_CONTINUE;
}
DUMPV("%d",,filemon_inotify_fd);
DUMPV("%d",,filemon_inotify_wdmax);
for (i=0; i<filemon_inotify_wdmax; i++)
- fprintf(f," wd2ipf[%d]=%p\n", i, filemon_inotify_wd2ipf[i],);
+ fprintf(f," wd2ipf[%d]=%p\n", i, filemon_inotify_wd2ipf[i]);
}
#endif /* HAVE_INOTIFY && !HAVE_FILEMON */
OOP_RD_SHORTREC_LONG,
};
+static void inputfile_reading_resume(InputFile *ipf) {
+ if (!ipf->rd) return;
+ if (!ipf->paused) return;
+
+ int r= oop_rd_read(ipf->rd, &feedfile_rdstyle, MAX_LINE_FEEDFILE,
+ feedfile_got_article,ipf, feedfile_read_err, ipf);
+ if (r) sysdie("unable start reading feedfile %s",ipf->path);
+
+ ipf->paused= 0;
+}
+
+static void inputfile_reading_pause(InputFile *ipf) {
+ if (!ipf->rd) return;
+ if (ipf->paused) return;
+ oop_rd_cancel(ipf->rd);
+ ipf->paused= 1;
+}
+
static void inputfile_reading_start(InputFile *ipf) {
assert(!ipf->rd);
ipf->readable.on_readable= tailing_on_readable;
ipf->rd= oop_rd_new(loop, &ipf->readable, 0,0);
assert(ipf->rd);
- int r= oop_rd_read(ipf->rd, &feedfile_rdstyle, MAX_LINE_FEEDFILE,
- feedfile_got_article,ipf, feedfile_read_err, ipf);
- if (r) sysdie("unable start reading feedfile %s",ipf->path);
+ ipf->paused= 1;
+ inputfile_reading_resume(ipf);
}
static void inputfile_reading_stop(InputFile *ipf) {
assert(ipf->rd);
- oop_rd_cancel(ipf->rd);
+ inputfile_reading_pause(ipf);
oop_rd_delete(ipf->rd);
ipf->rd= 0;
assert(!ipf->filemon); /* we shouldn't be monitoring it now */
| flsh->rd!=0 | | flsh->rd!=0
| [Separated] | | [Dropping]
| main F idle | | main none
- | old D tail | | old D tail
+ | flsh D tail | | flsh D tail
| ============= | | ============
| | | | install |
^ | EOF ON D | | defer | EOF ON D
| flsh->rd==0 | V flsh->rd==0
| [Finishing] | | [Dropping]
| main F tail | `. main none
- | old D closed | `. old D closed
+ | flsh D closed | `. flsh D closed
| =============== V `. ===============
| | `. |
| | ALL D PROCESSED `. | ALL D PROCESSED
DROPPED
[Dropped]
main none
- old none
+ flsh none
some backlog
==============
|
if (file_d) {
debug("startup: F!=D => Separated");
startup_set_input_file(file_d);
- SMS(SEPARATED, 0, "found both old and current feed files");
+ flushing_input_file= main_input_file;
+ main_input_file= open_input_file(feedfile);
+ if (!main_input_file) die("feedfile vanished during startup");
+ SMS(SEPARATED, max_separated_periods,
+ "found both old and current feed files");
} else {
debug("startup: F exists, D ENOENT => Normal");
InputFile *file_f= open_input_file(feedfile);
why,
(unsigned long)(main_input_file ? main_input_file->offset : 0),
(unsigned long)target_max_feedfile_size,
- sm_period_counter);
+ until_flush);
int r= link(feedfile, path_flushing);
if (r) sysfatal("link feedfile %s to flushing file %s",
static int trigger_flush_ok(void) { /* => Flushing,FLUSHING, ret 1; or ret 0 */
switch (sms) {
+
case sm_NORMAL:
statemc_start_flush("periodic"); /* Normal => Flushing; => FLUSHING */
return 1;
+
case sm_FLUSHFAILED:
spawn_inndcomm_flush("retry"); /* Moved => Flushing; => FLUSHING */
return 1;
+
+ case sm_SEPARATED:
+ case sm_DROPPING:
+ warn("took too long to complete old feedfile after flush, autodeferring");
+ assert(flushing_input_file);
+ autodefer_input_file(flushing_input_file);
+ return 1;
+
default:
return 0;
}
}
static void statemc_period_poll(void) {
- if (!sm_period_counter) return;
- sm_period_counter--;
- assert(sm_period_counter>=0);
+ if (!until_flush) return;
+ until_flush--;
+ assert(until_flush>=0);
- if (sm_period_counter) return;
+ if (until_flush) return;
int ok= trigger_flush_ok();
assert(ok);
}
char *inprog= completed
? xasprintf("%s","") /* GCC produces a stupid warning for printf("") ! */
: xasprintf(" inprogress=%ld", ipf->inprogress);
+ char *autodefer= ipf->autodefer >= 0
+ ? xasprintf(" autodeferred=%ld", ipf->autodefer)
+ : xasprintf("%s","");
- info("%s %s%s read=%d (+bl=%d,+err=%d)%s"
- " offered=%d (ch=%d,nc=%d) accepted=%d (ch=%d,nc=%d)"
+ info("%s %s%s read=%d (+bl=%d,+err=%d)%s%s"
+ " missing=%d offered=%d (ch=%d,nc=%d) accepted=%d (ch=%d,nc=%d)"
RESULT_COUNTS(RCI_NOTHING, RCI_TRIPLE_FMT)
,
completed?"completed":"processed", what, spec,
- ipf->readcount_ok, ipf->readcount_blank, ipf->readcount_err, inprog,
+ ipf->readcount_ok, ipf->readcount_blank, ipf->readcount_err,
+ inprog, autodefer, ipf->count_nooffer_missing,
CNT(Unchecked,sent) + CNT(Unsolicited,sent)
, CNT(Unchecked,sent), CNT(Unsolicited,sent),
CNT(Wanted,accepted) + CNT(Unsolicited,accepted)
);
free(inprog);
+ free(autodefer);
#undef CNT
}
notice("flush complete");
SMS(NORMAL, spontaneous_flush_periods, "flush complete");
} else if (sms==sm_DROPPING) {
- SMS(DROPPED, 0, "old flush complete");
+ SMS(DROPPED, max_separated_periods, "old flush complete");
search_backlog_file();
notice("feed dropped, but will continue until backlog is finished");
}
static void statemc_setstate(StateMachineState newsms, int periods,
const char *forlog, const char *why) {
sms= newsms;
- sm_period_counter= periods;
+ until_flush= periods;
const char *xtra= "";
switch (sms) {
static void preterminate(void) {
if (in_child) return;
notice_processed(main_input_file,0,"feedfile","");
- notice_processed(flushing_input_file,0,"flushing file","");
+ notice_processed(flushing_input_file,0,"flushing","");
if (backlog_input_file)
notice_processed(backlog_input_file,0, "backlog file ",
backlog_input_file->path);
main_input_file= 0;
if (flushing_input_file) {
- SMS(DROPPING, 0, "feed dropped by innd, but must finish last flush");
+ SMS(DROPPING, max_separated_periods,
+ "feed dropped by innd, but must finish last flush");
} else {
close_defer();
SMS(DROPPED, 0, "feed dropped by innd");
die("flush succeeded but feedfile %s does not exist!", feedfile);
if (flushing_input_file) {
- SMS(SEPARATED, spontaneous_flush_periods, "recovery flush complete");
+ SMS(SEPARATED, max_separated_periods, "recovery flush complete");
} else {
close_defer();
SMS(NORMAL, spontaneous_flush_periods, "flush complete");
const char *slash= strrchr(ipf->path,'/');
const char *path= slash ? slash+1 : ipf->path;
- return xasprintf("%p/%s:ip=%ld,off=%ld,fd=%d%s%s",
+ return xasprintf("%p/%s:queue=%d,ip=%ld,autodef=%ld,off=%ld,fd=%d%s%s%s",
ipf, path,
- ipf->inprogress, (long)ipf->offset,
- ipf->fd,
+ ipf->queue.count, ipf->inprogress, ipf->autodefer,
+ (long)ipf->offset, ipf->fd,
ipf->rd ? "" : ",!rd",
- ipf->skippinglong ? "*skiplong" : "");
+ ipf->skippinglong ? "*skiplong" : "",
+ ipf->rd && ipf->paused ? "*paused" : "");
}
static void period(void) {
char *dipf_backlog= debug_report_ipf(backlog_input_file);
debug("PERIOD"
- " sms=%s[%d] conns=%d queue=%d until_connect=%d"
- " input_files main:%s flushing:%s backlog:%s"
+ " sms=%s[%d] conns=%d until_connect=%d"
+ " input_files main:%s flushing:%s backlog:%s[%d]"
" children connecting=%ld inndcomm=%ld"
,
- sms_names[sms], sm_period_counter,
- conns.count, queue.count, until_connect,
- dipf_main, dipf_flushing, dipf_backlog,
+ sms_names[sms], until_flush, conns.count, until_connect,
+ dipf_main, dipf_flushing, dipf_backlog, until_backlog_nextscan,
(long)connecting_child, (long)inndcomm_child
);
if (until_connect) until_connect--;
+ inputfile_queue_check_expired(backlog_input_file);
poll_backlog_file();
if (!backlog_input_file) close_defer(); /* want to start on a new backlog */
statemc_period_poll();
}
}
-static void dump_input_file(FILE *f, InputFile *ipf, const char *wh) {
+static void dump_input_file(FILE *f, const ControlCommand *c,
+ InputFile *ipf, const char *wh) {
char *dipf= debug_report_ipf(ipf);
fprintf(f,"input %s %s", wh, dipf);
free(dipf);
wh, *statename
RESULT_COUNTS(RC_DUMP_VAL,RC_DUMP_VAL));
}
+ fprintf(f,"input %s queue", wh);
+ dump_article_list(f,c,&ipf->queue);
}
}
fprintf(f,"general");
DUMPV("%s", sms_names,[sms]);
- DUMPV("%d", ,sm_period_counter);
+ DUMPV("%d", ,until_flush);
DUMPV("%ld", (long),self_pid);
DUMPV("%p", , defer);
DUMPV("%d", , until_connect);
fprintf(f,"filemon ");
filemon_method_dump_info(f);
- dump_input_file(f, main_input_file, "main" );
- dump_input_file(f, flushing_input_file, "flushing");
- dump_input_file(f, backlog_input_file, "backlog" );
+ dump_input_file(f,c, main_input_file, "main" );
+ dump_input_file(f,c, flushing_input_file, "flushing");
+ dump_input_file(f,c, backlog_input_file, "backlog" );
fprintf(f,"conns count=%d\n", conns.count);
const struct iovec *iv= &conn->xmit[i];
const XmitDetails *xd= &conn->xmitd[i];
char *dinfo;
- long diff;
switch (xd->kind) {
- case xk_Malloc:
- diff= xd->info.malloc_tofree - (char*)iv->iov_base;
- dinfo= xasprintf("M%5ld", diff);
- break;
- case xk_Const:
- dinfo= xasprintf("Const");
- break;
- case xk_Artdata:
- dinfo= xasprintf("A%p", xd->info.sm_art);
- break;
+ case xk_Const: dinfo= xasprintf("Const"); break;
+ case xk_Artdata: dinfo= xasprintf("A%p", xd->info.sm_art); break;
default:
abort();
}
}
}
- fprintf(f,"queue"); dump_article_list(f,c,&queue);
-
fprintf(f,"paths");
DUMPV("%s", , path_lock);
DUMPV("%s", , path_flushing);
{0,"max-connections", "N", &max_connections, op_integer },
{0,"max-queue-per-conn", "N", &max_queue_per_conn, op_integer },
+{0,"max-queue-per-file", "N", &max_queue_per_ipf, op_integer },
{0,"feedfile-flush-size","BYTES", &target_max_feedfile_size, op_integer },
{0,"period-interval", "TIME", &period_seconds, op_seconds },
{0,"earliest-deferred-retry","PERIOD", &backlog_retry_minperiods, op_seconds },
{0,"backlog-rescan-interval","PERIOD",&backlog_spontrescan_periods,op_seconds},
{0,"max-flush-interval", "PERIOD", &spontaneous_flush_periods,op_seconds },
+{0,"flush-finish-timeout", "PERIOD", &max_separated_periods, op_seconds },
{0,"idle-timeout", "PERIOD", &need_activity_periods, op_seconds },
{0,"max-bad-input-data-ratio","PERCENT", &max_bad_data_ratio, op_double },
convert_to_periods_rndup(&backlog_retry_minperiods);
convert_to_periods_rndup(&backlog_spontrescan_periods);
convert_to_periods_rndup(&spontaneous_flush_periods);
+ convert_to_periods_rndup(&max_separated_periods);
convert_to_periods_rndup(&need_activity_periods);
if (max_bad_data_ratio < 0 || max_bad_data_ratio > 100)
feedfile= xasprintf("%s%s",feedfile,sitename);
}
+ if (max_queue_per_ipf<0)
+ max_queue_per_ipf= max_queue_per_conn * 2;
+
const char *feedfile_forbidden= "?*[~#";
int c;
while ((c= *feedfile_forbidden++))
loop= (oop_source*)sysloop;
LIST_INIT(conns);
- LIST_INIT(queue);
if (become_daemon) {
int i;
~ian / inn-innduct.git / blobdiff