1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

use std::time::Duration;
use std::sync::Arc;

use websocket::{Config};

impl Config {
    /// Create a config with defaults
    pub fn new() -> Config {
        Config {
            ping_interval: Duration::new(10, 0),
            message_timeout: Duration::new(30, 0),
            byte_timeout: Duration::new(30, 0),
            max_packet_size: 10 << 20,
        }
    }
    /// Set ping interval
    ///
    /// Default is 10 seconds.
    ///
    /// If no messages have been received within this interval, we send
    /// a ping message. Only full messages are accounted. If some large
    /// frame is being received for this long, we still send ping.
    ///
    /// Note: you can't remove the interval, but you can set it to
    /// a sufficiently large value.
    ///
    /// Note 2: you may also need to tune inactivity timeout if you change
    /// this value.
    pub fn ping_interval(&mut self, dur: Duration) -> &mut Self {
        self.ping_interval = dur;
        self
    }

    /// Set inactivity timeout
    ///
    /// Default is 25 seconds.
    ///
    /// A connection is shut down if no messages were received during this
    /// interval.
    ///
    /// Note: only full frames are accounted. If some very large frame is
    /// being sent too long, we drop the connection. So be sure to set this
    /// value large enough so that slowest client can send largest frame and
    /// another ping.
    ///
    /// There are two use cases for this interval:
    ///
    /// 1. Make it 2.5x the ping_interval to detect connections which
    ///    don't have destination host alive
    ///
    /// 2. Inactivity interval that is smaller than `ping_interval` will
    ///    detect connections which are alive but do not send any messages.
    ///    This is similar to how HTTP servers shutdown inactive connections.
    ///
    /// Note: you may also need to tune ping interval if you change
    /// this value.
    pub fn message_timeout(&mut self, dur: Duration) -> &mut Self {
        self.message_timeout = dur;
        self
    }

    /// Sets both message timeout and byte timeout to the same value
    pub fn inactivity_timeout(&mut self, dur: Duration) -> &mut Self {
        self.message_timeout = dur;
        self.byte_timeout = dur;
        self
    }

    /// Similar to message timeout but works at byte level
    ///
    /// Being less strict timeout this value is two-way: any byte sent or
    /// received resets the timer (Also, we do our best to ignore outgoing
    /// pings)
    ///
    /// There are two points to consider for tweaking timeout:
    ///
    /// 1. To prevent resource exhaustion by a peer: sending a byte at a time,
    ///    you might make it higher, up to message timeout
    /// 2. To be able to receive larger messages (say 1Mb or 10 Mb) you can
    ///    make message timeout much larger for largest message to fit, but
    ///    make byte timeout smaller so that if nothing it being received you
    ///    can close connection earlier.
    ///
    /// Note: there is no sense to make this value larger than message_timeout
    pub fn byte_timeout(&mut self, dur: Duration) -> &mut Self {
        self.byte_timeout = dur;
        self
    }

    /// Maximum packet size
    ///
    /// If some frame declares size larger than this, we immediately abort
    /// the connection
    pub fn max_packet_size(&mut self, size: usize) -> &mut Self {
        self.max_packet_size = size;
        self
    }

    /// Create a Arc'd config clone to pass to the constructor
    ///
    /// This is just a convenience method.
    pub fn done(&mut self) -> Arc<Config> {
        Arc::new(self.clone())
    }
}