Merge lp:~xavi-garcia-mena/go-unityscopes/utils-config-scopefiles into lp:go-unityscopes/v2

[Xavi Garcia]

Adding package that holds the functionality relative to scope configuration files in order to crosscompile and build click packages.

Adding package that holds the functionality relative to scope configuration files in order to crosscompile and build click packages.

Unmerged revisions

72. By Xavi Garcia on 2015-07-24

Added scopefiles package to deal with the configuration files and how and where config files are located and verified

71. By Xavi Garcia on 2015-07-24

Added utilites series information to describe the different configurations we can face when crosscompiling go scopes

70. By Xavi Garcia on 2015-07-24

Added utils directory with tools for building. Added common test utils package. Added utils command package to run system commands

=== added file 'utils/goscope-security.json'
--- utils/goscope-security.json	1970-01-01 00:00:00 +0000
+++ utils/goscope-security.json	2015-07-24 14:23:18 +0000
@@ -0,0 +1,7 @@
+{
+    "template": "ubuntu-scope-network",
+    "policy_groups": [
+     ],
+    "policy_version": 1.3
+}
+

=== added file 'utils/goscope.ini'
--- utils/goscope.ini	1970-01-01 00:00:00 +0000
+++ utils/goscope.ini	2015-07-24 14:23:18 +0000
@@ -0,0 +1,13 @@
+[ScopeConfig]
+ScopeRunner=./%SCOPE_NAME% --runtime %R --scope %S
+DisplayName=Goscope
+Description=This is test scope developed in Go
+Author=Canonical Ltd.
+Art=
+Icon=images/goscope-card.png
+SearchHint=Search Goscope
+
+[Appearance]
+PageHeader.Logo=images/goscope_logo.png
+PageHeader.Background=color:///#FFFFFF
+Background=color:///#FFFFFF

=== added file 'utils/manifest.json'
--- utils/manifest.json	1970-01-01 00:00:00 +0000
+++ utils/manifest.json	2015-07-24 14:23:18 +0000
@@ -0,0 +1,16 @@
+{
+    "description": "Test Go scope",
+    "framework": "ubuntu-sdk-15.04",
+    "architecture": "armhf",
+    "hooks": {
+        "goscope": {
+            "scope": "%SCOPE_NAME%",
+            "apparmor": "goscope-security.json"
+        }
+    },
+    "icon": "icon",
+    "maintainer": "Canonical Content Partners <[e-mail]>",
+    "name": "%SCOPE_NAME%",
+    "title": "Go scope",
+    "version": "1.0.0"
+}

