drove-cli 0.0.1__py3-none-any.whl

plugins/applications.py

@@ -0,0 +1,233 @@
+import argparse
+import droveclient
+import droveutils
+import json
+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("apps", help="Drove application related commands")
+
+        commands = parser.add_subparsers(help="Available commands for application management")
+
+        sub_parser = commands.add_parser("list", help="List all applications")
+        sub_parser.add_argument("--sort", "-s", help="Sort output by column", type=int, choices=range(0, 9), default = 0)
+        sub_parser.add_argument("--reverse", "-r", help="Sort in reverse order", action="store_true")
+        sub_parser.set_defaults(func=self.list_apps)
+
+        sub_parser = commands.add_parser("summary", help="Show a summary for an application")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.set_defaults(func=self.show_summary)
+
+        sub_parser = commands.add_parser("spec", help="Print the raw json spec for an application")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.set_defaults(func=self.show_spec)
+
+        sub_parser = commands.add_parser("create", help="Create application on cluster")
+        sub_parser.add_argument("spec_file", metavar="spec-file", help="JSON spec file for the application")
+        sub_parser.set_defaults(func=self.create_app)
+        
+        sub_parser = commands.add_parser("destroy", help="Destroy an app with zero instances")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.set_defaults(func=self.destroy_app)
+
+        sub_parser = commands.add_parser("deploy", help="Deploy new app instances.")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instances", metavar="instances", type=int, help="Number of new instances to be created")
+        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 instance count is reached", default=False, action="store_true")
+        sub_parser.set_defaults(func=self.deploy_app)
+
+
+        sub_parser = commands.add_parser("scale", help="Scale app to required instances. Will increase or decrease instances on the cluster to match this number")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.add_argument("instances", metavar="instances", type=int, help="Number of instances. Setting this to 0 will suspend the app")
+        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 instance count is reached", default=False, action="store_true")
+        sub_parser.set_defaults(func=self.scale_app)
+
+        sub_parser = commands.add_parser("suspend", help="Suspend the app")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        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 suspended", default=False, action="store_true")
+        sub_parser.set_defaults(func=self.suspend_app)
+
+        sub_parser = commands.add_parser("restart", help="Restart am existing app instances.")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        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.restart_app)
+
+        sub_parser = commands.add_parser("cancelop", help="Cancel current operation")
+        sub_parser.add_argument("app_id", metavar="app-id", help="Application ID")
+        sub_parser.set_defaults(func=self.cancel_app_operation)
+
+        super().populate_options(drove_client, parser)
+
+
+    def list_apps(self, options: SimpleNamespace):
+        data = self.drove_client.get('/apis/v1/applications')
+        app_rows = []
+        for app_id, app_data in data.items():
+            row = []
+            row.append(app_id)
+            row.append(app_data["name"])
+            row.append(app_data["state"])
+            row.append(app_data["totalCPUs"])
+            row.append(app_data["totalMemory"])
+            row.append(app_data["requiredInstances"])
+            row.append(app_data["healthyInstances"])
+            row.append(droveutils.to_date(app_data["created"]))
+            row.append(droveutils.to_date(app_data["updated"]))
+
+            app_rows.append(row)
+
+        app_rows = sorted(app_rows, key=itemgetter(options.sort), reverse=options.reverse)
+
+        headers = ["Id", "Name", "State", "Total CPU", "Total Memory(MB)", "Required Instances", "Healthy Instances", "Created", "Updated"]
+        droveutils.print_table(headers, app_rows)
+
+    def show_summary(self, options: SimpleNamespace):
+        data = self.drove_client.get("/apis/v1/applications/{app_id}".format(app_id = options.app_id))
+        droveutils.print_dict(data)
+
+    def show_spec(self, options: SimpleNamespace):
+        data = self.drove_client.get("/apis/v1/applications/{app_id}/spec".format(app_id = options.app_id))
+        droveutils.print_json(data)
+
+    def create_app(self, options: SimpleNamespace):
+        try:
+            with open(options.spec_file, 'r') as fp:
+                spec = json.load(fp)
+            operation = {
+                "type": "CREATE",
+                "spec": spec,
+                "opSpec": {
+                   "timeout": "5m",
+                    "parallelism": 1,
+                    "failureStrategy": "STOP"
+                }
+            }
+            data = self.drove_client.post("/apis/v1/applications/operations", operation)
+            print("Application created with app id: {appid}".format(appid=data["appId"]))
+        except (OSError, IOError) as e:
+            print("Error creating application. Error: " + str(e))
+
+    def destroy_app(self, options: SimpleNamespace):
+        operation = {
+            "type": "DESTROY",
+            "appId": options.app_id,
+            "opSpec": {
+                "timeout": "5m",
+                "parallelism": 1,
+                "failureStrategy": "STOP"
+            }
+        }
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        print("Application destroyed")
+
+    def scale_app(self, options: SimpleNamespace):
+        operation = {
+            "type": "SCALE",
+            "appId": options.app_id,
+            "requiredInstances": options.instances,
+            "opSpec": {
+                "timeout": options.timeout,
+                "parallelism": options.parallelism,
+                "failureStrategy": "STOP"
+            }
+        }
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        if options.wait:
+            print("Waiting till required scale is reached")
+            self.ensure_count(options.app_id, options.instances)
+            print("Required number of instances reached")
+        else:
+            print("Application scaling command accepted. Please use appinstances comand or the UI to check status of deployment")
+
+    def suspend_app(self, options: SimpleNamespace):
+        operation = {
+            "type": "SUSPEND",
+            "appId": options.app_id,
+            "opSpec": {
+                "timeout": options.timeout,
+                "parallelism": options.parallelism,
+                "failureStrategy": "STOP"
+            }
+        }
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        if options.wait:
+            print("Waiting till all instances shut down")
+            self.ensure_count(options.app_id, 0)
+            print("All instances suspended")
+        else:
+            print("Application suspend command accepted.")
+
+    def deploy_app(self, options: SimpleNamespace):
+        operation = {
+            "type": "START_INSTANCES",
+            "appId": options.app_id,
+            "instances": options.instances,
+            "opSpec": {
+                "timeout": options.timeout,
+                "parallelism": options.parallelism,
+                "failureStrategy": "STOP"
+            }
+        }
+        existing_count = 0 if options.wait == False else len(self.drove_client.app_instances(options.app_id))
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        if options.wait:
+            print("Waiting till required scale is reached")
+            self.ensure_count(options.app_id, existing_count + options.instances)
+            print("Required number of instances reached")
+        else:
+            print("Application deployment command accepted. Please use appinstances comand or the UI to check status of deployment")
+
+    def restart_app(self, options: SimpleNamespace):
+        operation = {
+            "type": "REPLACE_INSTANCES",
+            "appId": options.app_id,
+            "opSpec": {
+                "timeout": options.timeout,
+                "parallelism": options.parallelism,
+                "failureStrategy": "STOP"
+            }
+        }
+        existing = [] if options.wait == False else self.drove_client.app_instances(options.app_id)
+        data = self.drove_client.post("/apis/v1/applications/operations", operation)
+        if options.wait:
+            self.ensure_replaced(options.app_id, set(existing))
+            print("All instances replaced")
+        else:
+            print("Application restart command accepted.")
+
+    def cancel_app_operation(self, options: SimpleNamespace):
+        data = self.drove_client.post("/apis/v1/operations/{appId}/cancel".format(appId=options.app_id), None, False)
+        print("Operation cancellation request registered :" + data["message"])
+
+    @retry(wait=tenacity.wait_exponential(multiplier=1, min=4, max=10),
+           retry=tenacity.retry_if_result(lambda x: x == False))
+    def ensure_count(self, app_id: str, instances: int) -> bool:
+        healthy = len(self.drove_client.app_instances(app_id))
+        print("Healthy instances count: {count}".format(count=healthy))
+        return healthy == instances
+
+    @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)
+        overlap = len(existing.intersection(healthy))
+        print("Remaining old instance count: {overlap}".format(overlap = overlap))
+        return overlap == 0

