drove-cli 0.0.1__py3-none-any.whl

drove_cli-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+drove.py,sha256=8RzbZU_hpHdxcJy9oDeYKh5bNmD54b7TKB1DJ9QtN18,1807
+drovecli.py,sha256=u8oJc15Bxl9flhvDjJMJUyNWKz1wo35XR4ywMhT1gWs,1168
+droveclient.py,sha256=0M0dl_H4m90pQFCgrF-Nz6JJfu9ycN7YQY0E3RaZdkU,8561
+droveutils.py,sha256=-Yook6cYnStFDox_9CFFV9Ox1ywCQCzKTyMx9cg6jKc,4026
+plugins/__init__.py,sha256=jp5G2AnrSmrENhsDe_6iBLUHbKA9DYDO6wYIOujv4YM,1327
+plugins/appinstances.py,sha256=Wtg3suTiaIWTrQHK0JUHfSON2rdVgRv65Zab_2uKjhg,9188
+plugins/applications.py,sha256=u8lgsiFpCol6v84PMghleo_JlaYpZuSRFkoeUZx41Ho,11752
+plugins/cluster.py,sha256=TG2GthGtShMdsJrMJD7NMDnqpRoalzGz9wNFRDbXPXY,5635
+plugins/executors.py,sha256=AnWfX6FxZd5-f4M7Wzp5RXdId0DUf0USnmH8XicChno,7005
+plugins/tasks.py,sha256=q-aL2B2NePTmHDW83mKSYn4XiWYkujt1dTqjG5sHoCs,7966
+drove_cli-0.0.1.dist-info/METADATA,sha256=1zlH82KH0yYBiF4igoSExNHYeWdwB1p-xrAet1GJGgw,20425
+drove_cli-0.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+drove_cli-0.0.1.dist-info/entry_points.txt,sha256=PBYfLCyK6IJMnqgttT0ATxjl7h2AgLDK4zF7gSNoFGM,35
+drove_cli-0.0.1.dist-info/RECORD,,

drove_cli-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

drove_cli-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+drove=drove:run
+

drovecli.py

@@ -0,0 +1,37 @@
+import argparse
+import droveclient
+from plugins import DrovePlugin
+from types import SimpleNamespace
+
+
+
+class DroveCli:
+    def __init__(self, parser: argparse.ArgumentParser):
+        self.parser = parser
+        self.drove_client = droveclient.DroveClient()
+        self.plugins: list = []
+        self.debug = False
+        subparsers = parser.add_subparsers(help="Available plugins")
+        for plugin_class in DrovePlugin.plugins:
+            plugin = plugin_class()
+            # print("Loading plugin: " + str(plugin))
+            plugin.populate_options(drove_client=self.drove_client, subparser=subparsers)
+            self.plugins.append(plugin)
+        parser.set_defaults(func=self.show_help)
+        
+        
+    def run(self):
+        args = self.parser.parse_args()
+        self.debug = args.debug
+        drove_client = droveclient.build_drove_client(self.drove_client, args=args)
+        if drove_client is None:
+            return None
+        self.drove_client = drove_client
+
+        # Load plugins
+        
+        args.func(args)
+    
+    def show_help(self, options: SimpleNamespace) -> None:
+        self.parser.print_help()
+        exit(-1)

droveclient.py

