Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

# -*- coding: utf-8 -*- 

""" 

Module to manage SeedLinkConnection state. 

 

Part of Python implementation of libslink of Chad Trabant and 

JSeedLink of Anthony Lomax 

 

:copyright: 

    The ObsPy Development Team (devs@obspy.org) & Anthony Lomax 

:license: 

    GNU Lesser General Public License, Version 3 

    (http://www.gnu.org/copyleft/lesser.html) 

""" 

 

from obspy.seedlink.seedlinkexception import SeedLinkException 

from obspy.seedlink.slpacket import SLPacket 

 

 

class SLState(object): 

    """ 

     Class to manage SeedLinkConnection state. 

 

    :var SL_DOWN: Connection state down. 

    :type SL_DOWN: int 

    :var SL_UP: Connection state up. 

    :type SL_UP: int 

    :var SL_DATA: Connection state data. 

    :type SL_DATA: int 

    :var state: Connection state. 

    :type state: int 

    :var NO_QUERY: INFO query state NO_QUERY. 

    :type NO_QUERY: int 

    :var INFO_QUERY: INFO query state INFO_QUERY. 

    :type INFO_QUERY: int. 

    :var KEEP_ALIVE_QUERY: INFO query state KEEP_ALIVE_QUERY. 

    :type KEEP_ALIVE_QUERY: int 

    :var query_mode: INFO query state. 

    :type query_mode: int 

    :var BUFSIZE: Size of receiving buffer (default is 8192). 

    :type BUFSIZE: int 

    :var databuf: Data buffer for received packets. 

    :type databuf: bytearray 

    :var recptr: Receive pointer for databuf. 

    :type recptr: int 

    :var sendptr: Send pointer for databuf. 

    :type sendptr: int 

    :var expect_info: Flag to indicate if an INFO response is expected. 

    :type expect_info: boolean 

    :var netto_trig: Network timeout trigger.netto_trig 

    :type netto_trig: int 

    :var netdly_trig: Network re-connect delay trigger. 

    :type netdly_trig: int 

    :var keepalive_trig: Send keepalive trigger. 

    :type keepalive_trig: TTT 

    :var previous_time: Time stamp of last state update. 

    :type previous_time: float 

    :var netto_time: Network timeout time stamp. 

    :type netto_time: float 

    :var netdly_time: Network re-connect delay time stamp. 

    :type netdly_time: float 

    :var keepalive_time: Keepalive time stamp. 

    :type keepalive_time: float 

    """ 

    SL_DOWN = 0 

    SL_UP = 1 

    SL_DATA = 2 

    NO_QUERY = 0 

    INFO_QUERY = 1 

    KEEP_ALIVE_QUERY = 2 

    BUFSIZE = 8192 

 

    state = SL_DOWN 

    query_mode = NO_QUERY 

    #AJL databuf = [str() for __idx0 in range(BUFSIZE)] 

    databuf = bytearray(BUFSIZE) 

    recptr = 0 

    sendptr = 0 

    expect_info = False 

    netto_trig = -1 

    netdly_trig = 0 

    keepalive_trig = -1 

    previous_time = 0.0 

    netto_time = 0.0 

    netdly_time = 0.0 

    keepalive_time = 0.0 

 

    def __init__(self): 

        pass 

 

    def getPacket(self): 

        """ 

        Returns last received packet. 

 

        :return: last received packet if data buffer contains a full packet to 

            send. 

        :raise: SeedLinkException if there is not a packet ready to send. 

 

        See also: :meth:`packetAvailable` 

        """ 

        if not self.packetAvailable(): 

            raise SeedLinkException("SLPacket not available to send") 

        return SLPacket(self.databuf, self.sendptr) 

 

    def packetAvailable(self): 

        """ 

        Check for full packet available to send. 

 

        :return: true if data buffer contains a full packet to send. 

 

        See also: :meth:`getPacket` 

 

        """ 

        return self.recptr - self.sendptr >= \ 

            SLPacket.SLHEADSIZE + SLPacket.SLRECSIZE 

 

    def bytesRemaining(self): 

        """ 

        Return number of bytes remaining in receiving buffer. 

 

        :return: number of bytes remaining. 

 

        """ 

        return self.BUFSIZE - self.recptr 

 

    def isError(self): 

        """ 

        Check for SeedLink ERROR packet. 

 

        :return: true if next send packet is a SeedLink ERROR packet 

 

        :raise: SeedLinkException if there are not enough bytes to determine 

 

        """ 

        if self.recptr - self.sendptr < len(SLPacket.ERRORSIGNATURE): 

            msg = "not enough bytes to determine packet type" 

            raise SeedLinkException(msg) 

        return self.databuf[self.sendptr: self.sendptr + \ 

                            len(SLPacket.ERRORSIGNATURE)].lower() == \ 

                            SLPacket.ERRORSIGNATURE.lower() 

 

    def isEnd(self): 

        """ 

        Check for SeedLink END packet. 

 

        :return: true if next send packet is a SeedLink END packet 

 

        :raise: SeedLinkException if there are not enough bytes to determine 

        """ 

        if self.recptr - self.sendptr < len(SLPacket.ENDSIGNATURE): 

            msg = "not enough bytes to determine packet type" 

            raise SeedLinkException(msg) 

        return self.databuf[self.sendptr: self.sendptr + \ 

                            len(SLPacket.ENDSIGNATURE)].lower() == \ 

                            SLPacket.ENDSIGNATURE.lower() 

 

    def packetIsInfo(self): 

        """ 

        Check for SeedLink INFO packet. 

 

        :return: true if next send packet is a SeedLink INFO packet 

 

        :raise: SeedLinkException if there are not enough bytes to determine 

            packet type 

        """ 

        if self.recptr - self.sendptr < len(SLPacket.INFOSIGNATURE): 

            msg = "not enough bytes to determine packet type" 

            raise SeedLinkException(msg) 

        return self.databuf[self.sendptr: self.sendptr + \ 

                            len(SLPacket.INFOSIGNATURE)].lower() == \ 

                            SLPacket.INFOSIGNATURE.lower() 

 

    def incrementSendPointer(self): 

        """ 

        Increments the send pointer by size of one packet. 

 

        """ 

        self.sendptr += SLPacket.SLHEADSIZE + SLPacket.SLRECSIZE 

 

    #AJL packed_buf = [str() for __idx0 in range(BUFSIZE)] 

    packed_buf = bytearray(BUFSIZE) 

 

    def packDataBuffer(self): 

        """ 

        Packs the buffer by removing all sent packets and shifting remaining 

        bytes to beginning of buffer. 

        """ 

        #AJL System.arraycopy(self.databuf, self.sendptr, self.packed_buf, 0, 

        #                     self.recptr - self.sendptr) 

        self.packed_buf[0:self.recptr - self.sendptr] = \ 

            self.databuf[self.sendptr: self.recptr] 

        temp_buf = self.databuf 

        self.databuf = self.packed_buf 

        self.packed_buf = temp_buf 

        self.recptr -= self.sendptr 

        self.sendptr = 0 

 

    def appendBytes(self, bytes): 

        """ 

        Appends bytes to the receive buffer after the last received data. 

        """ 

        if self.bytesRemaining() < len(bytes): 

            msg = "not enough bytes remaining in buffer to append new bytes" 

            raise SeedLinkException(msg) 

        ## for-while 

        for i in range(len(bytes)): 

            self.databuf[self.recptr] = bytes[i] 

            self.recptr += 1