1

"""

     2

    Socket implementation helpers

     3

"""

     4

     5

from qmsk.net.socket import socket

     6

from qmsk.net.socket.constants import *

     7

     8

class SocketError (Exception) :

     9

    """

    10

        Base class of errors raised by the Socket classes.

    11

    """

    12

    13

class SocketBindAddrinfoError (SocketError) :

    14

    """

    15

        The socket was unable to socket()+bind() to the given addrinfo.

    16

    """

    17

    18

    def __init__ (self, addrinfo, error) :

    19

        """

    20

            addrinfo            - the addrinfo we tried to use

    21

            error               - the resulting error

    22

        """

    23

    24

        self.addrinfo = addrinfo

    25

        self.error = error

    26

    27

    def __str__ (self) :

    28

        return "Unable to bind() to %s: %s" % (self.addrinfo, self.error)

    29

    30

class SocketBindEndpointError (SocketError) :

    31

    """

    32

        The socket was unable to bind() to the any of the given endpoint's addresses.

    33

    """

    34

    35

    def __init__ (self, endpoint, errors) :

    36

        """

    37

            endpoint            - the endpoint we tried to bind to

    38

            errors              - a sequence of ServiceBindAddrinfoErrors describing the failed bind attempts.

    39

        """

    40

    41

        self.endpoint = endpoint

    42

        self.errors = errors

    43

    44

    def __str__ (self) :

    45

        # XXX: too verbose?

    46

        return "Unable to bind() to any addresses on endpoint %s:\n%s" % (self.endpoint, "\n".join(

    47

            "\t%s" % (error, ) for error in self.errors

    48

        ))

    49

    50

    51

class Base (object) :

    52

    """

    53

        Base class for all other socket-related classes, contains the underlying socket object.

    54

    """

    55

    56

    # the underlying socket object

    57

    sock = None

    58

    59

    def _init_sock (self, sock) :

    60

        """

    61

            Initialize with the given pre-existing socket.

    62

        """

    63

    64

        self.sock = sock

    65

    66

    67

class Common (Base) :

    68

    """

    69

        Common operations for Client/Service

    70

    """

    71

    72

    @classmethod

    73

    def _socket (self, family, socktype, protocol = 0) :

    74

        """

    75

            Construct and return a new socket object using the given parameters.

    76

        """

    77

    78

        return socket.socket(family, socktype, protocol)

    79

    80

    @classmethod

    81

    def _bind_addrinfo (cls, ai) :

    82

        """

    83

            This will attempt to create a new socket and bind it, based on the given addrinfo, returning the new socket.

    84

    85

            Raises a ServiceBindAddrinfoError if this fails

    86

        """

    87

    88

        try :

    89

            # socket()

    90

            sock = self._socket(ai.family, ai.socktype, ai.protocol)

    91

    92

            # bind()

    93

            sock.bind(ai.addr)

    94

    95

        # XXX: except socket.error as e :

    96

        except OSError, error : 

    97

            raise SocketBindAddrinfoError(ai, error)

    98

    99

        else :

   100

            return sock

   101

   102

    @classmethod

   103

    def _bind_endpoint (cls, endpoint, family, socktype, protocol=0) :

   104

        """

   105

            This will resolve the given endpoint, and attempt to create and bind a suitable socket and return it.

   106

   107

                endpoint        - local Endpoint to bind() to.

   108

                family          - socket address family to use.

   109

                socktype        - socket type to use

   110

                protocol        - (optional) specific protocol

   111

   112

            Raises a ServiceBindError if this is unable to create a bound socket.

   113

   114

            XXX: bind to all of the given endpoint's addresses instead of just one...?

   115

        """

   116

   117

        errors = []

   118

   119

        # resolve the endpoint and try socket+bind

   120

        for ai in endpoint.getaddrinfo(family, socktype, protocol, AI_PASSIVE) :

   121

            try :

   122

                # try to socket+bind this addrinfo

   123

                sock = cls._bind_addrinfo(ai)

   124

   125

            except SocketBindAddrinfoError, error :

   126

                # collect

   127

                errors.append(error)

   128

   129

                # keep trying

   130

                continue

   131

   132

            else :

   133

                # got a working socket :)

   134

                return sock

   135

   136

        else :

   137

            # no suitable address found :(

   138

            raise SocketBindEndpointError(endpoint, errors)

   139

   140

    def _init_endpoint (self, endpoint, family, socktype, protocol = 0) :

   141

        """

   142

            Initialize this socket by constructing a new socket with the given parameters, bound to the given endpoint,

   143

            if given. If no endpoint is given, this simply creates a socket with the given settings and does not bind

   144

            it anywhere.

   145

        """

   146

   147

        # create local socket

   148

        if endpoint :

   149

            # create a suitable socket bound to a the given endpoint

   150

            self.sock = self._bind_endpoint(endpoint, family, socktype, protocol)

   151

   152

        else :

   153

            # create a suitable socket not bound to anything

   154

            self.sock = self._socket(family, socktype, protocol)

   155

   156

   157

