Why Start Over?

Over the years, life simply got busier.

Between work, family, and everything else that comes with life, the amount of uninterrupted time I have to spend on personal projects is much smaller than it used to be. When I do have a few free hours, I’d much rather spend them building something interesting than maintaining the platform I’m writing on.

My previous setup wasn’t particularly fragile—in fact, almost everything was automated—but it had grown into a surprisingly large stack. Just to publish a simple post, I was effectively maintaining:

• Ubuntu
• Apache
• PHP
• MySQL
• WordPress
• Themes
• Plugins
• Backups
• Security updates and monitoring
• IAM, authentication, SSO, and 2FA
• Deployment and automation scripts

That’s a lot of infrastructure for what is, at its core, a collection of Markdown articles.

Eventually I realized I was spending more time maintaining the blog than writing for it. That wasn’t the trade-off I wanted anymore.

Rediscovering Simplicity

Over the last five to six years, I’ve grown to appreciate the elegance of static websites.

Write in Markdown. Commit to Git. Deploy automatically.

That’s really all I wanted.

That, and I still wanted complete control over how the site was built, deployed, and hosted. Hugo gives me that flexibility without adding complexity.

Modern static site generators offer incredible performance, security, scalability, and deployment flexibility—all with virtually no operational overhead. There’s something satisfying about eliminating entire classes of problems simply by removing the technologies that create them. And perhaps most importantly, they eliminate an entire class of security concerns that come with running a dynamic web application.

In reality, I wasn’t looking for a full-featured publishing platform anymore. I just wanted a place to quickly share interesting projects, technical deep dives, automation ideas, and the occasional how-to—a step above a collection of GitHub Gists.

Why Hugo?

When it came time to rebuild, I evaluated just about every major static site generator I could find, including Hugo, Jekyll, Gatsby, Eleventy, Hexo, Docusaurus, and MkDocs.

Each has its strengths, but Hugo checked all the boxes for me:

• Extremely fast builds
• Simple Markdown-based workflow
• Flexible templating
• Minimal dependencies
• Easy deployment to virtually any hosting provider

I’ll save the details for another post, but Hugo felt like the right balance between power and simplicity.

The Internet Changed (Again)

Years ago, if you wanted to figure out how to do something obscure, you were often on your own.

Maybe you wanted to compile a custom Android kernel, integrate a Perl script with Amazon SES, or get Widevine DRM working on a Raspberry Pi. Those projects often took an entire weekend of research, experimentation, trial and error, and digging through forum posts before you finally had something that worked.

Those were exactly the kinds of things I enjoyed writing about.

Today, that world looks very different.

Modern LLMs from OpenAI, Anthropic, and Google can often produce a working solution after just a few prompts. They aren’t perfect, but they’re remarkably good at answering the kinds of “How do I…?” questions that used to drive people to technical blogs, along with implementing technical solutions.

That’s a good thing.

It also means the internet has changed—yet again.

A number of years ago, my college friend Mike Burns wrote an excellent post titled "The Internet Is Gone", reflecting on how the web had evolved from the one we grew up with. Reading it today, I think we’re in the middle of another major shift.

Search engines are no longer the primary destination for technical knowledge. Neither are blogs. Increasingly, people ask an AI assistant first and only reach for search engines when they need more context or verification.

That fundamentally changes the value of publishing another “How to install X on Ubuntu” tutorial.

So What Is Worth Writing?

Personally, I think straightforward technical tutorials have become a commodity.

That doesn’t mean blogging is dead—it just means the interesting parts have shifted.

LLMs are excellent at synthesizing information that’s already out there. They’re much less effective at generating genuinely new experience.

If nobody has ever tried an approach before, measured the results, compared architectures, or documented the trade-offs, there isn’t much for an AI to synthesize.

Someone still has to do the work.

The exciting part is that AI also helps us do that work faster. It accelerates research, helps validate ideas, writes code, reviews designs, and removes much of the repetitive effort involved in building something new. But it’s still up to us to ask the right questions, run the experiments, evaluate the results, and share what we learn.

What still excites me are things that AI can’t easily fully synthesize (yet):

• Experiments
• Proofs of concept
• Lessons learned
• Architectural trade-offs
• Unexpected failures
• Surprising discoveries
• Connecting ideas across different technologies
• The bigger picture

In other words, the kinds of things you only get by actually building something.

Those are the stories I want to tell.

Looking Ahead

For the last five to six years, I’ve been working almost exclusively with Generative AI.

During that time I’ve built, evaluated, or advised on hundreds of projects, prototypes, and proof-of-concepts spanning a wide range of industries and use cases.

Some succeeded.

Some failed spectacularly.

Almost all of them taught me something.

I’m hoping this blog becomes a place where I can share some of those lessons—not just prompts or snippets of code, but the design decisions, trade-offs, failures, surprises, and patterns that only become obvious after you’ve built enough of these systems.

I’ll still write about cloud infrastructure, automation, programming, open source, homelabs, and whatever technical rabbit hole I happen to be exploring.

The difference is that I probably won’t spend three pages explaining how to configure a particular tool or reproduce every command I typed along the way. AI is remarkably good at filling in those details.

Instead, I’d rather focus on why I chose a particular approach, what worked, what didn’t, the trade-offs I discovered, and the lessons I learned while building it.

Those are the parts that I still find interesting—and, hopefully, useful to others.

What Happened to the Old Blog?

I’ve archived my old site, but you can still browse all of the posts under the Old WordPress Blog tag, including the last article published on March 30, 2020.

There’s still plenty of content there that’s worth preserving, and it’s also a fun snapshot of the technologies and approaches I was using over the years. Think of it as a small piece of personal—and internet—history.

One Final Irony

Generative AI may have made many traditional technical blog posts less valuable, but it also makes writing better blog posts dramatically easier.

This article, for example, started as a handful of scattered notes and half-finished thoughts. AI helped organize them into something coherent while leaving the opinions, experiences, and perspective entirely my own.

I think that’s a pretty good use of the technology.

Welcome to the new site. It’s cleaner, simpler, faster, and, most importantly, lets me spend less time maintaining infrastructure and more time experimenting, learning, and sharing what I discover along the way.

Last Update: 3-13-21 | Official Raspberry Pi Package now available - see bellow

Last Update: 11-9-20 | Updated ventz-media-pi for new Chromium version (v.84+) and new WideVine setup: v.4.10.1679.0+ NOTE: You MUST re-download and re-run it from this date to fix - lots of changes!

Last Update: 11-2-20 | Updated libwidevinecdm.so_.zip to v.4.10.1679.0 within ventz-media-pi

Last Update: 7-22-20 | Updated .desktop with Chrome User Agent string for CrOS Chrome/77.0.3865.120

Last Update: 7-20-20 | redacted company reached out about creating an official package, also there are conversations happening with redacted company about official support of the Pi

Last Update: 5-6-20 | Specify that “Raspbian with desktop” is assumed and tested

Last Update: 4-7-20 | Fixed screen tearing

Great News - This can finally be announced:) - There is now an official Raspberry Package with this work!!

Setup everything here with:

sudo apt update
sudo apt full-upgrade
sudo apt install libwidevinecdm0

Everything from here down is the “pre-official-raspberry-package” info:

If you just want to take a Raspberry Pi 4 (as of today!) and turn it into a fully functional “Media” center by just pasting one line, here it is:

SSH to your Pi (don’t run from the Pi console if you want pretty graphics :)) and run:

curl -fsSL https://pi.vpetkov.net -o ventz-media-pi
sh ventz-media-pi

This will produce the following (click to see larger image):

Reboot, and then from the Application Menu (top left) -> go to “Internet” -> open “Chromium (Media Edition)”

You are now ready to use your Raspberry Pi on Netflix, Hulu, Amazon Prime, Disney Plus, HBO, Spotify, Pandora, and many others.

If you need to change any browser Settings, do so via the “Chromium” browser and not the “Chromium (Media Edition) - both are the same browser, so the settings are the same. The “Media Edition” (just a custom launcher with the user-agent) cannot load the settings since Chromium thinks you are launching it on “Chrome OS”, and when it checks for the Chrome OS language settings it crashes since they don’t exist.

At last, all this assumes the latest version of Raspbian with desktop (not Debian/Ubuntu! -
https://downloads.raspberrypi.org/raspbian_latest), and you can re-run the curl and sh as many times as you want without any harm.

If you are curious about some of the background and details on why you can’t easily run Netflix (and others) on your Pi and how to solve it, you are welcome to go look at my “development” blog post article: vpetkov.net/2019/07/12/netflix-and-spotify-on-a-raspberry-pi-4-with-latest-default-chromium/

Enjoy!

As of 3-30-2020, if you want the “paste-one-line-it-just-works” go to:

vpetkov.net/2020/03/30/raspberry-pi-netflix-one-line-easy-install-along-with-hulu-amazon-prime-disney-plus-hbo-spotify-pandora-and-many-others/

^^^ Please use the post linked above for my “one-line it just works” install ^^^
(Ignore everything bellow this, as it’s the original development work)

Everything from this point down is out of date as of: 3-30-2020

This was my initial “netflix on the raspberry pi 4 development” blog post. Leaving it on here due to the comments, initial work, info for those interested, but I highly recommend using the easy method above (linked).

Last libwidevine extract: 3-29-2020 - v.4.10.1610.6 of libwidevine - EVERYTHING CONFIRMED WORKING

Chromium has made substantial changes the way libwidevine (and a few major things around DRM) are loaded/used/etc. They have also made changes to the setting and reading of the user-agent propagation. For some time (~2 months or so) - the combination of this badly broke Netflix. It seems they have undone the lib loading in the last couple of versions, and user @Spartacuss discovered the user-agent fix.

The instructions here (as of 3-29-2020) work for: Netflix, Hulu, HBO, Disney+, Amazon Prime, Spotify, Pandora, and many others.

The Raspberry Pi 4 model with 4GB of RAM is the first cheap hardware that can provide a real “desktop-like” experience when browsing the web/watching Netflix/etc. However, if you have tried to run Netflix on the Pi, you have quickly entered the disgusting mess that exists around DRM, WideVine (Netflix being one example of something that needs it), and Chromium.

After hours and hours of effort, I finally discovered a quick and elegant solution that lets you use the latest default provided Chromium browser, without having to recompile anything in order to watch any WideVine/DRM (Netflix, Spotify, etc) content.

Background and the DRM Problem

If you are not familiar with this, the short version is that Netflix (and many others, ex: Spotify) use the WideVine “Content Protection System” - aka DRM, and if you want to watch Netflix or something else that uses it, you need to have a WideVine plugin+browse supported integration. Chrome, Firefox, and Safari make it available for x86/amd64 systems, but not for ARM since technically they don’t have ARM builds.

Chromium, the project Chrome is based on, does have an ARM build, but it does not include any DRM support, and technically it does not include widevine support by default (*caveat here, which helps us later)
So long story short, the question becomes “how do you enable DRM/WideVine support in Chromium?”.

It seems there are two main solutions out there: use an old (v51, 55, 56, 60) version of Chromium which has been “patched” with widevine support (kusti8’s version seems to be the most popular one - except since the new Netflix changes, that also does not work), which requires uninstalling the latest Chromium available, installing the old/patched one, and dropping in older widevine plugins; the second option is to use Vivaldi - a proprietary fork of Opera which also has been “sort of patched”, but it still needs a valid libwidevinecdm plugin (see bellow) and it has it’s own issues (and also…it’s Opera…in 2019…who uses Opera?)

After a lot of research and trial and error, I discovered a much more elegant solution - use the extracted ChromeOS (armv7l - yay) binaries and insert them into Chromium + make everything think it’s ChromeOS (user agent)

Netflix/Hulu/Spotify with the Default Raspberry Pi Chromium Browser

Enough theory - let’s do this in 2 quick steps!
0.) If you have tried Netflix/etc already, open Chromium and clear your browser history + cookies. Otherwise it will cache the “failed” DRM components.

