What to do with records.py

[Honestpuck]

After our discussion about records.py and what it might need I remembered some code I wrote a while back while playing around with JP.

Here it is. I think it might offer a solution or at least a framework for one. I think the important thing about this idea is the way it simplifies the call structure without adding much complexity. If the requests calls were replaced by the python-jamf API calls we might have something.

If people like this idea I'll tackle it this week.

#!/usr/bin/env python
#
# JPC v1.1
#
# Tony Williams 31/01/2020

"""See docstring for JPC class"""

import datetime
import logging.handlers
import plistlib
import sys
from os import path

import requests
from dicttoxml import dicttoxml

__all__ = [
    'Policy', 'Computer', 'ComputerGroup',
    'Package', 'PatchPolicy', 'PatchTitle',
    'Script']


class _logger:
    """Logging etc"""

    LOGFILE = '/usr/local/var/log/%s.log' % 'Test'
    LOGLEVEL = logging.ERROR

    now = datetime.datetime.now().strftime('%d/%m/%Y %H:%M')
    frmt = "%(levelname)s {} %(message)s".format(now)
    # set up logging
    logger = logging.getLogger('')
    # set logging formatting
    # ch = logging.StreamHandler()
    ch = logging.handlers.TimedRotatingFileHandler(
        LOGFILE, when='D', interval=7, backupCount=4)
    ch.setFormatter(logging.Formatter(frmt))
    logger.addHandler(ch)
    logger.setLevel(LOGLEVEL)

    def error(self, line):
        self.logger.error(line)

    def warning(self, line):
        self.logger.warning(line)

    def info(self, line):
        self.logger.info(line)

    def debug(self, line):
        if self.logger.getEffectiveLevel() == 10:
            print(line)
        self.logger.debug(line)


class _JPC:
    """Talks to a Jamf Cloud instance"""

    _plist = path.expanduser('~/Library/Preferences/JPCImporter.plist')
    _prefs = plistlib.readPlist(_plist)
    _auth = (_prefs['user'], _prefs['password'])
    _base = _prefs['url'] + '/JSSResource/'
    _hdrs = {'accept': 'application/json'}

    logger = _logger()

    _o_type = ''
    _l_type = ''

    def JPCError(self, line):
        self.logger.error(line)
        sys.exit(1)

    def get(self, obj):
        self._obj = obj
        self._url = self._base + obj
        ret = requests.get(self._url, auth=self._auth, headers=self._hdrs)
        self.logger.debug('GET call url: %s status: %s'
                          % (self._url, ret.status_code))
        if ret.status_code != 200:
            raise self.JPCError("GET failed URL: %s Err: %s"
                                % (self._url, ret.status_code))
        return ret.json()

    def put(self, obj, data):
        u = self._url + obj
        ret = requests.put(u, auth=self._auth,
                           headers=self._hdrs,
                           data=dicttoxml(data, root=False))
        self.logger.debug('PUT call u: %s status: %s' % (u, ret.status_code))
        if ret.status_code != 201:
            raise self.JPCError("PUT failed URL: %s Err: %s"
                                % (u, ret.status_code))
        return ret.text

    def push(self):
        data = {}
        data[self._o_type] = self.json
        ret = requests.put(self._url, auth=self._auth,
                           headers=self._hdrs,
                           data=dicttoxml(data, root=False))
        if ret.status_code != 201:
            raise self.JPCError("Push failed URL: %s Err: %s"
                                % (u, ret.status_code))
        return ret.text


class JPCObject(_JPC):
    """Parent class for an object on the cloud instance"""

    def __init__(self, *args):
        try:
            self.obj = args[0]
            self.json = self._request(self.obj)[self._o_type]
        except IndexError:
            self.obj = None
            self.json = self._request(self.obj)[self._l_type]

    def _get_list(self):
        return _JPC.get(self, self._l_type)

    def _get_one(self, obj):
        try:
            self.o_id = str(int(obj))
            self.o_path = self._l_type + '/id/' + self.o_id
        except ValueError:
            self.o_path = self._l_type + '/name/' + obj
        return _JPC.get(self, self.o_path)

    def _request(self, obj=None):
        if obj is None:
            return self._get_list()
        else:
            return self._get_one(obj)


class Policy(JPCObject):

    _l_type = 'policies'
    _o_type = 'policy'


class ComputerGroup(JPCObject):

    _l_type = 'computergroups'
    _o_type = 'computer'



class Computer(JPCObject):

    _l_type = 'computers'
    _o_type = 'computer'


class Package(JPCObject):

    _l_type = 'packages'
    _o_type = 'package'


class PatchTitle(JPCObject):

    _l_type = 'patchsoftwaretitles'
    _o_type = 'patchsoftwaretitle'


class PatchPolicy(JPCObject):

    _l_type = 'patchpolicies'
    _o_type = 'patchpolicy'


class Script(JPCObject):

    _l_type = 'scripts'
    _o_type = 'script'

[magnusviri]

So if I understand correctly, in this file _JPC is equivalent to API and JPCObject is equivalent to Record. So JPCObject subclasses _JPC. To make ours do the same, then Record would subclass API, right? Is that what you are proposing?

[Honestpuck]

I'm more interested in moving the get code into __init__ in the Records class but it might also be a good idea for Records to subclass API.

[magnusviri]

I'm probably going to play around with this for the next hour and see what I come up with.

[magnusviri]

Here is the Jamf objects from records.py we are going to focus on (not listed in priority order).

• Categories
• ComputerGroups
• Computers
• OSXConfigurationProfiles
• Packages
• PatchPolicies
• Policies

I don't plan on deserializing any of them in the code, but instead I'm going to write a bunch of demo/test code that actually does things we want like create new objects, list them, modify them, delete them etc. I'll probably try to simulate all of the things I do with the GUI first.

[Honestpuck]

@magnusviri Would it be possible to add Packages and AdvancedComputerSearches to that list. Oh, and is there anything I can help with.

[magnusviri]

Packages is on the list. AdvancedComputerSearches is fine. In fact, while working on it I decided to just continue to make things generic.

You could help a lot just by looking at the code and commenting on it. I know you've mainly been interested in the python library but I'm pretty excited about jctl. I just uploaded what I've been working on and here's what it can do right now.

./jctl list AdvancedComputerSearches
./jctl list AdvancedComputerSearches "REGEX"
./jctl info AdvancedComputerSearches "NAME"

Except it works with the 56 records in records.py. I haven't tested them all yet.

#30

Also, do you know if it's possible to put python stuff on homebrew? I think jctl is a perfect candidate for putting on homebrew (if it's possible).

[Honestpuck]

OK, I'll have a look at jctl tomorrow after the game. (Go Bucs!) I'll also have a look at how to get something into homebrew.