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

    75

    @classmethod

    77

        """

    78

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

    79

        """

    80

    84

        return socket.socket(family, socktype, protocol)

    85

    86

    @classmethod

    87

    def _bind_addrinfo (cls, ai) :

    88

        """

    89

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

    90

    91

            Raises a ServiceBindAddrinfoError if this fails

    92

        """

    93

    94

        try :

    95

            # socket()

    96

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

    97

    98

            # bind()

    99

            sock.bind(ai.addr)

   100

   101

        # XXX: except socket.error as e :

   102

        except OSError, error : 

   103

            raise SocketBindAddrinfoError(ai, error)

   104

   105

        else :

   106

            return sock

   107

   108

    @classmethod

   110

        """

   111

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

   112

   113

                endpoint        - local Endpoint to bind() to.

   115

                protocol        - (optional) specific protocol

   116

   117

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

   118

   119

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

   120

        """

   121

   122

        errors = []

   123

   127

        # resolve the endpoint and try socket+bind

   129

            try :

   130

                # try to socket+bind this addrinfo

   131

                sock = cls._bind_addrinfo(ai)

   132

   133

            except SocketBindAddrinfoError, error :

   134

                # collect

   135

                errors.append(error)

   136

   137

                # keep trying

   138

                continue

   139

   140

            else :

   141

                # got a working socket :)

   142

                return sock

   143

   144

        else :

   145

            # no suitable address found :(

   146

            raise SocketBindEndpointError(endpoint, errors)

   147

   149

        """

   150

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

   151

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

   152

            it anywhere.

   153

        """

   156

            # create a suitable socket bound to a the given endpoint

   159

        else :

   163

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

   164

   165

class Service (Common) :

   166

    """

   167

        Listener socket

   168

    """

   169

   170

    def _listen (self, backlog) :

   171

        """

   172

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

   173

        """

   174

   175

        self.sock.listen(backlog)

   176

   177

class SocketConnectAddrinfoError (SocketError) :

   178

    """

   179

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

   180

    """

   181

   182

    def __init__ (self, addrinfo, error) :

   183

        """

   184

            addrinfo            - the addrinfo we tried to use

   185

            error               - the resulting error

   186

        """

   187

   188

        self.addrinfo = addrinfo

   189

        self.error = error

   190

   191

    def __str__ (self) :

   192

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

   193

   194

class SocketConnectEndpointError (SocketError) :

   195

    """

   196

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

   197

    """

   198

   199

    def __init__ (self, endpoint, errors) :

   200

        """

   201

            endpoint            - the endpoint we tried to connect to

   202

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

   203

        """

   204

   205

        self.endpoint = endpoint

   206

        self.errors = errors

   207

   208

    def __str__ (self) :

   209

        # XXX: too verbose?

   210

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

   211

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

   212

        ))

   213

   214

   215

class Client (Common) :

   216

    """

   217

        Connecting socket

   218

    """

   219

   220

    @classmethod

   221

    def _connect_sock_addr (cls, sock, addr) :

   222

        """

   223

            Attempt to connect the given socket to the given address.

   224

        """

   225

   226

        sock.connect(addr)

   227

   228

    @classmethod

   229

    def _connect_sock_addrinfo (cls, sock, ai) :

   230

        """

   231

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

   232

        """

   233

   234

        try :

   235

            cls._connect_sock_addr(sock, ai.addr)

   236

   237

        # XXX: except socket.error as e :

   238

        except OSError, error :

   239

            raise SocketConnectAddrinfoError(ai, error)

   240

   241

    @classmethod

   242

    def _connect_addrinfo (cls, ai) :

   243

        """

   244

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

   245

        """

   246

   247

        try :

   248

            # socket()

   249

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

   250

   251

        # XXX: except socket.error as e :

   252

        except OSError, error : 

   253

            raise SocketConnectAddrinfoError(ai, error)

   254

   255

   256

        # try and connect() it

   257

        cls._connect_sock_addrinfo(sock, ai)

   258

   259

        # return once succesfully

   260

        return sock

   261

   262

    @classmethod

   264

        """

   265

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

   266

        """

   267

   268

        errors = []

   269

   273

        # resolve the endpoint and try socket+bind

   275

            try :

   276

                # try to connect the socket to this addrinfo

   277

                cls._connect_sock_addrinfo(sock, ai)

   278

   279

            except SocketConnectAddrinfoError, error :

   280

                # collect

   281

                errors.append(error)

   282

   283

                # keep trying

   284

                continue

   285

   286

            else :

   287

                # got a working socket :)

   288

                return

   289

   290

        else :

   291

            # no suitable address found :(

   292

            raise SocketConnectEndpointError(endpoint, errors)

   293

   294

    @classmethod

   296

        """

   297

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

   298

            endpoint.

   299

        """

   300

   301

        errors = []

   302

   306

        # resolve the endpoint and try socket+bind

   308

            try :

   309

                # try to socket+connect this addrinfo

   310

                sock = cls._connect_addrinfo(ai)

   311

   312

            except SocketConnectAddrinfoError, error :

   313

                # collect

   314

                errors.append(error)

   315

   316

                # keep trying

   317

                continue

   318

   319

            else :

   320

                # got a working socket :)

   321

                return sock

   322

   323

        else :

   324

            # no suitable address found :(

   325

            raise SocketConnectEndpointError(endpoint, errors)

   326

   328

        """

   329

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

   330

            given endpoint with a new socket.

   331

   332

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

   333

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

   334

            and then to the IPv4 address using the IPv6 socket.

   335

   336

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

   337

            and to the IPv4 address using an IPv4 socket.

   338

        """

   339

   340

        if self.socket :

   341

            # connect with existing socket

   343

   344

        else :

   345

            # connect with new socket

   347

   348

class Stream (Base) :

   349

    """

   350

        Unbuffered byte-stream interface.

   351

    """

   352

   353

    def read (self, iov) :

   354

        return self.sock.read(iov)

   355

   356

    def readv (self, iovecs) :

   357

        return self.sock.readv(iovecs)

   358

   359

    def write (self, buf) :

   360

        return self.sock.write(buf)

   361

   362

    def writev (self, iovecs) :

   363

        return self.sock.writev(iovecs)

   364

   365

    def close (self) :

   366

        self.sock.close()

   367

   368

    def abort (self) :

   369

        # XXX: SO_LINGER magic

   370

   371

        raise NotImplementedError()

   372

   373