developer: consolidiate gossip timing options into one --dev-fast-gossip.

It's generally clearer to have simple hardcoded numbers with an
#if DEVELOPER around it, than apparent variables which aren't, really.

Interestingly, our pruning test was always kinda broken: we have to pass
two cycles, since l2 will refresh the channel once to avoid pruning.

Do the more obvious thing, and cut the network in half and check that
l1 and l3 time out.

Signed-off-by: Rusty Russell <[email protected]>

Author: rustyrussell

channeld/channel_wire.csv

@@ -68,8 +68,8 @@ msgdata,channel_init,upfront_shutdown_script_len,u16,
 msgdata,channel_init,upfront_shutdown_script,u8,upfront_shutdown_script_len
 msgdata,channel_init,remote_ann_node_sig,?secp256k1_ecdsa_signature,
 msgdata,channel_init,remote_ann_bitcoin_sig,?secp256k1_ecdsa_signature,
-msgdata,channel_init,announce_delay,u32,
 msgdata,channel_init,option_static_remotekey,bool,
+msgdata,channel_init,dev_fast_gossip,bool,
 
 # master->channeld funding hit new depth(funding locked if >= lock depth)
 msgtype,channel_funding_depth,1002

channeld/channeld.c

@@ -110,9 +110,6 @@ struct peer {
 	u64 commit_timer_attempts;
 	u32 commit_msec;
 
-	/* How long to delay before broadcasting announcement? */
-	u32 announce_delay;
-
 	/* Are we expecting a pong? */
 	bool expecting_pong;
 
@@ -505,7 +502,7 @@ static void channel_announcement_negotiate(struct peer *peer)
 
 		/* Give other nodes time to notice new block. */
 		notleak(new_reltimer(&peer->timers, peer,
-				     time_from_sec(peer->announce_delay),
+				     time_from_sec(GOSSIP_ANNOUNCE_DELAY(dev_fast_gossip)),
 				     announce_channel, peer));
 	}
 }
@@ -3000,8 +2997,8 @@ static void init_channel(struct peer *peer)
 				   &peer->remote_upfront_shutdown_script,
 				   &remote_ann_node_sig,
 				   &remote_ann_bitcoin_sig,
-				   &peer->announce_delay,
-				   &option_static_remotekey)) {
+				   &option_static_remotekey,
+				   &dev_fast_gossip)) {
 					   master_badmsg(WIRE_CHANNEL_INIT, msg);
 	}
 	/* stdin == requests, 3 == peer, 4 = gossip, 5 = gossip_store, 6 = HSM */

closingd/closing_wire.csv

@@ -30,6 +30,7 @@ msgdata,closing_init,channel_reestablish,u8,channel_reestablish_len
 msgdata,closing_init,final_scriptpubkey_len,u16,
 msgdata,closing_init,final_scriptpubkey,u8,final_scriptpubkey_len
 msgdata,closing_init,last_remote_secret,secret,
+msgdata,closing_init,dev_fast_gossip,bool,
 
 # We received an offer, save signature.
 msgtype,closing_received_signature,2002

closingd/closingd.c

@@ -605,7 +605,8 @@ int main(int argc, char *argv[])
 				   &revocations_received,
 				   &channel_reestablish,
 				   &final_scriptpubkey,
-				   &last_remote_per_commit_secret))
+				   &last_remote_per_commit_secret,
+				   &dev_fast_gossip))
 		master_badmsg(WIRE_CLOSING_INIT, msg);
 
 	/* stdin == requests, 3 == peer, 4 = gossip, 5 = gossip_store, 6 = hsmd */

common/per_peer_state.c

@@ -2,9 +2,12 @@
 #include <ccan/fdpass/fdpass.h>
 #include <common/gossip_rcvd_filter.h>
 #include <common/per_peer_state.h>
+#include <gossipd/gossip_constants.h>
 #include <unistd.h>
 #include <wire/wire.h>
 
