This commit will add an interface `SetEnvironmentParams` to
metadata.Manager that allows setting of env params.

Also implements the logic for parsing the jsonnet snippet to
append / modify params in simple env param schemas. It will:

1. Update the params if the component exists in the jsonnet
snippet.
2. Add the component if it does not exist.

This commit will add an interface `GetComponentParams` to
metadata.Manager that returns a map of parameters for the passed in
component.

Also implements the logic for parsing the jsonnet snippet to retrieve
the parameters.

This functionality will later support new commands to list parameters.

This commit will:

1. Add an interface `SetComponentParams` to metadata.Manager that takes
a list of parameters and sets those fields for the given component.

2. Add the jsonnet snippet manipulation logic that does the
'setting'. Parameters are set by:

a. Keeping track of the parameters that are to be modified / added --
this defaults to the parameters provided to us.
b. Discovering the current parameters in the existing snippet.
c. Adding any parameters from (b) that is not in (a).
d. Swapping out the old parameters with (c) in the snippet based on
the location text span, and returning the new snippet.

This commit will append both mandatory and optional  prototype
parameters to the component params.libsonnet file on `ks gen foo ...`.

Default values will be used for optional params where the user does not
specify flags to `ks gen foo ...`.

Because we are trying to append to jsonnet, we will have to traverse the
AST to first identify the location of where to insert the new component
params. New components will be inserted at the bottom of the components
object, with the params ordered alphabetically.

Expose the import path to environments/:env/params.libsonnet as an
ExtCode so that it is made accessible to component files during
expansion.

This commit will generate the `environments/<env>/params.libsonnet` file
on `env add <env>`.

The purpose of this file is to allow users to define custom parameters
on an environment-to-environment basis. It is meant to allow for
"overrides" to component params.

The purpose of this file is to allow re-parameterization of components
after they are created.

`components/params.libsonnet` is generated on `ks init`. This file will
contain a jsonnet obj containing two objs:

1. global: contains user-defined global parameters; accessible to all
component and environments.
2. components: contains component-level parameters, defined initially
from `ks prototype use ...`

These objs are empty by default.

'server' is consistent with what is used by clientgo. 'uri' only
introduces new language to ksonnet with the same meaning.

Environments currently have the concept of a server URI, but it is
ambiguous which cluster namespace to use.

This commit will introduce the concept of namespaces to the env
commands.

For example,
`kubecfg env add staging http://mock-staging-uri \
 --namespace=staging-namespace`
`kubecfg env set staging --namespace=staging-namespace`

The default environment will use the namespace of the default context.

This commit will also update commands that take the <env> arg such as
`apply` to make use of the env namespace, if specified.

Commands that take `env` as a param currently expand all files in the
`components` directory. This is no longer necessary with the
introduction of `base.libsonnet` and the per-environment override
`<env>.jsonnet` file.

This commit will simply expand the single `<env>.jsonnet` file (which
will implicitly expand all component files). The case of running
`ksonnet apply default`, is equivalent to running `ksonnet apply -f
environments/default/default.jsonnet`.

This commit will generate an "<env-name>.jsonnet" file when an
environment is created.

For example, the default environment would have the following tree
structure:
├── environments
│   ├── base.libsonnet
│   └── default
│       ├── .metadata
│       │   ├── k.libsonnet
│       │   ├── k8s.libsonnet
│       │   └── swagger.json
│       ├── default.jsonnet
│       └── spec.json

The goal of this file is to allow users to extend on base.libsonnet on a
per-environment basis to allow for custom overrides, such as replica
count.

base.libsonnet is a generated file that exists at the root of the
environments directory. This file is generated for all ksonnet projects.
The main goal of this file is to import all components in the components
directory, so that environments are able to easily extend / override any
one of these components in a modular structure.

This change simply hides the environment metadata details that we do not
want users directly modifying into a .metadata folder.

There is a bug where if --name is not passed during env set, an error is
thrown due to failed validation checking on an empty name. This commit
fixes this bug.

Currently the command 'prototype use' expands a prototype and prints to
stdout. This is useful, but most of the time, users want to simply dump
the result in 'components/'

This command implements this print-to-stdout behavior in a new command,
'prototype-preview', and reimplements 'prototype use' to drop the
expanded prototype into 'components/'.

The new form of this command is:

  ksonnet prototype use <prototype-name> <component-name> [type] [flags]

So, for example, a command like:

  ksonnet prototype use deployment nginx-depl [...]

would expand the 'deployment' prototype, and place it in
'components/nginx-depl.jsonnet' (since Jsonnet is the default template
expansion). Alternatively, something like this:

  ksonnet prototype use deployment nginx-depl yaml [...]

