// FIXME: Do more extensive tests (ex: create multiple, delete, recreate;
// create multiple, check the amount of images and paths, etc..)
func TestGraphCreate(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
archive, err := fakeTar()
if err != nil {
t.Fatal(err)
}
img, err := graph.Create(archive, "", "", "Testing", "", nil, nil)
if err != nil {
t.Fatal(err)
}
if err := image.ValidateID(img.ID); err != nil {
t.Fatal(err)
}
if img.Comment != "Testing" {
t.Fatalf("Wrong comment: should be '%s', not '%s'", "Testing", img.Comment)
}
if img.DockerVersion != dockerversion.VERSION {
t.Fatalf("Wrong docker_version: should be '%s', not '%s'", dockerversion.VERSION, img.DockerVersion)
}
images, err := graph.Map()
if err != nil {
t.Fatal(err)
} else if l := len(images); l != 1 {
t.Fatalf("Wrong number of images. Should be %d, not %d", 1, l)
}
if images[img.ID] == nil {
t.Fatalf("Could not find image with id %s", img.ID)
}
}
func (s *TagStore) recursiveLoad(address, tmpImageDir string) error {
if _, err := s.LookupImage(address); err != nil {
glog.V(1).Infof("Loading %s", address)
imageJson, err := ioutil.ReadFile(filepath.Join(tmpImageDir, "repo", address, "json"))
if err != nil {
glog.V(1).Infof("Error reading json", err)
return err
}
layer, err := os.Open(filepath.Join(tmpImageDir, "repo", address, "layer.tar"))
if err != nil {
glog.V(1).Infof("Error reading embedded tar", err)
return err
}
img, err := image.NewImgJSON(imageJson)
if err != nil {
glog.V(1).Infof("Error unmarshalling json", err)
return err
}
if err := image.ValidateID(img.ID); err != nil {
glog.V(1).Infof("Error validating ID: %s", err)
return err
}
// ensure no two downloads of the same layer happen at the same time
if c, err := s.poolAdd("pull", "layer:"+img.ID); err != nil {
if c != nil {
glog.V(1).Infof("Image (id: %s) load is already running, waiting: %v", img.ID, err)
<-c
return nil
}
return err
}
defer s.poolRemove("pull", "layer:"+img.ID)
if img.Parent != "" {
if !s.graph.Exists(img.Parent) {
if err := s.recursiveLoad(img.Parent, tmpImageDir); err != nil {
return err
}
}
}
if err := s.graph.Register(img, layer); err != nil {
return err
}
}
glog.V(1).Infof("Completed processing %s", address)
return nil
}
func validateRemoteName(remoteName string) error {
var (
namespace string
name string
)
nameParts := strings.SplitN(remoteName, "/", 2)
if len(nameParts) < 2 {
namespace = "library"
name = nameParts[0]
// the repository name must not be a valid image ID
if err := image.ValidateID(name); err == nil {
return fmt.Errorf("Invalid repository name (%s), cannot specify 64-byte hexadecimal strings", name)
}
} else {
namespace = nameParts[0]
name = nameParts[1]
}
if !validNamespaceChars.MatchString(namespace) {
return fmt.Errorf("Invalid namespace name (%s). Only [a-z0-9-_] are allowed.", namespace)
}
if len(namespace) < 2 || len(namespace) > 255 {
return fmt.Errorf("Invalid namespace name (%s). Cannot be fewer than 2 or more than 255 characters.", namespace)
}
if strings.HasPrefix(namespace, "-") || strings.HasSuffix(namespace, "-") {
return fmt.Errorf("Invalid namespace name (%s). Cannot begin or end with a hyphen.", namespace)
}
if strings.Contains(namespace, "--") {
return fmt.Errorf("Invalid namespace name (%s). Cannot contain consecutive hyphens.", namespace)
}
if !validRepo.MatchString(name) {
return fmt.Errorf("Invalid repository name (%s), only [a-z0-9-_.] are allowed", name)
}
if strings.HasPrefix(name, "-") || strings.HasSuffix(name, "-") {
return fmt.Errorf("Invalid repository name (%s). Cannot begin or end with a hyphen.", name)
}
return nil
}
func MakePod(podName, image, workdir, src, vol, shellDir string, cmds, entrys []string) (string, error) {
if image == "" {
return "", fmt.Errorf("image can not be null")
}
if err := dockerimage.ValidateID(image); err == nil {
image = image[:12]
}
var (
env = []pod.UserEnvironmentVar{}
containerList = []pod.UserContainer{}
volList = []pod.UserVolume{}
cVols = []pod.UserVolumeReference{}
)
if src != "" {
myVol1 := pod.UserVolumeReference{
Path: "/tmp/src/",
Volume: "source",
ReadOnly: false,
}
myVol2 := pod.UserVolumeReference{
Path: "/tmp/shell/",
Volume: "shell",
ReadOnly: false,
}
cVols = append(cVols, myVol1)
cVols = append(cVols, myVol2)
vol1 := pod.UserVolume{
Name: "source",
Source: src,
Driver: "vfs",
}
vol2 := pod.UserVolume{
Name: "shell",
Source: shellDir,
Driver: "vfs",
}
volList = append(volList, vol1)
volList = append(volList, vol2)
}
var container = pod.UserContainer{
Name: "mac-builder",
Image: image,
Command: cmds,
Workdir: workdir,
Entrypoint: entrys,
Ports: []pod.UserContainerPort{},
Envs: env,
Volumes: cVols,
Files: []pod.UserFileReference{},
RestartPolicy: "never",
}
containerList = append(containerList, container)
var userPod = &pod.UserPod{
Name: podName,
Containers: containerList,
Resource: pod.UserResource{Vcpu: 1, Memory: 512},
Files: []pod.UserFile{},
Volumes: volList,
Tty: false,
}
jsonString, err := utils.JSONMarshal(userPod, true)
if err != nil {
return "", err
}
return string(jsonString), nil
}