=== added directory 'utils/scopefiles'
=== added file 'utils/scopefiles/scopefiles.go'
--- utils/scopefiles/scopefiles.go	1970-01-01 00:00:00 +0000
+++ utils/scopefiles/scopefiles.go	2015-07-24 14:23:18 +0000
@@ -0,0 +1,140 @@
+package scopefiles
+
+import (
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// PathExists returns whether the given file or directory exists or not
+func PathExists(path string) bool {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true
+	}
+	if os.IsNotExist(err) {
+		return false
+	}
+	return true
+}
+
+// FindSourceDirectory finds in the system the directory where to find the source files for the series package.
+func FindSourceDirectory() string {
+	pack, err := build.Import("launchpad.net/go-unityscopes/v2/utils/series", "", build.FindOnly)
+	if err != nil {
+		fmt.Println("ERROR: package launchpad.net/go-unityscopes/v2/utils/series was not installed under GOPATH")
+		os.Exit(2)
+	}
+	return pack.Dir + string(filepath.Separator) + ".." + string(filepath.Separator)
+}
+
+// PrepareFile copies a file from the source path to the destination modifying the word "%SCOPE_NAME% for the given scope name.
+func PrepareFile(sourcePath, finalPath, scopeName string) error {
+	buff, err := ioutil.ReadFile(sourcePath)
+	if err != nil {
+		return fmt.Errorf("Error opening file: %s, Error is: %s", sourcePath, err.Error())
+	}
+
+	strContent := string(buff)
+	newContent := strings.Replace(strContent, "%SCOPE_NAME%", scopeName, -1)
+	f, err := os.Create(finalPath)
+	if err != nil {
+		return fmt.Errorf("Error creating file: %s Error is: %s", finalPath, err.Error())
+	}
+	f.WriteString(newContent)
+	f.Close()
+	return nil
+}
+
+// PrepareScopeFiles creates all the necessary files to build a scope under the current path.
+// Parameters:
+// baseDir: Base directory (will take current directory if empty)
+// scopeName: the scope name
+// developerName: the developer name
+//
+// Returns: nil on success, a non nil error containing the failure information otherwise.
+func PrepareScopeFiles(baseDir, scopeName, developerName string) error {
+	auxBaseDir := baseDir + string(filepath.Separator)
+	if baseDir == "" {
+		auxBaseDir = "." + string(filepath.Separator)
+	} else {
+		if !PathExists(baseDir) {
+			return fmt.Errorf("Base directory %s does not exist", baseDir)
+		}
+	}
+
+	scopeDir := scopeName + "." + developerName
+	fmt.Println("Removing directory [" + scopeDir + "]...")
+	err := os.RemoveAll(scopeDir)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Creating directory [" + auxBaseDir + scopeDir + "]...")
+	err = os.Mkdir(auxBaseDir+scopeDir, 0777)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Creating directory [" + auxBaseDir + scopeDir + "/" + scopeDir + "]...")
+	err = os.Mkdir(auxBaseDir+scopeDir+string(filepath.Separator)+scopeDir, 0777)
+	if err != nil {
+		return err
+	}
+
+	sourceDir := FindSourceDirectory()
+	fmt.Println("Preparing manifest file...")
+	err = PrepareFile(sourceDir+"manifest.json", auxBaseDir+scopeDir+string(filepath.Separator)+"manifest.json", scopeDir)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Preparing ini file...")
+	iniFilePath := fmt.Sprintf("%s/%s/%s_%s.ini", auxBaseDir+scopeDir, scopeDir, scopeDir, scopeName)
+	err = PrepareFile(sourceDir+"goscope.ini", iniFilePath, auxBaseDir+scopeDir)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println("Preparing security file...")
+	securityFilePath := fmt.Sprintf("%s/goscope-security.json", auxBaseDir+scopeDir)
+	err = PrepareFile(sourceDir+"goscope-security.json", securityFilePath, auxBaseDir+scopeDir)
+	return err
+}
+
+// CheckBuildDirectory verifies that the build directory have the expected contents.
+func CheckBuildDirectory(baseDir, scopeName, developerName string) error {
+	auxBaseDir := baseDir + string(filepath.Separator)
+	if baseDir == "" {
+		auxBaseDir = "." + string(filepath.Separator)
+	} else {
+		if !PathExists(baseDir) {
+			return fmt.Errorf("Base directory %s does not exist", baseDir)
+		}
+	}
+	scopeFullName := scopeName + "." + developerName
+	sep := string(filepath.Separator)
+	internalDir := auxBaseDir + scopeFullName + sep + scopeFullName
+	checkDirs := []string{internalDir,
+		auxBaseDir + scopeFullName,
+	}
+	checkFiles := []string{auxBaseDir + scopeFullName + sep + "manifest.json",
+		auxBaseDir + scopeFullName + sep + "goscope-security.json",
+		auxBaseDir + scopeFullName + sep + scopeFullName + sep + fmt.Sprintf("%s_%s.ini", scopeFullName, scopeName),
+	}
+	for _, path := range checkDirs {
+		if !PathExists(path) {
+			return fmt.Errorf("Directory %s does not exist, use the prepare-scope tool to create all needed files", path)
+		}
+	}
+
+	for _, path := range checkFiles {
+		if !PathExists(path) {
+			return fmt.Errorf("File %s does not exist, use the prepare-scope tool to create all needed files", path)
+		}
+	}
+	return nil
+}

