iotedgedev 3.3.4__zip

s/iotedgedev/dockercls.py

@@ -0,0 +1,255 @@
+import os
+import zipfile
+
+import docker
+
+from .deploymentmanifest import DeploymentManifest
+from .utility import Utility
+
+
+class Docker:
+
+    def __init__(self, envvars, utility, output):
+        self.envvars = envvars
+        self.utility = utility
+        self.output = output
+
+        try:
+            self.docker_client = docker.from_env(version="auto")
+            self.docker_api = self.docker_client.api
+        except Exception as ex:
+            msg = "Could not connect to Docker daemon. Please make sure Docker daemon is running and accessible"
+            raise ValueError(msg, ex)
+
+    def get_os_type(self):
+        return self.docker_client.info()["OSType"].lower()
+
+    def init_registry(self):
+
+        for registry in self.envvars.CONTAINER_REGISTRY_MAP.values():
+            self.output.header("INITIALIZING CONTAINER REGISTRY")
+            self.output.info("REGISTRY: " + registry.server)
+
+            if "localhost" in registry.server:
+                self.init_local_registry(registry.server)
+
+        self.output.line()
+
+    def init_local_registry(self, local_server):
+
+        parts = local_server.split(":")
+
+        if len(parts) < 2:
+            raise ValueError("You must specific a port for your local registry server. Expected: 'localhost:5000'. Found: " + local_server)
+
+        port = parts[1]
+        ports = {'5000/tcp': int(port)}
+
+        try:
+            self.output.info("Looking for local 'registry' container")
+            self.docker_client.containers.get("registry")
+            self.output.info("Found local 'registry' container")
+        except docker.errors.NotFound:
+            self.output.info("Local 'registry' container not found")
+
+            try:
+                self.output.info("Looking for local 'registry' image")
+                self.docker_client.images.get("registry:2")
+                self.output.info("Local 'registry' image found")
+            except docker.errors.ImageNotFound:
+                self.output.info("Local 'registry' image not found")
+                self.output.info("Pulling 'registry' image")
+                self.docker_client.images.pull("registry", tag="2")
+
+            self.output.info("Running registry container")
+            self.docker_client.containers.run("registry:2", detach=True, name="registry", ports=ports, restart_policy={"Name": "always"})
+
+    def setup_registry(self):
+        self.output.header("SETTING UP CONTAINER REGISTRY")
+        self.init_registry()
+        self.output.info("PUSHING EDGE IMAGES TO CONTAINER REGISTRY")
+        image_names = ["azureiotedge-agent", "azureiotedge-hub", "azureiotedge-simulated-temperature-sensor"]
+        default_cr = self.envvars.CONTAINER_REGISTRY_MAP['']
+
+        for image_name in image_names:
+
+            microsoft_image_name = "mcr.microsoft.com/{0}:{1}".format(
+                image_name, self.envvars.EDGE_RUNTIME_VERSION)
+
+            container_registry_image_name = "{0}/{1}:{2}".format(
+                default_cr.server, image_name, self.envvars.EDGE_RUNTIME_VERSION)
+
+            # Pull image from MCR
+            try:
+                self.output.info(
+                    "PULLING IMAGE: '{0}'".format(microsoft_image_name))
+                image_pull = self.docker_client.images.pull(
+                    microsoft_image_name)
+                self.output.info(
+                    "SUCCESSFULLY PULLED IMAGE: '{0}'".format(microsoft_image_name))
+                self.output.info(str(image_pull))
+            except docker.errors.APIError as e:
+                self.output.error(
+                    "ERROR WHILE PULLING IMAGE: '{0}'".format(microsoft_image_name))
+                self.output.error(str(e))
+
+            # Tagging Image with Container Registry Name
+            try:
+                self.docker_api.tag(
+                    image=microsoft_image_name, repository=container_registry_image_name)
+            except docker.errors.APIError as e:
+                self.output.error(
+                    "ERROR WHILE TAGGING IMAGE: '{0}'".format(microsoft_image_name))
+                self.output.error(str(e))
+
+            # Push Image to Container Registry
+            try:
+                self.output.info("PUSHING IMAGE: '{0}'".format(
+                    container_registry_image_name))
+
+                response = self.docker_client.images.push(repository=container_registry_image_name, tag=self.envvars.EDGE_RUNTIME_VERSION, stream=True, auth_config={
+                                                          "username": default_cr.username, "password": default_cr.password})
+                self.process_api_response(response)
+                self.output.info("SUCCESSFULLY PUSHED IMAGE: '{0}'".format(
+                    container_registry_image_name))
+            except docker.errors.APIError as e:
+                self.output.error("ERROR WHILE PUSHING IMAGE: '{0}'".format(
+                    container_registry_image_name))
+                self.output.error(str(e))
+
+        self.setup_registry_in_config(image_names)
+
+        self.output.footer("Container Registry Setup Complete")
+
+    def setup_registry_in_config(self, image_names):
+        self.output.info(
+            "Replacing 'mcr.microsoft.com/' with '{CONTAINER_REGISTRY_SERVER}/' in config files.")
+
+        # Replace mcr.microsoft.com/ with ${CONTAINER_REGISTRY_SERVER}
+        for config_file in self.utility.get_config_files():
+            config_file_contents = Utility.get_file_contents(config_file)
+            for image_name in image_names:
+                config_file_contents = config_file_contents.replace(
+                    "mcr.microsoft.com/" + image_name, "${CONTAINER_REGISTRY_SERVER}/" + image_name)
+
+            with open(config_file, "w") as config_file_build:
+                config_file_build.write(config_file_contents)
+
+    def remove_modules(self):
+        self.output.info(
+            "Removing Edge Modules Containers and Images from Docker")
+
+        deployment_manifest = DeploymentManifest(self.envvars, self.output, self.utility, self.envvars.DEPLOYMENT_CONFIG_FILE_PATH, False)
+        modules_in_config = list(deployment_manifest.get_user_modules().keys())
+
+        for module in modules_in_config:
+            self.output.info("Searching for {0} Containers".format(module))
+            containers = self.docker_client.containers.list(
+                filters={"name": module})
+            for container in containers:
+                self.output.info("Removing Container: " + str(container))
+                container.remove(force=True)
+
+            self.output.info("Searching for {0} Images".format(module))
+            for image in self.docker_client.images.list():
+                if module in str(image):
+                    self.output.info(
+                        "Removing Module Image: " + str(image))
+                    self.docker_client.images.remove(
+                        image=image.id, force=True)
+
+    def remove_containers(self):
+        self.output.info("Removing Containers....")
+        containers = self.docker_client.containers.list(all=True)
+        self.output.info("Found {0} Containers".format(len(containers)))
+        for container in containers:
+            self.output.info("Removing Container: {0}:{1}".format(
+                container.id, container.name))
+            container.remove(force=True)
+        self.output.info("Containers Removed")
+
+    def remove_images(self):
+        self.output.info("Removing Dangling Images....")
+        images = self.docker_client.images.list(
+            all=True, filters={"dangling": True})
+        self.output.info("Found {0} Images".format(len(images)))
+
+        for image in images:
+            self.output.info("Removing Image: {0}".format(str(image.id)))
+            self.docker_client.images.remove(image=image.id, force=True)
+        self.output.info("Images Removed")
+
+        self.output.info("Removing Images....")
+        images = self.docker_client.images.list()
+        self.output.info("Found {0} Images".format(len(images)))
+
+        for image in images:
+            self.output.info("Removing Image: {0}".format(str(image.id)))
+            self.docker_client.images.remove(image=image.id, force=True)
+        self.output.info("Images Removed")
+
+    def handle_logs_cmd(self, show, save):
+
+        # Create LOGS_PATH dir if it doesn't exist
+        if save:
+            self.utility.ensure_dir(self.envvars.LOGS_PATH)
+
+        deployment_manifest = DeploymentManifest(self.envvars, self.output, self.utility, self.envvars.DEPLOYMENT_CONFIG_FILE_PATH, False)
+        modules_in_config = list(deployment_manifest.get_all_modules().keys())
+
+        for module in modules_in_config:
+            if show:
+                try:
+                    command = self.envvars.LOGS_CMD.format(module)
+                    os.system(command)
+                except Exception as ex:
+                    self.output.error(
+                        "Error while trying to open module log '{0}' with command '{1}'. Try `iotedgedev docker log --save` instead.".format(module, command))
+                    self.output.error(str(ex))
+            if save:
+                try:
+                    self.utility.exe_proc(["docker", "logs", module, ">",
+                                           os.path.join(self.envvars.LOGS_PATH, module + ".log")], True)
+                except Exception as ex:
+                    self.output.error("Error while trying to save module log file '{0}'".format(module))
+                    self.output.error(str(ex))
+
+        if save:
+            self.zip_logs()
+
+    def zip_logs(self):
+        log_files = [os.path.join(self.envvars.LOGS_PATH, f)
+                     for f in os.listdir(self.envvars.LOGS_PATH) if f.endswith(".log")]
+        zip_path = os.path.join(self.envvars.LOGS_PATH, 'edge-logs.zip')
+
+        self.output.info("Creating {0} file".format(zip_path))
+
+        zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
+
+        for log_file in log_files:
+            self.output.info("Adding {0} to zip". format(log_file))
+            zipf.write(log_file)
+
+        zipf.close()
+
+        self.output.info("Log files successfully saved to: " + zip_path)
+
+    def process_api_response(self, response):
+        for json_ in docker.utils.json_stream.json_stream(response):
+            for key in json_:
+                if key == "stream" and isinstance(json_[key], str):
+                    self.output.procout(json_[key], nl=False)
+                if key == "status" and isinstance(json_[key], str):
+                    message = ""
+                    if ("id" in json_):
+                        message += json_["id"] + " "
+                    message += json_[key] + " "
+                    if ("progress" in json_):
+                        message += json_["progress"]
+                    self.output.procout(message)
+
+            # Docker SDK won't throw exceptions for some failures.
+            # We have to check the response ourselves.
+            # Related issue: https://github.com/docker/docker-py/issues/1772
+            if "error" in json_:
+                raise ValueError(json_["error"])

