// 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)
}