1.) Download the latest extracted ChromeOS libwidevine binary and extract it:

$ sudo su
# cd /usr/lib/chromium-browser
# wget https://media.vpetkov.net/wp-content/uploads/2020/03/libwidevinecdm.so_.zip
# unzip libwidevinecdm.so_.zip && chmod 755 libwidevinecdm.so
# wget https://media.vpetkov.net/wp-content/uploads/2020/03/chromium-media-browser.desktop.zip
# unzip chromium-media-browser.desktop.zip && mv chromium-media-browser.desktop /usr/share/applications

NOTE: Credit and thanks to @Spartacuss for discovering user-agent method with .desktop file!

NOTE: You can verify that these are the official versions from ChromeOS:
https://dl.google.com/dl/edgedl/chromeos/recovery/chromeos_12739.105.0_elm_recovery_stable-channel_mp-v2.bin.zip

NOTE: UPDATED (Last re-extracted from ChromeOS on: 3-23-20)
version: 4.10.1610.6 (see optional script below how to check version)
filename: libwidevinecdm.so
md5sum: 6857e5f102651bfa977eb739b86bf75e
sha256sum: 678c21b5ebf459919f9dcde100af8f59e580b6bed56b1cae1ae5eb43a7029e17

2.) Completely QUIT all Chromium windows.
Start Chromium with the new Application Menu under “Internet”: Chromium (Media Edition)
Open a new tab, and go to: https://bitmovin.com/demos/drm You should be able to see the movie on the left.(While this still works, it will show “No DRM” unless you set the Chromium user-agent from within the app - which breaks Netflix. BitMoving unfortunately looks for that first. Just go to Netflix/Your media source directly.)
You can now play Netflix, Hulu, HBO, Spotify, Pandora, Disney+, Amazon Prime, and many others!

Please note that If you can see the video on the left, this means the DRM plugin has worked! From this point on, anything that does not work (ex: Netflix sometimes breaks after a browser update) is due to the site specifically filtering User Agents/doing other “tricks”. So for example, if Netflix does not work, Spotify, Pandora, Hulu, Amazon Prime, HBO, etc will still work. The BitMovin website is the “real” test on wether the DRM plugin has worked.(While still technically true, if your Chromium user-agent is not set from within the app itself, which breaks Netflix, BitMovin will show “No DRM” even though the DRM decryption works)

Solution for the occasional “screen tearing”

Updated: 4-7-2020

$ sudo rm /etc/xdg/autostart/xcompmgr.desktop
$ sudo reboot

It seems the Pi’s raw CPU frequency is still not powerful enough for decoding 100% of the time. While 97-98% of the time is good enough, you will get the occasional “screen tearing” (https://en.wikipedia.org/wiki/Screen_tearing), especially in scenes with fast motion.

~~Users Otaku, DM (and thanks to Luca for testing/extra info!) have found a solution which was mentioned on https://lb.raspberrypi.org/forums/viewtopic.php?t=246179 by user Greysvandir.
I had to add a few more things and I created a compressed and slightly automated 😉 version:
# sudo apt install -f compton
$ mkdir -p ~/.config/lxsession/LXDE-pi
$ cd ~/.config && wget https://raw.githubusercontent.com/dastorm/Compton-xfce-config/master/compton.conf
$ cp -f /etc/xdg/lxsession/LXDE-pi/autostart ~/.config/lxsession/LXDE-pi/autostart
$ echo “@usr/bin/compton –backend glx” » /.config/lxsession/LXDE-pi/autostart
$ echo “xrandr –output HDMI-1 –mode 1280x720” » /.config/lxsession/LXDE-pi/autostart
The result is no tearing with 1080p@60fps video.

(Optional) Get libwidevinecdm version

If you want to check your *actual* libwidevinecdm version, the easiest and quickest way is using user VMX’s elegant python solution:

# cd /usr/lib/chromium-browser
# python -c 'import ctypes;
> lib = ctypes.cdll.LoadLibrary("./libwidevinecdm.so");
> lib.GetCdmVersion.restype = ctypes.c_char_p;
> print(lib.GetCdmVersion())'

This will give you the version:
4.10.1610.6

Alternatively, if for some reason you want to, you can compile a binary (C) checker by:

a.) Create a file called “get_cdm_version.c with:

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
int main(int argc, char *argv[]) {
  void *handle;
  const char *(*get_cdm_version)();

  handle = dlopen("./libwidevinecdm.so", RTLD_LAZY);
  if (!handle) {
    fprintf(stderr, "%s\n", dlerror());
    exit(EXIT_FAILURE);
  }

  get_cdm_version = dlsym(handle, "GetCdmVersion");
  if (!get_cdm_version) {
    fprintf(stderr, "%s\n", dlerror());
    exit(EXIT_FAILURE);
  }

  printf("%s\n", get_cdm_version());
  dlclose(handle);
  exit(EXIT_SUCCESS);
}

b.) Compile the binary with: gcc get_cdm_version.c -o get_cdm_version -ldl

If you want a binary version for some reason (I don’t know why you would given python method), and you can’t compile it yourself, and you trust me (why?!), feel free to grab my already compiled version:

$ wget https://media.vpetkov.net/wp-content/uploads/2020/03/get_cdm_version.zip
$ unzip -f get_cdm_version.zip
$ chmod 755 get_cdm_version

c.) Place a copy of the libwidevinecdm.so in the same directory as your binary
d.) Run it

./get_cdm_version
4.10.1610.6

^^ Here the Version is: 4.10.1610.6

(Optional) Older Versions

Here are the last few OLDER versions in case you need them (note the unique date in the url):
libwidevinecdm.so (2019/09)
libwidevinecdm.so (2019/08)
libwidevinecdm.so (2019/07)

A few hours ago it was discovered that Apple’s FaceTime app allows anyone to connect to any Apple device that supports FaceTime and hear their audio without the person ever accepting the call. What’s worse (debatably?) is that it is incredibly easy to do this.

Listen-in on any remote Apple device in 4 steps

1.) Start a FaceTime call with someone
2.) While the call is “connecting”, quickly swipe up on the FaceTime menu
3.) Click on the “+ Add Person”
4.) Add your own phone number/contact

What happens at this point is that the call is “bridged” and a remote audio line is open to the destination Apple device.

Yes - really! You have now turned the remote Apple device into a remote audio tap/bug. You can choose to keep a 2-way audio channel, or mute it from your side.

Update #1: Apparently it works on Mac OS Mojave too.

Temporary Fix - disable FaceTime

As of right now, until Apple patches this, the only fix is to disable FaceTime:

iOS

1.) open “Settings”
2.) click on “FaceTime”
3.) toggle it “off” (green toggle -> to white)

Mac OS Mojave

1.) open “FaceTime” app
2.) press “command + K”
or
2.) click on the top-left menu bar with the app name “FaceTime”, and select “Turn FaceTime Off”

The script was simple and it worked very well. It made dealing with plugins many times easier. However, there was one big down side as some users pointed out - it did not actually check if a plugin needed to be updated. It blindly replaced the current plugin with the latest version. This meant that there was no way to “efficiently” automate it. If you cron-ed it directly, it would simply pull and update all your plugins at whatever period you specified. For the longest time this really irritated me, but I didn’t have time to dig through WordPress to understand how the engined checked and signaled for local plugins. One particular user (Joel) forked a copy and made many improvements to deal with this specific issue.

As time went on, I decided to look at this problem again. A couple of years ago I solved it in a really elegant way, but I didn’t have time to update the blog post. A few days ago, after looking at the blog statistics, I realized that the WordPress article was one of the top 10 most popular ones. So, with that said, here is:

A new simple and elegant solution

The idea is to use the WordPress CLI in order to “query” the local plugins database for plugin names, version number, and “activated” status, and then compare the “local” plugin version with the “remote” plugin version. If the plugin is active and in need of an update, fall back to my original Perl script to update it. Aha! And now we have something that can be cron-ed 🙂

To get started, first grab the WP CLI utility. We are going to rename it, move it to an accessible place, and take care of permissions so that we can use it:

curl -O  https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar
sudo mv wp-cli.phar /usr/local/bin/wp && chmod +x /usr/local/bin/wp

Now, grab the Perl script (vpetkov.net/2011/08/03/script-to-upgrade-plugins-on-wordpress-to-the-latest-version-fully-automatically/) and save it as:

/usr/local/bin/update-wp-plugins.pl

Finally, you can simply run:

# create a file: /usr/local/bin/check-wp-plugins.sh

/usr/local/bin/wp plugin list --format=csv \
--status=active --update=available \
--path=/var/www/wordpress-blog \
--fields=name \
| egrep -v '^name$' | xargs -L1 /usr/local/bin/update-wp-plugins.pl

This will check the plugins for activate ones that have an update available (local version doesn’t match remote) and extract them + feed them to my perl script to have them update.

If you save the final script as let’s say “check-wp-plugins.sh” in /usr/local/bin, you can simply run a cron job with:

0 0 * * 0 /usr/local/bin/check-wp-plugins.sh

You have to admit - this is just beautiful!

In this day and age where everything is measured, recorded, and available remotely (via a REST API most of the time!), it really bothered me that our heating oil tank measured the remaining gallons of oil by a crude plastic dip stick. It’s not accurate, there is no historical data, and there is no way to audit (for honesty, accuracy, or problems/errors).

So the problem is simple enough: Find a quick and easy way to remotely monitor the number of gallons of heating oil in a home, and alert at pre-set intervals (let’s say 75%, 50%, and 25%) of remaining oil in the tank.

After looking for commercial solutions, the cheapest one I found is $120 with a $10/year fee. In my view, that’s simply ridiculous. I decided that I could build something better for 1/3rd of the price ($40), without an yearly fee.

Hardware How-To

Start with this Instructable I created with the exact parts/steps, and with lots of pictures:
https://www.instructables.com/id/Monitor-Heating-Oil-Tank-Gallons-With-Email-SMS-an/

This should take care of the hardware side.

Firmware code and How-To Access Data

Once you have it built - flash your Photon with the code here (see bellow - large code paste).

