The following pull request was submitted through Github.
It can be accessed and reviewed at: https://github.com/lxc/lxd/pull/2495

This e-mail was sent by the LXC bot, direct replies will not reach the author
unless they happen to be subscribed to this list.

=== Description (from pull-request) ===
Right now, we store simplestreams data for up to an hour. This is done
through a simple memory cache in LXD.

The goal of this was to decrease load on the simplestreams servers and
that's been working pretty well so far.

One thing that this cache doesn't help much with is dealing with
simplestreams servers being offline or the client being temporarily
disconnected from the internet.

Right now once the cache times out, LXD will refresh it, if that fails,
then the cache is gone.

This commit makes it so that our cache persists across LXD restarts by
serializing it to disk. It also changes its use a bit, so that if we
fail to refresh the cache, we log a warning and bump its expiry for
another hour.

This effectively allows LXD to be used completely offline and work fine
with any image that's already in the local cache.

Closes #2487

Signed-off-by: St├ęphane Graber <stgra...@ubuntu.com>
From 30afe435745323c7ddfe3369d0f4e663950d1f91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phane=20Graber?= <stgra...@ubuntu.com>
Date: Thu, 13 Oct 2016 21:53:51 -0400
Subject: [PATCH] Store the simplestreams cache to disk
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Right now, we store simplestreams data for up to an hour. This is done
through a simple memory cache in LXD.

The goal of this was to decrease load on the simplestreams servers and
that's been working pretty well so far.

One thing that this cache doesn't help much with is dealing with
simplestreams servers being offline or the client being temporarily
disconnected from the internet.

Right now once the cache times out, LXD will refresh it, if that fails,
then the cache is gone.

This commit makes it so that our cache persists across LXD restarts by
serializing it to disk. It also changes its use a bit, so that if we
fail to refresh the cache, we log a warning and bump its expiry for
another hour.

This effectively allows LXD to be used completely offline and work fine
with any image that's already in the local cache.

Closes #2487

Signed-off-by: St├ęphane Graber <stgra...@ubuntu.com>
---
 lxd/daemon.go        |  13 +++++
 lxd/daemon_images.go | 134 ++++++++++++++++++++++++++++++++++++++++++++-------
 shared/util.go       |  13 +++++
 3 files changed, 142 insertions(+), 18 deletions(-)

