gcloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/boto/sdb/db/query.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2006,2007,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.
+
+class Query(object):
+    __local_iter__ = None
+    def __init__(self, model_class, limit=None, next_token=None, manager=None):
+        self.model_class = model_class
+        self.limit = limit
+        self.offset = 0
+        if manager:
+            self.manager = manager
+        else:
+            self.manager = self.model_class._manager
+        self.filters = []
+        self.select = None
+        self.sort_by = None
+        self.rs = None
+        self.next_token = next_token
+
+    def __iter__(self):
+        return iter(self.manager.query(self))
+
+    def next(self):
+        if self.__local_iter__ == None:
+            self.__local_iter__ = self.__iter__()
+        return self.__local_iter__.next()
+
+    def filter(self, property_operator, value):
+        self.filters.append((property_operator, value))
+        return self
+
+    def fetch(self, limit, offset=0):
+        """Not currently fully supported, but we can use this
+        to allow them to set a limit in a chainable method"""
+        self.limit = limit
+        self.offset = offset
+        return self
+
+    def count(self, quick=True):
+        return self.manager.count(self.model_class, self.filters, quick, self.sort_by, self.select)
+
+    def get_query(self):
+        return self.manager._build_filter_part(self.model_class, self.filters, self.sort_by, self.select)
+
+    def order(self, key):
+        self.sort_by = key
+        return self
+    
+    def to_xml(self, doc=None):
+        if not doc:
+            xmlmanager = self.model_class.get_xmlmanager()
+            doc = xmlmanager.new_doc()
+        for obj in self:
+            obj.to_xml(doc)
+        return doc
+
+    def get_next_token(self):
+        if self.rs:
+            return self.rs.next_token
+        if self._next_token:
+            return self._next_token
+        return None
+
+    def set_next_token(self, token):
+        self._next_token = token
+
+    next_token = property(get_next_token, set_next_token)

data/packages/gsutil/boto/boto/sdb/db/sequence.py