@@ -0,0 +1,192 @@
+import configparser
+import json
+import os
+import requests
+import urllib3
+from pathlib import Path
+from requests.adapters import HTTPAdapter, Retry
+from types import SimpleNamespace
+
+class TokenAuth(requests.auth.AuthBase):
+    def __init__(self, token: str):
+        self.token = token
+        super().__init__()
+
+    def __call__(self, r):
+        r.headers.update({"Authorization": self.token})
+        return r
+
+class DroveException(Exception):
+    """Exception raised while calling drove endpoint"""
+
+    def __init__(self, status_code: int, message: str, raw: str = None, api_response: dict = None):
+        self.status_code = status_code
+        self.raw = raw
+        self.api_response = api_response
+        super().__init__(message)
+
+class DroveClient:
+    def __init__(self):
+        self.endpoint: str = None
+        self.auth_header: str = None
+        self.username = None
+        self.password = None
+        self.insecure: bool = False
+        self.session = requests.session()
+        retries = Retry(connect=5,
+                        read=5,
+                        backoff_factor=0.1)
+
+        self.session.mount('https://', HTTPAdapter(max_retries=retries))
+        self.session.mount('http://', HTTPAdapter(max_retries=retries))
+    
+
+    def start(self,
+               endpoint: str = None,
+               auth_header: str = None,
+               username: str = None,
+               password: str = None,
+               insecure: bool = False):
+        self.endpoint = endpoint
+        self.auth_header = auth_header
+        self.insecure = insecure
+        self.session.verify = not insecure
+        if insecure:
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+        if username != None and password != None:
+            self.session.auth = requests.auth.HTTPBasicAuth(username, password)
+        elif auth_header:
+            self.session.auth = TokenAuth(auth_header)
+
+        self.get("/apis/v1/ping")
+        # print("Connection validated for endpoint: " + self.endpoint)        
+
+    def app_instances(self, app_id: str, healthy_only: bool = True):
+        data = self.get("/apis/v1/applications/{app_id}/instances".format(app_id=app_id))
+        if healthy_only:
+            instances = [instance["instanceId"] for instance in data if instance["state"] == "HEALTHY"]
+        else:
+            instances = [instance["instanceId"] for instance in data]
+        return set(instances)
+
+
+    def get(self, path: str, expected_status = 200) -> dict:
+        try:
+            response = self.session.get(self.endpoint + path)
+        except requests.ConnectionError as e:
+            raise DroveException(-1, "Error connecting to endpoint " + self.endpoint, raw={})
+        return handle_drove_response(response, expected_status)
+    
+    def get_raw(self, path: str, expected_status: int = 200) -> dict:
+        try:
+            response = self.session.get(self.endpoint + path)
+        except requests.ConnectionError as e:
+            raise DroveException(-1, "Error connecting to endpoint " + self.endpoint, raw={})
+
+        status_code = response.status_code
+        text = response.text
+        if status_code != expected_status:
+            raise DroveException(status_code, "Drove call failed with status: " + str(status_code), raw=text)
+        try:
+            return json.loads(text)
+        except Exception as e:
+            raise DroveException(status_code, str(e))
+    
+    def get_to_file(self, path: str, filename: str, expected_status: int = 200) -> int:
+        size = 0
+        try:
+            with self.session.get(self.endpoint + path, stream=True) as r:
+                if r.status_code != expected_status:
+                    raise DroveException(r.status_code, "Drove call failed with status: " + str(r.status_code))
+                with open(filename, 'wb') as f:
+                    for chunk in r.iter_content(chunk_size=8192): 
+                        # If you have chunk encoded response uncomment if
+                        # and set chunk_size parameter to None.
+                        #if chunk: 
+                        f.write(chunk)
+                        size = size + len(chunk)
+            return size
+        except DroveException:
+            raise
+        except Exception as e:
+            raise DroveException(-1, str(e))
+        
+    def post(self, path: str, body: dict,  parse=True, expected_status = 200) -> dict:
+        try:
+            response = self.session.post(self.endpoint + path, json=body)
+        except requests.ConnectionError as e:
+            raise DroveException(-1, "Error connecting to endpoint " + self.endpoint, raw={})
+        return handle_drove_response(response, expected_status)
+        
+def handle_drove_response(response: requests.Response, expected_status: int):
+    status_code = response.status_code
+    text = response.text
+    api_response = None
+    try:
+        if text != None and response.json() != None:
+            api_response = response.json()
+    except json.decoder.JSONDecodeError:
+        raise DroveException(status_code, text)
+    except Exception as e:
+        raise DroveException(status_code, str(e))
+    if status_code != expected_status:
+        raise DroveException(status_code,
+                            "Drove call failed with status code: {code}, error: {message}".format(code=status_code, message=text),
+                            api_response=api_response)
+    if api_response == None:
+        raise DroveException(status_code, "Drove call failed with status code: {code}".format(code=status_code))
+                                
+    if "status" in api_response:
+        if api_response["status"] != "SUCCESS":
+            raise DroveException(status_code, message = api_response.get("message", ""), raw=text, api_response=api_response)
+    else:
+        raise DroveException(status_code, text)
+    return api_response["data"] if "data" in api_response else api_response
+
+def build_drove_client(drove_client: DroveClient, args: SimpleNamespace):
+    endpoint = args.endpoint
+    auth_header = args.auth_header
+    insecure = args.insecure
+    username = args.username
+    password = args.password
+
+    if endpoint is None:
+        # If cmdl options are not passed, see if config file is passed
+        # If config file path is not passed, see if .drove exists in home and use that
+        config_file = args.file if args.file is not None else str(Path.home()) + "/.drove"
+        # Try to parse config if it exists and is readable
+        if os.path.isfile(config_file) and os.access(config_file, os.R_OK):
+            config_parser = configparser.ConfigParser()
+            try:
+                with open(config_file) as stream:
+                    config_parser.read_string(stream.read())
+                drove_config = config_parser['DEFAULT']
+                if args.cluster is not None:
+                    if args.cluster in config_parser:
+                        drove_config = config_parser[args.cluster]
+                    else:
+                        print("error: No cluster definition found for {cluster} in config {config_file}".format(config_file=config_file, cluster=args.cluster))
+                        return None
+                endpoint = drove_config.get("endpoint")
+                username = drove_config.get("username")
+                password = drove_config.get("password")
+                auth_header = drove_config.get("auth_header", None)
+                insecure = drove_config.get("insecure", False)
+            except Exception as e:
+                #Looks like some random file was passed. Bail out
+                print("Error parsing config file " + config_file + ": " + str(e))
+                return None
+        else:
+            print("Error: Config file {config_file} is not present or readable".format(config_file=config_file))
+            return None
+    # At least endpoint is needed
+    if endpoint == None:
+        raise Exception("Error: provide config file or required command line params for drove connectivity\n")
+    endpoint = endpoint[:-1] if endpoint.endswith('/') else endpoint
+    if args.debug:
+        print('Endpoint: {endpoint} Username: {has_username} Password: {has_password} AuthHeader: {has_auth_header} Insecure: {insecure}'
+              .format(endpoint=endpoint, has_username=username is not None, has_password=password is not None,
+                       has_auth_header=auth_header is not None, insecure=insecure))
+    drove_client.start(endpoint, auth_header, username, password, insecure)
+    return drove_client
+    

