Tunneling improvements

src/index.json

@@ -325,9 +325,9 @@
         ],
         "webapp": [
             {
-                "filename": "webapp-0.2.4-py2.py3-none-any.whl",
-                "sha256Digest": "0a00e039ff91b28e4286d45fb7bf2f0eb4fdd0a40d250798d488b32ada76a4a1",
-                "downloadUrl": "https://github.com/panchagnula/azure-cli-extensions/raw/sisirap-extensions-whl/dist/webapp-0.2.4-py2.py3-none-any.whl",
+                "filename": "webapp-0.2.5-py2.py3-none-any.whl",
+                "sha256Digest": "1def923fa2ad729191824382bc96c98b35686c38e4746699a8dc89bd78394fa3",
+                "downloadUrl": "https://github.com/panchagnula/azure-cli-extensions/raw/sisirap-extensions-whl/dist/webapp-0.2.5-py2.py3-none-any.whl",
                 "metadata": {
                     "azext.isPreview": true,
                     "azext.minCliCoreVersion": "2.0.24",
@@ -366,7 +366,7 @@
                     "metadata_version": "2.0",
                     "name": "webapp",
                     "summary": "An Azure CLI Extension to manage appservice resources",
-                    "version": "0.2.4"
+                    "version": "0.2.5"
                 }
             }
         ],

src/webapp/azext_webapp/__init__.py

@@ -35,7 +35,7 @@ def load_arguments(self, _):
                        help="shows summary of the create and deploy operation instead of executing it",
                        default=False, action='store_true')
         with self.argument_context('webapp remote-connection create') as c:
-            c.argument('port', options_list=['--port', '-p'], help='Port for the remote connection', type=int)
+            c.argument('port', options_list=['--port', '-p'], help='Port for the remote connection. Default: Random available port', type=int)
             c.argument('name', options_list=['--name', '-n'], help='Name of the webapp to connect to')
         with self.argument_context('webapp config snapshot list') as c:
             c.argument('resource_group', options_list=['--resource-group', '-g'], help='Name of resource group.')

src/webapp/azext_webapp/custom.py

@@ -38,6 +38,8 @@
 
 from ._constants import (NODE_RUNTIME_NAME, OS_DEFAULT, JAVA_RUNTIME_NAME, STATIC_RUNTIME_NAME)
 
+import time
+
 logger = get_logger(__name__)
 
 # pylint:disable=no-member,too-many-lines,too-many-locals,too-many-statements
@@ -162,14 +164,7 @@ def create_deploy_webapp(cmd, name, location=None, dryrun=False):
             # work around until the timeout limits issue for linux is investigated & fixed
             # wakeup kudu, by making an SCM call
 
-        import requests
-        # work around until the timeout limits issue for linux is investigated & fixed
-        user_name, password = _get_site_credential(cmd.cli_ctx, rg_name, name)
-        scm_url = _get_scm_url(cmd, rg_name, name)
-
-        import urllib3
-        authorization = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(user_name, password))
-        requests.get(scm_url + '/api/settings', headers=authorization)
+        _ping_scm_site(cmd, rg_name, name)
 
         if is_java:
             zip_file_path = src_path + '\\\\' + lang_details.get('file_loc')[0]
@@ -194,6 +189,17 @@ def create_deploy_webapp(cmd, name, location=None, dryrun=False):
     return create_json
 
 
+def _ping_scm_site(cmd, resource_group, name):
+    #  wakeup kudu, by making an SCM call
+    import requests
+    #  work around until the timeout limits issue for linux is investigated & fixed
+    user_name, password = _get_site_credential(cmd.cli_ctx, resource_group, name)
+    scm_url = _get_scm_url(cmd, resource_group, name)
+    import urllib3
+    authorization = urllib3.util.make_headers(basic_auth='{}:{}'.format(user_name, password))
+    requests.get(scm_url + '/api/settings', headers=authorization)
+
+
 def list_webapp_snapshots(cmd, resource_group, name, slot=None):
     client = web_client_factory(cmd.cli_ctx)
     if slot is None:
@@ -226,38 +232,50 @@ def restore_webapp_snapshot(cmd, resource_group, name, time, slot=None, restore_
             return client.web_apps.recover(resource_group, name, request)
 
 
-def _check_for_ready_tunnel(cmd, resource_group_name, name, remote_debugging, tunnel_server, slot=None):
+def _get_app_url(cmd, rg_name, app_name):
+    site = _generic_site_operation(cmd.cli_ctx, rg_name, app_name, 'get')
+    return "https://" + site.enabled_host_names[0]
+
+
+def _check_for_ready_tunnel(remote_debugging, tunnel_server):
     from .tunnel import TunnelServer
     default_port = tunnel_server.is_port_set_to_default()
     if default_port is not remote_debugging:
         return True
     return False
 
 
-def create_tunnel(cmd, resource_group_name, name, port, slot=None):
+def create_tunnel(cmd, resource_group_name, name, port=None, slot=None):
     profiles = list_publish_profiles(cmd, resource_group_name, name, slot)
     user_name = next(p['userName'] for p in profiles)
     user_password = next(p['userPWD'] for p in profiles)
-    import time
     import threading
     from .tunnel import TunnelServer
+
+    if port is None:
+        port = 0  # Will auto-select a free port from 1024-65535
+        logger.info('No port defined, creating on random free port')
     tunnel_server = TunnelServer('', port, name, user_name, user_password)
     config = get_site_configs(cmd, resource_group_name, name, slot)
+    _ping_scm_site(cmd, resource_group_name, name)
 
-    t = threading.Thread()
+    t = threading.Thread(target=_start_tunnel, args=(tunnel_server, config.remote_debugging_enabled))
     t.daemon = True
     t.start()
-    if not _check_for_ready_tunnel(cmd, resource_group_name, name, config.remote_debugging_enabled, tunnel_server, slot):
+
+    # Wait indefinitely for CTRL-C
+    while True:
+        time.sleep(5)
+
+
+def _start_tunnel(tunnel_server, remote_debugging_enabled):
+    if not _check_for_ready_tunnel(remote_debugging_enabled, tunnel_server):
         logger.warning('Tunnel is not ready yet, please wait (may take up to 1 minute)')
         while True:
             time.sleep(1)
             logger.warning('.')
-            if _check_for_ready_tunnel(cmd, resource_group_name, name, config.remote_debugging_enabled, tunnel_server, slot):
+            if _check_for_ready_tunnel(remote_debugging_enabled, tunnel_server):
                 break
-    logger.warning('Tunnel is ready! Creating on port %s', port)
+    if remote_debugging_enabled is False:
+        logger.warning('SSH is available { username: root, password: Docker! }')
     tunnel_server.start_server()
-
-
-def _get_app_url(cmd, rg_name, app_name):
-    site = _generic_site_operation(cmd.cli_ctx, rg_name, app_name, 'get')
-    return "https://" + site.enabled_host_names[0]

src/webapp/azext_webapp/tunnel.py

@@ -12,6 +12,7 @@
 import logging as logs
 
 from contextlib import closing
+from datetime import datetime
 from threading import Thread
 from websocket import create_connection, WebSocket
 
@@ -39,7 +40,7 @@ class TunnelServer(object):
     def __init__(self, local_addr, local_port, remote_addr, remote_user_name, remote_password):
         self.local_addr = local_addr
         self.local_port = local_port
-        if not self.is_port_open():
+        if self.local_port != 0 and not self.is_port_open():
             raise CLIError('Defined port is currently unavailable')
         self.remote_addr = remote_addr
         self.remote_user_name = remote_user_name
@@ -50,6 +51,9 @@ def __init__(self, local_addr, local_port, remote_addr, remote_user_name, remote
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         logger.info('Binding to socket on local address and port')
         self.sock.bind((self.local_addr, self.local_port))
+        if self.local_port == 0:
+            self.local_port = self.sock.getsockname()[1]
+            logger.warning('Auto-selecting port: %s', self.local_port)
         logger.info('Finished initialization')
 
     def create_basic_auth(self):
@@ -103,7 +107,7 @@ def listen(self):
         basic_auth_string = self.create_basic_auth()
         while True:
             self.client, address = self.sock.accept()
-            self.client.settimeout(60)
+            self.client.settimeout(1800)
             host = 'wss://{}{}'.format(self.remote_addr, '.scm.azurewebsites.net/AppServiceTunnel/Tunnel.ashx')
             basic_auth_header = 'Authorization: Basic {}'.format(basic_auth_string)
             cli_logger = get_logger()  # get CLI logger which has the level set through command lines
@@ -121,15 +125,14 @@ def listen(self):
                                         sslopt={'cert_reqs': ssl.CERT_NONE},
                                         enable_multithread=True)
             logger.info('Websocket, connected status: %s', self.ws.connected)
-
             index = index + 1
             logger.info('Got debugger connection... index: %s', index)
             debugger_thread = Thread(target=self.listen_to_client, args=(self.client, self.ws, index))
             web_socket_thread = Thread(target=self.listen_to_web_socket, args=(self.client, self.ws, index))
             debugger_thread.start()
             web_socket_thread.start()
             logger.info('Both debugger and websocket threads started...')
-            logger.warning('Successfully started local server..')
+            logger.warning('Successfully connected to local server..')
             debugger_thread.join()
             web_socket_thread.join()
             logger.info('Both debugger and websocket threads stopped...')
@@ -182,5 +185,5 @@ def listen_to_client(self, client, ws_socket, index):
                 return False
 
     def start_server(self):
-        logger.warning('Starting local server..')
+        logger.warning('Start your favorite client and connect to port %s', self.local_port)
         self.listen()

src/webapp/setup.py

@@ -8,7 +8,7 @@
 from codecs import open
 from setuptools import setup, find_packages
 
-VERSION = "0.2.4"
+VERSION = "0.2.5"
 
 CLASSIFIERS = [
     'Development Status :: 4 - Beta',