Index: mapi.py

22 Oct 2009

Sounds like something that should have gone to the Candidate (Nov2009)
branch?
Gijs Molenaar wrote:
...
Update of /cvsroot/monetdb/clients/src/python/monetdb
In directory 23jxhf1.ch3.sourceforge.com:/tmp/cvs-serv12494
Modified Files:
   mapi.py 
Added Files:
   mapi2.py 
Log Message:
Both python2 and python3 can do import monetdb.mapi now. Change is backwards
compatible.
Previously you needed to do import monetdb.mapi3 in python3.

--- NEW FILE: mapi2.py ---
# The contents of this file are subject to the MonetDB Public License
# Version 1.1 (the "License"); you may not use this file except in
# compliance with the License. You may obtain a copy of the License at
# http://monetdb.cwi.nl/Legal/MonetDBLicense-1.1.html
#
# Software distributed under the License is distributed on an "AS IS"
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
# License for the specific language governing rights and limitations
# under the License.
#
# The Original Code is the MonetDB Database System.
#
# The Initial Developer of the Original Code is CWI.
# Portions created by CWI are Copyright (C) 1997-July 2008 CWI.
# Copyright August 2008-2009 MonetDB B.V.
# All Rights Reserved.
"""
this is the python 2.* implementation of the mapi API.
If you use python 3.* you should use mapi3.py
"""
import socket
import logging
import struct
from monetdb.monetdb_exceptions import *
logger = logging.getLogger("monetdb")
MAX_PACKAGE_LENGTH = (1024*8)-2
MSG_PROMPT = ""
MSG_INFO = "#"
MSG_ERROR = "!"
MSG_Q = "&"
MSG_QTABLE = "&1"
MSG_QUPDATE = "&2"
MSG_QSCHEMA = "&3"
MSG_QTRANS = "&4"
MSG_QPREPARE = "&5"
MSG_QBLOCK = "&6"
MSG_HEADER = "%"
MSG_TUPLE = "["
MSG_REDIRECT = "^"
STATE_INIT = 0
STATE_READY = 1
class Server:
    def __init__(self):
        self.state = STATE_INIT
        self._result = None
def connect(self, hostname, port, username, password, database, language):
    """ connect to a MonetDB database using the mapi protocol"""

    self.hostname = hostname
    self.port = port
    self.username = username
    self.password = password
    self.database = database
    self.language = language

    self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    try:
        self.socket.connect((hostname, port))
    except socket.error, error:
        (error_code, error_str) = error
        raise OperationalError(error_str)

    self.__login()


def __login(self, iteration=0):
    """ Reads challenge from line, generate response and check if
    everything is okay """

    challenge = self.__getblock()
    response = self.__challenge_response(challenge)
    self.__putblock(response)
    prompt = self.__getblock().strip()

    if len(prompt) == 0:
        # Empty response, server is happy
        pass
    elif prompt.startswith(MSG_INFO):
        logger.info("II %s" % prompt[1:])

    elif prompt.startswith(MSG_ERROR):
        logger.error(prompt[1:])
        raise DatabaseError(prompt[1:])

    elif prompt.startswith(MSG_REDIRECT):
        # a redirect can contain multiple redirects, for now we only use
        # the first
        response = prompt.split()[0][1:].split(':')
        if response[1] == "merovingian":
            logger.debug("II: merovingian proxy, restarting " +
                    "authenticatiton")
            if iteration <= 10:
                self.__login(iteration=iteration+1)
            else:
                raise OperationalError("maximal number of redirects " +
                "reached (10)")

        elif response[1] == "monetdb":
            self.hostname = response[2][2:]
            self.port, self.database = response[3].split('/')
            self.port = int(self.port)
            logger.info("II: merovingian redirect to monetdb://%s:%s/%s" %
                    (self.hostname, self.port, self.database))
            self.socket.close()
            self.connect(self.hostname, self.port, self.username,
                    self.password, self.database, self.language)

        else:
            logger.error('!' + prompt[0])
            raise ProgrammingError("unknown redirect: %s" % prompt)

    else:
        logger.error('!' + prompt[0])
        raise ProgrammingError("unknown state: %s" % prompt)

    self.state = STATE_READY
    return True