droveutils.py

@@ -0,0 +1,91 @@
+import datetime
+import droveclient
+import json
+import tabulate
+import time
+
+def print_dict(data: dict, level: int = 0):
+    for key, value in data.items():
+        print(level * 4 * " ", end='')
+        if type(value) is dict and not len(dict(value)) == 0:
+            print(f"{key: <30}")
+            print_dict(value, level + 1)
+        elif type(value) is list and all(isinstance(n, dict) for n in value):
+            print(f"{key: <30}")
+            for item in value:
+                print_dict(item, level + 1)
+                print()
+        else:
+            print(f"{key: <30}{value}")
+
+def print_json(data: dict):
+    print(json.dumps(data, indent = 4))
+
+def print_table(headers: list, data: list):
+    print(tabulate.tabulate(data, headers=headers))
+
+def print_dict_table(data: dict, headers: list = None):
+    if headers:
+        print(tabulate.tabulate(data, headers=headers))
+    else:
+        print(tabulate.tabulate(data, headers="keys"))
+                            
+def to_date(epoch: int) -> str:
+    date = datetime.datetime.fromtimestamp(epoch/1000)
+    return date.strftime("%d/%m/%Y, %H:%M:%S")
+
+def now():
+    return round(time.time() * 1000)
+
+def populate_resources(raw: dict, output: dict):
+    cpu_list = [r for r in raw.get("resources", list()) if r.get("type", "") == "CPU"]
+    if len(cpu_list) > 0:
+        output["CPU"] = ", ".join(["NUMA Node %s: Cores: %s" % (key, value) for (key, value) in cpu_list[0].get("cores", dict()).items()])
+    memory_list = [r for r in raw.get("resources", list()) if r.get("type", "") == "MEMORY"]
+    if len(memory_list) > 0:
+        output["Memory (MB)"] = ", ".join(["NUMA Node %s: Cores: %s" % (key, value) for (key, value) in memory_list[0].get("memoryInMB", dict()).items()])
+
+def list_logs(drove_client: droveclient.DroveClient, prefix: str, domain: str, id: str):
+    data = drove_client.get_raw("/apis/v1/logfiles/{prefix}/{domain}/{id}/list".format(prefix=prefix, domain=domain, id=id))
+    print_dict(data)
+
+def tail_log(drove_client: droveclient.DroveClient, prefix: str, domain: str, id: str, file_name: str):
+    offset:int = -1
+    old_offset:int = -1
+    while True:
+        old_offset = offset
+        data = drove_client.get_raw("/apis/v1/logfiles/{prefix}/{domain}/{id}/read/{name}?offset={offset}"
+                                    .format(prefix=prefix, domain=domain, id=id, name=file_name, offset=offset))
+        data_length = len(data["data"])
+        if old_offset == -1:
+            offset = int(data["offset"])
+        else:
+            offset = offset + data_length
+        
+        if data_length == 0:
+            time.sleep(1) #Nothing available right now .. try a bit later. TODO: binary backoff overkill here?
+        else:
+            print(data["data"], end='')
+
+def download_log(drove_client: droveclient.DroveClient, prefix: str, domain: str, id: str, file_name: str, outfilename: str):
+    print("Downloading log to: " + outfilename)
+    size = drove_client.get_to_file("/apis/v1/logfiles/{prefix}/{domain}/{id}/download/{name}"
+                                    .format(prefix=prefix, domain=domain, id=id, name=file_name), outfilename)
+    print("Downloaded size: {size:,} bytes".format(size = size))
+
+def print_drove_error(e: droveclient.DroveException, print_raw: bool):
+    printed = False
+    if e.api_response != None:
+        if "data" in e.api_response:
+            if "message" in e.api_response:
+                print("Error: [{code} - {status}] {message}.".format(message=e.api_response["message"], code=e.status_code, status=e.api_response["status"]))
+                printed = True
+            if "validationErrors" in e.api_response["data"]:
+                print("Validation errors:")
+                [print("  - " + err) for err in e.api_response["data"]["validationErrors"]]
+                printed = True
+        if print_raw:
+            print("Raw Response: ")
+            print_json(e.api_response)
+    if printed == False:
+        print("Error making Drove call: {error}".format(error = str(e)))

