Create Script Extension Attribute via API?

I haven't had the chance to look over your entire script and digest it, but I see two things that immediately stand out to me.

One, if you are iterating numbers to use for the IDs for the new Extension Attributes as it loops with the _count variable, which is what it looks like, that's not the proper method. To create any new object in Jamf Pro using the API, use an ID of 0. This tells the server that it should assign a new ID to it as it creates it. The server figures out what the next ID is it can use on its own.

Two, I believe the script itself must be encoded, to convert characters that are illegal in xml to ones that are legal. I may be wrong, but when I look at any script based Extension Attributes on our Jamf Pro 10.10.1 instance, they are encoded. For example, any hard returns in the script show as 
, and the < and > symbols turn into < and > respectively. And there are others besides those two. So I have a feeling that might be necessary to accept the XML during a POST.

Unfortunately I can't guide you on that conversion, if that's necessary to do. The perl command I use for similar encoding only works on single strings, not whole files, and doesn't do the same type of encoding anyway.

@mm2270

1. You are correct. Thanks for that info.
2. On it. Just needed to be pointed in a direction.

Thanks a bunch!

EDIT: I can just pull down some new xml. It has all the encoding, I removed it.

In case you need more, I actually found a command that does the trick. Again using perl, but a different one than the one I mentioned above.

This works on a whole file. In my testing, what I did was output a script into /tmp/ and then in the same script I did this to create an encoded variable for the entire script

1ENCODED_SCRIPT=$(perl -p -e 'BEGIN { use CGI qw(escapeHTML); } $_ = escapeHTML($_);' /tmp/SCRIPT_1.sh)

Obviously change /tmp/SCRIPT_1.sh to another variable or name as needed.

From there, I used that to create the XML file, like so:

1cat << EOEA > /tmp/EA_1.xml
2<computer_extension_attribute>
3    <id>0</id>
4    <name>Example EA</name>
5    <description>Example</description>
6    <data_type>String</data_type>
7    <input_type>
8        <type>script</type>
9        <platform>Mac</platform>
10        <script>
11        ${ENCODED_SCRIPT}
12        </script>
13    </input_type>
14    <inventory_display>Extension Attributes</inventory_display>
15    <recon_display>Extension Attributes</recon_display>
16</computer_extension_attribute>
17EOEA

Note the ${ENCODED_SCRIPT} variable where the actual script would go.
I then used a POST command to upload it, and voila! It shows up in my Jamf Pro console correctly.

It's just an example to make sure it actually works. Would still need to be tested against more complex scripts, but I think this should work.

@mm2270

A couple few questions?
1. Can I see the encoded output?
2. Can I see your curl expression (or Python expressions) for uploading to your JSS instance?

After figuring out how to install CPAN and installing the CGI module, the encoding part seems to-- maybe-- work ok, though I noticed in the raw xml from a GET request with curl, that line breaks were encoded (like you mentioned). Getting Unsupported media type error for the upload to JSS.

EDIT: I'm not getting a numerical status error, just some html telling me so.

Encode example:

1#!/bin/bash
2
3id_path=/usr/local/ORG
4id_file=.ms8
5
6if [[ -f "$id_path"/"$id_file" ]]; then
7  echo <result>true</result>
8fi

What my code is doing:
- iterating over array of attribute_names
- printing the extension attribute script body to a file. attribute_names are used to make the script unique to a group
- encode the extension attribute script body file in a variable
- POST the actual extension attribute not as a file (not required, just emphasized). attribute_name is used to make the actual extension attribute unique to group

Tried:
- Accept: application/xml, Accept: text/xml
- --data, --data-binary
With curl

Code:

