merged in master

Author: allmightyspiff

.secrets.baseline

@@ -3,7 +3,7 @@
     "files": "^.secrets.baseline$",
     "lines": null
   },
-  "generated_at": "2023-09-27T14:21:34Z",
+  "generated_at": "2023-10-13T20:28:05Z",
   "plugins_used": [
     {
       "name": "AWSKeyDetector"
@@ -238,7 +238,7 @@
         "hashed_secret": "fb5f2f1b65d1f2bc130ce9d5729b38d12f2b444e",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 259,
+        "line_number": 274,
         "type": "Secret Keyword",
         "verified_result": null
       }
@@ -529,23 +529,22 @@
         "verified_result": null
       }
     ],
-    "tests/CLI/modules/securitygroup_tests.py": [
+    "tests/CLI/modules/hardware/hardware_basic_tests.py": [
       {
-        "hashed_secret": "bc553d847e40dd6f3f63638f16f57b28ce1425cc",
-        "is_secret": false,
+        "hashed_secret": "6367c48dd193d56ea7b0baad25b19455e529f5ee",
         "is_verified": false,
-        "line_number": 339,
-        "type": "Hex High Entropy String",
+        "line_number": 57,
+        "type": "Secret Keyword",
         "verified_result": null
       }
     ],
-    "tests/CLI/modules/server_tests.py": [
+    "tests/CLI/modules/securitygroup_tests.py": [
       {
-        "hashed_secret": "6367c48dd193d56ea7b0baad25b19455e529f5ee",
+        "hashed_secret": "bc553d847e40dd6f3f63638f16f57b28ce1425cc",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 57,
-        "type": "Secret Keyword",
+        "line_number": 339,
+        "type": "Hex High Entropy String",
         "verified_result": null
       }
     ],
@@ -594,7 +593,7 @@
         "hashed_secret": "fb5f2f1b65d1f2bc130ce9d5729b38d12f2b444e",
         "is_secret": false,
         "is_verified": false,
-        "line_number": 737,
+        "line_number": 673,
         "type": "Secret Keyword",
         "verified_result": null
       }

SoftLayer/API.py

@@ -9,11 +9,12 @@
 import time
 import warnings
 
+import concurrent.futures as cf
 import json
 import logging
+import math
 import requests
 
-
 from SoftLayer import auth as slauth
 from SoftLayer import config
 from SoftLayer import consts
@@ -289,13 +290,6 @@ def call(self, service, method, *args, **kwargs):
             request.verify = kwargs.get('verify')
 
         if self.auth:
-            extra_headers = self.auth.get_headers()
-            if extra_headers:
-                warnings.warn("auth.get_headers() is deprecated and will be "
-                              "removed in the next major version",
-                              DeprecationWarning)
-                request.headers.update(extra_headers)
-
             request = self.auth.get_request(request)
 
         request.headers.update(kwargs.get('headers', {}))
@@ -352,6 +346,42 @@ def iter_call(self, service, method, *args, **kwargs):
 
             offset += limit
 
+    def cf_call(self, service, method, *args, **kwargs):
+        """Uses threads to iterate through API calls.
+
+        :param service: the name of the SoftLayer API service
+        :param method: the method to call on the service
+        :param integer limit: result size for each API call (defaults to 100)
+        :param \\*args: same optional arguments that ``Service.call`` takes
+        :param \\*\\*kwargs: same optional keyword arguments that ``Service.call`` takes
+        """
+        limit = kwargs.pop('limit', 100)
+        offset = kwargs.pop('offset', 0)
+
+        if limit <= 0:
+            raise AttributeError("Limit size should be greater than zero.")
+        # This initial API call is to determine how many API calls we need to make after this first one.
+        first_call = self.call(service, method, offset=offset, limit=limit, *args, **kwargs)
+
+        # This was not a list result, just return it.
+        if not isinstance(first_call, transports.SoftLayerListResult):
+            return first_call
+        # How many more API calls we have to make
+        api_calls = math.ceil((first_call.total_count - limit) / limit)
+
+        def this_api(offset):
+            """Used to easily call executor.map() on this fuction"""
+            return self.call(service, method, offset=offset, limit=limit, *args, **kwargs)
+
+        with cf.ThreadPoolExecutor(max_workers=10) as executor:
+            future_results = {}
+            offset_map = [x * limit for x in range(1, api_calls)]
+            future_results = list(executor.map(this_api, offset_map))
+        # Append the results in the order they were called
+        for call_result in future_results:
+            first_call = first_call + call_result
+        return first_call
+
     def __repr__(self):
         return "Client(transport=%r, auth=%r)" % (self.transport, self.auth)
 

SoftLayer/CLI/command.py

@@ -30,6 +30,7 @@ class OptionHighlighter(RegexHighlighter):
         r"(?P<option_choices>Choices: )",
         r"(?P<example_block>Example::)",
         r"(?P<url>(file|https|http|ws|wss)://[-0-9a-zA-Z$_+!`(),.?/;:&=%#~]*)"
+        r"(?P<args_keyword>^[A-Z]+$)",
     ]
 
 
