Пример #1
0
func (m *BuildClient) UpdateCodeRevision(model_id string,
	request *CodeRevisionLong) (CodeRevisionLong, error) {
	var url bytes.Buffer
	resp := new(CodeRevisionResponse)
	url.WriteString(EI_URL)
	url.WriteString(MODELS_ENDPOINT)
	url.WriteString("/")
	url.WriteString(model_id)
	url.WriteString("/")
	url.WriteString(MODELS_REVISIONS_ENDPOINT)

	req_string, err := json.Marshal(request)
	logging.Debug("Request String for upload: %s", req_string)
	full_resp, err := m._complete_request("POST", url.String(), req_string)
	if err != nil {
		logging.Debug("Failed to update code revisions: %s", err.Error())
		return resp.Revisions, err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from code revision update.. %s", err.Error())
		return resp.Revisions, err
	}

	if resp.Success == false {
		return resp.Revisions, errors.New("Error When retriveing Code Revisions")
	}
	return resp.Revisions, nil
}
Пример #2
0
func main() {
	logging_int := flag.Int("l", int(logging.LOG_INFO),
		"Levels 0-4 0 == None, 4 == Debug")
	log_colors_flag := flag.Bool("log_color", false, "-log_color enables log coloring(mingw/linux only)")
	settings_file := flag.String("settings", DEFAULT_PROJECT_FILE,
		"Set the settings file to a non standard file...")

	flag.Parse()
	err, log_value := logging.IntToLogLevel(*logging_int)
	if err == nil {
		logging.SetLoggingLevel(log_value)
	} else {
		PrintHelp()
		os.Exit(1)
		return
	}

	logging.SetColorEnabled(*log_colors_flag)

	args := flag.Args()

	if len(args) < 1 {
		logging.Info("Need a subcommand")
		PrintHelp()
		os.Exit(1)
		return
	}

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	go func() {
		for {
			select {
			case <-c:
				os.Exit(0)
			}
		}
	}()

	logging.Debug("Using settings file: %s", *settings_file)
	projectSettings := ProcessSettings(*settings_file)
	logging.Debug("Settings found: %s", projectSettings)
	for _, cmd := range commands {
		if cmd.Name() == args[0] && cmd.Runnable() {
			cmd.Flag.Usage = func() { cmd.Usage() }
			for i, s := range args {
				logging.Debug("Left Args: %d:%s", i, s)
			}
			if cmd.CustomFlags {
				args = args[0:]
			} else if len(args) > 2 {
				cmd.Flag.Parse(args[0:])
				args = cmd.Flag.Args()
			}
			cmd.settings = projectSettings
			cmd.Run(cmd, args)
			return
		}
	}
}
Пример #3
0
func StartDeviceLogging(client *ei.BuildClient, device_id string) {
	logs, poll_url, err := client.GetDeviceLogs(device_id)
	if err != nil {
		logging.Fatal("Failed to get device logs %s", err.Error())
		return
	}

	logging.Debug("Poll Url %s", poll_url)
	for _, entry := range logs {
		fmt.Printf("%s: %s: %s\n", entry.Timestamp, entry.Type, entry.Message)
	}

	for {
		logs, err = client.ContinueDeviceLogs(poll_url)
		if err != nil {
			if _, ok := err.(*ei.Timeout); ok == false {
				logging.Fatal("Failed to get device logs %s", err.Error())
				return
			} else {
				logging.Debug("Long poll timed out...")
			}
		} else {
			for _, entry := range logs {
				fmt.Printf("%s: %s: %s\n", entry.Timestamp, entry.Type, entry.Message)
			}
		}
	}
}
Пример #4
0
func (m *BuildClient) RestartModelDevices(model_id string) error {
	var url bytes.Buffer
	resp := new(ModelResponse)
	url.WriteString(EI_URL)
	url.WriteString(MODELS_ENDPOINT)
	url.WriteString("/")
	url.WriteString(model_id)
	url.WriteString("/")
	url.WriteString(MODELS_DEVICE_RESTART_ENDPOINT)

	full_resp, err := m._complete_request("POST", url.String(), nil)
	if err != nil {
		logging.Debug("An error happened during model restart, %s", err.Error())
		return err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from model response.. %s", err.Error())
		return err
	}

	if resp.Success == false {
		return errors.New("Error When retriveing Code Revisions")
	}

	return nil
}
Пример #5
0
func (m *BuildClient) GetModel(model_id string) (*Model, error) {
	var url bytes.Buffer
	resp := new(ModelResponse)
	url.WriteString(EI_URL)
	url.WriteString(MODELS_ENDPOINT)
	url.WriteString("/")
	url.WriteString(model_id)

	full_resp, err := m._complete_request("GET", url.String(), nil)
	if err != nil {
		logging.Debug("An error happened during model get, %s", err.Error())
		return &resp.Model, err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from get model response.. %s", err.Error())
		return &resp.Model, err
	}

	if resp.Success == false {
		return &resp.Model, errors.New("Error when attempting to get model: " + resp.Error.MessageShort)
	}

	return &resp.Model, nil
}
Пример #6
0
func (m *BuildClient) _complete_request(method string,
	url string, data []byte) ([]byte, error) {
	var req *http.Request
	if data != nil {
		req, _ = http.NewRequest(method, url, bytes.NewBuffer(data))
	} else {
		req, _ = http.NewRequest(method, url, nil)
	}

	m.SetAuthHeader(req)
	req.Header.Set("Content-Type", "application/json")
	resp, err := m.http_client.Do(req)
	if resp.StatusCode == http.StatusGatewayTimeout {
		return nil, new(Timeout)
	}

	if err == nil {
		dump, err := httputil.DumpResponse(resp, true)
		logging.Debug(string(dump))
		full_response, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			return full_response, err
		}
		return full_response, nil
	} else {
		return nil, err
	}
}
Пример #7
0
func (m *BuildClient) GetDeviceLogs(device_id string) ([]DeviceLogEntry, string, error) {
	var url bytes.Buffer
	resp := new(DeviceLogResponse)
	url.WriteString(EI_URL)
	url.WriteString(DEVICES_ENDPOINT)
	url.WriteString("/")
	url.WriteString(device_id)
	url.WriteString("/")
	url.WriteString(DEVICES_LOG_ENDPOINT)
	full_resp, err := m._complete_request("GET", url.String(), nil)
	if err != nil {
		logging.Debug("Failed to get device logs: %s", err.Error())
		return resp.Logs, "", err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from device logs.. %s", err.Error())
		return resp.Logs, "", err
	}

	if resp.Success == false {
		return resp.Logs, "", errors.New("Error When retriveing device logs")
	}
	return resp.Logs, resp.PollUrl, nil
}
Пример #8
0
func TestMe(cmd *Command, args []string) {
	logging.Info("Attempting to find test scripts...")
	test_files, err := FindTestFiles()
	if err != nil {
		os.Exit(1)
	}

	for _, input_file := range test_files {
		split_file := strings.Split(input_file, ".")
		// Remove test, and add .o
		split_file = append(split_file[:len(split_file)-2], split_file[len(split_file)-1], "o")
		output_file := strings.Join(split_file, ".")
		logging.Info("Processing target: %s as output: %s", input_file, output_file)
		err = PreProcessFile(output_file, input_file, cmd.settings.LibraryDirs)
		if err != nil {
			logging.Warn("Could not processes output file %s, got error: ", output_file, err.Error())
			continue
		}
		logging.Info("Running target: %s", output_file)
		err = ExecuteSqrl(output_file)
		if err != nil {
			logging.Warn("Could not run output_file %s, got error: ", output_file, err.Error())
			continue
		}
	}

	logging.Debug("All Files Found: %s", test_files)
	logging.Info("Script finished")
}
Пример #9
0
func (m *BuildClient) RestartDevice(device_id string) error {
	var url bytes.Buffer
	resp := new(DeviceResponse)
	url.WriteString(EI_URL)
	url.WriteString(DEVICES_ENDPOINT)
	url.WriteString("/")
	url.WriteString(device_id)
	url.WriteString("/")
	url.WriteString(DEVICES_RESTART_ENDPOINT)

	full_resp, err := m._complete_request("POST", url.String(), nil)
	if err != nil {
		logging.Debug("Failed to get device list: %s", err.Error())
		return err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from code revision update.. %s", err.Error())
		return err
	}

	if resp.Success == false {
		return errors.New("Error When retriveing Code Revisions")
	}
	return nil
}
Пример #10
0
func (m *BuildClient) UpdateDevice(new_device *Device, device_id string) (Device, error) {
	var url bytes.Buffer
	resp := new(DeviceResponse)
	url.WriteString(EI_URL)
	url.WriteString(DEVICES_ENDPOINT)
	url.WriteString("/")
	url.WriteString(device_id)

	req_bytes, err := json.Marshal(new_device)
	full_resp, err := m._complete_request("PUT", url.String(), req_bytes)
	if err != nil {
		logging.Debug("Failed to update device: %s", err.Error())
		return resp.Device, err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from device update.. %s", err.Error())
		return resp.Device, err
	}

	if resp.Success == false {
		return resp.Device, errors.New("Error when updating device")
	}
	return resp.Device, nil
}
Пример #11
0
func (m *BuildClient) GetCodeRevision(model_id string, build_num string) (CodeRevisionLong, error) {
	var url bytes.Buffer
	resp := new(CodeRevisionResponse)
	url.WriteString(EI_URL)
	url.WriteString(MODELS_ENDPOINT)
	url.WriteString("/")
	url.WriteString(model_id)
	url.WriteString("/")
	url.WriteString(MODELS_REVISIONS_ENDPOINT)
	url.WriteString("/")
	url.WriteString(build_num)
	full_resp, err := m._complete_request("GET", url.String(), nil)
	if err != nil {
		logging.Debug("Failed to get code revisions: %s", err.Error())
		return resp.Revisions, err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from code revision.. %s", err.Error())
		return resp.Revisions, err
	}

	if resp.Success == false {
		return resp.Revisions, errors.New("Error When retriveing Code Revisions")
	}
	return resp.Revisions, nil
}
Пример #12
0
func PreProcessFile(outputFile string, inputFile string, libraryDirs []string) error {
	if _, err := os.Stat(inputFile); err != nil {
		logging.Fatal("Did not find input file %s", inputFile)
		return errors.New("Input file not found")
	}
	gppCmdName := PREPROCESSOR_CMD_BIN
	gppArgs := []string{"-o", outputFile, inputFile}
	var s []string
	for _, dir := range libraryDirs {
		s = []string{"-I", dir}
		gppArgs = append(gppArgs, strings.Join(s, ""))
	}
	gppArgs = append(gppArgs, "-C")
	logging.Debug("gppArgs: %s", gppArgs)
	gppCmd := exec.Command(gppCmdName, gppArgs...)
	cmdReader, err := gppCmd.StdoutPipe()
	if err != nil {
		logging.Fatal("Failed to get stdout pipe Error: %s\n", err.Error())
		os.Exit(1)
	}

	cmdErrorReader, err := gppCmd.StderrPipe()
	if err != nil {
		logging.Fatal("Failed to get stderr pipe Error: %s\n", err.Error())
		os.Exit(1)
	}

	scanner := bufio.NewScanner(cmdReader)
	go func() {
		for scanner.Scan() {
			logging.Info("%s", scanner.Text())
		}
	}()

	errScanner := bufio.NewScanner(cmdErrorReader)
	go func() {
		for errScanner.Scan() {
			logging.Warn("%s", errScanner.Text())
		}
	}()

	err = gppCmd.Start()
	if err != nil {
		logging.Fatal("Error starting gpp", err)
		os.Exit(1)
	}

	err = gppCmd.Wait()
	if err != nil {
		logging.Fatal("Error waiting for gpp", err)
		os.Exit(1)
	}

	return nil
}
Пример #13
0
func DeviceSubCommand(cmd *Command, args []string) {
	logging.Debug("In Device")
	for i, s := range args {
		logging.Debug("%d:%s", i, s)
	}

	client, err := CreateClient(cmd.settings.ApiKeyFile)
	if err != nil {
		os.Exit(1)
		return
	}

	if len(args) < 2 {
		PrintModelHelp()
		os.Exit(1)
	}

	if args[1] == "list" {
		ListDevices(client)
	} else if args[1] == "log" {
		if len(args) < 3 {
			fmt.Printf("Usage: device log <device_id>\n")
			PrintDeviceHelp()
		} else {
			logging.Debug("Attempting to start logging")
			StartDeviceLogging(client, args[2])
		}
	} else if args[1] == "assign" {
		if len(args) < 4 {
			fmt.Printf("Usage: device assign <device_id> <model_id>\n")
			PrintDeviceHelp()
		} else {
			logging.Debug("Attemptting to assign device to model")
			AssignDeviceToModel(client, args[2], args[3])
		}
	} else {
		logging.Debug("Showing help")
		PrintDeviceHelp()
		os.Exit(1)
	}
}
Пример #14
0
func (m *BuildClient) CreateModel(new_model *Model) (*Model, error) {
	var url bytes.Buffer
	resp := new(ModelResponse)
	url.WriteString(EI_URL)
	url.WriteString(MODELS_ENDPOINT)

	req_string, err := json.Marshal(new_model)
	logging.Debug("Request String for upload: %s", req_string)
	full_resp, err := m._complete_request("POST", url.String(), req_string)
	if err != nil {
		logging.Debug("An error happened during model creation, %s", err.Error())
		return &resp.Model, err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from model response.. %s", err.Error())
		return &resp.Model, err
	}

	return &resp.Model, nil
}
Пример #15
0
func (m *BuildClient) ListModels() (*ModelList, error) {
	list := new(ModelList)
	full_resp, err := m._complete_request("GET", Concat(EI_URL, "models"), nil)
	if err != nil {
		logging.Debug("An error happened during model get, %s", err.Error())
		return list, err
	}

	if err := json.Unmarshal(full_resp, list); err != nil {
		logging.Warn("Failed to unmarshal data from models.. %s", err.Error())
		return list, err
	}

	return list, nil
}
Пример #16
0
func ModelSubCommand(cmd *Command, args []string) {
	logging.Debug("In model")

	// TODO(sean) Break this out to a helpers area for the ei stuff
	client, err := CreateClient(cmd.settings.ApiKeyFile)
	if err != nil {
		os.Exit(1)
		return
	}

	if len(args) < 2 {
		logging.Debug(cmd.settings.ModelKey)
		if cmd.settings.ModelKey != "" {
			model, err := client.GetModel(cmd.settings.ModelKey)
			if err != nil {
				logging.Fatal("Failed to get model id: %s, Got Error: %s",
					cmd.settings.ModelKey, err.Error())
				os.Exit(1)
				return
			}
			fmt.Printf("Current Model: %s\n", model.Name)
		} else {
			fmt.Printf("No Model set in settings.wrench\n")
		}

		PrintModelHelp()
		os.Exit(1)
	}

	if args[1] == "list" {
		ListModels(client)
	} else {
		PrintModelHelp()
		os.Exit(1)
	}
}
Пример #17
0
func AssignDeviceToModel(client *ei.BuildClient, device_id string, model_id string) {
	device, err := client.GetDevice(device_id)
	if err != nil {
		logging.Fatal("Failed to retrieve current model for model id: %s", model_id)
		return
	}

	// Don't do anything if its already the same
	if device.ModelId == model_id {
		return
	}

	device.ModelId = model_id
	updated_device, err := client.UpdateDevice(&device, device_id)
	logging.Debug("Model and new Devices: %s", updated_device)
}
Пример #18
0
func (m *BuildClient) ContinueDeviceLogs(poll_url string) ([]DeviceLogEntry, error) {
	var url bytes.Buffer
	resp := new(DeviceLogResponse)
	url.WriteString(BASE_EI_URL)
	url.WriteString(poll_url)
	full_resp, err := m._complete_request("GET", url.String(), nil)
	if err != nil {
		logging.Debug("Failed to get device logs: %s", err.Error())
		return resp.Logs, err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from device logs.. %s", err.Error())
		return resp.Logs, err
	}

	if resp.Success == false {
		return resp.Logs, errors.New("Error when retriveing device logs")
	}
	return resp.Logs, nil
}
Пример #19
0
func FindTestFiles() ([]string, error) {
	var files []string
	err := filepath.Walk("./", func(path string, info os.FileInfo, err error) error {
		if info.IsDir() {
			location := path + "\\" + TEST_FILE_PATTERN
			matches, err := filepath.Glob(location)
			if err != nil {
				return err
			}
			if len(matches) > 0 {
				logging.Debug("Found these files: %s", matches)
				files = append(files, matches...)
			}
		}
		return nil
	})

	if err != nil {
		return nil, err
	}

	return files, nil
}
Пример #20
0
func (m *BuildClient) DeleteDevice(device_id string) error {
	var url bytes.Buffer
	resp := new(DeviceResponse)
	url.WriteString(EI_URL)
	url.WriteString(DEVICES_ENDPOINT)
	url.WriteString("/")
	url.WriteString(device_id)

	full_resp, err := m._complete_request("DELETE", url.String(), nil)
	if err != nil {
		logging.Debug("Failed to delete device: %s", err.Error())
		return err
	}

	if err := json.Unmarshal(full_resp, resp); err != nil {
		logging.Warn("Failed to unmarshal data from device deletion.. %s", err.Error())
		return err
	}

	if resp.Success == false {
		return errors.New("Error when updating device")
	}
	return nil
}
Пример #21
0
func main() {
	logging_int := flag.Int("l", int(logging.LOG_INFO),
		"Levels 0-4 0 == None, 4 == Debug")
	log_colors_flag := flag.Bool("log_color", false, "-log_color enables log coloring(mingw/linux only)")
	settings_file := flag.String("settings", DEFAULT_PROJECT_FILE,
		"Set the settings file to a non standard file...")
	gen_settings_flag := flag.Bool("g", false, "-g generates a default settings file if one is not found")

	flag.Parse()
	err, log_value := logging.IntToLogLevel(*logging_int)
	if err == nil {
		logging.SetLoggingLevel(log_value)
	} else {
		PrintHelp()
		os.Exit(1)
		return
	}

	logging.SetColorEnabled(*log_colors_flag)

	args := flag.Args()

	if len(args) < 1 {
		logging.Info("Need a subcommand")
		PrintHelp()
		os.Exit(1)
		return
	}

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	go func() {
		for {
			select {
			case <-c:
				os.Exit(0)
			}
		}
	}()

	var projectSettings ProjectSettings
	logging.Debug("Using settings file: %s", *settings_file)
	if _, err := os.Stat(*settings_file); err != nil {
		logging.Info("Did not find the settings file %s", *settings_file)
		if *settings_file != DEFAULT_PROJECT_FILE {
			logging.Fatal("Could not load non default settings file...")
			os.Exit(1)
		}

		if *gen_settings_flag {
			projectSettings, err = GenerateDefaultSettingsFile(*settings_file)
			if err != nil {
				os.Exit(1)
			}
		} else {
			os.Exit(1)
		}
	} else {
		projectSettings, err = LoadSettings(*settings_file)
		if err != nil {
			logging.Info("Failed to load settings file: %s", *settings_file)
			os.Exit(1)
		}
	}

	logging.Debug("Settings found: %s", projectSettings)
	for _, cmd := range commands {
		if cmd.Name() == args[0] && cmd.Runnable() {
			cmd.Flag.Usage = func() { cmd.Usage() }
			for i, s := range args {
				logging.Debug("Left Args: %d:%s", i, s)
			}
			if cmd.CustomFlags {
				args = args[0:]
			} else if len(args) > 2 {
				cmd.Flag.Parse(args[0:])
				args = cmd.Flag.Args()
			}
			cmd.settings = projectSettings
			cmd.Run(cmd, args)
			return
		}
	}
}