// readStartedAtFile reads the date from an upload's startedAtFile func readStartedAtFile(driver storageDriver.StorageDriver, path string) (time.Time, error) { // todo:(richardscothern) - pass in a context startedAtBytes, err := driver.GetContent(context.Background(), path) if err != nil { return time.Now(), err } startedAt, err := time.Parse(time.RFC3339, string(startedAtBytes)) if err != nil { return time.Now(), err } return startedAt, nil }
func main() { root := os.Args[1] config := configuration.Configuration{ Storage: configuration.Storage{ "filesystem": configuration.Parameters{ "rootdirectory": root, }, }, } app := handlers.NewApp(context.Background(), config) if err := http.ListenAndServe(":8080", app); err != nil { log.Fatal(err) } }
// statusResponse completes the request with a response describing the health // of the service. func statusResponse(w http.ResponseWriter, r *http.Request, status int, checks map[string]string) { p, err := json.Marshal(checks) if err != nil { context.GetLogger(context.Background()).Errorf("error serializing health status: %v", err) p, err = json.Marshal(struct { ServerError string `json:"server_error"` }{ ServerError: "Could not parse error message", }) status = http.StatusInternalServerError if err != nil { context.GetLogger(context.Background()).Errorf("error serializing health status failure message: %v", err) return } } w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Content-Length", fmt.Sprint(len(p))) w.WriteHeader(status) if _, err := w.Write(p); err != nil { context.GetLogger(context.Background()).Errorf("error writing health status response body: %v", err) } }
// context either returns a new context or looks it up in the manager. func (cm *contextManager) context(parent context.Context, w http.ResponseWriter, r *http.Request) context.Context { cm.mu.Lock() defer cm.mu.Unlock() ctx, ok := cm.contexts[r] if ok { return ctx } if parent == nil { parent = ctxu.Background() } ctx = ctxu.WithRequest(parent, r) ctx, w = ctxu.WithResponseWriter(ctx, w) ctx = ctxu.WithLogger(ctx, ctxu.GetRequestLogger(ctx)) cm.contexts[r] = ctx return ctx }
func TestDocker(t *testing.T) { if os.Getuid() != 0 { t.Skip("pinkerton: must be root to create AUFS mounts") } // start Docker registry using test files cwd, err := os.Getwd() if err != nil { t.Fatal(err) } root := filepath.Join(cwd, "test", "files") config := configuration.Configuration{ Storage: configuration.Storage{ "filesystem": configuration.Parameters{ "rootdirectory": root, }, }, } logrus.SetLevel(logrus.ErrorLevel) app := handlers.NewApp(context.Background(), config) srv := httptest.NewServer(app) defer srv.Close() // create context tmp, err := ioutil.TempDir("", "pinkerton-test") if err != nil { t.Fatal(err) } defer os.RemoveAll(tmp) ctx, err := BuildContext("aufs", tmp) if err != nil { t.Fatal(err) } // pull image using digest imageID, err := ctx.PullDocker(srv.URL+"?name=pinkerton-test&id="+testImageDigest, ioutil.Discard) if err != nil { t.Fatal(err) } if imageID != testImageID { t.Fatalf("expected image to have ID %q, got %q", testImageID, imageID) } // checkout image name := random.String(8) path, err := ctx.Checkout(name, imageID) if err != nil { t.Fatal(err) } defer ctx.Cleanup(name) // check foo.txt exists and has correct data f, err := os.Open(filepath.Join(path, "foo.txt")) if err != nil { t.Fatal(err) } data, err := ioutil.ReadAll(f) f.Close() if err != nil { t.Fatal(err) } if !reflect.DeepEqual(data, []byte(testImageData)) { t.Fatalf("expected foo.txt to contain %q, got %q", testImageData, string(data)) } }
// CheckBlobDescriptorCache takes a cache implementation through a common set // of operations. If adding new tests, please add them here so new // implementations get the benefit. This should be used for unit tests. func CheckBlobDescriptorCache(t *testing.T, provider BlobDescriptorCacheProvider) { ctx := context.Background() checkBlobDescriptorCacheEmptyRepository(t, ctx, provider) checkBlobDescriptorCacheSetAndRead(t, ctx, provider) }