// SpecConfig returns a spec.VirtualMachineConfigSpecConfig struct
func SpecConfig(session *session.Session) *spec.VirtualMachineConfigSpecConfig {
backing, err := session.Network.EthernetCardBackingInfo(context.TODO())
if err != nil {
log.Errorf("unable to get backing info for test network: %s", err)
return nil
}
uuid, err := guest.UUID()
if err != nil {
log.Errorf("unable to get UUID for guest - used for VM name: %s", err)
return nil
}
return &spec.VirtualMachineConfigSpecConfig{
NumCPUs: 2,
MemoryMB: 2048,
VMForkEnabled: true,
ConnectorURI: "tcp://1.2.3.4:9876",
ID: uuid,
Name: "zombie_attack",
BootMediaPath: session.Datastore.Path("brainz.iso"),
VMPathName: fmt.Sprintf("[%s]", session.Datastore.Name()),
DebugNetwork: backing,
}
}
// Update adds new images to the cache
func (c *ImageCache) Update(client *client.PortLayer) error {
c.m.Lock()
defer c.m.Unlock()
CacheNotUpdated = true
log.Debugf("Updating image cache...")
host, err := guest.UUID()
if host == "" {
host, err = os.Hostname()
}
if err != nil {
return fmt.Errorf("Unexpected error getting hostname: %s", err)
}
// attempt to create the image store if it doesn't exist
store := &models.ImageStore{Name: host}
_, err = client.Storage.CreateImageStore(
storage.NewCreateImageStoreParams().WithBody(store),
)
if err != nil {
if _, ok := err.(*storage.CreateImageStoreConflict); ok {
log.Debugf("Store already exists")
} else {
log.Debugf("Creating a store failed: %#v", err)
return err
}
}
params := storage.NewListImagesParams().WithStoreName(host)
layers, err := client.Storage.ListImages(params)
if err != nil {
return fmt.Errorf("Failed to retrieve image list from portlayer: %s", err)
}
for _, layer := range layers.Payload {
imageConfig := &metadata.ImageConfig{}
if err := json.Unmarshal([]byte(layer.Metadata["metaData"]), imageConfig); err != nil {
derr.NewErrorWithStatusCode(fmt.Errorf("Failed to unmarshal image config: %s", err),
http.StatusInternalServerError)
}
if imageConfig.ImageID != "" {
var imageID string
// Don't assume the image id in image has "sha256:<id> as format. We store it in
// this fomat to make it easier to lookup by digest
if strings.HasPrefix(imageConfig.ImageID, "sha") {
imageID = imageConfig.ImageID
} else {
imageID = "sha256:" + imageConfig.ImageID
}
c.cacheByID[imageID] = imageConfig
// Normalize the name stored in imageConfig using Docker's reference code
ref, err := reference.WithName(imageConfig.Name)
if err != nil {
log.Errorf("Tried to create reference from %s: %s", imageConfig.Name, err.Error())
continue
}
for id := range imageConfig.Tags {
tag := imageConfig.Tags[id]
ref, err = reference.WithTag(ref, tag)
if err != nil {
log.Errorf("Tried to create tagged reference from %s and tag %s: %s", imageConfig.Name, tag, err.Error())
continue
}
if tagged, ok := ref.(reference.NamedTagged); ok {
taggedName := fmt.Sprintf("%s:%s", tagged.Name(), tagged.Tag())
c.cacheByName[taggedName] = imageConfig
} else {
c.cacheByName[ref.Name()] = imageConfig
}
}
}
}
CacheNotUpdated = false
return nil
}