s/iotedgedev/dotnet.py

@@ -0,0 +1,31 @@
+"""
+This module provides interfaces to interact with dotnet CLI
+"""
+
+
+class DotNet:
+    def __init__(self, output, utility):
+        self.output = output
+        self.utility = utility
+        # Fail fast if dotnet is not on path
+        self.utility.check_dependency(["dotnet", "--version"], "To add new C# modules and C# Functions modules, the .NET Core SDK")
+
+    def install_module_template(self):
+        cmd = "dotnet new -i Microsoft.Azure.IoT.Edge.Module"
+        self.output.header(cmd)
+        self.utility.exe_proc(cmd.split())
+
+    def install_function_template(self):
+        cmd = "dotnet new -i Microsoft.Azure.IoT.Edge.Function"
+        self.output.header(cmd)
+        self.utility.exe_proc(cmd.split())
+
+    def create_custom_module(self, name, repo, cwd):
+        cmd = "dotnet new aziotedgemodule -n {0} -r {1}".format(name, repo)
+        self.output.header(cmd)
+        self.utility.exe_proc(cmd.split(), cwd=cwd)
+
+    def create_function_module(self, name, repo, cwd):
+        cmd = "dotnet new aziotedgefunction -n {0} -r {1}".format(name, repo)
+        self.output.header(cmd)
+        self.utility.exe_proc(cmd.split(), cwd=cwd)