plugins/__init__.py

@@ -0,0 +1,47 @@
+import argparse
+import droveclient
+import os
+import traceback
+
+from importlib import util
+from types import SimpleNamespace
+
+
+class DrovePlugin:
+    plugins = []
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls.plugins.append(cls)
+
+    def __init__(self) -> None:
+        self.drove_client: droveclient.DroveClient = None
+        self.parser: argparse.ArgumentParser = None
+        
+    def populate_options(self, drove_client: droveclient.DroveClient, subparser: argparse.ArgumentParser):
+        self.drove_client = drove_client
+        subparser.set_defaults(func=self.process)
+        self.parser = subparser
+
+    def process(self, options: SimpleNamespace):
+        self.parser.print_help()
+        exit(-1)
+
+def load_module(path):
+    name = os.path.split(path)[-1]
+    spec = util.spec_from_file_location(name, path)
+    module = util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+path = os.path.abspath(__file__)
+dirpath = os.path.dirname(path)
+
+for fname in os.listdir(dirpath):
+    # Load only "real modules"
+    if not fname.startswith('.') and \
+       not fname.startswith('__') and fname.endswith('.py'):
+        try:
+            load_module(os.path.join(dirpath, fname))
+        except Exception:
+            traceback.print_exc()

plugins/appinstances.py

