Package registry

Variables

GCCmd is the cobra command that corresponds to the garbage-collect subcommand

var GCCmd = &cobra.Command{
    Use:   "garbage-collect <config>",
    Short: "`garbage-collect` deletes layers not referenced by any manifests",
    Long:  "`garbage-collect` deletes layers not referenced by any manifests",
    Run: func(cmd *cobra.Command, args []string) {
        config, err := resolveConfiguration(args)
        if err != nil {
            fmt.Fprintf(os.Stderr, "configuration error: %v\n", err)
            cmd.Usage()
            os.Exit(1)
        }

        driver, err := factory.Create(config.Storage.Type(), config.Storage.Parameters())
        if err != nil {
            fmt.Fprintf(os.Stderr, "failed to construct %s driver: %v", config.Storage.Type(), err)
            os.Exit(1)
        }

        ctx := dcontext.Background()
        ctx, err = configureLogging(ctx, config)
        if err != nil {
            fmt.Fprintf(os.Stderr, "unable to configure logging with config: %s", err)
            os.Exit(1)
        }

        k, err := libtrust.GenerateECP256PrivateKey()
        if err != nil {
            fmt.Fprint(os.Stderr, err)
            os.Exit(1)
        }

        registry, err := storage.NewRegistry(ctx, driver, storage.Schema1SigningKey(k))
        if err != nil {
            fmt.Fprintf(os.Stderr, "failed to construct registry: %v", err)
            os.Exit(1)
        }

        err = storage.MarkAndSweep(ctx, driver, registry, storage.GCOpts{
            DryRun:         dryRun,
            RemoveUntagged: removeUntagged,
        })
        if err != nil {
            fmt.Fprintf(os.Stderr, "failed to garbage collect: %v", err)
            os.Exit(1)
        }
    },
}

RootCmd is the main command for the 'registry' binary.

var RootCmd = &cobra.Command{
    Use:   "registry",
    Short: "`registry`",
    Long:  "`registry`",
    Run: func(cmd *cobra.Command, args []string) {
        if showVersion {
            version.PrintVersion()
            return
        }
        cmd.Usage()
    },
}

ServeCmd is a cobra command for running the registry.

var ServeCmd = &cobra.Command{
    Use:   "serve <config>",
    Short: "`serve` stores and distributes Docker images",
    Long:  "`serve` stores and distributes Docker images.",
    Run: func(cmd *cobra.Command, args []string) {

        ctx := dcontext.WithVersion(dcontext.Background(), version.Version)

        config, err := resolveConfiguration(args)
        if err != nil {
            fmt.Fprintf(os.Stderr, "configuration error: %v\n", err)
            cmd.Usage()
            os.Exit(1)
        }

        if config.HTTP.Debug.Addr != "" {
            go func(addr string) {
                log.Infof("debug server listening %v", addr)
                if err := http.ListenAndServe(addr, nil); err != nil {
                    log.Fatalf("error listening on debug interface: %v", err)
                }
            }(config.HTTP.Debug.Addr)
        }

        registry, err := NewRegistry(ctx, config)
        if err != nil {
            log.Fatalln(err)
        }

        if config.HTTP.Debug.Prometheus.Enabled {
            path := config.HTTP.Debug.Prometheus.Path
            if path == "" {
                path = "/metrics"
            }
            log.Info("providing prometheus metrics on ", path)
            http.Handle(path, metrics.Handler())
        }

        if err = registry.ListenAndServe(); err != nil {
            log.Fatalln(err)
        }
    },
}

type Registry ¶

A Registry represents a complete instance of the registry. TODO(aaronl): It might make sense for Registry to become an interface.

type Registry struct {
    // contains filtered or unexported fields
}

func NewRegistry ¶

func NewRegistry(ctx context.Context, config *configuration.Configuration) (*Registry, error)

NewRegistry creates a new registry from a context and configuration struct.

func (*Registry) ListenAndServe ¶

func (registry *Registry) ListenAndServe() error

ListenAndServe runs the registry's HTTP server.

Subdirectories