s/iotedgedev/edge.py

@@ -0,0 +1,33 @@
+from iotedgedev.output import Output
+from iotedgedev.envvars import EnvVars
+from iotedgedev.azurecli import AzureCli
+
+
+class Edge:
+    def __init__(self, envvars: EnvVars, output: Output, azure_cli: AzureCli):
+        self.envvars = envvars
+        self.output = output
+        self.azure_cli = azure_cli
+
+    def deploy(self, manifest_file: str):
+
+        self.output.header("DEPLOYING CONFIGURATION")
+
+        self.envvars.verify_envvar_has_val("IOTHUB_CONNECTION_STRING", self.envvars.IOTHUB_CONNECTION_INFO)
+        self.envvars.verify_envvar_has_val("DEVICE_CONNECTION_STRING", self.envvars.DEVICE_CONNECTION_INFO)
+        self.envvars.verify_envvar_has_val("DEPLOYMENT_CONFIG_FILE", self.envvars.DEPLOYMENT_CONFIG_FILE)
+
+        if self.azure_cli.set_modules(config=manifest_file,
+                                      connection_string=self.envvars.IOTHUB_CONNECTION_INFO,
+                                      device_id=self.envvars.DEVICE_CONNECTION_INFO.device_id):
+            self.output.footer("DEPLOYMENT COMPLETE")
+
+    def tag(self, tags):
+        self.output.header("UPDATE DEVICE TAG")
+        if not tags:
+            tags = self.envvars.get_envvar("DEVICE_TAGS", True)
+        self.envvars.verify_envvar_has_val("IOTHUB_CONNECTION_STRING", self.envvars.IOTHUB_CONNECTION_INFO)
+        self.envvars.verify_envvar_has_val("DEVICE_CONNECTION_STRING", self.envvars.DEVICE_CONNECTION_INFO)
+
+        if self.azure_cli.set_device_tag(connection_string=self.envvars.IOTHUB_CONNECTION_INFO, device_id=self.envvars.DEVICE_CONNECTION_INFO.device_id, tags=tags):
+            self.output.footer("TAG UPDATE COMPLETE")

