fn new()

in quic/s2n-quic-transport/src/connection/connection_impl.rs [589:705]
104 lines of code
4 McCabe index (conditional complexity)

    fn new(parameters: ConnectionParameters<Self::Config>) -> Result<Self, connection::Error> {
        let mut event_context = EventContext {
            context: parameters.event_context,
            internal_connection_id: parameters.internal_connection_id,
            quic_version: parameters.quic_version,
        };

        let rtt_estimator = RttEstimator::new(parameters.limits.initial_round_trip_time());
        // Assume clients validate the server's address implicitly.
        let peer_validated = Self::Config::ENDPOINT_TYPE.is_server();
        // The path manager always starts with a single path containing the known peer and local
        // connection ids.
        let initial_path = path::Path::new(
            parameters.path_handle,
            parameters.peer_connection_id,
            parameters.local_connection_id,
            rtt_estimator,
            parameters.congestion_controller,
            peer_validated,
            parameters.mtu_config,
            parameters.limits.anti_amplification_multiplier(),
        );

        let path_manager = path::Manager::new(initial_path, parameters.peer_id_registry);

        let mut publisher =
            event_context.publisher(parameters.timestamp, parameters.event_subscriber);

        publisher.on_connection_started(event::builder::ConnectionStarted {
            path: event::builder::Path {
                local_addr: parameters.path_handle.local_address().into_event(),
                local_cid: parameters.local_connection_id.into_event(),
                remote_addr: parameters.path_handle.remote_address().into_event(),
                remote_cid: parameters.peer_connection_id.into_event(),
                id: path_manager.active_path_id().into_event(),
                is_active: true,
            },
        });

        publisher.on_mtu_updated(event::builder::MtuUpdated {
            path_id: path_manager.active_path_id().into_event(),
            mtu: path_manager
                .active_path()
                .mtu_controller
                .max_datagram_size() as u16,
            cause: MtuUpdatedCause::NewPath,
            search_complete: path_manager
                .active_path()
                .mtu_controller
                .is_search_completed(),
        });

        let wakeup_handle = Arc::from(parameters.wakeup_handle);
        let waker = Waker::from(wakeup_handle.clone());
        let mut connection = Self {
            local_id_registry: parameters.local_id_registry,
            open_registry: parameters.open_registry,
            timers: Default::default(),
            accept_state: AcceptState::Handshaking,
            state: ConnectionState::Handshaking,
            path_manager,
            limits: parameters.limits,
            error: Ok(()),
            close_sender: CloseSender::default(),
            space_manager: parameters.space_manager,
            wakeup_handle,
            waker,
            event_context,
        };

        if Config::ENDPOINT_TYPE.is_client() {
            if let Err(error) = connection.update_crypto_state(
                parameters.timestamp,
                parameters.event_subscriber,
                parameters.datagram_endpoint,
                parameters.dc_endpoint,
                parameters.limits_endpoint,
            ) {
                connection.with_event_publisher(
                    parameters.timestamp,
                    None,
                    parameters.event_subscriber,
                    |publisher, _path| {
                        use s2n_quic_core::event::{
                            builder::ConnectionClosed, ConnectionPublisher,
                        };
                        publisher.on_connection_closed(ConnectionClosed { error });
                    },
                );
                return Err(error);
            }
        }

        let meta = event::builder::ConnectionMeta {
            endpoint_type: Config::ENDPOINT_TYPE,
            id: connection.internal_connection_id().into(),
            timestamp: parameters.timestamp,
        };

        if let Some(duration) = parameters.event_subscriber.supervisor_timeout(
            &mut connection.event_context.context,
            &meta.into_event(),
            parameters.supervisor_context,
        ) {
            connection
                .timers
                .supervisor_timer
                .set(parameters.timestamp + duration);
        }

        connection
            .timers
            .max_handshake_duration_timer
            .set(parameters.timestamp + connection.limits.max_handshake_duration());

        Ok(connection)
    }