func main() {
opts := optparse.New("Usage: dynamodb-marshal file1.go [file2.go ...]",
"dynamodb-marshal 0.0.1")
force := opts.Bool([]string{"-f", "--force"},
"overwrite existing marshal files")
os.Args[0] = "dynamodb-marshal"
files := opts.Parse(os.Args)
if len(files) == 0 {
opts.PrintUsage()
runtime.Exit(0)
}
log.AddConsoleLogger()
for _, file := range files {
path, err := filepath.Abs(file)
if err != nil {
runtime.StandardError(err)
}
parseFile(path, *force)
}
log.Wait()
}
func (r Registry) Main(ctx *Context, args []string) {
opts := optparse.Parser("Usage: bolt <command-1> <command-2> ... [options]\n", "bolt 0.1")
opts.String([]string{"--boltfile"}, "",
"use the Boltfile at the given path", "PATH")
opts.String([]string{"--gen"}, "",
"save the generated executable at the given path", "PATH")
opts.Bool([]string{"--recompile"}, false,
"recompile the generated executable instead of using cached builds")
noConsoleLog := opts.BoolConfig("no-console-log", false,
"disable logging to the console [false]")
completions := append(ctx.completions, r.Keys()...)
opts.Completer = optparse.ListCompleter(completions...)
opts.Parse(args)
if len(args) == 1 {
listing := r.Listing()
fmt.Print(listing)
runtime.Exit(0)
}
if !*noConsoleLog {
log.AddConsoleLogger()
}
buf := &bytes.Buffer{}
yaml.NormaliseID(buf, args[1])
cmd := buf.String()
if task, ok := r[cmd]; ok {
task.Func.Call([]reflect.Value{reflect.ValueOf(ctx)})
} else {
fmt.Printf("Task not found:\n\n\t%s\n\n", args[1])
runtime.Exit(1)
}
}
func main() {
opts := optparse.Parser("Usage: genapi [options]", "0.1")
root := opts.String(
[]string{"-r", "--root"}, "../src/espra",
"path to the root package directory for the app", "PATH")
ignoreList := opts.String(
[]string{"-i", "--ignore"}, "api.go html.go",
"space-separated list of files/subdirectories to ignore", "LIST")
digestFile := opts.String(
[]string{"-d", "--digest"}, "../etc/app/version.digest",
"path to write the digest of the API version", "PATH")
os.Args[0] = "genapi"
opts.Parse(os.Args)
log.AddConsoleLogger()
ignore := strings.Split(*ignoreList, " ")
for i, path := range ignore {
ignore[i] = filepath.Join(*root, path)
}
pkgpath := strings.Split(*root, "/")
pkgname := pkgpath[len(pkgpath)-1]
if err := parseDirectory(pkgname, pkgname, *root, ignore); err != nil {
runtime.StandardError(err)
}
for _, method := range methods {
log.Info("%#v", method)
}
log.Wait()
_ = *digestFile
}
// DefaultOpts processes default runtime command line options.
func DefaultOpts(name string, opts *optparse.Parser, argv []string, autoExit bool) (bool, string, string, string, bool) {
var (
configPath string
instanceDirectory string
err error
)
debug := opts.Bool([]string{"-d", "--debug"},
"enable debug mode")
genConfig := opts.Bool([]string{"-g", "--gen-config"},
"show the default yaml config")
runDirectory := opts.StringConfig("run-dir", "run",
"the path to the run directory to store locks, pid files, etc. [run]")
logDirectory := opts.StringConfig("log-dir", "log",
"the path to the log directory [log]")
logRotate := opts.StringConfig("log-rotate", "never",
"specify one of 'hourly', 'daily' or 'never' [never]")
noConsoleLog := opts.BoolConfig("no-console-log",
"disable server requests being logged to the console [false]")
extraConfig := opts.StringConfig("extra-config", "",
"path to a YAML config file with additional options")
// Parse the command line options.
args := opts.Parse(argv)
// Print the default YAML config file if the ``-g`` flag was specified.
if *genConfig {
opts.PrintDefaultConfigFile(name)
Exit(0)
}
// Enable the console logger early.
if !*noConsoleLog {
log.AddConsoleLogger()
}
// Assume the parent directory of the config as the instance directory.
if len(args) >= 1 {
var statInfo os.FileInfo
configPath, err = filepath.Abs(filepath.Clean(args[0]))
if err != nil {
StandardError(err)
}
statInfo, err = os.Stat(configPath)
if err != nil {
StandardError(err)
}
if statInfo.IsDir() {
instanceDirectory = configPath
Profile = "default"
} else {
err = opts.ParseConfig(configPath, os.Args)
if err != nil {
StandardError(err)
}
instanceDirectory, _ = filepath.Split(configPath)
Profile = strings.Split(filepath.Base(configPath), ".")[0]
}
} else {
if autoExit {
opts.PrintUsage()
Exit(0)
}
return false, "", "", "", true
}
// Load the extra config file with additional options if one has been
// specified.
if *extraConfig != "" {
extraConfigPath, err := filepath.Abs(filepath.Clean(*extraConfig))
if err != nil {
StandardError(err)
}
extraConfigPath = JoinPath(instanceDirectory, extraConfigPath)
err = opts.ParseConfig(extraConfigPath, os.Args)
if err != nil {
StandardError(err)
}
}
// Create the log directory if it doesn't exist.
logPath := JoinPath(instanceDirectory, *logDirectory)
err = os.MkdirAll(logPath, 0755)
if err != nil {
StandardError(err)
}
// Create the run directory if it doesn't exist.
runPath := JoinPath(instanceDirectory, *runDirectory)
err = os.MkdirAll(runPath, 0755)
if err != nil {
StandardError(err)
}
// Setup the file and console logging.
var rotate int
switch *logRotate {
case "daily":
rotate = log.RotateDaily
case "hourly":
rotate = log.RotateHourly
case "never":
rotate = log.RotateNever
default:
Error("Unknown log rotation format %q", *logRotate)
}
_, err = log.AddFileLogger(name, logPath, rotate, log.InfoLog)
if err != nil {
Error("Couldn't initialise logfile: %s", err)
}
_, err = log.AddFileLogger("error", logPath, rotate, log.ErrorLog)
if err != nil {
Error("Couldn't initialise logfile: %s", err)
}
// Initialise the runtime -- which will run the process on multiple
// processors if possible.
Init()
// Initialise the process-related resources.
if Platform != "windows" {
InitProcess(name, runPath)
}
return *debug, instanceDirectory, runPath, logPath, false
}
func main() {
opts := optparse.Parser("Usage: html2domly [options]", "v")
outputFile := opts.String([]string{"-o", "--output"}, "../coffee/templates.coffee", "coffeescript file to compile to", "PATH")
templatesSrcDir := opts.String([]string{"-i", "--input"}, "../etc/domly", "template source directory", "PATH")
printJSON := opts.Bool([]string{"--print"}, false, "Print the JSON nicely to the output logger")
os.Args[0] = "html2domly"
opts.Parse(os.Args)
log.AddConsoleLogger()
var (
data []byte
err error
prettyStr string
basename string
pretty bytes.Buffer
)
dir, err := os.Open(*templatesSrcDir)
if err != nil {
runtime.StandardError(err)
}
defer dir.Close()
out, err := os.Create(*outputFile)
if err != nil {
runtime.StandardError(err)
}
defer out.Close()
names, err := dir.Readdirnames(0)
if err != nil {
runtime.StandardError(err)
}
out.Write([]byte("define 'templates', (exports, root) ->\n"))
for _, name := range names {
if strings.HasSuffix(name, ".html") {
basename = strings.TrimSuffix(name, ".html")
} else {
log.Error("file %v does not end in .html", name)
continue
}
templatePath := filepath.Join(*templatesSrcDir, name)
data, err = ui.ParseTemplate(templatePath)
if err != nil {
log.StandardError(err)
} else {
err := json.Indent(&pretty, data, ">", " ")
if err != nil {
log.StandardError(err)
log.Info("%v", data)
} else if *printJSON {
prettyStr = pretty.String()
pretty.Reset()
log.Info("%v", prettyStr)
}
out.Write([]byte(fmt.Sprintf(" exports['%s'] = `%s`\n", basename, data)))
log.Info("compiled '%s'", name)
}
}
out.Write([]byte(" return"))
outPath, _ := filepath.Abs(*outputFile)
log.Info("compiled domly written to: %v", outPath)
log.Wait()
}