After that, you should be able to do this from the particle CLI (replace $device-id-here$ with actual device #):

# This will tell you how many inches away from the sensor the oil is. It is the only "100% accurate" (non-calculated, but actually measured that is)
particle get $device-id-here$ distance

# This is calculated based on the first one and assuming a 275 gallon tank:
particle get $device-id-here$ oil-inches

# And using well known charts (like this: http://www.adamspetro.com/residential-heating-tank-chart), gallons are calculated:
particle get $device-id-here$ oil-gallons

# You can also get a real time stream (every 10 seconds with current firmware code):
particle subscribe oil-gallons mine

If you have not used the Particle Photon, I am going to provide some additional information on the bottom of this post that will walk you through building/flashing the code, and how to setup the web hook. I have also added a lot of pictures of this on the Instructables page to go with the steps.

Particle Photon web IDE code:

// By: Ventz Petkov
// LAST UPDATED: 10-27-2018
// This #include statement was automatically added by the Particle IDE.
#include <HC_SR04.h>

double inches = 0.0;
double inches_of_oil = 0.0;
double gallons_of_oil = 0.0;

int trigPin = D0;
int echoPin = D1;


int alert1 = 1;
int alert2 = 1;
int alert3 = 1;
int alert4 = 1;
int alert5 = 1;
int alert6 = 1;
int refill_alert = 1;
/*
Connect an HC-SR04 Range finder as follows:
Spark   HC-SR04
GND     GND
5V      VCC
D0     Trig
D1      Echo

The default usable rangefinder is 10cm to 250cm. Outside of that range -1 is returned as the distance.

You can change this range by supplying two extra parameters to the constructor of minCM and maxCM, like this:

HC_SR04 rangefinder = HC_SR04(trigPin, echoPin, 5.0, 300.0);

Inches of oil to gallons:
http://www.adamspetro.com/residential-heating-tank-chart

*/

HC_SR04 rangefinder = HC_SR04(trigPin, echoPin);

void setup() 
{
    // NOTE: distance is the only TRUE/"non-calculated" measurement away from the sensor
    Particle.variable("distance", inches);
    Particle.variable("oil-inches", inches_of_oil);
    // NOTE: When comparing with physical oil gauges, always read it at the TOP of the "wedge" if it's not a thin "line" type of gague.
    Particle.variable("oil-gallons", gallons_of_oil);
}

void loop() 
{
    /*
    NOTE: This assumes a 275 Gallon Vertical Oil tank - the most popular residential ("home") tank.
          If you have something else, please modify the inches to gallons bellow per the provided URL chart.
          The max capacity on a 275 gallon tank is 266 gallons, and most companies fill it up to 250-255 gallons.
    */

    inches = rangefinder.getDistanceInch(); inches = rangefinder.getDistanceInch();
    inches_of_oil = round((45.89 - inches)*10)/10;
    
    if(inches_of_oil == 44) { gallons_of_oil = 275; }
    else if(inches_of_oil == 43.9) { gallons_of_oil = 274.7; }
    else if(inches_of_oil == 43.8) { gallons_of_oil = 274.4; }
    else if(inches_of_oil == 43.7) { gallons_of_oil = 274.1; }
    else if(inches_of_oil == 43.6) { gallons_of_oil = 273.8; }
    else if(inches_of_oil == 43.5) { gallons_of_oil = 273.5; }
    else if(inches_of_oil == 43.4) { gallons_of_oil = 273.2; }
    else if(inches_of_oil == 43.3) { gallons_of_oil = 272.9; }
    else if(inches_of_oil == 43.2) { gallons_of_oil = 272.6; }
    else if(inches_of_oil == 43.1) { gallons_of_oil = 272.3; }
    else if(inches_of_oil == 43) { gallons_of_oil = 272; }
    else if(inches_of_oil == 42.9) { gallons_of_oil = 271.6; }
    else if(inches_of_oil == 42.8) { gallons_of_oil = 271.2; }
    else if(inches_of_oil == 42.7) { gallons_of_oil = 270.8; }
    else if(inches_of_oil == 42.6) { gallons_of_oil = 270.4; }
    else if(inches_of_oil == 42.5) { gallons_of_oil = 270; }
    else if(inches_of_oil == 42.4) { gallons_of_oil = 269.6; }
    else if(inches_of_oil == 42.3) { gallons_of_oil = 269.2; }
    else if(inches_of_oil == 42.2) { gallons_of_oil = 268.8; }
    else if(inches_of_oil == 42.1) { gallons_of_oil = 268.4; }
    else if(inches_of_oil == 42) { gallons_of_oil = 268; }
    else if(inches_of_oil == 41.9) { gallons_of_oil = 267.6; }
    else if(inches_of_oil == 41.8) { gallons_of_oil = 267.2; }
    else if(inches_of_oil == 41.7) { gallons_of_oil = 266.8; }
    else if(inches_of_oil == 41.6) { gallons_of_oil = 266.4; }
    else if(inches_of_oil == 41.5) { gallons_of_oil = 266; }
    else if(inches_of_oil == 41.4) { gallons_of_oil = 265.6; }
    else if(inches_of_oil == 41.3) { gallons_of_oil = 265.2; }
    else if(inches_of_oil == 41.2) { gallons_of_oil = 264.8; }
    else if(inches_of_oil == 41.1) { gallons_of_oil = 264.4; }
    else if(inches_of_oil == 41) { gallons_of_oil = 264; }
    else if(inches_of_oil == 40.9) { gallons_of_oil = 263.5; }
    else if(inches_of_oil == 40.8) { gallons_of_oil = 263; }
    else if(inches_of_oil == 40.7) { gallons_of_oil = 262.5; }
    else if(inches_of_oil == 40.6) { gallons_of_oil = 262; }
    else if(inches_of_oil == 40.5) { gallons_of_oil = 261.5; }
    else if(inches_of_oil == 40.4) { gallons_of_oil = 261; }
    else if(inches_of_oil == 40.3) { gallons_of_oil = 260.5; }
    else if(inches_of_oil == 40.2) { gallons_of_oil = 260; }
    else if(inches_of_oil == 40.1) { gallons_of_oil = 259.5; }
    else if(inches_of_oil == 40) { gallons_of_oil = 259; }
    else if(inches_of_oil == 39.9) { gallons_of_oil = 258.5; }
    else if(inches_of_oil == 39.8) { gallons_of_oil = 258; }
    else if(inches_of_oil == 39.7) { gallons_of_oil = 257.5; }
    else if(inches_of_oil == 39.6) { gallons_of_oil = 257; }
    else if(inches_of_oil == 39.5) { gallons_of_oil = 256.5; }
    else if(inches_of_oil == 39.4) { gallons_of_oil = 256; }
    else if(inches_of_oil == 39.3) { gallons_of_oil = 255.5; }
    else if(inches_of_oil == 39.2) { gallons_of_oil = 255; }
    else if(inches_of_oil == 39.1) { gallons_of_oil = 254.5; }
    else if(inches_of_oil == 39) { gallons_of_oil = 254; }
    else if(inches_of_oil == 38.9) { gallons_of_oil = 253.4; }
    else if(inches_of_oil == 38.8) { gallons_of_oil = 252.8; }
    else if(inches_of_oil == 38.7) { gallons_of_oil = 252.2; }
    else if(inches_of_oil == 38.6) { gallons_of_oil = 251.6; }
    else if(inches_of_oil == 38.5) { gallons_of_oil = 251; }
    else if(inches_of_oil == 38.4) { gallons_of_oil = 250.4; }
    else if(inches_of_oil == 38.3) { gallons_of_oil = 249.8; }
    else if(inches_of_oil == 38.2) { gallons_of_oil = 249.2; }
    else if(inches_of_oil == 38.1) { gallons_of_oil = 248.6; }
    else if(inches_of_oil == 38) { gallons_of_oil = 248; }
    else if(inches_of_oil == 37.9) { gallons_of_oil = 247.4; }
    else if(inches_of_oil == 37.8) { gallons_of_oil = 246.8; }
    else if(inches_of_oil == 37.7) { gallons_of_oil = 246.2; }
    else if(inches_of_oil == 37.6) { gallons_of_oil = 245.6; }
    else if(inches_of_oil == 37.5) { gallons_of_oil = 245.0; }
    else if(inches_of_oil == 37.4) { gallons_of_oil = 244.4; }
    else if(inches_of_oil == 37.3) { gallons_of_oil = 243.8; }
    else if(inches_of_oil == 37.2) { gallons_of_oil = 243.2; }
    else if(inches_of_oil == 37.1) { gallons_of_oil = 242.6; }
    else if(inches_of_oil == 37) { gallons_of_oil = 242; }
    else if(inches_of_oil == 36.9) { gallons_of_oil = 241.3; }
    else if(inches_of_oil == 36.8) { gallons_of_oil = 240.6; }
    else if(inches_of_oil == 36.7) { gallons_of_oil = 239.9; }
    else if(inches_of_oil == 36.6) { gallons_of_oil = 239.2; }
    else if(inches_of_oil == 36.5) { gallons_of_oil = 238.5; }
    else if(inches_of_oil == 36.4) { gallons_of_oil = 237.8; }
    else if(inches_of_oil == 36.3) { gallons_of_oil = 237.1; }
    else if(inches_of_oil == 36.2) { gallons_of_oil = 236.4; }
    else if(inches_of_oil == 36.1) { gallons_of_oil = 235.7; }
    else if(inches_of_oil == 36) { gallons_of_oil = 235; }
    else if(inches_of_oil == 35.9) { gallons_of_oil = 234.3; }
    else if(inches_of_oil == 35.8) { gallons_of_oil = 233.6; }
    else if(inches_of_oil == 35.7) { gallons_of_oil = 232.9; }
    else if(inches_of_oil == 35.6) { gallons_of_oil = 232.2; }
    else if(inches_of_oil == 35.5) { gallons_of_oil = 231.5; }
    else if(inches_of_oil == 35.4) { gallons_of_oil = 230.8; }
    else if(inches_of_oil == 35.3) { gallons_of_oil = 230.1; }
    else if(inches_of_oil == 35.2) { gallons_of_oil = 229.4; }
    else if(inches_of_oil == 35.1) { gallons_of_oil = 228.7; }
    else if(inches_of_oil == 35) { gallons_of_oil = 228; }
    else if(inches_of_oil == 34.9) { gallons_of_oil = 227.3; }
    else if(inches_of_oil == 34.8) { gallons_of_oil = 226.6; }
    else if(inches_of_oil == 34.7) { gallons_of_oil = 225.9; }
    else if(inches_of_oil == 34.6) { gallons_of_oil = 225.2; }
    else if(inches_of_oil == 34.5) { gallons_of_oil = 224.5; }
    else if(inches_of_oil == 34.4) { gallons_of_oil = 223.8; }
    else if(inches_of_oil == 34.3) { gallons_of_oil = 223.1; }
    else if(inches_of_oil == 34.2) { gallons_of_oil = 222.4; }
    else if(inches_of_oil == 34.1) { gallons_of_oil = 221.7; }
    else if(inches_of_oil == 34) { gallons_of_oil = 221; }
    else if(inches_of_oil == 33.9) { gallons_of_oil = 220.3; }
    else if(inches_of_oil == 33.8) { gallons_of_oil = 219.6; }
    else if(inches_of_oil == 33.7) { gallons_of_oil = 218.9; }
    else if(inches_of_oil == 33.6) { gallons_of_oil = 218.2; }
    else if(inches_of_oil == 33.5) { gallons_of_oil = 217.5; }
    else if(inches_of_oil == 33.4) { gallons_of_oil = 216.8; }
    else if(inches_of_oil == 33.3) { gallons_of_oil = 216.1; }
    else if(inches_of_oil == 33.2) { gallons_of_oil = 215.4; }
    else if(inches_of_oil == 33.1) { gallons_of_oil = 214.7; }
    else if(inches_of_oil == 33) { gallons_of_oil = 214; }
    else if(inches_of_oil == 32.9) { gallons_of_oil = 213.3; }
    else if(inches_of_oil == 32.8) { gallons_of_oil = 212.6; }
    else if(inches_of_oil == 32.7) { gallons_of_oil = 211.9; }
    else if(inches_of_oil == 32.6) { gallons_of_oil = 211.2; }
    else if(inches_of_oil == 32.5) { gallons_of_oil = 210.5; }
    else if(inches_of_oil == 32.4) { gallons_of_oil = 209.8; }
    else if(inches_of_oil == 32.3) { gallons_of_oil = 209.1; }
    else if(inches_of_oil == 32.2) { gallons_of_oil = 208.4; }
    else if(inches_of_oil == 32.1) { gallons_of_oil = 207.7; }
    else if(inches_of_oil == 32) { gallons_of_oil = 207; }
    else if(inches_of_oil == 31.9) { gallons_of_oil = 206.3; }
    else if(inches_of_oil == 31.8) { gallons_of_oil = 205.6; }
    else if(inches_of_oil == 31.7) { gallons_of_oil = 204.9; }
    else if(inches_of_oil == 31.6) { gallons_of_oil = 204.2; }
    else if(inches_of_oil == 31.5) { gallons_of_oil = 203.5; }
    else if(inches_of_oil == 31.4) { gallons_of_oil = 202.8; }
    else if(inches_of_oil == 31.3) { gallons_of_oil = 202.1; }
    else if(inches_of_oil == 31.2) { gallons_of_oil = 201.4; }
    else if(inches_of_oil == 31.1) { gallons_of_oil = 200.7; }
    else if(inches_of_oil == 31) { gallons_of_oil = 200; }
    else if(inches_of_oil == 30.9) { gallons_of_oil = 199.3; }
    else if(inches_of_oil == 30.8) { gallons_of_oil = 198.6; }
    else if(inches_of_oil == 30.7) { gallons_of_oil = 197.9; }
    else if(inches_of_oil == 30.6) { gallons_of_oil = 197.2; }
    else if(inches_of_oil == 30.5) { gallons_of_oil = 196.5; }
    else if(inches_of_oil == 30.4) { gallons_of_oil = 195.8; }
    else if(inches_of_oil == 30.3) { gallons_of_oil = 195.1; }
    else if(inches_of_oil == 30.2) { gallons_of_oil = 194.4; }
    else if(inches_of_oil == 30.1) { gallons_of_oil = 193.7; }
    else if(inches_of_oil == 30) { gallons_of_oil = 193; }
    else if(inches_of_oil == 29.9) { gallons_of_oil = 192.3; }
    else if(inches_of_oil == 29.8) { gallons_of_oil = 191.6; }
    else if(inches_of_oil == 29.7) { gallons_of_oil = 190.9; }
    else if(inches_of_oil == 29.6) { gallons_of_oil = 190.2; }
    else if(inches_of_oil == 29.5) { gallons_of_oil = 189.5; }
    else if(inches_of_oil == 29.4) { gallons_of_oil = 188.8; }
    else if(inches_of_oil == 29.3) { gallons_of_oil = 188.1; }
    else if(inches_of_oil == 29.2) { gallons_of_oil = 187.4; }
    else if(inches_of_oil == 29.1) { gallons_of_oil = 186.7; }
    else if(inches_of_oil == 29) { gallons_of_oil = 186; }
    else if(inches_of_oil == 28.9) { gallons_of_oil = 185.3; }
    else if(inches_of_oil == 28.8) { gallons_of_oil = 184.6; }
    else if(inches_of_oil == 28.7) { gallons_of_oil = 183.9; }
    else if(inches_of_oil == 28.6) { gallons_of_oil = 183.2; }
    else if(inches_of_oil == 28.5) { gallons_of_oil = 182.5; }
    else if(inches_of_oil == 28.4) { gallons_of_oil = 181.8; }
    else if(inches_of_oil == 28.3) { gallons_of_oil = 181.1; }
    else if(inches_of_oil == 28.2) { gallons_of_oil = 180.4; }
    else if(inches_of_oil == 28.1) { gallons_of_oil = 179.7; }
    else if(inches_of_oil == 28) { gallons_of_oil = 179; }
    else if(inches_of_oil == 27.9) { gallons_of_oil = 178.3; }
    else if(inches_of_oil == 27.8) { gallons_of_oil = 177.6; }
    else if(inches_of_oil == 27.7) { gallons_of_oil = 176.9; }
    else if(inches_of_oil == 27.6) { gallons_of_oil = 176.2; }
    else if(inches_of_oil == 27.5) { gallons_of_oil = 175.5; }
    else if(inches_of_oil == 27.4) { gallons_of_oil = 174.8; }
    else if(inches_of_oil == 27.3) { gallons_of_oil = 174.1; }
    else if(inches_of_oil == 27.2) { gallons_of_oil = 173.4; }
    else if(inches_of_oil == 27.1) { gallons_of_oil = 172.7; }
    else if(inches_of_oil == 27) { gallons_of_oil = 172; }
    else if(inches_of_oil == 26.9) { gallons_of_oil = 171.3; }
    else if(inches_of_oil == 26.8) { gallons_of_oil = 170.6; }
    else if(inches_of_oil == 26.7) { gallons_of_oil = 169.9; }
    else if(inches_of_oil == 26.6) { gallons_of_oil = 169.2; }
    else if(inches_of_oil == 26.5) { gallons_of_oil = 168.5; }
    else if(inches_of_oil == 26.4) { gallons_of_oil = 167.8; }
    else if(inches_of_oil == 26.3) { gallons_of_oil = 167.1; }
    else if(inches_of_oil == 26.2) { gallons_of_oil = 166.4; }
    else if(inches_of_oil == 26.1) { gallons_of_oil = 165.7; }
    else if(inches_of_oil == 26) { gallons_of_oil = 165; }
    else if(inches_of_oil == 25.9) { gallons_of_oil = 164.3; }
    else if(inches_of_oil == 25.8) { gallons_of_oil = 163.6; }
    else if(inches_of_oil == 25.7) { gallons_of_oil = 162.9; }
    else if(inches_of_oil == 25.6) { gallons_of_oil = 162.2; }
    else if(inches_of_oil == 25.5) { gallons_of_oil = 161.5; }
    else if(inches_of_oil == 25.4) { gallons_of_oil = 160.8; }
    else if(inches_of_oil == 25.3) { gallons_of_oil = 160.1; }
    else if(inches_of_oil == 25.2) { gallons_of_oil = 159.4; }
    else if(inches_of_oil == 25.1) { gallons_of_oil = 158.7; }
    else if(inches_of_oil == 25) { gallons_of_oil = 158; }
    else if(inches_of_oil == 24.9) { gallons_of_oil = 157.3; }
    else if(inches_of_oil == 24.8) { gallons_of_oil = 156.6; }
    else if(inches_of_oil == 24.7) { gallons_of_oil = 155.9; }
    else if(inches_of_oil == 24.6) { gallons_of_oil = 155.2; }
    else if(inches_of_oil == 24.5) { gallons_of_oil = 154.5; }
    else if(inches_of_oil == 24.4) { gallons_of_oil = 153.8; }
    else if(inches_of_oil == 24.3) { gallons_of_oil = 153.1; }
    else if(inches_of_oil == 24.2) { gallons_of_oil = 152.4; }
    else if(inches_of_oil == 24.1) { gallons_of_oil = 151.7; }
    else if(inches_of_oil == 24) { gallons_of_oil = 151; }
    else if(inches_of_oil == 23.9) { gallons_of_oil = 150.2; }
    else if(inches_of_oil == 23.8) { gallons_of_oil = 149.4; }
    else if(inches_of_oil == 23.7) { gallons_of_oil = 148.6; }
    else if(inches_of_oil == 23.6) { gallons_of_oil = 147.8; }
    else if(inches_of_oil == 23.5) { gallons_of_oil = 147; }
    else if(inches_of_oil == 23.4) { gallons_of_oil = 146.2; }
    else if(inches_of_oil == 23.3) { gallons_of_oil = 145.4; }
    else if(inches_of_oil == 23.2) { gallons_of_oil = 144.6; }
    else if(inches_of_oil == 23.1) { gallons_of_oil = 143.8; }
    else if(inches_of_oil == 23) { gallons_of_oil = 143; }
    else if(inches_of_oil == 22.9) { gallons_of_oil = 142.3; }
    else if(inches_of_oil == 22.8) { gallons_of_oil = 141.6; }
    else if(inches_of_oil == 22.7) { gallons_of_oil = 140.9; }
    else if(inches_of_oil == 22.6) { gallons_of_oil = 140.2; }
    else if(inches_of_oil == 22.5) { gallons_of_oil = 139.5; }
    else if(inches_of_oil == 22.4) { gallons_of_oil = 138.8; }
    else if(inches_of_oil == 22.3) { gallons_of_oil = 138.1; }
    else if(inches_of_oil == 22.2) { gallons_of_oil = 137.4; }
    else if(inches_of_oil == 22.1) { gallons_of_oil = 136.7; }
    else if(inches_of_oil == 22) { gallons_of_oil = 136; }
    else if(inches_of_oil == 21.9) { gallons_of_oil = 135.3; }
    else if(inches_of_oil == 21.8) { gallons_of_oil = 134.6; }
    else if(inches_of_oil == 21.7) { gallons_of_oil = 133.9; }
    else if(inches_of_oil == 21.6) { gallons_of_oil = 133.2; }
    else if(inches_of_oil == 21.5) { gallons_of_oil = 132.5; }
    else if(inches_of_oil == 21.4) { gallons_of_oil = 131.8; }
    else if(inches_of_oil == 21.3) { gallons_of_oil = 131.1; }
    else if(inches_of_oil == 21.2) { gallons_of_oil = 130.4; }
    else if(inches_of_oil == 21.1) { gallons_of_oil = 129.7; }
    else if(inches_of_oil == 21) { gallons_of_oil = 129; }
    else if(inches_of_oil == 20.9) { gallons_of_oil = 128.3; }
    else if(inches_of_oil == 20.8) { gallons_of_oil = 127.6; }
    else if(inches_of_oil == 20.7) { gallons_of_oil = 126.9; }
    else if(inches_of_oil == 20.6) { gallons_of_oil = 126.2; }
    else if(inches_of_oil == 20.5) { gallons_of_oil = 125.5; }
    else if(inches_of_oil == 20.4) { gallons_of_oil = 124.8; }
    else if(inches_of_oil == 20.3) { gallons_of_oil = 124.1; }
    else if(inches_of_oil == 20.2) { gallons_of_oil = 123.4; }
    else if(inches_of_oil == 20.1) { gallons_of_oil = 122.7; }
    else if(inches_of_oil == 20) { gallons_of_oil = 122; }
    else if(inches_of_oil == 19.9) { gallons_of_oil = 121.3; }
    else if(inches_of_oil == 19.8) { gallons_of_oil = 120.6; }
    else if(inches_of_oil == 19.7) { gallons_of_oil = 119.9; }
    else if(inches_of_oil == 19.6) { gallons_of_oil = 119.2; }
    else if(inches_of_oil == 19.5) { gallons_of_oil = 118.5; }
    else if(inches_of_oil == 19.4) { gallons_of_oil = 117.8; }
    else if(inches_of_oil == 19.3) { gallons_of_oil = 117.1; }
    else if(inches_of_oil == 19.2) { gallons_of_oil = 116.4; }
    else if(inches_of_oil == 19.1) { gallons_of_oil = 115.7; }
    else if(inches_of_oil == 19) { gallons_of_oil = 115; }
    else if(inches_of_oil == 18.9) { gallons_of_oil = 114.3; }
    else if(inches_of_oil == 18.8) { gallons_of_oil = 113.6; }
    else if(inches_of_oil == 18.7) { gallons_of_oil = 112.9; }
    else if(inches_of_oil == 18.6) { gallons_of_oil = 112.2; }
    else if(inches_of_oil == 18.5) { gallons_of_oil = 111.5; }
    else if(inches_of_oil == 18.4) { gallons_of_oil = 110.8; }
    else if(inches_of_oil == 18.3) { gallons_of_oil = 110.1; }
    else if(inches_of_oil == 18.2) { gallons_of_oil = 109.4; }
    else if(inches_of_oil == 18.1) { gallons_of_oil = 108.7; }
    else if(inches_of_oil == 18) { gallons_of_oil = 108; }
    else if(inches_of_oil == 17.9) { gallons_of_oil = 107.3; }
    else if(inches_of_oil == 17.8) { gallons_of_oil = 106.6; }
    else if(inches_of_oil == 17.7) { gallons_of_oil = 105.9; }
    else if(inches_of_oil == 17.6) { gallons_of_oil = 105.2; }
    else if(inches_of_oil == 17.5) { gallons_of_oil = 104.5; }
    else if(inches_of_oil == 17.4) { gallons_of_oil = 103.8; }
    else if(inches_of_oil == 17.3) { gallons_of_oil = 103.1; }
    else if(inches_of_oil == 17.2) { gallons_of_oil = 102.4; }
    else if(inches_of_oil == 17.1) { gallons_of_oil = 101.7; }
    else if(inches_of_oil == 17) { gallons_of_oil = 101; }
    else if(inches_of_oil == 16.9) { gallons_of_oil = 100.3; }
    else if(inches_of_oil == 16.8) { gallons_of_oil = 99.6; }
    else if(inches_of_oil == 16.7) { gallons_of_oil = 98.9; }
    else if(inches_of_oil == 16.6) { gallons_of_oil = 98.2; }
    else if(inches_of_oil == 16.5) { gallons_of_oil = 97.5; }
    else if(inches_of_oil == 16.4) { gallons_of_oil = 96.8; }
    else if(inches_of_oil == 16.3) { gallons_of_oil = 96.1; }
    else if(inches_of_oil == 16.2) { gallons_of_oil = 95.4; }
    else if(inches_of_oil == 16.1) { gallons_of_oil = 94.7; }
    else if(inches_of_oil == 16.0) { gallons_of_oil = 94; }
    else if(inches_of_oil == 15.9) { gallons_of_oil = 93.2; }
    else if(inches_of_oil == 15.8) { gallons_of_oil = 92.4; }
    else if(inches_of_oil == 15.7) { gallons_of_oil = 91.6; }
    else if(inches_of_oil == 15.6) { gallons_of_oil = 90.8; }
    else if(inches_of_oil == 15.5) { gallons_of_oil = 90; }
    else if(inches_of_oil == 15.4) { gallons_of_oil = 89.2; }
    else if(inches_of_oil == 15.3) { gallons_of_oil = 88.4; }
    else if(inches_of_oil == 15.2) { gallons_of_oil = 87.6; }
    else if(inches_of_oil == 15.1) { gallons_of_oil = 86.8; }
    else if(inches_of_oil == 15) { gallons_of_oil = 86; }
    else if(inches_of_oil == 14.9) { gallons_of_oil = 85.3; }
    else if(inches_of_oil == 14.8) { gallons_of_oil = 84.6; }
    else if(inches_of_oil == 14.7) { gallons_of_oil = 83.9; }
    else if(inches_of_oil == 14.6) { gallons_of_oil = 83.2; }
    else if(inches_of_oil == 14.5) { gallons_of_oil = 82.5; }
    else if(inches_of_oil == 14.4) { gallons_of_oil = 81.8; }
    else if(inches_of_oil == 14.3) { gallons_of_oil = 81.1; }
    else if(inches_of_oil == 14.2) { gallons_of_oil = 80.4; }
    else if(inches_of_oil == 14.1) { gallons_of_oil = 79.7; }
    else if(inches_of_oil == 14) { gallons_of_oil = 79; }
    else if(inches_of_oil == 13.9) { gallons_of_oil = 78.3; }
    else if(inches_of_oil == 13.8) { gallons_of_oil = 77.6; }
    else if(inches_of_oil == 13.7) { gallons_of_oil = 76.9; }
    else if(inches_of_oil == 13.6) { gallons_of_oil = 76.2; }
    else if(inches_of_oil == 13.5) { gallons_of_oil = 75.5; }
    else if(inches_of_oil == 13.4) { gallons_of_oil = 74.8; }
    else if(inches_of_oil == 13.3) { gallons_of_oil = 74.1; }
    else if(inches_of_oil == 13.2) { gallons_of_oil = 73.4; }
    else if(inches_of_oil == 13.1) { gallons_of_oil = 72.7; }
    else if(inches_of_oil == 13) { gallons_of_oil = 72; }
    else if(inches_of_oil == 12.9) { gallons_of_oil = 71.3; }
    else if(inches_of_oil == 12.8) { gallons_of_oil = 70.6; }
    else if(inches_of_oil == 12.7) { gallons_of_oil = 69.9; }
    else if(inches_of_oil == 12.6) { gallons_of_oil = 69.2; }
    else if(inches_of_oil == 12.5) { gallons_of_oil = 68.5; }
    else if(inches_of_oil == 12.4) { gallons_of_oil = 67.8; }
    else if(inches_of_oil == 12.3) { gallons_of_oil = 67.1; }
    else if(inches_of_oil == 12.2) { gallons_of_oil = 66.4; }
    else if(inches_of_oil == 12.1) { gallons_of_oil = 65.7; }
    else if(inches_of_oil == 12) { gallons_of_oil = 65; }
    else if(inches_of_oil == 11.9) { gallons_of_oil = 64.3; }
    else if(inches_of_oil == 11.8) { gallons_of_oil = 63.6; }
    else if(inches_of_oil == 11.7) { gallons_of_oil = 62.9; }
    else if(inches_of_oil == 11.6) { gallons_of_oil = 62.2; }
    else if(inches_of_oil == 11.5) { gallons_of_oil = 61.5; }
    else if(inches_of_oil == 11.4) { gallons_of_oil = 60.8; }
    else if(inches_of_oil == 11.3) { gallons_of_oil = 60.1; }
    else if(inches_of_oil == 11.2) { gallons_of_oil = 59.4; }
    else if(inches_of_oil == 11.1) { gallons_of_oil = 58.7; }
    else if(inches_of_oil == 11) { gallons_of_oil = 58; }
    else if(inches_of_oil == 10.9) { gallons_of_oil = 57.3; }
    else if(inches_of_oil == 10.8) { gallons_of_oil = 56.6; }
    else if(inches_of_oil == 10.7) { gallons_of_oil = 55.9; }
    else if(inches_of_oil == 10.6) { gallons_of_oil = 55.2; }
    else if(inches_of_oil == 10.5) { gallons_of_oil = 54.5; }
    else if(inches_of_oil == 10.4) { gallons_of_oil = 53.8; }
    else if(inches_of_oil == 10.3) { gallons_of_oil = 53.1; }
    else if(inches_of_oil == 10.2) { gallons_of_oil = 52.4; }
    else if(inches_of_oil == 10.1) { gallons_of_oil = 51.7; }
    else if(inches_of_oil == 10) { gallons_of_oil = 51; }
    else if(inches_of_oil == 9.9) { gallons_of_oil = 50.3; }
    else if(inches_of_oil == 9.8) { gallons_of_oil = 49.6; }
    else if(inches_of_oil == 9.7) { gallons_of_oil = 48.9; }
    else if(inches_of_oil == 9.6) { gallons_of_oil = 48.2; }
    else if(inches_of_oil == 9.5) { gallons_of_oil = 47.5; }
    else if(inches_of_oil == 9.4) { gallons_of_oil = 46.8; }
    else if(inches_of_oil == 9.3) { gallons_of_oil = 46.1; }
    else if(inches_of_oil == 9.2) { gallons_of_oil = 45.4; }
    else if(inches_of_oil == 9.1) { gallons_of_oil = 44.7; }
    else if(inches_of_oil == 9) { gallons_of_oil = 44; }
    else if(inches_of_oil == 8.9) { gallons_of_oil = 43.4; }
    else if(inches_of_oil == 8.8) { gallons_of_oil = 42.8; }
    else if(inches_of_oil == 8.7) { gallons_of_oil = 42.2; }
    else if(inches_of_oil == 8.6) { gallons_of_oil = 41.6; }
    else if(inches_of_oil == 8.5) { gallons_of_oil = 41; }
    else if(inches_of_oil == 8.4) { gallons_of_oil = 40.4; }
    else if(inches_of_oil == 8.3) { gallons_of_oil = 39.8; }
    else if(inches_of_oil == 8.2) { gallons_of_oil = 39.2; }
    else if(inches_of_oil == 8.1) { gallons_of_oil = 38.6; }
    else if(inches_of_oil == 8) { gallons_of_oil = 38; }
    else if(inches_of_oil == 7.9) { gallons_of_oil = 37.3; }
    else if(inches_of_oil == 7.8) { gallons_of_oil = 36.6; }
    else if(inches_of_oil == 7.7) { gallons_of_oil = 35.9; }
    else if(inches_of_oil == 7.6) { gallons_of_oil = 35.2; }
    else if(inches_of_oil == 7.5) { gallons_of_oil = 34.5; }
    else if(inches_of_oil == 7.4) { gallons_of_oil = 33.8; }
    else if(inches_of_oil == 7.3) { gallons_of_oil = 33.1; }
    else if(inches_of_oil == 7.2) { gallons_of_oil = 32.4; }
    else if(inches_of_oil == 7.1) { gallons_of_oil = 31.7; }
    else if(inches_of_oil == 7) { gallons_of_oil = 31; }
    else if(inches_of_oil == 6.9) { gallons_of_oil = 30.4; }
    else if(inches_of_oil == 6.8) { gallons_of_oil = 29.8; }
    else if(inches_of_oil == 6.7) { gallons_of_oil = 29.2; }
    else if(inches_of_oil == 6.6) { gallons_of_oil = 28.6; }
    else if(inches_of_oil == 6.5) { gallons_of_oil = 28; }
    else if(inches_of_oil == 6.4) { gallons_of_oil = 27.4; }
    else if(inches_of_oil == 6.3) { gallons_of_oil = 26.8; }
    else if(inches_of_oil == 6.2) { gallons_of_oil = 26.2; }
    else if(inches_of_oil == 6.1) { gallons_of_oil = 25.6; }
    else if(inches_of_oil == 6) { gallons_of_oil = 25; }
    else if(inches_of_oil == 5.9) { gallons_of_oil = 24.4; }
    else if(inches_of_oil == 5.8) { gallons_of_oil = 23.8; }
    else if(inches_of_oil == 5.7) { gallons_of_oil = 23.2; }
    else if(inches_of_oil == 5.6) { gallons_of_oil = 22.6; }
    else if(inches_of_oil == 5.5) { gallons_of_oil = 22; }
    else if(inches_of_oil == 5.4) { gallons_of_oil = 21.4; }
    else if(inches_of_oil == 5.3) { gallons_of_oil = 20.8; }
    else if(inches_of_oil == 5.2) { gallons_of_oil = 20.2; }
    else if(inches_of_oil == 5.1) { gallons_of_oil = 19.06; }
    else if(inches_of_oil == 5) { gallons_of_oil = 19; }
    else if(inches_of_oil == 4.9) { gallons_of_oil = 18.5; }
    else if(inches_of_oil == 4.8) { gallons_of_oil = 18; }
    else if(inches_of_oil == 4.7) { gallons_of_oil = 17.5; }
    else if(inches_of_oil == 4.6) { gallons_of_oil = 17; }
    else if(inches_of_oil == 4.5) { gallons_of_oil = 16.5; }
    else if(inches_of_oil == 4.4) { gallons_of_oil = 16; }
    else if(inches_of_oil == 4.3) { gallons_of_oil = 15.5; }
    else if(inches_of_oil == 4.2) { gallons_of_oil = 15; }
    else if(inches_of_oil == 4.1) { gallons_of_oil = 14.5; }
    else if(inches_of_oil == 4) { gallons_of_oil = 14; }
    else if(inches_of_oil == 3.9) { gallons_of_oil = 13.5; }
    else if(inches_of_oil == 3.8) { gallons_of_oil = 13; }
    else if(inches_of_oil == 3.7) { gallons_of_oil = 12.5; }
    else if(inches_of_oil == 3.6) { gallons_of_oil = 12; }
    else if(inches_of_oil == 3.5) { gallons_of_oil = 11.5; }
    else if(inches_of_oil == 3.4) { gallons_of_oil = 11; }
    else if(inches_of_oil == 3.3) { gallons_of_oil = 10.5; }
    else if(inches_of_oil == 3.2) { gallons_of_oil = 10; }
    else if(inches_of_oil == 3.1) { gallons_of_oil = 9.5; }
    else if(inches_of_oil == 3) { gallons_of_oil = 9; }
    else if(inches_of_oil == 2.9) { gallons_of_oil = 8.6; }
    else if(inches_of_oil == 2.8) { gallons_of_oil = 8.2; }
    else if(inches_of_oil == 2.7) { gallons_of_oil = 7.8; }
    else if(inches_of_oil == 2.6) { gallons_of_oil = 7.4; }
    else if(inches_of_oil == 2.5) { gallons_of_oil = 7; }
    else if(inches_of_oil == 2.4) { gallons_of_oil = 6.6; }
    else if(inches_of_oil == 2.3) { gallons_of_oil = 6.2; }
    else if(inches_of_oil == 2.2) { gallons_of_oil = 5.8; }
    else if(inches_of_oil == 2.1) { gallons_of_oil = 5.4; }
    else if(inches_of_oil == 2) { gallons_of_oil = 5; }
    else if(inches_of_oil == 1.9) { gallons_of_oil = 4.7; }
    else if(inches_of_oil == 1.8) { gallons_of_oil = 4.4; }
    else if(inches_of_oil == 1.7) { gallons_of_oil = 4.1; }
    else if(inches_of_oil == 1.6) { gallons_of_oil = 3.8; }
    else if(inches_of_oil == 1.5) { gallons_of_oil = 3.5; }
    else if(inches_of_oil == 1.4) { gallons_of_oil = 3.2; }
    else if(inches_of_oil == 1.3) { gallons_of_oil = 2.9; }
    else if(inches_of_oil == 1.2) { gallons_of_oil = 2.6; }
    else if(inches_of_oil == 1.1) { gallons_of_oil = 2.3; }
    else if(inches_of_oil == 1) { gallons_of_oil = 2; }
    else if(inches_of_oil == 0.9) { gallons_of_oil = 1.8; }
    else if(inches_of_oil == 0.8) { gallons_of_oil = 1.6; }
    else if(inches_of_oil == 0.7) { gallons_of_oil = 1.4; }
    else if(inches_of_oil == 0.6) { gallons_of_oil = 1.2; }
    else if(inches_of_oil == 0.5) { gallons_of_oil = 1; }
    else if(inches_of_oil == 0.4) { gallons_of_oil = 0.8; }
    else if(inches_of_oil == 0.3) { gallons_of_oil = 0.6; }
    else if(inches_of_oil == 0.2) { gallons_of_oil = 0.4; }
    else if(inches_of_oil == 0.1) { gallons_of_oil = 0.2; }
    else if(inches_of_oil == 0) { gallons_of_oil = 0; }
    
    Particle.publish("oil-gallons", String(gallons_of_oil,1), PRIVATE);
    delay(10000);
    
    // Reset all of the alert flags!
    /*
    if(gallons_of_oil > 240 && refill_alert) {
        Particle.publish("Alert", "Oil REFILLED!", PRIVATE);
        alert1 = 1; alert2 = 1; alert3 = 1; alert4 = 1; alert5 = 1; alert6 = 1;
        refill_alert = 0;
    }
    
    else if(gallons_of_oil > 125 && gallons_of_oil < 187.5 && alert1) {
    */
    if(gallons_of_oil > 125 && gallons_of_oil < 187.5 && alert1) {
        Particle.publish("Alert", "Oil Level bellow 75%", PRIVATE);
        alert1 = 0;
        refill_alert = 1;
    }
    else if(gallons_of_oil > 65 &&  gallons_of_oil < 125 && alert2) {
        Particle.publish("Alert", "NOTICE: Oil Level bellow 50%", PRIVATE);
        alert2 = 0; alert1 = 1;
        refill_alert = 1;
    }
    else if(gallons_of_oil > 75 &&  gallons_of_oil < 87.5 && alert3) {
        Particle.publish("Alert", "NOTICE: Oil Level bellow 35%", PRIVATE);
        alert3 = 0; alert1 = 0; alert2 = 0;
        refill_alert = 1;
    }
    else if(gallons_of_oil > 62.5 &&  gallons_of_oil < 75 && alert4) {
        Particle.publish("Alert", "WARNING: Oil Level bellow 30% - Refill Soon", PRIVATE);
        alert4 = 0; alert1 = 0; alert2 = 0; alert3 = 0;
        refill_alert = 1;
    }
    else if(gallons_of_oil > 50 &&  gallons_of_oil < 62.5 && alert5) {
        Particle.publish("Alert", "CRITIAL: Oil Level bellow 25% - Call to Refill", PRIVATE);
        alert5 = 0; alert1 = 0; alert2 = 0; alert3 = 0; alert4 = 0;
        refill_alert = 1;
    }
    else if(gallons_of_oil < 50 && alert6) {
        Particle.publish("Alert", "EMERGENCY: Oil Level bellow 20%  - Get Delivery ASAP!", PRIVATE);
        alert6 = 0; alert1 = 0; alert2 = 0; alert3 = 0; alert4 = 0; alert5 = 0;
        refill_alert = 1;
        
    }
}

Now that you have everything you need, the last part is to web hook the “Alert” publish call into something that actually alerts you. The easiest way to do this is to create a JSON “custom” webhook, which allows you to “hook” a publish event. In this case, I will hook the “Alert” published event, and redirect it to Pushbullet. You can just as easily call a 3rd party SMS service (Twilio), Email (Sendgrid, Mailgun, etc), or some other custom notification/hook.

Here is the Pushbullet config (please replace “Access-Token” with your token):

Web Hook for Notifications (free with Pushbullet)

{
"eventName": "Alert",
"url": "https://api.pushbullet.com/v2/pushes",
"requestType": "POST",
"headers": {
"Access-Token": "#REPLACE-WITH-YOUR-PUSHBULLET-ACCESS-TOKEN",
"Content-Type": "application/json"
},
"json": {
"type": "note",
"title": "Particle Alert - {{PARTICLE_PUBLISHED_AT}}",
"body": "{{PARTICLE_EVENT_VALUE}}"
},
"deviceID": "",
"mydevices": true,
"source": "{{PARTICLE_DEVICE_ID}}",
"published_at": "{{PARTICLE_PUBLISHED_AT}}"
}

Or, if you are using Pushover

{
  "event": "Alert",
  "url": "https://api.pushover.net/1/messages.json",
  "requestType": "POST",
  "rejectUnauthorized": true,
  "noDefaults": false,
  "headers": {
    "Content-Type": "application/json"
  },
  "json": {
      "token": "#APP-API-TOKEN-KEY-HERE#",
      "user": "#USER-KEY-HERE#",
      "title": "Particle Alert - {{PARTICLE_PUBLISHED_AT}}",
      "message": "{{PARTICLE_EVENT_VALUE}}"
  },
  "deviceID": "",
  "mydevices": true,
  "source": "{{PARTICLE_DEVICE_ID}}",
  "published_at": "{{PARTICLE_PUBLISHED_AT}}"
}

You will note that I have added a whole lot of pictures showing the steps around the Photon code build/flash and the Webhooks on the Instructables page. Here is some more informations/detials:

What if you have never used a Particle Photon? Detailed Help on setup/code/flashing!

I made the assumption that a most people who would be interested in a hardware project like this one would be very familiar with Particle’s photons/arduino, and I think this is a bad assumption. If you have not used these before, here is a step by step walk thru what to do from the software side in order to get this to work.

1.) Start by following this: https://docs.particle.io/guide/getting-started/start/photon/#step-1-power-on-your-device
2.) After you have initialized/“set up” your photon, go to: https://build.particle.io
3.) On the left side, under “Current Apps” (where it says “Title”) create an app called “oil-tank”.
Paste the large code from “Particle Photon web IDE code:” above, and click on the top-left “Save” (folder icon)
4.) On the left, click on “Libraries” (bookmark icon) and under “Community Libraries” search in the box for “HC_SR04”.
5.) Click on the found “HC_SR04” and click the blue “INCLUDE IN PROJECT” button. Then select from the list “oil-tank” (what you called your app in step #3), and click the blue “CONFIRM” button.
6.) At this point, make sure there is only ONE line that looks like this:

