func handleFlags() (*CliOptions, bool) { flag.Usage = Usage _ = flag.String("serveraddr", "127.0.0.1", "Server address to listen") // ignored serverPort := flag.Uint("port", 9000, "Port to listen") portLayerAddr := flag.String("port-layer-addr", "127.0.0.1", "Port layer server address") portLayerPort := flag.Uint("port-layer-port", 9001, "Port Layer server port") debug := flag.Bool("debug", false, "Enable debuglevel logging") flag.Parse() // load the vch config src, err := extraconfig.GuestInfoSource() if err != nil { log.Fatalf("Unable to load configuration from guestinfo: %s", err) } extraconfig.Decode(src, &vchConfig) if *debug || vchConfig.Diagnostics.DebugLevel > 0 { log.SetLevel(log.DebugLevel) } cli := &CliOptions{ serverPort: *serverPort, portLayerAddr: fmt.Sprintf("%s:%d", *portLayerAddr, *portLayerPort), proto: "tcp", } return cli, true }
// Create accepts a Config and returns a Session with the cached vSphere resources. func (s *Session) Create(ctx context.Context) (*Session, error) { var vchExtraConfig metadata.VirtualContainerHostConfigSpec source, err := extraconfig.GuestInfoSource() if err != nil { return nil, err } extraconfig.Decode(source, &vchExtraConfig) s.ExtensionKey = vchExtraConfig.ExtensionKey s.ExtensionCert = vchExtraConfig.ExtensionCert s.ExtensionName = vchExtraConfig.ExtensionName _, err = s.Connect(ctx) if err != nil { return nil, err } // we're treating this as an atomic behaviour, so log out if we failed defer func() { if err != nil { s.Client.Logout(ctx) } }() _, err = s.Populate(ctx) if err != nil { return nil, err } return s, nil }
func init() { trace.Logger.Level = log.DebugLevel defer trace.End(trace.Begin("")) flag.StringVar(&config.addr, "l", ":2378", "Listen address") flag.StringVar(&config.dockerHost, "docker-host", "127.0.0.1:2376", "Docker host") flag.StringVar(&config.ExtensionCert, "cert", "", "VMOMI Client certificate file") flag.StringVar(&config.hostCertFile, "hostcert", "", "Host certificate file") flag.StringVar(&config.ExtensionKey, "key", "", "VMOMI Client private key file") flag.StringVar(&config.hostKeyFile, "hostkey", "", "Host private key file") flag.StringVar(&config.Service, "sdk", "", "The ESXi or vCenter URL") flag.StringVar(&config.DatacenterPath, "dc", "", "Name of the Datacenter") flag.StringVar(&config.DatastorePath, "ds", "", "Name of the Datastore") flag.StringVar(&config.ClusterPath, "cluster", "", "Path of the cluster") flag.StringVar(&config.PoolPath, "pool", "", "Path of the resource pool") flag.BoolVar(&config.Insecure, "insecure", false, "Allow connection when sdk certificate cannot be verified") flag.BoolVar(&config.tls, "tls", true, "Set to false to disable -hostcert and -hostkey and enable plain HTTP") // This is only applicable for containers hosted under the VCH VM folder // This will not function for vSAN flag.StringVar(&config.vmPath, "vm-path", "", "Docker vm path") // load the vch config src, err := extraconfig.GuestInfoSource() if err != nil { log.Errorf("Unable to load configuration from guestinfo") } extraconfig.Decode(src, &vchConfig) }
func init() { defer trace.End(trace.Begin("")) trace.Logger.Level = log.DebugLevel _ = pprof.StartPprof("vicadmin", pprof.VicadminPort) // We don't want to run this as root. ud := syscall.Getuid() gd := syscall.Getgid() log.Info(fmt.Sprintf("Current UID/GID = %d/%d", ud, gd)) // TODO: Enable this after we figure out to NOT break the test suite with it. // if ud == 0 { // log.Errorf("Error: vicadmin must not run as root.") // time.Sleep(60 * time.Second) // os.Exit(1) // } flag.StringVar(&rootConfig.addr, "l", "client.localhost:2378", "Listen address") // TODO: This should all be pulled from the config flag.StringVar(&rootConfig.DatacenterPath, "dc", "", "Path of the datacenter") flag.StringVar(&rootConfig.ClusterPath, "cluster", "", "Path of the cluster") flag.StringVar(&rootConfig.PoolPath, "pool", "", "Path of the resource pool") // load the vch config src, err := extraconfig.GuestInfoSource() if err != nil { log.Errorf("Unable to load configuration from guestinfo") return } extraconfig.Decode(src, &vchConfig) // FIXME: pull the rest from flags flag.Parse() }
func handleFlags() (*CliOptions, bool) { flag.Usage = Usage enableTLS := flag.Bool("TLS", false, "Use TLS; implied by --tlsverify") verifyTLS := flag.Bool("tlsverify", false, "Use TLS and verify the remote") cafile := flag.String("tls-ca-certificate", "", "Trust certs signed only by this CA") certfile := flag.String("tls-certificate", "", "Path to TLS certificate file") keyfile := flag.String("tls-key", "", "Path to TLS Key file") serverAddr := flag.String("serveraddr", "127.0.0.1", "Server address to listen") serverPort := flag.Uint("port", 9000, "Port to listen") portLayerAddr := flag.String("port-layer-addr", "127.0.0.1", "Port layer server address") portLayerPort := flag.Uint("port-layer-port", 9001, "Port Layer server port") debug := flag.Bool("debug", false, "Enable debuglevel logging") flag.Parse() if *enableTLS && (len(*certfile) == 0 || len(*keyfile) == 0) { fmt.Fprintf(os.Stderr, "TLS requested, but tls-certificate and tls-key were all not specified\n") return nil, false } if *verifyTLS { *enableTLS = true if len(*certfile) == 0 || len(*keyfile) == 0 || len(*cafile) == 0 { fmt.Fprintf(os.Stderr, "tlsverfiy requested, but tls-ca-certificate, tls-certificate, tls-key were all not specified\n") return nil, false } } cli := &CliOptions{ enableTLS: *enableTLS, verifyTLS: *verifyTLS, cafile: *cafile, certfile: *certfile, keyfile: *keyfile, serverAddr: *serverAddr, serverPort: *serverPort, fullserver: fmt.Sprintf("%s:%d", *serverAddr, *serverPort), portLayerAddr: fmt.Sprintf("%s:%d", *portLayerAddr, *portLayerPort), proto: "tcp", } // load the vch config src, err := extraconfig.GuestInfoSource() if err != nil { log.Errorf("Unable to load configuration from guestinfo") } extraconfig.Decode(src, &vchConfig) if *debug || vchConfig.Diagnostics.DebugLevel > 0 { log.SetLevel(log.DebugLevel) } return cli, true }
func main() { defer func() { if r := recover(); r != nil { log.Errorf("run time panic: %s : %s", r, debug.Stack()) } halt() }() // where to look for the various devices and files related to tether pathPrefix = "/.tether" if strings.HasSuffix(os.Args[0], "-debug") { extraconfig.DecodeLogLevel = log.DebugLevel extraconfig.EncodeLogLevel = log.DebugLevel } // use the same logger for trace and other logging trace.Logger = log.StandardLogger() log.SetLevel(log.DebugLevel) // Initiliaze logger with default TextFormatter log.SetFormatter(&log.TextFormatter{DisableColors: true, FullTimestamp: true}) // TODO: hard code executor initialization status reporting via guestinfo here err := createDevices() if err != nil { log.Error(err) // return gives us good behaviour in the case of "-debug" binary return } sshserver := NewAttachServerSSH() src, err := extraconfig.GuestInfoSource() if err != nil { log.Error(err) return } sink, err := extraconfig.GuestInfoSink() if err != nil { log.Error(err) return } // create the tether tthr = tether.New(src, sink, &operations{}) // register the attach extension tthr.Register("Attach", sshserver) err = tthr.Start() if err != nil { log.Error(err) return } log.Info("Clean exit from tether") }
func init() { // load the vch config // TODO: Optimize this to just pull the fields we need... src, err := extraconfig.GuestInfoSource() if err != nil { log.Errorf("Unable to load configuration from guestinfo") return } extraconfig.Decode(src, &vchConfig) }
func main() { defer func() { if r := recover(); r != nil { log.Errorf("run time panic: %s : %s", r, debug.Stack()) } halt() }() // where to look for the various devices and files related to tether pathPrefix = "com://" if strings.HasSuffix(os.Args[0], "-debug") { extraconfig.DecodeLogLevel = log.DebugLevel extraconfig.EncodeLogLevel = log.DebugLevel } // use the same logger for trace and other logging trace.Logger = log.StandardLogger() log.SetLevel(log.DebugLevel) // Initiliaze logger with default TextFormatter log.SetFormatter(&log.TextFormatter{DisableColors: true, FullTimestamp: true}) // get the windows service logic running so that we can play well in that mode runService("VMware Tether", false) sshserver := &attachServerSSH{} server = sshserver src, err := extraconfig.GuestInfoSource() if err != nil { log.Error(err) return } sink, err := extraconfig.GuestInfoSink() if err != nil { log.Error(err) return } // create the tether and register the attach extension tthr = tether.New(src, sink, &operations{}) tthr.Register("Attach", sshserver) err = tthr.Start() if err != nil { log.Error(err) return } log.Info("Clean exit from tether") }
func main() { defer func() { if r := recover(); r != nil { log.Errorf("run time panic: %s : %s", r, debug.Stack()) } halt() }() // where to look for the various devices and files related to tether pathPrefix = "/.tether" if strings.HasSuffix(os.Args[0], "-debug") { extraconfig.DecodeLogLevel = log.DebugLevel extraconfig.EncodeLogLevel = log.DebugLevel log.SetLevel(log.DebugLevel) } // TODO: hard code executor initialization status reporting via guestinfo here err := createDevices() if err != nil { log.Error(err) // return gives us good behaviour in the case of "-debug" binary return } sshserver := &attachServerSSH{} server = sshserver src, err := extraconfig.GuestInfoSource() if err != nil { log.Error(err) return } sink, err := extraconfig.GuestInfoSink() if err != nil { log.Error(err) return } // create the tether and register the attach extension tthr := tether.New(src, sink, &operations{}) tthr.Register("Attach", sshserver) err = tthr.Start() if err != nil { log.Error(err) return } log.Info("Clean exit from tether") }
func Init(ctx context.Context, sess *session.Session) error { source, err := extraconfig.GuestInfoSource() if err != nil { return err } sink, err := extraconfig.GuestInfoSink() if err != nil { return err } // Grab the storage layer config blobs from extra config extraconfig.Decode(source, &storage.Config) log.Debugf("Decoded VCH config for storage: %#v", storage.Config) // create or restore a portlayer k/v store in the VCH's directory. vch, err := guest.GetSelf(ctx, sess) if err != nil { return err } vchvm := vm.NewVirtualMachineFromVM(ctx, sess, vch) vmPath, err := vchvm.VMPathName(ctx) if err != nil { return err } // vmPath is set to the vmx. Grab the directory from that. vmFolder, err := datastore.ToURL(path.Dir(vmPath)) if err != nil { return err } if err = store.Init(ctx, sess, vmFolder); err != nil { return err } if err := exec.Init(ctx, sess, source, sink); err != nil { return err } if err = network.Init(ctx, sess, source, sink); err != nil { return err } return nil }
func init() { defer trace.End(trace.Begin("")) trace.Logger.Level = log.DebugLevel _ = pprof.StartPprof("vicadmin", pprof.VicadminPort) // We don't want to run this as root. ud := syscall.Getuid() gd := syscall.Getgid() log.Info(fmt.Sprintf("Current UID/GID = %d/%d", ud, gd)) // TODO: Enable this after we figure out to NOT break the test suite with it. // if ud == 0 { // log.Errorf("Error: vicadmin must not run as root.") // time.Sleep(60 * time.Second) // os.Exit(1) // } flag.StringVar(&config.addr, "l", ":2378", "Listen address") flag.StringVar(&config.dockerHost, "docker-host", "127.0.0.1:2376", "Docker host") flag.StringVar(&config.hostCertFile, "hostcert", "", "Host certificate file") flag.StringVar(&config.hostKeyFile, "hostkey", "", "Host private key file") flag.StringVar(&config.DatacenterPath, "dc", "", "Name of the Datacenter") flag.StringVar(&config.DatastorePath, "ds", "", "Name of the Datastore") flag.StringVar(&config.ClusterPath, "cluster", "", "Path of the cluster") flag.StringVar(&config.PoolPath, "pool", "", "Path of the resource pool") flag.BoolVar(&config.Insecure, "insecure", false, "Allow connection when sdk certificate cannot be verified") flag.BoolVar(&config.tls, "tls", true, "Set to false to disable -hostcert and -hostkey and enable plain HTTP") // This is only applicable for containers hosted under the VCH VM folder // This will not function for vSAN flag.StringVar(&config.vmPath, "vm-path", "", "Docker vm path") flag.Parse() // load the vch config src, err := extraconfig.GuestInfoSource() if err != nil { log.Errorf("Unable to load configuration from guestinfo") return } extraconfig.Decode(src, &vchConfig) }
func main() { defer func() { if r := recover(); r != nil { log.Errorf("run time panic: %s : %s", r, debug.Stack()) } halt() }() logFile, err := os.OpenFile("/dev/ttyS1", os.O_WRONLY|os.O_SYNC, 0644) if err != nil { log.Errorf("Could not open serial port for debugging info. Some debug info may be lost! Error reported was %s", err) } if err = syscall.Dup3(int(logFile.Fd()), int(os.Stderr.Fd()), 0); err != nil { log.Errorf("Could not pipe logfile to standard error due to error %s", err) } if _, err = os.Stderr.WriteString("all stderr redirected to debug log"); err != nil { log.Errorf("Could not write to Stderr due to error %s", err) } // where to look for the various devices and files related to tether pathPrefix = "/.tether" if strings.HasSuffix(os.Args[0], "-debug") { extraconfig.DecodeLogLevel = log.DebugLevel extraconfig.EncodeLogLevel = log.DebugLevel } // use the same logger for trace and other logging trace.Logger = log.StandardLogger() log.SetLevel(log.DebugLevel) // Initiliaze logger with default TextFormatter log.SetFormatter(&log.TextFormatter{DisableColors: true, FullTimestamp: true}) // TODO: hard code executor initialization status reporting via guestinfo here err = createDevices() if err != nil { log.Error(err) // return gives us good behaviour in the case of "-debug" binary return } sshserver := NewAttachServerSSH() src, err := extraconfig.GuestInfoSource() if err != nil { log.Error(err) return } sink, err := extraconfig.GuestInfoSink() if err != nil { log.Error(err) return } // create the tether tthr = tether.New(src, sink, &operations{}) // register the attach extension tthr.Register("Attach", sshserver) // register the toolbox extension tthr.Register("Toolbox", tether.NewToolbox().InContainer()) err = tthr.Start() if err != nil { log.Error(err) return } log.Info("Clean exit from tether") }
func Init(ctx context.Context, sess *session.Session) error { source, err := extraconfig.GuestInfoSource() if err != nil { return err } f := find.NewFinder(sess.Vim25(), false) extraconfig.Decode(source, &exec.VCHConfig) log.Debugf("Decoded VCH config for execution: %#v", exec.VCHConfig) ccount := len(exec.VCHConfig.ComputeResources) if ccount != 1 { detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount) log.Errorf(detail) return err } cr := exec.VCHConfig.ComputeResources[0] r, err := f.ObjectReference(ctx, cr) if err != nil { detail := fmt.Sprintf("could not get resource pool or virtual app reference from %q: %s", cr.String(), err) log.Errorf(detail) return err } switch o := r.(type) { case *object.VirtualApp: exec.VCHConfig.VirtualApp = o exec.VCHConfig.ResourcePool = o.ResourcePool case *object.ResourcePool: exec.VCHConfig.ResourcePool = o default: detail := fmt.Sprintf("could not get resource pool or virtual app from reference %q: object type is wrong", cr.String()) log.Errorf(detail) return errors.New(detail) } // we have a resource pool, so lets create the event manager for monitoring exec.VCHConfig.EventManager = vsphere.NewEventManager(sess) // configure event manager to monitor the resource pool exec.VCHConfig.EventManager.AddMonitoredObject(exec.VCHConfig.ResourcePool.Reference().String()) // instantiate the container cache now exec.NewContainerCache() // need to blacklist the VCH from eventlistening - too many reconfigures vch, err := guest.GetSelf(ctx, sess) if err != nil { return fmt.Errorf("Unable to get a reference to the VCH: %s", err.Error()) } exec.VCHConfig.EventManager.Blacklist(vch.Reference().String()) // other managed objects could be added for the event stream, but for now the resource pool will do exec.VCHConfig.EventManager.Start() //FIXME: temporary injection of debug network for debug nic ne := exec.VCHConfig.Networks["client"] if ne == nil { detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present") log.Errorf(detail) return err } nr := new(types.ManagedObjectReference) nr.FromString(ne.Network.ID) r, err = f.ObjectReference(ctx, *nr) if err != nil { detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err) log.Errorf(detail) return err } exec.VCHConfig.DebugNetwork = r.(object.NetworkReference) extraconfig.Decode(source, &network.Config) log.Debugf("Decoded VCH config for network: %#v", network.Config) for nn, n := range network.Config.ContainerNetworks { pgref := new(types.ManagedObjectReference) if !pgref.FromString(n.ID) { log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID) } r, err = f.ObjectReference(ctx, *pgref) if err != nil { log.Warnf("could not get network reference for %s network", nn) continue } n.PortGroup = r.(object.NetworkReference) } // Grab the storage layer config blobs from extra config extraconfig.Decode(source, &storage.Config) log.Debugf("Decoded VCH config for storage: %#v", storage.Config) // Grab the AboutInfo about our host environment about := sess.Vim25().ServiceContent.About exec.VCHConfig.VCHMhz = exec.NCPU(ctx) exec.VCHConfig.VCHMemoryLimit = exec.MemTotal(ctx) exec.VCHConfig.HostOS = about.OsType exec.VCHConfig.HostOSVersion = about.Version exec.VCHConfig.HostProductName = about.Name log.Debugf("Host - OS (%s), version (%s), name (%s)", about.OsType, about.Version, about.Name) log.Debugf("VCH limits - %d Mhz, %d MB", exec.VCHConfig.VCHMhz, exec.VCHConfig.VCHMemoryLimit) return nil }
func Init(ctx context.Context, sess *session.Session) error { source, err := extraconfig.GuestInfoSource() if err != nil { return err } f := find.NewFinder(sess.Vim25(), false) extraconfig.Decode(source, &exec.Config) log.Debugf("Decoded VCH config for execution: %#v", exec.Config) ccount := len(exec.Config.ComputeResources) if ccount != 1 { detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount) log.Errorf(detail) return err } cr := exec.Config.ComputeResources[0] r, err := f.ObjectReference(ctx, cr) if err != nil { detail := fmt.Sprintf("could not get resource pool reference from %s: %s", cr.String(), err) log.Errorf(detail) return err } exec.Config.ResourcePool = r.(*object.ResourcePool) //FIXME: temporary injection of debug network for debug nic ne := exec.Config.Networks["client"] if ne == nil { detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present") log.Errorf(detail) return err } nr := new(types.ManagedObjectReference) nr.FromString(ne.Network.ID) r, err = f.ObjectReference(ctx, *nr) if err != nil { detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err) log.Errorf(detail) return err } exec.Config.DebugNetwork = r.(object.NetworkReference) extraconfig.Decode(source, &network.Config) log.Debugf("Decoded VCH config for network: %#v", network.Config) for nn, n := range network.Config.ContainerNetworks { pgref := new(types.ManagedObjectReference) if !pgref.FromString(n.ID) { log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID) } r, err = f.ObjectReference(ctx, *pgref) if err != nil { log.Warnf("could not get network reference for %s network", nn) continue } n.PortGroup = r.(object.NetworkReference) } return nil }