class Service (Common) :

   158

    """

   159

        Listener socket

   160

    """

   161

   162

    def _listen (self, backlog) :

   163

        """

   164

            Puts this socket into listen() mode with the given backlog.

   165

        """

   166

   167

        self.sock.listen(backlog)

   168

   169

class SocketConnectAddrinfoError (SocketError) :

   170

    """

   171

        The socket was unable to socket()+connect() to the given addrinfo.

   172

    """

   173

   174

    def __init__ (self, addrinfo, error) :

   175

        """

   176

            addrinfo            - the addrinfo we tried to use

   177

            error               - the resulting error

   178

        """

   179

   180

        self.addrinfo = addrinfo

   181

        self.error = error

   182

   183

    def __str__ (self) :

   184

        return "Unable to connect() to %s: %s" % (self.addrinfo, self.error)

   185

   186

class SocketConnectEndpointError (SocketError) :

   187

    """

   188

        The socket was unable to connect() to the any of the given endpoint's addresses.

   189

    """

   190

   191

    def __init__ (self, endpoint, errors) :

   192

        """

   193

            endpoint            - the endpoint we tried to connect to

   194

            errors              - a sequence of ServiceBindAddrinfoErrors describing the failed connect attempts.

   195

        """

   196

   197

        self.endpoint = endpoint

   198

        self.errors = errors

   199

   200

    def __str__ (self) :

   201

        # XXX: too verbose?

   202

        return "Unable to connect() to any addresses on endpoint %s:\n%s" % (self.endpoint, "\n".join(

   203

            "\t%s" % (error, ) for error in self.errors

   204

        ))

   205

   206

   207

