func main() {
if version.Show() {
fmt.Fprintf(os.Stdout, "%s\n", version.String())
return
}
// If we're in an ESXi environment, then we need
// to extract the userid/password from UserPassword
if vchConfig.UserPassword != "" {
newurl, _ := url.Parse(fmt.Sprintf("%s://%s@%s%s",
vchConfig.Target.Scheme,
vchConfig.UserPassword,
vchConfig.Target.Host,
vchConfig.Target.Path))
vchConfig.Target = *newurl
}
// FIXME: these should just be consumed directly inside Session
rootConfig.Service = vchConfig.Target.String()
rootConfig.ExtensionCert = vchConfig.ExtensionCert
rootConfig.ExtensionKey = vchConfig.ExtensionKey
rootConfig.ExtensionName = vchConfig.ExtensionName
rootConfig.Thumbprint = vchConfig.TargetThumbprint
rootConfig.DatastorePath = vchConfig.Storage.ImageStores[0].Host
if vchConfig.Diagnostics.DebugLevel > 2 {
rootConfig.addr = "0.0.0.0:2378"
log.Warn("Listening on all networks because of debug level")
}
s := &server{
addr: rootConfig.addr,
}
err := s.listen()
if err != nil {
log.Fatal(err)
}
log.Infof("listening on %s", s.addr)
signals := []syscall.Signal{
syscall.SIGTERM,
syscall.SIGINT,
}
sigchan := make(chan os.Signal, 1)
for _, signum := range signals {
signal.Notify(sigchan, signum)
}
go func() {
signal := <-sigchan
log.Infof("received %s", signal)
s.stop()
}()
s.serve()
}
func main() {
if version.Show() {
fmt.Fprintf(os.Stdout, "%s\n", version.String())
return
}
flag.Parse()
// If we're in an ESXi environment, then we need
// to extract the userid/password from UserPassword
if vchConfig.UserPassword != "" {
newurl, _ := url.Parse(fmt.Sprintf("%s://%s@%s%s",
vchConfig.Target.Scheme,
vchConfig.UserPassword,
vchConfig.Target.Host,
vchConfig.Target.Path))
vchConfig.Target = *newurl
}
config.Service = vchConfig.Target.String()
config.ExtensionCert = vchConfig.ExtensionCert
config.ExtensionKey = vchConfig.ExtensionKey
config.ExtensionName = vchConfig.ExtensionName
s := &server{
addr: config.addr,
}
err := s.listen(config.tls)
if err != nil {
log.Fatal(err)
}
log.Infof("listening on %s", s.addr)
signals := []syscall.Signal{
syscall.SIGTERM,
syscall.SIGINT,
}
sigchan := make(chan os.Signal, 1)
for _, signum := range signals {
signal.Notify(sigchan, signum)
}
go func() {
signal := <-sigchan
log.Infof("received %s", signal)
s.stop()
}()
s.serve()
}
func main() {
if version.Show() {
fmt.Fprintf(os.Stdout, "%s\n", version.String())
return
}
if !vmcheck.IsVirtualWorld() {
log.Fatalf("ERROR: not in a virtual world.")
}
if !set && !get && !fork {
flag.Usage()
}
config := rpcvmx.NewConfig()
if set {
if flag.NArg() != 2 {
log.Fatalf("ERROR: Please provide guestinfo key / value pair (eg; -set foo bar")
}
if err := config.SetString(flag.Arg(0), flag.Arg(1)); err != nil {
log.Fatalf("ERROR: SetString failed with %s", err)
}
}
if get {
if flag.NArg() != 1 {
log.Fatalf("ERROR: Please provide guestinfo key (eg; -get foo)")
}
if out, err := config.String(flag.Arg(0), ""); err != nil {
log.Fatalf("ERROR: String failed with %s", err)
} else {
fmt.Printf("%s\n", out)
}
}
if fork {
out, ok, err := rpcout.SendOne("vmfork-begin -1 -1")
if err != nil {
log.Fatalf("ERROR: %s | %s | %t", err, out, ok)
} else if !ok {
log.Fatalf("FAILED: %s", out)
} else {
fmt.Printf("%s\n", out)
}
}
}
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Fprintf(os.Stderr, fmt.Sprintf("%s : %s", r, debug.Stack()))
}
}()
if version.Show() {
fmt.Fprintf(os.Stdout, "%s\n", version.String())
return
}
// Initiliaze logger with default TextFormatter
log.SetFormatter(&log.TextFormatter{DisableColors: false, FullTimestamp: true})
// Set the log level
if options.Debug {
log.SetLevel(log.DebugLevel)
}
server := dns.NewServer(options)
if server != nil {
server.Start()
}
// handle the signals and gracefully shutdown the server
sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
go func() {
log.Warnf("signal %s received", <-sig)
server.Stop()
}()
server.Wait()
}
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Fprintf(os.Stderr, string(sf.FormatError(fmt.Errorf("%s : %s", r, debug.Stack()))))
}
}()
if version.Show() {
fmt.Fprintf(os.Stdout, "%s\n", version.String())
return
}
// Enable profiling if mode is set
switch options.profiling {
case "cpu":
defer profile.Start(profile.CPUProfile, profile.ProfilePath("."), profile.Quiet).Stop()
case "mem":
defer profile.Start(profile.MemProfile, profile.ProfilePath("."), profile.Quiet).Stop()
case "block":
defer profile.Start(profile.BlockProfile, profile.ProfilePath("."), profile.Quiet).Stop()
default:
// do nothing
}
// Register our custom Error hook
log.AddHook(NewErrorHook(os.Stderr))
// Enable runtime tracing if tracing is true
if options.tracing {
tracing, err := os.Create(time.Now().Format("2006-01-02T150405.pprof"))
if err != nil {
log.Fatalf("Failed to create tracing logfile: %s", err)
}
defer tracing.Close()
if err := trace.Start(tracing); err != nil {
log.Fatalf("Failed to start tracing: %s", err)
}
defer trace.Stop()
}
// Open the log file
f, err := os.OpenFile(options.logfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
log.Fatalf("Failed to open the logfile %s: %s", options.logfile, err)
}
defer f.Close()
// Initiliaze logger with default TextFormatter
log.SetFormatter(&log.TextFormatter{DisableColors: true, FullTimestamp: true})
// Set the log level
if options.debug {
log.SetLevel(log.DebugLevel)
}
// SetOutput to log file and/or stdout
log.SetOutput(f)
if options.stdout {
log.SetOutput(io.MultiWriter(os.Stdout, f))
}
// Parse the -reference parameter
if err = ParseReference(); err != nil {
log.Fatalf(err.Error())
}
// Host is either the host's UUID (if run on vsphere) or the hostname of
// the system (if run standalone)
host, err := sys.UUID()
if host != "" {
log.Infof("Using UUID (%s) for imagestore name", host)
} else if options.standalone {
host, err = os.Hostname()
log.Infof("Using host (%s) for imagestore name", host)
}
if err != nil {
log.Fatalf("Failed to return the UUID or host name: %s", err)
}
if !options.standalone {
log.Debugf("Running with portlayer")
// Ping the server to ensure it's at least running
ok, err := PingPortLayer()
if err != nil || !ok {
log.Fatalf("Failed to ping portlayer: %s", err)
}
} else {
log.Debugf("Running standalone")
}
// Calculate (and overwrite) the registry URL and make sure that it responds to requests
options.registry, err = LearnRegistryURL(options)
if err != nil {
log.Fatalf("Error while pulling image: %s", err)
}
// Get the URL of the OAuth endpoint
url, err := LearnAuthURL(options)
if err != nil {
log.Fatalf("Failed to obtain OAuth endpoint: %s", err)
}
// Get the OAuth token - if only we have a URL
if url != nil {
token, err := FetchToken(url)
if err != nil {
log.Fatalf("Failed to fetch OAuth token: %s", err)
}
options.token = token
}
// HACK: Required to learn the name of the vmdk from given reference
// Used by docker personality until metadata support lands
if !options.resolv {
progress.Message(po, "", "Pulling from "+options.image)
}
// Get the manifest
manifest, err := FetchImageManifest(options)
if err != nil {
if strings.Contains(err.Error(), "image not found") {
log.Fatalf("Error: image %s not found", options.image)
} else {
log.Fatalf("Error while pulling image manifest: %s", err)
}
}
// Create the ImageWithMeta slice to hold Image structs
images, imageLayer, err := ImagesToDownload(manifest, host)
if err != nil {
log.Fatalf(err.Error())
}
// HACK: Required to learn the name of the vmdk from given reference
// Used by docker personality until metadata support lands
if options.resolv {
if len(images) > 0 {
fmt.Printf("%s", images[0].meta)
os.Exit(0)
}
os.Exit(1)
}
// Fetch the blobs from registry
if err := DownloadImageBlobs(images); err != nil {
log.Fatalf(err.Error())
}
if err := CreateImageConfig(images, manifest); err != nil {
log.Fatalf(err.Error())
}
// Write blobs to the storage layer
if err := WriteImageBlobs(images); err != nil {
log.Fatalf(err.Error())
}
if err := updateImageMetadata(imageLayer, manifest); err != nil {
log.Fatalf(err.Error())
}
progress.Message(po, "", "Digest: "+manifest.Digest)
if len(images) > 0 {
progress.Message(po, "", "Status: Downloaded newer image for "+options.image+":"+options.tag)
} else {
progress.Message(po, "", "Status: Image is up to date for "+options.image+":"+options.tag)
}
}