def disconnect(self):
    """ disconnect from the monetdb server """
    self.state = STATE_INIT
    self.socket.close()


def cmd(self, operation):
    """ put a mapi command on the line"""
    logger.debug("II: executing command %s" % operation)

    if self.state != STATE_READY:
        raise(ProgrammingError, "Not connected")

    self.__putblock(operation)
    response = self.__getblock()
    if not len(response):
        return
    if response[0] in [MSG_Q, MSG_HEADER, MSG_TUPLE]:
        return response
    elif response[0] == MSG_ERROR:
        raise OperationalError(response[1:])
    else:
        raise ProgrammingError("unknown state: %s" % response)


def __challenge_response(self, challenge):
    """ generate a response to a mapi login challenge """
    challenges = challenge.split(':')
    salt, identity, protocol, hashes, endian = challenges[:5]

    password = self.password

    if protocol == '9':
        algo = challenges[5]
        if algo == 'SHA512':
            import hashlib
            password = hashlib.sha512(password).hexdigest()
        elif algo == 'SHA384':
            import hashlib
            password = hashlib.sha384(password).hexdigest()
        elif algo == 'SHA256':
            import hashlib
            password = hashlib.sha256(password).hexdigest()
        elif algo == 'SHA224':
            import hashlib
            password = hashlib.sha224(password).hexdigest()
        elif algo == 'SHA1':
            import hashlib
            password = hashlib.sha1(password).hexdigest()
        elif algo == 'MD5':
            import hashlib
            password = hashlib.md5(password).hexdigest()
        else:
            raise NotSupportedError("The %s hash algorithm is not " +
                "supported" % algo)
    elif protocol != "8":
        raise NotSupportedError("We only speak protocol v8 and v9")

    h = hashes.split(",")
    if "SHA1" in h:
        import hashlib
        s = hashlib.sha1()
        s.update(password.encode())
        s.update(salt.encode())
        pwhash = "{SHA1}" + s.hexdigest()
    elif "MD5" in h:
        import hashlib
        m = hashlib.md5()
        m.update(password.encode())
        m.update(salt.encode())
        pwhash = "{MD5}" + m.hexdigest()
    elif "crypt" in h:
        import crypt
        pwhash = "{crypt}" + crypt.crypt((password+salt)[:8], salt[-2:])
    else:
        pwhash = "{plain}" + password + salt

    return ":".join(["BIG", self.username, pwhash, self.language,
        self.database]) + ":"


def __getblock(self):
    """ read one mapi encoded block """
    result = []
    last = 0
    while not last:
        flag = self.__getbytes(2)
        if len(flag) != 2:
            raise OperationalError("server returned %s bytes, I need 2" %
                    len(flag))

        # unpack (little endian short)
        unpacked = struct.unpack('<H', flag)[0]
        length = unpacked >> 1
        last = unpacked & 1
        logger.debug("II: reading %i bytes" % length)
        if length > 0:
            result.append(self.__getbytes(length))

    result_str = "".join(result)
    logger.debug("RX: %s" % result_str)
    return result_str


def __getbytes(self, bytes):
    """Read an amount of bytes from the socket"""
    try:
        return self.socket.recv(bytes)
    except socket.error, error:
        raise OperationalError(error[1])


def __putblock(self, block):
    """ wrap the line in mapi format and put it into the socket """
    pos = 0
    last = 0
    while not last:
        data = block[pos:pos+MAX_PACKAGE_LENGTH]
        length = len(data)
        if length < MAX_PACKAGE_LENGTH:
            last = 1
        flag = struct.pack( '<H', ( length << 1 ) + last )
        try:
            logger.debug("II: sending %i bytes, last: %s" % (length, last))
            logger.debug("TX: %s" % data)
            self.socket.send(flag)
            self.socket.send(data)
        except socket.error, error:
            raise OperationalError(error[1])
        pos += length