// This #include statement was automatically added by the Particle IDE.
#include <HC_SR04.h>

at the top of the file.
7.) Now clic on “Devices” and click on the star icon next to the device you setup in step #1 – this selects it for flashing the firmware.
8.) Go back to your “Code” for “oil-tank” and click “Verify” (check icon above “Save”) and then “Flash” (lightning bolt icon above “Verify”)
9.) That’s it – you have now flashed the firmware on your Photon.

What are these Web Hooks/Notifications - step by step instructions

1.) Go to: https://console.particle.io/devices
2.) Click on “Integrations” (star-looking icon above the Billing icon) and click on “New Integration”, and click on “Webhook”.
3.) There are TWO differentways to do this - using the “WEBHOOK BUILDER” step by step, OR pasting the whole JSON in the “CUSTOM TEMPLATE” section. No matter which you do, the only thing to really pay attention to is the “Event Name”. It always needs to be “Alert” (unless you change the Particle.publish in your firmware. This is what hooks that notifications into some “real world” notifcation - alert, SMS, Email, etc.)
4.) If you use the “CUSTOM TEMPLATE”, you can paste the “Web Hook for Notifications (free with Pushbullet)” code.
Alternative, and let’s say if you want SMS for example, you can go to the “WEBHOOK BUILDER” section, and follow something like this: https://www.twilio.com/docs/guides/sms-mms-messages-particle-photon#sign-into-or-sign-up-for-a-twilio-account, specifically following this sub-section: https://www.twilio.com/docs/guides/sms-mms-messages-particle-photon#example-1-a-simple-example-of-sending-smses-with-a-particle-photon (the “Set Up a Particle Webhook” part, and noting that the “Event Name” should be “Alert”).
5.) That’s it – you now have a method to “Alert” to external services. Generally, look for the REST POST URL, and either place it in your “WEBHOOK BUILDER” section, or into the JSON template I provided above.