@@ -0,0 +1,226 @@
+# Copyright (c) 2010 Chris Moyer http://coredumped.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.
+
+from boto.exception import SDBResponseError
+
+class SequenceGenerator(object):
+    """Generic Sequence Generator object, this takes a single
+    string as the "sequence" and uses that to figure out
+    what the next value in a string is. For example
+    if you give "ABC" and pass in "A" it will give you "B",
+    and if you give it "C" it will give you "AA".
+
+    If you set "rollover" to True in the above example, passing
+    in "C" would give you "A" again.
+
+    The Sequence string can be a string or any iterable
+    that has the "index" function and is indexable.
+    """
+    __name__ = "SequenceGenerator"
+
+    def __init__(self, sequence_string, rollover=False):
+        """Create a new SequenceGenerator using the sequence_string
+        as how to generate the next item.
+
+        :param sequence_string: The string or list that explains
+        how to generate the next item in the sequence
+        :type sequence_string: str,iterable
+
+        :param rollover: Rollover instead of incrementing when
+        we hit the end of the sequence
+        :type rollover: bool
+        """
+        self.sequence_string = sequence_string
+        self.sequence_length = len(sequence_string[0])
+        self.rollover = rollover
+        self.last_item = sequence_string[-1]
+        self.__name__ = "%s('%s')" % (self.__class__.__name__, sequence_string)
+
+    def __call__(self, val, last=None):
+        """Get the next value in the sequence"""
+        # If they pass us in a string that's not at least
+        # the lenght of our sequence, then return the
+        # first element in our sequence
+        if val == None or len(val) < self.sequence_length:
+            return self.sequence_string[0]
+        last_value = val[-self.sequence_length:]
+        if (not self.rollover) and (last_value == self.last_item):
+            val = "%s%s" % (self(val[:-self.sequence_length]), self._inc(last_value))
+        else:
+            val = "%s%s" % (val[:-self.sequence_length], self._inc(last_value))
+        return val
+
+    def _inc(self, val):
+        """Increment a single value"""
+        assert(len(val) == self.sequence_length)
+        return self.sequence_string[(self.sequence_string.index(val)+1) % len(self.sequence_string)]
+
+
+
+#
+# Simple Sequence Functions
+#
+def increment_by_one(cv=None, lv=None):
+    if cv == None:
+        return 0
+    return cv + 1
+
+def double(cv=None, lv=None):
+    if cv == None:
+        return 1
+    return cv * 2
+
+def fib(cv=1, lv=0):
+    """The fibonacci sequence, this incrementer uses the
+    last value"""
+    if cv == None:
+        cv = 1
+    if lv == None:
+        lv = 0
+    return cv + lv
+
+increment_string = SequenceGenerator("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+
+
+
+class Sequence(object):
+    """A simple Sequence using the new SDB "Consistent" features
+    Based largly off of the "Counter" example from mitch garnaat:
+    http://bitbucket.org/mitch/stupidbototricks/src/tip/counter.py"""
+
+
+    def __init__(self, id=None, domain_name=None, fnc=increment_by_one, init_val=None):
+        """Create a new Sequence, using an optional function to 
+        increment to the next number, by default we just increment by one.
+        Every parameter here is optional, if you don't specify any options
+        then you'll get a new SequenceGenerator with a random ID stored in the
+        default domain that increments by one and uses the default botoweb 
+        environment
+
+        :param id: Optional ID (name) for this counter
+        :type id: str
+
+        :param domain_name: Optional domain name to use, by default we get this out of the
+            environment configuration
+        :type domain_name:str
+
+        :param fnc: Optional function to use for the incrementation, by default we just increment by one
+            There are several functions defined in this module.
+            Your function must accept "None" to get the initial value
+        :type fnc: function, str
+
+        :param init_val: Initial value, by default this is the first element in your sequence, 
+            but you can pass in any value, even a string if you pass in a function that uses
+            strings instead of ints to increment
+        """
+        self._db = None
+        self._value = None
+        self.last_value = None
+        self.domain_name = domain_name
+        self.id = id
+        if init_val == None:
+            init_val = fnc(init_val)
+
+        if self.id == None:
+            import uuid
+            self.id = str(uuid.uuid4())
+
+        self.item_type = type(fnc(None))
+        self.timestamp = None
+        # Allow us to pass in a full name to a function
+        if isinstance(fnc, str):
+            from boto.utils import find_class
+            fnc = find_class(fnc)
+        self.fnc = fnc
+
+        # Bootstrap the value last
+        if not self.val:
+            self.val = init_val
+
+    def set(self, val):
+        """Set the value"""
+        import time
+        now = time.time()
+        expected_value = []
+        new_val = {}
+        new_val['timestamp'] = now
+        if self._value != None:
+            new_val['last_value'] = self._value
+            expected_value = ['current_value', str(self._value)]
+        new_val['current_value'] = val
+        try:
+            self.db.put_attributes(self.id, new_val, expected_value=expected_value)
+            self.timestamp = new_val['timestamp']
+        except SDBResponseError, e:
+            if e.status == 409:
+                raise ValueError("Sequence out of sync")
+            else:
+                raise
+
+
+    def get(self):
+        """Get the value"""
+        val = self.db.get_attributes(self.id, consistent_read=True)
+        if val:
+            if 'timestamp' in val:
+                self.timestamp = val['timestamp']
+            if 'current_value' in val:
+                self._value = self.item_type(val['current_value'])
+            if "last_value" in val and val['last_value'] != None:
+                self.last_value = self.item_type(val['last_value'])
+        return self._value
+
+    val = property(get, set)
+
+    def __repr__(self):
+        return "%s('%s', '%s', '%s.%s', '%s')" % (
+            self.__class__.__name__,
+            self.id,
+            self.domain_name,
+            self.fnc.__module__, self.fnc.__name__,
+            self.val)
+
+
+    def _connect(self):
+        """Connect to our domain"""
+        if not self._db:
+            import boto
+            sdb = boto.connect_sdb()
+            if not self.domain_name:
+                self.domain_name = boto.config.get("DB", "sequence_db", boto.config.get("DB", "db_name", "default"))
+            try:
+                self._db = sdb.get_domain(self.domain_name)
+            except SDBResponseError, e:
+                if e.status == 400:
+                    self._db = sdb.create_domain(self.domain_name)
+                else:
+                    raise
+        return self._db
+
+    db = property(_connect)
+
+    def next(self):
+        self.val = self.fnc(self.val, self.last_value)
+        return self.val
+
+    def delete(self):
+        """Remove this sequence"""
+        self.db.delete_attributes(self.id)

data/packages/gsutil/boto/boto/sdb/db/test_db.py

@@ -0,0 +1,231 @@
+import logging
+import time
+from datetime import datetime
+
+from boto.sdb.db.model import Model
+from boto.sdb.db.property import StringProperty, IntegerProperty, BooleanProperty
+from boto.sdb.db.property import DateTimeProperty, FloatProperty, ReferenceProperty
+from boto.sdb.db.property import PasswordProperty, ListProperty, MapProperty
+from boto.exception import SDBPersistenceError
+
+logging.basicConfig()
+log = logging.getLogger('test_db')
+log.setLevel(logging.DEBUG)
+
+_objects = {}
+
+#
+# This will eventually be moved to the boto.tests module and become a real unit test
+# but for now it will live here.  It shows examples of each of the Property types in
+# use and tests the basic operations.
+#
+class TestBasic(Model):
+
+    name = StringProperty()
+    size = IntegerProperty()
+    foo = BooleanProperty()
+    date = DateTimeProperty()
+
+class TestFloat(Model):
+
+    name = StringProperty()
+    value = FloatProperty()
+
+class TestRequired(Model):
+
+    req = StringProperty(required=True, default='foo')
+
+class TestReference(Model):
+
+    ref = ReferenceProperty(reference_class=TestBasic, collection_name='refs')
+
+class TestSubClass(TestBasic):
+
+    answer = IntegerProperty()
+
+class TestPassword(Model):
+    password = PasswordProperty()
+
+class TestList(Model):
+
+    name = StringProperty()
+    nums = ListProperty(int)
+
+class TestMap(Model):
+
+    name = StringProperty()
+    map = MapProperty()
+
+class TestListReference(Model):
+
+    name = StringProperty()
+    basics = ListProperty(TestBasic)
+
+class TestAutoNow(Model):
+
+    create_date = DateTimeProperty(auto_now_add=True)
+    modified_date = DateTimeProperty(auto_now=True)
+
+class TestUnique(Model):
+    name = StringProperty(unique=True)
+
+def test_basic():
+    global _objects
+    t = TestBasic()
+    t.name = 'simple'
+    t.size = -42
+    t.foo = True
+    t.date = datetime.now()
+    log.debug('saving object')
+    t.put()
+    _objects['test_basic_t'] = t
+    time.sleep(5)
+    log.debug('now try retrieving it')
+    tt = TestBasic.get_by_id(t.id)
+    _objects['test_basic_tt'] = tt
+    assert tt.id == t.id
+    l = TestBasic.get_by_id([t.id])
+    assert len(l) == 1
+    assert l[0].id == t.id
+    assert t.size == tt.size
+    assert t.foo == tt.foo
+    assert t.name == tt.name
+    #assert t.date == tt.date
+    return t
+
+def test_float():
+    global _objects
+    t = TestFloat()
+    t.name = 'float object'
+    t.value = 98.6
+    log.debug('saving object')
+    t.save()
+    _objects['test_float_t'] = t
+    time.sleep(5)
+    log.debug('now try retrieving it')
+    tt = TestFloat.get_by_id(t.id)
+    _objects['test_float_tt'] = tt
+    assert tt.id == t.id
+    assert tt.name == t.name
+    assert tt.value == t.value
+    return t
+    
+def test_required():
+    global _objects
+    t = TestRequired()
+    _objects['test_required_t'] = t
+    t.put()
+    return t
+
+def test_reference(t=None):
+    global _objects
+    if not t:
+        t = test_basic()
+    tt = TestReference()
+    tt.ref = t
+    tt.put()
+    time.sleep(10)
+    tt = TestReference.get_by_id(tt.id)
+    _objects['test_reference_tt'] = tt
+    assert tt.ref.id == t.id
+    for o in t.refs:
+        log.debug(o)
+
+def test_subclass():
+    global _objects
+    t = TestSubClass()
+    _objects['test_subclass_t'] = t
+    t.name = 'a subclass'
+    t.size = -489
+    t.save()
+
+def test_password():
+    global _objects
+    t = TestPassword()
+    _objects['test_password_t'] = t
+    t.password = "foo"
+    t.save()
+    time.sleep(5)
+    # Make sure it stored ok
+    tt = TestPassword.get_by_id(t.id)
+    _objects['test_password_tt'] = tt
+    #Testing password equality
+    assert tt.password == "foo"
+    #Testing password not stored as string
+    assert str(tt.password) != "foo"
+
+def test_list():
+    global _objects
+    t = TestList()
+    _objects['test_list_t'] = t
+    t.name = 'a list of ints'
+    t.nums = [1, 2, 3, 4, 5]
+    t.put()
+    tt = TestList.get_by_id(t.id)
+    _objects['test_list_tt'] = tt
+    assert tt.name == t.name
+    for n in tt.nums:
+        assert isinstance(n, int)
+
+def test_list_reference():
+    global _objects
+    t = TestBasic()
+    t.put()
+    _objects['test_list_ref_t'] = t
+    tt = TestListReference()
+    tt.name = "foo"
+    tt.basics = [t]
+    tt.put()
+    time.sleep(5)
+    _objects['test_list_ref_tt'] = tt
+    ttt = TestListReference.get_by_id(tt.id)
+    assert ttt.basics[0].id == t.id
+
+def test_unique():
+    global _objects
+    t = TestUnique()
+    name = 'foo' + str(int(time.time()))
+    t.name = name
+    t.put()
+    _objects['test_unique_t'] = t
+    time.sleep(10)
+    tt = TestUnique()
+    _objects['test_unique_tt'] = tt
+    tt.name = name
+    try:
+        tt.put()
+        assert False
+    except(SDBPersistenceError):
+        pass
+
+def test_datetime():
+    global _objects
+    t = TestAutoNow()
+    t.put()
+    _objects['test_datetime_t'] = t
+    time.sleep(5)
+    tt = TestAutoNow.get_by_id(t.id)
+    assert tt.create_date.timetuple() == t.create_date.timetuple()
+
+def test():
+    log.info('test_basic')
+    t1 = test_basic()
+    log.info('test_required')
+    test_required()
+    log.info('test_reference')
+    test_reference(t1)
+    log.info('test_subclass')
+    test_subclass()
+    log.info('test_password')
+    test_password()
+    log.info('test_list')
+    test_list()
+    log.info('test_list_reference')
+    test_list_reference()
+    log.info("test_datetime")
+    test_datetime()
+    log.info('test_unique')
+    test_unique()
+
+if __name__ == "__main__":
+    test()