diff --git a/lxd/daemon.go b/lxd/daemon.go
index 949d7dc..63d694f 100644
--- a/lxd/daemon.go
+++ b/lxd/daemon.go
@@ -748,6 +748,9 @@ func (d *Daemon) Init() error {
        d.lxcpath = shared.VarPath("containers")
 
        /* Make sure all our directories are available */
+       if err := os.MkdirAll(shared.CachePath(), 0700); err != nil {
+               return err
+       }
        if err := os.MkdirAll(shared.VarPath("containers"), 0711); err != nil {
                return err
        }
@@ -821,6 +824,12 @@ func (d *Daemon) Init() error {
                if err != nil {
                        return err
                }
+
+               /* Restore simplestreams cache */
+               err = imageLoadStreamCache(d)
+               if err != nil {
+                       return err
+               }
        }
 
        /* Log expiry */
@@ -1166,6 +1175,10 @@ func (d *Daemon) Stop() error {
        d.devlxd.Close()
        shared.LogInfof("Stopped /dev/lxd handler")
 
+       shared.LogInfof("Saving simplestreams cache")
+       imageSaveStreamCache()
+       shared.LogInfof("Saved simplestreams cache")
+
        if d.MockMode || forceStop {
                return nil
        }
diff --git a/lxd/daemon_images.go b/lxd/daemon_images.go
index b7ea919..876bd7a 100644
--- a/lxd/daemon_images.go
+++ b/lxd/daemon_images.go
@@ -4,26 +4,79 @@ import (
        "encoding/json"
        "fmt"
        "io"
+       "io/ioutil"
        "mime"
        "mime/multipart"
        "os"
        "path/filepath"
+       "strings"
        "sync"
        "time"
 
+       "gopkg.in/yaml.v2"
+
        "github.com/lxc/lxd/shared"
 
        log "gopkg.in/inconshreveable/log15.v2"
 )
 
+// Simplestream cache
 type imageStreamCacheEntry struct {
-       ss     *shared.SimpleStreams
-       expiry time.Time
+       Aliases      shared.ImageAliases `yaml:"aliases"`
+       Fingerprints []string            `yaml:"fingerprints"`
+       expiry       time.Time
+       ss           *shared.SimpleStreams
 }
 
 var imageStreamCache = map[string]*imageStreamCacheEntry{}
 var imageStreamCacheLock sync.Mutex
 
+func imageSaveStreamCache() error {
+       data, err := yaml.Marshal(&imageStreamCache)
+       if err != nil {
+               return err
+       }
+
+       err = ioutil.WriteFile(shared.CachePath("simplestreams.yaml"), data, 
0600)
+       if err != nil {
+               return err
+       }
+
+       return nil
+}
+
+func imageLoadStreamCache(d *Daemon) error {
+       imageStreamCacheLock.Lock()
+       defer imageStreamCacheLock.Unlock()
+
+       if !shared.PathExists(shared.CachePath("simplestreams.yaml")) {
+               return nil
+       }
+
+       content, err := ioutil.ReadFile(shared.CachePath("simplestreams.yaml"))
+       if err != nil {
+               return err
+       }
+
+       err = yaml.Unmarshal(content, imageStreamCache)
+       if err != nil {
+               return err
+       }
+
+       for url, entry := range imageStreamCache {
+               if entry.ss == nil {
+                       ss, err := shared.SimpleStreamsClient(url, d.proxy)
+                       if err != nil {
+                               return err
+                       }
+
+                       entry.ss = ss
+               }
+       }
+
+       return nil
+}
+
 // ImageDownload checks if we have that Image Fingerprint else
 // downloads the image from a remote server.
 func (d *Daemon) ImageDownload(op *operation, server string, protocol string, 
certificate string, secret string, alias string, forContainer bool, autoUpdate 
bool) (string, error) {
@@ -42,34 +95,79 @@ func (d *Daemon) ImageDownload(op *operation, server 
string, protocol string, ce
                imageStreamCacheLock.Lock()
                entry, _ := imageStreamCache[server]
                if entry == nil || entry.expiry.Before(time.Now()) {
-                       ss, err = shared.SimpleStreamsClient(server, d.proxy)
-                       if err != nil {
+                       refresh := func() (*imageStreamCacheEntry, error) {
+                               // Setup simplestreams client
+                               ss, err = shared.SimpleStreamsClient(server, 
d.proxy)
+                               if err != nil {
+                                       return nil, err
+                               }
+
+                               // Get all aliases
+                               aliases, err := ss.ListAliases()
+                               if err != nil {
+                                       return nil, err
+                               }
+
+                               // Get all fingerprints
+                               images, err := ss.ListImages()
+                               if err != nil {
+                                       return nil, err
+                               }
+
+                               fingerprints := []string{}
+                               for _, image := range images {
+                                       fingerprints = append(fingerprints, 
image.Fingerprint)
+                               }
+
+                               // Generate cache entry
+                               entry = &imageStreamCacheEntry{ss: ss, Aliases: 
aliases, Fingerprints: fingerprints, expiry: time.Now().Add(time.Hour)}
+                               imageStreamCache[server] = entry
+                               imageSaveStreamCache()
+
+                               return entry, nil
+                       }
+
+                       newEntry, err := refresh()
+                       if err == nil {
+                               // Cache refreshed
+                               entry = newEntry
+                       } else if entry != nil {
+                               // Failed to fetch entry but existing cache
+                               shared.LogWarn("Unable to refresh cache, using 
stale entry", log.Ctx{"server": server})
+                               entry.expiry = time.Now().Add(time.Hour)
+                       } else {
+                               // Failed to fetch entry and nothing in cache
                                imageStreamCacheLock.Unlock()
                                return "", err
                        }
-
-                       entry = &imageStreamCacheEntry{ss: ss, expiry: 
time.Now().Add(time.Hour)}
-                       imageStreamCache[server] = entry
                } else {
-                       shared.LogDebugf("Using SimpleStreams cache entry for 
%s, expires at %s", server, entry.expiry)
+                       shared.LogDebug("Using SimpleStreams cache entry", 
log.Ctx{"server": server, "expiry": entry.expiry})
                        ss = entry.ss
                }
                imageStreamCacheLock.Unlock()
 
-               target := ss.GetAlias(fp)
-               if target != "" {
-                       fp = target
-               }
+               // Expand aliases
+               for _, alias := range entry.Aliases {
+                       if alias.Name != fp {
+                               continue
+                       }
 
-               image, err := ss.GetImageInfo(fp)
-               if err != nil {
-                       return "", err
+                       fp = alias.Target
+                       break
                }
 
-               if fp == alias {
-                       alias = image.Fingerprint
+               // Expand fingerprint
+               for _, fingerprint := range entry.Fingerprints {
+                       if !strings.HasPrefix(fingerprint, fp) {
+                               continue
+                       }
+
+                       if fp == alias {
+                               alias = fingerprint
+                       }
+                       fp = fingerprint
+                       break
                }
-               fp = image.Fingerprint
        } else if protocol == "lxd" {
                target, err := remoteGetImageFingerprint(d, server, 
certificate, fp)
                if err == nil && target != "" {
diff --git a/shared/util.go b/shared/util.go
index 7c994a4..2cf0371 100644
--- a/shared/util.go
+++ b/shared/util.go
@@ -93,6 +93,19 @@ func VarPath(path ...string) string {
        return filepath.Join(items...)
 }
 
+// CachePath returns the directory that LXD should its cache under. If LXD_DIR 
is
+// set, this path is $LXD_DIR/cache, otherwise it is /var/cache/lxd.
+func CachePath(path ...string) string {
+       varDir := os.Getenv("LXD_DIR")
+       logDir := "/var/cache/lxd"
+       if varDir != "" {
+               logDir = filepath.Join(varDir, "cache")
+       }
+       items := []string{logDir}
+       items = append(items, path...)
+       return filepath.Join(items...)
+}
+
 // LogPath returns the directory that LXD should put logs under. If LXD_DIR is
 // set, this path is $LXD_DIR/logs, otherwise it is /var/log/lxd.
 func LogPath(path ...string) string {
_______________________________________________
lxc-devel mailing list
lxc-devel@lists.linuxcontainers.org
http://lists.linuxcontainers.org/listinfo/lxc-devel

Reply via email to