1#!/bin/bash -x                                                                                                        
2
3_password=''
4_user=''
5_credentials="$(printf "$_user:$_password" | iconv -t ISO-8859-1 | base64 -i -)"
6_urlPrefix="https://orgname.jamfcloud.com/JSSResource"
7_urlInclude="$(echo computerExtensionAttributes | tr '[A-Z]' '[a-z]')/id"
8_xmlPath="${HOME}/.tps/Scratch/JAMF/extAttributes"
9
10
11attribute_names=( 'finanace' 'development' 
12                             'facilities' 'front_office' 
13                             'technology' 'faculty' 'staff' 
14                             'student' 'blt' 'admissions' 
15                             'communications' 'heads' 'humanresources' 
16                             'art' 'spanish' 'physed' 'pka' 'pkb' 'ka' 'kb' 
17                             'pa' 'pb' 'pc' 'pd' '3a' '3b' 'jua' 'jub' 'jud' 
18                             'juc' 'ms6' 'ms7' 'ms8' )
19
20
21for _name in "${attribute_names[@]}"; do
22
23    printf "%s
24" 
25"#!/bin/bash                                                                                        
26
27 id_path=/usr/local/ORG                                                                                      
28 id_file=.${_name}                                                                                                    
29
30 if [[ -f "$id_path"/"$id_file" ]]; then                                                                        
31   echo <result>true</result>                                                                                         
32 fi" > ${_xmlPath}/${_name}_ea.sh
33
34    _encoded_script=$(perl -p -e 'BEGIN { use CGI qw(escapeHTML); } $_ = escapeHTML($_);' 
35                           ${_xmlPath}/${_name}_ea.sh)
36
37    curl -X POST 
38         "${_urlPrefix}"/"${_urlInclude}"/0 
39         --header "Authorization: Basic ${_credentials}" 
40         --header "Accept: application/xml" 
41         --data  "<computer_extension_attribute>                                                                      
42<id>0</id>                                                                                                            
43<name>Group File ${_name}?</name>                                                                                     
44<description>looks for /usr/local/TPS/.${_name}</description>                                                         
45<data_type>String</data_type>                                                                                         
46<input_type>                                                                                                          
47<type>script</type>                                                                                                   
48<platform>Mac</platform>                                                                                              
49<script>                                                                                                              
50${_encoded_script}                                                                                                    
51</script>                                                                                                             
52</input_type>                                                                                                         
53<inventory_display>Extension Attributes</inventory_display>                                                           
54<recon_display>Extension Attributes</recon_display>                                                                   
55</computer_extension_attribute>"
56
57done

@mm2270

Ok, I figured it out...

I didn't think until I was speaking with a friend last night to add the --verbose flag to curl. The Content-Type was showing Content-Type: application/x-www-form-urlencoded, so I added another --header:

Content-Type: application/xml

Boom. See screenshots.

I think just using a GET requested 'template' extension attribute would have been fine (as it has all the encoding), but I need to test this.

Thanks for all your help @mm2270

EDIT: added new screenshots...couldn't see test in my original ones.

Hey @zetaomegagon An example curl command I use for uploading an xml file to the JSS would be like this:

1curl -u username:password https://your.jamf.instance.com/JSSResource/computerextensionattributes/id/0 -X POST -T /tmp/file.xml

The -T flag lets you specify a file to use as the upload, but you can also use --data flag for uploading direct data as you have it. I don't often has as much luck using a direct data upload though, so I tend to use a file.

As for the encoded script, here is the one I used in the test I mentioned above

1#!/bin/bash
2
3if [ -e "/Applications/Safari.app" ]; then
4    echo "<result>Installed</result>"
5else
6    echo "<result>Not Installed</result>"
7fi

Interestingly, the encoding here looks a bit different than the way it would appear in the Jamf Pro server, but, despite the differences, it accepted the XML and worked to create the EA for me. I guess there's no hard rule on the encoding, as long as it's something that is valid for inclusion in an XML file.

Hope the above helps.

@mm2270

Cool. That is basically how my encoding looks.

At least for curl 7.61.1, you can use --data or --data-binary and reference a file like this: @/path/to/file. I had been using the -T option as --upload-file. I like to use long options if possible, for reference, because I will have to train other members of my staff to use cli/shell in the future.

Please note: in my original script, I had tried about half a dozen options and some jenky stuff made it into the script (like: --data-binary followed by --upload-file). Original script should be considered alpha quality.

EDIT: Ah. I see --data @/path/to/file will just read the contents, where as -T|--upload-file will actually upload the file. My bad.