You find OpenConnect - the perfect solution, only to realize that the 3rd-party GUI is basically broken and actually doesn’t work (last checked on 8-14-17) with 2-Factor authentication (ex: Duo).

At this point, you can run OpenConnect from a terminal, which works, but you have to keep the terminal open and you have to wrap the long command in a shell script.

Or, you can use my little solution which seems to work perfectly.

Everything you need to get started is on GitHub:
https://github.com/ventz/openconnect-gui-menu-bar

Whatever the solution was going to be, it had to be very open and customizable, easy to setup and scale for a production-like environment (stability, size), and ideally cheap/free. But most of all - it had to make sense and really be straight forward.

3 Containers and 10 minutes is all you need

To get this:

There are 3 components that are started via containers:

Grafana (dashboard/visual metrics and analytics)
InfluxDB (time-series DB)
Telegraf (time-series collector) - 1 per Docker host

The idea is that you first launch Grafana, and then launch InfluxDB. You configure Grafana (via the web) to point to InfluxDB’s IP, and then you setup a Telegraf container on each Docker host that you want to monitor. Telegraf collects all the metrics and feeds them into a central InfluxDB, and Grafana displays them.

Setup Tutorial/Examples

In our example, we have a bunch of servers running Docker:
vm01, vm02, vm03 [VM IPs do not matter in this case]

