A Ruby On Rails Development Environment (Basic) hosted on a Vagrant Box
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.



A Ruby On Rails Development Environment (Basic)

Containing Ubuntu Server 16.04(i386), Ruby 2.3.4, Rails 5.0.7, Gem 2.5.2, Node.js v4.2.6, Git 2.7.4

This is a Vagrant Box, (https://www.vagrantup.com), intended for quick installation of a very basic Ruby On Rails development environment. Assuming Vagrant and VirtualBox are already installed on your host computer, this Vagrant Box can be easily and quickly installed and removed.

Because it can be quickly built or rebuilt if necessary, this Vagrant Box may be handy for transient work environments, such as tutorials, or experimental work which may sacrifice this expendable vagrant-ruby-rails development environment package.

It also allows easy reproduction and distribution of exact duplicates of a development environment shared among multiple project members.

The installed Git software can be used for committing Ruby/Rails project files or other sources into repositories.

If you customize the configuration and provisioning files of this vagrant-ruby-rails Vagrant Box, and then save them in a Git repository, you can easily recreate your own custom vagrant-ruby-rails Vagrant Box development environment in the future. Also, using an online Git repository, you can easily share your customized vagrant-ruby-rails Vagrant Box with other users.

Note that the Ubuntu Server OS installed in this Vagrant Box is not a 64 bit machine runtime; it is a 32 bit image installation. Though a 32 bit image may be slightly slower than a 64 bit image for some applications, it requires less storage than a 64 bit image, and runs more legacy software packages.

If the host supports simultaneous virtual machines, more than one instance of vagrant-ruby-rails may execute simultaneously, as many as the host has resources to run.

Definitions : A "host" is a computer on which you will be installing vagrant-ruby-rails. Vagrant-ruby-rails is a "guest" installed onto your "host" computer. Because the vagrant-ruby-rails "guest" is a Vagrant Box, it is referred to in this document as a guest-vbox.

If you are very unfamiliar with the software products listed at the top of this document, you may wish to visit online references before proceeding. Some relevant online resources are listed in a section near the end of this document, titled "The Short List Of Online References".

Introduction To Installation And Use

To install vagrant-ruby-rails, your host computer needs :

  • An Internet connection

  • 512MB of available memory (free RAM) - After installation, you may increase or decrease the amount of host memory allocated to the guest-vbox.

  • 2.8GB of storage (minimum) - Your long term host storage space requirement will be determined by your application.

  • Vagrant and VirtualBox - Your host computer must have an operating system installed which supports Vagrant and VirtualBox, and those must be installed prior to installing vagrant-ruby-rails.

  • A terminal/shell program - previously installed on the host.

  • A zip file extraction program - previously installed on the host.

The installation of Ruby/Rails/etc has been tested only on the Ubuntu 16.04 guest-vbox installed by the included Vagrantfile.

Quickstart For Experts Already Running Vagrant With VirtualBox On Linux or Windows

Instdall A New Rails Dev Env And Minimal Scaffolded Rails App, (for details, see Software Installation)
Copy-and-Paste The Commands Given Here Into Your Terminal Session
  1. Open a terminal session in your host computer storage workspace.

  2. Navigate to a location where you wish to create a directory which will contain vagrant-ruby-rails.

  3. Download ZIP vagrant-ruby-rails file from GitHub into the current directory :

$ wget -O vagrant-ruby-rails.zip https://github.com/addiscent/vagrant-ruby-rails/archive/master.zip

  1. Unzip vagrant-ruby-rails files from the zip file, e.g. :

$ unzip vagrant-ruby-rails.zip

  1. Navigate into the vagrant-ruby-rails directory created by unzipping, e.g. :

$ cd vagrant-ruby-rails-master

  1. Create a directory and spin up a Vagrant Box. The spin-up provisioning installs Rails.

$ mkdir workspace && vagrant up && vagrant ssh

Now wait a while for the Ubuntu Server 16.04 image to download and provision. The amount of wait time is mostly determined by the speed of connections to the necessary servers on the Internet. Typically, a vagrant-ruby-rails instance requires 15 minutes to download and install.

After the image finishes downloading and provisioning is complete, you see the prompt of the guest-vbox :

  1. Become root user :

$ sudo -s

  1. Create a new "empty" Rails app :

(as root)# cd /vagrant/workspace && rails new myapp

  1. Quit being root user by exiting root user shell :

(as root)# exit

  1. Start the lightweight web server :

$ cd myapp && rails s -b

While waiting for the web server to fill the Rails pipeline, open a web browser to http://localhost:3033. After the pipeline fills, in the web browser window you see :

    Yay! You’re on Rails!

When ready to stop the Rails server, press control-C :

    The vagrant-ruby-rails guest-vbox terminal SSH session prompt returns.

When ready, end the vagrant-ruby-rails guest-vbox SSH terminal session :

$ exit

    The terminal session prompt of the host returns.

When you wish to do so, you may remove everything which was installed, by using the following commands.

  1. Remove the vagrant-ruby-rails guest-vbox from the host computer :

$ vagrant destroy

    The vagrant-ruby-rails guest-vbox has been stopped.
    The vagrant-ruby-rails guest-vbox virtual machine files have been removed.
  1. Remove the vagrant-ruby-rails project files from the host computer :

$ cd .. && rm -r vagrant-ruby-rails-master

"And just like that, she was gone."

Software Installation

Before beginning installation of vagrant-ruby-rails, you must already have Vagrant and VirtualBox installed and properly configured. The versions used for development and testing are Vagrant 1.9.3 and VirtualBox 5.1.14. Other "close" versions may work. For more information, see the section near the end of this document, titled, "Other Notes".

Installation of vagrant-ruby-rails - Expanded description

Prepare For The Build

Open a terminal session in your host computer storage workspace.

Navigate to a location where you wish to create a directory which will contain vagrant-ruby-rails.

Download ZIP vagrant-ruby-rails file from GitHub into the current directory :

$ wget -O vagrant-ruby-rails.zip https://github.com/addiscent/vagrant-ruby-rails/archive/master.zip

Unzip vagrant-ruby-rails files from the zip file, e.g. :

$ unzip vagrant-ruby-rails.zip

Unzipping the file creates a directory named vagrant-ruby-rails-master. You may leave it named as is, or rename it as you wish. For the purpose of this document, we rename it now to vagrant-ruby-rails :

$ mv vagrant-ruby-rails-master vagrant-ruby-rails

Navigate into the vagrant-ruby-rails directory created by unzipping, e.g. :

$ cd vagrant-ruby-rails

After extraction, verify the contents of ".../vagrant-ruby-rails/". Enter the following command :

$ ls -al

A directory listing shows the following, (or similar), contents :

    -rw-rw-r-- 1 user group   28 Jul 10 19:19 .gitignore
    -rw-rw-r-- 1 user group  12K Jul 10 19:19 LICENSE
    -rw-rw-r-- 1 user group 3.0K Jul 10 19:19 bashrc-mod.txt
    -rw-rw-r-- 1 user group  28K Jul 10 19:19 README.md
    -rw-rw-r-- 1 user group 3.0K Jul 10 19:19 Vagrantfile

Create a directory named "workspace". The "workspace" directory is the recommended location for placement of your future "rails apps" :

$ mkdir workspace

Do The Build

The "vagrant up" command executed below provisions and starts a vagrant-ruby-rails Vagrant Box. The work done by Vagrant during this initial "vagrant up" operation will be performed only once. Typically, the guest-vbox image requires 15 minutes to download and build. Subsequent "vagrant up" operations will result in a running guest-vbox within approximately one minute.

During provisioning, there is a large amount of terminal message output. The vast majority of these messages log the construction of software which is being placed into the vagrant-ruby-rails Vagrant Box. During this procedure, Ruby, Gems, Rails, Git, and Node.js are not placed directly onto your host, they are placed into the guest-vbox.

Enter the following command :

$ vagrant up

The Build starts.

A very long list of text messages is output during the build process, beginning with :

    "==> Bringing machine 'default' up with 'virtualbox' provider..."

The build tools will output numerous status/progress messages. If you are using a terminal which is configured to show color text, most of the informational messages displayed are green in color, but, some are red-color text output. The output messages are color coded by Vagrant; green messages indicate those of STDOUT from the guest-vbox, while red messages indicate those of STDERR from the guest-vbox.

Red-color messages are common, they do not indicate an error has definitely occured; the author of that particular software simply chose to use STDERR to output trace/status messages. Typically, if the build fails, it will stop with an obvious error message, but in some unusual cases it does not. After the build finishes, you should scroll back through the terminal output messages and scrutinize them for messages which may indicate a legitimate error. Sometimes error messages may displayed, but upon investigation you may discover that they are "non-fatal", and the installation software assumed it was safe to continue. If you believe The Build did not complete successfully, see the section near the end of this document titled, "If The Build Fails".

After the build completes successfully, the last build message reads similar to the following :

    -->  END ./ruby-rails-tools-install.sh

Verify The Build

Verify The Toolset Has Properly Installed

After the build finishes, the guest-vbox is ready for use.

Log into the guest-vbox using the following command :

$ vagrant ssh

Successful login to the guest-vbox result in an Ubuntu banner and a prompt similar to :

    Welcome to Ubuntu 14.04.4 LTS (GNU/Linux 3.13.0-91-generic x86_64)

      System information as of Mon Jul 11 01:49:42 UTC 2016

      System load:  0.76              Processes:           82
      Usage of /:   3.5% of 39.34GB   Users logged in:     0
      Memory usage: 27%               IP address for eth0:
      Swap usage:   0%


Enter the following commands. Notice the components which have been installed, and their associated version numbers :

$ ruby --version

      Result :

        ruby 2.3.4p301 (2017-03-30 revision 58214)

$ rails --version

      Result : Rails 5.0.7

$ gem --version

      Result : 2.5.2

$ bundler --version

      Result : Bundler version 1.14.6

$ nodejs --version

      Result : v4.2.6

$ git --version

      Result : git version 2.7.4

$ gem list sqlite3

      Result : sqlite3 (1.3.13)

Note the name of the currrently logged-in user is vagrant, the default built-in user on this vagrantbox.

Construct And Test A Minimal App Which Confirms Working Rails Scaffolding

Ensure you are still in the "vagrant ssh" session in your terminal program.

Enter the following commands.

Become root user by executing this command :

$ sudo -s

The next command line builds and serves a web page from an example Rails app named "myapp" :

(as root)# cd /vagrant/workspace && rails new myapp && cd myapp && rails s -b

Terminal output messages shown below trace the progress of the command above, which builds the scaffolding for a new Rails app named "myapp", and then executes the Rails server.

    Puma starting in single mode...
    Version 3.8.2 (ruby 2.4.1-p111), codename: Sassy Salamander
    Listening on tcp://
    Use Ctrl-C to stop

The Rails default test server, Puma, is now running.

Use a web browser on your host to examine the resulting example web page at URL :


The example web page shows :

    Yay! You’re on Rails!

You may now terminate execution of the test server, by entering Ctrl-C in the guest-vbox terminal.

It no longer necessary now to work as root, so execute the following command to exit as root and resume operating as the typically more appropriate user vagrant:

(as root)# exit

This ends verification of a successful build. You may now continue to experiment with "myapp", or you may remove it if you have no other use for it. If you wish to remove it, you may enter the following command.

$ cd && rm -rf /vagrant/workspace/myapp

    Result :

      The "myapp" directory and its subdirectories are deleted.
      Return to prompt :

Quicklist Of Vagrant Commands

The following set of commands is the minimum set required to control a Vagrant Box from a shell prompt :

  • "vagrant up" - creates a new Vagrant Box on the host, directed by the Vagrantfile. Also restarts a previously halted Vagrant Box.

  • "vagrant ssh" - opens an ssh terminal session with the Vagrant Box, allowing its system administration.

  • "vagrant halt" - stops execution of a running Vagrant Box.

  • "vagrant destroy" - Removes a guest-vbox's image files, including its virtual file system, from host storage. When this command finishes executing, the guest-vbox operating system and its file system contents have been permanently deleted from host file system storage.

There are many Vagrant commands in addition to those listed above; see the Vagrant documentation. Because a Vagrant Box is also a VirtualBox, the many VirtualBox commands may be used as well.

Using vagrant-ruby-rails

While following the instructions immediately above, you ventured "inside" the guest-vbox, using "vagrant ssh" to verify the success of the build and the versions of its components. Now, let's do some exploring.

Enter the following command :

$ ls -l /

The listing which results shows a typical Ubuntu Server 16.04 root directory hierarchy, on the guest-vbox file system.

    total 92
    drwxr-xr-x  2 root    root     4096 Apr  6 20:06 bin
    drwxr-xr-x  3 root    root     4096 Apr  6 20:06 boot
    drwxrws---  1 vagrant vagrant  4096 Apr  8 08:34 vagrant
    drwxr-xr-x 13 root    root     4096 Apr 11 21:05 var
    lrwxrwxrwx  1 root    root       30 Apr  6 20:05 vmlinuz...

Notice there is one subdirectory not typically found in an Ubuntu Server root directory hierarchy. It is named "/vagrant/".

Guest VBox "/vagrant/" Subdirectory

The guest-vbox "/vagrant/" subdirectory is created by Vagrant during construction of the guest-vbox. Upon loading, "/vagrant/" is sync'd by VirtualBox to a directory you created earlier on the host file system, the one (herein) named ".../vagrant-ruby-rails/". The result of the VirtualBox sync is that guest-vbox "/vagrant/" and host ".../vagrant-ruby-rails/" are effectively "mapped into" a single directory. You can observe evidence of that by entering the following command :

$ ls -al /vagrant

Note that the guest-vbox Vagrantfile and .sh provisioning Bash files, among others, are listed.

    drwxrwxr-x  1 vagrant vagrant  4096 Jul 11 01:48 .
    drwxr-xr-x 23 root    root     4096 Jul 11 01:49 ..
    -rw-rw-r--  1 vagrant vagrant    28 Jul 11 01:43 .gitignore
    -rw-rw-r--  1 vagrant vagrant 11350 Jul 11 01:43 LICENSE
    -rw-rw-r--  1 vagrant vagrant 28552 Jul 11 01:43 README.md
    drwxrwxr-x  1 vagrant vagrant  4096 Jul 11 01:48 .vagrant
    -rw-rw-r--  1 vagrant vagrant  3050 Jul 11 01:43 Vagrantfile
    drwxrwxr-x  1 vagrant vagrant  4096 Jul 11 01:59 workspace

These are the same files you placed into ".../vagrant-ruby-rails/" after you created it, when beginning installation of vagrant-ruby-rails.

You can manage or edit those files either from "within" the guest-vbox, (in guest-vbox "/vagrant/"), or from "outside" the guest-vbox, (in host ".../vagrant-ruby-rails/").

It is important to clearly understand that the files which appear in guest-vbox "/vagrant/" can have create-read-write-delete operations done on them from that guest-vbox directory, but, those files are not stored in the guest-vbox file system. Those files reside on the host file system.

That implementation detail means that files which you place in the guest-vbox "/vagrant" subdirectory tree are not deleted by a "vagrant destroy" command. This is because those files can be referenced in guest-vbox "/vagrant", but they are stored on the host, in ".../vagrant-ruby-rails".

Conversely, any files stored on the guest-vbox file system, in any other subdirectory hierarchy, are deleted along with the guest-vbox, by a "vagrant destroy" command.

Guest VBox ".../workspace/" Subdirectory

Recall that earlier you created a subdirectory in ".../vagrant-ruby-rails/" named "workspace/". You created it while in a terminal session on the host computer, on its file system. Later, while in a "vagrant ssh" session, you created a Rails app in guest-vbox "/vagrant/workspace", and served its web pages from the server.

That is an example of how a subdirectory heirarchy in the host ".../vagrant-ruby-rails/" subdirectory can be used from "within" the guest-vbox file system.

Here is a ".../workspace/"-related tip for using Git : At some point you may wish to commit your guest-vbox Vagrantfile and .sh provisioning files to a Git repository. However, you probably do not want the files in "workspace/", or equivalent subdirectories of ".../vagrant-ruby-rails/", to be co-mingled with commits of your guest-vbox configuration/provisioning files. You can prevent that by adding the name "workspace" into your ".../vagrant-ruby-rails/.gitignore" file. The same is true of the hidden ".../vagrant-ruby-rails/.vagrant" subdirectory. See the .gitignore file which you placed into ".../vagrant-ruby-rails/" during installation.

Other Notes

Gems Documentation Is Not Built-in

In order to minimize both the build time and the storage space consumed by this guest-vbox, Gems documentation is not included during The Build.

Port Mapping

A Rails server port default number is 3000. The vagrant-ruby-rails Vagrantfile maps guest-vbox port number 3000 to host port number 3033. In order to prevent port assignment conflict with a possible previous installation of Rails on the host, port 3033 was chosen so it will not conflict with the host's Rails default port 3000. The choice of port number 3033 is arbitrary. If you wish to change this port mapping to a host port number which better suits your needs, you can do so by editing the Vagrantfile.

You may also run more than one instance of vagrant-ruby-rails guest-vbox at the same time, by revising this port mapping for each additional instance of a guest-vbox installed. You may install as many vagrant-ruby-rails Vagrant Boxes as the host has resources to run. When installing multiple guest-vboxes, the port assigment directive must be changed in the Vagrantfile before a conflicting guest-vbox is provisioned the first time. During "vagrant up", a port conflict error message notifies the operator if a conflict is detected. For more information, see the Vagrant documentation about the config.vm.network directive.

Memory (RAM) Usage

The amount of memory allocated to the guest-vbox during installation is the minimum necessary for compiling Ruby, Gems, and Rails. Based on your application needs, after installation you may wish to reduce or increase the amount of memory allocated to your guest-vbox. If that is the case, after installation of a guest-vbox, you can use the Vagrantfile directive vb.memory to change the amount of allocated memory. For more information, see the Vagrantfile documentation.

Storage Usage

VirtualBox will dynamically increase the size of the guest-vbox Ubuntu Server virtual disk drive as you add new files into its file system. The maximum virtual disk drive size of this guest-vbox Ubuntu Server is 40GB. This limit was set by the original developer of the Ubuntu Server 16.04 VirtualBox image; it cannot be changed by the user.


Provisioning is a process during which all of the components needed for the vagrant-ruby-rails guest-vbox are downloaded, built, and placed into the vagrant-ruby-rails guest-vbox. By default, Vagrant executes this time-consuming provisioning of the guest-vbox only the first time "vagrant up" is executed. Subsequent "vagrant up" commands will fetch the previously provisioned image from host local storage, rather than redundantly provisioning the guest-vbox every time "vagrant up" is executed.

The provisioning file is the Vagrantfile. Inspect the Vagrantfile, and notice the provisioning commands which are located at the end of the file, following the "config.vm.provision" directive. Notice that these are typical GNU/Linux-style commands which you might use on a command line or in a Bash shell script. By understanding how the Vagrant-specific directives, and the Bash-type commands work together, you can easily change the default versions of the components installed, or add/remove components, as desired.

Note that if you change the provisioning commands at the end of the Vagrantfile, the installed guest-vbox image will need to be rebuilt, (re-provisioned), in order to implement those changes. The guest-vbox is re-provisioned by executing the "vagrant provision" command.

See the Vagrant documentation for more information about provisioning Vagrant Boxes.

Installing Vagrant

The vagrant-ruby-rails guest-vbox is built and managed by Vagrant. The specific version of Vagrant used on the vagrant-ruby-rails project development computer is Vagrant 1.9.3. You may have success with other versions of Vagrant, but the vagrant-ruby-rails project has been built/tested using only 1.9.3.

Vagrant installation is typically not difficult for those persons familiar with installation of software on their operating system.

For Vagrant installation instructions, please visit the Vagrant web site : http://docs.vagrantup.com/v2/installation/index.html

Installing VirtualBox

vagrant-ruby-rails uses VirtualBox as the provider. The specific version of VirtualBox used as the provider on the vagrant-ruby-rails project development computer is VirtualBox 5.1.14 (AMD64). You will probably have success with slightly differing versions of VirtualBox, or the most recent stable version, but the vagrant-ruby-rails project has not tested those.

VirtualBox installation is typically not difficult for those persons familiar with installation of software on their operating system.

For VirtualBox installation instructions, please visit the VirtualBox web site : https://www.virtualbox.org/


The Vagrantfile specifies that the operating system image to be loaded during provisioning is bento/ubuntu-16.04-i386, which is a 32-bit CPU image. An i386 image is not strictly required; as an alternative, you may use a 64-bit Ubuntu Linux image, or possibly some other compatible (e.g., Debian-based), distibution of Linux, if necessary. If that is the case, revise the Vagrantfile to specify some other image; e.g., to install 64 bit Ubuntu instead of 32 bit, find and change:

    config.vm.box = "bento/ubuntu-16.04-i386"


    config.vm.box = "bento/ubuntu-16.04".

An image specifier of bento/ubuntu-16.04 downloads and starts a 64-bit version of Ubuntu 16.04.2. For more information, or to use other compatible versions of Linux, see the Bento page on Hashicorp's website : https://app.vagrantup.com/bento

A different version of OS may be specified immediately after installing the Vagrantfile in its directory, or after "vagrant up" has been executed. If you previously provisioned a guest-vbox, then after revising the Vagrantfile to specify a different OS image, you must execute "vagrant destroy", which removes the existing guest-vbox; this is the only way to remove the existing OS image. Then execute "vagrant up". This downloads the new VirtualBox OS image from the Hashicorp Bento repository, and it is used to build a new guest-vbox. Beware that if you "vagrant destroy" an existing guest-vbox image, any files residing in the virtual file system of the existing guest-vbox image will be destroyed as well.

Misc Troubleshooting Tips
"Vagrant SSH" Times Out

If "vagrant ssh" times out while attempting to shell into the guest-vbox, one cause may be that the guest-box image requires a 64-bit installation of VirtualBox, but your host is capable of only 32-bit guests. Also, it is possible that some guest-box image you have installed is simply defective. As an example, prompting for a password during boot has been observed with the ubuntu/xenial64 guest-vbox. Consider trying a different guest-vbox image. See "Using Bento/Ubuntu-16.04-i386", above.

Remote SSH Times Out

When using ssh from a remote terminal to shell into the guest-vbox, if it times out instead of presenting a guest-vbox prompt, investigate the host firewall settings and ensure it does not block the guest-vbox ssh port. The default ssh port number of the guest-vbox is 2222.

If The Build Fails

First, ensure you save the terminal output messages of the "vagrant up" provisioning build for future reference. This is usually easily done by backscrolling the terminal, highlighting the terminal text, and then doing copy-paste into a file, and saving it.

Only you have access to the necessary configuration information about your host, so the only practical advice which can be offered here is :

Divide And Conquer

Identify the "milestone" at which the provisioning error occurred. Inspect the install.sh provisioning file. Find the milestone locations in the Vagrantfile at which the terminal messages indicate an eror, (notice echoed markers "-->"). Narrow down which milestone succeeded, and which did not. Once you find the most likely script commands, investigate as to why that particular command may have failed.

It's possible for a build to fail for quite a few reasons. Some are :

  • Unreliable Internet connection.

  • One or more web sites which provide source code, or build scripts, have become unavailable, (broken links, temporarily or permanently offline).

  • Missing, misconfigured, or incompatible versions of Vagrant or VirtualBox.

After you have found something suspicious, address it, either by changing some configuration of your host, (most likely to resolve the problem), or by modifying the Vagrantfile custom provisioning script, (see broken links, above).

Then, try again to "vagrant up" vagrant-ruby-rails. Before doing so, be aware that the Vagrantfile provisioning script is not idempotent, meaning, the likelyhood of producing a correctly provisioned vagrant-ruby-rails Vagrant Box is low if you simply re-run "vagrant up" after installation failed, even after you have implemented a "guaranteed" fix for an error. Unless you know otherwise, your best course of action after implementing an error correction is to execute "vagrant destroy", and then execute "vagrant up" again.

The Short List Of Online References

If you are unfamiliar with the products in this document, you may wish to inform yourself about them. The references "short list" is :

Vagrant : https://docs.vagrantup.com/v2/
VirtualBox : https://www.virtualbox.org/
Ruby On Rails : http://rubyonrails.org/
Ruby : https://www.ruby-lang.org/en/
Ruby Gems : https://rubygems.org/
Git : http://git-scm.com/
Node.js : https://nodejs.org/

Caveats And Known Issues

"works on my machine"

This software package, at this time, is in the alpha stage of development. Extensive testing has not been done on its components, only its gross operation has been confirmed . Host hardware and host OS environment testing has been limited to a single generic AMD/Ubuntu box used for development.

Your feedback is appreciated, especially with regard to success or problems using this software on OS X.

Licensing And Disclaimer

USE THIS SOFTWARE AT YOUR OWN RISK. The original author and other contributors are not responsible or liable for adverse consequences caused by use of this software, even if used as designed or intended, or as described or implied, herein or elsewhere.

Please read the Apache License, Version 2.0 included with this README file for important licensing information and disclaimers.

Copyright 2018 Rex Addiscentis, all rights reserved.