Golang cobra.Command类代码示例

// Main entry point for running fixr subcommand.
func runFixr(cmd *cobra.Command, args []string) {
	if len(args) < 1 {
		log.Fatalf("Must provide at least one directory argument to fixr.")
	}

	var files []fileInfo
	for _, dir := range args {
		fl, err := ioutil.ReadDir(dir)
		if err != nil {
			log.Fatalf("Failed to read directory '%v' with error %v\n", dir, err)
		}

		for _, f := range fl {
			if match, _ := regexp.MatchString("\\.json$", f.Name()); match && !f.IsDir() {
				files = append(files, fileInfo{d: dir, f: f})
			}
		}
	}

	if cmd.Flags().Lookup("prompt").Changed {
		runFixrInteractive(cmd, files)
	} else {
		runFixrBatch(cmd, files)
	}
}

func githubIngestor(c client, cmd *cobra.Command) http.HandlerFunc {
	gho := cmd.Flags().Lookup("github-oauth").Value.String()
	return func(w http.ResponseWriter, r *http.Request) {
		defer r.Body.Close()

		// TODO this is all pretty sloppy
		bod, err := ioutil.ReadAll(r.Body)
		if err != nil {
			// Too long, or otherwise malformed request body
			w.WriteHeader(400)
			w.Write([]byte(err.Error()))
			return
		}

		gpe := githubPushEvent{}
		err = json.Unmarshal(bod, &gpe)
		if err != nil {
			w.WriteHeader(400)
			w.Write([]byte(err.Error()))
			return
		}

		err = c.send(gpe.ToMessage(gho))
		if err != nil {
			w.WriteHeader(502) // 502, bad gateway
		} else {
			// tell github it's all OK
			w.WriteHeader(202)
		}
	}
}

func runDotDumper(cmd *cobra.Command, args []string) {
	g := represent.NewGraph()
	raw, err := schema.Master()
	if err != nil {
		panic(fmt.Sprint("Failed to open master schema file, test must abort. message:", err.Error()))
	}

	schemaMaster, err := gjs.NewSchema(gjs.NewStringLoader(string(raw)))
	if err != nil {
		panic("bad schema...?")
	}

	if len(args) < 1 {
		log.Fatalf("Must provide at least one directory argument to dotdumper.")
	}

	var k uint64 = 0
	for _, dir := range args {
		fl, err := ioutil.ReadDir(dir)
		if err != nil {
			erro.Printf("Failed to read directory '%v' with error %v\n", dir, err)
		}

		for _, f := range fl {
			if match, _ := regexp.MatchString("\\.json$", f.Name()); match && !f.IsDir() {
				src, err := ioutil.ReadFile(dir + "/" + f.Name())
				if err != nil {
					erro.Printf("Failed to read fixture file %v/%v\n", dir, f.Name())
					continue
				}

				result, err := schemaMaster.Validate(gjs.NewStringLoader(string(src)))
				if err != nil {
					erro.Printf("Validation process terminated with errors for %v/%v. Error: \n%v\n", dir, f.Name(), err.Error())
					continue
				}

				if !result.Valid() {
					for _, desc := range result.Errors() {
						erro.Printf("\t%s\n", desc)
					}
				} else {
					k++
					m := ingest.Message{}
					json.Unmarshal(src, &m)

					g = g.Merge(k, m.UnificationForm())
					fmt.Printf("Merged message %v/%v into graph\n", dir, f.Name())
				}
			}
		}
	}

	pathflag := cmd.Flags().Lookup("output")
	if pathflag.Changed {
		ioutil.WriteFile(pathflag.Value.String(), GenerateDot(g), 0644)
	} else {
		fmt.Println(string(GenerateDot(g)))
	}
}

// Performs the fixr run with user interaction, confirming for each message.
func runFixrInteractive(cmd *cobra.Command, files []fileInfo) {
	client := http.Client{Timeout: 5 * time.Second}
FileLoop:
	for k, f := range files {
		src, err := ioutil.ReadFile(f.d + "/" + f.f.Name())
		if err != nil {
			erro.Printf("Failed to read file '%v/%v' with error %v\n", f.d, f.f.Name(), err)
			continue
		}
		fmt.Printf("\nMessage #%v (%v/%v) contents:\n%s", k+1, f.d, f.f.Name(), src)

		for {
			fmt.Printf("Message #%v: (S)end, s(k)ip, or (q)uit? ", k+1)
			reader := bufio.NewReader(os.Stdin)

			raw, err := reader.ReadString('\n')
			if err != nil {
				erro.Fatalf("Bad input, terminating fixr\n")
			}

			input := strings.Split(strings.Trim(raw, " \n"), " ")
			if len(input) < 1 {
				erro.Fatalf("TODO huh how would this happen\n")
			}
			switch input[0] {
			case "k", "skip":
				continue FileLoop
			case "", "s", "send":
				resp, err := client.Post(cmd.Flags().Lookup("target").Value.String(), "application/json", bytes.NewReader(src))
				fmt.Printf("Sending %v/%v...", f.d, f.f.Name())
				if err != nil {
					log.Fatalf(err.Error())
				}

				bod, err := ioutil.ReadAll(resp.Body)
				if err != nil {
					erro.Println(err)
				}
				resp.Body.Close()

				fmt.Printf("%v, msgid %v\n", resp.StatusCode, string(bod))
				continue FileLoop
			case "q", "quit":
				fmt.Printf("Quitting...\n")
				os.Exit(1)
			}
		}
	}
}

