Provide default implementations of simple CLI commands

azure-cli.pyproj

@@ -14,6 +14,9 @@
     <LaunchProvider>Standard Python launcher</LaunchProvider>
     <InterpreterId>{1dd9c42b-5980-42ce-a2c3-46d3bf0eede4}</InterpreterId>
     <InterpreterVersion>3.5</InterpreterVersion>
+    <CommandLineArguments>
+    </CommandLineArguments>
+    <EnableNativeCodeDebugging>False</EnableNativeCodeDebugging>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)' == 'Debug'" />
   <PropertyGroup Condition="'$(Configuration)' == 'Release'" />
@@ -25,12 +28,19 @@
     <Compile Include="azure\cli\commands\account.py" />
     <Compile Include="azure\cli\commands\login.py" />
     <Compile Include="azure\cli\commands\logout.py" />
+    <Compile Include="azure\cli\commands\network.py" />
+    <Compile Include="azure\cli\commands\resourcegroup.py" />
     <Compile Include="azure\cli\commands\storage.py" />
+    <Compile Include="azure\cli\commands\vm.py" />
+    <Compile Include="azure\cli\commands\_auto_command.py" />
     <Compile Include="azure\cli\commands\__init__.py" />
     <Compile Include="azure\cli\main.py" />
     <Compile Include="azure\cli\tests\test_argparse.py">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="azure\cli\tests\test_autocommand.py">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="azure\cli\tests\test_connection_verify.py">
       <SubType>Code</SubType>
     </Compile>
@@ -43,6 +53,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="azure\cli\_logging.py" />
+    <Compile Include="azure\cli\_output.py" />
     <Compile Include="azure\cli\_profile.py" />
     <Compile Include="azure\cli\_session.py">
       <SubType>Code</SubType>

src/azure/cli/_argparse.py

@@ -208,7 +208,7 @@ def not_global(a):
             return handler(parsed, others)
         except IncorrectUsageError as ex:
             print(str(ex), file=out)
-            return self.display_usage(nouns, m, args, out)
+            return self._display_usage(nouns, m, args, out)
         finally:
             sys.stdout = old_stdout
 

src/azure/cli/commands/__init__.py

@@ -3,11 +3,13 @@
 
 # TODO: Alternatively, simply scan the directory for all modules
 COMMAND_MODULES = [
+    'account',
     'login',
     'logout',
-    'account',
+    'network',
+    'resourcegroup',
     'storage',
-    'resourcegroup'
+    'vm',
 ]
 
 _COMMANDS = {}

src/azure/cli/commands/_auto_command.py

@@ -0,0 +1,58 @@
+import inspect
+from msrest import Serializer
+from ..commands import command, description, option
+from azure.cli._argparse import IncorrectUsageError
+
+def _decorate_command(name, func):
+    return command(name)(func)
+
+def _decorate_description(desc, func):
+    return description(desc)(func)
+
+def _decorate_option(spec, descr, func):
+    return option(spec, descr)(func)
+
+def _make_func(client_factory, member_name, return_type_name, unbound_func):
+    def call_client(args, unexpected): #pylint: disable=unused-argument
+        client = client_factory()
+        ops_instance = getattr(client, member_name)
+        try:
+            result = unbound_func(ops_instance, **args)
+            if not return_type_name:
+                return {}
+            return Serializer().serialize_data(result, return_type_name)
+        except TypeError as exception:
+            # TODO: Evaluate required/missing parameters and provide specific
+            # usage for missing params...
+            raise IncorrectUsageError(exception)
+
+    return call_client
+
+def _option_description(operation, arg):
+    """Pull out parameter help from doccomments of the command
+    """
+    # TODO: We are currently doing this for every option/argument.
+    # We should do it (at most) once for a given command...
+    return ' '.join(l.split(':')[-1] for l in inspect.getdoc(operation).splitlines()
+                    if l.startswith(':param') and arg + ':' in l)
+
+EXCLUDED_PARAMS = frozenset(['self', 'raw', 'custom_headers', 'operation_config'])
+
+def operation_builder(package_name, resource_type, member_name, client_type, operations):
+    for operation, return_type_name in operations:
+        opname = operation.__name__
+        func = _make_func(client_type, member_name, return_type_name, operation)
+        func = _decorate_command(' '.join([package_name, resource_type, opname]), func)
+
+        args = []
+        try:
+            # only supported in python3 - falling back to argspec if not available
+            sig = inspect.signature(operation)
+            args = sig.parameters
+        except AttributeError:
+            sig = inspect.getargspec(operation) #pylint: disable=deprecated-method
+            args = sig.args
+
+        for arg in [a for a in args if not a in EXCLUDED_PARAMS]:
+            spec = '--%s <%s>' % (arg, arg)
+            func = _decorate_option(spec, _option_description(operation, arg), func=func)