A “data” folder (/data) on each vm for the data mounts.
And we create an empty folder for each container: “/data/grafana”, “/data/influxdb”, “/data/telegraf”

A common network overlay or macvlan network (docker 1.12+) - we use the name “someNetworkName”

Static IPs (either via “–ip” directly, or something like pipework)

We will launch Grafana and InfluxDB on vm01, and a Telegraf container on vm01, vm02, and vm03.

Grafana (10.0.0.10)
InfluxDB (10.0.0.20)
Telegraf (10.0.0.101 on vm01, 10.0.0.102 on vm02, and 10.0.0.103 on vm03)

Grafana

Beautiful metric and analytics dashboard. Ideal for visualization and querying of time series data.

This is the first container you will launch on vm01:
(note: you are mounting the dirs so that you can access/change the configs, and data that is generated. Dirs can be empty)

NOTE: For Grafana, using ALL defaults works. That means you can either specify the “-v” for the /etc/grafana, /var/lib/grafana, and /var/log/grafana - or skip it. It would make sense to specify the logs to have them, and it would make sense to specify the rest if you want to 1.) override something and/or 2.) add plugins. Otherwise, you are fine with defaults. I will provide the “default” config in the comments bellow.

docker run --restart=always -d --net=someNetworkName --ip=10.0.0.10 \
	--name grafana \
	--hostname grafana \
	-v /data/grafana/var/lib/grafana:/var/lib/grafana \
	-v /data/grafana/etc/grafana:/etc/grafana \
	-v /data/grafana/var/log/grafana:/var/log/grafana \
	-p 3000:3000 \
	-e "GF_SERVER_ROOT_URL=http://10.0.0.10"  \
	-e "GF_SECURITY_ADMIN_PASSWORD=somepasswordhere"  \
	grafana/grafana

