func createAppliance(ctx context.Context, sess *session.Session, conf *config.VirtualContainerHostConfigSpec, vConf *data.InstallerData, hasErr bool, t *testing.T) {
var err error
d := &Dispatcher{
session: sess,
ctx: ctx,
isVC: sess.IsVC(),
force: false,
}
delete(conf.Networks, "bridge") // FIXME: cannot create bridge network in simulator
if d.isVC {
if d.vchVapp, err = d.createVApp(conf, vConf); err != nil {
// FIXME: Got error: ServerFaultCode: ResourcePool:resourcepool-14 does not implement: CreateVApp. Simulator need to implement CreateVApp
// t.Errorf("Unable to create virtual app: %s", err)
}
}
if d.vchPool, err = d.createResourcePool(conf, vConf); err != nil {
t.Errorf("Unable to create resource pool: %s", err)
}
spec, err := d.createApplianceSpec(conf, vConf)
if err != nil {
t.Errorf("Unable to create appliance spec: %s", err)
return
}
// create appliance VM
info, err := tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return d.session.Folders(ctx).VmFolder.CreateVM(ctx, *spec, d.vchPool, d.session.Host)
})
// get VM reference and save it
moref := info.Result.(types.ManagedObjectReference)
conf.SetMoref(&moref)
obj, err := d.session.Finder.ObjectReference(d.ctx, moref)
if err != nil {
t.Errorf("Failed to reacquire reference to appliance VM after creation: %s", err)
return
}
gvm, ok := obj.(*object.VirtualMachine)
if !ok {
t.Errorf("Required reference after appliance creation was not for a VM: %T", obj)
return
}
vm2 := vm.NewVirtualMachineFromVM(d.ctx, d.session, gvm)
uuid, err := vm2.UUID(d.ctx)
if err != nil {
t.Errorf("Failed to get VM UUID: %s", err)
return
}
t.Logf("uuid: %s", uuid)
// leverage create volume method to create image datastore
conf.VolumeLocations["images-store"], _ = url.Parse(fmt.Sprintf("ds://LocalDS_0/VIC/%s/images", uuid))
if err := d.createVolumeStores(conf); err != nil {
t.Errorf("Unable to create volume stores: %s", err)
return
}
}
func Init(ctx context.Context, sess *session.Session) error {
source, err := extraconfig.GuestInfoSource()
if err != nil {
return err
}
sink, err := extraconfig.GuestInfoSink()
if err != nil {
return err
}
// Grab the storage layer config blobs from extra config
extraconfig.Decode(source, &storage.Config)
log.Debugf("Decoded VCH config for storage: %#v", storage.Config)
// create or restore a portlayer k/v store in the VCH's directory.
vch, err := guest.GetSelf(ctx, sess)
if err != nil {
return err
}
vchvm := vm.NewVirtualMachineFromVM(ctx, sess, vch)
vmPath, err := vchvm.VMPathName(ctx)
if err != nil {
return err
}
// vmPath is set to the vmx. Grab the directory from that.
vmFolder, err := datastore.ToURL(path.Dir(vmPath))
if err != nil {
return err
}
if err = store.Init(ctx, sess, vmFolder); err != nil {
return err
}
if err := exec.Init(ctx, sess, source, sink); err != nil {
return err
}
if err = network.Init(ctx, sess, source, sink); err != nil {
return err
}
return nil
}
func (d *Dispatcher) createAppliance(conf *metadata.VirtualContainerHostConfigSpec, settings *data.InstallerData) error {
defer trace.End(trace.Begin(""))
log.Infof("Creating appliance on target")
spec, err := d.createApplianceSpec(conf, settings)
if err != nil {
log.Errorf("Unable to create appliance spec: %s", err)
return err
}
// create test VM
info, err := tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return d.session.Folders(ctx).VmFolder.CreateVM(ctx, *spec, d.vchPool, d.session.Host)
})
if err != nil {
log.Errorf("Unable to create appliance VM: %s", err)
return err
}
if info.Error != nil || info.State != types.TaskInfoStateSuccess {
log.Errorf("Create appliance reported: %s", info.Error.LocalizedMessage)
}
// get VM reference and save it
moref := info.Result.(types.ManagedObjectReference)
conf.SetMoref(&moref)
obj, err := d.session.Finder.ObjectReference(d.ctx, moref)
if err != nil {
log.Errorf("Failed to reacquire reference to appliance VM after creation: %s", err)
return err
}
gvm, ok := obj.(*object.VirtualMachine)
if !ok {
return fmt.Errorf("Required reference after appliance creation was not for a VM: %T", obj)
}
vm2 := vm.NewVirtualMachineFromVM(d.ctx, d.session, gvm)
// update the displayname to the actual folder name used
if d.vmPathName, err = vm2.FolderName(d.ctx); err != nil {
log.Errorf("Failed to get canonical name for appliance: %s", err)
return err
}
log.Debugf("vm folder name: %s", d.vmPathName)
log.Debugf("vm inventory path: %s", vm2.InventoryPath)
// create an extension to register the appliance as
if err = d.GenerateExtensionName(conf); err != nil {
return errors.Errorf("Could not generate extension name during appliance creation due to error: %s", err)
}
settings.Extension = types.Extension{
Description: &types.Description{
Label: "VIC",
Summary: "vSphere Integrated Containers Virtual Container Host",
},
Company: "VMware, Inc.",
Version: "0.0",
Key: conf.ExtensionName,
}
conf.AddComponent("vicadmin", &metadata.SessionConfig{
Cmd: metadata.Cmd{
Path: "/sbin/vicadmin",
Args: []string{
"/sbin/vicadmin",
"-docker-host=unix:///var/run/docker.sock",
// FIXME: hack during config migration
"-insecure",
"-sdk=" + conf.Target.String(),
"-ds=" + conf.ImageStores[0].Host,
"-cluster=" + settings.ClusterPath,
"-pool=" + settings.ResourcePoolPath,
"-vm-path=" + vm2.InventoryPath,
},
Env: []string{
"PATH=/sbin:/bin",
},
},
},
)
if conf.HostCertificate != nil {
d.VICAdminProto = "https"
d.DockerPort = "2376"
} else {
d.VICAdminProto = "http"
d.DockerPort = "2375"
}
conf.AddComponent("docker-personality", &metadata.SessionConfig{
Cmd: metadata.Cmd{
Path: "/sbin/docker-engine-server",
Args: []string{
"/sbin/docker-engine-server",
//FIXME: hack during config migration
"-serveraddr=0.0.0.0",
"-port=" + d.DockerPort,
"-port-layer-port=8080",
},
Env: []string{
"PATH=/sbin",
},
},
},
)
conf.AddComponent("port-layer", &metadata.SessionConfig{
Cmd: metadata.Cmd{
Path: "/sbin/port-layer-server",
Args: []string{
"/sbin/port-layer-server",
//FIXME: hack during config migration
"--host=localhost",
"--port=8080",
"--insecure",
"--sdk=" + conf.Target.String(),
"--datacenter=" + settings.DatacenterName,
"--cluster=" + settings.ClusterPath,
"--pool=" + settings.ResourcePoolPath,
"--datastore=" + conf.ImageStores[0].Host,
"--vch=" + conf.ExecutorConfig.Name,
},
},
},
)
spec, err = d.reconfigureApplianceSpec(vm2, conf)
// reconfig
info, err = tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return vm2.Reconfigure(ctx, *spec)
})
if err != nil {
log.Errorf("Error while setting component parameters to appliance: %s", err)
return err
}
if info.State != types.TaskInfoStateSuccess {
log.Errorf("Setting parameters to appliance reported: %s", info.Error.LocalizedMessage)
return err
}
d.appliance = vm2
return nil
}
func (d *Dispatcher) createAppliance(conf *config.VirtualContainerHostConfigSpec, settings *data.InstallerData) error {
defer trace.End(trace.Begin(""))
log.Infof("Creating appliance on target")
spec, err := d.createApplianceSpec(conf, settings)
if err != nil {
log.Errorf("Unable to create appliance spec: %s", err)
return err
}
var info *types.TaskInfo
// create appliance VM
if d.isVC && d.vchVapp != nil {
info, err = tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.Task, error) {
return d.vchVapp.CreateChildVM_Task(ctx, *spec, d.session.Host)
})
} else {
// if vapp is not created, fall back to create VM under default resource pool
folder := d.session.Folders(d.ctx).VmFolder
info, err = tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.Task, error) {
return folder.CreateVM(ctx, *spec, d.vchPool, d.session.Host)
})
}
if err != nil {
log.Errorf("Unable to create appliance VM: %s", err)
return err
}
if info.Error != nil || info.State != types.TaskInfoStateSuccess {
log.Errorf("Create appliance reported: %s", info.Error.LocalizedMessage)
}
// get VM reference and save it
moref := info.Result.(types.ManagedObjectReference)
conf.SetMoref(&moref)
obj, err := d.session.Finder.ObjectReference(d.ctx, moref)
if err != nil {
log.Errorf("Failed to reacquire reference to appliance VM after creation: %s", err)
return err
}
gvm, ok := obj.(*object.VirtualMachine)
if !ok {
return fmt.Errorf("Required reference after appliance creation was not for a VM: %T", obj)
}
vm2 := vm.NewVirtualMachineFromVM(d.ctx, d.session, gvm)
// update the displayname to the actual folder name used
if d.vmPathName, err = vm2.FolderName(d.ctx); err != nil {
log.Errorf("Failed to get canonical name for appliance: %s", err)
return err
}
log.Debugf("vm folder name: %q", d.vmPathName)
log.Debugf("vm inventory path: %q", vm2.InventoryPath)
// create an extension to register the appliance as
if err = d.GenerateExtensionName(conf, vm2); err != nil {
return errors.Errorf("Could not generate extension name during appliance creation due to error: %s", err)
}
settings.Extension = types.Extension{
Description: &types.Description{
Label: "VIC",
Summary: "vSphere Integrated Containers Virtual Container Host",
},
Company: "VMware, Inc.",
Version: "0.0",
Key: conf.ExtensionName,
}
conf.AddComponent("vicadmin", &executor.SessionConfig{
User: "******",
Group: "vicadmin",
Cmd: executor.Cmd{
Path: "/sbin/vicadmin",
Args: []string{
"/sbin/vicadmin",
"--dc=" + settings.DatacenterName,
"--pool=" + settings.ResourcePoolPath,
"--cluster=" + settings.ClusterPath,
},
Env: []string{
"PATH=/sbin:/bin",
"GOTRACEBACK=all",
},
Dir: "/home/vicadmin",
},
Restart: true,
},
)
if conf.HostCertificate != nil {
d.VICAdminProto = "https"
d.DockerPort = fmt.Sprintf("%d", opts.DefaultTLSHTTPPort)
} else {
d.VICAdminProto = "http"
d.DockerPort = fmt.Sprintf("%d", opts.DefaultHTTPPort)
}
personality := executor.Cmd{
Path: "/sbin/docker-engine-server",
Args: []string{
"/sbin/docker-engine-server",
//FIXME: hack during config migration
"-port=" + d.DockerPort,
fmt.Sprintf("-port-layer-port=%d", portLayerPort),
},
Env: []string{
"PATH=/sbin",
"GOTRACEBACK=all",
},
}
if settings.HTTPProxy != nil {
personality.Env = append(personality.Env, fmt.Sprintf("HTTP_PROXY=%s", settings.HTTPProxy.String()))
}
if settings.HTTPSProxy != nil {
personality.Env = append(personality.Env, fmt.Sprintf("HTTPS_PROXY=%s", settings.HTTPSProxy.String()))
}
conf.AddComponent("docker-personality", &executor.SessionConfig{
// currently needed for iptables interaction
// User: "******",
// Group: "nobody",
Cmd: personality,
Restart: true,
},
)
conf.AddComponent("port-layer", &executor.SessionConfig{
Cmd: executor.Cmd{
Path: "/sbin/port-layer-server",
Args: []string{
"/sbin/port-layer-server",
"--host=localhost",
fmt.Sprintf("--port=%d", portLayerPort),
},
Env: []string{
//FIXME: hack during config migration
"VC_URL=" + conf.Target.String(),
"DC_PATH=" + settings.DatacenterName,
"CS_PATH=" + settings.ClusterPath,
"POOL_PATH=" + settings.ResourcePoolPath,
"DS_PATH=" + conf.ImageStores[0].Host,
},
},
Restart: true,
},
)
conf.BootstrapImagePath = fmt.Sprintf("[%s] %s/%s", conf.ImageStores[0].Host, d.vmPathName, settings.BootstrapISO)
spec, err = d.reconfigureApplianceSpec(vm2, conf, settings)
if err != nil {
log.Errorf("Error while getting appliance reconfig spec: %s", err)
return err
}
// reconfig
info, err = vm2.WaitForResult(d.ctx, func(ctx context.Context) (tasks.Task, error) {
return vm2.Reconfigure(ctx, *spec)
})
if err != nil {
log.Errorf("Error while setting component parameters to appliance: %s", err)
return err
}
if info.State != types.TaskInfoStateSuccess {
log.Errorf("Setting parameters to appliance reported: %s", info.Error.LocalizedMessage)
return err
}
d.appliance = vm2
return nil
}
// addTestVM will add a pseudo VM to the container
func addTestVM(container *Container) {
mo := types.ManagedObjectReference{Type: "vm", Value: "12"}
v := object.NewVirtualMachine(nil, mo)
container.vm = vm.NewVirtualMachineFromVM(nil, nil, v)
}