plugins/cluster.py

@@ -0,0 +1,116 @@
+import argparse
+from operator import itemgetter
+import droveclient
+import droveutils
+import json
+import plugins
+import time
+
+from types import SimpleNamespace
+
+class Cluster(plugins.DrovePlugin):
+    def __init__(self) -> None:
+        pass
+
+    def populate_options(self, drove_client: droveclient.DroveClient, subparser: argparse.ArgumentParser):
+        parser = subparser.add_parser("cluster", help="Drove cluster related commands")
+        
+        commands = parser.add_subparsers(help="Available commands for cluster management")
+
+        sub_parser = commands.add_parser("ping", help="Ping the cluster")
+        sub_parser.set_defaults(func=self.ping)
+
+        sub_parser = commands.add_parser("summary", help="Show cluster summary")
+        sub_parser.set_defaults(func=self.show_summary)
+
+        sub_parser = commands.add_parser("leader", help="Show leader for cluster")
+        sub_parser.set_defaults(func=self.show_leader)
+
+        sub_parser = commands.add_parser("endpoints", help="Show all exposed endpoints")
+        sub_parser.add_argument("--vhost", "-v", help="Show details only for the specific vhost")
+
+        sub_parser.set_defaults(func=self.show_endpoints)
+
+        sub_parser = commands.add_parser("events", help="Events on the cluster")
+        sub_parser.add_argument("--follow", "-f", help="Follow events (Press CTRL-C to kill)", action="store_true")
+        sub_parser.add_argument("--type", "-t", help="Output events of only the matching type")
+        sub_parser.add_argument("--count", "-c", help="Fetch <count> events at a time.", default=1024, type=int)
+        sub_parser.add_argument("--textfmt", "-s", help="Use the format string to print message", type=str, default="{type: <25} | {id: <36} | {time: <20} | {metadata}")
+        sub_parser.set_defaults(func=self.handle_events)
+
+
+        # maintenance_parser = commands.add_parser("maintenance-on", help="Set cluster to maintenance mode")
+        # maintenance_parser.set_defaults(func=self.set_maintenance)
+
+        # maintenance_parser = commands.add_parser("maintenance-off", help="Removed maintenance mode on cluster")
+        # maintenance_parser.set_defaults(func=self.unset_maintenance)
+
+        # executors_command = commands.add_parser("executors", help="List executors")
+        # executors_command.add_argument("--list", "-l", help="List executors", action="store_true")
+        # executors_command.add_argument("--info", "-i", dest='executor_id', help="Get detailed info about executor")
+
+        super().populate_options(drove_client, parser)
+
+    def ping(self, options: SimpleNamespace):
+        try:
+            self.drove_client.get("/apis/v1/ping")
+            print("Cluster ping successful")
+        except droveclient.DroveException as e:
+            print("Error pinging drove cluster: status: {status} message: {message} raw: {raw}"
+                  .format(status = e.status_code, message = str(e), raw = e.raw))
+        except Exception as e:
+            print("Error pinging drove cluster: " + str(e))
+
+    def show_summary(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/cluster")
+        data = dict()
+        data["State"] = raw["state"]
+        data["Leader Controller"] = raw.get("leader", "")
+        data["Cores"] = "Utilization: {util:.0%} (Total: {total} Used: {used} Free: {free})".format(util = float(raw["usedCores"]/raw["totalCores"]), total=raw["totalCores"], used = raw["usedCores"], free = raw["freeCores"])
+        data["Memory"] = "Utilization: {util:.0%} (Total: {total:,} MB Used: {used:,} MB Free: {free:,} MB)".format(util = float(raw["usedMemory"]/raw["totalMemory"]), total = raw["totalMemory"], used = raw["usedMemory"], free = raw["freeMemory"])
+        data["Number of live executors"] = raw["numExecutors"]
+        data["Applications"] = "Active: {active:,} Total: {total:,}".format(total = raw["numApplications"], active =  raw["numActiveApplications"])
+
+        droveutils.print_dict(data)
+
+    def show_leader(self, options: SimpleNamespace):
+        data = self.drove_client.get("/apis/v1/cluster")
+        try:
+            print("Cluster leader: " + data["leader"])
+        except KeyError:
+            print("Cluster has no leader")
+
+    def show_endpoints(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/endpoints")
+        data = sorted(raw, key=itemgetter('vhost', 'appId'))
+        if options.vhost:
+            data = [d for d in data if d['vhost'] == options.vhost]
+        droveutils.print_dict({"endpoints" : data})
+
+    def handle_events(self, options: SimpleNamespace):
+        currtime = 0
+        while True:
+            events = self.drove_client.get("/apis/v1/cluster/events?size={size}&lastSyncTime={time}".format(size=options.count, time=currtime))
+            if options.type:
+                events = [e for e in events if e['type'] == options.type]
+            if len(events) > 0:
+                print("\n".join([self.convert_event(options.textfmt, e) for e in events]))
+            if not options.follow:
+                break
+            currtime = droveutils.now()
+            time.sleep(1)
+
+    def set_maintenance(self, options: SimpleNamespace):
+        print("Maintenance mode set")
+    
+    def unset_maintenance(self, options: SimpleNamespace):
+        print("Maintenance mode unset")
+
+    def convert_event(self, format: str, event: dict) -> str:
+        data = dict()
+        data["type"] = event["type"]
+        data["id"] = event["id"]
+        data["time"] = droveutils.to_date(event["time"])
+        data["metadata"] = json.dumps(event["metadata"])
+
+        return format.format_map(data)

plugins/executors.py

@@ -0,0 +1,129 @@
+import argparse
+from operator import itemgetter
+import droveclient
+import droveutils
+import json
+import plugins
+import time
+
+from types import SimpleNamespace
+
+class Executors(plugins.DrovePlugin):
+    def __init__(self) -> None:
+        pass
+
+    def populate_options(self, drove_client: droveclient.DroveClient, subparser: argparse.ArgumentParser):
+        parser = subparser.add_parser("executor", help="Drove cluster executor related commands")
+        
+        commands = parser.add_subparsers(help="Available commands for cluster executor management")
+
+        sub_parser = commands.add_parser("list", help="List all executors")
+        sub_parser.set_defaults(func=self.list)
+
+        sub_parser = commands.add_parser("info", help="Show details about executor")
+        sub_parser.add_argument("executor_id", metavar="executor-id", help="Executor id for which info is to be shown")
+        sub_parser.set_defaults(func=self.show_info)
+
+        sub_parser = commands.add_parser("appinstances", help="Show app instances running on this executor")
+        sub_parser.add_argument("executor_id", metavar="executor-id", help="Executor id for which info is to be shown")
+        sub_parser.add_argument("--sort", "-s", help="Sort output by column", type=int, choices=range(0, 6), default = 1)
+        sub_parser.add_argument("--reverse", "-r", help="Sort in reverse order", action="store_true")
+        sub_parser.set_defaults(func=self.show_appinstances)
+
+
+        sub_parser = commands.add_parser("tasks", help="Show tasks running on this executor")
+        sub_parser.add_argument("executor_id", metavar="executor-id", help="Executor id for which info is to be shown")
+        sub_parser.add_argument("--sort", "-s", help="Sort output by column", type=int, choices=range(0, 6), default = 1)
+        sub_parser.add_argument("--reverse", "-r", help="Sort in reverse order", action="store_true")
+        sub_parser.set_defaults(func=self.show_tasks)
+
+        super().populate_options(drove_client, parser)
+
+    def list(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/cluster/executors")
+        droveutils.print_dict_table(raw, headers={"executorId" : "Executor ID",
+                                                "hostname" : "Host",
+                                                "port" : "Port",
+                                                "transportType" : "Transport",
+                                                "freeCores" : "Free Cores",
+                                                "usedCores" : "Used Cores",
+                                                "freeMemory" : "Free Memory (MB)",
+                                                "usedMemory" : "Used Memory (MB)",
+                                                "tags" : "Tags",
+                                                "state" : "State"})
+
+    def show_info(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/cluster/executors/{id}".format(id=options.executor_id))
+        # droveutils.print_dict(raw)
+        data = dict()
+        data["ID"] = raw["state"]["executorId"]
+        data["Host"] = raw["hostname"]
+        data["Port"] = raw["port"]
+        data["Transport"] = raw["transportType"]
+        cpu_nodes = dict()
+        for key, value in raw["state"]["cpus"]["freeCores"].items():
+            cpu_nodes["NUMA node " + str(key)] = "Free cores: " + ",".join(map(str, sorted(value)))
+        for key, value in raw["state"]["cpus"]["usedCores"].items():
+            cpu_nodes["NUMA node " + str(key)] = cpu_nodes.get("NUMA node " + str(key), "") + " Used cores: " + ",".join(map(str, sorted(value)))
+        memory_nodes = dict()
+        for key, value in raw["state"]["memory"]["freeMemory"].items():
+            memory_nodes["NUMA node " + str(key)] = "Free : {0: ,} MB".format(value)
+        for key, value in raw["state"]["memory"]["usedMemory"].items():
+            memory_nodes["NUMA node " + str(key)] = memory_nodes.get("NUMA node " + str(key), "") + " Used: {0: ,} MB".format(value)
+
+        data["Resources"] = { "CPU" : cpu_nodes, "Memory" : memory_nodes }
+        data["Blacklisted"] = raw["blacklisted"]
+        data["Tags"] = ",".join(raw["tags"])
+        data["Last Updated"] = droveutils.to_date(raw["updated"])
+
+        droveutils.print_dict(data)
+
+    def show_appinstances(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/cluster/executors/{id}".format(id=options.executor_id))
+        headers = ["Instance ID", "App name", "App ID", "CPU", "Memory (MB)", "State", "Error Message", "Created", "Last Updated"]
+        rows = []
+        for instance in raw.get("instances", list()):
+            row = []
+            row.append(instance["instanceId"])
+            row.append(instance["appName"])
+            row.append(instance["appId"])
+            cpu_list = [r for r in instance.get("resources", list()) if r.get("type", "") == "CPU"]
+            if len(cpu_list) > 0:
+                row.append(len(cpu_list[0].get("cores", dict())))
+            memory_list = [r for r in instance.get("resources", list()) if r.get("type", "") == "MEMORY"]
+            if len(memory_list) > 0:
+                row.append("{0: ,}".format(sum(memory_list[0].get("memoryInMB", dict()).values())))
+            row.append(instance["state"])
+            row.append(instance["errorMessage"])
+            row.append(droveutils.to_date(instance["created"]))
+            row.append(droveutils.to_date(instance["updated"]))
+
+            rows.append(row)
+        rows = sorted(rows, key=itemgetter(options.sort), reverse=options.reverse)
+        droveutils.print_table(headers, rows)
+
+    def show_tasks(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/cluster/executors/{id}".format(id=options.executor_id))
+        task_rows = []
+        for task in raw.get("tasks", list()):
+            if options.app and task["sourceAppName"] != options.app:
+                continue
+            row = []
+            row.append(task["instanceId"])
+            row.append(task["sourceAppName"])
+            row.append(task["taskId"])
+            row.append(task["state"])
+            cpu_list = [r for r in task.get("resources", list()) if r.get("type", "") == "CPU"]
+            if len(cpu_list) > 0:
+                row.append(len(cpu_list[0].get("cores", dict())))
+            memory_list = [r for r in task.get("resources", list()) if r.get("type", "") == "MEMORY"]
+            if len(memory_list) > 0:
+                row.append("{0: ,}".format(sum(memory_list[0].get("memoryInMB", dict()).values())))
+            row.append(droveutils.to_date(task["created"]))
+            row.append(droveutils.to_date(task["updated"]))
+
+            task_rows.append(row)
+
+        task_rows = sorted(task_rows, key=itemgetter(options.sort), reverse=options.reverse)
+        headers = ["Id", "Source App", "Task ID", "State", "CPU", "Memory(MB)", "Created", "Updated"]
+        droveutils.print_table(headers, task_rows)

plugins/tasks.py

@@ -0,0 +1,155 @@
+import argparse
+import droveclient
+import droveutils
+import json
+import plugins
+
+from collections import OrderedDict
+from operator import itemgetter
+from types import SimpleNamespace
+
+class Tasks(plugins.DrovePlugin):
+    def __init__(self) -> None:
+        pass
+
+    def populate_options(self, drove_client: droveclient.DroveClient, subparser: argparse.ArgumentParser):
+        parser = subparser.add_parser("tasks", help="Drove task related commands")
+
+        commands = parser.add_subparsers(help="Available commands for task management")
+
+        sub_parser = commands.add_parser("create", help="Spawn a new task on cluster")
+        sub_parser.add_argument("spec_file", metavar="spec-file", help="JSON spec file for the application")
+        sub_parser.set_defaults(func=self.create_task)
+
+        sub_parser = commands.add_parser("kill", help="Kill a running task")
+        sub_parser.add_argument("source_app_name", metavar="source-app-name", help="Source app name as specified in spec")
+        sub_parser.add_argument("task_id", metavar="task-id", help="ID of the task as specified in the spec")
+        sub_parser.set_defaults(func=self.kill_task)
+
+        sub_parser = commands.add_parser("list", help="List all active tasks")
+        sub_parser.add_argument("--app", "-a", help="Show tasks only for the given source app", type=str)
+        sub_parser.add_argument("--sort", "-s", help="Sort output by column", type=int, choices=range(0, 9), default = 0)
+        sub_parser.add_argument("--reverse", "-r", help="Sort in reverse order", action="store_true")
+        sub_parser.set_defaults(func=self.list_task)
+
+        sub_parser = commands.add_parser("show", help="Shows details about a task")
+        sub_parser.add_argument("source_app", metavar="source-app", help="Name of the Drove application that started the task")
+        sub_parser.add_argument("task_id", metavar="task-id", help="Task ID")
+        sub_parser.set_defaults(func=self.show_task)
+
+        sub_parser = commands.add_parser("logs", help="Print list of logs for task")
+        sub_parser.add_argument("source_app", metavar="source-app", help="Name of the Drove application that started the task")
+        sub_parser.add_argument("task_id", metavar="task-id", help="Task ID")
+        sub_parser.set_defaults(func=self.show_logs_list)
+
+        sub_parser = commands.add_parser("tail", help="Tail log for task")
+        sub_parser.add_argument("source_app", metavar="source-app", help="Name of the Drove application that started the task")
+        sub_parser.add_argument("task_id", metavar="task-id", help="Task ID")
+        sub_parser.add_argument("--file", "-f", 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 task")
+        sub_parser.add_argument("source_app", metavar="source-app", help="Name of the Drove application that started the task")
+        sub_parser.add_argument("task_id", metavar="task-id", help="Task ID")
+        sub_parser.add_argument("tasklogfile", 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)
+        
+        super().populate_options(drove_client, parser)
+
+    def create_task(self, options: SimpleNamespace):
+        try:
+            with open(options.spec_file, 'r') as fp:
+                spec = json.load(fp)
+            operation = {
+                "type": "CREATE",
+                "spec": spec,
+                "opSpec": {
+                   "timeout": "5m",
+                    "parallelism": 1,
+                    "failureStrategy": "STOP"
+                }
+            }
+            data = self.drove_client.post("/apis/v1/tasks/operations", operation)
+            print("Task created. Source App Name: {sourceAppName} Task ID: {taskId}. Drove assigned task ID: {internalTaskId}"
+                  .format(internalTaskId=data["taskId"], sourceAppName=spec["sourceAppName"], taskId=spec["taskId"]))
+        except (OSError, IOError) as e:
+            print("Error creating task. Error: " + str(e))
+
+    def kill_task(self, options: SimpleNamespace):
+        operation = {
+            "type": "KILL",
+            "sourceAppName" : options.source_app_name,
+            "taskId" : options.task_id,
+            "opSpec": {
+                "timeout": "5m",
+                "parallelism": 1,
+                "failureStrategy": "STOP"
+            }
+        }
+        data = self.drove_client.post("/apis/v1/tasks/operations", operation)
+        print("Task kill issued")
+
+    def list_task(self, options: SimpleNamespace):
+        data = self.drove_client.get('/apis/v1/tasks')
+        task_rows = []
+        for task in data:
+            if options.app and task["sourceAppName"] != options.app:
+                continue
+            row = []
+            row.append(task["instanceId"])
+            row.append(task["sourceAppName"])
+            row.append(task["taskId"])
+            row.append(task["state"])
+            row.append(task.get("hostname", ""))
+            cpu_list = [r for r in task.get("resources", list()) if r.get("type", "") == "CPU"]
+            if len(cpu_list) > 0:
+                row.append(len(cpu_list[0].get("cores", dict())))
+            memory_list = [r for r in task.get("resources", list()) if r.get("type", "") == "MEMORY"]
+            if len(memory_list) > 0:
+                row.append(sum(memory_list[0].get("memoryInMB", dict()).values()))
+            row.append(droveutils.to_date(task["created"]))
+            row.append(droveutils.to_date(task["updated"]))
+
+            task_rows.append(row)
+
+        task_rows = sorted(task_rows, key=itemgetter(options.sort), reverse=options.reverse)
+
+        headers = ["Id", "Source App", "Task ID", "State", "Host", "CPU", "Memory(MB)", "Created", "Updated"]
+        droveutils.print_table(headers, task_rows)
+
+    def show_task(self, options: SimpleNamespace):
+        raw = self.drove_client.get("/apis/v1/tasks/{source_app}/instances/{task_id}".format(source_app = options.source_app, task_id = options.task_id))
+        data = OrderedDict()
+        data["Source App"] = raw["sourceAppName"]
+        data["Task ID"] = raw["taskId"]
+        data["Instance ID"] = raw["instanceId"]
+        data["State"] = raw["state"]
+        data["Executor Host"] = raw["hostname"]
+        droveutils.populate_resources(raw, data)
+        data["Executable"] = "{url} ({type})".format_map(raw["executable"])
+        data["Volumes"] = ", ".join(["{pathOnHost} (Mounted as {pathInContainer} in {mode} mode)".format_map(v) for v in raw["volumes"]])
+        data["Logging Mode"] = raw.get("logging", dict()).get("type", "")
+        data["Metadata"] = ", ".join(["%s: %s" % (key,value) for (key, value) in raw.get("metadata", dict())])
+        result = raw.get("taskResult", dict())
+        if len(result) > 0:
+            data["Result"] = "{status} (Task exit code: {exitCode})".format_map(result)
+        else:
+            data["Result"] = ""
+        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, "tasks", options.source_app, options.task_id)
+
+    def log_tail(self, options):
+        droveutils.tail_log(self.drove_client, "tasks", options.source_app, options.task_id, options.file)
+        
+    def log_download(self, options):
+        filename = options.tasklogfile
+        if options.out and len(options.out) > 0:
+            filename = options.out
+        droveutils.download_log(self.drove_client, "tasks", options.source_app, options.task_id, options.tasklogfile, filename)