#ifndef __router_private_h__ #define __router_private_h__ 1 /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ /**@file * Router Private type definitions *@internal */ #include #include #include #include #include #include #include "dispatch_private.h" #include "entity.h" qd_error_t qd_router_python_setup(qd_router_t *router); void qd_router_python_free(qd_router_t *router); qd_error_t qd_pyrouter_tick(qd_router_t *router); qd_error_t qd_router_configure_address(qd_router_t *router, qd_entity_t *entity); qd_error_t qd_router_configure_waypoint(qd_router_t *router, qd_entity_t *entity); qd_error_t qd_router_configure_lrp(qd_router_t *router, qd_entity_t *entity); void qd_router_configure_free(qd_router_t *router); typedef enum { QD_ROUTER_MODE_STANDALONE, ///< Standalone router. No routing protocol participation QD_ROUTER_MODE_INTERIOR, ///< Interior router. Full participation in routing protocol. QD_ROUTER_MODE_EDGE, ///< Edge router. No transit-router capability. QD_ROUTER_MODE_ENDPOINT ///< No routing except for internal modules (agent, etc.). } qd_router_mode_t; ENUM_DECLARE(qd_router_mode); typedef enum { QD_LINK_ENDPOINT, ///< A link to a connected endpoint QD_LINK_WAYPOINT, ///< A link to a configured waypoint QD_LINK_ROUTER, ///< A link to a peer router in the same area QD_LINK_AREA ///< A link to a peer router in a different area (area boundary) } qd_link_type_t; ENUM_DECLARE(qd_link_type); typedef struct qd_routed_event_t { DEQ_LINKS(struct qd_routed_event_t); qd_router_delivery_t *delivery; qd_message_t *message; bool settle; uint64_t disposition; } qd_routed_event_t; extern const char *QD_ROUTER_NODE_TYPE; extern const char *QD_ROUTER_ADDRESS_TYPE; extern const char *QD_ROUTER_LINK_TYPE; ALLOC_DECLARE(qd_routed_event_t); DEQ_DECLARE(qd_routed_event_t, qd_routed_event_list_t); DEQ_DECLARE(qd_router_delivery_t, qd_router_delivery_list_t); struct qd_router_link_t { DEQ_LINKS(qd_router_link_t); int mask_bit; ///< Unique mask bit if this is an inter-router link qd_link_type_t link_type; qd_direction_t link_direction; qd_address_t *owning_addr; ///< [ref] Address record that owns this link qd_waypoint_t *waypoint; ///< [ref] Waypoint that owns this link qd_link_t *link; ///< [own] Link pointer qd_router_link_t *connected_link; ///< [ref] If this is a link-route, reference the connected link qd_router_link_ref_t *ref; ///< Pointer to a containing reference object char *target; ///< Target address for incoming links qd_routed_event_list_t event_fifo; ///< FIFO of outgoing delivery/link events (no messages) qd_routed_event_list_t msg_fifo; ///< FIFO of outgoing message deliveries qd_router_delivery_list_t deliveries; ///< [own] outstanding unsettled deliveries }; ALLOC_DECLARE(qd_router_link_t); DEQ_DECLARE(qd_router_link_t, qd_router_link_list_t); void qd_router_link_free_LH(qd_router_link_t *); struct qd_router_node_t { DEQ_LINKS(qd_router_node_t); qd_address_t *owning_addr; int mask_bit; qd_router_node_t *next_hop; ///< Next hop node _if_ this is not a neighbor node qd_router_link_t *peer_link; ///< Outgoing link _if_ this is a neighbor node uint32_t ref_count; qd_bitmask_t *valid_origins; }; ALLOC_DECLARE(qd_router_node_t); DEQ_DECLARE(qd_router_node_t, qd_router_node_list_t); struct qd_router_ref_t { DEQ_LINKS(qd_router_ref_t); qd_router_node_t *router; }; ALLOC_DECLARE(qd_router_ref_t); DEQ_DECLARE(qd_router_ref_t, qd_router_ref_list_t); struct qd_router_link_ref_t { DEQ_LINKS(qd_router_link_ref_t); qd_router_link_t *link; }; ALLOC_DECLARE(qd_router_link_ref_t); DEQ_DECLARE(qd_router_link_ref_t, qd_router_link_ref_list_t); struct qd_lrp_t { DEQ_LINKS(qd_lrp_t); char *prefix; qd_lrp_container_t *container; }; DEQ_DECLARE(qd_lrp_t, qd_lrp_list_t); struct qd_lrp_container_t { DEQ_LINKS(qd_lrp_container_t); qd_dispatch_t *qd; qd_config_connector_t *cc; qd_lrp_list_t lrps; qd_timer_t *timer; qd_connection_t *conn; }; DEQ_DECLARE(qd_lrp_container_t, qd_lrp_container_list_t); struct qd_router_lrp_ref_t { DEQ_LINKS(qd_router_lrp_ref_t); qd_lrp_t *lrp; }; ALLOC_DECLARE(qd_router_lrp_ref_t); DEQ_DECLARE(qd_router_lrp_ref_t, qd_router_lrp_ref_list_t); struct qd_router_conn_t { int ref_count; int mask_bit; }; ALLOC_DECLARE(qd_router_conn_t); /** A router address */ struct qd_address_t { DEQ_LINKS(qd_address_t); qd_router_message_cb_t on_message; ///< In-Process Message Consumer void *on_message_context; ///< In-Process Consumer context qd_router_lrp_ref_list_t lrps; ///< Local link-route destinations qd_router_link_ref_list_t rlinks; ///< Locally-Connected Consumers qd_router_ref_list_t rnodes; ///< Remotely-Connected Consumers qd_hash_handle_t *hash_handle; ///< Linkage back to the hash table entry qd_address_semantics_t semantics; qd_address_t *redirect; qd_address_t *static_cc; qd_address_t *dynamic_cc; bool toggle; bool waypoint; bool block_deletion; qd_router_forwarder_t *forwarder; // // TODO - Add support for asynchronous address lookup: // - Add a FIFO for routed_events holding the message and delivery // - Add an indication that the address is awaiting a lookup response // /**@name Statistics */ ///@{ uint64_t deliveries_ingress; uint64_t deliveries_egress; uint64_t deliveries_transit; uint64_t deliveries_to_container; uint64_t deliveries_from_container; ///@} }; ALLOC_DECLARE(qd_address_t); DEQ_DECLARE(qd_address_t, qd_address_list_t); /** Constructor for qd_address_t */ qd_address_t* qd_address(qd_address_semantics_t semantics); struct qd_config_phase_t { DEQ_LINKS(qd_config_phase_t); char phase; qd_address_semantics_t semantics; }; DEQ_DECLARE(qd_config_phase_t, qd_config_phase_list_t); struct qd_config_address_t { DEQ_LINKS(qd_config_address_t); char *prefix; char last_phase; qd_config_phase_list_t phases; }; DEQ_DECLARE(qd_config_address_t, qd_config_address_list_t); /** * A waypoint is a point on a multi-phase route where messages can exit and re-enter the router. * * NOTE: a message received by a waypoint is first sent OUT and then received back IN. */ struct qd_waypoint_t { DEQ_LINKS(qd_waypoint_t); char *address; char in_phase; ///< Phase for re-entering message. char out_phase; ///< Phase for exiting message. char *connector_name; ///< On-demand connector name for outgoing messages. qd_config_connector_t *connector; ///< Connector for outgoing messages. qd_connection_t *connection; ///< Connection for outgoing messages. qd_link_t *in_link; ///< Link for re-entering messages. qd_link_t *out_link; ///< Link for exiting messages. qd_address_t *in_address; ///< Address for re-entering messages. qd_address_t *out_address; ///< Address for exiting messages. bool connected; ///< True if connected. }; DEQ_DECLARE(qd_waypoint_t, qd_waypoint_list_t); struct qd_router_t { qd_dispatch_t *qd; qd_log_source_t *log_source; qd_router_mode_t router_mode; const char *router_area; const char *router_id; qd_node_t *node; qd_address_list_t addrs; qd_hash_t *addr_hash; qd_address_t *router_addr; qd_address_t *routerma_addr; qd_address_t *hello_addr; qd_router_link_list_t links; qd_router_node_list_t routers; qd_lrp_container_list_t lrp_containers; qd_router_link_t **out_links_by_mask_bit; qd_router_node_t **routers_by_mask_bit; qd_bitmask_t *neighbor_free_mask; sys_mutex_t *lock; qd_timer_t *timer; uint64_t dtag; qd_config_address_list_t config_addrs; qd_waypoint_list_t waypoints; }; void qd_router_check_addr(qd_router_t *router, qd_address_t *addr, int was_local); void qd_router_add_link_ref_LH(qd_router_link_ref_list_t *ref_list, qd_router_link_t *link); void qd_router_del_link_ref_LH(qd_router_link_ref_list_t *ref_list, qd_router_link_t *link); void qd_router_add_node_ref_LH(qd_router_ref_list_t *ref_list, qd_router_node_t *rnode); void qd_router_del_node_ref_LH(qd_router_ref_list_t *ref_list, qd_router_node_t *rnode); void qd_router_add_lrp_ref_LH(qd_router_lrp_ref_list_t *ref_list, qd_lrp_t *lrp); void qd_router_del_lrp_ref_LH(qd_router_lrp_ref_list_t *ref_list, qd_lrp_t *lrp); void qd_router_mobile_added(qd_router_t *router, qd_field_iterator_t *iter); void qd_router_mobile_removed(qd_router_t *router, const char *addr); void qd_router_link_lost(qd_router_t *router, int link_mask_bit); qd_address_semantics_t router_semantics_for_addr(qd_router_t *router, qd_field_iterator_t *iter, char in_phase, char *out_phase); qd_address_t *qd_router_address_lookup_LH(qd_router_t *router, qd_field_iterator_t *addr_iter, bool *is_local, bool *is_direct); /** * Important: qd_router_link_new_delivery must never be called twice in a row * without an intervening pn_link_advance. The Disatch architecture * provides a hook for discovering when an outgoing link is writable * and has credit. When a link is writable, a delivery is * allocated, written, and advanced in one operation. If a backlog * of pending deliveries is created, an assertion will be thrown. */ qd_router_delivery_t *qd_router_link_new_delivery(qd_router_link_t *link, pn_delivery_tag_t tag); qd_router_delivery_t *qd_router_delivery(qd_router_link_t *link, pn_delivery_t *pnd); void qd_router_delivery_set_undeliverable_LH(qd_router_delivery_t *delivery); void qd_router_delivery_free_LH(qd_router_delivery_t *delivery, uint64_t final_disposition); void qd_router_delivery_link_peers_LH(qd_router_delivery_t *left, qd_router_delivery_t *right); void qd_router_delivery_unlink_LH(qd_router_delivery_t *delivery); void qd_router_delivery_fifo_enter_LH(qd_router_delivery_t *delivery); bool qd_router_delivery_fifo_exit_LH(qd_router_delivery_t *delivery); qd_router_delivery_t *qd_router_delivery_peer(qd_router_delivery_t *delivery); void qd_router_delivery_set_context(qd_router_delivery_t *delivery, void *context); void *qd_router_delivery_context(qd_router_delivery_t *delivery); pn_delivery_t *qd_router_delivery_pn(qd_router_delivery_t *delivery); void qd_router_delivery_settle(qd_router_delivery_t *delivery); bool qd_router_delivery_settled(qd_router_delivery_t *delivery); bool qd_router_delivery_disp_changed(qd_router_delivery_t *delivery); uint64_t qd_router_delivery_disp(qd_router_delivery_t *delivery); qd_router_link_t *qd_router_delivery_link(qd_router_delivery_t *delivery); #endif