machinery-tool 1.16.4 → 1.17.0

data/machinery-helper/machinery_helper_test.go

@@ -18,96 +18,96 @@
 package main
 
 import (
-  "testing"
-  "reflect"
-  "os"
-  "time"
-  "github.com/nowk/go-fakefileinfo"
+	"github.com/nowk/go-fakefileinfo"
+	"os"
+	"reflect"
+	"testing"
+	"time"
 )
 
 func doTestParseRpmLine(t *testing.T, line string, expectedFileType string, expectedFileName string, expectedLinkTarget string) {
-  fileType, fileName, linkTarget := parseRpmLine(line)
-
-  if fileType != expectedFileType {
-    t.Errorf("parseRpmLine('%s') file type = '%s', want '%s'", line, fileType, expectedFileType)
-  }
-  if fileName != expectedFileName {
-    t.Errorf("parseRpmLine('%s') file name = '%s', want '%s'", line, fileName, expectedFileName)
-  }
-  if linkTarget != expectedLinkTarget {
-    t.Errorf("parseRpmLine('%s') file type = '%s', want '%s'", line, linkTarget, expectedLinkTarget)
-  }
+	fileType, fileName, linkTarget := parseRpmLine(line)
+
+	if fileType != expectedFileType {
+		t.Errorf("parseRpmLine('%s') file type = '%s', want '%s'", line, fileType, expectedFileType)
+	}
+	if fileName != expectedFileName {
+		t.Errorf("parseRpmLine('%s') file name = '%s', want '%s'", line, fileName, expectedFileName)
+	}
+	if linkTarget != expectedLinkTarget {
+		t.Errorf("parseRpmLine('%s') file type = '%s', want '%s'", line, linkTarget, expectedLinkTarget)
+	}
 }
 
 func TestParseRpmLineFile(t *testing.T) {
-  line := "-rw-r--r--    1 root    root                 18234080 Mar 31 11:40 /usr/lib64/libruby2.0-static.a"
+	line := "-rw-r--r--    1 root    root                 18234080 Mar 31 11:40 /usr/lib64/libruby2.0-static.a"
 
-  expectedFileType := "-"
-  expectedFileName := "/usr/lib64/libruby2.0-static.a"
-  expectedLinkTarget := ""
+	expectedFileType := "-"
+	expectedFileName := "/usr/lib64/libruby2.0-static.a"
+	expectedLinkTarget := ""
 
-  doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
+	doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
 }
 
 func TestParseRpmLineDir(t *testing.T) {
-  line := "drwxr-xr-x    2 root    root                        0 Mar 31 11:45 /usr/include/ruby-2.0.0/x86_64-linux/ruby"
+	line := "drwxr-xr-x    2 root    root                        0 Mar 31 11:45 /usr/include/ruby-2.0.0/x86_64-linux/ruby"
 
-  expectedFileType := "d"
-  expectedFileName := "/usr/include/ruby-2.0.0/x86_64-linux/ruby"
-  expectedLinkTarget := ""
+	expectedFileType := "d"
+	expectedFileName := "/usr/include/ruby-2.0.0/x86_64-linux/ruby"
+	expectedLinkTarget := ""
 
-  doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
+	doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
 }
 
 func TestParseRpmLineLink(t *testing.T) {
-  line := "lrwxrwxrwx    1 root    root                       19 Mar 31 11:45 /usr/lib64/libruby2.0.so -> libruby2.0.so.2.0.0"
+	line := "lrwxrwxrwx    1 root    root                       19 Mar 31 11:45 /usr/lib64/libruby2.0.so -> libruby2.0.so.2.0.0"
 
-  expectedFileType := "l"
-  expectedFileName := "/usr/lib64/libruby2.0.so"
-  expectedLinkTarget := "libruby2.0.so.2.0.0"
+	expectedFileType := "l"
+	expectedFileName := "/usr/lib64/libruby2.0.so"
+	expectedLinkTarget := "libruby2.0.so.2.0.0"
 
-  doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
+	doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
 }
 
 func TestParseRpmLineFileSpaces(t *testing.T) {
-  line := "-rw-r--r--    1 root    root                    61749 Jun 26 01:56 /usr/share/kde4/templates/kipiplugins_photolayoutseditor/data/templates/a4/h/Flipping Tux Black.ple"
+	line := "-rw-r--r--    1 root    root                    61749 Jun 26 01:56 /usr/share/kde4/templates/kipiplugins_photolayoutseditor/data/templates/a4/h/Flipping Tux Black.ple"
 
-  expectedFileType := "-"
-  expectedFileName := "/usr/share/kde4/templates/kipiplugins_photolayoutseditor/data/templates/a4/h/Flipping Tux Black.ple"
-  expectedLinkTarget := ""
+	expectedFileType := "-"
+	expectedFileName := "/usr/share/kde4/templates/kipiplugins_photolayoutseditor/data/templates/a4/h/Flipping Tux Black.ple"
+	expectedLinkTarget := ""
 
-  doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
+	doTestParseRpmLine(t, line, expectedFileType, expectedFileName, expectedLinkTarget)
 }
 
 func TestAddImplicitlyManagedDirs(t *testing.T) {
-  filesOriginal := map[string]string{
-    "/abc/def/ghf/somefile": "",
-    "/zzz": "/abc/def",
-  }
-  dirsOriginal := map[string]bool{
-    "/abc/def": true,
-  }
-  dirsExpected := map[string]bool{
-    "/abc": false,
-    "/abc/def": true,
-    "/abc/def/ghf": false,
-    "/zzz": false,
-  }
-
-  dirs := dirsOriginal
-
-  addImplicitlyManagedDirs(dirs, filesOriginal)
-
-  if !reflect.DeepEqual(dirs, dirsExpected) {
-    t.Errorf("addImplicitlyManagedDirs('%v') = '%v', want '%v'", dirsOriginal, dirs, dirsExpected)
-  }
+	filesOriginal := map[string]string{
+		"/abc/def/ghf/somefile": "",
+		"/zzz":                  "/abc/def",
+	}
+	dirsOriginal := map[string]bool{
+		"/abc/def": true,
+	}
+	dirsExpected := map[string]bool{
+		"/abc":         false,
+		"/abc/def":     true,
+		"/abc/def/ghf": false,
+		"/zzz":         false,
+	}
+
+	dirs := dirsOriginal
+
+	addImplicitlyManagedDirs(dirs, filesOriginal)
+
+	if !reflect.DeepEqual(dirs, dirsExpected) {
+		t.Errorf("addImplicitlyManagedDirs('%v') = '%v', want '%v'", dirsOriginal, dirs, dirsExpected)
+	}
 }
 
 func TestAssembleJSON(t *testing.T) {
-  unmanagedFilesMap := map[string]string{
-    "name": "/usr/share/go_rulez", "type":"file",
-  }
-  want := `{
+	unmanagedFilesMap := map[string]string{
+		"name": "/usr/share/go_rulez", "type": "file",
+	}
+	want := `{
    "extracted": false,
    "files": {
      "name": "/usr/share/go_rulez",
@@ -115,78 +115,78 @@ func TestAssembleJSON(t *testing.T) {
    }
  }`
 
-  json := assembleJSON(unmanagedFilesMap)
-  if !reflect.DeepEqual(json, want) {
-    t.Errorf("assembleJSON() = '%v', want '%v'", json, want)
-  }
+	json := assembleJSON(unmanagedFilesMap)
+	if !reflect.DeepEqual(json, want) {
+		t.Errorf("assembleJSON() = '%v', want '%v'", json, want)
+	}
 }
 
 func TestRespectManagedDirsInUnmanagedDirs(t *testing.T) {
-  unmanagedFiles := make(map[string]string)
-  wantUnmanagedFiles := make(map[string]string)
-
-  /*
-  We mock the readDir method and return following directory structure:
-   /
-   /managed_dir/
-   /managed_dir/unmanaged_dir/
-   /managed_dir/unmanaged_dir/managed_dir/
-  */
-  readDir = func(dir string) ([]os.FileInfo, error) {
-    dirs := make([]os.FileInfo, 0, 1)
-    var fi os.FileInfo
-    switch dir {
-    case "/":
-      fi = fakefileinfo.New("managed_dir", int64(123), os.ModeType, time.Now(), true, nil)
-    case "/managed_dir/":
-      fi = fakefileinfo.New("unmanaged_dir", int64(123), os.ModeType, time.Now(), true, nil)
-    case "/managed_dir/unmanaged_dir/":
-      fi = fakefileinfo.New("managed_dir", int64(123), os.ModeType, time.Now(), true, nil)
-    }
-    dirs = append (dirs, fi)
-    return dirs, nil
-  }
-
-  rpmFiles := make(map[string]string)
-  ignoreList := make(map[string]bool)
-
-  rpmDirs := map[string]bool{
-    "/managed_dir": true,
-    "/managed_dir/unmanaged_dir/managed_dir": true,
-  }
-
-  findUnmanagedFiles("/", rpmFiles, rpmDirs, unmanagedFiles, ignoreList)
-
-  if !reflect.DeepEqual(unmanagedFiles, wantUnmanagedFiles) {
-    t.Errorf("findUnmanagedFiles() = '%v', want '%v'", unmanagedFiles, wantUnmanagedFiles)
-  }
+	unmanagedFiles := make(map[string]string)
+	wantUnmanagedFiles := make(map[string]string)
+
+	/*
+	  We mock the readDir method and return following directory structure:
+	   /
+	   /managed_dir/
+	   /managed_dir/unmanaged_dir/
+	   /managed_dir/unmanaged_dir/managed_dir/
+	*/
+	readDir = func(dir string) ([]os.FileInfo, error) {
+		dirs := make([]os.FileInfo, 0, 1)
+		var fi os.FileInfo
+		switch dir {
+		case "/":
+			fi = fakefileinfo.New("managed_dir", int64(123), os.ModeType, time.Now(), true, nil)
+		case "/managed_dir/":
+			fi = fakefileinfo.New("unmanaged_dir", int64(123), os.ModeType, time.Now(), true, nil)
+		case "/managed_dir/unmanaged_dir/":
+			fi = fakefileinfo.New("managed_dir", int64(123), os.ModeType, time.Now(), true, nil)
+		}
+		dirs = append(dirs, fi)
+		return dirs, nil
+	}
+
+	rpmFiles := make(map[string]string)
+	ignoreList := make(map[string]bool)
+
+	rpmDirs := map[string]bool{
+		"/managed_dir":                           true,
+		"/managed_dir/unmanaged_dir/managed_dir": true,
+	}
+
+	findUnmanagedFiles("/", rpmFiles, rpmDirs, unmanagedFiles, ignoreList)
+
+	if !reflect.DeepEqual(unmanagedFiles, wantUnmanagedFiles) {
+		t.Errorf("findUnmanagedFiles() = '%v', want '%v'", unmanagedFiles, wantUnmanagedFiles)
+	}
 }
 
 func TestHasManagedDirs(t *testing.T) {
-  rpmDirs := map[string]bool{
-    "/managed_dir": true,
-    "/managed_dir/unmanaged_dir/sub_dir/managed_dir": true,
-  }
+	rpmDirs := map[string]bool{
+		"/managed_dir":                                   true,
+		"/managed_dir/unmanaged_dir/sub_dir/managed_dir": true,
+	}
 
-  hasDirs := hasManagedDirs("/managed_dir/unmanaged_dir", rpmDirs)
-  want := true
+	hasDirs := hasManagedDirs("/managed_dir/unmanaged_dir", rpmDirs)
+	want := true
 
-  if hasDirs != want {
-    t.Errorf("hasManagedDirs() = '%v', want '%v'", hasDirs, want)
-  }
+	if hasDirs != want {
+		t.Errorf("hasManagedDirs() = '%v', want '%v'", hasDirs, want)
+	}
 
 }
 
 func TestSubdirIsNotAccidentallyConsideredManaged(t *testing.T) {
-  rpmDirs := map[string]bool{
-    "/usr": true,
-    "/usr/foobar": true,
-  }
+	rpmDirs := map[string]bool{
+		"/usr":        true,
+		"/usr/foobar": true,
+	}
 
-  hasDirs := hasManagedDirs("/usr/foo", rpmDirs)
-  want := false
+	hasDirs := hasManagedDirs("/usr/foo", rpmDirs)
+	want := false
 
-  if hasDirs != want {
-    t.Errorf("hasManagedDirs() = '%v', want '%v'", hasDirs, want)
-  }
+	if hasDirs != want {
+		t.Errorf("hasManagedDirs() = '%v', want '%v'", hasDirs, want)
+	}
 }

data/machinery-helper/mountpoints.go

@@ -18,9 +18,9 @@
 package main
 
 import (
-  "io/ioutil"
-  "strings"
-  "sort"
+	"io/ioutil"
+	"sort"
+	"strings"
 )
 
 // this specifies the path of the process mounts. This needs to be
@@ -29,53 +29,53 @@ var ProcMountsPath = "/proc/mounts"
 
 var remoteFileSystems = []string{"autofs", "cifs", "nfs", "nfs4"}
 var specialFileSystems = []string{"proc", "sysfs", "devtmpfs", "tmpfs", "rpc_pipefs", "fuse.gvfs-fuse-daemon"}
-var localFileSystems  = []string{"ext2", "ext3", "ext4", "reiserfs", "btrfs", "vfat", "xfs", "jfs"}
+var localFileSystems = []string{"ext2", "ext3", "ext4", "reiserfs", "btrfs", "vfat", "xfs", "jfs"}
 
 func parseMounts() map[string]string {
-  mount, _ := ioutil.ReadFile(ProcMountsPath)
-  mounts := make(map[string]string)
+	mount, _ := ioutil.ReadFile(ProcMountsPath)
+	mounts := make(map[string]string)
 
-  lines := strings.Split(string(mount), "\n")
+	lines := strings.Split(string(mount), "\n")
 
-  for _, line := range(lines) {
-    elements := strings.Split(line, " ")
+	for _, line := range lines {
+		elements := strings.Split(line, " ")
 
-    if len(elements) >= 3 {
-      mounts[elements[1]] = elements[2]
-    }
-  }
+		if len(elements) >= 3 {
+			mounts[elements[1]] = elements[2]
+		}
+	}
 
-  return mounts
+	return mounts
 }
 
-func selectFileSystems(allMounts map[string]string, fileSystems[]string) []string {
-  mounts := []string{}
+func selectFileSystems(allMounts map[string]string, fileSystems []string) []string {
+	mounts := []string{}
 
-  for path, fs := range(allMounts) {
-    for _, specialFs := range fileSystems {
-      if specialFs == fs {
-        mounts = append(mounts, path)
-      }
-    }
-  }
-  sort.Strings(mounts)
+	for path, fs := range allMounts {
+		for _, specialFs := range fileSystems {
+			if specialFs == fs {
+				mounts = append(mounts, path)
+			}
+		}
+	}
+	sort.Strings(mounts)
 
-  return mounts
+	return mounts
 }
 
 // SpecialMounts returns an array of all special mount paths like
 // proc or sysfs
 func SpecialMounts() []string {
-  return selectFileSystems(parseMounts(), specialFileSystems)
+	return selectFileSystems(parseMounts(), specialFileSystems)
 }
 
 // LocalMounts returns an array of all local mount paths
 func LocalMounts() []string {
-  return selectFileSystems(parseMounts(), localFileSystems)
+	return selectFileSystems(parseMounts(), localFileSystems)
 }
 
 // RemoteMounts returns an array of all remote mount paths
 // (for example NFS mount points)
 func RemoteMounts() []string {
-  return selectFileSystems(parseMounts(), remoteFileSystems)
+	return selectFileSystems(parseMounts(), remoteFileSystems)
 }

data/machinery-helper/tar.go

@@ -18,27 +18,28 @@
 package main
 
 import (
-  "flag"
-  "os"
-  "io"
-  "bufio"
-  "strings"
-  "archive/tar"
-  "compress/gzip"
-  "fmt"
-  "path/filepath"
-  "os/user"
-  "strconv"
-  "os/exec"
+	"archive/tar"
+	"bufio"
+	"compress/gzip"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/user"
+	"path/filepath"
+	"strconv"
+	"strings"
 )
 
 type stringArrayFlag []string
+
 func (i *stringArrayFlag) String() string {
-  return "exclude"
+	return "exclude"
 }
 func (i *stringArrayFlag) Set(value string) error {
-  *i = append(*i, value)
-  return nil
+	*i = append(*i, value)
+	return nil
 }
 
 var excludeList = make(map[string]bool)
@@ -46,97 +47,97 @@ var gzipWriter = gzip.NewWriter(os.Stdout)
 var tarWriter = tar.NewWriter(gzipWriter)
 
 func addPath(path string, info os.FileInfo, err error) error {
-  if err != nil {
-    return err
-  }
-
-  if stat, err := os.Lstat(path); err == nil {
-    if _, ok := excludeList[strings.TrimRight(path, "/")]; ok {
-      return nil
-    }
-
-    linkTarget := ""
-    if(stat.Mode() & os.ModeSymlink != 0) {
-      if linkTarget, err= os.Readlink(path); err != nil {
-        return err
-      }
-    }
-    header, err := tar.FileInfoHeader(stat, linkTarget)
-    header.Name = strings.TrimLeft(path, "/")
-    if err != nil {
-      return err
-    }
-
-    username, err := user.LookupId(strconv.Itoa(header.Uid))
-    if err != nil {
-      return err
-    }
-    header.Uname = username.Username
-
-    groupname, err := exec.Command("bash", "-c",
-      fmt.Sprintf("getent group %d | cut -d: -f1", header.Gid)).Output()
-    if err != nil {
-      return err
-    }
-    header.Gname = strings.TrimSpace(string(groupname))
-
-    if err := tarWriter.WriteHeader(header); err != nil {
-      return err
-    }
-
-    if stat.Mode().IsRegular() {
-      file, err := os.Open(path)
-      if err != nil {
-        return err
-      }
-      defer file.Close()
-
-      if _, err := io.Copy(tarWriter, file); err != nil {
-        return err
-      }
-    }
-  }
-  return nil
+	if err != nil {
+		return err
+	}
+
+	if stat, err := os.Lstat(path); err == nil {
+		if _, ok := excludeList[strings.TrimRight(path, "/")]; ok {
+			return nil
+		}
+
+		linkTarget := ""
+		if stat.Mode()&os.ModeSymlink != 0 {
+			if linkTarget, err = os.Readlink(path); err != nil {
+				return err
+			}
+		}
+		header, err := tar.FileInfoHeader(stat, linkTarget)
+		header.Name = strings.TrimLeft(path, "/")
+		if err != nil {
+			return err
+		}
+
+		username, err := user.LookupId(strconv.Itoa(header.Uid))
+		if err != nil {
+			return err
+		}
+		header.Uname = username.Username
+
+		groupname, err := exec.Command("bash", "-c",
+			fmt.Sprintf("getent group %d | cut -d: -f1", header.Gid)).Output()
+		if err != nil {
+			return err
+		}
+		header.Gname = strings.TrimSpace(string(groupname))
+
+		if err := tarWriter.WriteHeader(header); err != nil {
+			return err
+		}
+
+		if stat.Mode().IsRegular() {
+			file, err := os.Open(path)
+			if err != nil {
+				return err
+			}
+			defer file.Close()
+
+			if _, err := io.Copy(tarWriter, file); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
 }
 
 // Tar represents the "tar" command for the machinery-helper
 func Tar(args []string) {
-  var files []string
-  tarCommand := flag.NewFlagSet("tar", flag.ExitOnError)
-  tarCommand.Bool("create", true, "Create an tar archive")
-  tarCommand.Bool("gzip", true, "Compress archive using GZip")
-  tarCommand.Bool("null", true, "Read null-terminated names")
-  filesFromFlag := tarCommand.String("files-from", "", "Where to take the file list from")
-
-  var excludeFlag stringArrayFlag
-  tarCommand.Var(&excludeFlag, "exclude", "Read null-terminated names")
-
-  tarCommand.Parse(args)
-  for _, path := range(excludeFlag) {
-    excludeList[path] = true
-  }
-
-  if(*filesFromFlag == "-") {
-    reader := bufio.NewReader(os.Stdin)
-
-    for {
-      s, err := reader.ReadString('\x00')
-
-      files = append(files, strings.TrimRight(strings.TrimSpace(s), "\x00"))
-
-      if err == io.EOF {
-        break
-      }
-    }
-  } else {
-    files = tarCommand.Args()
-  }
-
-  for i := range files {
-    if err := filepath.Walk(files[i], addPath); err != nil {
-      fmt.Fprintln(os.Stderr, "Error:", err)
-    }
-  }
-  defer gzipWriter.Close()
-  defer tarWriter.Close()
+	var files []string
+	tarCommand := flag.NewFlagSet("tar", flag.ExitOnError)
+	tarCommand.Bool("create", true, "Create an tar archive")
+	tarCommand.Bool("gzip", true, "Compress archive using GZip")
+	tarCommand.Bool("null", true, "Read null-terminated names")
+	filesFromFlag := tarCommand.String("files-from", "", "Where to take the file list from")
+
+	var excludeFlag stringArrayFlag
+	tarCommand.Var(&excludeFlag, "exclude", "Read null-terminated names")
+
+	tarCommand.Parse(args)
+	for _, path := range excludeFlag {
+		excludeList[path] = true
+	}
+
+	if *filesFromFlag == "-" {
+		reader := bufio.NewReader(os.Stdin)
+
+		for {
+			s, err := reader.ReadString('\x00')
+
+			files = append(files, strings.TrimRight(strings.TrimSpace(s), "\x00"))
+
+			if err == io.EOF {
+				break
+			}
+		}
+	} else {
+		files = tarCommand.Args()
+	}
+
+	for i := range files {
+		if err := filepath.Walk(files[i], addPath); err != nil {
+			fmt.Fprintln(os.Stderr, "Error:", err)
+		}
+	}
+	defer gzipWriter.Close()
+	defer tarWriter.Close()
 }