// Performs the fixr run in a batch, sending all fixtures found immediately and without confirmation.
func runFixrBatch(cmd *cobra.Command, files []fileInfo) {
	client := http.Client{Timeout: 5 * time.Second}
	for _, f := range files {
		src, err := ioutil.ReadFile(f.d + "/" + f.f.Name())
		if err != nil {
			erro.Printf("Failed to read file '%v/%v' with error %v\n", f.d, f.f.Name(), err)
			continue
		}

		resp, err := client.Post(cmd.Flags().Lookup("target").Value.String(), "application/json", bytes.NewReader(src))
		fmt.Printf("Sending %v/%v...", f.d, f.f.Name())
		if err != nil {
			log.Fatalln(err)
		}

		bod, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			erro.Println(err)
		}
		resp.Body.Close()

		fmt.Printf("%v, msgid %v\n", resp.StatusCode, string(bod))
	}
}

// runGenLS is the main entry point for running the logic state-generating
// ls subcommand.
func (lsc lsCmd) runGenLS(cmd *cobra.Command, args []string) {
	ls := &semantic.LogicState{}

	if !cmd.Flags().Lookup("no-detect").Changed {
		*ls = lsc.detectDefaults()
	}

	// Write directly to stdout, at least for now
	w := os.Stdout

	// Prep schema to validate the messages as we go
	raw, err := schema.Master()
	if err != nil {
		fmt.Fprintln(w, "WARNING: Failed to open master schema file; pvc cannot validate outgoing messages.")
	}

	schemaMaster, err = gjs.NewSchema(gjs.NewStringLoader(string(raw)))
	if err != nil {
		panic("bad schema...?")
	}

	client := http.Client{Timeout: 5 * time.Second}

	fmt.Fprintln(w, "Generating a logic state message...")
	reader := bufio.NewReader(os.Stdin)
MenuLoop:
	for {
		fmt.Fprintf(w, "\n")
		lsc.printCurrentState(w, *ls)

		var input string
		for {
			fmt.Fprintf(w, "\nSelect a value to edit by number, (p)rint current JSON message, (s)end, or (q)uit: ")
			l, err := fmt.Fscanln(reader, &input)
			if l > 1 || err != nil {
				continue
			}

			switch input {
			case "q", "quit":
				fmt.Fprintf(w, "\nQuitting; message was not sent\n")
				os.Exit(1)
			case "s", "send":
				msg, err := toJSONBytes(*ls)
				if err != nil {
					log.Fatalf("\nFailed to marshal JSON of logic state object, no message sent\n")
				}

				resp, err := client.Post(cmd.Flags().Lookup("target").Value.String(), "application/json", bytes.NewReader(msg))
				if err != nil {
					log.Fatalf(err.Error())
				}

				bod, err := ioutil.ReadAll(resp.Body)
				resp.Body.Close()
				if err != nil {
					log.Fatalf(err.Error())
				}

				if resp.StatusCode >= 200 && resp.StatusCode <= 300 {
					fmt.Printf("Message accepted (HTTP code %v), msgid %v\n", resp.StatusCode, string(bod))
				} else {
					fmt.Printf("Message was rejected with HTTP code %v and message %v\n", resp.StatusCode, string(bod))
				}
				break MenuLoop

			case "p", "print":
				byts, err := toJSONBytes(*ls)
				if err != nil {
					fmt.Fprintf(w, "Error while generating JSON for printing: %q", err.Error())
					continue MenuLoop
				}

				var prettied bytes.Buffer
				err = json.Indent(&prettied, byts, "", "    ")
				if err != nil {
					fmt.Fprintf(w, "Error while generating JSON for printing: %q", err.Error())
					continue MenuLoop
				}

				fmt.Fprintf(w, "\nMessage that will be sent to %s:\n", cmd.Flags().Lookup("target").Value)
				prettied.WriteTo(w)
				w.WriteString("\n")

			default:
				num, interr := strconv.Atoi(input)
				if interr != nil {
					continue
				} else if 0 < num && num < 10 {
					switch num {
					case 1:
						lsc.collectPath(w, reader, ls)
					case 2:
						lsc.collectHostFQDN(w, reader, ls)
					case 3:
						lsc.collectHostNick(w, reader, ls)
					case 4:
						lsc.collectCommit(w, reader, ls)
//.........这里部分代码省略.........