add image.Store.Info() function

backend/_example/memory_store/accessor/image.go

@@ -13,6 +13,8 @@ import (
 
 	log "github.com/go-pkgz/lgr"
 	"github.com/pkg/errors"
+
+	"github.com/umputun/remark/backend/app/store/image"
 )
 
 // MemImage implements image.Store with memory backend
@@ -95,3 +97,17 @@ func (m *MemImage) Cleanup(_ context.Context, ttl time.Duration) error {
 	m.Unlock()
 	return nil
 }
+
+// Info returns meta information about storage
+func (m *MemImage) Info() (image.StoreInfo, error) {
+	var ts time.Time
+	m.RLock()
+	for _, t := range m.insertTime {
+		if ts.IsZero() || t.Before(ts) {
+			ts = t
+		}
+	}
+	m.RUnlock()
+
+	return image.StoreInfo{FirstStagingImageTS: ts}, nil
+}

backend/_example/memory_store/accessor/image_test.go

@@ -80,3 +80,23 @@ func TestMemImage_Cleanup(t *testing.T) {
 	err := svc.Cleanup(context.TODO(), time.Minute)
 	assert.NoError(t, err)
 }
+
+func TestMemImage_Info(t *testing.T) {
+	svc := NewMemImageStore()
+	gopher, err := ioutil.ReadAll(gopherPNG())
+	assert.NoError(t, err)
+
+	// get info on empty storage, should be zero
+	info, err := svc.Info()
+	assert.NoError(t, err)
+	assert.True(t, info.FirstStagingImageTS.IsZero())
+
+	// save image
+	err = svc.Save("test_img", gopher)
+	assert.NoError(t, err)
+
+	// get info after saving, should be non-zero
+	info, err = svc.Info()
+	assert.NoError(t, err)
+	assert.False(t, info.FirstStagingImageTS.IsZero())
+}

backend/_example/memory_store/server/image.go

@@ -54,3 +54,8 @@ func (s *RPC) imgCleanupHndl(id uint64, params json.RawMessage) (rr jrpc.Respons
 	err := s.img.Cleanup(context.TODO(), ttl)
 	return jrpc.EncodeResponse(id, nil, err)
 }
+
+func (s *RPC) imgInfoHndl(id uint64, _ json.RawMessage) (rr jrpc.Response) {
+	info, err := s.img.Info()
+	return jrpc.EncodeResponse(id, info, err)
+}

backend/_example/memory_store/server/image_test.go

@@ -124,3 +124,25 @@ func TestRPC_imgCleanupHndl(t *testing.T) {
 	_, err = ri.Load(id)
 	assert.EqualError(t, err, "image test_img not found")
 }
+
+func TestRPC_imgInfoHndl(t *testing.T) {
+	port, teardown := prepTestStore(t)
+	defer teardown()
+	api := fmt.Sprintf("http://localhost:%d/test", port)
+
+	ri := image.RPC{Client: jrpc.Client{API: api, Client: http.Client{Timeout: 1 * time.Second}}}
+
+	// get info on empty storage, should be zero
+	info, err := ri.Info()
+	assert.NoError(t, err)
+	assert.True(t, info.FirstStagingImageTS.IsZero())
+
+	// save
+	err = ri.Save("test_img", gopherPNGBytes())
+	assert.NoError(t, err)
+
+	// get info after saving, should be non-zero
+	info, err = ri.Info()
+	assert.NoError(t, err)
+	assert.False(t, info.FirstStagingImageTS.IsZero())
+}

backend/_example/memory_store/server/rpc.go

@@ -61,5 +61,6 @@ func (s *RPC) addHandlers() {
 		"load":         s.imgLoadHndl,
 		"commit":       s.imgCommitHndl,
 		"cleanup":      s.imgCleanupHndl,
+		"info":         s.imgInfoHndl,
 	})
 }