VMware vSphere Integrated Containers provider (#206)

* Add Virtual Kubelet provider for VIC

Initial virtual kubelet provider for VMware VIC.  This provider currently
handles creating and starting of a pod VM via the VIC portlayer and persona
server.  Image store handling via the VIC persona server.  This provider
currently requires the feature/wolfpack branch of VIC.

* Added pod stop and delete.  Also added node capacity.

Added the ability to stop and delete pod VMs via VIC.  Also retrieve
node capacity information from the VCH.

* Cleanup and readme file

Some file clean up and added a Readme.md markdown file for the VIC
provider.

* Cleaned up errors, added function comments, moved operation code

1. Cleaned up error handling.  Set standard for creating errors.
2. Added method prototype comments for all interface functions.
3. Moved PodCreator, PodStarter, PodStopper, and PodDeleter to a new folder.

* Add mocking code and unit tests for podcache, podcreator, and podstarter

Used the unit test framework used in VIC to handle assertions in the provider's
unit test.  Mocking code generated using OSS project mockery, which is compatible
with the testify assertion framework.

* Vendored packages for the VIC provider

Requires feature/wolfpack branch of VIC and a few specific commit sha of
projects used within VIC.

* Implementation of POD Stopper and Deleter unit tests (#4)

* Updated files for initial PR

vendor/github.com/vmware/vic/lib/archive/util.go

@@ -0,0 +1,147 @@
+// Copyright 2016-2017 VMware, Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package archive
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	// CopyTo is used to indicate that the desired filter spec is for a CopyTo direction
+	CopyTo = true
+
+	// CopyFrom is used to indicate that the desired filter spec is for the CopyFrom direction
+	CopyFrom = false
+)
+
+// GenerateFilterSpec will populate the appropriate relative Rebase and Strip paths based on the supplied scenarios.
+// Inclusion/Exclusion should be constructed separately. Please also note that any mount that exists before the copy
+// target that is not primary and comes before the primary target will have a bogus filterspec, since it would not be
+// written or read to.
+func GenerateFilterSpec(copyPath string, mountPoint string, primaryTarget bool, direction bool) FilterSpec {
+	var filter FilterSpec
+
+	// NOTE: this solidifies that this function is very heavily designed for docker cp behavior.
+	// which is why this should mainly only be used by the docker personality
+	// scrub trailing '/' before passing copyPath along and create a Clean fs path
+	copyPath = strings.TrimSuffix(copyPath, "/")
+
+	// Note I know they are just booleans, if that changes then this statement will not need to.
+	if direction == CopyTo {
+		filter = generateCopyToFilterSpec(copyPath, mountPoint, primaryTarget)
+	} else {
+		filter = generateCopyFromFilterSpec(copyPath, mountPoint, primaryTarget)
+	}
+
+	filter.Exclusions = make(map[string]struct{})
+	filter.Inclusions = make(map[string]struct{})
+	return filter
+}
+
+func generateCopyFromFilterSpec(copyPath string, mountPoint string, primaryTarget bool) FilterSpec {
+	var filter FilterSpec
+
+	// If the copyPath ends with '/.', we don't want the content's directory name
+	// to be included in the resulting tar header. we do this by removing the directory
+	// portion of the rebase path.
+	// if the copyPath does not end with '/.', we only need the right most element of copyPath.
+	first := filepath.Base(copyPath)
+	if first == "." {
+		first = ""
+		copyPath = Clean(copyPath, false)
+	}
+
+	// primary target was provided so we wil need to split the target and take the right most element for the rebase.
+	// then strip set the strip as the target path.
+	if primaryTarget {
+		filter.RebasePath = Clean(first, true)
+		filter.StripPath = Clean(strings.TrimPrefix(copyPath, mountPoint), true)
+		return filter
+	}
+
+	// non primary target was provided. in this case we will need rebase to include the right most member of the target(or "/") joined to the front of the mountPath - the target path. 3
+	filter.RebasePath = Clean(filepath.Join(first, strings.TrimPrefix(mountPoint, copyPath)), true)
+	filter.StripPath = ""
+	return filter
+}
+
+func generateCopyToFilterSpec(copyPath string, mountPoint string, primaryTarget bool) FilterSpec {
+	var filter FilterSpec
+
+	// primary target was provided so we will need to rebase header assets for this mount to have the target in front for the write.
+	if primaryTarget {
+		filter.RebasePath = Clean(strings.TrimPrefix(copyPath, mountPoint), true)
+		filter.StripPath = ""
+		return filter
+	}
+
+	// non primary target, this implies that the asset header has part of the mount point path in it. We must strip out that part since the non primary target will be mounted and be looking at the world from it's own root "/"
+	filter.RebasePath = ""
+	filter.StripPath = Clean(strings.TrimPrefix(mountPoint, copyPath), true)
+
+	return filter
+}
+
+func AddMountInclusionsExclusions(currentMount string, filter *FilterSpec, mounts []string, copyTarget string) error {
+	if filter == nil {
+		return fmt.Errorf("filterSpec for (%s) was nil, cannot add exclusions or inclusions", currentMount)
+	}
+
+	if filter.Exclusions == nil || filter.Inclusions == nil {
+		return fmt.Errorf("either the inclusions or exclusions map was nil for (%s)", currentMount)
+	}
+
+	if strings.HasPrefix(copyTarget, currentMount) && copyTarget != currentMount {
+
+		inclusion := Clean(strings.TrimPrefix(copyTarget, currentMount), true)
+
+		if filepath.Base(copyTarget) == "." {
+			inclusion += "/"
+		}
+
+		filter.Inclusions[inclusion] = struct{}{}
+		filter.Exclusions[""] = struct{}{}
+	} else {
+		// this would be a mount that is after the target. It would mean we have to include root. then exclude any mounts after root.
+		filter.Inclusions[""] = struct{}{}
+	}
+
+	for _, mount := range mounts {
+		if strings.HasPrefix(mount, currentMount) && currentMount != mount {
+			// exclusions are relative to the mount so the leading `/` should be removed unless we decide otherwise.
+			exclusion := Clean(strings.TrimPrefix(mount, currentMount), true) + "/"
+			filter.Exclusions[exclusion] = struct{}{}
+		}
+	}
+	return nil
+}
+
+// Clean run filepath.Clean on the target and will remove leading
+// and trailing slashes from the target path corresponding to supplied booleans
+func Clean(path string, leading bool) string {
+	path = filepath.Clean(path)
+	// path returns '.' if the result of the Clean was an empty string.
+	if path == "." {
+		return ""
+	}
+
+	if leading {
+		path = strings.TrimPrefix(path, "/")
+	}
+
+	return path
+}