besapi 3.7.7__tar.gz → 3.8.1__tar.gz

{besapi-3.7.7/src/besapi.egg-info → besapi-3.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: besapi
-Version: 3.7.7
+Version: 3.8.1
 Summary: Library for working with the BigFix REST API
 Home-page: https://github.com/jgstew/besapi
 Author: Matt Hansen, James Stewart

{besapi-3.7.7 → besapi-3.8.1}/src/besapi/besapi.py

@@ -12,13 +12,13 @@ Library for communicating with the BES (BigFix) REST API.
 import configparser
 import datetime
 import hashlib
-import io
 import json
 import logging
 import os
 import random
 import site
 import string
+import typing
 
 try:
     from urllib import parse
@@ -29,7 +29,7 @@ import requests
 from lxml import etree, objectify
 from pkg_resources import resource_filename
 
-__version__ = "3.7.7"
+__version__ = "3.8.1"
 
 besapi_logger = logging.getLogger("besapi")
 
@@ -94,7 +94,7 @@ def elem2dict(node):
 def replace_text_between(
     original_text, first_delimiter, second_delimiter, replacement_text
 ):
-    """Replace text between delimeters. Each delimiter should only appear once."""
+    """Replace text between delimiters. Each delimiter should only appear once."""
     leading_text = original_text.split(first_delimiter)[0]
     trailing_text = original_text.split(second_delimiter)[1]
 
@@ -120,7 +120,7 @@ def parse_bes_modtime(string_datetime):
 #     """custom HTTPAdapter for requests to override blocksize
 #     for Uploading or Downloading large files"""
 
-#     # override inti_poolmanager from regular HTTPAdapter
+#     # override init_poolmanager from regular HTTPAdapter
 #     # https://stackoverflow.com/questions/22915295/python-requests-post-and-big-content/22915488#comment125583017_22915488
 #     def init_poolmanager(self, connections, maxsize, block=False, **pool_kwargs):
 #         """Initializes a urllib3 PoolManager.
@@ -152,6 +152,92 @@ def parse_bes_modtime(string_datetime):
 #         )
 
 
+def get_action_combined_relevance(relevances: typing.List[str]):
+    """take array of ordered relevance clauses and return relevance string for action"""
+
+    relevance_combined = ""
+
+    if not relevances:
+        return "False"
+    if len(relevances) == 0:
+        return "False"
+    if len(relevances) == 1:
+        return relevances[0]
+    if len(relevances) > 0:
+        for clause in relevances:
+            if len(relevance_combined) == 0:
+                relevance_combined = clause
+            else:
+                relevance_combined = (
+                    "( " + relevance_combined + " ) AND ( " + clause + " )"
+                )
+
+    return relevance_combined
+
+
+def get_target_xml(targets=None):
+    """get target xml based upon input
+
+    Input can be a single string:
+        - starts with "<AllComputers>" if all computers should be targeted
+        - Otherwise will be interpreted as custom relevance
+
+    Input can be a single int:
+        - Single Computer ID Target
+
+    Input can be an array:
+        - Array of Strings: ComputerName
+        - Array of Integers: ComputerID
+    """
+    if targets is None or not targets:
+        logging.warning("No valid targeting found, will target no computers.")
+        # default if invalid:
+        return "<CustomRelevance>False</CustomRelevance>"
+
+    # if targets is int:
+    if isinstance(targets, int):
+        if targets == 0:
+            raise ValueError(
+                "Int 0 is not valid Computer ID, set targets to an array of strings of computer names or an array of ints of computer ids or custom relevance string or <AllComputers>"
+            )
+        return f"<ComputerID>{targets}</ComputerID>"
+
+    # if targets is str:
+    if isinstance(targets, str):
+        # if targets string starts with "<AllComputers>":
+        if targets.startswith("<AllComputers>"):
+            if "false" in targets.lower():
+                # In my testing, <AllComputers>false</AllComputers> does not work correctly
+                return "<CustomRelevance>False</CustomRelevance>"
+                # return "<AllComputers>false</AllComputers>"
+            return "<AllComputers>true</AllComputers>"
+        # treat as custom relevance:
+        return f"<CustomRelevance><![CDATA[{targets}]]></CustomRelevance>"
+
+    # if targets is array:
+    if isinstance(targets, list):
+        element_type = type(targets[0])
+        if element_type is int:
+            # array of computer ids
+            return (
+                "<ComputerID>"
+                + "</ComputerID><ComputerID>".join(map(str, targets))
+                + "</ComputerID>"
+            )
+        if element_type is str:
+            # array of computer names
+            return (
+                "<ComputerName>"
+                + "</ComputerName><ComputerName>".join(targets)
+                + "</ComputerName>"
+            )
+
+    logging.warning("No valid targeting found, will target no computers.")
+
+    # default if invalid:
+    return "<CustomRelevance>False</CustomRelevance>"
+
+
 def validate_xsd(doc):
     """validate results using XML XSDs"""
     try:
@@ -257,7 +343,7 @@ class BESConnection:
     def __repr__(self):
         """object representation"""
         # https://stackoverflow.com/a/2626364/861745
-        return f"Object: besapi.BESConnction( username={self.username}, rootserver={self.rootserver} )"
+        return f"Object: besapi.BESConnection( username={self.username}, rootserver={self.rootserver} )"
 
     def __eq__(self, other):
         if (
@@ -669,7 +755,7 @@ class BESConnection:
         file_url = str(result_upload.besobj.FileUpload.URL)
         if use_https:
             file_url = file_url.replace("http://", "https://")
-        # there are 3 different posibilities for the server FQDN
+        # there are 3 different possibilities for the server FQDN
         # localhost
         # self.rootserver (without port number)
         # the returned value from the upload result
@@ -927,7 +1013,7 @@ class RESTResult:
                     f"\n - HTTP Response Status Code: `403` Forbidden\n - ERROR: `{self.text}`\n - URL: `{self.request.url}`"
                 )
 
-            besapi_logger.info(
+            besapi_logger.debug(
                 "HTTP Request Status Code `%d` from URL `%s`",
                 self.request.status_code,
                 self.request.url,

{besapi-3.7.7 → besapi-3.8.1}/src/besapi/plugin_utilities.py

@@ -58,7 +58,7 @@ def get_invoke_file_name(verbose=0):
 def setup_plugin_argparse(plugin_args_required=False):
     """setup argparse for plugin use"""
     arg_parser = argparse.ArgumentParser(
-        description="Provde command line arguments for REST URL, username, and password"
+        description="Provide command line arguments for REST URL, username, and password"
     )
     arg_parser.add_argument(
         "-v",

{besapi-3.7.7 → besapi-3.8.1/src/besapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: besapi
-Version: 3.7.7
+Version: 3.8.1
 Summary: Library for working with the BigFix REST API
 Home-page: https://github.com/jgstew/besapi
 Author: Matt Hansen, James Stewart

{besapi-3.7.7 → besapi-3.8.1}/src/bescli/bescli.py

@@ -10,6 +10,7 @@ Simple command line interface for the BES (BigFix) REST API.
 """
 
 import getpass
+import json
 import logging
 import os
 import site
@@ -56,8 +57,50 @@ class BESCLInterface(Cmd):
         # set default config file path
         self.conf_path = os.path.expanduser("~/.besapi.conf")
         self.CONFPARSER = SafeConfigParser()
+        # for completion:
+        self.api_resources = []
         self.do_conf()
 
+    def parse_help_resources(self):
+        """get api resources from help"""
+        if self.bes_conn:
+            help_result = self.bes_conn.get("help")
+            help_result = help_result.text.split("\n")
+            # print(help_result)
+            help_resources = []
+            for item in help_result:
+                if "/api/" in item:
+                    _, _, res = item.partition("/api/")
+                    # strip whitespace just in case:
+                    help_resources.append(res.strip())
+
+            return help_resources
+        else:
+            return [
+                "actions",
+                "clientqueryresults",
+                "dashboardvariables",
+                "help",
+                "login",
+                "query",
+                "relaysites",
+                "serverinfo",
+                "sites",
+            ]
+
+    def complete_api_resources(self, text, line, begidx, endidx):
+        """define completion for apis"""
+
+        # only initialize once
+        if not self.api_resources:
+            self.api_resources = self.parse_help_resources()
+
+        # TODO: make this work to complete only the first word after get/post/delete
+        # return the matching subset:
+        return [name for name in self.api_resources if name.startswith(text)]
+
+    complete_get = complete_api_resources
+
     def do_get(self, line):
         """Perform get request to BigFix server using provided api endpoint argument"""
 
@@ -80,16 +123,18 @@ class BESCLInterface(Cmd):
                 b = self.bes_conn.get(robjs[0])
                 # print objectify.ObjectPath(robjs[1:])
                 if b:
-                    print(eval("b()." + ".".join(robjs[1:])))
+                    self.poutput(eval("b()." + ".".join(robjs[1:])))
             else:
                 output_item = self.bes_conn.get(line)
-                # print(type(output_item))
-                print(output_item)
-                # print(output_item.besdict)
-                # print(output_item.besjson)
+                # self.poutput(type(output_item))
+                self.poutput(output_item)
+                # self.poutput(output_item.besdict)
+                # self.poutput(output_item.besjson)
         else:
             self.pfeedback("Not currently logged in. Type 'login'.")
 
+    complete_delete = complete_api_resources
+
     def do_delete(self, line):
         """Perform delete request to BigFix server using provided api endpoint argument"""
 
@@ -104,16 +149,18 @@ class BESCLInterface(Cmd):
         if self.bes_conn:
             output_item = self.bes_conn.delete(line)
 
-            print(output_item)
-            # print(output_item.besdict)
-            # print(output_item.besjson)
+            self.poutput(output_item)
+            # self.poutput(output_item.besdict)
+            # self.poutput(output_item.besjson)
         else:
             self.pfeedback("Not currently logged in. Type 'login'.")
 
+    complete_post = complete_api_resources
+
     def do_post(self, statement):
         """post file as data to path"""
-        print(statement)
-        print("not yet implemented")
+        self.poutput(statement)
+        self.poutput("not yet implemented")
 
     def do_config(self, conf_file=None):
         """Attempt to load config info from file and login"""
@@ -244,7 +291,7 @@ class BESCLInterface(Cmd):
         else:
             self.perror("Login Error!")
 
-    def do_logout(self, arg=None):
+    def do_logout(self, _=None):
         """Logout and clear session"""
         if self.bes_conn:
             self.bes_conn.logout()
@@ -254,7 +301,7 @@ class BESCLInterface(Cmd):
 
     def do_debug(self, setting):
         """Enable or Disable Debug Mode"""
-        print(bool(setting))
+        self.poutput(bool(setting))
         self.debug = bool(setting)
         self.echo = bool(setting)
         self.quiet = bool(setting)
@@ -288,12 +335,12 @@ class BESCLInterface(Cmd):
         """save current config to file"""
         self.do_saveconf(arg)
 
-    def do_saveconf(self, arg=None):
+    def do_saveconf(self, _=None):
         """save current config to file"""
         if not self.bes_conn:
             self.do_login()
         if not self.bes_conn:
-            print("Can't save config without working login")
+            self.poutput("Can't save config without working login")
         else:
             conf_file_path = self.conf_path
             self.pfeedback(f"Saving Config File to: {conf_file_path}")
@@ -304,29 +351,31 @@ class BESCLInterface(Cmd):
         """List the current settings and connection status"""
         self.do_ls(arg)
 
-    def do_ls(self, arg=None):
+    def do_ls(self, _=None):
         """List the current settings and connection status"""
-        print("        Connected: " + str(bool(self.bes_conn)))
-        print(
+        self.poutput("        Connected: " + str(bool(self.bes_conn)))
+        self.poutput(
             "  BES_ROOT_SERVER: "
             + (self.BES_ROOT_SERVER if self.BES_ROOT_SERVER else "")
         )
-        print(
+        self.poutput(
             "    BES_USER_NAME: " + (self.BES_USER_NAME if self.BES_USER_NAME else "")
         )
-        print(
+        self.poutput(
             "  Password Length: "
             + str(len(self.BES_PASSWORD if self.BES_PASSWORD else ""))
         )
-        print(" Config File Path: " + self.conf_path)
+        self.poutput(" Config File Path: " + self.conf_path)
         if self.bes_conn:
-            print("Current Site Path: " + self.bes_conn.get_current_site_path(None))
+            self.poutput(
+                "Current Site Path: " + self.bes_conn.get_current_site_path(None)
+            )
 
-    def do_error_count(self, arg=None):
+    def do_error_count(self, _=None):
         """Output the number of errors"""
         self.poutput(f"Error Count: {self.num_errors}")
 
-    def do_exit(self, arg=None):
+    def do_exit(self, _=None):
         """Exit this application"""
         self.exit_code = self.num_errors
         # no matter what I try I can't get anything but exit code 0 on windows
@@ -347,7 +396,7 @@ class BESCLInterface(Cmd):
                 self.pfeedback("A: ")
                 self.poutput(rel_result)
 
-    def do_version(self, statement=None):
+    def do_version(self, _=None):
         """output version of besapi"""
         self.poutput(f"besapi version: {__version__}")
 
@@ -361,7 +410,7 @@ class BESCLInterface(Cmd):
         result_op = self.bes_conn.get_user(statement)
         self.poutput(result_op)
 
-    def do_get_current_site(self, statement=None):
+    def do_get_current_site(self, _=None):
         """output current site path context"""
         self.poutput(
             f"Current Site Path: `{ self.bes_conn.get_current_site_path(None) }`"
@@ -375,11 +424,11 @@ class BESCLInterface(Cmd):
 
     def do_get_content(self, resource_url):
         """get a specific item by resource url"""
-        print(self.bes_conn.get_content_by_resource(resource_url))
+        self.poutput(self.bes_conn.get_content_by_resource(resource_url))
 
     def do_export_item_by_resource(self, statement):
         """export content itemb to current folder"""
-        print(self.bes_conn.export_item_by_resource(statement))
+        self.poutput(self.bes_conn.export_item_by_resource(statement))
 
     def do_export_site(self, site_path):
         """export site contents to current folder"""
@@ -387,7 +436,7 @@ class BESCLInterface(Cmd):
             site_path, verbose=True, include_site_folder=False, include_item_ids=False
         )
 
-    def do_export_all_sites(self, statement=None):
+    def do_export_all_sites(self, _=None):
         """export site contents to current folder"""
         self.bes_conn.export_all_sites(verbose=False)
 
@@ -409,47 +458,58 @@ class BESCLInterface(Cmd):
     def do_upload(self, file_path):
         """upload file to root server"""
         if not os.access(file_path, os.R_OK):
-            print(file_path, "is not a readable file")
+            self.poutput(file_path, "is not a readable file")
         else:
             upload_result = self.bes_conn.upload(file_path)
-            print(upload_result)
-            print(self.bes_conn.parse_upload_result_to_prefetch(upload_result))
+            self.poutput(upload_result)
+            self.poutput(self.bes_conn.parse_upload_result_to_prefetch(upload_result))
 
     complete_create_group = Cmd.path_complete
 
     def do_create_group(self, file_path):
         """create bigfix group from bes file"""
         if not os.access(file_path, os.R_OK):
-            print(file_path, "is not a readable file")
+            self.poutput(file_path, "is not a readable file")
         else:
-            print(self.bes_conn.create_group_from_file(file_path))
+            self.poutput(self.bes_conn.create_group_from_file(file_path))
 
     complete_create_user = Cmd.path_complete
 
     def do_create_user(self, file_path):
         """create bigfix user from bes file"""
         if not os.access(file_path, os.R_OK):
-            print(file_path, "is not a readable file")
+            self.poutput(file_path, "is not a readable file")
         else:
-            print(self.bes_conn.create_user_from_file(file_path))
+            self.poutput(self.bes_conn.create_user_from_file(file_path))
 
     complete_create_site = Cmd.path_complete
 
     def do_create_site(self, file_path):
         """create bigfix site from bes file"""
         if not os.access(file_path, os.R_OK):
-            print(file_path, "is not a readable file")
+            self.poutput(file_path, "is not a readable file")
         else:
-            print(self.bes_conn.create_site_from_file(file_path))
+            self.poutput(self.bes_conn.create_site_from_file(file_path))
 
     complete_update_item = Cmd.path_complete
 
     def do_update_item(self, file_path):
         """update bigfix content item from bes file"""
         if not os.access(file_path, os.R_OK):
-            print(file_path, "is not a readable file")
+            self.poutput(file_path, "is not a readable file")
         else:
-            print(self.bes_conn.update_item_from_file(file_path))
+            self.poutput(self.bes_conn.update_item_from_file(file_path))
+
+    def do_serverinfo(self, _=None):
+        """get server info and return formatted"""
+
+        # not sure what the minimum version for this is:
+        result = self.bes_conn.get("serverinfo")
+
+        result_json = json.loads(result.text)
+
+        self.poutput(f"\nServer Info for {self.BES_ROOT_SERVER}")
+        self.poutput(json.dumps(result_json, indent=2))
 
 
 def main():

{besapi-3.7.7 → besapi-3.8.1}/tests/tests.py

@@ -91,6 +91,37 @@ assert b"<BES>Example</BES>" in rest_result.xmlparse_text("<BES>Example</BES>")
 
 assert rest_result.text == "this is just a test"
 
+# test date parsing function:
+assert 2017 == besapi.besapi.parse_bes_modtime("Tue, 05 Sep 2017 23:31:48 +0000").year
+
+# test action combined relevance
+assert (
+    "( ( True ) AND ( windows of operating system ) ) AND ( False )"
+    == besapi.besapi.get_action_combined_relevance(
+        ["True", "windows of operating system", "False"]
+    )
+)
+
+# test target xml
+assert "<CustomRelevance>False</CustomRelevance>" == besapi.besapi.get_target_xml()
+assert "<AllComputers>true</AllComputers>" == besapi.besapi.get_target_xml(
+    "<AllComputers>"
+)
+assert "<ComputerID>1</ComputerID>" == besapi.besapi.get_target_xml(1)
+assert (
+    "<CustomRelevance><![CDATA[not windows of operating system]]></CustomRelevance>"
+    == besapi.besapi.get_target_xml("not windows of operating system")
+)
+assert (
+    "<ComputerID>1</ComputerID><ComputerID>2</ComputerID>"
+    == besapi.besapi.get_target_xml([1, 2])
+)
+assert (
+    "<ComputerName>Computer 1</ComputerName><ComputerName>Another Computer</ComputerName>"
+    == besapi.besapi.get_target_xml(["Computer 1", "Another Computer"])
+)
+
+# test bescli:
 import bescli
 
 bigfix_cli = bescli.bescli.BESCLInterface()
@@ -151,8 +182,10 @@ if bigfix_cli.bes_conn:
             'CMD /C python -m besapi ls clear ls conf "query number of bes computers" version error_count exit',
             check=True,
         )
-        bes_conn = besapi.besapi.get_bes_conn_using_config_file()
-        print("login succeeded:", bes_conn.login())
+
+    bes_conn = besapi.besapi.get_bes_conn_using_config_file()
+    print("login succeeded:", bes_conn.login())
+    assert bes_conn.login()
 
 # test plugin_utilities:
 print(besapi.plugin_utilities.get_invoke_folder())