Fixes + docker

colony/core/roles/manager.py

@@ -1,9 +1,9 @@
 import threading
 
 from colony.core.context import RoleContext
+from colony.core.network.advice import assignable_roles
 from colony.core.roles.policy import DefaultRolePolicy
 from colony.core.state_manager import StateManager
-from colony.role_registry import RolePriority
 from colony.core.logger.logging import get_logger
 
 
@@ -18,10 +18,8 @@ class RoleManager:
         self._lock = threading.RLock()
 
     def ensure_general_roles(self):
-        general = sorted(
-            name for name, stats in self.role_registry.roles.items()
-            if stats.priority == RolePriority.GENERAL
-        )
+        roles = self.role_registry.roles
+        general = sorted(set(roles) - set(assignable_roles(roles)))
         current = self.state_manager.get(StateManager.Data.Roles)
         wanted = list(dict.fromkeys(general + current))
         if wanted != current:
@@ -42,11 +40,14 @@ class RoleManager:
                 self.logger.debug(f"Creating instance of role {role_name}. ")
                 roles[role_name] = role_cls(context=context)
 
-            self.network.self_node.roles = list(roles)
-            self.network.self_node.set_role_instances(roles)
-            self.network.membership.update_self(roles=list(roles))
+            self._publish(roles)
         self.logger.info(f"Roles initialized: {list(roles.keys())}. ")
 
+    def _publish(self, roles):
+        self.network.self_node.set_role_instances(roles)
+        self.network.self_node.roles = list(roles)
+        self.network.membership.update_self(roles=list(roles))
+
     def get_role_instances(self):
         return self.network.self_node.get_role_instances()
 
@@ -92,9 +93,7 @@ class RoleManager:
             }
 
             self.state_manager.set(StateManager.Data.Roles, list(final_roles.keys()))
-            self.network.self_node.set_role_instances(final_roles)
-            self.network.self_node.roles = list(final_roles.keys())
-            self.network.membership.update_self(roles=list(final_roles))
+            self._publish(final_roles)
 
             for role_name in roles_to_remove:
                 self.logger.debug(f"Stopping removed role {role_name}")
@@ -106,6 +105,17 @@ class RoleManager:
 
         self.logger.info(f"Roles updated to: {list(final_roles.keys())}")
 
+    def drop_roles(self, role_names):
+        with self._lock:
+            assignable = assignable_roles(self.role_registry.roles)
+            held = list(self.get_role_instances())
+            remaining = [name for name in held if name not in role_names or name not in assignable]
+            if remaining != held:
+                self.set_roles(remaining)
+
+    def _decline(self, role_name):
+        self.network.membership.decline(role_name, self.role_policy.decline_cooldown)
+
     def request_role(self, role_name):
         membership = self.network.membership
 
@@ -124,9 +134,15 @@ class RoleManager:
             accepted, reason = self.role_policy.decide(role_name, held, scores, self.role_registry.roles)
             if not accepted:
                 self.logger.info(f"Declining role {role_name}: {reason}")
-                membership.decline(role_name, self.role_policy.decline_cooldown)
+                self._decline(role_name)
                 return {"accepted": False, "reason": reason}
 
-            self.set_roles(held + [role_name])
+            try:
+                self.set_roles(held + [role_name])
+            except Exception:
+                self.logger.exception(f"Could not take role {role_name}")
+                self._decline(role_name)
+                return {"accepted": False, "reason": "role could not be started"}
+
             membership.clear_decline(role_name)
             return {"accepted": True, "reason": reason}