// Returns a singleton instance of API, intialised with an empty DB containing a
// single user and a silent version of ClassicMartini
func getTestApi() API {
if test_api != nil {
return test_api
}
// Set Log level here. This should only be called once, and near the start
// of the test run
if !*verboseMartini {
log.SetLevel(log.ErrorLevel)
} else {
log.SetLevel(log.DebugLevel)
}
db := getTestDb()
a := New(Options{JwtKey: "RandomString", Db: db, Martini: getSilentMartini()})
a.AddDefaultRoutes(&PrivateWidget{}, RouteOptions{Authenticate: true})
a.AddDefaultRoutes(&Widget{})
a.AddDefaultRoutes(&VerifiedWidget{})
a.AddDefaultRoutes(&Widget{}, RouteOptions{UriModelName: "other_widgets"})
a.AddDefaultRoutes(&User{})
a.SetAuth(&User{}, "/auth")
test_api = a
return a
}
func main() {
config, err := core.ParseConfig("./config.yaml")
if err != nil {
logrus.Errorf("Failed to parse configuration: %s", err)
return
}
switch core.Global.Logging {
case "debug":
logrus.SetLevel(logrus.DebugLevel)
case "info":
logrus.SetLevel(logrus.InfoLevel)
case "warn":
logrus.SetLevel(logrus.WarnLevel)
case "error":
logrus.SetLevel(logrus.ErrorLevel)
default:
logrus.SetLevel(logrus.InfoLevel)
logrus.Warnf("Home: invalid log level supplied: '%s'", core.Global.Logging)
}
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
for sig := range c {
_ = sig
eventbus.EventBus.Publish(eventbus.Event{
Topic: eventbus.HOME_SHUTDOWN,
Origin: "home",
})
}
}()
logrus.Infof("[Home] Geo-Location set to: Lat=%f Long=%f", core.Global.Latitude, core.Global.Longitude)
service.ServiceRegistry.Register(&backend.Component{
Name: "core",
}, "shutdown_home", "Shutdown home", shutdownHome, map[string]string{}, map[string]string{})
eventbus.EventBus.Start()
backendConfig, _ := config.List("backends")
backend.DefaultManager.StartBackendsByConfig(backendConfig)
eventbus.EventBus.Subscribe(eventbus.HOME_SHUTDOWN, func(event eventbus.Event) {
backend.DefaultManager.StopBackends()
})
core.PluginManager.Start(config)
core.StateTracker.Start()
service.ServiceRegistry.Start()
eventbus.EventBus.Publish(eventbus.Event{
Topic: eventbus.HOME_STARTED,
Origin: "home",
})
eventbus.EventBus.Wait()
}
func main() {
app := cli.NewApp()
app.Name = "pipes_api"
app.Author = "Francis Bouvier <*****@*****.**>"
app.Version = "0.1.0"
app.Usage = "API for pipes, micro-services framework"
app.Flags = []cli.Flag{logLevelFlag}
app.Action = func(c *cli.Context) {
switch c.String("log") {
case "debug":
log.SetLevel(log.DebugLevel)
case "warn":
log.SetLevel(log.WarnLevel)
default:
log.SetLevel(log.InfoLevel)
}
storeAddr := c.Args()[0]
projectID := c.Args()[1]
addr := "0.0.0.0:8080"
if err := launch(storeAddr, projectID, addr); err != nil {
log.Fatalln(err)
}
}
app.Run(os.Args)
}
// InitLog initializes the logrus logger
func InitLog(logLevel, formatter string) error {
switch formatter {
case LogStashFormatter:
logrus.SetFormatter(&logstash.LogstashFormatter{
TimestampFormat: time.RFC3339,
})
default:
logrus.SetFormatter(&logrus.TextFormatter{
ForceColors: true,
FullTimestamp: true,
})
}
logrus.SetOutput(os.Stdout)
level, err := logrus.ParseLevel(logLevel)
if err != nil {
logrus.SetLevel(logrus.DebugLevel)
return err
}
logrus.SetLevel(level)
return nil
}
func ParseArgs(config *Config) {
configfile := flag.String("config", "etc/ssologin.json", "config file (JSON)")
flag.BoolVar(&config.Debug, "debug", false, "Debug-level output")
flag.Parse()
// Read the config file
c, err := ioutil.ReadFile(*configfile)
CheckError(err)
// Unmarshal the config file
err = json.Unmarshal(c, &config)
CheckError(err)
// Convert Expiration (int) to time type
config.Expiry = time.Duration(config.Expiration) * time.Second
// Set appropriate log-level
if config.Debug {
log.SetLevel(log.DebugLevel)
} else {
log.SetLevel(log.InfoLevel)
}
privkey, err := ssocookie.ReadECCPrivateKeyPem(config.Privkeyfile)
CheckError(err)
config.Privkey = privkey
}
func main() {
app := cli.NewApp()
app.Name = path.Base(os.Args[0])
app.Usage = "An entropy and failure injection management API for Docker platforms."
app.Version = VERSION
app.Authors = []cli.Author{{Name: "Jeff Nickoloff", Email: "*****@*****.**"}}
app.Flags = flags
app.Commands = commands
app.Before = func(c *cli.Context) error {
log.SetOutput(os.Stderr)
level, err := log.ParseLevel(c.String("log-level"))
if err != nil {
log.Fatalf(err.Error())
}
log.SetLevel(level)
// If a log level wasn't specified and we are running in debug mode,
// enforce log-level=debug.
if !c.IsSet("log-level") && !c.IsSet("l") && c.Bool("debug") {
log.SetLevel(log.DebugLevel)
}
return nil
}
if err := app.Run(os.Args); err != nil {
log.Fatal(err)
}
}
func main() {
flag.Parse()
cpus := runtime.NumCPU()
runtime.GOMAXPROCS(cpus)
log.SetFormatter(&log.JSONFormatter{})
log.SetOutput(os.Stderr)
if *env == "production" {
log.SetLevel(log.WarnLevel)
} else {
log.SetLevel(log.DebugLevel)
}
log.Infoln("Starting server...")
// load config
d, err := ioutil.ReadFile(*configFile)
if err != nil {
log.Fatalln("[ERROR] read config.yml", err)
}
cfg, err := config.Load(bytes.NewReader(d), *env)
if err != nil {
log.Fatalln("[ERROR] config Load", err)
}
psAll := sphinx.NewSphinx(cfg.PSConfig, cpus)
ctx := context.Background()
ctx = sphinx.NewContext(ctx, psAll)
kami.Context = ctx
kami.Serve()
}
func main() {
need_help := flag.Bool("h", false, "Show help")
is_server := flag.Bool("s", false, "Run as server")
verbose := flag.Bool("v", false, "More verbose output")
cpuprofile := flag.String("cpuprofile", "", "Write cpu profile to file")
flag.Parse()
log.SetFormatter(&LogFormatter{&log.TextFormatter{
FullTimestamp: true,
TimestampFormat: time.RFC822,
}, "JUSTVPN"})
log.SetLevel(log.InfoLevel)
if *verbose {
log.SetLevel(log.DebugLevel)
}
if *need_help {
fmt.Printf("Usage: %v [OPTIONS] config.json\n", os.Args[0])
flag.PrintDefaults()
os.Exit(0)
}
if *is_server {
log.Info("Running as server!")
}
if *cpuprofile != "" {
log.Info("Saving CPU profile to %v", *cpuprofile)
if f, err := os.Create(*cpuprofile); err != nil {
log.Fatal(err)
} else {
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
}
if flag.NArg() == 0 {
log.Fatal("Config file missing")
}
json_content, err := ioutil.ReadFile(flag.Arg(0))
if err != nil {
log.WithField("filename", flag.Arg(0)).Fatal("Error reading config file")
}
vpn := justvpn.VPN{}
defer vpn.Destroy()
if err = vpn.Init(*is_server, json_content); err != nil {
log.WithField("error", err).Error("Error initing VPN")
return
}
vpn.Start()
signal_chan := make(chan os.Signal, 1)
signal.Notify(signal_chan, os.Interrupt)
select {
case <-signal_chan:
fmt.Println("CTRL-C Pressed")
}
}
func InitializeLogger(developerModeFlag bool) {
logger = log.New()
if developerModeFlag {
customFormatter := new(log.TextFormatter)
customFormatter.FullTimestamp = true
customFormatter.TimestampFormat = "2006-01-02 15:04:05"
log.SetFormatter(customFormatter)
log.SetLevel(log.DebugLevel)
logger.Level = log.DebugLevel
logger.Formatter = customFormatter
} else {
customFormatter := new(log.JSONFormatter)
customFormatter.TimestampFormat = "2006-01-02 15:04:05"
log.SetFormatter(customFormatter)
customFormatter.DisableTimestamp = false
log.SetLevel(log.InfoLevel)
logger.Level = log.InfoLevel
logger.Formatter = customFormatter
}
logger.Out = os.Stdout
}
func NewCustomizedLogger(level string, developerModeFlag bool) (*log.Logger, error) {
logger := log.New()
lv, err := log.ParseLevel(level)
if err != nil {
return nil, err
}
logger.Level = lv
if developerModeFlag {
customFormatter := new(log.TextFormatter)
customFormatter.FullTimestamp = true
customFormatter.TimestampFormat = "2006-01-02 15:04:05"
log.SetFormatter(customFormatter)
log.SetLevel(log.DebugLevel)
logger.Level = lv
logger.Formatter = customFormatter
} else {
customFormatter := new(log.JSONFormatter)
customFormatter.TimestampFormat = "2006-01-02 15:04:05"
log.SetFormatter(customFormatter)
customFormatter.DisableTimestamp = false
log.SetLevel(log.InfoLevel)
logger.Level = lv
logger.Formatter = customFormatter
}
logger.Out = os.Stdout
return logger, nil
}
func TestRunWithTimeoutFailed(t *testing.T) {
log.SetLevel(log.DebugLevel)
defer log.SetLevel(log.InfoLevel)
tmp, _ := ioutil.TempFile("", "tmp")
defer os.Remove(tmp.Name())
log.SetOutput(tmp)
defer log.SetOutput(os.Stdout)
cmd, _ := NewCommand("./testdata/test.sh failStuff --debug", "100ms")
fields := log.Fields{"process": "test"}
if err := RunWithTimeout(cmd, fields); err == nil {
t.Errorf("Expected error but got nil")
}
time.Sleep(200 * time.Millisecond)
buf, _ := ioutil.ReadFile(tmp.Name())
logs := string(buf)
if strings.Contains(logs, "timeout after") {
t.Fatalf("RunWithTimeout failed to cancel timeout after failure: %v", logs)
}
}
func SetLoggingLevel(debug bool) {
if debug {
log.SetLevel(log.DebugLevel)
} else {
log.SetLevel(log.InfoLevel)
}
}
func setDebugMode(debug bool) {
if !debug {
logrus.SetLevel(logrus.InfoLevel)
} else {
logrus.SetLevel(logrus.DebugLevel)
}
}
func main() {
// configure logging
logrus.SetLevel(logrus.InfoLevel)
logrus.SetFormatter(&logrus.TextFormatter{FullTimestamp: true})
// options to change log level
globalOptions.Quiet = func() {
logrus.SetLevel(logrus.WarnLevel)
}
globalOptions.Verbose = func() {
logrus.SetLevel(logrus.DebugLevel)
}
globalOptions.LogJSON = func() {
logrus.SetFormatter(&logrus.JSONFormatter{})
}
globalOptions.LogSyslog = func() {
setupSyslog()
}
originalArgs = os.Args
if _, err := parser.Parse(); err != nil {
os.Exit(1)
}
}
// initConfig reads in config file and ENV variables if set.
func initConfig() {
if len(cfgFile) != 0 {
viper.SetConfigFile(cfgFile)
}
viper.SetConfigName(".otp-config")
viper.AddConfigPath("$HOME")
viper.AutomaticEnv()
apiKey, _ := RootCmd.Flags().GetString("api-key")
if len(apiKey) == 0 && len(os.Getenv("GITHUB_API_KEY")) > 0 {
RootCmd.Flags().Set("api-key", os.Getenv("GITHUB_API_KEY"))
}
if len(apiKey) > 0 {
if err := os.Setenv("GITHUB_API_KEY", apiKey); err != nil {
fmt.Fprintf(os.Stderr, "Error: Unable to set GITHUB_API_KEY\n")
os.Exit(1)
}
}
// If a config file is found, read it in.
if err := viper.ReadInConfig(); err == nil {
fmt.Println("Using config file:", viper.ConfigFileUsed())
}
log.SetFormatter(&log.TextFormatter{})
log.SetOutput(os.Stderr)
if api.Verbose {
log.SetLevel(log.DebugLevel)
} else {
log.SetLevel(log.WarnLevel)
}
}
func (t *tether) setLogLevel() {
// TODO: move all of this into an extension.Pre() block when we move to that model
// adjust the logging level appropriately
switch t.config.DebugLevel {
case 0:
log.SetLevel(log.InfoLevel)
// TODO: do not echo application output to console without debug enabled
serial.DisableTracing()
case 1:
log.SetLevel(log.DebugLevel)
serial.DisableTracing()
case 2:
log.SetLevel(log.DebugLevel)
serial.EnableTracing()
log.Info("Launching pprof server on port 6060")
fn := func() {
go http.ListenAndServe("0.0.0.0:6060", nil)
}
once.Do(fn)
default:
log.SetLevel(log.DebugLevel)
logConfig(t.config)
}
}
func main() {
envflag.Parse()
if *debug {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.WarnLevel)
}
handler := router.Load(
ginrus.Ginrus(logrus.StandardLogger(), time.RFC3339, true),
middleware.Version,
middleware.Store(),
middleware.Remote(),
middleware.Cache(),
)
if *cert != "" {
logrus.Fatal(
http.ListenAndServeTLS(*addr, *cert, *key, handler),
)
} else {
logrus.Fatal(
http.ListenAndServe(*addr, handler),
)
}
}
func LoadSettingsFromFile() {
viper.SetConfigType(ConfigType)
setConfigLocation()
// Set defaults
viper.SetDefault("Port", Port)
viper.SetDefault("EnableAutomerge", EnableAutomerge)
viper.SetDefault("Debug", Debug)
viper.SetDefault("DefaultEnvironment", DefaultEnvironment)
viper.SetDefault("DefaultTask", DefaultTask)
viper.SetDefault("BoltdbName", BoltdbName)
// Load configuration
err := viper.ReadInConfig()
if err != nil {
log.Warning("Configuration not found, loading defaults")
}
// set log level
if viper.GetBool("Debug") {
log.SetLevel(log.DebugLevel)
} else {
log.SetLevel(log.InfoLevel)
}
log.Debugf("Loaded setting values: %v", viper.AllSettings())
log.Info("Settings loaded")
}
func init() {
cmf, err := os.Open("casemanager.conf")
if err != nil {
logrus.Fatal(err)
return
}
defer cmf.Close()
if err = json.NewDecoder(cmf).Decode(&pubConfig); err != nil {
logrus.Fatal(err)
return
}
if pubConfig.Debug {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.WarnLevel)
}
db := liboct.GetDefaultDB()
db.RegistCollect(liboct.DBCase)
db.RegistCollect(liboct.DBRepo)
db.RegistCollect(liboct.DBTask)
repos := pubConfig.Repos
for index := 0; index < len(repos); index++ {
if err := repos[index].IsValid(); err != nil {
logrus.Warnf("The repo ", repos[index], " is invalid. ", err.Error())
continue
}
if id, err := db.Add(liboct.DBRepo, repos[index]); err == nil {
RefreshRepo(id)
}
}
}
func init() {
of, err := os.Open("octd.conf")
if err != nil {
logrus.Fatal(err)
return
}
defer of.Close()
if err = json.NewDecoder(of).Decode(&pubConfig); err != nil {
logrus.Fatal(err)
return
}
if pubConfig.Class == "container" {
cmd := exec.Command("/bin/sh", "-c", pubConfig.ContainerDaemon)
cmd.Stdin = os.Stdin
if _, err := cmd.CombinedOutput(); err != nil {
logrus.Fatal(err)
return
}
}
if pubConfig.Debug {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.InfoLevel)
}
db := liboct.GetDefaultDB()
db.RegistCollect(liboct.DBTask)
RegisterToTestServer()
}
func main() {
// let the user enter the number of points to be used
numPoints := flag.Int("points", 1000, "Number of points to be generated")
filename := flag.String("output", "curve", "name of the file where the image will be written")
size := flag.Int("size", 1024, "Size of the file to be generated")
debug := flag.Bool("d", false, "Print debug information")
flag.Parse()
if *debug {
log.SetLevel(log.DebugLevel)
log.Debug("Debug enabled")
} else {
log.SetLevel(log.InfoLevel)
}
runtime.GOMAXPROCS(runtime.NumCPU())
file := fmt.Sprintf("%s.png", *filename)
log.Info("Starting program")
pl := point.RandomSlice(*numPoints)
log.Info("Calculating matrix")
m := matrix.FindSmallerCellSize(&pl)
//fmt.Println("Initial matrix: ", m)
canvas := drawing.NewCanvas(*size, file)
strat := strategy.NewSnake(len(m.Squares))
m.Draw(canvas, *strat)
log.Info("Saving the image (this process might take a few minutes)")
canvas.Save()
log.Info("Finished program")
}
// Returns a singleton instance of API, intialised with an empty DB containing a
// single user
func getTestApi() *Grapi {
if test_api != nil {
return test_api
}
// Set Log level here. This should only be called once, and near the start
// of the test run
logLevel := 0
if !*verboseAPI {
log.SetLevel(log.PanicLevel)
} else {
logLevel = 1
log.SetLevel(log.DebugLevel)
}
db := getTestDb()
a := New(Options{JwtKey: "RandomString", Db: db, LogLevel: logLevel})
a.AddDefaultRoutes(&PrivateWidget{}, RouteOptions{UseDefaultAuth: true})
a.AddDefaultRoutes(&Widget{})
a.AddDefaultRoutes(&VerifiedWidget{})
a.AddDefaultRoutes(&Widget{}, RouteOptions{UriModelName: "other_widgets"})
a.AddDefaultRoutes(&User{})
a.SetAuth(&User{}, "auth")
test_api = a
return a
}
func Action(c *cli.Context) {
if len(c.Args()) != 1 {
logrus.Fatalf("usage: gotty-client [GoTTY URL]")
}
// setting up logrus
logrus.SetOutput(os.Stderr)
if c.Bool("debug") {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.InfoLevel)
}
// create Client
url := c.Args()[0]
client, err := gottyclient.NewClient(url)
if err != nil {
logrus.Fatalf("Cannot create client: %v", err)
}
if c.Bool("skip-tls-verify") {
client.SkipTLSVerify = true
}
// loop
if err = client.Loop(); err != nil {
logrus.Fatalf("Communication error: %v", err)
}
}
func main() {
flag.Parse()
if flLogLevel != "" {
lvl, err := logrus.ParseLevel(flLogLevel)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to parse logging level: %s\n", flLogLevel)
os.Exit(1)
}
logrus.SetLevel(lvl)
} else {
logrus.SetLevel(logrus.InfoLevel)
}
if flDebug {
logrus.SetLevel(logrus.DebugLevel)
}
d, err := rbd.NewRbdDriver(root, graphOptions)
if err != nil {
logrus.Errorf("Create rbd driver failed: %v", err)
os.Exit(1)
}
h := degraph.NewHandler(d)
logrus.Infof("listening on %s\n", socketAddress)
fmt.Println(h.ServeUnix("root", socketAddress))
}
func init() {
log.SetOutput(os.Stderr)
log.SetLevel(log.InfoLevel)
if os.Getenv("DEBUG") != "" {
log.SetLevel(log.DebugLevel)
}
}
func (f *filePublisher) Publish(metrics []plugin.Metric, config plugin.Config) error {
log.SetFormatter(&log.TextFormatter{DisableTimestamp: true})
if _, err := config.GetBool(debug); err == nil {
log.SetLevel(log.DebugLevel)
} else {
log.SetLevel(log.InfoLevel)
}
log.Debug("publishing started")
filename, err := config.GetString("file")
if err != nil {
log.Error(err)
return err
}
file, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0666)
defer file.Close()
if err != nil {
log.Error(err)
return err
}
log.WithFields(log.Fields{
"file": filename,
"metrics-published-count": len(metrics),
}).Debug("metrics published")
w := bufio.NewWriter(file)
for _, m := range metrics {
formattedTags := formatMetricTagsAsString(m.Tags)
w.WriteString(fmt.Sprintf("%v|%v|%v|%v\n", m.Timestamp, m.Namespace, m.Data, formattedTags))
}
w.Flush()
return nil
}
func setupLogger(cmd *cobra.Command, args []string) {
if verbose, _ := cmd.Flags().GetBool(VerboseFlag); verbose {
log.SetLevel(log.DebugLevel)
} else {
log.SetLevel(log.InfoLevel)
}
}
func initLogrus(ctx *cli.Context) {
logrus.SetFormatter(&logrus.TextFormatter{
TimestampFormat: time.RFC822,
FullTimestamp: true,
})
if level, err := logrus.ParseLevel(ctx.String("log_level")); err == nil {
logrus.SetLevel(level)
} else {
log.Error(err)
logrus.SetLevel(logrus.InfoLevel)
}
filename := ctx.String("log_file")
logrus.SetOutput(os.Stderr)
if filename != "" {
var f *os.File
_, err := os.Stat(filename)
if !os.IsNotExist(err) {
os.Rename(filename, filename+".prev")
}
f, err = os.Create(filename)
if err != nil {
log.Error("Cannot create log file ", err)
log.Warning("Continuing to log to stderr")
} else {
logrus.SetOutput(f)
}
}
}
func main() {
// Set log options.
log.SetOutput(os.Stderr)
log.SetLevel(log.WarnLevel)
// Options.
var opts struct {
Verbose bool `short:"v" long:"verbose" description:"Verbose"`
Version bool `long:"version" description:"Version"`
BindAddr string `short:"b" long:"bind-addr" description:"Bind to address" default:"0.0.0.0"`
Port int `short:"p" long:"port" description:"Port" default:"5050"`
StaticDir string `short:"s" long:"static-dir" description:"Static content" default:"static"`
TemplateDir string `short:"t" long:"template-dir" description:"Templates" default:"templates"`
}
// Parse options.
if _, err := flags.Parse(&opts); err != nil {
ferr := err.(*flags.Error)
if ferr.Type == flags.ErrHelp {
os.Exit(0)
} else {
log.Fatal(err.Error())
}
}
// Print version.
if opts.Version {
fmt.Printf("peekaboo %s\n", Version)
os.Exit(0)
}
// Set verbose.
if opts.Verbose {
log.SetLevel(log.InfoLevel)
}
// Check root.
if runtime.GOOS != "darwin" && os.Getuid() != 0 {
log.Fatal("This application requires root privileges to run.")
}
info, err := hwinfo.Get()
if err != nil {
log.Fatal(err.Error())
}
log.Infof("Using static dir: %s", opts.StaticDir)
log.Infof("Using template dir: %s", opts.TemplateDir)
m := macaron.Classic()
m.Use(macaron.Static(opts.StaticDir))
m.Use(macaron.Renderer(macaron.RenderOptions{
Directory: opts.TemplateDir,
IndentJSON: true,
}))
routes(m, info)
m.Run(opts.BindAddr, opts.Port)
}
// Entry point of oci2aci,
// First convert oci layout to aci layout, then build aci layout to image.
func RunOCI2ACI(args []string, flagDebug bool, flagName string) error {
var srcPath, dstPath string
srcPath = args[0]
if len(args) == 1 {
dstPath = ""
} else {
dstPath = args[1]
ext := filepath.Ext(dstPath)
if ext != schema.ACIExtension {
errStr := fmt.Sprintf("Extension must be %s (given %s)", schema.ACIExtension, ext)
err := errors.New(errStr)
return err
}
}
if flagDebug {
logrus.SetLevel(logrus.DebugLevel)
} else {
logrus.SetLevel(logrus.InfoLevel)
}
manifestName = flagName
_, err := types.NewACName(manifestName)
if err != nil {
return err
}
if bValidate := validateOCIProc(srcPath); bValidate != true {
logrus.Infof("Conversion stop.")
return nil
}
dirWork := createWorkDir()
// First, convert layout
manifestPath, err := convertLayout(srcPath, dirWork)
if err != nil {
logrus.Debugf("Conversion from oci to aci layout failed: %v", err)
} else {
logrus.Debugf("Manifest:%v generated successfully.", manifestPath)
}
// Second, build image
imgPath, err := buildACI(dirWork)
if err != nil {
logrus.Debugf("Generate aci image failed:%v", err)
} else {
logrus.Debugf("Image:%v generated successfully.", imgPath)
}
// Save aci image to the path user specified
if dstPath != "" {
if err = run(exec.Command("cp", imgPath, dstPath)); err != nil {
logrus.Debugf("Store aci image failed:%v", err)
} else {
logrus.Debugf("Image:%v generated successfully", dstPath)
}
}
return nil
}
