Esempio n. 1
0
func init() {
	logFile, err := os.OpenFile("systic.log", os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		log.Printf("Couldn't open systic.log. Logging to stdout.\n")
	} else {
		log.SetOutput(logFile)
	}

	Config, err := config.LoadConfig(filepath.Join("config", "app.conf"))
	if err != nil {
		log.Fatalf("Couldn't read app.conf: %s\n", err)
	}

	appName = Config.AppName

	if len(Config.Secret) < 20 {
		log.Fatalln("That secret in app.conf is not long enough! Make it hella long!")
	}
	Jar = sessions.NewCookieStore([]byte(Config.Secret))
}
Esempio n. 2
0
func buildProject(args []string) {
	// If intermediate directory already exists, remove it.
	// We're going to recreate it anyway. This is just easier.
	if err := os.RemoveAll(intermediateDir); err != nil {
		fatalError(err, "Couldn't remove existing intermediate directory!")
	}

	// Same for the build directory.
	if err := os.RemoveAll(buildDir); err != nil {
		fatalError(err, "Couldn't remove existing build directory!")
	}

	// Create the directory structure we need in the intermediate directory.
	for _, dirPath := range ids {
		os.MkdirAll(dirPath, 0744)
	}

	// Parse app.conf and apply its settings.

	appConfig, err := config.LoadConfig(join(configDir, appConf))
	if err != nil {
		fatalError(err, "Error reading app.conf:")
	}

	// Create initServer.go, which contains the generated code that sets up routes and stuff.
	serverSrcFile, err := os.Create(join(intermediateDir, serverSrc))
	if err != nil {
		fatalError(err, "Error creating file for generated server init:")
	}

	transformer.GenerateServerMain(serverSrcFile, join(configDir, routingConf), appConfig)
	serverSrcFile.Close()

	// Get a list of the controllers...
	controllerFiles, err := ioutil.ReadDir(controllersDir)

	if err != nil {
		fatalErrorf(err, "Error reading contents of %v:", controllersDir)
	}

	// ...and transform them and create their packages in intermediate.
	for _, controllerFileInfo := range controllerFiles {
		controllerFileName := controllerFileInfo.Name()
		if !strings.HasSuffix(controllerFileName, controllerExtension) {
			continue
		}
		controllerName := controllerFileName[0 : len(controllerFileName)-len(".controller")]
		controllerFilePath := join(controllersDir, controllerFileName)
		transformedControllerFileName := fmt.Sprintf("%s.go", controllerName)
		transformedControllerDirectory := join(intermediateDir, controllersDir, controllerName)
		transformedControllerFilePath := join(transformedControllerDirectory, transformedControllerFileName)

		err = os.Mkdir(transformedControllerDirectory, 0744)

		if err != nil {
			fatalErrorf(err, "Error creating package directory for %v:", controllerName)
		}

		transformedControllerFile, err := os.Create(transformedControllerFilePath)

		if err != nil {
			fatalErrorf(err, "Error transforming %v:", controllerFileName)
		}

		transformer.TransformController(transformedControllerFile, controllerFilePath)
		transformedControllerFile.Close()
	}

	// Copy over server.go, which contains the main() for the server.
	// This contains no generated code; it's part of a systic project.
	// skeleton includes a basic server.go which should be fine for most normal web applications.
	// Users may want to modify server.go to start other stuff like a websocket listener on another goroutine.
	err = copyFile(mainSrc, join(intermediateDir, mainSrc))
	if err != nil {
		fatalError(err, "Couldn't copy server.go to intermediate! Is it in your project root?")
	}

	// Make the build directory, which is where all the files needed for deployment end up.
	mkdirOrDie(buildDir, "Error making build directory.")

	// Copy over the view templates...
	mkdirOrDie(join(buildDir, viewsDir), "Couldn't create the views directory for deployment.")

	viewFiles, err := ioutil.ReadDir(viewsDir)
	if err != nil {
		fatalErrorf(err, "Error reading contents of %v:", viewsDir)
	}

	for _, viewFileInfo := range viewFiles {
		viewFileName := viewFileInfo.Name()
		if !strings.HasSuffix(viewFileName, viewExtension) {
			continue
		}
		src := join(viewsDir, viewFileName)
		dst := join(buildDir, viewsDir, viewFileName)
		copyFile(src, dst)
	}

	// Copy over the config...
	mkdirOrDie(join(buildDir, configDir), "Couldn't create config directory for deployment.")
	src := join(configDir, appConf)
	dst := join(buildDir, configDir, appConf)
	copyFile(src, dst)

	appname := appConfig.AppName
	// F*****g Windows 98...
	if runtime.GOOS == "windows" {
		appname = fmt.Sprintf("%v.exe", appname)
	}

	// Compile intermediate and create the executable.
	outputFilePath := join(buildDir, appname)

	cmdArgs := []string{"build", "-o", outputFilePath, "-v", strings.Join([]string{".", intermediateDir}, string(os.PathSeparator))}
	log.Printf("%v\n", strings.Join(cmdArgs, " "))
	cmd := exec.Command("go", cmdArgs...)
	output, err := cmd.CombinedOutput()
	os.Stdout.Write(output)

	if err != nil {
		fatalError(err, "Build did not complete successfully.")
	}

	fmt.Println("No errors. Build successful?")
}
Esempio n. 3
0
func copyProject(srcPath string, srcInfo os.FileInfo, err error) error {
	// Get the path of this file relative to the root of the project.
	relativeSrcPath := strings.TrimLeft(srcPath[len(baseProjectDir):], string(os.PathSeparator))

	if len(relativeSrcPath) == 0 {
		return nil
	}

	absDestPath := path.Join(newProjectDir, relativeSrcPath)

	_, err = os.Stat(absDestPath)

	// If it's a directory, try to create it.
	if srcInfo.IsDir() {
		err := os.Mkdir(absDestPath, 0744)
		if err != nil {
			if !os.IsExist(err) {
				errorf("Failed to create directory: %s\n", err)
			}
		}
		return nil
	}

	// Need to do this double negation; we don't get an error if it DOES exist.
	if !os.IsNotExist(err) {
		// Skip if it's a README.md that we already copied...
		if strings.Contains(relativeSrcPath, "README.md") {
			return nil
		}
		fmt.Printf("Overwrite %v? [Y/n] ", absDestPath)
		var choice string
		fmt.Scan(&choice)
		choice = strings.ToLower(choice[0:1])
		fmt.Print("\n")
		if choice == "n" {
			return nil
		}
	}

	/*
		Process app.conf.
		Set appname to the name of the base directory of the new project.
		Set secret to a randomly generated value.
	*/
	if strings.Contains(relativeSrcPath, "app.conf") {
		appConfig, err := config.LoadConfig(srcPath)
		if err != nil {
			errorf("Couldn't read app.conf: %s\n", err)
		}

		appConfig.AppName = filepath.Base(newProjectDir)
		appConfig.Secret = generateSecret()

		configBytes, err := json.MarshalIndent(appConfig, "", "\t")
		if err != nil {
			errorf("Error marshalling app.conf: %s\n", err)
		}

		err = ioutil.WriteFile(absDestPath, configBytes, 0644)
		if err != nil {
			errorf("Error writing %s: %s\n", absDestPath, err)
		}

		return nil
	}

	// Anything else is just a plain old copy...
	srcBytes, err := ioutil.ReadFile(srcPath)
	if err != nil {
		errorf("Failed to read file: %s\n", err)
	}

	err = ioutil.WriteFile(absDestPath, srcBytes, 0600)
	if err != nil {
		errorf("Failed to write file: %s\n", err)
	}
	return nil

}