Remove unused use_taskmanager flag

Now that there is no more TaskManager class, nor anything using
one, the use_taskmanager flag is vestigal. Clean it up so that we
don't have to pass it around to things anymore.

Change-Id: I7c1f766f948ad965ee5f07321743fbaebb54288a

nodepool/builder.py

@@ -542,7 +542,6 @@ class CleanupWorker(BaseWorker):
         self._checkForZooKeeperChanges(new_config)
         provider_manager.ProviderManager.reconfigure(self._config, new_config,
                                                      self._zk,
-                                                     use_taskmanager=False,
                                                      only_image_manager=True)
         self._config = new_config
 
@@ -960,7 +959,6 @@ class UploadWorker(BaseWorker):
         self._checkForZooKeeperChanges(new_config)
         provider_manager.ProviderManager.reconfigure(self._config, new_config,
                                                      self._zk,
-                                                     use_taskmanager=False,
                                                      only_image_manager=True)
         self._config = new_config
 

nodepool/cmd/nodepoolcmd.py

@@ -250,7 +250,7 @@ class NodePoolCmd(NodepoolApp):
                       (node.provider, node.id))
                 return
             provider = self.pool.config.providers[node.provider]
-            manager = provider_manager.get_provider(provider, True)
+            manager = provider_manager.get_provider(provider)
             manager.start(self.zk)
             launcher.NodeDeleter.delete(self.zk, manager, node)
             manager.stop()

nodepool/driver/__init__.py

@@ -120,14 +120,10 @@ class Driver(object, metaclass=abc.ABCMeta):
         pass
 
     @abc.abstractmethod
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
         """Return a Provider instance
 
         :arg dict provider_config: A ProviderConfig instance
-
-        :arg bool use_taskmanager: Whether this provider should use a
-           task manager (i.e., perform synchronous or asynchronous
-           operations).
         """
         pass
 

nodepool/driver/aws/__init__.py

@@ -23,5 +23,5 @@ class AwsDriver(Driver):
     def getProviderConfig(self, provider):
         return AwsProviderConfig(self, provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
-        return AwsProvider(provider_config, use_taskmanager)
+        return AwsProvider(provider_config)

nodepool/driver/fake/__init__.py

@@ -30,5 +30,5 @@ class FakeDriver(Driver):
     def getProviderConfig(self, provider):
         return FakeProviderConfig(self, provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
-        return FakeProvider(provider_config, use_taskmanager)
+        return FakeProvider(provider_config)

nodepool/driver/fake/provider.py

@@ -364,11 +364,11 @@ class FakeLaunchAndDeleteFailCloud(FakeOpenStackCloud):
 class FakeProvider(OpenStackProvider):
     fake_cloud = FakeOpenStackCloud
 
-    def __init__(self, provider, use_taskmanager):
+    def __init__(self, provider):
         self.createServer_fails = 0
         self.createServer_fails_with_external_id = 0
         self.__client = FakeProvider.fake_cloud()
-        super(FakeProvider, self).__init__(provider, use_taskmanager)
+        super(FakeProvider, self).__init__(provider)
 
     def _getClient(self):
         return self.__client

nodepool/driver/kubernetes/__init__.py

@@ -30,5 +30,5 @@ class KubernetesDriver(Driver):
     def getProviderConfig(self, provider):
         return KubernetesProviderConfig(self, provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
-        return KubernetesProvider(provider_config, use_taskmanager)
+        return KubernetesProvider(provider_config)

nodepool/driver/openshift/__init__.py

@@ -33,5 +33,5 @@ class OpenshiftDriver(Driver):
     def getProviderConfig(self, provider):
         return OpenshiftProviderConfig(self, provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
-        return OpenshiftProvider(provider_config, use_taskmanager)
+        return OpenshiftProvider(provider_config)

nodepool/driver/openstack/__init__.py

@@ -30,5 +30,5 @@ class OpenStackDriver(Driver):
     def getProviderConfig(self, provider):
         return OpenStackProviderConfig(self, provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
-        return OpenStackProvider(provider_config, use_taskmanager)
+        return OpenStackProvider(provider_config)

nodepool/driver/openstack/provider.py

@@ -41,7 +41,7 @@ MAX_QUOTA_AGE = 5 * 60  # How long to keep the quota information cached
 class OpenStackProvider(Provider):
     log = logging.getLogger("nodepool.driver.openstack.OpenStackProvider")
 
-    def __init__(self, provider, use_taskmanager):
+    def __init__(self, provider):
         self.provider = provider
         self._images = {}
         self._networks = {}

nodepool/driver/static/__init__.py

@@ -21,5 +21,5 @@ class StaticDriver(Driver):
     def getProviderConfig(self, provider):
         return config.StaticProviderConfig(provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
-        return provider.StaticNodeProvider(provider_config, use_taskmanager)
+        return provider.StaticNodeProvider(provider_config)

nodepool/driver/test/__init__.py

@@ -21,5 +21,5 @@ class TestDriver(Driver):
     def getProviderConfig(self, provider):
         return config.TestConfig(provider)
 
-    def getProvider(self, provider_config, use_taskmanager):
+    def getProvider(self, provider_config):
         return provider.TestProvider(provider_config)

nodepool/provider_manager.py

@@ -21,16 +21,16 @@ import logging
 from nodepool.driver import Drivers
 
 
-def get_provider(provider, use_taskmanager):
+def get_provider(provider):
     driver = Drivers.get(provider.driver.name)
-    return driver.getProvider(provider, use_taskmanager)
+    return driver.getProvider(provider)
 
 
 class ProviderManager(object):
     log = logging.getLogger("nodepool.ProviderManager")
 
     @staticmethod
-    def reconfigure(old_config, new_config, zk_conn, use_taskmanager=True,
+    def reconfigure(old_config, new_config, zk_conn,
                     only_image_manager=False):
         '''
         Reconfigure the provider managers on any configuration changes.
@@ -41,7 +41,6 @@ class ProviderManager(object):
         :param Config old_config: The previously read configuration.
         :param Config new_config: The newly read configuration.
         :param ZooKeeper zk_conn: A ZooKeeper connection object.
-        :param bool use_taskmanager: If True, use a task manager.
         :param bool only_image_manager: If True, skip manager that do not
                     manage images. This is used by the builder process.
         '''
@@ -60,8 +59,7 @@ class ProviderManager(object):
             else:
                 ProviderManager.log.debug("Creating new ProviderManager object"
                                           " for %s" % p.name)
-                new_config.provider_managers[p.name] = \
+                new_config.provider_managers[p.name] = get_provider(p)
-                    get_provider(p, use_taskmanager)
                 new_config.provider_managers[p.name].start(zk_conn)
 
         for stop_manager in stop_managers:

nodepool/tests/unit/test_sdk_integration.py

@@ -59,8 +59,7 @@ class TestShadeIntegration(tests.IntegrationTestCase):
 
         config = nodepool_config.loadConfig(configfile)
         self.assertIn('real-provider', config.providers)
-        pm = provider_manager.get_provider(
+        pm = provider_manager.get_provider(config.providers['real-provider'])
-            config.providers['real-provider'], use_taskmanager=True)
         # We need to cleanup the provider manager so that it doesn't leak a
         # thread that causes wait_for_threads in subsequent tests to fail.
         self.addCleanup(pm.stop)