=== added file 'utils/scopefiles/scopefiles_test.go'
--- utils/scopefiles/scopefiles_test.go	1970-01-01 00:00:00 +0000
+++ utils/scopefiles/scopefiles_test.go	2015-07-24 14:23:18 +0000
@@ -0,0 +1,206 @@
+package scopefiles_test
+
+import (
+	. "gopkg.in/check.v1"
+	"io/ioutil"
+	"launchpad.net/go-unityscopes/v2/utils/scopefiles"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type S struct{}
+
+func init() {
+	Suite(&S{})
+}
+
+func TestAll(t *testing.T) {
+	TestingT(t)
+}
+
+func (s *S) TestDirExists(c *C) {
+	c.Check(scopefiles.PathExists("/tmp"), Equals, true)
+}
+
+func (s *S) TestDirNotExists(c *C) {
+	c.Check(scopefiles.PathExists("/tmpppppppppppppp"), Equals, false)
+}
+
+func (s *S) TestFileExists(c *C) {
+	// create temp directory
+	dir, err := ioutil.TempDir("/tmp", "scopefiles_test")
+	c.Assert(err, IsNil)
+	c.Assert(dir, Not(Equals), "")
+
+	// create temp file
+	file, err := ioutil.TempFile(dir, "test")
+	c.Assert(err, IsNil)
+	c.Assert(file, Not(Equals), nil)
+	c.Check(scopefiles.PathExists(file.Name()), Equals, true)
+
+	err = os.RemoveAll(dir)
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestFileNotExists(c *C) {
+	// create temp directory
+	dir, err := ioutil.TempDir("/tmp", "scopefiles_test")
+	c.Assert(err, IsNil)
+	c.Assert(dir, Not(Equals), "")
+
+	c.Check(scopefiles.PathExists(dir+"/the-dir-is-empty"), Equals, false)
+
+	err = os.RemoveAll(dir)
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestFindSourceDirectoryAndFiles(c *C) {
+	source := scopefiles.FindSourceDirectory()
+	c.Check(source, Not(Equals), "")
+
+	_, err := os.Stat(source + string(filepath.Separator) + "manifest.json")
+	c.Assert(err, IsNil)
+
+	_, err = os.Stat(source + string(filepath.Separator) + "goscope.ini")
+	c.Assert(err, IsNil)
+
+	_, err = os.Stat(source + string(filepath.Separator) + "goscope-security.json")
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestModifyFile(c *C) {
+	source := scopefiles.FindSourceDirectory()
+	c.Check(source, Not(Equals), "")
+
+	scopefiles.PrepareFile(source+string(filepath.Separator)+"goscope.ini", "./testFile", "%%GO_SCOPE%%")
+	_, err := os.Stat("./testFile")
+	c.Assert(err, IsNil)
+
+	buff, err := ioutil.ReadFile("./testFile")
+	c.Assert(err, IsNil)
+
+	c.Check(strings.Contains(string(buff), "%SCOPE_NAME%"), Equals, false)
+	c.Check(strings.Contains(string(buff), "%%GO_SCOPE%%"), Equals, true)
+
+	err = os.Remove("./testFile")
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestPrepareScopeFilesBadDir(c *C) {
+	err := scopefiles.PrepareScopeFiles("/tmpppppppppppp", "test", "developer")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(err.Error(), Equals, "Base directory /tmpppppppppppp does not exist")
+}
+
+func (s *S) TestPrepareScopeFiles(c *C) {
+	// create temp directory
+	dir, err := ioutil.TempDir("/tmp", "scopefiles_test")
+	c.Assert(err, IsNil)
+	c.Assert(dir, Not(Equals), "")
+
+	scopeDir := "test.developer"
+	sep := string(filepath.Separator)
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir), Equals, false)
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir+sep+scopeDir), Equals, false)
+
+	err = scopefiles.PrepareScopeFiles(dir, "test", "developer")
+	c.Assert(err, IsNil)
+
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir), Equals, true)
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir+sep+scopeDir), Equals, true)
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir+sep+"manifest.json"), Equals, true)
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir+sep+"goscope-security.json"), Equals, true)
+	c.Check(scopefiles.PathExists(dir+sep+scopeDir+sep+scopeDir+sep+"test.developer_test.ini"), Equals, true)
+
+	err = os.RemoveAll(dir)
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestCheckBuildDirectory(c *C) {
+	// create temp directory
+	dir, err := ioutil.TempDir("/tmp", "scopefiles_test")
+	c.Assert(err, IsNil)
+	c.Assert(dir, Not(Equals), "")
+
+	err = scopefiles.CheckBuildDirectory(dir, "test", "developer")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(err.Error(), Equals, "Directory "+dir+"/test.developer/test.developer does not exist, use the prepare-scope tool to create all needed files")
+
+	err = scopefiles.PrepareScopeFiles(dir, "test", "developer")
+	c.Assert(err, IsNil)
+
+	err = scopefiles.CheckBuildDirectory(dir, "test", "developer")
+	c.Check(err, IsNil)
+
+	err = os.RemoveAll(dir)
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestCheckBuildDirectoryBadDir(c *C) {
+	// create temp directory
+	dir, err := ioutil.TempDir("/tmp", "scopefiles_test")
+	c.Assert(err, IsNil)
+	c.Assert(dir, Not(Equals), "")
+
+	err = scopefiles.PrepareScopeFiles(dir, "test", "developer")
+	c.Assert(err, IsNil)
+
+	err = scopefiles.CheckBuildDirectory("/tmppppppp", "test", "developer")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(err.Error(), Equals, "Base directory /tmppppppp does not exist")
+
+	err = os.RemoveAll(dir)
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestCheckBuildDirectoryEraseManifestFile(c *C) {
+
+	sep := string(filepath.Separator)
+	filePaths := []string{"test.developer" + sep + "manifest.json",
+		"test.developer" + sep + "goscope-security.json",
+		"test.developer" + sep + "test.developer" + sep + "test.developer_test.ini",
+	}
+
+	for _, filePath := range filePaths {
+		// create temp directory
+		dir, err := ioutil.TempDir("/tmp", "scopefiles_test")
+		c.Assert(err, IsNil)
+		c.Assert(dir, Not(Equals), "")
+
+		err = scopefiles.PrepareScopeFiles(dir, "test", "developer")
+		c.Assert(err, IsNil)
+
+		err = os.Remove(dir + sep + filePath)
+		c.Assert(err, IsNil)
+
+		err = scopefiles.CheckBuildDirectory(dir, "test", "developer")
+		c.Check(err, Not(Equals), nil)
+		c.Check(err.Error(), Equals, "File "+dir+sep+filePath+" does not exist, use the prepare-scope tool to create all needed files")
+
+		err = os.RemoveAll(dir)
+		c.Assert(err, IsNil)
+	}
+}
+
+func (s *S) TestCheckBuildDirectoryCurrentDirectory(c *C) {
+	err := scopefiles.CheckBuildDirectory("", "test", "developer")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(err.Error(), Equals, "Directory ./test.developer/test.developer does not exist, use the prepare-scope tool to create all needed files")
+
+	err = scopefiles.PrepareScopeFiles("", "test", "developer")
+	c.Assert(err, IsNil)
+
+	err = scopefiles.CheckBuildDirectory("", "test", "developer")
+	c.Check(err, IsNil)
+
+	err = os.RemoveAll("test.developer")
+	c.Assert(err, IsNil)
+}
+
+func (s *S) TestPermissionErrors(c *C) {
+	err := scopefiles.PrepareScopeFiles("/usr", "test", "developer")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(err.Error(), Equals, "mkdir /usr/test.developer: permission denied")
+}