image/refs: Implement Engine.Put

This is pretty straightforward with the new WriteTarEntryByName
helper.

I considered pulling the ref name -> path conversion (%s -> ./refs/%s)
out into a helper function to stay DRY, but the logic is simple enough
that it seemed more intuitive to leave it inline.

Signed-off-by: W. Trevor King <[email protected]>

Author: wking

cmd/oci-refs/main.go

@@ -27,6 +27,7 @@ func main() {
 		Short: "Name-based reference manipulation",
 	}
 
+	cmd.AddCommand(newPutCmd())
 	cmd.AddCommand(newGetCmd())
 	cmd.AddCommand(newListCmd())
 

cmd/oci-refs/put.go

@@ -0,0 +1,81 @@
+// Copyright 2016 The Linux Foundation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/opencontainers/image-spec/specs-go"
+	"github.com/opencontainers/image-tools/image/refs/layout"
+	"github.com/spf13/cobra"
+	"golang.org/x/net/context"
+)
+
+type putCmd struct {
+	path string
+	name string
+}
+
+func newPutCmd() *cobra.Command {
+	state := &putCmd{}
+
+	return &cobra.Command{
+		Use:   "put PATH NAME",
+		Short: "Write a reference to the store",
+		Long:  "Read descriptor JSON from stdin and write it to the store.",
+		Run:   state.Run,
+	}
+}
+
+func (state *putCmd) Run(cmd *cobra.Command, args []string) {
+	if len(args) != 2 {
+		if err := cmd.Usage(); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+		os.Exit(1)
+	}
+
+	state.path = args[0]
+	state.name = args[1]
+
+	err := state.run()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	os.Exit(0)
+}
+
+func (state *putCmd) run() (err error) {
+	ctx := context.Background()
+
+	engine, err := layout.NewEngine(ctx, state.path)
+	if err != nil {
+		return err
+	}
+	defer engine.Close()
+
+	decoder := json.NewDecoder(os.Stdin)
+	var descriptor specs.Descriptor
+	err = decoder.Decode(&descriptor)
+	if err != nil {
+		return err
+	}
+
+	return engine.Put(ctx, state.name, &descriptor)
+}

image/refs/layout/main.go

@@ -28,7 +28,7 @@ import (
 // NewEngine instantiates an engine with the appropriate backend (tar,
 // HTTP, ...).
 func NewEngine(ctx context.Context, path string) (engine refs.Engine, err error) {
-	file, err := os.Open(path)
+	file, err := os.OpenFile(path, os.O_RDWR, 0)
 	if err != nil {
 		return nil, err
 	}

image/refs/layout/tar.go

@@ -16,6 +16,7 @@ package layout
 
 import (
 	"archive/tar"
+	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -51,8 +52,15 @@ func NewTarEngine(ctx context.Context, file caslayout.ReadWriteSeekCloser) (eng
 
 // Put adds a new reference to the store.
 func (engine *TarEngine) Put(ctx context.Context, name string, descriptor *specs.Descriptor) (err error) {
-	// FIXME
-	return errors.New("TarEngine.Put is not supported yet")
+	data, err := json.Marshal(descriptor)
+	if err != nil {
+		return err
+	}
+
+	size := int64(len(data))
+	reader := bytes.NewReader(data)
+	targetName := fmt.Sprintf("./refs/%s", name)
+	return imagelayout.WriteTarEntryByName(ctx, engine.file, targetName, reader, &size)
 }
 
 // Get returns a reference from the store.