s/iotedgedev/envvars.py

@@ -0,0 +1,240 @@
+import os
+import platform
+from shutil import copyfile
+
+from dotenv import load_dotenv, set_key
+from fstrings import f
+
+from .args import Args
+from .connectionstring import DeviceConnectionString, IoTHubConnectionString
+from .constants import Constants
+from .containerregistry import ContainerRegistry
+from .utility import Utility
+
+
+class EnvVars:
+    def __init__(self, output):
+        self.output = output
+        self.loaded = False
+
+        current_command = Args().get_current_command()
+
+        # for some commands we don't want verbose dotenv load output
+        self.terse_commands = ['', 'iothub setup', 'solution init', 'init', 'solution e2e', 'solution new', 'new', 'simulator stop', 'simulator modulecred']
+        self.verbose = not self.is_terse_command(current_command)
+
+    def backup_dotenv(self):
+        dotenv_path = self.get_dotenv_file_path()
+        dotenv_backup_path = dotenv_path + ".backup"
+        try:
+            copyfile(dotenv_path, dotenv_backup_path)
+            self.output.info(f("Successfully backed up {dotenv_path} to {dotenv_backup_path}"))
+            return True
+        except Exception as e:
+            self.output.error(f("Could not backup {dotenv_path} to {dotenv_backup_path}"))
+            self.output.error(str(e))
+        return False
+
+    def load_dotenv(self):
+        dotenv_file = self.get_dotenv_file()
+        dotenv_path = self.get_dotenv_path(dotenv_file)
+
+        try:
+            if os.path.exists(dotenv_path):
+                load_dotenv(dotenv_path)
+                if self.verbose:
+                    self.output.info("Environment Variables loaded from: {0} ({1})".format(dotenv_file, dotenv_path))
+            else:
+                if self.verbose:
+                    self.output.info("{0} file not found on disk. Without a file on disk, you must specify all Environment Variables at the system level. ({1})".format(dotenv_file, dotenv_path))
+        except Exception as ex:
+            self.output.error("Error while trying to load .env file: {0}. {1}".format(dotenv_path, str(ex)))
+
+    def get_dotenv_file(self):
+        default_dotenv_file = ".env"
+
+        if "DOTENV_FILE" not in os.environ:
+            return default_dotenv_file
+        else:
+            dotenv_file_from_environ = os.environ["DOTENV_FILE"].strip("\"").strip("'")
+            if dotenv_file_from_environ:
+                return dotenv_file_from_environ
+
+        return default_dotenv_file
+
+    def get_dotenv_path(self, dotenv_file):
+        return os.path.join(os.getcwd(), dotenv_file)
+
+    def get_dotenv_file_path(self):
+        return self.get_dotenv_path(self.get_dotenv_file())
+
+    def load(self, force=False):
+        if not self.loaded or force:
+            if self.verbose:
+                self.output.header("ENVIRONMENT VARIABLES")
+
+            self.load_dotenv()
+
+            try:
+                try:
+                    self.IOTHUB_CONNECTION_STRING = self.get_envvar("IOTHUB_CONNECTION_STRING")
+                    self.IOTHUB_CONNECTION_INFO = None
+                    if self.IOTHUB_CONNECTION_STRING:
+                        self.IOTHUB_CONNECTION_INFO = IoTHubConnectionString(self.IOTHUB_CONNECTION_STRING)
+                        if(not self.IOTHUB_CONNECTION_INFO.connection_string):
+                            self.output.error("iotedgedev currently only recognizes SAS connection strings. Will be setting connection string as empty.")
+
+                except Exception as ex:
+                    raise ValueError("Unable to parse IOTHUB_CONNECTION_STRING Environment Variable. Please ensure that you have the right connection string set. {0}".format(str(ex)))
+
+                try:
+                    self.DEVICE_CONNECTION_STRING = self.get_envvar("DEVICE_CONNECTION_STRING")
+                    self.DEVICE_CONNECTION_INFO = None
+                    if self.DEVICE_CONNECTION_STRING:
+                        self.DEVICE_CONNECTION_INFO = DeviceConnectionString(self.DEVICE_CONNECTION_STRING)
+                        if(not self.DEVICE_CONNECTION_INFO.connection_string):
+                            self.output.error("iotedgedev currently only recognizes SAS connection strings. Will be setting connection string as empty.")
+
+                except Exception as ex:
+                    raise ValueError("Unable to parse DEVICE_CONNECTION_STRING Environment Variable. Please ensure that you have the right connection string set. {0}".format(str(ex)))
+
+                self.get_registries()
+
+                self.BYPASS_MODULES = self.get_envvar("BYPASS_MODULES", default="")
+                self.CONTAINER_TAG = self.get_envvar("CONTAINER_TAG", default="")
+                self.EDGE_RUNTIME_VERSION = self.get_envvar("EDGE_RUNTIME_VERSION", default="")
+                self.EDGEAGENT_SCHEMA_VERSION = self.get_envvar("EDGEAGENT_SCHEMA_VERSION", default="")
+                self.EDGEHUB_SCHEMA_VERSION = self.get_envvar("EDGEHUB_SCHEMA_VERSION", default="")
+                self.CONFIG_OUTPUT_DIR = self.get_envvar("CONFIG_OUTPUT_DIR", default=Constants.default_config_folder)
+                self.DEPLOYMENT_CONFIG_TEMPLATE_FILE = self.get_envvar("DEPLOYMENT_CONFIG_TEMPLATE_FILE", default=Constants.default_deployment_template_file)
+                self.DEPLOYMENT_CONFIG_DEBUG_TEMPLATE_FILE = self.get_envvar("DEPLOYMENT_CONFIG_DEBUG_TEMPLATE_FILE", default=Constants.default_deployment_debug_template_file)
+                self.DEFAULT_PLATFORM = self.get_envvar("DEFAULT_PLATFORM", default=Constants.default_platform)
+                self.DEPLOYMENT_CONFIG_FILE = Utility.get_deployment_manifest_name(self.DEPLOYMENT_CONFIG_TEMPLATE_FILE, None, self.DEFAULT_PLATFORM)
+                self.MODULES_PATH = self.get_envvar("MODULES_PATH", default=Constants.default_modules_folder)
+                self.LOGS_PATH = self.get_envvar("LOGS_PATH", default="logs")
+                self.LOGS_CMD = self.get_envvar("LOGS_CMD", default="start /B start cmd.exe @cmd /k docker logs {0} -f")
+                self.SUBSCRIPTION_ID = self.get_envvar("SUBSCRIPTION_ID")
+                self.RESOURCE_GROUP_NAME = self.get_envvar("RESOURCE_GROUP_NAME")
+                self.RESOURCE_GROUP_LOCATION = self.get_envvar("RESOURCE_GROUP_LOCATION")
+                self.IOTHUB_NAME = self.get_envvar("IOTHUB_NAME")
+                self.IOTHUB_SKU = self.get_envvar("IOTHUB_SKU")
+                self.EDGE_DEVICE_ID = self.get_envvar("EDGE_DEVICE_ID")
+                self.CREDENTIALS = self.get_envvar("CREDENTIALS")
+                self.UPDATE_DOTENV = self.get_envvar("UPDATE_DOTENV")
+
+            except Exception as ex:
+                msg = "Environment variables not configured correctly. Run `iotedgedev new` to create a new solution with sample .env file. "
+                "Please see README for variable configuration options. Tip: You might just need to restart your command prompt to refresh your Environment Variables. "
+                "Variable that caused exception: {0}".format(str(ex))
+                raise ValueError(msg)
+
+        self.loaded = True
+
+    def __getattribute__(self, name):
+        try:
+            return object.__getattribute__(self, name)
+        except AttributeError as e:
+            if name in os.environ:
+                return self.get_envvar(name)
+            else:
+                raise e
+
+    def get_envvar(self, key, required=False, default=None, altkeys=None):
+        val = ""
+        if altkeys is None:
+            altkeys = []
+
+        # some envvars have alternate keys for legacy reasons, name changes, etc.  this processes key first and then looks in each altkey until it finds a match.
+        altkeys.insert(0, key)
+        for altkey in altkeys:
+            if altkey in os.environ:
+                val = os.environ[altkey].strip()
+                if val:
+                    break
+
+        if required and not val:
+            raise ValueError("Environment Variable {0} not set. Either add to .env file or to your system's Environment Variables".format(key))
+
+        # if we have a val return it, if not and we have a default then return default, otherwise return None.
+        if val:
+            return val
+        elif default:
+            self.set_envvar(key, default)
+            return default
+        else:
+            return ''
+
+    def verify_envvar_has_val(self, key, value):
+        if not value:
+            raise ValueError("Environment Variable {0} not set. Either add to .env file or to your system's Environment Variables".format(key))
+
+    def get_envvar_key_if_val(self, key):
+        if key in os.environ and os.environ.get(key):
+            return key
+        else:
+            return None
+
+    def set_envvar(self, key, value):
+        os.environ[key] = value
+
+    def save_envvar(self, key, value):
+        try:
+            dotenv_file = self.get_dotenv_file()
+            dotenv_path = os.path.join(os.getcwd(), dotenv_file)
+            set_key(dotenv_path, key, value)
+        except Exception:
+            raise IOError(f("Could not update the environment variable {key} in file {dotenv_path}"))
+
+    def get_registries(self):
+        self.CONTAINER_REGISTRY_MAP = {}
+        subkeys = ['server', 'username', 'password']
+        # loops through os.environ for key matching container_registry_server, container_registry_username, container_registry_password
+        for key in os.environ:
+            for subkey in subkeys:
+                self._set_registry_map(key, subkey)
+
+    def is_posix(self):
+        plat = platform.system().lower()
+        return plat == "linux" or plat == "darwin"
+
+    def is_terse_command(self, command):
+        return self.in_command_list(command, self.terse_commands)
+
+    def in_command_list(self, command, command_list):
+        for cmd in command_list:
+            if cmd == '':
+                if command == '':
+                    return True
+                else:
+                    continue
+
+            if command.startswith(cmd):
+                if len(command) == len(cmd) or command[len(cmd)] == ' ':
+                    return True
+                else:
+                    continue
+        return False
+
+    @property
+    def DEPLOYMENT_CONFIG_FILE_PATH(self):
+        return os.path.join(self.CONFIG_OUTPUT_DIR, self.DEPLOYMENT_CONFIG_FILE)
+
+    def _set_registry_map(self, env_key, subkey):
+        registry_key_prefix = 'CONTAINER_REGISTRY_'
+        default_key_prefix = registry_key_prefix + subkey.upper()
+
+        # The prefix for additional registries has an additional underscore
+        add_key_prefix = default_key_prefix + '_'
+        add_key_prefix_length = len(add_key_prefix)
+
+        if env_key.startswith(default_key_prefix):
+            if env_key == default_key_prefix:
+                token = ''
+            elif env_key.startswith(add_key_prefix):
+                token = env_key[add_key_prefix_length:]
+            else:
+                return
+
+            if token not in self.CONTAINER_REGISTRY_MAP:
+                self.CONTAINER_REGISTRY_MAP[token] = ContainerRegistry('', '', '')
+            setattr(self.CONTAINER_REGISTRY_MAP[token], subkey.lower(), self.get_envvar(env_key))

