Adds a new grape-based RESTful API to support "GET" ops on the node/model slices
(along with a corresponding grape-swagger-style documentation layer for the RESTful
API that we are adding)
Adds in a new grape-stype RESTful API for the boot/config/image slices
(and removes some extraneous code from the model/node slice APIs that
have already been added).  Also includes modifications to Razor to
support an additional configuration parameter that can be used to set
the web-service root context (websvc_root) and assigned it a reasonable
default value if it's undefined (/razor/api/vi).

Note; with these changes in place we can now boot a node into the
Razor Microkernel using our newly-defined grape-style RESTful API
added in tests for accessiblity of a few of the resources defined to date
(specifically, added tests for accessibility of the /config, /config/ipxe,
and /boot resources; the first two should only be accessible directly from
the Razor server and the last should only be accessible from the Razor
subnet
Separates out tests for whether the request came from the razor subnet or the razor server into a separate module (to avoid copy-and-paste coding issues).
Adds limits for access to /image (razor server only) and /image/{path} (razor subnet only) endpoints of our grape-style RESTful API
Changes to hide some of the endpoints from the swagger-ui-based documentation
layer; with these changes in place, the boot and config slice RESTful endpoints
are hidden from the swagger-ui-based documentation layer, as is the RESTful
endpoint in the image slice API that can be used to retrieve files from
an image (by UUID).  None of this functionality is meant to be accessed by
end-users, and any end-user attempting to access the functionality will
see an error returned anyway (unless they are on the Razor server or, in
some cases, on the Razor subnet).
Adds checkin and registration functionality to the new "node" RESTful API
(and adds a utility method to the ApiUtils module that can be used to validate
parameters that are passed in via the RESTful API (or the CLI)
Adds an active_model endpoint and support for a POST to the model endpoint.
Also adds a stub for a PUT to the model endpoint (to update an existing model),
cleans up the usage of some of the other endpoints to make their usage more
consistent.  This includes modifications to the node registration endpoint to parse
the hw_id, last_state, and attributes_hash values directly from the HTTP request
body (which is assumed to be in the form of a JSON-formatted string) instead of
parsing it from a more generic "json_hash" form field (which contained a reference
to that same JSON-formatted string).  It should be noted that this last change requires
a newer version of the Razor Microkernel (one that will pass this metadata using the
new scheme) in order to work; older versions of the Microkernel will fail to register
with this newer Razor server.
Adds in additional functionality to remove instances and update instances to existing endpoints.
Also includes a bit of code cleanup and adds an accessor function to the existing slice API
(so that we can determine if a given object is a "uri_root") and onverts "error!" calls used
by earlier versions to code that raises (and handles) a ProjectRazor::Error::Slice::MethodNotAllowed
exception instead; this should make the behavior more consistent with what was seen in previous
versions of Razor (and less Rack-specific)
Adds the policy slice to our new (grape-based) RESTful API; includes all capabilities from the current Razor RESTful API.
Also added in description tags to hide some of the endpoints that have been added recently from the swagger-ui-based
documentation layer and cleaned up a few copy-and-paste problems in some of the comments in the codebase.
Fixes a few copy-and-paste errors in the grape-based policy resource we just added to our RESTful API (and cleans up a few comments)
Adds the RESTful APIs for the broker and tag slices
Changes to make all of the responses consistent (previously, some of the responses were not using the same format as is used in the current version of Razor).  Also added the "GET" on images by UUID back into the API (again, to make it more consistent with the API used in Razor v1) and changed the names of the utility methods used to construct the responses back to the user by Razor to make it clearer what they were returning (from response_with_status_web to slice_success_object_array and from slice_success_web to slice_success_response).  Finally, got rid of the local references to the slice framework (replacing them all with a class-level constant that refers to an appropriate slice object in each part of the API).
Fixes up a couple of copy-and-paste errors that crept into the code
Fixes how the responses for collections of elements are handled

When a collection is returned in response to a RESTful request, the response should now only
include a limited number of fields (the @uuid, @classname, and @noun fields) for each element
plus a URI that can be used to access the details for that element of the collection.  Previously,
the full details were returned whenever a collection of size 1 was detected (meaning that the
response would change format depending on how many elements were in the collection).  The
key that determines the behavior now is whether or not the object being returned responds to
the method named "collection".  If so, then a summary of the elements in the collection is
returned (the proper behavior), otherwise the full details of the object (a single element, not
a collection) will be returned.  This is much more consistent behavior than exists even in the
current version of Razor (which changes what it returns depending on whether the collection
that is being returned has a single element in it or multiple elements in it).  To more closely
reflect this change, we have also refactored the method names that are used to return an object
(either a single object or a collection of objects) as part of the request.  That functionality is
now under the 'slice_success_object' method in 'helpers' section of the various API classes
(in previous versions of these classes, this appeared as the 'slice_success_object_array'
method) and it invokes the 'Razor::WebService::Utils::rz_slice_success_object' (rather than the
'Razor::WebService::Utils::rz_slice_success_object_array' method that was invoked by previous
versions of this same method)
Modified to handle RESTful queries for policy templates, model templates, and broker plugins like other objects.
Now, templates and plugins behave like any other Razor object (in terms of what's returned
from a RESTful query).  Collections of templates/plugins are returned as summary lists
containing a URI and calls for a specific plugin/template return detailed information for that
plugin/template)
Changes to invert things so that the CLI slices call into the RESTful API that was added in earlier commits.  With these changes in place, we now have a standalone Razor server where all of the CLI slice methods call into the RESTful APIs provided by that server, and the methods behind those RESTful APIs do the heavy lifting of interfacing with the underlying Razor server codebase...
Fixes problem with how the meta-data gathered using the cli_create_metadata method is carried through to the RESTful API (where it's used when creating/updating broker and model objects).  Previously, the meta-data entered by the user (if any) when this method was called didn't carry through to the RESTful request (and was lost).  As a result, only default values could be used for these model/broker-specific meta-data fields.  The changes in this commit fix that problem.
Fixes an error that was thrown when getting a node's details using a command like "razor get (UUID)" and fixes a couple of spurious problems (a copy-and-paste error in the label output by the command and a debugging statement that shouldn't have been committed) in the "tag update matcher" output.
Fixes issue with UUID generation in a multi-threaded environment (by turning off use
of the state file used by the uuid gem; see documentation at http://rubydoc.info/gems/uuid/2.3.7/frames
for more details).  Also fixes an issue with the pattern used in the "is_uuid?" helper
method used throughout our RESTful API classes and makes note of another error that was
seen that traced back into the engine class (added a "ToDo" to that class to track the error
and see if it crops up again since we haven't been able to recreate it).  If it doesn't
show up again, perhaps it's related to the issue seen with the UUID gem, above.