class Client (Common) :

   208

    """

   209

        Connecting socket

   210

    """

   211

   212

    @classmethod

   213

    def _connect_sock_addr (cls, sock, addr) :

   214

        """

   215

            Attempt to connect the given socket to the given address.

   216

        """

   217

   218

        sock.connect(addr)

   219

   220

    @classmethod

   221

    def _connect_sock_addrinfo (cls, sock, ai) :

   222

        """

   223

            Attempt to connect the given socket to the given addrinfo's address.

   224

        """

   225

   226

        try :

   227

            cls._connect_sock_addr(sock, ai.addr)

   228

   229

        # XXX: except socket.error as e :

   230

        except OSError, error :

   231

            raise SocketConnectAddrinfoError(ai, error)

   232

   233

    @classmethod

   234

    def _connect_addrinfo (cls, ai) :

   235

        """

   236

            Attempt to create a socket and connect it based on the given addrinfo, returning the new socket is succesfull.

   237

        """

   238

   239

        try :

   240

            # socket()

   241

            sock = cls._socket(ai.family, ai.socktype, ai.protocol)

   242

   243

        # XXX: except socket.error as e :

   244

        except OSError, error : 

   245

            raise SocketConnectAddrinfoError(ai, error)

   246

   247

   248

        # try and connect() it

   249

        cls._connect_sock_addrinfo(sock, ai)

   250

   251

        # return once succesfully

   252

        return sock

   253

   254

    @classmethod

   255

    def _connect_sock_endpoint (cls, sock, endpoint, family, socktype, protocol = 0) :

   256

        """

   257

            Connect this socket to the given remote endpoint, using the given parameters to resolve the endpoint.

   258

        """

   259

   260

        errors = []

   261

   262

        # resolve the endpoint and try socket+bind

   263

        for ai in endpoint.getaddrinfo(family, socktype, protocol) :

   264

            try :

   265

                # try to connect the socket to this addrinfo

   266

                cls._connect_sock_addrinfo(sock, ai)

   267

   268

            except SocketConnectAddrinfoError, error :

   269

                # collect

   270

                errors.append(error)

   271

   272

                # keep trying

   273

                continue

   274

   275

            else :

   276

                # got a working socket :)

   277

                return

   278

   279

        else :

   280

            # no suitable address found :(

   281

            raise SocketConnectEndpointError(endpoint, errors)

   282

   283

    @classmethod

   284

    def _connect_endpoint (self, endpoint, family, socktype, protocol = 0) :

   285

        """

   286

            Create a new socket and connect it to the given remote endpoint, using the given parameters to resolve the

   287

            endpoint.

   288

        """

   289

   290

        errors = []

   291

   292

        # resolve the endpoint and try socket+bind

   293

        for ai in endpoint.getaddrinfo(family, socktype, protocol) :

   294

            try :

   295

                # try to socket+connect this addrinfo

   296

                sock = cls._connect_addrinfo(ai)

   297

   298

            except SocketConnectAddrinfoError, error :

   299

                # collect

   300

                errors.append(error)

   301

   302

                # keep trying

   303

                continue

   304

   305

            else :

   306

                # got a working socket :)

   307

                return sock

   308

   309

        else :

   310

            # no suitable address found :(

   311

            raise SocketConnectEndpointError(endpoint, errors)

   312

   313

    def _init_connect_endpoint (self, endpoint, family, socktype, protocol = 0):

   314

        """

   315

            If we already have an existing socket, connect it to the given endpoint, otherwise try and connect to the

   316

            given endpoint with a new socket.

   317

   318

            There is a subtle difference here, because if we have e.g. an IPv4 socket and try and connect it to an

   319

            endpoint with both IPv6 and IPv4 addresses, we will try to connect to an IPv6 address using the IPv4 socket,

   320

            and then to the IPv4 address using the IPv6 socket.

   321

   322

            If we do not yet have a socket, then we will attempt to connect to the IPv6 address using an IPv6 socket,

   323

            and to the IPv4 address using an IPv4 socket.

   324

        """

   325

   326

        if self.socket :

   327

            # connect with existing socket

   328

            self._connect_sock_endpoint(self.socket, endpoint, family, socktype, protocol)

   329

   330

        else :

   331

            # connect with new socket

   332

            self._connect_endpoint(endpoint, family, socktype, protocol)

   333

   334

class Stream (Base) :

   335

    """

   336

        Unbuffered byte-stream interface.

   337

    """

   338

   339

    def read (self, iov) :

   340

        return self.sock.read(iov)

   341

   342

    def readv (self, iovecs) :

   343

        return self.sock.readv(iovecs)

   344

   345

    def write (self, buf) :

   346

        return self.sock.write(buf)

   347

   348

    def writev (self, iovecs) :

   349

        return self.sock.writev(iovecs)

   350

   351

    def close (self) :

   352

        self.sock.close()

   353

   354

    def abort (self) :

   355

        # XXX: SO_LINGER magic

   356

   357

        raise NotImplementedError()

   358

   359