@@ -0,0 +1,169 @@
+import argparse
+import droveclient
+import droveutils
+import plugins
+import tenacity
+
+from operator import itemgetter
+from tenacity import retry
+from types import SimpleNamespace
+
+class Applications(plugins.DrovePlugin):
+    def __init__(self) -> None:
+        pass
+
+    def populate_options(self, drove_client: droveclient.DroveClient, subparser: argparse.ArgumentParser):
+        parser = subparser.add_parser("appinstances", help="Drove application instance related commands")
+
+        commands = parser.add_subparsers(help="Available commands for application management")
+
+        sub_parser = commands.add_parser("list", help="List all application instances")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("--old", "-o", help="Show old instances", action="store_true")
+        sub_parser.add_argument("--sort", "-s", help="Sort output by column", type=int, choices=range(0, 6), default = 0)
+        sub_parser.add_argument("--reverse", "-r", help="Sort in reverse order", action="store_true")
+        sub_parser.set_defaults(func=self.list_instances)
+
+        sub_parser = commands.add_parser("info", help="Print details for an application instance")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instance_id", metavar="instance-id", help="Application Instance ID")
+        sub_parser.set_defaults(func=self.show_instance)
+
+        sub_parser = commands.add_parser("logs", help="Print list of logs for application instance")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instance_id", metavar="instance-id", help="Application Instance ID")
+        sub_parser.set_defaults(func=self.show_logs_list)
+
+        sub_parser = commands.add_parser("tail", help="Tail log for application instance")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instance_id", metavar="instance-id", help="Application Instance ID")
+        sub_parser.add_argument("--log", "-l", default = "output.log", help="Log filename to tail. Default is to tail output.log")
+        sub_parser.set_defaults(func=self.log_tail)
+
+        sub_parser = commands.add_parser("download", help="Download log for application instance")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instance_id", metavar="instance-id", help="Application Instance ID")
+        sub_parser.add_argument("applogfile", help="Log filename to download")
+        sub_parser.add_argument("--out", "-o", help="Filename to download to. Default is the same filename as provided.")
+        sub_parser.set_defaults(func=self.log_download)
+
+
+        sub_parser = commands.add_parser("replace", help="Replace specific app instances with fresh instances")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instance_ids", nargs="+", metavar="instance-id", help="Application Instance IDs")
+        sub_parser.add_argument("--parallelism", "-p", help="Number of parallel threads to be used to execute operation", type=int, default = 1)
+        sub_parser.add_argument("--timeout", "-t", help="Timeout for the operation on the cluster", type=str, default = "5m")
+        sub_parser.add_argument("--wait", "-w", help="Wait to ensure all instances are replaced", default=False, action="store_true")
+        sub_parser.set_defaults(func=self.replace)
+
+        sub_parser = commands.add_parser("kill", help="Kill specific app instances")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instance_ids", nargs="+", metavar="instance-id", help="Application Instance IDs")
+        sub_parser.add_argument("--parallelism", "-p", help="Number of parallel threads to be used to execute operation", type=int, default = 1)
+        sub_parser.add_argument("--timeout", "-t", help="Timeout for the operation on the cluster", type=str, default = "5m")
+        sub_parser.add_argument("--wait", "-w", help="Wait to ensure all instances are killed", default=False, action="store_true")
+        sub_parser.set_defaults(func=self.kill)
+
+        # sub_parser = commands.add_parser("create", help="Create application")
+        # sub_parser.add_argument("definition", help="JSON application definition")
+        
+        super().populate_options(drove_client, parser)
+
+
+    def list_instances(self, options: SimpleNamespace):
+        api = "/apis/v1/applications/{app_id}/instances"
+        if options.old:
+            api = "/apis/v1/applications/{app_id}/instances/old"
+        data = self.drove_client.get(api.format(app_id = options.app_id))
+        #headers = ["Instance ID", "Executor", "CPU", "Memory(MB)", "State", "Error Message", "Created", "Last Updated"]
+        headers = ["Instance ID", "Executor Host", "State", "Error Message", "Created", "Last Updated"]
+        rows = []
+        for instance in data:
+            instance_row = []
+            instance_row.append(instance["instanceId"])
+            try:
+                instance_row.append(instance["localInfo"]["hostname"])
+            except KeyError:
+                instance_row.append("")
+            instance_row.append(instance["state"])
+            instance_row.append(instance["errorMessage"])
+            instance_row.append(droveutils.to_date(instance["created"]))
+            instance_row.append(droveutils.to_date(instance["updated"]))
+
+            rows.append(instance_row)
+        rows = sorted(rows, key=itemgetter(options.sort), reverse=options.reverse)
+        droveutils.print_table(headers, rows)
+
+    def show_instance(self, options):
+        raw = self.drove_client.get("/apis/v1/applications/{app_id}/instances/{instance_id}".format(app_id = options.app_id, instance_id=options.instance_id))
+        data = dict()
+        data["Instance ID"] = raw["instanceId"]
+        data["App ID"] = raw["appId"]
+        data["State"] = raw["state"]
+        data["Host"] = raw.get("localInfo", dict()).get("hostname", "")
+        droveutils.populate_resources(raw, data)
+        ports = raw.get("localInfo", dict()).get("ports", dict())
+        data["Ports"] = ", ".join(["%s: %s" % (key, "{containerPort}->{hostPort} ({portType})".format_map(value)) for (key, value) in ports.items()])
+        data["Metadata"] = ", ".join(["%s: %s" % (key,value) for (key, value) in raw.get("metadata", dict())])
+        data["Error Message"] = raw.get("errorMessage", "").strip('\n')
+        data["Created"] = droveutils.to_date(raw.get("created"))
+        data["Last Updated"] = droveutils.to_date(raw.get("updated"))
+
+        droveutils.print_dict(data)
+
+    def show_logs_list(self, options):
+        droveutils.list_logs(self.drove_client, "applications", options.app_id, options.instance_id)
+
+    def log_tail(self, options):
+        droveutils.tail_log(self.drove_client, "applications", options.app_id, options.instance_id, options.log)
+        
+    def log_download(self, options):
+        filename = options.applogfile
+        if options.out and len(options.out) > 0:
+            filename = options.out
+        droveutils.download_log(self.drove_client, "applications", options.app_id, options.instance_id, options.applogfile, filename)
+
+    def replace(self, options):
+        operation = {
+            "type": "REPLACE_INSTANCES",
+            "appId": options.app_id,
+            "instanceIds": options.instance_ids,
+            "opSpec": {
+                "timeout": options.timeout,
+                "parallelism": options.parallelism,
+                "failureStrategy": "STOP"
+            }
+        }
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        if options.wait:
+            self.ensure_replaced(options.app_id, set(options.instance_ids))
+            print("All instances replaced")
+        else:
+            print("Instance(s) replace command accepted.")
+
+    def kill(self, options):
+        operation = {
+            "type": "STOP_INSTANCES",
+            "appId": options.app_id,
+            "instanceIds": options.instance_ids,
+            "skipRespawn": True,
+            "opSpec": {
+                "timeout": options.timeout,
+                "parallelism": options.parallelism,
+                "failureStrategy": "STOP"
+            }
+        }
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        if options.wait:
+            self.ensure_replaced(options.app_id, set(options.instance_ids))
+            print("All instances replaced")
+        else:
+            print("Instance(s) kill command accepted.")
+
+    @retry(wait=tenacity.wait_exponential(multiplier=1, min=4, max=10),
+           retry=tenacity.retry_if_result(lambda x: x == False))
+    def ensure_replaced(self, app_id: str, existing: set) -> bool:
+        healthy = self.drove_client.app_instances(app_id, False)
+        overlap = len(existing.intersection(healthy))
+        print("Remaining old instance count: {overlap}".format(overlap = overlap))
+        return overlap == 0