func Init(ctx context.Context, sess *session.Session) error {
source, err := extraconfig.GuestInfoSource()
if err != nil {
return err
}
f := find.NewFinder(sess.Vim25(), false)
extraconfig.Decode(source, &exec.VCHConfig)
log.Debugf("Decoded VCH config for execution: %#v", exec.VCHConfig)
ccount := len(exec.VCHConfig.ComputeResources)
if ccount != 1 {
detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount)
log.Errorf(detail)
return err
}
cr := exec.VCHConfig.ComputeResources[0]
r, err := f.ObjectReference(ctx, cr)
if err != nil {
detail := fmt.Sprintf("could not get resource pool or virtual app reference from %q: %s", cr.String(), err)
log.Errorf(detail)
return err
}
switch o := r.(type) {
case *object.VirtualApp:
exec.VCHConfig.VirtualApp = o
exec.VCHConfig.ResourcePool = o.ResourcePool
case *object.ResourcePool:
exec.VCHConfig.ResourcePool = o
default:
detail := fmt.Sprintf("could not get resource pool or virtual app from reference %q: object type is wrong", cr.String())
log.Errorf(detail)
return errors.New(detail)
}
// we have a resource pool, so lets create the event manager for monitoring
exec.VCHConfig.EventManager = vsphere.NewEventManager(sess)
// configure event manager to monitor the resource pool
exec.VCHConfig.EventManager.AddMonitoredObject(exec.VCHConfig.ResourcePool.Reference().String())
// instantiate the container cache now
exec.NewContainerCache()
// need to blacklist the VCH from eventlistening - too many reconfigures
vch, err := guest.GetSelf(ctx, sess)
if err != nil {
return fmt.Errorf("Unable to get a reference to the VCH: %s", err.Error())
}
exec.VCHConfig.EventManager.Blacklist(vch.Reference().String())
// other managed objects could be added for the event stream, but for now the resource pool will do
exec.VCHConfig.EventManager.Start()
//FIXME: temporary injection of debug network for debug nic
ne := exec.VCHConfig.Networks["client"]
if ne == nil {
detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present")
log.Errorf(detail)
return err
}
nr := new(types.ManagedObjectReference)
nr.FromString(ne.Network.ID)
r, err = f.ObjectReference(ctx, *nr)
if err != nil {
detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err)
log.Errorf(detail)
return err
}
exec.VCHConfig.DebugNetwork = r.(object.NetworkReference)
extraconfig.Decode(source, &network.Config)
log.Debugf("Decoded VCH config for network: %#v", network.Config)
for nn, n := range network.Config.ContainerNetworks {
pgref := new(types.ManagedObjectReference)
if !pgref.FromString(n.ID) {
log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID)
}
r, err = f.ObjectReference(ctx, *pgref)
if err != nil {
log.Warnf("could not get network reference for %s network", nn)
continue
}
n.PortGroup = r.(object.NetworkReference)
}
// Grab the storage layer config blobs from extra config
extraconfig.Decode(source, &storage.Config)
log.Debugf("Decoded VCH config for storage: %#v", storage.Config)
// Grab the AboutInfo about our host environment
about := sess.Vim25().ServiceContent.About
exec.VCHConfig.VCHMhz = exec.NCPU(ctx)
exec.VCHConfig.VCHMemoryLimit = exec.MemTotal(ctx)
exec.VCHConfig.HostOS = about.OsType
exec.VCHConfig.HostOSVersion = about.Version
exec.VCHConfig.HostProductName = about.Name
log.Debugf("Host - OS (%s), version (%s), name (%s)", about.OsType, about.Version, about.Name)
log.Debugf("VCH limits - %d Mhz, %d MB", exec.VCHConfig.VCHMhz, exec.VCHConfig.VCHMemoryLimit)
return nil
}
// Creates a tar archive in memory for each layer and uses this to test image creation of layers
func TestCreateImageLayers(t *testing.T) {
numLayers := 4
cacheStore, client, parentPath, err := setup(t)
if !assert.NoError(t, err) {
return
}
vsStore := cacheStore.DataStore.(*ImageStore)
defer cleanup(t, client, vsStore, parentPath)
op := trace.NewOperation(context.Background(), "test")
storeURL, err := cacheStore.CreateImageStore(op, "testStore")
if !assert.NoError(t, err) {
return
}
// Get an image that doesn't exist and check for error
grbg, err := cacheStore.GetImage(op, storeURL, "garbage")
if !assert.Error(t, err) || !assert.Nil(t, grbg) {
return
}
// base this image off scratch
parent, err := cacheStore.GetImage(op, storeURL, portlayer.Scratch.ID)
if !assert.NoError(t, err) {
return
}
// Keep a list of all files we're extracting via layers so we can verify
// they exist in the leaf layer. Ext adds lost+found, so add it here.
expectedFilesOnDisk := []string{"lost+found"}
// Keep a list of images we created
expectedImages := make(map[string]*portlayer.Image)
expectedImages[parent.ID] = parent
for layer := 0; layer < numLayers; layer++ {
dirName := fmt.Sprintf("dir%d", layer)
// Add some files to the archive.
var files = []tarFile{
{dirName, tar.TypeDir, ""},
{dirName + "/readme.txt", tar.TypeReg, "This archive contains some text files."},
{dirName + "/gopher.txt", tar.TypeReg, "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
{dirName + "/todo.txt", tar.TypeReg, "Get animal handling license."},
}
for _, i := range files {
expectedFilesOnDisk = append(expectedFilesOnDisk, i.Name)
}
// meta for the image
meta := make(map[string][]byte)
meta[dirName+"_meta"] = []byte("Some Meta")
meta[dirName+"_moreMeta"] = []byte("Some More Meta")
meta[dirName+"_scorpions"] = []byte("Here I am, rock you like a hurricane")
// Tar the files
buf, terr := tarFiles(files)
if !assert.NoError(t, terr) {
return
}
// Calculate the checksum
h := sha256.New()
h.Write(buf.Bytes())
sum := fmt.Sprintf("sha256:%x", h.Sum(nil))
// Write the image via the cache (which writes to the vsphere impl)
writtenImage, terr := cacheStore.WriteImage(op, parent, dirName, meta, sum, buf)
if !assert.NoError(t, terr) || !assert.NotNil(t, writtenImage) {
return
}
expectedImages[dirName] = writtenImage
// Get the image directly via the vsphere image store impl.
vsImage, terr := vsStore.GetImage(op, parent.Store, dirName)
if !assert.NoError(t, terr) || !assert.NotNil(t, vsImage) {
return
}
assert.Equal(t, writtenImage, vsImage)
// make the next image a child of the one we just created
parent = writtenImage
}
// Test list images on the datastore
listedImages, err := vsStore.ListImages(op, parent.Store, nil)
if !assert.NoError(t, err) || !assert.NotNil(t, listedImages) {
return
}
for _, img := range listedImages {
if !assert.Equal(t, expectedImages[img.ID], img) {
return
}
}
// verify the disk's data by attaching the last layer rdonly
roDisk, err := mountLayerRO(vsStore, parent)
if !assert.NoError(t, err) {
return
}
p, err := roDisk.MountPath()
if !assert.NoError(t, err) {
return
}
rodiskcleanupfunc := func() {
if roDisk != nil {
if roDisk.Mounted() {
roDisk.Unmount()
}
if roDisk.Attached() {
vsStore.dm.Detach(op, roDisk)
}
}
os.RemoveAll(p)
}
filesFoundOnDisk := []string{}
// Diff the contents of the RO file of the last child (with all of the contents)
err = filepath.Walk(p, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
f := path[len(p):]
if f != "" {
// strip the slash
filesFoundOnDisk = append(filesFoundOnDisk, f[1:])
}
return nil
})
if !assert.NoError(t, err) {
return
}
rodiskcleanupfunc()
sort.Strings(filesFoundOnDisk)
sort.Strings(expectedFilesOnDisk)
if !assert.Equal(t, expectedFilesOnDisk, filesFoundOnDisk) {
return
}
// Try to delete an intermediate image (should fail)
exec.NewContainerCache()
err = cacheStore.DeleteImage(op, expectedImages["dir1"])
if !assert.Error(t, err) || !assert.True(t, portlayer.IsErrImageInUse(err)) {
return
}
// Try to delete a leaf (should pass)
leaf := expectedImages["dir"+strconv.Itoa(numLayers-1)]
err = cacheStore.DeleteImage(op, leaf)
if !assert.NoError(t, err) {
return
}
// Get the delete image directly via the vsphere image store impl.
deletedImage, err := vsStore.GetImage(op, parent.Store, leaf.ID)
if !assert.Error(t, err) || !assert.Nil(t, deletedImage) || !assert.True(t, os.IsNotExist(err)) {
return
}
}