func main() {
fixListenPid()
files := activation.Files(false)
if len(files) == 0 {
panic("No files")
}
if os.Getenv("LISTEN_PID") == "" || os.Getenv("LISTEN_FDS") == "" {
panic("Should not unset envs")
}
files = activation.Files(true)
if os.Getenv("LISTEN_PID") != "" || os.Getenv("LISTEN_FDS") != "" {
panic("Can not unset envs")
}
// Write out the expected strings to the two pipes
files[0].Write([]byte("Hello world"))
files[1].Write([]byte("Goodbye world"))
return
}
func startContainer(context *cli.Context, spec *specs.LinuxSpec) (int, error) {
id := context.Args().First()
if id == "" {
return -1, errEmptyID
}
container, err := createContainer(context, id, spec)
if err != nil {
return -1, err
}
// ensure that the container is always removed if we were the process
// that created it.
detach := context.Bool("detach")
if !detach {
defer destroy(container)
}
// Support on-demand socket activation by passing file descriptors into the container init process.
listenFDs := []*os.File{}
if os.Getenv("LISTEN_FDS") != "" {
listenFDs = activation.Files(false)
}
status, err := runProcess(container, &spec.Process, listenFDs, context.String("console"), context.String("pid-file"), detach)
if err != nil {
destroy(container)
return -1, err
}
return status, nil
}
func startContainer(context *cli.Context, spec *specs.Spec, create bool) (int, error) {
id := context.Args().First()
if id == "" {
return -1, errEmptyID
}
container, err := createContainer(context, id, spec)
if err != nil {
return -1, err
}
// Support on-demand socket activation by passing file descriptors into the container init process.
listenFDs := []*os.File{}
if os.Getenv("LISTEN_FDS") != "" {
listenFDs = activation.Files(false)
}
r := &runner{
enableSubreaper: !context.Bool("no-subreaper"),
shouldDestroy: true,
container: container,
listenFDs: listenFDs,
console: context.String("console"),
detach: context.Bool("detach"),
pidFile: context.String("pid-file"),
create: create,
}
return r.run(&spec.Process)
}
func main() {
flag.Parse()
if cpuProfile != "" {
f, err := os.Create(cpuProfile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
stopCh := make(chan bool)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
for sig := range c {
log.Printf("Signal %#v", sig)
stopCh <- true
}
}()
if !cliEnabled() {
var err error
var l net.Listener
if !noEpmd {
listen_fds := activation.Files(false)
if listen_fds != nil {
l, err = net.FileListener(listen_fds[0])
} else {
l, err = net.Listen("tcp", net.JoinHostPort("", listenPort))
}
if err != nil || noEpmd {
// Cannot bind, eclus instance already running, connect to it
eclusCli()
} else {
epm := make(chan regReq, 10)
go epmReg(epm)
go func() {
for {
conn, err := l.Accept()
log.Printf("Accept new")
if err != nil {
log.Printf(err.Error())
} else {
go mLoop(conn, epm)
}
}
}()
if nodeEnabled() {
go runNode()
}
<-stopCh
}
}
} else {
eclusCli()
}
}
func main() {
files := activation.Files(true)
if len(files) != 1 {
panic("Unexpected number of socket activation fds")
}
l, err := net.FileListener(files[0])
if err != nil {
panic(err)
}
http.HandleFunc("/", HelloServer)
http.Serve(l, nil)
}
func gocat(socket, server, cert, key string) {
var ln net.Listener
var err error
if activatedFds := activation.Files(); len(activatedFds) == 0 {
ln, err = net.Listen("tcp", server)
if err != nil {
panic(err)
}
} else if len(activatedFds) == 1 {
fmt.Println("socket activation!") //TODO: remove
ln, err = net.FileListener(activatedFds[0])
if err != nil {
panic(err)
}
//TODO: does activatedFDs[0] need to be closed?
} else {
panic("Too many activated sockets! Check .socket file configuration.")
}
if key != "" {
ln = wrapTLS(ln, cert, key)
} else {
fmt.Println("danger: no certificate or key specified - starting without TLS!")
}
for {
conn, err := ln.Accept()
if err != nil {
fmt.Fprintln(os.Stderr, "accept failure:", err)
continue
}
unix, err := net.Dial("unix", socket)
if err != nil {
fmt.Fprintln(os.Stderr, "socket connection error:", err)
conn.Close()
continue
}
go func() {
//TODO: consider ways the connection might close
go io.Copy(unix, conn)
io.Copy(conn, unix)
conn.Close()
}()
}
}
func listenFD() ([]net.Listener, error) {
files := activation.Files(false)
if files == nil || len(files) == 0 {
return nil, errors.New("No sockets found")
}
listeners := make([]net.Listener, len(files))
for i, f := range files {
var err error
listeners[i], err = net.FileListener(f)
if err != nil {
return nil, fmt.Errorf("Error setting up FileListener for fd %d: %s", f.Fd(), err.Error())
}
}
return listeners, nil
}
// startContainer starts the container. Returns the exit status or -1 and an
// error. Signals sent to the current process will be forwarded to container.
func startContainer(spec *specs.Spec, id, pidFile string, detach, useSystemdCgroup bool) (int, error) {
// create the libcontainer config
config, err := specconv.CreateLibcontainerConfig(&specconv.CreateOpts{
CgroupName: id,
UseSystemdCgroup: useSystemdCgroup,
NoPivotRoot: false,
Spec: spec,
})
if err != nil {
return -1, err
}
if _, err := os.Stat(config.Rootfs); err != nil {
if os.IsNotExist(err) {
return -1, fmt.Errorf("rootfs (%q) does not exist", config.Rootfs)
}
return -1, err
}
factory, err := loadFactory(useSystemdCgroup)
if err != nil {
return -1, err
}
container, err := factory.Create(id, config)
if err != nil {
return -1, err
}
// Support on-demand socket activation by passing file descriptors into the container init process.
listenFDs := []*os.File{}
if os.Getenv("LISTEN_FDS") != "" {
listenFDs = activation.Files(false)
}
r := &runner{
enableSubreaper: true,
shouldDestroy: true,
container: container,
console: console,
detach: detach,
pidFile: pidFile,
listenFDs: listenFDs,
}
return r.run(&spec.Process)
}
func setupSocketActivation() (net.Listener, error) {
if !util.IsRunningSystemd() {
return nil, nil
}
listenFds := activation.Files(false)
if len(listenFds) > 1 {
return nil, fmt.Errorf("expected only one socket from systemd, got %d", len(listenFds))
}
var listener net.Listener
if len(listenFds) == 1 {
l, err := net.FileListener(listenFds[0])
if err != nil {
return nil, err
}
listener = l
}
return listener, nil
}
func main() {
flag.Parse()
file, err := os.Open(configFileName)
if err != nil {
log.Fatal(err)
}
decoder := json.NewDecoder(file)
err = decoder.Decode(&serverConfig)
if err != nil {
log.Fatal(err)
}
dm = devicemaster.New(deviceapi.DefaultRegistry)
for _, value := range serverConfig.Devices {
name, id, lamp := deviceFromConfig(value)
if name != "" && id != "" && lamp != nil {
dm.AddDevice(name, id, lamp)
}
}
r := mux.NewRouter()
r.HandleFunc("/devices", DeviceListHandler)
r.HandleFunc("/devices/{id}", DeviceHandler).Methods("GET")
r.HandleFunc("/devices/{id}/effect", EffectGetHandler).Methods("GET")
r.HandleFunc("/devices/{id}/effect", EffectPutHandler).Methods("PUT")
r.HandleFunc("/devices/{id}/active", ActivePutHandler).Methods("PUT")
r.HandleFunc("/devices/{id}/available", EffectListHandler)
files := activation.Files(false)
var l net.Listener
if len(files) != 1 {
l, err = net.Listen("tcp", serverConfig.ListenAddress)
} else {
l, err = net.FileListener(files[0])
}
if err != nil {
log.Fatal("Could not create Listener: ", err)
}
if err = http.Serve(l, r); err != nil {
log.Fatal("Serve: ", err)
}
}
func newUnixListener(pluginName string, group string) (net.Listener, string, error) {
path, err := fullSocketAddress(pluginName)
if err != nil {
return nil, "", err
}
listenFds := activation.Files(false)
if len(listenFds) > 1 {
return nil, "", fmt.Errorf("expected only one socket from systemd, got %d", len(listenFds))
}
if len(listenFds) == 1 {
l, err := net.FileListener(listenFds[0])
if err != nil {
return nil, "", err
}
return l, path, nil
}
listener, err := sockets.NewUnixSocket(path, group)
if err != nil {
return nil, "", err
}
return listener, path, nil
}