InfluxDB

Time-series data storage. A database designed for time-series data. Very easy to use, and feeds data into Grafana. It can accept data from many tools, specifically collectors like Telegraf.

First generate a config file:

docker run --rm influxdb influxd config > /data/influxdb/influxdb.conf

Then run the container as your second container on vm01:

docker run --restart=always -d --net=someNetworkName --ip=10.0.0.20 \
	--name=influxdb \
	--hostname=influxdb \
	-p 8083:8083 -p 8086:8086 \
	-v /data/influxdb:/var/lib/influxdb \
	-v /data/influxdb/influxdb.conf:/etc/influxdb/influxdb.conf:ro \
	influxdb -config /etc/influxdb/influxdb.conf

Telegraf

Time-series data collection. This uses a config to know what data to collect and where to feed it.

First generate a config file:

docker run --rm telegraf -sample-config > /data/telegraf/telegraf.conf

Edit the config and just enable the Docker portion (uncomment the “[[inputs.docker]]” section until the timeout)

The only other config line you need is this:

[[outputs.influxdb]]
  #urls = ["http://IP-or-NAME-of-INFLUXDB:8086"] # required
  urls = ["http://10.10.10.20:8086"] # required
  database = "telegraf" # required

Then run the container as your third container on vm01 (and later on vm02, and vm03, with changes bellow code):

docker run -d --restart=always --net=admin01 --ip=10.0.0.101 \
	--add-host="influxdb:10.0.0.20"\
	--name=stats-s01 \
	--hostname=vm01 \
	-e "HOST_PROC=/rootfs/proc" \
	-e "HOST_SYS=/rootfs/sys" \
	-e "HOST_ETC=/rootfs/etc" \
	-v /data/telegraf/telegraf.conf:/etc/telegraf/telegraf.conf:ro \
	-v /var/run/docker.sock:/var/run/docker.sock:ro \
	-v /sys:/rootfs/sys:ro -v /proc:/rootfs/proc:ro \
	-v /etc:/rootfs/etc:ro telegraf

NOTE: You will launch the almost the same thing on vm02 and vm03, but you would change the –hostname (vm02, and vm03) and –ip (10.0.0.102, and 10.0.0.103)

Last Step - Connect via Web and Start Using

Log into http://10.0.0.10:3000 (admin, and password from docker “GF_SECURITY_ADMIN_PASSWORD”), and go to:
1.) The top left Menu (icon of Spiral)
2.) Data Sources
3.) + Add data source
4.) Fill out:
a.) Name: InfluxDB
b.) Type: InfluxDB
c.) (HTTP Settings) Url: http://10.0.0.20:8086
d.) (InfluxDB Settings) Database: telegraf
5.) Click “Save & Test” - it will save and work (ignore the “Please fill out this field - this is for production environments - setting up DB users, and eventually SSL)

It should look like this:

That’s it! You are Done!

Now you can go to the top left menu -> Add a new Dashboard -> Add a panel, and start adding Graph (or other) data.
For Graph for example, under the Metrics tab, you can access all of the variables in a point and click method.

Here’s a example to add a new graph on a new Row (after you create a Panel):

And here’s an example of how you would modify the “search” by point and click:

How I came to this solution (skip if you are not interested)

After some research, I realized just how bad of a state the currently available solutions and tutorials/example/documentation were. They were either too simple and not useful (CAdvisor), not fully implemented (Stats, Scout), extremely complicated in design and difficult to setup or lacking documentation (Sensu, Prometheus, etc.), or just expensive (DataDog, SysDigCloud).

And the tutorials on docker and metrics were basically non existent. Rancher’s guide is the most “current and complete” doc on this as of today, in terms of what’s available, and you can find it HERE.

Using Swarm with pre-generated static tokens is useful, but there are many benefits to using a service discovery backend. For example, you can utilize network overlays and have common “bridges” that span multiple hosts (https://docs.docker.com/engine/userguide/networking/get-started-overlay/). It also provides service registration and discovery for the Docker containers launched into the Swarm. Now lets get into how to use it with service discovery - which is what you would use in a scaled out environment/production.

Again, assuming you have a bunch of servers running docker:
vm01 (10.0.0.101), vm02 (10.0.0.102), vm03 (10.0.0.103), vm04 (10.0.0.104)

Normally, you can do “docker ps” on each host for example:
ssh vm01 ‘docker ps’
ssh vm04 ‘docker ps’

If you enable the API for remote bind on each host you can manage them from a central place:
docker -H tcp://vm01:2375 ps
docker -H tcp://vm04:2375 ps
(note: port is optional for default)

But if you want to use all of these docker engines as a cluster, you need Swarm.
Here we will go one step further and use a common service discovery backend (Consul).

Docker Swarm Tutorial with Consul and How-To/Examples

A swarm contains only two components: agents (the workers in the cluster) and manager(s).
We are also going to add consul (the service discovery backend).

First, grab the swarm and the consul images on each docker host:

docker pull swarm
docker pull progrium/consul

Then, make sure the API is enabled for remote bind on each host (NOTE: see bellow if using Systemd OS):

# (on Ubuntu) cat /etc/default/docker:

DOCKER_OPTS="-H tcp://0.0.0.0:2375 \
--cluster-store=consul://consulServer:8500 \
--cluster-advertise=managerIp:2376 \
-H unix:///var/run/docker.sock --dns 8.8.8.8 --dns 8.8.4.4 ..."

# And then restart:
/etc/init.d/docker restart

# -- OR --

# IF USING a Systemd OS -- Ubuntu 16.04/CentOS7 and up, use this instead:

# (on Ubuntu) cat /etc/systemd/system/docker.service

[Service]
ExecStart=/usr/bin/docker daemon -H tcp://0.0.0.0:2375 \
--cluster-store=consul://consulIp:8500 \
--cluster-advertise=managerIp:2376 \
-H unix:///var/run/docker.sock --dns 8.8.8.8 --dns 8.8.4.4

# And then reload/restart
systemctl daemon-reload
systemctl restart docker

Don’t panic here! It looks complicated, but it’s actually incredibly easy.

The consulIp in “–cluster-store=consul://consulIp:8500” is the docker host that will run the consul service (much like the swarm manager). Since you will map the port to the docker host itself, that’s simply the IP of the docker host (in our case - vm01)

The managerIp in “–cluster-advertise=managerIp:2376” is the docker host that will run the swarm manager service. Since you will map the port to the docker host itself, that’s simply the IP of the docker host (in our case - vm01).

To get everything started, go to whatever docker host you pick as the manager (in our case vm01), and create the consul server:
docker run -d -p "8500:8500" -h "consul" progrium/consul -server -bootstrap

Now, on *each* AGENT (including the manager if you want to use it as a worker) run:
docker run -d swarm join –addr 107.170.73.43:2375 consul://consulIp/swarm:8500/swarm

docker run -d swarm join --advertise 10.0.0.101:2375 consul://10.0.0.101:8500/swarm
docker run -d swarm join --advertise 10.0.0.102:2375 consul://10.0.0.101:8500/swarm
docker run -d swarm join --advertise 10.0.0.103:2375 consul://10.0.0.101:8500/swarm
docker run -d swarm join --advertise 10.0.0.104:2375 consul://10.0.0.101:8500/swarm

You would do this for *each* agent and in our case vm01 is also an agent.

At last, you need to run a manager service on your chosen manager host (in our case, vm01) to manage the swarm:
docker run -d -p 2376:2375 swarm manage consul://consulIp:8500/swarm
docker run -d -p 2376:2375 swarm manage consul://10.0.0.101:8500/swarm

The idea is that the manager wants to provide an API on port 2375. We are binding that to the local host on 2376. If your manager is NOT an agent, you can simply bind it on 2375 by doing a “run -d -P swarm manage consul://…”. In that case, you would NOT run the “swarm join” command on your manager. However, in our case we want all of the hosts to be agents, including the manager.

The last step is to query the cluster:
docker -H tcp://managerIP:2376 info

In our case, we use vm01:

docker -H tcp://vm01:2376 info
or
docker -H tcp://vm01:2376 ps

Again, if your manager is NOT an agent, you would simply run:
“docker -H tcp://managerIP:2375 info” or even “docker -H tcp://managerip”

Don’t forget to start the manager on reboot, and each join on the agents on reboot.

Recently I tried setting up a Plex server in a docker container. The first problem was the 127.0.0.1:32400 bind which required logging in locally or port forwarding. After doing this once, I realized that you could use the Preferences.xml file, but that meant that you couldn’t truly automate this/deploy it elegantly in a docker container. And what if you wanted to run other servers - for friends? I finally figured out how to do this in the most elegant way possible.

First - Grab your Unique Plex Access Token

Login at https://app.plex.tv/web/app with your username and password
Open your javascript console (in Chrome: View -> Developer -> JavaScript Console)
and type:
console.log(window.PLEXWEB.myPlexAccessToken);

Note the token, which will look like this: “PZwoXix8vxhQJyrdqAbY”

At this stage DO NOT click log out of your account until you register the new server. Otherwise your token will regenerate.
Once you register the server, it won’t matter after that if the token changes.

Grab my Docker Image

Check out: https://hub.docker.com/r/ventz/plex/
You can pull it down by doing:
docker pull ventz/plex

Setup a DATA directory

Create a DATA directory (let’s assume it’s “/plex”) which contains:
1.) a folder called “Plug-ins” -> this has all your plugins from: https://github.com/plexinc-plugins or any other source.
2.) a file called “Preferences.xml”