s/iotedgedev/iothub.py

@@ -0,0 +1,65 @@
+from iotedgedev.envvars import EnvVars
+from iotedgedev.output import Output
+from iotedgedev.azurecli import AzureCli
+from .utility import Utility
+from .version import PY35
+
+
+class IoTHub:
+    def __init__(self, envvars: EnvVars, output: Output, utility: Utility, azure_cli: AzureCli):
+        self.envvars = envvars
+        self.output = output
+        self.utility = utility
+        self.azure_cli = azure_cli
+
+    def deploy(self, manifest_file: str, layered_deployment_name: str, priority: str, target_condition: str):
+
+        self.output.header("DEPLOYING CONFIGURATION")
+
+        self.envvars.verify_envvar_has_val("IOTHUB_CONNECTION_STRING", self.envvars.IOTHUB_CONNECTION_INFO)
+        if not target_condition:
+            target_condition = self.envvars.get_envvar("IOTHUB_DEPLOYMENT_TARGET_CONDITION", True)
+        self.envvars.verify_envvar_has_val("DEPLOYMENT_CONFIG_FILE", self.envvars.DEPLOYMENT_CONFIG_FILE)
+
+        if self.azure_cli.create_deployment(config=manifest_file,
+                                            connection_string=self.envvars.IOTHUB_CONNECTION_INFO,
+                                            deployment_name=layered_deployment_name,
+                                            target_condition=target_condition,
+                                            priority=priority):
+            self.output.footer("DEPLOYMENT COMPLETE")
+
+    def monitor_events(self, timeout=0):
+
+        self.envvars.verify_envvar_has_val("IOTHUB_CONNECTION_STRING", self.envvars.IOTHUB_CONNECTION_STRING)
+        self.envvars.verify_envvar_has_val("DEVICE_CONNECTION_STRING", self.envvars.DEVICE_CONNECTION_STRING)
+
+        if timeout is None:
+            timeout = 0
+
+        self.output.header("MONITOR EVENTS")
+        self.output.status("It may take 1-2 minutes before you start to see messages below.")
+
+        if PY35:
+            self.monitor_events_cli(timeout)
+        else:
+            self.monitor_events_node(timeout)
+
+    def monitor_events_node(self, timeout=0):
+        try:
+
+            cmd = ['iothub-explorer', '--login', self.envvars.IOTHUB_CONNECTION_STRING, 'monitor-events', self.envvars.DEVICE_CONNECTION_INFO.device_id]
+
+            if timeout != 0:
+                cmd.extend(['--duration', timeout])
+
+            self.utility.call_proc(cmd, shell=not self.envvars.is_posix())
+
+        except Exception as ex:
+            self.output.error("Problem while trying to call iothub-explorer. Please ensure that you have installed the iothub-explorer npm package with: npm i -g iothub-explorer.")
+            self.output.error(str(ex))
+
+    def monitor_events_cli(self, timeout=0):
+        self.azure_cli.monitor_events(self.envvars.DEVICE_CONNECTION_INFO.device_id,
+                                      self.envvars.IOTHUB_CONNECTION_INFO.connection_string,
+                                      self.envvars.IOTHUB_CONNECTION_INFO.iothub_host.hub_name,
+                                      timeout)