iotedgedev 3.3.4__zip

s/docs/Manual-Dev-Machine-Setup.md

@@ -0,0 +1,77 @@
+Here is what you need to do to get Azure IoT Edge Dev Tool (aka `iotedgedev`) running on your dev machine manually instead of using the IoT Edge Dev Container.
+
+If you are using a separate Edge device, like a Raspberry Pi, you do not need to run all of these steps on your IoT Edge device, you can install and setup Edge runtime directly on the device. See the [Edge Device Setup](edge-device-setup) wiki page for more information on setting up your Edge device.
+
+> Note: See the ["Test Coverage"](test-coverage) wiki page to see what the IoT Edge Dev Tool has been tested with.
+
+1. Install **[Docker](https://docs.docker.com/engine/installation/)**
+    - Windows    
+        - Be sure to check whether you are running in Linux container mode or Windows container mode.
+    - Linux
+        - We've seen some issues with docker.io. If Edge doesn't run for you, then try installing Docker CE directly instead of via docker.io. Use the [CE install steps](https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/#install-docker-ce), or use the [convenience script](https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/#install-using-the-convenience-script).
+        - By default, you need `sudo` to run `docker` commands. If you want to avoid this, please follow the [post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user).
+        
+1. Install **Python 2.7+ or Python 3.6+** and **pip** (Python 3.6 is recommended)
+    - Windows: [Install from Python's website](https://www.python.org/downloads/)
+    - Linux: `sudo apt install python-pip` or `sudo apt install python3-pip`
+    - macOS: The OpenSSL used by the system built-in Python is old and vulnerable. Please use Python installed with [Homebrew](https://docs.brew.sh/Homebrew-and-Python)
+    
+1. Install **[Azure CLI 2.0](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest)**
+
+1. Install **[Azure CLI IoT extension](https://github.com/Azure/azure-iot-cli-extension/)**
+
+    - New Install: `az extension add --name azure-iot`
+    - Update Install: `az extension update --name azure-iot`
+
+1. (Python < 3.5 only) Install **[Node.js](https://nodejs.org/en/download/)** and the **`iothub-explorer`** package
+
+    - uamqp, which is needed by Azure CLI IoT extension for monitoring messages, is not supported in Python < 3.5. For Python < 3.5 users, please install [Node.js](https://nodejs.org/en/download/) and the `iothub-explorer` Node.js package: `npm i -g iothub-explorer`
+
+1. (Raspberry Pi only) Install extra system dependencies
+
+    ```
+    sudo apt-get install python2.7-dev libffi-dev libssl-dev -y
+    ```
+
+1. (Linux only) Install [Docker Compose](https://docs.docker.com/compose/)
+
+    ```
+    pip install -U docker-compose
+    ```
+
+1. Install **`iotedgedev`**
+
+    > You do not need to run this on the Edge device. See the [Edge Device Setup](edge-device-setup) page for more information on setting up your Edge device.
+
+    > You can also run under a Python Virtual Environment.  See the [Python Virtual Environment Setup](python-virtual-environment-setup) instructions page for details on how to set that up.
+
+    > There is a known dependency conflict between `iotedgedev` and now-deprecated `azure-iot-edge-runtime-ctl`. Please make sure you have uninstalled `azure-iot-edge-runtime-ctl` before installing `iotedgedev`: `pip uninstall azure-iot-edge-runtime-ctl `, or use a clean virtual environment.
+
+    ```
+    pip install -U iotedgedev
+    ```
+
+1. Install module dependencies
+    ##### C# module and C# Azure Functions module
+    Install **[.NET Core SDK](https://www.microsoft.com/net/download)**.
+    > You need .NET Core SDK 2.1 or later to run it on ARM. There is no official document on installing .NET Core SDK on ARM yet, but you can follow the [ARM32v7 Dockerfile](https://github.com/dotnet/dotnet-docker/blob/master/src/sdk/3.1/buster/arm32v7/Dockerfile).
+    
+    ##### Python module
+    1. Install **[Git](https://git-scm.com/)**
+    2. Install **[Cookiecutter](https://github.com/audreyr/cookiecutter)**
+    ```
+    pip install -U cookiecutter
+    ```
+
+    ##### Node.js module
+    1. Install **[Node.js](https://nodejs.org/en/download/)**
+    2. Install **[Yeoman](http://yeoman.io/)** and **[Azure IoT Edge Node.js module generator](https://github.com/Azure/generator-azure-iot-edge-module)** packages
+    ```
+    npm i -g yo generator-azure-iot-edge-module
+    ```
+
+    ##### Java module
+    1. Install **[JDK](https://www.oracle.com/technetwork/java/javase/downloads/index.html)**
+    1. Install **[Maven](https://maven.apache.org/)**
+
+1. Follow the [Usage Wiki](usage) to learn the usage of IoT Edge Dev Tool

s/docs/Migration-Guides.md

@@ -0,0 +1,131 @@
+IoT Edge Dev Tool 0.82.0 provides support for the GA release of Azure IoT Edge and other new features, while on the other hand, introduces some breaking changes to better serve these new features. If you have used IoT Edge Dev Tool during the Azure IoT Edge public preview, this document will help you migrate your code and workflow to IoT Edge Dev Tool 0.82.0.
+
+### Retirement of `iotedgectl`
+With the GA release of Azure IoT Edge, iotedgectl (a.k.a, [azure-iot-edge-runtime-ctl](https://pypi.org/project/azure-iot-edge-runtime-ctl/)) is retired. In IoT Edge Dev Tool 0.82.0, we replace `iotedgectl` with the IoT Edge Simulator provided by the [iotedgehubdev CLI](https://pypi.org/project/iotedgehubdev/). The `setup`, `start`, and `stop` commands will now control IoT Edge Simulator instead.
+
+### Updated command list and options
+IoT Edge Dev Tool 0.82.0 comes with a new CLI UX. All commands are organized into four categories: `docker`, `iothub`, `simulator`, and `solution`. The general style is **iotedgedev _category_ _command_ --_parameter_**. For some frequently used commands, there is also an **iotedgedev _command_ --_parameter_** style shortcut (only if the shortcut won't cause confusion, similar to the relationship between `docker logs` and `docker container logs`). The shortcuts also add backward compatibility with some public preview style commands.
+
+Here is what you would see when you type `iotedgedev --help` (shortcuts are intentionally listed before the categories):
+
+```
+$ iotedgedev --help
+Usage: iotedgedev [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  --version   Show the version and exit.
+  -h, --help  Show this message and exit.
+
+Commands:
+  add        Add a new module to the solution
+  build      Build the solution
+  deploy     Deploy solution to IoT Edge device
+  genconfig  Expand environment variables and placeholders in *.template.json
+             and copy to config folder
+  init       Create a new IoT Edge solution and provision Azure resources
+  log        Open a new terminal window for EdgeAgent, EdgeHub and each Edge
+             module and save to LOGS_PATH
+  monitor    Monitor messages from IoT Edge device to IoT Hub
+  new        Create a new IoT Edge solution
+  push       Push module images to container registry
+  setup      Setup IoT Edge simulator. This must be done before starting
+  start      Start IoT Edge simulator
+  stop       Stop IoT Edge simulator
+  docker     Manage Docker
+  iothub     Manage IoT Hub and IoT Edge devices
+  simulator  Manage IoT Edge simulator
+  solution   Manage IoT Edge solutions
+```
+
+Here is the help message for a category:
+
+```
+$ iotedgedev solution --help
+Usage: iotedgedev solution [OPTIONS] COMMAND [ARGS]...
+
+  Manage IoT Edge solutions
+
+Options:
+  -h, --help  Show this message and exit.
+
+Commands:
+  add        Add a new module to the solution
+  build      Build the solution
+  deploy     Deploy solution to IoT Edge device
+  e2e        Push, deploy, start, monitor
+  genconfig  Expand environment variables and placeholders in *.template.json
+             and copy to config folder
+  init       Create a new IoT Edge solution and provision Azure resources
+  new        Create a new IoT Edge solution
+  push       Push module images to container registry
+```
+
+Here is the help message for a specific command. Only the parameters relevant to the command are listed. In addition, parameter shortcuts are also added, like `-t` below for `--template`, whenever possible.
+
+```
+$ iotedgedev solution add --help
+Usage: iotedgedev add [OPTIONS] NAME
+
+  Add a new module to the solution, where NAME is the module name
+
+Options:
+  -t, --template [c|csharp|java|nodejs|python|csharpfunction]
+                                  Specify the template used to create the
+                                  default module  [default: csharp]
+  -g, --group-id TEXT             (Java modules only) Specify the groupId
+                                  [default: com.edgemodule]
+  -h, --help                      Show this message and exit.
+```
+
+Below is a full table of the public preview commands, new commands, and shortcuts (if applicable):
+
+Public Preview Command | New Command | Shortcut
+-- | -- | --
+`--set-config` | `solution genconfig` | `genconfig `
+`solution --create --module --template` | `solution new --module/-t --template/-t` | `new`
+`init` | `solution init` | `init`
+`e2e` | `solution e2e` |
+`addmodule --template` | `solution add --template/-t` | `add --template/-t`
+`build --push --deploy` | `solution build --push/-p --deploy/-d` | `build --push/-p --deploy/-d`
+`push --deploy --no-build` | `solution push --deploy/-d --no-build` | `push --deploy/-d --no-build`
+`deploy` | `solution deploy` | `deploy`
+`monitor --timeout` | `iothub monitor --timeout/-t` | `monitor --timeout/-t`
+`azure --setup --credentials --service-principal --subscription --resource-group-location --resource-group-name --iothub-sku --iothub-name --edge-device-id --update-dotenv` | `iothub setup --credentials --service-principal --subscription --resource-group-location --resource-group-name --iothub-sku --iothub-name --edge-device-id --update-dotenv/-u` |  
+`modules --add --template` | `solution add --template` | `add --template/-t`
+`modules --build --push --deploy` | `solution build --push/-p --deploy/-d` | `build --push/-p --deploy/-d`
+`modules --push --deploy` | `solution push --deploy/-d --no-build` | `push --deploy/-d --no-build`
+`modules --deploy` | `solution deploy` | `deploy`
+`runtime --setup` | *deprecated, see [Retirement of `iotedgectl`](#retirement-of-iotedgectl) section* |  
+`runtime --start` | *deprecated, see [Retirement of `iotedgectl`](#retirement-of-iotedgectl) section* |  
+`runtime --stop` | *deprecated, see [Retirement of `iotedgectl`](#retirement-of-iotedgectl) section* |  
+`runtime --restart` | *deprecated, see [Retirement of `iotedgectl`](#retirement-of-iotedgectl) section* |  
+`runtime --status` | *deprecated, see [Retirement of `iotedgectl`](#retirement-of-iotedgectl) section* |  
+`docker --setup-registry` | `docker setup` |  
+`docker --clean --remove-modules --remove-containers --remove-images` | `docker clean --modules/-m --containers/-c --image/-i` |  
+`docker --logs --show-logs --save-logs` | `docker log --show/-l --save/-s` | `docker log --show/-l --save/-s`
+
+### Deployment manifest template
+IoT Edge Dev Tool 0.82.0 relies on the deployment manifest template to build the solution (see [Deprecation of `ACTIVE_MODULES`](#deprecation-of-active_modules) section for details). By default, it's the `deployment.template.json` file in the root of the solution folder, but you can also customize it with the `DEPLOYMENT_CONFIG_TEMPLATE_FILE` environment variable. The major difference between deployment manifest template and deployment manifest is that module image URLs in deployment manifest template can be placeholders (whose format looks like `${MODULES.filtermodule.amd64}`). The image placeholders can help you easily update the referenced module and image platform without typing lengthy image URLs. When building solutions, IoT Edge Dev Tool will parse the image placeholders, expand them with the actual image URLs and save the results in the deployment manifest in the config output folder. By default, it's the `deployment.json` file in the `config` folder, but you can also customize it with the `DEPLOYMENT_CONFIG_FILE` and `CONFIG_OUTPUT_DIR` environment variables. In addition, when adding modules, IoT Edge Dev Tool will add a corresponding section for the module in the deployment manifest template with `${MODULES.<module-name>.amd64}` as the image.
+
+To migrate your solutions created in the public preview to leverage the new build process, you can rename your deployment manifest, and update the images of the modules which you want to build with the corresponding image placeholders.
+
+### New module folder structure
+IoT Edge Dev Tool now calls module templates when adding new modules to the solution. For C# module developers, you don't need to execute `dotnet new` commands yourself. You only need to execute `iotedgedev add` command, specify the module name and template (for example, `csharp` or `csharpfunction`). IoT Edge Dev Tool will scaffold a new module from the template, save the module files in the `${MODULES_PATH}/<module-name>` folder (`modules/<module-name>` by default), and update the deployment manifest template for you. In each module folder, there are now four types of files:
+* Module code files, for example, `Program.cs` and `*.csproj`
+* Dockerfiles for each platform, for example, `Dockerfile.amd64`, `Dockerfile.amd64.debug` and `Dockerfile.arm32v7`
+* `module.json` file which specifies the meta-data of the module, including image repository, mapping between platforms and Dockerfiles, and build options.
+* Miscellaneous files, for example, `.gitignore`.
+
+To migrate your modules created in the public preview to work with IoT Edge Dev Tool 0.82.0, you need to create a module.json file from [here](https://github.com/Azure/dotnet-template-azure-iot-edge-module/blob/master/content/dotnet-template-azure-iot-edge-module/CSharp/module.json), update the `repository` as the module image repository such as `myregistry.azurecr.io/filtermodule`, or with environment variable placeholders `${CONTAINER_REGISTRY_SERVER}/filtermodule`. Next you need to update the `platforms` dictionary to make sure that platform-Dockerfile mapping is correct. The built module image will have the tag format `<repository>:<version>-<platform>`, for example `myregistry.azurecr.io/filtermodule:0.0.1-amd64`.
+
+### Building code in Dockerfiles
+The recent releases of IoT Edge module templates ship with Dockerfiles which will build the code binaries in the containers. For example, C# module developers now don't need to run `dotnet build` or `dotnet publish` on their development machine. A single `docker build` command will build the binaries in the container and copy them to the final module image. You can check the C# module template Dockerfile [here](https://github.com/Azure/dotnet-template-azure-iot-edge-module/blob/master/content/dotnet-template-azure-iot-edge-module/CSharp/Dockerfile.amd64), which leverages Docker's [multi-stage build feature](https://docs.docker.com/develop/develop-images/multistage-build/). On the other hand, IoT Edge Dev Tool is continuously adding support for modules in more languages such as Node.js and Python, with diverse steps to build. As a result, the `iotedgedev build` command will only build the Dockerfiles, but not run language-specific building commands.
+
+### Deprecation of `ACTIVE_MODULES`
+With the full support of deployment manifest template for module management, IoT Edge Dev Tool 0.82.0 now comes with new logic of determining which Dockerfiles to build. The `ACTIVE_MODULES` environment variable will be replaced by the image placeholders (whose format looks like `${MODULES.filtermodule.amd64}`) in deployment manifest template, and the `BYPASS_MODULES` and `ACTIVE_DOCKER_PLATFORMS` environment variables jointly. IoT Edge Dev Tool will built a Dockerfile if it meets either of the following two requirements:
+1. The module name is not in `BYPASS_MODULES`, and a module specifies `${MODULES.<module-name>.<platform>}` as its image in the deployment manifest template.
+1. The module name is not in `BYPASS_MODULES`, and the platform is in `ACTIVE_DOCKER_PLATFORMS`.
+
+The default value of `BYPASS_MODULES` and `ACTIVE_DOCKER_PLATFORM` are both `""`, which means you only need to update the deployment manifest template to specify which Dockerfiles to build. Although this will serve most requirements, you are free to update `BYPASS_MODULES` and `ACTIVE_DOCKER_PLATFORM` for your specific scenarios.
+
+### Misc

s/docs/Overview.md

@@ -0,0 +1,66 @@
+The **Azure IoT Edge Dev Tool** enables you to do all of the following with simple one-line CLI commands.
+
+1. **Start Container**:
+
+    `docker run -it -v /var/run/docker.sock:/var/run/docker.sock -v c:/temp/iotedge:/home/iotedge microsoft/iotedgedev`
+
+    This container includes all of the dependencies you need for IoT Edge development, including:
+
+    - Docker
+    - Python
+    - Pip
+    - Azure CLI
+    - Git
+    - .NET Core SDK
+    - OpenJDK
+    - Node.js
+    - [C# module template](https://www.nuget.org/packages/Microsoft.Azure.IoT.Edge.Module/)
+    - Maven (for scaffolding [Java modules](https://github.com/Microsoft/azure-maven-archetypes/tree/master/azure-iot-edge-archetype))
+    - [Yeoman](http://yeoman.io/) and [Node.js module template](https://www.npmjs.com/package/generator-azure-iot-edge-module)
+    - [Cookiecutter](https://cookiecutter.readthedocs.io/en/latest/) (for scaffolding [Python modules](https://github.com/Azure/cookiecutter-azure-iot-edge-module))
+    - [C# Functions module template](https://www.nuget.org/packages/Microsoft.Azure.IoT.Edge.Function/)
+
+    You can also directly install with: `pip install iotedgedev`
+    
+1. **Create Solution**: Create a new IoT Edge Solution that includes a sample module and all the the required configuration files.
+
+    ```
+    iotedgedev new edgesolution`
+    cd edgesolution
+    ```
+
+1. **Setup Azure**: Creates or selects your Azure IoT Hub and Edge Device and updates your Environment Variables.
+
+    `iotedgedev iothub setup`
+
+    > This must be run from the root of your solution, so make sure you cd into the `edgesolution1` folder before you run this command.
+
+1. **Build, Push & Deploy**: Build, Push and Deploy modules:
+
+    `iotedgedev push --deploy`
+    
+    > This will run `iotedgedev build`, `iotedgedev push`, and `iotedgedev deploy` on deployment.template.json targeting amd64 platform. You can use the `--file` and `--platform` parameters to change this behavior.
+
+    If your module is included in the `BYPASS_MODULES` environment variable, or not included in the deployment manifest template, then the `iotedgedev build` and `iotedgedev push` steps will be skipped.
+    
+1. **Setup**: Setup the IoT Edge Simulator (provided by the [iotedgehubdev](https://pypi.org/project/iotedgehubdev/) tool):
+
+    `iotedgedev setup`
+
+1. **Start**: Start IoT Edge Simulator:
+
+    `iotedgedev start -f config/deployment.amd64.json`
+
+1. **View Messages**: View Messages Sent from IoT Edge to IoT Hub:
+
+    `iotedgedev monitor`
+
+1. **View Logs**: View and Save Docker log files:
+
+    `iotedgedev docker log`
+
+1. **Setup Custom Registry**: Use a Custom Container Registry:
+
+    `iotedgedev docker setup-registry`
+
+Please see [Azure IoT Edge Dev Resources](https://github.com/Azure/iotedgedev) for links to official docs and other IoT Edge dev information.

s/docs/Python-Virtual-Environment-Setup.md

@@ -0,0 +1,35 @@
+You can run IoT Edge Dev Tool inside a [Python Virtual Environment](https://docs.python.org/3/tutorial/venv.html). A Python virtual environment is a self-contained directory tree that contains a Python installation for a particular version of Python, plus a number of additional packages.
+
+1. Install `virtualenv`
+
+    `pip install virtualenv`
+
+1. Create a virtual environment
+
+    `virtualenv venv`
+
+    > `venv` is just a env name that can be anything you want, but we recommend sticking with `venv` if you want to contribute to IoT Edge Dev Tool because the `.gitignore` file excludes it.
+
+    > To create a virtual environment with a Python version different with your system default, just use the `--python/-p` option to specify the Python executable path, *e.g.*:
+    > ```
+    > virtualenv --python /usr/bin/python2.7 py27
+    > ```
+
+1. Activate the virtual environment
+
+    - Windows
+        - cmd.exe: `venv\Scripts\activate.bat`
+        - PowerShell: `venv\Scripts\activate.ps1` (You may need to run `Set-ExecutionPolicy RemoteSigned` in an Administrator Powershell first to allow scripts to run)
+
+    - Posix: `source venv/bin/activate`
+    > It will be active until you deactivate it or close the terminal instance.
+
+1. Install dependencies
+
+    Continue with the instructions above starting with the [Manual Dev Machine Setup](manual-dev-machine-setup) -> Install Dependencies.
+
+1. Deactivate the virtual environment
+
+    When you are done with your virtualenv, you can deactivate it with the follow command:
+
+    `deactivate`

s/docs/Quickstart-with-IoT-Edge-Dev-Container.md

@@ -0,0 +1,145 @@
+Here is the absolute fastest way to get IoT Edge Dev Tool (aka `iotedgedev`) running on your dev machine with the IoT Edge Dev Container.
+
+You can use the IoT Edge Dev Tool container to avoid having to install all the dependencies on your local dev machine. The only thing you need to install is Docker. All of the other dev dependencies are included in the container. 
+
+1. **Install [Docker CE](https://docs.docker.com/install/)**
+
+    - For Windows, please follow [the document](https://docs.docker.com/docker-for-windows/#shared-drives) to open Docker Settings and setup a Shared Drive.
+    - For macOS, please follow [the document](https://docs.docker.com/docker-for-mac/#file-sharing) to choose local directories to share with your containers.
+
+
+1. **Run the IoT Edge Dev Container**
+
+    Before you run the container, you will need to create a local folder to store your IoT Edge solution files.
+    
+    **Windows**
+    ```
+    mkdir c:\temp\iotedge
+    docker run -ti -v /var/run/docker.sock:/var/run/docker.sock -v c:/temp/iotedge:/home/iotedge microsoft/iotedgedev
+    ```
+
+    **Linux**
+    ```
+    sudo mkdir /home/iotedge
+    sudo docker run -ti -v /var/run/docker.sock:/var/run/docker.sock -v ~/iotedge:/home/iotedge microsoft/iotedgedev
+    ```
+
+    **macOS**
+    ```
+    mkdir ~/iotedge
+    docker run -ti -v /var/run/docker.sock:/var/run/docker.sock -v ~/iotedge:/home/iotedge microsoft/iotedgedev
+    ```
+
+1. **Initialize IoT Edge solution and setup Azure resources**
+
+    `iotedgedev init`
+
+    > `iotedgedev init` will create a solution and setup your Azure IoT Hub in a single command. The solution comes with a default C# module named `filtermodule`.
+
+    <details>
+    <summary>More information</summary>
+
+    1. You will see structure of current folder like below:
+
+    ```
+        │  .env
+        │  .gitignore
+        │  deployment.debug.template.json
+        │  deployment.template.json
+        │
+        ├─.vscode
+        │      launch.json
+        │
+        └─modules
+            └─filtermodule
+                │  .gitignore
+                │  Dockerfile.amd64
+                │  Dockerfile.amd64.debug
+                │  Dockerfile.arm32v7
+                │  Dockerfile.windows-amd64
+                │  filtermodule.csproj
+                │  module.json
+                │  Program.cs
+    ```
+
+    2. Open `.env` file, you will see the `IOTHUB_CONNECTION_STRING` and `DEVICE_CONNECTION_STRING` environment variables filled correctly.
+    3. Open `deployment.template.json` file   
+        1. You will see below section in the modules section:
+
+        ```
+        "filtermodule": {
+            "version": "1.0",
+            "type": "docker",
+            "status": "running",
+            "restartPolicy": "always",
+            "settings": {
+                "image": "${MODULES.filtermodule}",
+                "createOptions": ""
+            }
+        }
+        ```
+
+        2. Two default routes are added:
+        
+        ```
+        "routes": {
+            "sensorTofiltermodule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/filtermodule/inputs/input1\")",
+            "filtermoduleToIoTHub": "FROM /messages/modules/filtermodule/outputs/* INTO $upstream"
+        }
+        ```
+
+    4. You will see privacy statement like below:
+
+        ```
+        Welcome to iotedgedev!
+        -------------------------
+        Telemetry
+        ---------
+        The iotedgedev collects usage data in order to improve your experience.
+        The data is anonymous and does not include commandline argument values.
+        The data is collected by Microsoft.
+        
+        You can change your telemetry settings by updating 'collect_telemetry' to 'no' in ~/.iotedgedev/setting.ini
+        ```
+
+    </details>
+
+1. **Build IoT Edge module images**
+
+    `sudo iotedgedev build`
+
+    > This step will build user modules in deployment.template.json targeting amd64 platform. You can use the `--file` and `--platform` parameters to change this behavior.
+
+    <details>
+    <summary>More information</summary>
+
+    1. You will see a "BUILD COMPLETE" for each module and no error messages in the terminal output.
+	2. Open `config/deployment.amd64.json` file, you will see the module image placeholders expanded correctly.
+    3. Run `sudo docker image ls`, you will see the module images you just built.
+
+    </details>
+
+1. **Setup and start the IoT Edge Simulator to run the solution**
+
+    `sudo iotedgedev start --setup --file config/deployment.amd64.json`
+
+    > IoT Edge Simulator does not support running Python and C modules yet. You'll need IoT Edge Runtime to run your Python and C modules.
+
+    <details>
+    <summary>More information</summary>
+
+    1. You will see an "IoT Edge Simulator has been started in solution mode." message at the end of the terminal output
+    2. Run `sudo docker ps`, you will see your modules running as well as an edgeHubDev container
+
+    </details>
+
+1. **Monitor messages sent from IoT Edge Simulator to IoT Hub**
+
+    `iotedgedev monitor`
+
+    <details>
+    <summary>More information</summary>
+
+    1. You will see your expected messages sending to IoT Hub
+
+    </details>

s/docs/Test-Coverage.md

@@ -0,0 +1,7 @@
+This module has been tested with the following:
+- Windows 10 April 2018 Update
+- Ubuntu 16.04
+- macOS High Sierra 10.13.6
+- Raspberry Pi with Raspbian Stretch
+- Python 2.7.13, Python 3.6.5 and Python 3.7.0
+- Docker Version 18.06.1-ce-win73 (19507), Channel: stable, b0f14f1

s/docs/Troubleshooting.md

@@ -0,0 +1,21 @@
+1. `Invalid Reference Format`
+    ```
+    500 Server Error: Internal Server Error for url: http+docker://localunixsocket/v1.30/images
+    500 Server Error: Internal Server Error ("invalid reference format")
+    ```
+
+    Solution: You likely installed Docker via `sudo apt install docker.io`. Use the proper steps for [CE here](https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/#install-docker-ce), or use the [convenience script](https://docs.docker.com/engine/installation/linux/docker-ce/ubuntu/#install-using-the-convenience-script).
+
+1. `('Connection aborted.', error(2, 'No such file or directory'))`
+
+    This means that you have likely do not have `DOCKER_HOST` Environment Variable set.
+
+    ```
+    ERROR: Could not login to Container Registry. Please verify your credentials in CONTAINER_REGISTRY_ environment variables.
+    ```
+
+    ```
+    ('Connection aborted.', error(2, 'No such file or directory'))
+    ERROR: Could not connect to docker daemon.
+    ERROR: Docker is unavailable
+    CRITICAL: IoT Edge dependency not available: docker

s/docs/Usage.md

@@ -0,0 +1,123 @@
+# Usage
+
+You can use the IoT Edge Dev Tool container to avoid having to install all the dependencies on your local dev machine. The only thing you need to install is Docker. All of the other dev dependencies are included in the container. Please see the [Quickstart](quickstart-with-IoT-Edge-Dev-Container) to learn more.
+
+To set up development machines manually instead of using the IoT Edge Dev Container, please see the [Manual Development Machine Setup Wiki](manual-Dev-Machine-Setup).
+
+If you are using a separate Edge device, like a Raspberry Pi, you do not need to run all of these steps on your IoT Edge device, you can install and setup Edge runtime directly on the device. See the [Edge Device Setup](edge-device-setup) wiki page for more information on setting up your Edge device.
+
+Note: See the ["Test Coverage"](test-coverage) wiki page to see what the IoT Edge Dev Tool has been tested with.
+
+1. **Initialize IoT Edge solution and setup Azure resources**
+
+    ```sh
+    iotedgedev init
+    ```
+
+    `iotedgedev init` will run both `iotedgedev new .` and `iotedgedev iothub setup`, which will create a new solution and setup your Azure resources in a single command.
+
+    If you want to use your existing IoT Hub and IoT Edge device, you can run `iotedgedev new .`, and update the `.env` file with the IoT Hub connection string and IoT Edge device connection string.
+
+    `iotedgedev init` and `iotedgedev new .` will add a default C# module named `filtermodule` to the solution. To customize this behavior, append the parameters `--module <module-name--template <template>`.
+
+1. **Add modules to IoT Edge solution**
+
+    ```sh
+    iotedgedev add <module-name--template <template>
+    ```
+
+    Currently the available template values are `c`, `csharp`, `java`, `nodejs`, `python`, `csharpfunction`. We are working on supporting more templates.
+
+1. **Build IoT Edge module images**
+
+    ```sh
+    sudo iotedgedev build
+    ```
+
+    You can avoid `sudo` if you are running IoT Edge Dev Tool outside Docker container, and:
+    * You are on Windows or macOS.
+    * You are on Linux, and you have followed the [post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow running Docker commands without `sudo`.
+
+1. **Setup the [IoT Edge Simulator]((https://pypi.org/project/iotedgehubdev/).)**
+
+    ```sh
+    sudo iotedgedev setup
+    ```
+
+    IoT Edge Simulator does not support running Python and C modules yet. You'll need IoT Edge Runtime to run your Python and C modules.
+
+    You can avoid `sudo` if you are on Windows, and running IoT Edge Dev Tool outside Docker container.
+
+1. **Start the IoT Edge Simulator to run the solution**
+
+    ```sh
+    sudo iotedgedev start
+    ```
+
+    You can also combine setup and start with `sudo iotedgedev start --setup`
+
+    You can avoid `sudo` if you are running IoT Edge Dev Tool outside Docker container, and:
+    * You are on Windows or macOS.
+    * You are on Linux, and you have followed the [post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow running Docker commands without `sudo`.
+
+1. **Monitor messages sent from IoT Edge Simulator to IoT Hub**
+
+    ```sh
+    iotedgedev monitor
+    ```
+
+1. **Stop the IoT Edge Simulator**
+
+    ```sh
+    sudo iotedgedev stop
+    ```
+
+    You can avoid `sudo` if you are running IoT Edge Dev Tool outside Docker container, and:
+    * You are on Windows or macOS.
+    * You are on Linux, and you have followed the [post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow running Docker commands without `sudo`.
+
+1. **Setup the IoT Edge Runtime**
+
+    1. Copy the device connection string from the `DEVICE_CONNECTION_STRING` environment variable in the `.env` file, [Azure Portal](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-register-device-portal#retrieve-the-connection-string), or [Azure CLI](https://docs.microsoft.com/en-us/azure/iot-edge/how-to-register-device-cli#retrieve-the-connection-string).
+    1. Follow [Edge Device Setup](edge-device-setup) to setup and start the IoT Edge Runtime with the copied device connection string
+
+1. **Push IoT Edge module images**
+
+    ```sh
+    sudo iotedgedev push
+    ```
+
+    You can avoid `sudo` if you are running IoT Edge Dev Tool outside Docker container, and:
+    * You are on Windows or macOS.
+    * You are on Linux, and you have followed the [post-installation steps for Linux](https://docs.docker.com/install/linux/linux-postinstall/#manage-docker-as-a-non-root-user) to allow running Docker commands without `sudo`.
+
+1. **Deploy modules to IoT Edge device**
+
+    ```sh
+    iotedgedev deploy
+    ```
+
+    You can also combine push and deploy with `iotedgedev push --deploy`
+
+1. **Deploy modules with automatic deployments to IoT Hub**
+
+    ```sh
+    iotedgedev iothub deploy --name TEXT --priority TEXT --target-condition TEXT
+    ```
+    
+    You can also combine tagging the device and deploy with the `--device-tag TEXT` flag
+
+    > More information on how automatic deployments work can be found here: <https://docs.microsoft.com/en-us/azure/iot-edge/module-deployment-monitoring?view=iotedge-2020-11>
+
+1. **Tag IoT Edge Device**
+
+    ```sh
+    iotedgedev solution tag --tags TEXT
+    ```
+
+
+1. **Monitor messages sent from IoT Edge Runtime to IoT Hub**
+
+    ```sh
+    iotedgedev monitor
+    ```

s/docs/_Sidebar.md

@@ -0,0 +1,13 @@
+* [Home](home)
+* Dev Machine Setup
+    * [Quickstart with IoT Edge Dev Container](quickstart-with-iot-edge-dev-container)
+    * [Manual Setup](manual-dev-machine-setup)
+* [Azure Setup](azure-setup)
+* [Edge Device Setup](edge-device-setup)
+* [Command List](command-list)
+* [Python Virtual Environment Setup](python-virtual-environment-setup)
+* [Test Coverage](test-coverage)
+* [Troubleshooting](troubleshooting)
+* [Contributing](https://github.com/Azure/iotedgedev/blob/main/CONTRIBUTING.md)
+* Misc
+    * [Migration Guides for Public Preview Users](migration-guides)

s/iotedgedev/__init__.py

@@ -0,0 +1,6 @@
+"""Top-level package for Azure IoT Edge Dev Tool."""
+
+__author__ = 'Microsoft Corporation'
+__email__ = 'opencode@microsoft.com'
+__version__ = '3.3.4'
+__AIkey__ = 'fed7fc65-5b4a-4e66-9d46-c5f016d4e2b4'

s/iotedgedev/args.py

@@ -0,0 +1,18 @@
+import sys
+
+# We had to implement this custom arg parsing class because Click doesn't have a handler to detect command before any arguments are parsed,
+# which we need for the dotenv load command.  We don't want to load dotenv for some commands and we terse output for other commands.
+
+
+class Args():
+    def get_current_command(self):
+        if sys.argv and len(sys.argv) > 1 and not self.is_info_command():
+            return ' '.join(sys.argv[1:]).strip()
+        else:
+            return ''
+
+    def is_info_command(self):
+        for arg in sys.argv:
+            if arg.startswith('--version') or arg.startswith('-h') or arg.startswith('--help'):
+                return True
+        return False