+bool dev_fast_gossip = false;
+
 static void destroy_per_peer_state(struct per_peer_state *pps)
 {
 	if (pps->peer_fd != -1)
@@ -66,9 +69,6 @@ void fromwire_gossip_state(const u8 **cursor, size_t *max,
 void towire_per_peer_state(u8 **pptr, const struct per_peer_state *pps)
 {
 	towire_crypto_state(pptr, &pps->cs);
-#if DEVELOPER
-	towire_u32(pptr, pps->dev_gossip_broadcast_msec);
-#endif
 	towire_bool(pptr, pps->gs != NULL);
 	if (pps->gs)
 		towire_gossip_state(pptr, pps->gs);
@@ -93,9 +93,6 @@ struct per_peer_state *fromwire_per_peer_state(const tal_t *ctx,
 
 	fromwire_crypto_state(cursor, max, &cs);
 	pps = new_per_peer_state(ctx, &cs);
-#if DEVELOPER
-	pps->dev_gossip_broadcast_msec = fromwire_u32(cursor, max);
-#endif
 	if (fromwire_bool(cursor, max)) {
 		pps->gs = tal(pps, struct gossip_state);
 		fromwire_gossip_state(cursor, max, pps->gs);
@@ -135,11 +132,8 @@ bool time_to_next_gossip(const struct per_peer_state *pps,
  */
 void per_peer_state_reset_gossip_timer(struct per_peer_state *pps)
 {
-	struct timerel t = time_from_sec(60);
+	struct timerel t = time_from_sec(GOSSIP_FLUSH_INTERVAL(dev_fast_gossip));
 
-#if DEVELOPER
-	t = time_from_msec(pps->dev_gossip_broadcast_msec);
-#endif
 	pps->gs->next_gossip = timemono_add(time_mono(), t);
 	gossip_rcvd_filter_age(pps->grf);
 }

common/per_peer_state.h

@@ -22,10 +22,6 @@ struct per_peer_state {
 	struct gossip_state *gs;
 	/* Cache of msgs we have received, to avoid re-xmitting from store */
 	struct gossip_rcvd_filter *grf;
-#if DEVELOPER
-	/* Normally 60000, but adjustable for dev mode */
-	u32 dev_gossip_broadcast_msec;
-#endif /* DEVELOPER */
 	/* If not -1, closed on freeing */
 	int peer_fd, gossip_fd, gossip_store_fd;
 };
@@ -60,4 +56,8 @@ bool time_to_next_gossip(const struct per_peer_state *pps,
 
 /* Reset pps->next_gossip now we've drained gossip_store */
 void per_peer_state_reset_gossip_timer(struct per_peer_state *pps);
+
+/* Used to speed up gossip iff DEVELOPER*/
+extern bool dev_fast_gossip;
+
 #endif /* LIGHTNING_COMMON_PER_PEER_STATE_H */

connectd/connectd.c

@@ -439,10 +439,6 @@ struct io_plan *peer_connected(struct io_conn *conn,
 
 	/* This contains the per-peer state info; gossipd fills in pps->gs */
 	pps = new_per_peer_state(tmpctx, cs);
-#if DEVELOPER
-	/* Overridden by lightningd, but initialize to keep valgrind happy */
-	pps->dev_gossip_broadcast_msec = 0;
-#endif
 
 	/* If gossipd can't give us a file descriptor, we give up connecting. */
 	if (!get_gossipfds(daemon, id, localfeatures, pps))

gossipd/gossip_constants.h

@@ -1,5 +1,6 @@
 #ifndef LIGHTNING_GOSSIPD_GOSSIP_CONSTANTS_H
 #define LIGHTNING_GOSSIPD_GOSSIP_CONSTANTS_H
+#include <common/utils.h>
 
 /* BOLT #4:
  *
@@ -40,4 +41,40 @@
  */
 #define ANNOUNCE_MIN_DEPTH 6
 
+/* Gossip timing constants.  These can be overridden in --enable-developer
+ * configurations with --dev-fast-gossip, otherwise the argument is ignored */
+#define DEV_FAST_GOSSIP(dev_fast_gossip_flag, fast, normal)	\
+	IFDEV((dev_fast_gossip_flag) ? (fast) : (normal), (normal))
+
+/* How close we can generate gossip msgs (5 minutes) */
+#define GOSSIP_MIN_INTERVAL(dev_fast_gossip_flag) \
+	DEV_FAST_GOSSIP(dev_fast_gossip_flag, 5, 300)
+
+/* BOLT #7:
+ *
+ * - SHOULD flush outgoing gossip messages once every 60 seconds,
+ *   independently of the arrival times of the messages.
+ */
+#define GOSSIP_FLUSH_INTERVAL(dev_fast_gossip_flag) \
+	DEV_FAST_GOSSIP(dev_fast_gossip_flag, 1, 60)
+
+/* BOLT #7:
+ *
+ * A node:
+ *   - if a channel's latest `channel_update`s `timestamp` is older than two weeks
+ *   (1209600 seconds):
+ *     - MAY prune the channel.
+ *     - MAY ignore the channel.
+ */
+#define GOSSIP_PRUNE_INTERVAL(dev_fast_gossip_flag) \
+	DEV_FAST_GOSSIP(dev_fast_gossip_flag, 90, 1209600)
+
+/* How long after seeing lockin until we announce the channel. */
+#define GOSSIP_ANNOUNCE_DELAY(dev_fast_gossip_flag) \
+	DEV_FAST_GOSSIP(dev_fast_gossip_flag, 1, 60)
+
+/* How long before deadline should we send refresh update? 1 day normally */
+#define GOSSIP_BEFORE_DEADLINE(dev_fast_gossip_flag) \
+	DEV_FAST_GOSSIP(dev_fast_gossip_flag, 30, 24*60*60)
+
 #endif /* LIGHTNING_GOSSIPD_GOSSIP_CONSTANTS_H */

gossipd/gossip_wire.csv

@@ -10,11 +10,10 @@ msgdata,gossipctl_init,gflen,u16,
 msgdata,gossipctl_init,globalfeatures,u8,gflen
 msgdata,gossipctl_init,rgb,u8,3
 msgdata,gossipctl_init,alias,u8,32
-msgdata,gossipctl_init,update_channel_interval,u32,
-msgdata,gossipctl_init,gossip_min_interval,u32,
 msgdata,gossipctl_init,num_announcable,u16,
 msgdata,gossipctl_init,announcable,wireaddr,num_announcable
 msgdata,gossipctl_init,dev_gossip_time,?u32,
+msgdata,gossipctl_init,dev_fast_gossip,bool,
 
 # In developer mode, we can mess with time.
 msgtype,gossip_dev_set_time,3001

gossipd/gossipd.c

@@ -1832,16 +1832,13 @@ static void gossip_refresh_network(struct daemon *daemon)
 	s64 highwater;
 	struct node *n;
 
-	/* For DEVELOPER testing, this can be set really short; otherwise, we
-	 * set it to 1 day before deadline. */
-	if (daemon->rstate->prune_timeout < 24*3600)
-		highwater = now - daemon->rstate->prune_timeout / 2;
-	else
-		highwater = now - (daemon->rstate->prune_timeout - 24*3600);
+	/* Send out 1 day before deadline */
+	highwater = now - (GOSSIP_PRUNE_INTERVAL(daemon->rstate->dev_fast_gossip)
+			   - GOSSIP_BEFORE_DEADLINE(daemon->rstate->dev_fast_gossip));
 
-	/* Schedule next run now (prune_timeout is 2 weeks) */
+	/* Schedule next run now */
 	notleak(new_reltimer(&daemon->timers, daemon,
-			     time_from_sec(daemon->rstate->prune_timeout/4),
+			     time_from_sec(GOSSIP_PRUNE_INTERVAL(daemon->rstate->dev_fast_gossip)/4),
 			     gossip_refresh_network, daemon));
 
 	/* Find myself in the network */
@@ -1980,32 +1977,25 @@ static struct io_plan *gossip_init(struct io_conn *conn,
 				   struct daemon *daemon,
 				   const u8 *msg)
 {
-	u32 update_channel_interval;
 	u32 *dev_gossip_time;
+	bool dev_fast_gossip;
 
 	if (!fromwire_gossipctl_init(daemon, msg,
 				     &daemon->chain_hash,
 				     &daemon->id, &daemon->globalfeatures,
 				     daemon->rgb,
 				     daemon->alias,
-				     /* 1 week in seconds
-				      * (unless --dev-channel-update-interval) */
-				     &update_channel_interval,
-				     /* 5 minutes, or
-				      * --dev-broadcast-interval * 5 seconds */
-				     &daemon->gossip_min_interval,
 				     &daemon->announcable,
-				     &dev_gossip_time)) {
+				     &dev_gossip_time, &dev_fast_gossip)) {
 		master_badmsg(WIRE_GOSSIPCTL_INIT, msg);
 	}
 
-	/* Prune time (usually 2 weeks) is twice update time */
 	daemon->rstate = new_routing_state(daemon,
 					   chainparams_by_chainhash(&daemon->chain_hash),
 					   &daemon->id,
-					   update_channel_interval * 2,
 					   &daemon->peers,
-					   take(dev_gossip_time));
+					   take(dev_gossip_time),
+					   dev_fast_gossip);
 
 	/* Load stored gossip messages */
 	if (!gossip_store_load(daemon->rstate, daemon->rstate->gs))
@@ -2018,9 +2008,9 @@ static struct io_plan *gossip_init(struct io_conn *conn,
 	 * or addresses might have changed!) */
 	maybe_send_own_node_announce(daemon);
 
-	/* Start the weekly refresh timer. */
+	/* Start the twice- weekly refresh timer. */
 	notleak(new_reltimer(&daemon->timers, daemon,
-			     time_from_sec(daemon->rstate->prune_timeout/4),
+			     time_from_sec(GOSSIP_PRUNE_INTERVAL(daemon->rstate->dev_fast_gossip) / 4),
 			     gossip_refresh_network, daemon));
 
 	return daemon_conn_read_next(conn, daemon->master);

gossipd/gossipd.h

@@ -33,9 +33,6 @@ struct daemon {
 	/* Timers: we batch gossip, and also refresh announcements */
 	struct timers timers;
 
-	/* Minimum interval for generating updated gossip */
-	u32 gossip_min_interval;
-
 	/* Global features to list in node_announcement. */
 	u8 *globalfeatures;
 

gossipd/make_gossip.c

@@ -170,7 +170,8 @@ static void update_own_node_announcement(struct daemon *daemon)
 		 *    previous `node_announcement` it has previously created.
 		 */
 		/* We do better: never send them within more than 5 minutes. */
-		next = self->bcast.timestamp + daemon->gossip_min_interval;
+		next = self->bcast.timestamp
+			+ GOSSIP_MIN_INTERVAL(daemon->rstate->dev_fast_gossip);
 
 		if (timestamp < next) {
 			status_debug("node_announcement: delaying %u secs",
@@ -260,7 +261,7 @@ static void update_local_channel(struct local_cupdate *lc /* frees! */)
 	/* Create an unsigned channel_update: we backdate enables, so
 	 * we can always send a disable in an emergency. */
 	if (!lc->disable)
-		timestamp -= daemon->gossip_min_interval;
+		timestamp -= GOSSIP_MIN_INTERVAL(daemon->rstate->dev_fast_gossip);
 
 	/* BOLT #7:
 	 *
@@ -321,7 +322,8 @@ static void update_local_channel(struct local_cupdate *lc /* frees! */)
 		}
 
 		/* Is it too soon to send another update? */
-		next = hc->bcast.timestamp + daemon->gossip_min_interval;
+		next = hc->bcast.timestamp
+			+ GOSSIP_MIN_INTERVAL(daemon->rstate->dev_fast_gossip);
 
 		if (timestamp < next) {
 			status_debug("channel_update %s/%u: delaying %u secs",

gossipd/routing.c

@@ -205,7 +205,7 @@ static bool timestamp_reasonable(struct routing_state *rstate, u32 timestamp)
 	if (timestamp > now + 24*60*60)
 		return false;
 	/* More than 2 weeks behind? */
-	if (timestamp < now - rstate->prune_timeout)
+	if (timestamp < now - GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip))
 		return false;
 	return true;
 }
@@ -234,16 +234,15 @@ static void memleak_help_routing_tables(struct htable *memtable,
 struct routing_state *new_routing_state(const tal_t *ctx,
 					const struct chainparams *chainparams,
 					const struct node_id *local_id,
-					u32 prune_timeout,
 					struct list_head *peers,
-					const u32 *dev_gossip_time TAKES)
+					const u32 *dev_gossip_time TAKES,
+					bool dev_fast_gossip)
 {
 	struct routing_state *rstate = tal(ctx, struct routing_state);
 	rstate->nodes = new_node_map(rstate);
 	rstate->gs = gossip_store_new(rstate, peers);
 	rstate->chainparams = chainparams;
 	rstate->local_id = *local_id;
-	rstate->prune_timeout = prune_timeout;
 	rstate->local_channel_announced = false;
 
 	pending_cannouncement_map_init(&rstate->pending_cannouncements);
@@ -263,6 +262,7 @@ struct routing_state *new_routing_state(const tal_t *ctx,
 		rstate->gossip_time->ts.tv_nsec = 0;
 	} else
 		rstate->gossip_time = NULL;
+	rstate->dev_fast_gossip = dev_fast_gossip;
 #endif
 	tal_add_destructor(rstate, destroy_routing_state);
 	memleak_add_helper(rstate, memleak_help_routing_tables);
@@ -2000,7 +2000,7 @@ bool routing_add_channel_update(struct routing_state *rstate,
 		}
 
 		/* Allow redundant updates once every 7 days */
-		if (timestamp < hc->bcast.timestamp + rstate->prune_timeout / 2
+		if (timestamp < hc->bcast.timestamp + GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip) / 2
 		    && !cupdate_different(rstate->gs, hc, update)) {
 			status_debug("Ignoring redundant update for %s/%u"
 				     " (last %u, now %u)",
@@ -2351,7 +2351,7 @@ bool routing_add_node_announcement(struct routing_state *rstate,
 		}
 
 		/* Allow redundant updates once every 7 days */
-		if (timestamp < node->bcast.timestamp + rstate->prune_timeout / 2
+		if (timestamp < node->bcast.timestamp + GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip) / 2
 		    && !nannounce_different(rstate->gs, node, msg)) {
 			status_debug("Ignoring redundant nannounce for %s"
 				     " (last %u, now %u)",
@@ -2698,7 +2698,7 @@ void route_prune(struct routing_state *rstate)
 {
 	u64 now = gossip_time_now(rstate).ts.tv_sec;
 	/* Anything below this highwater mark ought to be pruned */
-	const s64 highwater = now - rstate->prune_timeout;
+	const s64 highwater = now - GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip);
 	struct chan **pruned = tal_arr(tmpctx, struct chan *, 0);
 	u64 idx;