would expand the prototype and place it in 'components/nginx-depl.yaml'
(assuming that there is a YAML version of this template.

Currently `metadata.isValidName` will admit names that should be invalid
(e.g., names with spaces, leading '/' characters) and not admit names
that should be valid (e.g., names with '.' characters inside).

This commit moves this function into `metadata/interface.go` and hardens
it against these constraints.

When we run `init`, currently we generate a simple environment called
'default' with no URI. A better idea is to generate the URI from the
current context of the active kubeconfig file, if it exists.

For example, 'apply <env' currently operates as a no-op. With the
introduction of simple environments in PR #131, 'apply <env>' should
perform basic validation such that:

1. The user has added the environment that is being deployed against to
their Ksonnet project.

2. The URI in the environment's spec file that the user wishes to deploy
to should correspond to at least one cluster location as listed in
kubeconfig.

If either of those conditions are not satisfied, the kubecfg user will
receive the corresponding error.

In addition, this commit will set the kubectl --cluster flag to point at
the cluster listed by the environment URI.

Under certain circumstances, it is possible for operations to fail
because of permissions that are too restrictive. Here we adopt the
default permissions of 0755 (i.e., rwxr-xr-x), which should be a better
balance of restriction and flexibility.

This commit will add logging to all env subcommands 'list', 'set',
'add', and 'rm'. It adds both Info level and Debug level logging.

Fixes #137

Currently all files and folders created with the `metadata.Manager`
(which is the core FS management subsystem) are created with permissions
0777, i.e., everyone has all permissions.

This commit transistions us to a more locked down permissions set, 0644,
which allows the user to do everything except execute, and everyone else
to only read.

Since we don't store any app code that needs to be executed, this should
be suitable for everything.

Fixes #136.

'env set <name>' sets environment fields such as the name, and cluster
URI. It currently accepts the flags '--name' and '--uri'. Changing the
name of an environment will also update the directory structure in
'environments'.

'env rm <env-name>' deletes an environment within a ksonnet project.
This is the same as removing the <env-name> environment directory and
all files contained.  Empty parent directories will also be removed.

'env list' will list all environments within a Ksonnet project. Each
environment will be pretty-printed with it's name and cluster URI
location.

'env add <env-name> <env-uri>' will create a new environment within a
ksonnet project, by generating a new directory, 'env-name', within the
'envs' directory. Each environment will contain environment-specfic
files. Notably, a new environment-specific file is 'spec.json'.
'spec.json' currently only contains the 'env-uri' of the Kubernetes
cluster located at the added environment.

Below is an example directory structure for the environment
'us-west/staging':

app-name/
  .gitignore           Default .gitignore; can customize VCS
  .ksonnet/            Metadata for ksonnet
  environments/        Env specs (defaults: dev, test, prod)
    default/           [Default generated environment.]
    us-west/           [Example of user-generated env]
      staging/
        k.libsonnet
        k8s.libsonnet
        swagger.json
        spec.json      [This will contain the uri of the environment]
  components/          Top-level Kubernetes objects defining application
  lib/                 user-written .libsonnet files
  vendor/              mixin libraries, prototypes

This commit fixes #113, causing us to emit `k.libsonnet` (a collection
of extensions to the k8s API) by updating the dependency on
`ksonnet-lib/ksonnet-gen` and exercising the new signature for
`ksonnet.Emit`, which handles this automatically.

We update the `vendor/` directory and the code that depends on it in the
same commit so that we don't break bisect.

This commit will remove the vendor/lib and vendor/schema directories
generated by 'init'. An 'environments' directory will be created from
the root app directory, with the default environment directory 'dev'
and it's containing contents rooted at 'environments'.

The intention of environments are to represent the deployment
environments of Kubernete clusters, with the following example
directory structure:

app-name/
  ..
  envs/
    dev/
    us-west/
      prod/
      staging/

Currently, if the user wants to deploy a ksonnet application, and that
application uses some vendored library, or something in the `lib/`
directory, they will have to pass the appropriate `-J` flags into the
command themselves.

This commit will automatically add these whenever we're in an app
directory and a command is issued. In particular, even if the user
passes in the `-f` flag (rather than an environment name), we'll still
add library paths to the command if we're in a ksonnet app directory.
This is meant to capture the case that a user wants to update one
resource in particular in a ksonnet application.

This commit will introduce the ability of the `metadata.Manager` to
report every file in the `components/` directory.

This is primarily useful when we invoke the Jsonnet VM, as it requires a
list of files to expand. (The `template.Expander` also handles YAML and
JSON.)

`metadata.ClusterSpec` represents a specification for an abstract
Kubernetes cluster. For example, `version:1.7.0` represents a Kubernetes
cluster running a build from 1.7.0. This specification is primarily used
to generate ksonnet-lib.

This struct exposes a method, `data` that will retrieve the OpenAPI JSON
that specifies the API for a Kubernetes cluster. Eventually, `data` will
be able to read a file, pull from a URL, pull from a live cluster, or
pull a specific version of the API from the official Kubernetes
repository.

This commit introduces the the last of these options.

`metadata.Init` is meant to initialize a ksonnet application, including
its directory structure and the initial versions of various metadata
files in the tree. But, this implementation is incomplete: currently
only the directory tree is initialized.

This commit will change init to generate ksonnet-lib as part of the
initialization process.

Much of the tooling build around ksonnet applications will be powered by
metadata presented in a structured directory format. This is similar in
principle to how Hugo and Rails structure web applications.

This commit will begin the process of introducing a FS-based state
machine that manages this directory structure. Primarily, this involves
introducing:

1. Init routines for the directory structure
2. Routines to search parent directories for a ksonnet application
   (similar to how git does this with repositories)

Initially, the directory structures looks like this:

  app-name/
    .ksonnet/   Metadata for ksonnet
    components/ Top-level Kubernetes objects defining application
    lib/        User-written .libsonnet files
    vendor/     Mixin libraries, prototypes

The `.ksonnet` file marks the application root, making it possible to
search parent directories for the root.

As time continues, more verbs will be introduced to manipulate this
metadata (including, e.g., vendoring dependencies, searching prototypes,
and so on).