Index: mapi.py
RCS file: /cvsroot/monetdb/clients/src/python/monetdb/mapi.py,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- mapi.py	7 Jul 2009 11:15:45 -0000	1.17
+++ mapi.py	22 Oct 2009 10:25:35 -0000	1.18
@@ -1,263 +1,10 @@
-# The contents of this file are subject to the MonetDB Public License
-# Version 1.1 (the "License"); you may not use this file except in
-# compliance with the License. You may obtain a copy of the License at
-# http://monetdb.cwi.nl/Legal/MonetDBLicense-1.1.html
-#
-# Software distributed under the License is distributed on an "AS IS"
-# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
-# License for the specific language governing rights and limitations
-# under the License.
-#
-# The Original Code is the MonetDB Database System.
-#
-# The Initial Developer of the Original Code is CWI.
-# Portions created by CWI are Copyright (C) 1997-July 2008 CWI.
-# Copyright August 2008-2009 MonetDB B.V.
-# All Rights Reserved.



-"""
-this is the python 2.* implementation of the mapi API.



-If you use python 3.* you should use mapi3.py
-"""



-import socket
-import logging
-import struct



-from monetdb.monetdb_exceptions import *




-logger = logging.getLogger("monetdb")



-MAX_PACKAGE_LENGTH = (1024*8)-2



-MSG_PROMPT = ""
-MSG_INFO = "#"
-MSG_ERROR = "!"
-MSG_Q = "&"
-MSG_QTABLE = "&1"
-MSG_QUPDATE = "&2"
-MSG_QSCHEMA = "&3"
-MSG_QTRANS = "&4"
-MSG_QPREPARE = "&5"
-MSG_QBLOCK = "&6"
-MSG_HEADER = "%"
-MSG_TUPLE = "["
-MSG_REDIRECT = "^"



-STATE_INIT = 0
-STATE_READY = 1




-class Server:

def __init__(self):
   self.state = STATE_INIT


   self._result = None



def connect(self, hostname, port, username, password, database, language):
   """ connect to a MonetDB database using the mapi protocol"""



   self.hostname = hostname


   self.port = port


   self.username = username


   self.password = password


   self.database = database


   self.language = language



   self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)



   try:


       self.socket.connect((hostname, port))


   except socket.error, error:


       (error_code, error_str) = error


       raise OperationalError(error_str)



   self.__login()




def __login(self, iteration=0):
   """ Reads challenge from line, generate response and check if


   everything is okay """



   challenge = self.__getblock()


   response = self.__challenge_response(challenge)


   self.__putblock(response)


   prompt = self.__getblock().strip()



   if len(prompt) == 0:


       # Empty response, server is happy


       pass


   elif prompt.startswith(MSG_INFO):


       logger.info("II %s" % prompt[1:])



   elif prompt.startswith(MSG_ERROR):


       logger.error(prompt[1:])


       raise DatabaseError(prompt[1:])



   elif prompt.startswith(MSG_REDIRECT):


       # a redirect can contain multiple redirects, for now we only use


       # the first


       response = prompt.split()[0][1:].split(':')


       if response[1] == "merovingian":


           logger.debug("II: merovingian proxy, restarting " +


                   "authenticatiton")


           if iteration <= 10:


               self.__login(iteration=iteration+1)


           else:


               raise OperationalError("maximal number of redirects " +


               "reached (10)")



       elif response[1] == "monetdb":


           self.hostname = response[2][2:]


           self.port, self.database = response[3].split('/')


           self.port = int(self.port)


           logger.info("II: merovingian redirect to monetdb://%s:%s/%s" %


                   (self.hostname, self.port, self.database))


           self.socket.close()


           self.connect(self.hostname, self.port, self.username,


                   self.password, self.database, self.language)



       else:


           logger.error('!' + prompt[0])


           raise ProgrammingError("unknown redirect: %s" % prompt)



   else:


       logger.error('!' + prompt[0])


       raise ProgrammingError("unknown state: %s" % prompt)



   self.state = STATE_READY


   return True




def disconnect(self):
   """ disconnect from the monetdb server """


   self.state = STATE_INIT


   self.socket.close()




def cmd(self, operation):
   """ put a mapi command on the line"""


   logger.debug("II: executing command %s" % operation)



   if self.state != STATE_READY:


       raise(ProgrammingError, "Not connected")



   self.__putblock(operation)


   response = self.__getblock()


   if not len(response):


       return


   if response[0] in [MSG_Q, MSG_HEADER, MSG_TUPLE]:


       return response


   elif response[0] == MSG_ERROR:


       raise OperationalError(response[1:])


   else:


       raise ProgrammingError("unknown state: %s" % response)




