Use the latest framework code, workaround 1859769

* bind-address can now be obtained without waiting for a peer relation
  which currently appears to late to be useful (LP: #1859769);
* fix the single-unit setup by using a workaround with storing the newly
  generated cluster-id in StoredState and deferring the
  cluster_initalized event;
* Depend on Juju 2.7.5 due to a regression introduced into app relation
  data in 2.7.3 (see LP: #1865229).

Author: Dmitrii Shcherbakov

README.md

@@ -1,8 +1,31 @@
 CockroachDB Charm
 ==================================
 
-WIP - do not use.
+# Deployment Requirements
+
+The charm requires Juju 2.7.5 to be present (see [LP: #1865229](https://bugs.launchpad.net/juju/+bug/1865229)).
+
+# Deployment
+
+In order to deploy CockroachDB in a single-node mode, set replication factors to 1 explicitly.
+
+```bash
+juju deploy <charm-src-dir> --config default_zone_replicas=1 --config system_data_replicas=1
+```
+
+CockroachDB will use a replication factor of 3 unless explicitly specified.
 
 ```bash
-juju deploy cs:~dmitriis/cockroachdb
+juju deploy <charm-src-dir>
+juju add-unit cockroachdb -n 2
 ```
+
+HA with an explicit amount of replicas.
+
+```bash
+juju deploy <charm-src-dir> --config default_zone_replicas=3 --config system_data_replicas=3 -n 3
+```
+
+# Known Issues
+
+The charm uses a workaround for [LP: #1859769](https://bugs.launchpad.net/juju/+bug/1859769) for single-node deployments by saving a cluster ID in a local state before the peer relation becomes available.

metadata.yaml

@@ -3,6 +3,7 @@ summary: CockroachDB Charm
 maintainers:
     - github.com/dshcherb
 description: CockroachDB Charm
+min-juju-version: 2.7.5
 tags:
     - database
 provides:

mod/operator

@@ -163,27 +163,28 @@ def on_cockroachpeer_relation_changed(self, event):
             self.model.unit.status = ActiveStatus()
 
     def on_cockroachdb_started(self, event):
-        if not self.peers.is_joined:
+        if not self.peers.is_joined and not self.is_single_node:
+            self.unit.status = WaitingStatus('Waiting for peer units to join.')
             event.defer()
             return
 
-        unit = self.model.unit
         if self.peers.is_cluster_initialized:
             # Skip this event when some other unit has already initialized a cluster.
-            unit.status = ActiveStatus()
+            self.unit.status = ActiveStatus()
             return
-        elif not unit.is_leader():
-            unit.status = WaitingStatus('Waiting for the leader unit to initialize a cluster.')
+        elif not self.unit.is_leader():
+            self.unit.status = WaitingStatus('Waiting for the leader unit to initialize a cluster.')
             event.defer()
             return
 
-        unit.status = MaintenanceStatus('Initializing the cluster')
-        # Initialize the cluster if we're a leader in a multi-node deployment.
+        self.unit.status = MaintenanceStatus('Initializing the cluster')
+        # Initialize the cluster if we're a leader in a multi-node deployment, otherwise it have already
+        # been initialized by running start-single-node.
         if not self.is_single_node and self.model.unit.is_leader():
             subprocess.check_call([self.COCKROACH_BINARY_PATH, 'init', '--insecure'])
 
         self.on.cluster_initialized.emit(self.__get_cluster_id())
-        unit.status = ActiveStatus()
+        self.unit.status = ActiveStatus()
 
     def __get_cluster_id(self):
         for _ in range(self.MAX_RETRIES):

src/charm.py

@@ -1,62 +1,68 @@
-import ipaddress
-
-from ops.framework import Object
+from ops.framework import Object, StoredState
 
 
 class CockroachDBPeers(Object):
+
+    state = StoredState()
+
     def __init__(self, charm, relation_name):
         super().__init__(charm, relation_name)
-        self.relation_name = relation_name
-        self._relation = None
+        self._relation_name = relation_name
+        self._relation = self.framework.model.get_relation(self._relation_name)
         self.framework.observe(charm.on.cluster_initialized, self)
 
+        self.state.set_default(cluster_id=None)
+
     @property
     def _relations(self):
-        return self.framework.model.relations[self.relation_name]
+        return self.framework.model.relations[self._relation_name]
 
     @property
     def is_single(self):
         return len(self._relations) == 1
 
     @property
     def is_joined(self):
-        return self.framework.model.get_relation(self.relation_name) is not None
-
-    @property
-    def relation(self):
-        if self._relation is None:
-            self._relation = self.framework.model.get_relation(self.relation_name)
-        return self._relation
+        return self._relation is not None
 
     def on_cluster_initialized(self, event):
         if not self.framework.model.unit.is_leader():
             raise RuntimeError('The initial unit of a cluster must also be a leader.')
-        self.relation.data[self.relation.app]['initial_unit'] = self.framework.model.unit.name
-        self.relation.data[self.relation.app]['cluster_id'] = event.cluster_id
+
+        # A workaround for LP: #1859769.
+        self.state.cluster_id = event.cluster_id
+        if not self.is_joined:
+            event.defer()
+            return
+
+        self._relation.data[self.model.app]['initial_unit'] = self.framework.model.unit.name
+        self._relation.data[self.model.app]['cluster_id'] = self.state.cluster_id
 
     @property
     def is_cluster_initialized(self):
         """Determined by the presence of a cluster ID."""
-        return self.relation.data[self.relation.app].get('cluster_id') is not None
+        if self.is_joined:
+            return self._relation.data[self.model.app].get('cluster_id') is not None
+        elif self.state.cluster_id:
+            return True
+        else:
+            return False
 
     @property
     def initial_unit(self):
         """Return the unit that has initialized the cluster."""
         if self.is_joined:
-            return self.relation.get('initial_unit')
+            return self._relation.get('initial_unit')
         else:
             return None
 
     @property
     def peer_addresses(self):
         addresses = []
-        for u in self.relation.units:
-            addresses.append(self.relation.data[u]['ingress-address'])
+        for u in self._relation.units:
+            addresses.append(self._relation.data[u]['ingress-address'])
         return addresses
 
     @property
     def advertise_addr(self):
-        if self.is_joined:
-            return self.model.get_binding(self.relation).network.ingress_address
-        else:
-            return ipaddress.ip_address('127.0.0.1')
+        self.model.get_binding(self._relation_name).network.ingress_address