src/azure/cli/commands/network.py

@@ -0,0 +1,241 @@
+from azure.mgmt.network import NetworkManagementClient, NetworkManagementClientConfiguration
+from azure.mgmt.network.operations import (ApplicationGatewaysOperations,
+                                           ExpressRouteCircuitAuthorizationsOperations,
+                                           ExpressRouteCircuitPeeringsOperations,
+                                           ExpressRouteCircuitsOperations,
+                                           ExpressRouteServiceProvidersOperations,
+                                           LoadBalancersOperations,
+                                           LocalNetworkGatewaysOperations,
+                                           NetworkInterfacesOperations,
+                                           NetworkSecurityGroupsOperations,
+                                           PublicIPAddressesOperations,
+                                           RouteTablesOperations,
+                                           RoutesOperations,
+                                           SecurityRulesOperations,
+                                           SubnetsOperations,
+                                           UsagesOperations,
+                                           VirtualNetworkGatewayConnectionsOperations,
+                                           VirtualNetworkGatewaysOperations,
+                                           VirtualNetworksOperations)
+
+from ._command_creation import get_service_client
+from ..commands import _auto_command
+
+def _network_client_factory():
+    return get_service_client(NetworkManagementClient, NetworkManagementClientConfiguration)
+
+# pylint: disable=line-too-long
+# Application gateways
+_auto_command.operation_builder("network",
+                                "appgateway",
+                                "application_gateways",
+                                _network_client_factory,
+                                [
+                                    (ApplicationGatewaysOperations.delete, None),
+                                    (ApplicationGatewaysOperations.get, 'ApplicationGateway'),
+                                    (ApplicationGatewaysOperations.list, '[ApplicationGateway]'),
+                                    (ApplicationGatewaysOperations.list_all, '[ApplicationGateway]'),
+                                    (ApplicationGatewaysOperations.start, None),
+                                    (ApplicationGatewaysOperations.stop, None),
+                                ])
+
+# ExpressRouteCircuitAuthorizationsOperations
+_auto_command.operation_builder("network",
+                                "expressroutecircuitauth",
+                                "express_route_circuit_authorizations",
+                                _network_client_factory,
+                                [
+                                    (ExpressRouteCircuitAuthorizationsOperations.delete, None),
+                                    (ExpressRouteCircuitAuthorizationsOperations.get, 'ExpressRouteCircuitAuthorization'),
+                                    (ExpressRouteCircuitAuthorizationsOperations.list, '[ExpressRouteCircuitAuthorization]'),
+                                ])
+
+# ExpressRouteCircuitPeeringsOperations
+_auto_command.operation_builder("network",
+                                "expressroutecircuitpeering",
+                                "express_route_circuit_peerings",
+                                _network_client_factory,
+                                [
+                                    (ExpressRouteCircuitPeeringsOperations.delete, None),
+                                    (ExpressRouteCircuitPeeringsOperations.get, 'ExpressRouteCircuitPeering'),
+                                    (ExpressRouteCircuitPeeringsOperations.list, '[ExpressRouteCircuitPeering]'),
+                                ])
+
+# ExpressRouteCircuitsOperations
+_auto_command.operation_builder("network",
+                                "expressroutecircuit",
+                                "express_route_circuits",
+                                _network_client_factory,
+                                [
+                                    (ExpressRouteCircuitsOperations.delete, None),
+                                    (ExpressRouteCircuitsOperations.get, 'ExpressRouteCircuit'),
+                                    (ExpressRouteCircuitsOperations.list_arp_table, '[ExpressRouteCircuitArpTable]'),
+                                    (ExpressRouteCircuitsOperations.list_routes_table, '[ExpressRouteCircuitRoutesTable]'),
+                                    (ExpressRouteCircuitsOperations.list_stats, '[ExpressRouteCircuitStats]'),
+                                    (ExpressRouteCircuitsOperations.list, '[ExpressRouteCircuit]'),
+                                    (ExpressRouteCircuitsOperations.list_all, '[ExpressRouteCircuit]'),
+                                ])
+
+# ExpressRouteServiceProvidersOperations
+_auto_command.operation_builder("network",
+                                "expressroutesp",
+                                "express_route_service_providers",
+                                _network_client_factory,
+                                [
+                                    (ExpressRouteServiceProvidersOperations.list, '[ExpressRouteServiceProvider]'),
+                                ])
+
+# LoadBalancersOperations
+_auto_command.operation_builder("network",
+                                "lb",
+                                "load_balancers",
+                                _network_client_factory,
+                                [
+                                    (LoadBalancersOperations.delete, None),
+                                    (LoadBalancersOperations.get, 'LoadBalancer'),
+                                    (LoadBalancersOperations.list_all, '[LoadBalancer]'),
+                                    (LoadBalancersOperations.list, '[LoadBalancer]'),
+                                ])
+
+# LocalNetworkGatewaysOperations
+_auto_command.operation_builder("network",
+                                "localgateways",
+                                "local_network_gateways",
+                                _network_client_factory,
+                                [
+                                    (LocalNetworkGatewaysOperations.get, 'LocalNetworkGateway'),
+                                    (LocalNetworkGatewaysOperations.delete, None),
+                                    (LocalNetworkGatewaysOperations.list, '[LocalNetworkGateway]'),
+                                ])
+
+
+# NetworkInterfacesOperations
+_auto_command.operation_builder("network",
+                                "nic",
+                                "network_interfaces",
+                                _network_client_factory,
+                                [
+                                    (NetworkInterfacesOperations.delete, None),
+                                    (NetworkInterfacesOperations.get, 'NetworkInterface'),
+                                    (NetworkInterfacesOperations.list_virtual_machine_scale_set_vm_network_interfaces, '[NetworkInterface]'),
+                                    (NetworkInterfacesOperations.list_virtual_machine_scale_set_network_interfaces, '[NetworkInterface]'),
+                                    (NetworkInterfacesOperations.get_virtual_machine_scale_set_network_interface, 'NetworkInterface'),
+                                    (NetworkInterfacesOperations.list_all, '[NetworkInterface]'),
+                                    (NetworkInterfacesOperations.list, '[NetworkInterface]'),
+                                ])
+
+# NetworkSecurityGroupsOperations
+_auto_command.operation_builder("network",
+                                "securitygroup",
+                                "network_security_groups",
+                                _network_client_factory,
+                                [
+                                    (NetworkSecurityGroupsOperations.delete, None),
+                                    (NetworkSecurityGroupsOperations.delete, 'NetworkSecurityGroup'),
+                                    (NetworkSecurityGroupsOperations.list_all, '[NetworkSecurityGroup]'),
+                                    (NetworkSecurityGroupsOperations.list, '[NetworkSecurityGroup]'),
+                                ])
+
+# PublicIPAddressesOperations
+_auto_command.operation_builder("network",
+                                "publicipaddress",
+                                "public_ip_addresses",
+                                _network_client_factory,
+                                [
+                                    (PublicIPAddressesOperations.delete, None),
+                                    (PublicIPAddressesOperations.get, 'PublicIPAddress'),
+                                    (PublicIPAddressesOperations.list_all, '[PublicIPAddress]'),
+                                    (PublicIPAddressesOperations.list, '[PublicIPAddress]'),
+                                ])
+
+# RouteTablesOperations
+_auto_command.operation_builder("network",
+                                "routetable",
+                                "route_tables",
+                                _network_client_factory,
+                                [
+                                    (RouteTablesOperations.delete, None),
+                                    (RouteTablesOperations.get, 'RouteTable'),
+                                    (RouteTablesOperations.list, '[RouteTable]'),
+                                    (RouteTablesOperations.list_all, '[RouteTable]'),
+                                ])
+
+# RoutesOperations
+_auto_command.operation_builder("network",
+                                "routeoperation",
+                                "routes",
+                                _network_client_factory,
+                                [
+                                    (RoutesOperations.delete, None),
+                                    (RoutesOperations.get, 'Route'),
+                                    (RoutesOperations.list, '[Route]'),
+                                ])
+
+# SecurityRulesOperations
+_auto_command.operation_builder("network",
+                                "securityrules",
+                                "security_rules",
+                                _network_client_factory,
+                                [
+                                    (SecurityRulesOperations.delete, None),
+                                    (SecurityRulesOperations.get, 'SecurityRule'),
+                                    (SecurityRulesOperations.list, '[SecurityRule]'),
+                                ])
+
+# SubnetsOperations
+_auto_command.operation_builder("network",
+                                "subnet",
+                                "subnets",
+                                _network_client_factory,
+                                [
+                                    (SubnetsOperations.delete, None),
+                                    (SubnetsOperations.get, 'Subnet'),
+                                    (SubnetsOperations.list, '[Subnet]'),
+                                ])
+
+# UsagesOperations
+_auto_command.operation_builder("network",
+                                "usage",
+                                "usages",
+                                _network_client_factory,
+                                [
+                                    (UsagesOperations.list, '[Usage]'),
+                                ])
+
+# VirtualNetworkGatewayConnectionsOperations
+_auto_command.operation_builder("network",
+                                "vnetgatewayconnection",
+                                "virtual_network_gateway_connections",
+                                _network_client_factory,
+                                [
+                                    (VirtualNetworkGatewayConnectionsOperations.delete, None),
+                                    (VirtualNetworkGatewayConnectionsOperations.get, 'VirtualNetworkGatewayConnection'),
+                                    (VirtualNetworkGatewayConnectionsOperations.get_shared_key, 'ConnectionSharedKeyResult'),
+                                    (VirtualNetworkGatewayConnectionsOperations.list, '[VirtualNetworkGatewayConnection]'),
+                                    (VirtualNetworkGatewayConnectionsOperations.reset_shared_key, 'ConnectionResetSharedKey'),
+                                    (VirtualNetworkGatewayConnectionsOperations.set_shared_key, 'ConnectionSharedKey'),
+                                ])
+
+# VirtualNetworkGatewaysOperations
+_auto_command.operation_builder("network",
+                                "vnetgateway",
+                                "virtual_network_gateways",
+                                _network_client_factory,
+                                [
+                                    (VirtualNetworkGatewaysOperations.delete, None),
+                                    (VirtualNetworkGatewaysOperations.get, 'VirtualNetworkGateway'),
+                                    (VirtualNetworkGatewaysOperations.list, '[VirtualNetworkGateway]'),
+                                    (VirtualNetworkGatewaysOperations.reset, 'VirtualNetworkGateway'),
+                                ])
+
+# VirtualNetworksOperations
+_auto_command.operation_builder("network",
+                                "vnet",
+                                "virtual_networks",
+                                _network_client_factory,
+                                [
+                                    (VirtualNetworksOperations.delete, None),
+                                    (VirtualNetworksOperations.get, 'VirtualNetwork'),
+                                    (VirtualNetworksOperations.list, '[VirtualNetwork]'),
+                                    (VirtualNetworksOperations.list_all, '[VirtualNetwork]'),
+                                ])