def __challenge_response(self, challenge):
   """ generate a response to a mapi login challenge """


   challenges = challenge.split(':')


   salt, identity, protocol, hashes, endian = challenges[:5]



   password = self.password



   if protocol == '9':


       algo = challenges[5]


       if algo == 'SHA512':


           import hashlib


           password = hashlib.sha512(password).hexdigest()


       elif algo == 'SHA384':


           import hashlib


           password = hashlib.sha384(password).hexdigest()


       elif algo == 'SHA256':


           import hashlib


           password = hashlib.sha256(password).hexdigest()


       elif algo == 'SHA224':


           import hashlib


           password = hashlib.sha224(password).hexdigest()


       elif algo == 'SHA1':


           import hashlib


           password = hashlib.sha1(password).hexdigest()


       elif algo == 'MD5':


           import hashlib


           password = hashlib.md5(password).hexdigest()


       else:


           raise NotSupportedError("The %s hash algorithm is not " +


               "supported" % algo)


   elif protocol != "8":


       raise NotSupportedError("We only speak protocol v8 and v9")



   h = hashes.split(",")


   if "SHA1" in h:


       import hashlib


       s = hashlib.sha1()


       s.update(password.encode())


       s.update(salt.encode())


       pwhash = "{SHA1}" + s.hexdigest()


   elif "MD5" in h:


       import hashlib


       m = hashlib.md5()


       m.update(password.encode())


       m.update(salt.encode())


       pwhash = "{MD5}" + m.hexdigest()


   elif "crypt" in h:


       import crypt


       pwhash = "{crypt}" + crypt.crypt((password+salt)[:8], salt[-2:])


   else:


       pwhash = "{plain}" + password + salt



   return ":".join(["BIG", self.username, pwhash, self.language,


       self.database]) + ":"




def __getblock(self):
   """ read one mapi encoded block """


   result = []


   last = 0


   while not last:


       flag = self.__getbytes(2)


       if len(flag) != 2:


           raise OperationalError("server returned %s bytes, I need 2" %


                   len(flag))



       # unpack (little endian short)


       unpacked = struct.unpack('<H', flag)[0]


       length = unpacked >> 1


       last = unpacked & 1


       logger.debug("II: reading %i bytes" % length)


       if length > 0:


           result.append(self.__getbytes(length))



   result_str = "".join(result)


   logger.debug("RX: %s" % result_str)


   return result_str




def __getbytes(self, bytes):
   """Read an amount of bytes from the socket"""


   try:


       return self.socket.recv(bytes)


   except socket.error, error:


       raise OperationalError(error[1])




+import sys

def __putblock(self, block):
   """ wrap the line in mapi format and put it into the socket """


   pos = 0


   last = 0


   while not last:


       data = block[pos:pos+MAX_PACKAGE_LENGTH]


       length = len(data)


       if length < MAX_PACKAGE_LENGTH:


           last = 1


       flag = struct.pack( '<H', ( length << 1 ) + last )


       try:


           logger.debug("II: sending %i bytes, last: %s" % (length, last))


           logger.debug("TX: %s" % data)


           self.socket.send(flag)


           self.socket.send(data)


       except socket.error, error:


           raise OperationalError(error[1])


       pos += length



+# a ugly hack to support python 2 and 3 at the same time
+(major, minor, micro, level, serial)  = sys.version_info
+if (major == 3):

from monetdb.mapi3 import *

+else:

from monetdb.mapi2 import *


Come build with us! The BlackBerry(R) Developer Conference in SF, CA
is the only developer event you need to attend this year. Jumpstart your
developing skills, take BlackBerry mobile applications to market and stay 
ahead of the curve. Join us from November 9 - 12, 2009. Register now!
http://p.sf.net/sfu/devconference
_______________________________________________
Monetdb-checkins mailing list
Monetdb-checkins@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/monetdb-checkins
-- 
Sjoerd Mullender


    

Re: [Monetdb-developers] [Monetdb-checkins] clients/src/python/monetdb mapi2.py, , NONE, 1.1 mapi.py, , 1.17, 1.18

Sjoerd Mullender

Index: mapi.py

tags (0)

participants (1)