Пример #1
0
// taskDefinitionInput returns an ecs.RegisterTaskDefinitionInput suitable for
// creating a task definition from a Process.
func taskDefinitionInput(p *scheduler.Process, logConfiguration *ecs.LogConfiguration) (*ecs.RegisterTaskDefinitionInput, error) {
	args, err := shellwords.Parse(p.Command)
	if err != nil {
		return nil, err
	}

	// ecs.ContainerDefinition{Command} is expecting a []*string
	var command []*string
	for _, s := range args {
		ss := s
		command = append(command, &ss)
	}

	var environment []*ecs.KeyValuePair
	for k, v := range p.Env {
		environment = append(environment, &ecs.KeyValuePair{
			Name:  aws.String(k),
			Value: aws.String(v),
		})
	}

	var ports []*ecs.PortMapping
	for _, m := range p.Ports {
		ports = append(ports, &ecs.PortMapping{
			HostPort:      m.Host,
			ContainerPort: m.Container,
		})
	}

	labels := make(map[string]*string)
	for k, v := range p.Labels {
		labels[k] = aws.String(v)
	}

	return &ecs.RegisterTaskDefinitionInput{
		Family: aws.String(p.Type),
		ContainerDefinitions: []*ecs.ContainerDefinition{
			&ecs.ContainerDefinition{
				Name:             aws.String(p.Type),
				Cpu:              aws.Int64(int64(p.CPUShares)),
				Command:          command,
				Image:            aws.String(p.Image.String()),
				Essential:        aws.Bool(true),
				Memory:           aws.Int64(int64(p.MemoryLimit / MB)),
				Environment:      environment,
				LogConfiguration: logConfiguration,
				PortMappings:     ports,
				DockerLabels:     labels,
			},
		},
	}, nil
}
Пример #2
0
func TestLogger(t *testing.T) {
	if runtime.GOOS == "windows" {
		logfilePath = filepath.Join(os.Getenv("TEMP"), logfileName)
	} else {
		logfilePath = filepath.Join("/tmp", logfileName)
	}

	logger = NewLogger(logfilePath)
	defer cleanup()
	SetBackend2FrontendMap(&testBackend2FrontendMap)

	r := &http.Request{
		Header: map[string][]string{
			"User-Agent": {testUserAgent},
			"Referer":    {testReferer},
		},
		Proto:      testProto,
		Host:       testHostname,
		Method:     testMethod,
		RemoteAddr: fmt.Sprintf("%s:%d", testHostname, testPort),
		URL: &url.URL{
			User: url.UserPassword(testUsername, ""),
			Path: testPath,
		},
	}

	logger.ServeHTTP(&logtestResponseWriter{}, r, LogWriterTestHandlerFunc)

	if logdata, err := ioutil.ReadFile(logfilePath); err != nil {
		fmt.Printf("%s\n%s\n", string(logdata), err.Error())
		assert.Nil(t, err)
	} else if tokens, err := shellwords.Parse(string(logdata)); err != nil {
		fmt.Printf("%s\n", err.Error())
		assert.Nil(t, err)
	} else if assert.Equal(t, 14, len(tokens), printLogdata(logdata)) {
		assert.Equal(t, testHostname, tokens[0], printLogdata(logdata))
		assert.Equal(t, testUsername, tokens[2], printLogdata(logdata))
		assert.Equal(t, fmt.Sprintf("%s %s %s", testMethod, testPath, testProto), tokens[5], printLogdata(logdata))
		assert.Equal(t, fmt.Sprintf("%d", testStatus), tokens[6], printLogdata(logdata))
		assert.Equal(t, fmt.Sprintf("%d", len(helloWorld)), tokens[7], printLogdata(logdata))
		assert.Equal(t, testReferer, tokens[8], printLogdata(logdata))
		assert.Equal(t, testUserAgent, tokens[9], printLogdata(logdata))
		assert.Equal(t, "1", tokens[10], printLogdata(logdata))
		assert.Equal(t, testFrontendName, tokens[11], printLogdata(logdata))
		assert.Equal(t, testBackendName, tokens[12], printLogdata(logdata))
	}
}
Пример #3
0
// taskDefinitionInput returns an ecs.RegisterTaskDefinitionInput suitable for
// creating a task definition from a Process.
func taskDefinitionInput(p *Process) (*ecs.RegisterTaskDefinitionInput, error) {
	args, err := shellwords.Parse(p.Command)
	if err != nil {
		return nil, err
	}

	// ecs.ContainerDefinition{Command} is expecting a []*string
	var command []*string
	for _, s := range args {
		ss := s
		command = append(command, &ss)
	}

	var environment []*ecs.KeyValuePair
	for k, v := range p.Env {
		environment = append(environment, &ecs.KeyValuePair{
			Name:  aws.String(k),
			Value: aws.String(v),
		})
	}

	var ports []*ecs.PortMapping
	for _, m := range p.Ports {
		ports = append(ports, &ecs.PortMapping{
			HostPort:      m.Host,
			ContainerPort: m.Container,
		})
	}

	return &ecs.RegisterTaskDefinitionInput{
		Family: aws.String(p.Type),
		ContainerDefinitions: []*ecs.ContainerDefinition{
			&ecs.ContainerDefinition{
				Name:         aws.String(p.Type),
				CPU:          aws.Long(int64(p.CPUShares)),
				Command:      command,
				Image:        aws.String(p.Image.String()),
				Essential:    aws.Boolean(true),
				Memory:       aws.Long(int64(p.MemoryLimit / MB)),
				Environment:  environment,
				PortMappings: ports,
			},
		},
	}, nil
}
Пример #4
0
func (r *Runner) create(ctx context.Context, opts RunOpts) (*docker.Container, error) {
	cmd, err := shellwords.Parse(opts.Command)
	if err != nil {
		return nil, err
	}

	return r.client.CreateContainer(ctx, docker.CreateContainerOptions{
		Name: uuid.New(),
		Config: &docker.Config{
			Tty:          true,
			AttachStdin:  true,
			AttachStdout: true,
			AttachStderr: true,
			OpenStdin:    true,
			Image:        opts.Image.String(),
			Cmd:          cmd,
			Env:          envKeys(opts.Env),
		},
		HostConfig: &docker.HostConfig{},
	})
}
Пример #5
0
// Launches a child process to hold open a ZMQ connection
// to the upstream bolo server (send_bolo should take care
// of the configuration for how to connect). Upon termination
// this process will be respawned.
//
// Currently, if the send_bolo configuration directive for bmad
// is updated on a config reload, the send_bolo process will not
// be respawned. A full-daemon restart is required to make use
// of the new send_bolo configuration
func ConnectToBolo() error {
	args, err := shellwords.Parse(cfg.Send_bolo)
	if err != nil {
		return err
	}
	log.Debug("Spawning bolo submitter:  %#v", args)
	send2bolo = exec.Command(args[0], args[1:]...)
	r, w, err := os.Pipe()
	if err != nil {
		return err
	}
	send2bolo.Stdin = r
	writer = w
	err = send2bolo.Start()
	if err != nil {
		writer = nil
		send2bolo = nil
		return err
	}
	log.Debug("send_bolo: %#v", send2bolo)
	go func() { send2bolo.Wait(); send2bolo = nil }()
	return nil
}
Пример #6
0
func (s *AccessLogSuite) TestAccessLog(c *check.C) {
	// Ensure working directory is clean
	os.Remove("access.log")
	os.Remove("traefik.log")

	// Start Traefik
	cmd := exec.Command(traefikBinary, "--configFile=fixtures/access_log_config.toml")
	err := cmd.Start()
	c.Assert(err, checker.IsNil)
	defer cmd.Process.Kill()
	defer os.Remove("access.log")
	defer os.Remove("traefik.log")

	time.Sleep(500 * time.Millisecond)

	// Verify Traefik started OK
	traefikLog, err := ioutil.ReadFile("traefik.log")
	c.Assert(err, checker.IsNil)
	if len(traefikLog) > 0 {
		fmt.Printf("%s\n", string(traefikLog))
		c.Assert(len(traefikLog), checker.Equals, 0)
	}

	// Start test servers
	ts1 := startAccessLogServer(8081)
	defer ts1.Close()
	ts2 := startAccessLogServer(8082)
	defer ts2.Close()
	ts3 := startAccessLogServer(8083)
	defer ts3.Close()

	// Make some requests
	_, err = http.Get("http://127.0.0.1:8000/test1")
	c.Assert(err, checker.IsNil)
	_, err = http.Get("http://127.0.0.1:8000/test2")
	c.Assert(err, checker.IsNil)
	_, err = http.Get("http://127.0.0.1:8000/test2")
	c.Assert(err, checker.IsNil)

	// Verify access.log output as expected
	accessLog, err := ioutil.ReadFile("access.log")
	c.Assert(err, checker.IsNil)
	lines := strings.Split(string(accessLog), "\n")
	count := 0
	for i, line := range lines {
		if len(line) > 0 {
			count++
			tokens, err := shellwords.Parse(line)
			c.Assert(err, checker.IsNil)
			c.Assert(len(tokens), checker.Equals, 13)
			c.Assert(tokens[6], checker.Equals, "200")
			c.Assert(tokens[9], checker.Equals, fmt.Sprintf("%d", i+1))
			c.Assert(strings.HasPrefix(tokens[10], "frontend"), checker.True)
			c.Assert(strings.HasPrefix(tokens[11], "http://127.0.0.1:808"), checker.True)
			c.Assert(regexp.MustCompile("^\\d+\\.\\d+.*s$").MatchString(tokens[12]), checker.True)
		}
	}
	c.Assert(count, checker.Equals, 3)

	// Verify no other Traefik problems
	traefikLog, err = ioutil.ReadFile("traefik.log")
	c.Assert(err, checker.IsNil)
	if len(traefikLog) > 0 {
		fmt.Printf("%s\n", string(traefikLog))
		c.Assert(len(traefikLog), checker.Equals, 0)
	}
}
Пример #7
0
func upstream() {
	buff := make([]byte, 16384)
	for {
		line, err := rl.Readline()
		if err == readline.ErrInterrupt {
			line = "exit"
		}
		if err == io.EOF {
			continue
		}
		line = strings.TrimSpace(line)
		switch {
		case strings.HasPrefix(line, "login "):
			// arg1 => username
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(stderr, "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) == 0 {
				fmt.Fprintf(stderr, "Usage: login username\n")
				continue
			}
			if len(args) == 1 {
				proto.WriteString(buff, args[0])
				pkt := proto.NewPacket(4, buff[:len(args[0])+2])
				pkt.Sign(privkey)
				_, err = user.Conn.Write(pkt.Bytes())
				if err != nil {
					fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
					panic("Socket error!")
				}
			}
		case strings.HasPrefix(line, "exit"):
			// arg1 => reason
			reason := "Disconnected"
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(stderr, "Invalid line:", err.Error())
				continue
			}
			if len(args) >= 2 {
				reason = args[1]
			}
			proto.WriteString(buff, reason)
			pkt := proto.NewPacket(5, buff[:len(reason)+2])
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
			}
			time.Sleep(500 * time.Millisecond)
			os.Exit(0)
		case line == "games":
			pkt := proto.NewPacket(6, []byte{})
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
			}
		case line == "players":
			pkt := proto.NewPacket(7, []byte{})
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
			}
		case strings.HasPrefix(line, "join "):
			// arg1 => roomid

			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(stderr, "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) == 0 {
				fmt.Fprintf(stderr, "Usage: join roomid\n")
				continue
			}
			if len(args) == 1 {
				r, err := strconv.Atoi(args[0])
				if err != nil {
					fmt.Fprintf(stderr, "Invalid roomid %s\n", args[0])
				}
				roomid := uint16(r)
				binary.BigEndian.PutUint16(buff, roomid)
				pkt := proto.NewPacket(8, buff[:2])
				pkt.Sign(privkey)
				_, err = user.Conn.Write(pkt.Bytes())
				if err != nil {
					fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
					panic("Socket error!")
				}
			}
		case line == "leave":
			pkt := proto.NewPacket(9, []byte{})
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
				return
			}
		case line == "restart":
			pkt := proto.NewPacket(10, []byte{})
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
			}
		case strings.HasPrefix(line, "place "):
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(stderr, "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) < 2 {
				fmt.Fprintf(stderr, "Usage: place x y\n")
				continue
			}
			// arg1 => x, arg2 => y
			x, err := strconv.Atoi(args[0])
			if err != nil {
				fmt.Fprintf(stderr, "Invalid number %s\n", args[0])
			}
			y, err := strconv.Atoi(args[1])
			if err != nil {
				fmt.Fprintf(stderr, "Invalid number %s\n", args[1])
			}
			buff[0] = byte((x << 4) | y)
			pkt := proto.NewPacket(11, buff[:1])
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
			}
		case strings.HasPrefix(line, "msg "):
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(stderr, "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) < 2 {
				fmt.Fprintf(stderr, "Usage: msg player message\n")
				continue
			}
			b := buff
			b, _ = proto.WriteString(b, args[0])
			b, _ = proto.WriteString(b, args[1])
			pkt := proto.NewPacket(13, buff[:len(args[0])+len(args[1])+4])
			pkt.Sign(privkey)
			_, err = user.Conn.Write(pkt.Bytes())
			if err != nil {
				fmt.Fprintf(stderr, "Write packet error: %s\n", err.Error())
				panic("Socket error!")
			}
		default:
			fmt.Fprintln(stderr, "Commands: ")
			fmt.Fprint(stderr, completer.Tree("    "))
		}
	}
}
Пример #8
0
func loadShellCommand(value interface{}) (interface{}, error) {
	if str, ok := value.(string); ok {
		return shellwords.Parse(str)
	}
	return value, nil
}
Пример #9
0
// ParseCommand parses a string into a Command, taking quotes and other shell
// words into account. For example:
func ParseCommand(command string) (Command, error) {
	return shellwords.Parse(command)
}
Пример #10
0
// Takes a new check, and initializes it based on global config defaults, and
// hard-coded safeguards, to ensure checks don't run *too* frequently, or get
// configured in a messed up way (like setting Timeout above Every, or to 0)
func initialize_check(name string, check *Check, defaults *Config) error {
	if check.Name == "" {
		check.Name = name
	}
	if check.Name == "" {
		return errors.New("No check name specified")
	}
	if check.Command == "" {
		return errors.New("Unspecified command")
	} else {
		var err error
		check.cmd_args, err = shellwords.Parse(check.Command)
		if err != nil {
			return errors.New(fmt.Sprintf("Unable to parse command `%s`: %s",
				check.Command, err.Error()))
		}
	}
	if check.Every <= 0 {
		check.Every = defaults.Every
	} else if check.Every <= MIN_INTERVAL {
		check.Every = MIN_INTERVAL
	}
	if check.Every <= 0 {
		check.Every = MIN_INTERVAL * 30
	}
	if check.Retry_every <= 0 {
		check.Retry_every = defaults.Retry_every
	}
	if check.Retry_every > check.Every {
		check.Retry_every = check.Every
	}
	if check.Retry_every <= 0 {
		check.Retry_every = check.Every
	}
	if check.Retries <= 0 {
		check.Retries = defaults.Retries
	}
	if check.Retries <= 0 {
		check.Retries = 1
	}
	if check.Timeout <= 0 {
		check.Timeout = defaults.Timeout
	}
	if check.Timeout >= check.Retry_every || check.Timeout <= 0 {
		check.Timeout = check.Retry_every - 1
	}

	if check.Bulk == "" {
		check.Bulk = defaults.Bulk
	}
	if check.Report == "" {
		check.Report = defaults.Report
	}

	for key, val := range defaults.Env {
		if _, ok := check.Env[key]; !ok {
			check.Env[key] = val
		}
	}
	if check.Env == nil {
		check.Env = map[string]string{}
	}

	check.next_run = first_run(check.Every)

	return nil
}
Пример #11
0
func main() {
	sw.ParseEnv = false
	users = make(map[string]*common.User)
	games = make(map[uint16]*common.Game)
	var err error
	pubkey, privkey, err = ed25519.GenerateKey(rand.Reader)
	if err != nil {
		panic(err)
	}
	socket, err := utp.NewSocket("udp", ":5428")
	if err != nil {
		panic(err)
	}
	rl, err = readline.NewEx(&readline.Config{
		Prompt: "> ",
		// HistoryFile: "./readline.history",
		InterruptPrompt: "Ctrl-C received, exiting ...",
		EOFPrompt:       "\n",
		AutoComplete:    completer,
	})
	if err != nil {
		panic(err)
	}
	go server(socket)
	// Console part
	for {
		line, err := rl.Readline()
		if err == readline.ErrInterrupt {
			line = "exit"
		}
		if err == io.EOF {
			continue
		}
		line = strings.TrimSpace(line)
		switch {
		case line == "exit":
			fmt.Fprintf(rl.Stderr(), "Exiting... Kick all client\n")
			for _, user := range users {
				user.Kick("Server closed")
			}
			return
		case strings.HasPrefix(line, "msg "):
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(rl.Stderr(), "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) == 0 {
				fmt.Fprintf(rl.Stderr(), "Usage: msg [user] message\n")
				continue
			}
			if len(args) == 1 { // Broadcast
				for _, user := range users {
					go user.SendMessage("", args[0])
				}
				continue
			}
			if len(args) == 2 { // Send to specific user
				user, ok := users[args[0]]
				if ok {
					user.SendMessage("", args[1])
				} else {
					fmt.Fprintf(rl.Stderr(), "No such user: %s\n", args[0])
				}
			}
		case line == "users":
			fmt.Fprintf(rl.Stderr(), "Online users: \n")
			for name, user := range users {
				fmt.Fprintf(rl.Stderr(), "    %s [%s]: ", name, user.Conn.RemoteAddr().String())
				if user.Game == nil {
					fmt.Fprintf(rl.Stderr(), "Idle\n")
				} else {
					fmt.Fprintf(rl.Stderr(), "In Room %d\n", user.Game.ID)
				}
			}
		case strings.HasPrefix(line, "kick "):
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(rl.Stderr(), "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) == 0 {
				fmt.Fprintf(rl.Stderr(), "Usage: kick user [reason]\n")
				continue
			}
			reason := "Kicked with no reason."
			if len(args) > 1 {
				reason = fmt.Sprint("Kicked by server: ", args[1])
			}
			user, ok := users[args[0]]
			if ok {
				user.Kick(reason)
			} else {
				fmt.Fprintf(rl.Stderr(), "No such user: %s\n", args[0])
			}
		case line == "newgame":
			game := common.NewGame()
			game.ID = rid
			rid++
			games[game.ID] = game
			fmt.Fprintf(rl.Stderr(), "New room #%d opened.\n", game.ID)
		case line == "games":
			fmt.Fprintf(rl.Stderr(), "Current open game: \n")
			for _, game := range games {
				fmt.Fprintf(rl.Stderr(), "    Room #%d: ", game.ID)
				if game.Black != nil {
					fmt.Fprintf(rl.Stderr(), "Black: %s ", game.Black.Name)
				} else {
					fmt.Fprintf(rl.Stderr(), "Black: [free] ")
				}
				if game.White != nil {
					fmt.Fprintf(rl.Stderr(), "White: %s ", game.White.Name)
				} else {
					fmt.Fprintf(rl.Stderr(), "White: [free] ")
				}
				fmt.Fprintln(rl.Stderr())
			}
		case strings.HasPrefix(line, "watch "):
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(rl.Stderr(), "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) == 0 {
				fmt.Fprintf(rl.Stderr(), "Usage: watch ID\n")
				continue
			}
			var rid uint16
			if n, err := fmt.Sscanf(args[0], "%d", &rid); n != 1 || err != nil {
				fmt.Fprintf(rl.Stderr(), "Invalid room ID: %s\n", args[0])
				continue
			}
			if room, ok := games[rid]; ok {
				if room.Turn != 0 {
					for i := 0; i < 8; i++ {
						for j := 0; j < 8; j++ {
							ch := '.'
							if room.Board[i][j] == 1 {
								ch = 'O'
							} else if room.Board[i][j] == 2 {
								ch = 'X'
							}
							fmt.Fprintf(rl.Stderr(), "%c", ch)
						}
						fmt.Fprintln(rl.Stderr())
					}
					fmt.Fprintln(rl.Stderr())
				}
				if room.Black != nil {
					fmt.Fprintf(rl.Stderr(), "Black: %s ", room.Black.Name)
				} else {
					fmt.Fprintf(rl.Stderr(), "Black: [free] ")
				}
				if room.Turn == 1 {
					fmt.Fprintf(rl.Stderr(), "[Thinking]")
				}
				if room.White != nil {
					fmt.Fprintf(rl.Stderr(), "White: %s ", room.White.Name)
				} else {
					fmt.Fprintf(rl.Stderr(), "White: [free] ")
				}
				if room.Turn == 2 {
					fmt.Fprintf(rl.Stderr(), "[Thinking]")
				}
				fmt.Fprintln(rl.Stderr())
			} else {
				fmt.Fprintf(rl.Stderr(), "Room #%d does not exists!\n", rid)
			}
		case strings.HasPrefix(line, "closegame "):
			args, err := sw.Parse(line)
			if err != nil {
				fmt.Fprintln(rl.Stderr(), "Invalid line:", err.Error())
				continue
			}
			args = args[1:]
			if len(args) == 0 {
				fmt.Fprintf(rl.Stderr(), "Usage: closegame ID\n")
				continue
			}
			var rid uint16
			if n, err := fmt.Sscanf(args[0], "%d", &rid); n != 1 || err != nil {
				fmt.Fprintf(rl.Stderr(), "Invalid room ID: %s\n", args[0])
				continue
			}
			if room, ok := games[rid]; ok {
				if room.Black != nil {
					room.Black.Leave()
				}
				if room.White != nil {
					room.White.Leave()
				}
				delete(games, rid)
			} else {
				fmt.Fprintf(rl.Stderr(), "Room #%d does not exist!\n", rid)
			}
		default:
			fmt.Fprintln(rl.Stderr(), "Commands: ")
			fmt.Fprint(rl.Stderr(), completer.Tree("    "))
		}
	}
}