The “Preferences.xml” file should contain:

<?xml version="1.0" encoding="utf-8"?>
<Preferences MachineIdentifier="12f0e861-5876-498e-bec6-111b030118aa" ProcessedMachineIdentifier="f12a1d8fdc32ae0cf273ec699a3ddbd37a4a94e4" AnonymousMachineIdentifier="ae674c91-42ff-4be5-88e9-f6b2a1751146" MetricsEpoch="1" GracenoteUser="WEcxA9TX1GEpdlIDlmmKmq70OVYLCgKZ+qh/lJkydwKH29UjfnDGWq/M8Okr//E88wSk9A7UXVxjlZgVpu1px7GVA2GEOAAAk8AJ4KOXodtdzLj+HPNhYZIl/lzMY8P32sF2rq9yb4RwhtOE/mKejkvw/2Ak5mm0VNQjt3ifNEXpyfuo+oH519qFQ5XAk+7Y3cwtEff2" AcceptedEULA="1" ManualPortMappingMode="1" PublishServerOnPlexOnlineKey="1" collectUsageData="0" logDebug="0" PlexOnlineToken="PZwoXix8vxhQJyrdqAbY" CertificateVersion="2"/>

note: Edit out “PZwoXix8vxhQJyrdqAbY” with the AccessToken for the account you want to use!

This will end up being mounted over:
1.) /var/lib/plexmediaserver/Library/Application Support/Plex Media Server/Plug-ins
2.) /var/lib/plexmediaserver/Library/Application Support/Plex Media Server/Preferences.xml

Run Plex in a Docker Container on a VPS without backend setup/port forwarding

docker run --name=plex -d --privileged=true -p 32400:32400 -v /plex:/p ventz/plex

This will mount your /plex/{Plug-ins, Preferences.xml} into /p on the container, and then the default CMD on the container is “/start-plex.sh” which will chmod them, move them into the right places, and then start the server.

At this point, go to the Docker HOSTS’ IP address (or the Public IP that NATs to the internal IP) at: “http://dockerhostIP:32400/web”, and log-in with your Plex account. You will now see a NEW server registered, and you will be able to browse the channels that you have pushed + watch content 🙂

OPTIONAL - How to Build your own Docker image

Let’s say you don’t trust some random image by some random person (me). No problem - here’s how to build your own “ventz/plex” Docker image.

Create a /plex-container directory that has 3 files:
1.) Dockerfile
2.) The CentOS RPM (64bit - as of now, latest: plexmediaserver-0.9.12.19.1537-f38ac80.x86_64.rpm)
3.) start-plex.sh

[ updated 10-30-2016 | Upgraded Plex to plexmediaserver-1.1.4.2757-24ffd60.x86_64.rpm and CentOS ]

Make sure your Dockerfile has:

FROM centos:6.8

VOLUME ["/p"]

COPY start-plex.sh /
COPY plexmediaserver-1.1.4.2757-24ffd60.x86_64.rpm  /root
RUN rpm -i /root/plexmediaserver-1.1.4.2757-24ffd60.x86_64.rpm
RUN rm -f /root/plexmediaserver-1.1.4.2757-24ffd60.x86_64.rpm

EXPOSE 32400

# Run actual Plex server
CMD ["/start-plex.sh"]

and Finally, make sure your “start-plex.sh” has:

#!/bin/bash
# Needed to create Library and other dirs under "/var/lib/plexmediaserver"
/etc/init.d/plexmediaserver start
/etc/init.d/plexmediaserver stop

# Make sure permissions are correct.
chown -R plex:plex /p/*

# Move Files
cp -Rf /p/Plug-ins/* /var/lib/plexmediaserver/Library/Application\ Support/Plex\ Media\ Server/Plug-ins/.
cp -f /p/Preferences.xml /var/lib/plexmediaserver/Library/Application\ Support/Plex\ Media\ Server/.

# Start Real Plex server
su -s /bin/sh plex -c ". /etc/sysconfig/PlexMediaServer; cd /usr/lib/plexmediaserver; ./Plex\ Media\ Server"

Now, BUILD it:

docker build --rm=true --force-rm=true -t ventz/plex .

Enjoy! 🙂

If you use Docker, you very quickly run into a common question: how do you make Docker work across multiple hosts, datacenters, and different clouds. One of the simplest solutions is Docker Swarm. Docker summarizes it best as “a native clustering for Docker…[which] allows you create and access to a pool of Docker hosts using the full suite of Docker tools.”

One of the biggest benefits to using Docker Swarm is that it provides the standard Docker API, which means that all of the existing Docker management tools (and 3rd party products) just work out of the box as they do with a single host. The only difference is that they now scale transparently over multiple hosts.

After reading up on it in the Docker Swarm overview and the Swarm install guide, it was evident that this is a pretty simple service, but it wasn’t 100% clear what went where. After searching around the web, I realized that almost all of the tutorials and examples on Docker Swarm involved either docker-machine or very convoluted examples which did not explain what was happening on which component. With that said, here is a very simple Docker Swarm Tutorial with some practical examples.

Assuming you have a bunch of servers running docker:
vm01 (10.0.0.101), vm02 (10.0.0.102), vm03 (10.0.0.103), vm04 (10.0.0.104)

Normally, you can do “docker ps” on each host for example:
ssh vm01 ‘docker ps’
ssh vm04 ‘docker ps’

If you enable the API for remote bind on each host you can manage them from a central place:
docker -H tcp://vm01:2375 ps
docker -H tcp://vm04:2375 ps
(note: port is optional for default)

But if you want to use all of these docker engines as a cluster, you need Swarm.

Docker Swarm Tutorial and How-To/Examples

A swarm contains only two components: agents (the workers in the cluster) and manager(s).

First, grab the swarm image on each docker host:
docker pull swarm

Then, make sure the API is enabled for remote bind on each host (NOTE: see bellow if using Systemd OS):

# (on Ubuntu) cat /etc/default/docker:

DOCKER_OPTS="-H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock ..."

# And then restart:
/etc/init.d/docker restart

# -- OR --

# IF USING a Systemd OS -- Ubuntu 16.04/CentOS7 and up, use this instead:

# (on Ubuntu) cat /etc/systemd/system/docker.service

[Service]
ExecStart=/usr/bin/docker daemon -H tcp://0.0.0.0:2375 -H unix:///var/run/docker.sock --dns 8.8.8.8 --dns 8.8.4.4

# And then reload/restart
systemctl daemon-reload
systemctl restart docker

To get everything started, go to whatever docker host you pick as the manager (in our case vm01), and create the swarm:
docker run --rm swarm create

This will generate an unique token like:
c05c3ef4c4b15821a8e8e2ef6bdf192d

Now, on *each* AGENT (including the manager if you want to use it as a worker) run:
docker run -d swarm join –advertise agentIP:2375 token://c05c3ef4c4b15821a8e8e2ef6bdf192d

docker run -d swarm join --advertise 10.0.0.101:2375 token://c05c3ef4c4b15821a8e8e2ef6bdf192d
docker run -d swarm join --advertise 10.0.0.102:2375 token://c05c3ef4c4b15821a8e8e2ef6bdf192d
docker run -d swarm join --advertise 10.0.0.103:2375 token://c05c3ef4c4b15821a8e8e2ef6bdf192d
docker run -d swarm join --advertise 10.0.0.104:2375 token://c05c3ef4c4b15821a8e8e2ef6bdf192d

You would do this for *each* agent and in our case vm01 is also an agent)

At last, you need to run a manager service on your chosen manager host (in our case, vm01) to manage the swarm:
docker run -d -p 2376:2375 swarm manage token://c05c3ef4c4b15821a8e8e2ef6bdf192d

The idea is that the manager wants to provide an API on port 2375. We are binding that to the local host on 2376. If your manager is NOT an agent, you can simply bind it on 2375 by doing a “run -d -P swarm manage token://…”. In that case, you would NOT run the “swarm join” command on your manager. However, in our case we want all of the hosts to be agents, including the manager.

The last step is to query the cluster:
docker -H tcp://managerIP:2376 info

In our case, we use vm01:

docker -H tcp://vm01:2376 info
or
docker -H tcp://vm01:2376 ps

Again, if your manager is NOT an agent, you would simply run:
“docker -H tcp://managerIP:2375 info” or even “docker -H tcp://managerip”

Don’t forget to start the manager on reboot, and each join on the agents on reboot.