gcloud 0.0.7 → 0.1.0

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

@@ -1,43 +0,0 @@
-# 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

@@ -1,253 +0,0 @@
-# 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

@@ -1,478 +0,0 @@
-# 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
-