github.com/ranjib/nomad@v0.1.1-0.20160225204057-97751b02f70b/client/allocdir/alloc_dir_test.go (about)

     1  package allocdir
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"path/filepath"
     7  	"reflect"
     8  	"testing"
     9  
    10  	"github.com/hashicorp/nomad/client/testutil"
    11  	"github.com/hashicorp/nomad/nomad/structs"
    12  )
    13  
    14  var (
    15  	t1 = &structs.Task{
    16  		Name:   "web",
    17  		Driver: "exec",
    18  		Config: map[string]interface{}{
    19  			"command": "/bin/date",
    20  			"args":    "+%s",
    21  		},
    22  		Resources: &structs.Resources{
    23  			DiskMB: 1,
    24  		},
    25  	}
    26  
    27  	t2 = &structs.Task{
    28  		Name:   "web2",
    29  		Driver: "exec",
    30  		Config: map[string]interface{}{
    31  			"command": "/bin/date",
    32  			"args":    "+%s",
    33  		},
    34  		Resources: &structs.Resources{
    35  			DiskMB: 1,
    36  		},
    37  	}
    38  )
    39  
    40  // Test that given a set of tasks, each task gets a directory and that directory
    41  // has the shared alloc dir inside of it.
    42  func TestAllocDir_BuildAlloc(t *testing.T) {
    43  	tmp, err := ioutil.TempDir("", "AllocDir")
    44  	if err != nil {
    45  		t.Fatalf("Couldn't create temp dir: %v", err)
    46  	}
    47  	defer os.RemoveAll(tmp)
    48  
    49  	d := NewAllocDir(tmp)
    50  	defer d.Destroy()
    51  	tasks := []*structs.Task{t1, t2}
    52  	if err := d.Build(tasks); err != nil {
    53  		t.Fatalf("Build(%v) failed: %v", tasks, err)
    54  	}
    55  
    56  	// Check that the AllocDir and each of the task directories exist.
    57  	if _, err := os.Stat(d.AllocDir); os.IsNotExist(err) {
    58  		t.Fatalf("Build(%v) didn't create AllocDir %v", tasks, d.AllocDir)
    59  	}
    60  
    61  	for _, task := range tasks {
    62  		tDir, ok := d.TaskDirs[task.Name]
    63  		if !ok {
    64  			t.Fatalf("Task directory not found for %v", task.Name)
    65  		}
    66  
    67  		if _, err := os.Stat(tDir); os.IsNotExist(err) {
    68  			t.Fatalf("Build(%v) didn't create TaskDir %v", tasks, tDir)
    69  		}
    70  	}
    71  }
    72  
    73  func TestAllocDir_LogDir(t *testing.T) {
    74  	tmp, err := ioutil.TempDir("", "AllocDir")
    75  	if err != nil {
    76  		t.Fatalf("Couldn't create temp dir: %v", err)
    77  	}
    78  	defer os.RemoveAll(tmp)
    79  
    80  	d := NewAllocDir(tmp)
    81  	defer d.Destroy()
    82  
    83  	expected := filepath.Join(d.AllocDir, SharedAllocName, LogDirName)
    84  	if d.LogDir() != expected {
    85  		t.Fatalf("expected: %v, got: %v", expected, d.LogDir())
    86  	}
    87  }
    88  
    89  func TestAllocDir_EmbedNonExistent(t *testing.T) {
    90  	tmp, err := ioutil.TempDir("", "AllocDir")
    91  	if err != nil {
    92  		t.Fatalf("Couldn't create temp dir: %v", err)
    93  	}
    94  	defer os.RemoveAll(tmp)
    95  
    96  	d := NewAllocDir(tmp)
    97  	defer d.Destroy()
    98  	tasks := []*structs.Task{t1, t2}
    99  	if err := d.Build(tasks); err != nil {
   100  		t.Fatalf("Build(%v) failed: %v", tasks, err)
   101  	}
   102  
   103  	fakeDir := "/foobarbaz"
   104  	task := tasks[0].Name
   105  	mapping := map[string]string{fakeDir: fakeDir}
   106  	if err := d.Embed(task, mapping); err != nil {
   107  		t.Fatalf("Embed(%v, %v) should should skip %v since it does not exist", task, mapping, fakeDir)
   108  	}
   109  }
   110  
   111  func TestAllocDir_EmbedDirs(t *testing.T) {
   112  	tmp, err := ioutil.TempDir("", "AllocDir")
   113  	if err != nil {
   114  		t.Fatalf("Couldn't create temp dir: %v", err)
   115  	}
   116  	defer os.RemoveAll(tmp)
   117  
   118  	d := NewAllocDir(tmp)
   119  	defer d.Destroy()
   120  	tasks := []*structs.Task{t1, t2}
   121  	if err := d.Build(tasks); err != nil {
   122  		t.Fatalf("Build(%v) failed: %v", tasks, err)
   123  	}
   124  
   125  	// Create a fake host directory, with a file, and a subfolder that contains
   126  	// a file.
   127  	host, err := ioutil.TempDir("", "AllocDirHost")
   128  	if err != nil {
   129  		t.Fatalf("Couldn't create temp dir: %v", err)
   130  	}
   131  	defer os.RemoveAll(host)
   132  
   133  	subDirName := "subdir"
   134  	subDir := filepath.Join(host, subDirName)
   135  	if err := os.Mkdir(subDir, 0777); err != nil {
   136  		t.Fatalf("Failed to make subdir %v: %v", subDir, err)
   137  	}
   138  
   139  	file := "foo"
   140  	subFile := "bar"
   141  	if err := ioutil.WriteFile(filepath.Join(host, file), []byte{'a'}, 0777); err != nil {
   142  		t.Fatalf("Coudn't create file in host dir %v: %v", host, err)
   143  	}
   144  
   145  	if err := ioutil.WriteFile(filepath.Join(subDir, subFile), []byte{'a'}, 0777); err != nil {
   146  		t.Fatalf("Coudn't create file in host subdir %v: %v", subDir, err)
   147  	}
   148  
   149  	// Create mapping from host dir to task dir.
   150  	task := tasks[0].Name
   151  	taskDest := "bin/test/"
   152  	mapping := map[string]string{host: taskDest}
   153  	if err := d.Embed(task, mapping); err != nil {
   154  		t.Fatalf("Embed(%v, %v) failed: %v", task, mapping, err)
   155  	}
   156  
   157  	// Check that the embedding was done properly.
   158  	taskDir, ok := d.TaskDirs[task]
   159  	if !ok {
   160  		t.Fatalf("Task directory not found for %v", task)
   161  	}
   162  
   163  	exp := []string{filepath.Join(taskDir, taskDest, file), filepath.Join(taskDir, taskDest, subDirName, subFile)}
   164  	for _, e := range exp {
   165  		if _, err := os.Stat(e); os.IsNotExist(err) {
   166  			t.Fatalf("File %v not embeded: %v", e, err)
   167  		}
   168  	}
   169  }
   170  
   171  func TestAllocDir_MountSharedAlloc(t *testing.T) {
   172  	testutil.MountCompatible(t)
   173  	tmp, err := ioutil.TempDir("", "AllocDir")
   174  	if err != nil {
   175  		t.Fatalf("Couldn't create temp dir: %v", err)
   176  	}
   177  	defer os.RemoveAll(tmp)
   178  
   179  	d := NewAllocDir(tmp)
   180  	defer d.Destroy()
   181  	tasks := []*structs.Task{t1, t2}
   182  	if err := d.Build(tasks); err != nil {
   183  		t.Fatalf("Build(%v) failed: %v", tasks, err)
   184  	}
   185  
   186  	// Write a file to the shared dir.
   187  	exp := []byte{'f', 'o', 'o'}
   188  	file := "bar"
   189  	if err := ioutil.WriteFile(filepath.Join(d.SharedDir, file), exp, 0777); err != nil {
   190  		t.Fatalf("Couldn't write file to shared directory: %v", err)
   191  	}
   192  
   193  	for _, task := range tasks {
   194  		// Mount and then check that the file exists in the task directory.
   195  		if err := d.MountSharedDir(task.Name); err != nil {
   196  			t.Fatalf("MountSharedDir(%v) failed: %v", task.Name, err)
   197  		}
   198  
   199  		taskDir, ok := d.TaskDirs[task.Name]
   200  		if !ok {
   201  			t.Fatalf("Task directory not found for %v", task.Name)
   202  		}
   203  
   204  		taskFile := filepath.Join(taskDir, SharedAllocName, file)
   205  		act, err := ioutil.ReadFile(taskFile)
   206  		if err != nil {
   207  			t.Fatalf("Failed to read shared alloc file from task dir: %v", err)
   208  		}
   209  
   210  		if !reflect.DeepEqual(act, exp) {
   211  			t.Fatalf("Incorrect data read from task dir: want %v; got %v", exp, act)
   212  		}
   213  	}
   214  }