Adding Bigtable garbage collection rule class.

These are used as settings when creating new column
families within a table.

Also slipping in 3 small Bigtable docstring updates.

Author: dhermes

gcloud/bigtable/cluster.py

@@ -213,7 +213,7 @@ def finished(self):
         operation_name = ('operations/' + self._cluster.name +
                           '/operations/%d' % (self.op_id,))
         request_pb = operations_pb2.GetOperationRequest(name=operation_name)
-        # We expact a `._generated.operations_pb2.Operation`.
+        # We expect a `._generated.operations_pb2.Operation`.
         operation_pb = self._cluster._client._operations_stub.GetOperation(
             request_pb, self._cluster._client.timeout_seconds)
 
@@ -258,7 +258,7 @@ class Cluster(object):
 
     :type serve_nodes: int
     :param serve_nodes: (Optional) The number of nodes in the cluster.
-                        Defaults to 3.
+                        Defaults to 3 (``_DEFAULT_SERVE_NODES``).
     """
 
     def __init__(self, zone, cluster_id, client,

gcloud/bigtable/column_family.py

@@ -15,6 +15,59 @@
 """User friendly container for Google Cloud Bigtable Column Family."""
 
 
+class GarbageCollectionRule(object):
+    """Table garbage collection rule.
+
+    Cells in the table fitting the rule will be deleted during
+    garbage collection.
+
+    .. note::
+
+        At most one of ``max_num_versions`` and ``max_age`` can be specified
+        at once.
+
+    .. note::
+
+        A string ``gc_expression`` can also be used with API requests, but
+        that value would be superceded by a ``gc_rule``. As a result, we
+        don't support that feature and instead support via this native
+        object.
+
+    :type max_num_versions: int
+    :param max_num_versions: The maximum number of versions
+
+    :type max_age: :class:`datetime.timedelta`
+    :param max_age: The maximum age allowed for a cell in the table.
+
+    :raises: :class:`TypeError <exceptions.TypeError>` if both
+             ``max_num_versions`` and ``max_age`` are set.
+    """
+
+    def __init__(self, max_num_versions=None, max_age=None):
+        self.max_num_versions = max_num_versions
+        self.max_age = max_age
+        self._check_single_value()
+
+    def _check_single_value(self):
+        """Checks that at most one value is set on the instance.
+
+        :raises: :class:`TypeError <exceptions.TypeError>` if not exactly one
+                 value set on the instance.
+        """
+        if self.max_num_versions is not None and self.max_age is not None:
+            raise TypeError('At most one of max_num_versions and '
+                            'max_age can be set')
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        return (other.max_num_versions == self.max_num_versions and
+                other.max_age == self.max_age)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
 class ColumnFamily(object):
     """Representation of a Google Cloud Bigtable Column Family.
 

gcloud/bigtable/table.py

@@ -41,6 +41,7 @@ class Table(object):
     We can use a :class:`Table` to:
 
     * :meth:`create` the table
+    * :meth:`rename` the table
     * :meth:`delete` the table
 
     :type table_id: str

gcloud/bigtable/test_column_family.py

@@ -16,6 +16,47 @@
 import unittest2
 
 
+class TestGarbageCollectionRule(unittest2.TestCase):
+
+    def _getTargetClass(self):
+        from gcloud.bigtable.column_family import GarbageCollectionRule
+        return GarbageCollectionRule
+
+    def _makeOne(self, *args, **kwargs):
+        return self._getTargetClass()(*args, **kwargs)
+
+    def test_constructor_defaults(self):
+        gc_rule = self._makeOne()
+        self.assertEqual(gc_rule.max_num_versions, None)
+        self.assertEqual(gc_rule.max_age, None)
+
+    def test_constructor_failure(self):
+        with self.assertRaises(TypeError):
+            self._makeOne(max_num_versions=1, max_age=object())
+
+    def test___eq__max_age(self):
+        max_age = object()
+        gc_rule1 = self._makeOne(max_age=max_age)
+        gc_rule2 = self._makeOne(max_age=max_age)
+        self.assertEqual(gc_rule1, gc_rule2)
+
+    def test___eq__max_num_versions(self):
+        gc_rule1 = self._makeOne(max_num_versions=2)
+        gc_rule2 = self._makeOne(max_num_versions=2)
+        self.assertEqual(gc_rule1, gc_rule2)
+
+    def test___eq__type_differ(self):
+        gc_rule1 = self._makeOne()
+        gc_rule2 = object()
+        self.assertNotEqual(gc_rule1, gc_rule2)
+
+    def test___ne__same_value(self):
+        gc_rule1 = self._makeOne()
+        gc_rule2 = self._makeOne()
+        comparison_val = (gc_rule1 != gc_rule2)
+        self.assertFalse(comparison_val)
+
+
 class TestColumnFamily(unittest2.TestCase):
 
     def _getTargetClass(self):