googlecloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/boto/sqs/jsonmessage.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2006-2008 Mitch Garnaat http://garnaat.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+import base64
+
+from boto.sqs.message import MHMessage
+from boto.exception import SQSDecodeError
+from boto.compat import json
+
+
+class JSONMessage(MHMessage):
+    """
+    Acts like a dictionary but encodes it's data as a Base64 encoded JSON payload.
+    """
+
+    def decode(self, value):
+        try:
+            value = base64.b64decode(value)
+            value = json.loads(value)
+        except:
+            raise SQSDecodeError('Unable to decode message', self)
+        return value
+
+    def encode(self, value):
+        value = json.dumps(value)
+        return base64.b64encode(value)

data/packages/gsutil/boto/boto/sqs/message.py

@@ -0,0 +1,253 @@
+# Copyright (c) 2006,2007 Mitch Garnaat http://garnaat.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+SQS Message
+
+A Message represents the data stored in an SQS queue.  The rules for what is allowed within an SQS
+Message are here:
+
+    http://docs.amazonwebservices.com/AWSSimpleQueueService/2008-01-01/SQSDeveloperGuide/Query_QuerySendMessage.html
+
+So, at it's simplest level a Message just needs to allow a developer to store bytes in it and get the bytes
+back out.  However, to allow messages to have richer semantics, the Message class must support the 
+following interfaces:
+
+The constructor for the Message class must accept a keyword parameter "queue" which is an instance of a
+boto Queue object and represents the queue that the message will be stored in.  The default value for
+this parameter is None.
+
+The constructor for the Message class must accept a keyword parameter "body" which represents the
+content or body of the message.  The format of this parameter will depend on the behavior of the
+particular Message subclass.  For example, if the Message subclass provides dictionary-like behavior to the
+user the body passed to the constructor should be a dict-like object that can be used to populate
+the initial state of the message.
+
+The Message class must provide an encode method that accepts a value of the same type as the body
+parameter of the constructor and returns a string of characters that are able to be stored in an
+SQS message body (see rules above).
+
+The Message class must provide a decode method that accepts a string of characters that can be
+stored (and probably were stored!) in an SQS message and return an object of a type that is consistent
+with the "body" parameter accepted on the class constructor.
+
+The Message class must provide a __len__ method that will return the size of the encoded message
+that would be stored in SQS based on the current state of the Message object.
+
+The Message class must provide a get_body method that will return the body of the message in the
+same format accepted in the constructor of the class.
+
+The Message class must provide a set_body method that accepts a message body in the same format
+accepted by the constructor of the class.  This method should alter to the internal state of the
+Message object to reflect the state represented in the message body parameter.
+
+The Message class must provide a get_body_encoded method that returns the current body of the message
+in the format in which it would be stored in SQS.
+"""
+
+import base64
+import StringIO
+from boto.sqs.attributes import Attributes
+from boto.exception import SQSDecodeError
+import boto
+
+class RawMessage:
+    """
+    Base class for SQS messages.  RawMessage does not encode the message
+    in any way.  Whatever you store in the body of the message is what
+    will be written to SQS and whatever is returned from SQS is stored
+    directly into the body of the message.
+    """
+    
+    def __init__(self, queue=None, body=''):
+        self.queue = queue
+        self.set_body(body)
+        self.id = None
+        self.receipt_handle = None
+        self.md5 = None
+        self.attributes = Attributes(self)
+
+    def __len__(self):
+        return len(self.encode(self._body))
+
+    def startElement(self, name, attrs, connection):
+        if name == 'Attribute':
+            return self.attributes
+        return None
+
+    def endElement(self, name, value, connection):
+        if name == 'Body':
+            self.set_body(self.decode(value))
+        elif name == 'MessageId':
+            self.id = value
+        elif name == 'ReceiptHandle':
+            self.receipt_handle = value
+        elif name == 'MD5OfMessageBody':
+            self.md5 = value
+        else:
+            setattr(self, name, value)
+
+    def encode(self, value):
+        """Transform body object into serialized byte array format."""
+        return value
+
+    def decode(self, value):
+        """Transform seralized byte array into any object."""
+        return value
+ 
+    def set_body(self, body):
+        """Override the current body for this object, using decoded format."""
+        self._body = body
+
+    def get_body(self):
+        return self._body
+    
+    def get_body_encoded(self):
+        """
+        This method is really a semi-private method used by the Queue.write
+        method when writing the contents of the message to SQS.
+        You probably shouldn't need to call this method in the normal course of events.
+        """
+        return self.encode(self.get_body())
+
+    def delete(self):
+        if self.queue:
+            return self.queue.delete_message(self)
+
+    def change_visibility(self, visibility_timeout):
+        if self.queue:
+            self.queue.connection.change_message_visibility(self.queue,
+                                                            self.receipt_handle,
+                                                            visibility_timeout)
+    
+class Message(RawMessage):
+    """
+    The default Message class used for SQS queues.  This class automatically
+    encodes/decodes the message body using Base64 encoding to avoid any
+    illegal characters in the message body.  See:
+
+    http://developer.amazonwebservices.com/connect/thread.jspa?messageID=49680%EC%88%90
+
+    for details on why this is a good idea.  The encode/decode is meant to
+    be transparent to the end-user.
+    """
+    
+    def encode(self, value):
+        return base64.b64encode(value)
+
+    def decode(self, value):
+        try:
+            value = base64.b64decode(value)
+        except:
+            boto.log.warning('Unable to decode message')
+            return value
+        return value
+
+class MHMessage(Message):
+    """
+    The MHMessage class provides a message that provides RFC821-like
+    headers like this:
+
+    HeaderName: HeaderValue
+
+    The encoding/decoding of this is handled automatically and after
+    the message body has been read, the message instance can be treated
+    like a mapping object, i.e. m['HeaderName'] would return 'HeaderValue'.
+    """
+
+    def __init__(self, queue=None, body=None, xml_attrs=None):
+        if body == None or body == '':
+            body = {}
+        Message.__init__(self, queue, body)
+
+    def decode(self, value):
+        try:
+            msg = {}
+            fp = StringIO.StringIO(value)
+            line = fp.readline()
+            while line:
+                delim = line.find(':')
+                key = line[0:delim]
+                value = line[delim+1:].strip()
+                msg[key.strip()] = value.strip()
+                line = fp.readline()
+        except:
+            raise SQSDecodeError('Unable to decode message', self)
+        return msg
+
+    def encode(self, value):
+        s = ''
+        for item in value.items():
+            s = s + '%s: %s\n' % (item[0], item[1])
+        return s
+
+    def __getitem__(self, key):
+        if key in self._body:
+            return self._body[key]
+        else:
+            raise KeyError(key)
+
+    def __setitem__(self, key, value):
+        self._body[key] = value
+        self.set_body(self._body)
+
+    def keys(self):
+        return self._body.keys()
+
+    def values(self):
+        return self._body.values()
+
+    def items(self):
+        return self._body.items()
+
+    def has_key(self, key):
+        return key in self._body
+
+    def update(self, d):
+        self._body.update(d)
+        self.set_body(self._body)
+
+    def get(self, key, default=None):
+        return self._body.get(key, default)
+
+class EncodedMHMessage(MHMessage):
+    """
+    The EncodedMHMessage class provides a message that provides RFC821-like
+    headers like this:
+
+    HeaderName: HeaderValue
+
+    This variation encodes/decodes the body of the message in base64 automatically.
+    The message instance can be treated like a mapping object,
+    i.e. m['HeaderName'] would return 'HeaderValue'.
+    """
+
+    def decode(self, value):
+        try:
+            value = base64.b64decode(value)
+        except:
+            raise SQSDecodeError('Unable to decode message', self)
+        return MHMessage.decode(self, value)
+
+    def encode(self, value):
+        value = MHMessage.encode(self, value)
+        return base64.b64encode(value)
+    

data/packages/gsutil/boto/boto/sqs/queue.py

@@ -0,0 +1,478 @@
+# Copyright (c) 2006-2009 Mitch Garnaat http://garnaat.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+"""
+Represents an SQS Queue
+"""
+
+import urlparse
+from boto.sqs.message import Message
+
+
+class Queue:
+
+    def __init__(self, connection=None, url=None, message_class=Message):
+        self.connection = connection
+        self.url = url
+        self.message_class = message_class
+        self.visibility_timeout = None
+
+    def __repr__(self):
+        return 'Queue(%s)' % self.url
+
+    def _id(self):
+        if self.url:
+            val = urlparse.urlparse(self.url)[2]
+        else:
+            val = self.url
+        return val
+    id = property(_id)
+
+    def _name(self):
+        if self.url:
+            val = urlparse.urlparse(self.url)[2].split('/')[2]
+        else:
+            val = self.url
+        return  val
+    name = property(_name)
+
+    def _arn(self):
+        parts = self.id.split('/')
+        return 'arn:aws:sqs:%s:%s:%s' % (
+            self.connection.region.name, parts[1], parts[2])
+    arn = property(_arn)
+
+    def startElement(self, name, attrs, connection):
+        return None
+
+    def endElement(self, name, value, connection):
+        if name == 'QueueUrl':
+            self.url = value
+        elif name == 'VisibilityTimeout':
+            self.visibility_timeout = int(value)
+        else:
+            setattr(self, name, value)
+
+    def set_message_class(self, message_class):
+        """
+        Set the message class that should be used when instantiating
+        messages read from the queue.  By default, the class
+        :class:`boto.sqs.message.Message` is used but this can be overriden
+        with any class that behaves like a message.
+
+        :type message_class: Message-like class
+        :param message_class:  The new Message class
+        """
+        self.message_class = message_class
+
+    def get_attributes(self, attributes='All'):
+        """
+        Retrieves attributes about this queue object and returns
+        them in an Attribute instance (subclass of a Dictionary).
+
+        :type attributes: string
+        :param attributes: String containing one of:
+                           ApproximateNumberOfMessages,
+                           ApproximateNumberOfMessagesNotVisible,
+                           VisibilityTimeout,
+                           CreatedTimestamp,
+                           LastModifiedTimestamp,
+                           Policy
+                           ReceiveMessageWaitTimeSeconds
+        :rtype: Attribute object
+        :return: An Attribute object which is a mapping type holding the
+                 requested name/value pairs
+        """
+        return self.connection.get_queue_attributes(self, attributes)
+
+    def set_attribute(self, attribute, value):
+        """
+        Set a new value for an attribute of the Queue.
+
+        :type attribute: String
+        :param attribute: The name of the attribute you want to set.  The
+                           only valid value at this time is: VisibilityTimeout
+        :type value: int
+        :param value: The new value for the attribute.
+            For VisibilityTimeout the value must be an
+            integer number of seconds from 0 to 86400.
+
+        :rtype: bool
+        :return: True if successful, otherwise False.
+        """
+        return self.connection.set_queue_attribute(self, attribute, value)
+
+    def get_timeout(self):
+        """
+        Get the visibility timeout for the queue.
+
+        :rtype: int
+        :return: The number of seconds as an integer.
+        """
+        a = self.get_attributes('VisibilityTimeout')
+        return int(a['VisibilityTimeout'])
+
+    def set_timeout(self, visibility_timeout):
+        """
+        Set the visibility timeout for the queue.
+
+        :type visibility_timeout: int
+        :param visibility_timeout: The desired timeout in seconds
+        """
+        retval = self.set_attribute('VisibilityTimeout', visibility_timeout)
+        if retval:
+            self.visibility_timeout = visibility_timeout
+        return retval
+
+    def add_permission(self, label, aws_account_id, action_name):
+        """
+        Add a permission to a queue.
+
+        :type label: str or unicode
+        :param label: A unique identification of the permission you are setting.
+            Maximum of 80 characters ``[0-9a-zA-Z_-]``
+            Example, AliceSendMessage
+
+        :type aws_account_id: str or unicode
+        :param principal_id: The AWS account number of the principal who
+            will be given permission.  The principal must have an AWS account,
+            but does not need to be signed up for Amazon SQS. For information
+            about locating the AWS account identification.
+
+        :type action_name: str or unicode
+        :param action_name: The action.  Valid choices are:
+            SendMessage|ReceiveMessage|DeleteMessage|
+            ChangeMessageVisibility|GetQueueAttributes|*
+
+        :rtype: bool
+        :return: True if successful, False otherwise.
+
+        """
+        return self.connection.add_permission(self, label, aws_account_id,
+                                              action_name)
+
+    def remove_permission(self, label):
+        """
+        Remove a permission from a queue.
+
+        :type label: str or unicode
+        :param label: The unique label associated with the permission
+            being removed.
+
+        :rtype: bool
+        :return: True if successful, False otherwise.
+        """
+        return self.connection.remove_permission(self, label)
+
+    def read(self, visibility_timeout=None, wait_time_seconds=None):
+        """
+        Read a single message from the queue.
+
+        :type visibility_timeout: int
+        :param visibility_timeout: The timeout for this message in seconds
+
+        :type wait_time_seconds: int
+        :param wait_time_seconds: The duration (in seconds) for which the call
+            will wait for a message to arrive in the queue before returning.
+            If a message is available, the call will return sooner than
+            wait_time_seconds.
+
+        :rtype: :class:`boto.sqs.message.Message`
+        :return: A single message or None if queue is empty
+        """
+        rs = self.get_messages(1, visibility_timeout,
+                               wait_time_seconds=wait_time_seconds)
+        if len(rs) == 1:
+            return rs[0]
+        else:
+            return None
+
+    def write(self, message, delay_seconds=None):
+        """
+        Add a single message to the queue.
+
+        :type message: Message
+        :param message: The message to be written to the queue
+
+        :rtype: :class:`boto.sqs.message.Message`
+        :return: The :class:`boto.sqs.message.Message` object that was written.
+        """
+        new_msg = self.connection.send_message(self,
+                                               message.get_body_encoded(),
+                                               delay_seconds)
+        message.id = new_msg.id
+        message.md5 = new_msg.md5
+        return message
+
+    def write_batch(self, messages):
+        """
+        Delivers up to 10 messages in a single request.
+
+        :type messages: List of lists.
+        :param messages: A list of lists or tuples.  Each inner
+            tuple represents a single message to be written
+            and consists of and ID (string) that must be unique
+            within the list of messages, the message body itself
+            which can be a maximum of 64K in length, and an
+            integer which represents the delay time (in seconds)
+            for the message (0-900) before the message will
+            be delivered to the queue.
+        """
+        return self.connection.send_message_batch(self, messages)
+
+    def new_message(self, body=''):
+        """
+        Create new message of appropriate class.
+
+        :type body: message body
+        :param body: The body of the newly created message (optional).
+
+        :rtype: :class:`boto.sqs.message.Message`
+        :return: A new Message object
+        """
+        m = self.message_class(self, body)
+        m.queue = self
+        return m
+
+    # get a variable number of messages, returns a list of messages
+    def get_messages(self, num_messages=1, visibility_timeout=None,
+                     attributes=None, wait_time_seconds=None):
+        """
+        Get a variable number of messages.
+
+        :type num_messages: int
+        :param num_messages: The maximum number of messages to read from
+            the queue.
+
+        :type visibility_timeout: int
+        :param visibility_timeout: The VisibilityTimeout for the messages read.
+
+        :type attributes: str
+        :param attributes: The name of additional attribute to return
+            with response or All if you want all attributes.  The
+            default is to return no additional attributes.  Valid
+            values: All SenderId SentTimestamp ApproximateReceiveCount
+            ApproximateFirstReceiveTimestamp
+
+        :type wait_time_seconds: int
+        :param wait_time_seconds: The duration (in seconds) for which the call
+            will wait for a message to arrive in the queue before returning.
+            If a message is available, the call will return sooner than
+            wait_time_seconds.
+
+        :rtype: list
+        :return: A list of :class:`boto.sqs.message.Message` objects.
+        """
+        return self.connection.receive_message(
+            self, number_messages=num_messages,
+            visibility_timeout=visibility_timeout, attributes=attributes,
+            wait_time_seconds=wait_time_seconds)
+
+    def delete_message(self, message):
+        """
+        Delete a message from the queue.
+
+        :type message: :class:`boto.sqs.message.Message`
+        :param message: The :class:`boto.sqs.message.Message` object to delete.
+
+        :rtype: bool
+        :return: True if successful, False otherwise
+        """
+        return self.connection.delete_message(self, message)
+
+    def delete_message_batch(self, messages):
+        """
+        Deletes a list of messages in a single request.
+
+        :type messages: List of :class:`boto.sqs.message.Message` objects.
+        :param messages: A list of message objects.
+        """
+        return self.connection.delete_message_batch(self, messages)
+
+    def change_message_visibility_batch(self, messages):
+        """
+        A batch version of change_message_visibility that can act
+        on up to 10 messages at a time.
+
+        :type messages: List of tuples.
+        :param messages: A list of tuples where each tuple consists
+            of a :class:`boto.sqs.message.Message` object and an integer
+            that represents the new visibility timeout for that message.
+        """
+        return self.connection.change_message_visibility_batch(self, messages)
+
+    def delete(self):
+        """
+        Delete the queue.
+        """
+        return self.connection.delete_queue(self)
+
+    def clear(self, page_size=10, vtimeout=10):
+        """Utility function to remove all messages from a queue"""
+        n = 0
+        l = self.get_messages(page_size, vtimeout)
+        while l:
+            for m in l:
+                self.delete_message(m)
+                n += 1
+            l = self.get_messages(page_size, vtimeout)
+        return n
+
+    def count(self, page_size=10, vtimeout=10):
+        """
+        Utility function to count the number of messages in a queue.
+        Note: This function now calls GetQueueAttributes to obtain
+        an 'approximate' count of the number of messages in a queue.
+        """
+        a = self.get_attributes('ApproximateNumberOfMessages')
+        return int(a['ApproximateNumberOfMessages'])
+
+    def count_slow(self, page_size=10, vtimeout=10):
+        """
+        Deprecated.  This is the old 'count' method that actually counts
+        the messages by reading them all.  This gives an accurate count but
+        is very slow for queues with non-trivial number of messasges.
+        Instead, use get_attribute('ApproximateNumberOfMessages') to take
+        advantage of the new SQS capability.  This is retained only for
+        the unit tests.
+        """
+        n = 0
+        l = self.get_messages(page_size, vtimeout)
+        while l:
+            for m in l:
+                n += 1
+            l = self.get_messages(page_size, vtimeout)
+        return n
+
+    def dump(self, file_name, page_size=10, vtimeout=10, sep='\n'):
+        """Utility function to dump the messages in a queue to a file
+        NOTE: Page size must be < 10 else SQS errors"""
+        fp = open(file_name, 'wb')
+        n = 0
+        l = self.get_messages(page_size, vtimeout)
+        while l:
+            for m in l:
+                fp.write(m.get_body())
+                if sep:
+                    fp.write(sep)
+                n += 1
+            l = self.get_messages(page_size, vtimeout)
+        fp.close()
+        return n
+
+    def save_to_file(self, fp, sep='\n'):
+        """
+        Read all messages from the queue and persist them to file-like object.
+        Messages are written to the file and the 'sep' string is written
+        in between messages.  Messages are deleted from the queue after
+        being written to the file.
+        Returns the number of messages saved.
+        """
+        n = 0
+        m = self.read()
+        while m:
+            n += 1
+            fp.write(m.get_body())
+            if sep:
+                fp.write(sep)
+            self.delete_message(m)
+            m = self.read()
+        return n
+
+    def save_to_filename(self, file_name, sep='\n'):
+        """
+        Read all messages from the queue and persist them to local file.
+        Messages are written to the file and the 'sep' string is written
+        in between messages.  Messages are deleted from the queue after
+        being written to the file.
+        Returns the number of messages saved.
+        """
+        fp = open(file_name, 'wb')
+        n = self.save_to_file(fp, sep)
+        fp.close()
+        return n
+
+    # for backwards compatibility
+    save = save_to_filename
+
+    def save_to_s3(self, bucket):
+        """
+        Read all messages from the queue and persist them to S3.
+        Messages are stored in the S3 bucket using a naming scheme of::
+
+            <queue_id>/<message_id>
+
+        Messages are deleted from the queue after being saved to S3.
+        Returns the number of messages saved.
+        """
+        n = 0
+        m = self.read()
+        while m:
+            n += 1
+            key = bucket.new_key('%s/%s' % (self.id, m.id))
+            key.set_contents_from_string(m.get_body())
+            self.delete_message(m)
+            m = self.read()
+        return n
+
+    def load_from_s3(self, bucket, prefix=None):
+        """
+        Load messages previously saved to S3.
+        """
+        n = 0
+        if prefix:
+            prefix = '%s/' % prefix
+        else:
+            prefix = '%s/' % self.id[1:]
+        rs = bucket.list(prefix=prefix)
+        for key in rs:
+            n += 1
+            m = self.new_message(key.get_contents_as_string())
+            self.write(m)
+        return n
+
+    def load_from_file(self, fp, sep='\n'):
+        """Utility function to load messages from a file-like object to a queue"""
+        n = 0
+        body = ''
+        l = fp.readline()
+        while l:
+            if l == sep:
+                m = Message(self, body)
+                self.write(m)
+                n += 1
+                print 'writing message %d' % n
+                body = ''
+            else:
+                body = body + l
+            l = fp.readline()
+        return n
+
+    def load_from_filename(self, file_name, sep='\n'):
+        """Utility function to load messages from a local filename to a queue"""
+        fp = open(file_name, 'rb')
+        n = self.load_from_file(fp, sep)
+        fp.close()
+        return n
+
+    # for backward compatibility
+    load = load_from_filename
+