@@ -179,6 +180,8 @@ def format_usage(self, ctx: click.Context, formatter: click.formatting.HelpForma
                 pieces[index] = "[options][OPTIONS][/]"
             elif piece == "COMMAND [ARGS]...":
                 pieces[index] = "[command]COMMAND[/] [args][ARGS][/] ..."
+            else:
+                pieces[index] = f"[args_keyword]{piece}[/]"
 
         self.console.print(f"Usage: [path]{ctx.command_path}[/] {' '.join(pieces)}")
 
@@ -205,16 +208,23 @@ def format_epilog(self, ctx: click.Context, formatter: click.formatting.HelpForm
     def format_options(self, ctx, formatter):
         """Prints out the options in a table format"""
 
-        # NEXT support binary options --yes/--no
-        # NEXT SUPPORT color for IDENTIFIER and such
         options_table = Table(highlight=True, box=box.SQUARE, show_header=False)
 
         for param in self.get_params(ctx):
+            # useful for showing whats in a param
+            # print(param.to_info_dict())
+
+            # Set Arguments to all uppercase
+            if param.param_type_name == 'argument':
+                param.opts[0] = param.opts[0].upper()
+
+            # This option has a short (-v) and long (--verbose) options
             if len(param.opts) == 2:
                 opt1 = self.highlighter(param.opts[1])
                 opt2 = self.highlighter(param.opts[0])
             else:
                 opt2 = self.highlighter(param.opts[0])
+                # Needs to be the Text() type because rich.Text doesn't mesh with string
                 opt1 = Text("")
 
             # Ensures the short option is always in opt1.
@@ -224,19 +234,20 @@ def format_options(self, ctx, formatter):
             if param.metavar:
                 opt2 += Text(f" {param.metavar}", style="bold yellow")
 
-            options = Text(" ".join(reversed(param.opts)))
+            # secondary_opts are usually for flags --enable/--disable
+            if len(param.secondary_opts) == 1:
+                opt2 += Text("|") + self.highlighter(param.secondary_opts[0])
+
             help_record = param.get_help_record(ctx)
             help_message = ""
             if help_record:
-                help_message = param.get_help_record(ctx)[-1]
+                help_message = Text(param.get_help_record(ctx)[-1])
 
             # Add Click choices to help message
             if isinstance(param.type, click.Choice):
                 choices = ", ".join(param.type.choices)
                 help_message += f" Choices: {choices}"
 
-            if param.metavar:
-                options += f" {param.metavar}"
             options_table.add_row(opt1, opt2, self.highlighter(help_message))
 
         self.console.print(options_table)

SoftLayer/CLI/formatting.py

@@ -318,6 +318,22 @@ def __init__(self, columns, title=None, align=None):
         self.align = align or {}
         self.sortby = None
         self.title = title
+        # Used to print a message if the table is empty
+        self.empty_message = None
+
+    def __bool__(self):
+        """Useful for seeing if the table has any rows"""
+        return len(self.rows) > 0
+
+    def set_empty_message(self, message):
+        """Sets the empty message for this table for env.fout
+
+        Set this message if you want to print a message instead of a table to the user
+        but still want the json output to print an empty list `[]`
+
+        :param message str: Message to print if the table has no rows
+        """
+        self.empty_message = message
 
     def add_row(self, row):
         """Add a row to the table.
@@ -337,6 +353,10 @@ def to_python(self):
 
     def prettytable(self, fmt='table', theme=None):
         """Returns a RICH table instance."""
+
+        # Used to print a message instead of a bad looking empty table
+        if not self and self.empty_message:
+            return self.empty_message
         box_style = box.SQUARE
         if fmt == 'raw':
             box_style = None

SoftLayer/CLI/hardware/detail.py

@@ -29,14 +29,14 @@ def cli(env, identifier, passwords, price, components):
     table.align['value'] = 'l'
 
     hardware_id = helpers.resolve_id(hardware.resolve_ids, identifier, 'hardware')
-    result = hardware.get_hardware(hardware_id)
+    result = hardware.get_hardware_fast(hardware_id)
     result = utils.NestedDict(result)
     hard_drives = hardware.get_hard_drives(hardware_id)
 
     operating_system = utils.lookup(result, 'operatingSystem', 'softwareLicense', 'softwareDescription') or {}
     memory = formatting.gb(result.get('memoryCapacity', 0))
     owner = None
-    if utils.lookup(result, 'billingItem') != []:
+    if utils.lookup(result, 'billingItem'):
         owner = utils.lookup(result, 'billingItem', 'orderItem', 'order', 'userRecord', 'username')
 
     table_hard_drives = formatting.Table(['Name', 'Capacity', 'Serial #'])
@@ -72,11 +72,30 @@ def cli(env, identifier, passwords, price, components):
     table.add_row(['last_transaction', last_transaction])
     table.add_row(['billing', 'Hourly' if result['hourlyBillingFlag'] else 'Monthly'])
 
-    vlan_table = formatting.Table(['type', 'number', 'id', 'name', 'netmask'])
+    vlan_table = formatting.Table(['Network', 'Number', 'Id', 'Name', 'Type'])
     for vlan in result['networkVlans']:
-        vlan_table.add_row([vlan['networkSpace'], vlan['vlanNumber'],
-                            vlan['id'], vlan['fullyQualifiedName'],
-                            vlan['primarySubnets'][0]['netmask']])
+        vlan_table.add_row([
+            vlan.get('networkSpace'),
+            vlan.get('vlanNumber'),
+            vlan['id'],
+            vlan['fullyQualifiedName'],
+            'Primary'
+        ])
+
+    # Shows any VLANS trunked/tagged on this server
+    for component in result.get('networkComponents', []):
+        # These are the Primary network components
+        if component.get('primaryIpAddress', False):
+            uplink = component.get('uplinkComponent', {})
+            for trunk in uplink.get('networkVlanTrunks', []):
+                trunk_vlan = trunk.get('networkVlan')
+                vlan_table.add_row([
+                    trunk_vlan.get('networkSpace'),
+                    trunk_vlan.get('vlanNumber'),
+                    trunk_vlan.get('id'),
+                    trunk_vlan.get('fullyQualifiedName'),
+                    'Trunked'
+                ])
 
     table.add_row(['vlans', vlan_table])
 

SoftLayer/CLI/hardware/vlan_add.py

@@ -0,0 +1,60 @@
+"""Trunk a VLAN to this server."""
+# :license: MIT, see LICENSE for more details.
+
+import click
+
+import SoftLayer
+from SoftLayer.CLI import environment
+from SoftLayer.CLI import exceptions
+from SoftLayer.CLI import helpers
+
+
+@click.command(cls=SoftLayer.CLI.command.SLCommand, )
+@click.argument('hardware', nargs=1)
+@click.argument('vlans', nargs=-1)
+@environment.pass_env
+def cli(env, hardware, vlans):
+    """Trunk a VLAN to this server.
+
+    HARDWARE is the id of the server
+    VLANS is the ID, name, or number of the VLANs you want to add. Multiple vlans can be added at the same time.
+    It is recommended to use the vlan ID, especially if you have multiple vlans with the same name/number.
+    """
+
+    if not vlans:
+        raise exceptions.ArgumentError("Error: Missing argument 'VLANS'.")
+    h_mgr = SoftLayer.HardwareManager(env.client)
+    n_mgr = SoftLayer.NetworkManager(env.client)
+    hw_id = helpers.resolve_id(h_mgr.resolve_ids, hardware, 'hardware')
+    # Enclosing in quotes is required for any input that has a space in it.
+    # "Public DAL10" for example needs to be sent to search as \"Public DAL10\"
+    sl_vlans = n_mgr.search_for_vlan(" ".join(f"\"{v}\"" for v in vlans))
+    if not sl_vlans:
+        raise exceptions.ArgumentError(f"No vlans found matching {' '.join(vlans)}")
+    add_vlans = parse_vlans(sl_vlans)
+    component_mask = "mask[id, name, port, macAddress, primaryIpAddress]"
+    # NEXT: Add nice output / exception handling
+    if len(add_vlans['public']) > 0:
+        components = h_mgr.get_network_components(hw_id, mask=component_mask, space='public')
+        for c in components:
+            if c.get('primaryIpAddress'):
+                h_mgr.trunk_vlan(c.get('id'), add_vlans['public'])
+    if len(add_vlans['private']) > 0:
+        components = h_mgr.get_network_components(hw_id, mask=component_mask, space='private')
+        for c in components:
+            if c.get('primaryIpAddress'):
+                h_mgr.trunk_vlan(c.get('id'), add_vlans['private'])
+
+
+def parse_vlans(vlans):
+    """returns a dictionary mapping for public / private vlans"""
+
+    pub_vlan = []
+    pri_vlan = []
+    for vlan in vlans:
+        print(f"{vlan.get('networkSpace')} | {vlan.get('id')} -> {vlan.get('vlanNumber')}")
+        if vlan.get('networkSpace') == "PUBLIC":
+            pub_vlan.append(vlan)
+        else:
+            pri_vlan.append(vlan)
+    return {"public": pub_vlan, "private": pri_vlan}