In the last chapter, we wrote a quick bash script that used some tools to produce diagnostics summaries for qkviews.  Now that you have some experience with the API, maybe you want to do a little bit more.  In this article, we're going to explore the data in a little more detail to give you an idea of the kinds of things you can do with the API. Generally speaking, the API methods (sometimes called 'calls') are broken into two different broad categories, "group" or "collection" methods, and then methods that deal with a single qkview ("instance methods").  In this article, we're going to cover some of the collection methods, and how to manage your qkviews. In previous articles, we've restrained ourselves from going hog-wild and kept to the nice safe methods that are essentially read-only methods.  That is, we just ask for information from the API, and then consume it and manipulate it locally, without making any changes to the data on the server. This is a nice safe way to get a handle on how the API works, without accidentally deleting anything, or changing an attribute of a QKView without meaning to.

It's time to take the training wheels off, call in the goats, and go a little wild.  Today, we'll be modifying an attribute of a QKView, or if we're feeling really crazy, we'll modify two of them, maybe even in the same HTTP request.  My palms are sweating just writing this...

Before we get that crazy, let's take a minute and talk about some collection methods first, and get that out of the way.  Collection methods can be very handy, and very powerful, as they allow you to deal with your QKViews en masse. There are three collection methods that we'll talk about, the first one is a way to get a list of all your QKView IDs.  This makes it possible to iterate over all the QKViews in your iHealth account while hunting for something.  Remember how we got our list of goats in a barn?  Similarly:


GET qkview-analyzer/api/qkviews

will return a list of qkview ids for every qkview in your ihealth account:

API will return a list of qkview ids for every qkview in your ihealth account

What if we decide we want to get rid of all our QKViews?  We could GET the list of IDs, and then iterate through them, DELETEing each one, but a collection method is much easier:


DELETE qkview-analyzer/api/qkviews

will wipe all the qkviews from your account.  Use with caution, this is the 'nuke from orbit' option.  We won't be using it in our projects for this article series, but I thought I'd mention it, as it is very handy for some situations.

Another collection method that we *will* be using is this:


POST qkview-analyzer/api/qkviews

This method allows us to add to our collection of qkviews.  Since we're using POST, remember that each time this is executed (even with the exact same qkview file), a new qkview object is created on the server.  So you'll only need to do it once for a given qkview file, unless of course, you accidentally DELETE it from your collection, and want to add it again.  I've never done anything like that, I'm just speaking hypothetically. So now armed with those collection methods, and with knowledge of our previous scripts that allowed us to examine QKView metadata, let's build up a little script that combines collection methods with some instance methods. Now, the sample qkview won't suffice for this exercise, as it is meant for demonstration purposes, and is used system-wide (and is thus read-only).  For this exercise today, we'll be using a real qkview.

This article is going to write two scripts.  The first will perform an upload of a qkview file to iHealth, using many of the techniques that we learned in our first scripting session.

  • Upload QKView script (note that all the scripts referenced in this series are included, but the one needed for this exercise is

Notice how the authentication parts all look the same?  What a great opportunity to refactor these scripts and build up an iHealth API library that our other scripts could use.  Extra credit if you take that on! So using the same authentication methods, we need to be able to specify the location of the qkview file that we want to upload. Here is a sample qkview file for you to download and use for these exercises, or feel free to pull a qkview off your own gear, and use that.

AskF5 explains how to get a QKView.

Here is where the collection method to add a qkview to our collection happens:


     96 function upload_qkview {
     97         path="$1"
     98         CURL_CMD="${CURL} ${ACCEPT_HEADER} ${CURL_OPTS} -F 'qkview=@${path}' -D /dev/stdout"
     99         [[ $DEBUG ]] && echo "${CURL_CMD}" >&2
    100         out="$(eval "${CURL_CMD}")"
    101         if [[ $? -ne 0 ]]; then
    102                 error "Couldn't retrieve diagnostics for ${qid}"
    103         fi
    104         location=$(echo "${out}" | grep -e '^Location:' | tr -d '\r\n')
    105         transformed=${location/Location: /}
    106         echo "${transformed}"

The upload will finish with an HTTP 302 redirect that points us to the new qkview.

After we upload, we cannot just immediately ask for data about the qkview, as there is a certain amount of processing that happens before we can start grilling the server about it.  While the server is busy doing all the prep work it needs to do in order to give you back data about the qkview, the server doesn't mind if we politely ask it about how things are going up there in the cloud.

To do this, we use a GET request, and the server will respond with an HTTP status code that tells our script how things are going:

our code: "ready yet?"
server  : "not yet"
our code: "ready yet?"
server  : "not yet"

sort of like kids on a car trip asking "are we there yet?" over and over and over again.  Only instead of the driver getting enraged and turning up the radio to drown them out, our server just responds politely "not yet" until it's done processing.

our code: "ready yet?"
server  : "yup, ready!"

Then our code can go about it's business.  In the programming trades, this called 'polling'.  We poll the server until the server gives us the answer we want.

our code: GET qkview-analyzer/api/qkviews/
server  : HTTP 202
our code: GET qkview-analyzer/api/qkviews/
server  : HTTP 202
our code: GET qkview-analyzer/api/qkviews/
server  : HTTP 200

So that's how to add a qkview to your collection.  Of course you might not get an HTTP 202 or 200 back, you might get something else, in which case something went wrong in either the upload or the processing.  At that point, we should also bail out, and return an error to the runner of the script:


    109 function wait_for_state {
    110         url="$1"
    111         count=0
    112         CURL_CMD="${CURL} ${ACCEPT_HEADER} ${CURL_OPTS} -w "%{http_code}" ${url}"
    113         [[ $DEBUG ]] && echo "${CURL_CMD}" >&2
    114         _status=202
    115         time_passed=0
    116         while [[ "$_status" -eq 202 ]] && [[ $count -lt ${POLL_COUNT} ]]; do
    117                 _status="$(eval "${CURL_CMD}")"
    118                 count=$((count + 1))
    119                 time_passed=$((count * POLL_WAIT))
    120                 [[ $VERBOSE ]] && echo -ne "waiting (${time_passed} seconds and counting)\r" >&2
    121                 sleep ${POLL_WAIT}
    122         done
    123         printf "\nFinished in %s seconds\n" "${time_passed}" >&2
    124         if [[ "$_status" -eq 200 ]]; then
    125                 [[ $VERBOSE ]] && echo "Success - qkview is ready"
    126         elif [[ ${count} -ge ${POLL_COUNT} ]]; then
    127                 error "Timed out waiting for qkview to process"
    128         else
    129                 error "Something went wrong with qkview processing, status: ${_status}"
    130         fi
    131 }

The script (included in the zip linked above) will allow you to update the description field of any number of qkviews with a given chassis serial number. This script will use both a collection method (list all my qkview IDs), and an instance method on several qkviews to update some metadata associated with the qkview. We've introduced yet another verb into our working lexicon, PUT.  We use PUT here, because it's a modification on a qkview that no matter how many times we perform it, will result in the same qkview state.  This is called idempotency.  Unlike, say our POST above in our upload script, which results in new qkviews every time you run it, this PUT may change the state of the qkview the first time, but subsequent identical PUT requests won't change the state further.

So now we can submit QKViews, get diagnostic results, and change metadata about the QKView.  So what else could we possibly do?  The rest of this article series will explore the data in the API and how to retreive and process it.