// ListImages lists the images from given image store
func ListImages(host, storename string, images []*ImageWithMeta) (map[string]*models.Image, error) {
defer trace.End(trace.Begin(storename))
transport := httptransport.New(host, "/", []string{"http"})
client := apiclient.New(transport, nil)
ids := make([]string, len(images))
for i := range images {
ids = append(ids, images[i].ID)
}
imageList, err := client.Storage.ListImages(
storage.NewListImagesParamsWithContext(ctx).WithStoreName(storename).WithIds(ids),
)
if err != nil {
return nil, err
}
existingImages := make(map[string]*models.Image)
for i := range imageList.Payload {
v := imageList.Payload[i]
existingImages[v.ID] = v
}
return existingImages, nil
}
// CreateImageStore creates an image store
func CreateImageStore(storename string) error {
defer trace.End(trace.Begin(storename))
transport := httptransport.New(options.host, "/", []string{"http"})
client := apiclient.New(transport, nil)
log.Debugf("Creating a store from input %s", storename)
body := &models.ImageStore{Name: storename}
_, err := client.Storage.CreateImageStore(
storage.NewCreateImageStoreParamsWithContext(ctx).WithBody(body),
)
if _, ok := err.(*storage.CreateImageStoreConflict); ok {
log.Debugf("Store already exists")
return nil
}
if err != nil {
log.Debugf("Creating a store failed: %s", err)
return err
}
log.Debugf("Created a store %#v", body)
return nil
}
// PingPortLayer calls the _ping endpoint of the portlayer
func PingPortLayer(host string) (bool, error) {
defer trace.End(trace.Begin(host))
transport := httptransport.New(host, "/", []string{"http"})
client := apiclient.New(transport, nil)
ok, err := client.Misc.Ping(misc.NewPingParamsWithContext(ctx))
if err != nil {
return false, err
}
return ok.Payload == "OK", nil
}
func Init(portLayerAddr, product string, config *config.VirtualContainerHostConfigSpec, insecureRegs []url.URL) error {
_, _, err := net.SplitHostPort(portLayerAddr)
if err != nil {
return err
}
vchConfig = config
productName = product
if config != nil {
if config.Version != nil {
productVersion = config.Version.ShortVersion()
}
if productVersion == "" {
portLayerName = product + " Backend Engine"
} else {
portLayerName = product + " " + productVersion + " Backend Engine"
}
} else {
portLayerName = product + " Backend Engine"
}
t := httptransport.New(portLayerAddr, "/", []string{"http"})
portLayerClient = client.New(t, nil)
portLayerServerAddr = portLayerAddr
// block indefinitely while waiting on the portlayer to respond to pings
// the vic-machine installer timeout will intervene if this blocks for too long
pingPortLayer()
if err := hydrateCaches(); err != nil {
return err
}
log.Info("Creating image store")
if err := createImageStore(); err != nil {
log.Errorf("Failed to create image store")
return err
}
serviceOptions := registry.ServiceOptions{}
for _, r := range insecureRegs {
insecureRegistries = append(insecureRegistries, r.Path)
}
if len(insecureRegistries) > 0 {
serviceOptions.InsecureRegistries = insecureRegistries
}
log.Debugf("New registry service with options %#v", serviceOptions)
RegistryService = registry.NewService(serviceOptions)
return nil
}
func (c *ContainerProxy) createNewAttachClientWithTimeouts(connectTimeout, responseTimeout, responseHeaderTimeout time.Duration) (*client.PortLayer, *httpclient.Transport) {
runtime := httptransport.New(c.portlayerAddr, "/", []string{"http"})
transport := &httpclient.Transport{
ConnectTimeout: connectTimeout,
ResponseHeaderTimeout: responseHeaderTimeout,
RequestTimeout: responseTimeout,
}
runtime.Transport = transport
plClient := client.New(runtime, nil)
runtime.Consumers["application/octet-stream"] = httpkit.ByteStreamConsumer()
runtime.Producers["application/octet-stream"] = httpkit.ByteStreamProducer()
return plClient, transport
}
func Init(portLayerAddr, product string, config *metadata.VirtualContainerHostConfigSpec) error {
_, _, err := net.SplitHostPort(portLayerAddr)
if err != nil {
return err
}
vchConfig = config
productName = product
if config != nil {
productVersion = config.Version
if productVersion == "" {
portLayerName = product + " Backend Engine"
} else {
portLayerName = product + " " + productVersion + " Backend Engine"
}
} else {
portLayerName = product + " Backend Engine"
}
t := httptransport.New(portLayerAddr, "/", []string{"http"})
portLayerClient = client.New(t, nil)
portLayerServerAddr = portLayerAddr
imageCache = cache.NewImageCache()
// attempt to update the image cache at startup
log.Info("Refreshing image cache...")
go func() {
for i := 0; i < Retries; i++ {
// initial pause to wait for the portlayer to come up
time.Sleep(RetryTimeSeconds * time.Second)
if err := imageCache.Update(portLayerClient); err == nil {
log.Info("Image cache updated successfully")
return
}
log.Info("Failed to refresh image cache, retrying...")
}
log.Warn("Failed to refresh image cache. Is the portlayer server down?")
}()
return nil
}
// WriteImage writes the image to given image store
func WriteImage(host string, image *ImageWithMeta, data io.ReadCloser) error {
defer trace.End(trace.Begin(image.ID))
transport := httptransport.New(host, "/", []string{"http"})
client := apiclient.New(transport, nil)
transport.Consumers["application/json"] = httpkit.JSONConsumer()
transport.Producers["application/json"] = httpkit.JSONProducer()
transport.Consumers["application/octet-stream"] = httpkit.ByteStreamConsumer()
transport.Producers["application/octet-stream"] = httpkit.ByteStreamProducer()
key := new(string)
blob := new(string)
*key = metadata.MetaDataKey
*blob = image.Meta
r, err := client.Storage.WriteImage(
storage.NewWriteImageParamsWithContext(ctx).
WithImageID(image.ID).
WithParentID(*image.Parent).
WithStoreName(image.Store).
WithMetadatakey(key).
WithMetadataval(blob).
WithImageFile(data).
WithSum(image.Layer.BlobSum),
)
if err != nil {
log.Debugf("Creating an image failed: %s", err)
return err
}
log.Printf("Created an image %#v", r.Payload)
return nil
}