[Async 0.1] Listen on a range of ports, and feed into a single consumer

The idea is to create a TcpListener at each port. I make mutable references to self's fields, and then within each future::lazy, I make use of those mutable references.

    /// Starts the server
    pub fn start_server<'a: 'cxn>(mut self) -> impl Future<Item=(), Error=ConnectError<'cxn>> + 'cxn {
        let range = self.metadata.port_range.clone();
        let range_len = range.len();
        let offset = range.start as usize;
        let local_ip = self.metadata.local_bind_addr.unwrap();

        let outbound_txs_ref = &mut self.outbound_txs;
        let _ = &mut self.outbound_rxs;

        let signal_txs_ref = &mut self.signal_txs;

        // inbound channels all feed into the singular `inbound_rx` channel. As such, we need to clone 19 more versions to get MP -> SC
        let (inbound_tx, inbound_rx) = unbounded::<RawInboundItem>();


        let inbound_txs_ref = &mut self.inbound_txs;

        for _ in 0..(range_len - 1) {
            inbound_txs_ref.push(inbound_tx.clone());
        }

        inbound_txs_ref.push(inbound_tx);

        self.inbound_sink = Some(inbound_rx); // This is the single consumer... the output of all port's packets

        let mut futures = Vec::with_capacity(range_len);
        let futures_ref = &mut futures;

        for port in 0..range_len {
            let future = futures::lazy(move || {
                let port = (port + offset) as u16;
                let local_addr = SocketAddr::new(IpAddr::from_str(local_ip).unwrap(), port);
                let server = TcpListener::bind(&local_addr).unwrap();

                println!("[Server Listener] {} started!", local_addr.to_string());
                server.incoming().map_err(|_| ConnectError::Generic("Server error. DEBUG NOTE: FIX THIS TO GET ERROR TYPE")).for_each(move |stream| {
                    let remote_addr = stream.peer_addr().unwrap();
                    let addr = remote_addr.to_string();
                    println!("[Server] Connection with {} established!", addr);

                    let metadata = NetStreamMetadata::new_client_stream_meta(addr.as_str(), remote_addr.port(), local_ip, port).unwrap();
                    let (signal_tx, signal_rx) = channel::<u8>(3);
                    let (outbound_tx, outbound_rx) =unbounded::<OutboundItem>();

                    signal_txs_ref.push(signal_tx);
                    outbound_txs_ref.push(outbound_tx);

                    crate::connection::stream_wrappers::old::base64(stream, metadata, outbound_rx, inbound_txs_ref.remove((port - offset as u16) as usize), signal_rx)
                }).map_err(|err| {
                    println!("ERR: {:#?}", &err);
                    err
                }).map(|_| ())
            });

            futures_ref.push(future);
        }

        let listener = self.inbound_sink.unwrap().for_each(|packet| {
            println!("Packet received: {}", String::from_utf8(packet.data.to_vec()).unwrap());
            Ok(())
        }).map_err(|_| ());

        futures::future::select_all(futures).map(|_| ()).map_err(|_| ConnectError::Generic("Error propagated from one of the sockets"))
            .select(listener.map_err(|_| ConnectError::Generic("Error propagated")))
            .map(|_| ())
            .map_err(|err| err.0)
    }

However, I am getting this error from the borrow checker, as I cannot use the mutable references to the fields of self (e.g., signal_txs_ref) as it moves "in the previous iteration of the loop" . Preferably, I would have this designed such that the method signature uses a mutable reference of self rather than consuming self... do you guys have any ideas?