Exemplo n.º 1
0
// @return                      [paths-of-artifacts], error
func (mi *MfgImage) CreateMfgImage() ([]string, error) {
	cs, err := mi.build()
	if err != nil {
		return nil, err
	}

	sectionDir := MfgSectionBinDir(mi.basePkg.Name())
	if err := os.MkdirAll(sectionDir, 0755); err != nil {
		return nil, util.ChildNewtError(err)
	}

	for device, section := range cs.dsMap {
		sectionPath := MfgSectionBinPath(mi.basePkg.Name(), device)
		if err := ioutil.WriteFile(sectionPath, section, 0644); err != nil {
			return nil, util.ChildNewtError(err)
		}
	}

	manifest, err := mi.createManifest(cs)
	if err != nil {
		return nil, err
	}

	manifestPath := mi.ManifestPath()
	if err := ioutil.WriteFile(manifestPath, manifest, 0644); err != nil {
		return nil, util.FmtNewtError("Failed to write mfg manifest file: %s",
			err.Error())
	}

	return mi.ToPaths(), nil
}
Exemplo n.º 2
0
func writeElem(elem interface{}, buf *bytes.Buffer) error {
	/* XXX: Assume target platform uses little endian. */
	if err := binary.Write(buf, binary.LittleEndian, elem); err != nil {
		return util.ChildNewtError(err)
	}
	return nil
}
Exemplo n.º 3
0
func (mi *MfgImage) copyBinFiles() error {
	dstPath := MfgBinDir(mi.basePkg.Name())
	if err := os.MkdirAll(filepath.Dir(dstPath), 0755); err != nil {
		return util.ChildNewtError(err)
	}

	bootPaths := bootLoaderFromPaths(mi.boot)
	for _, path := range bootPaths {
		dstDir := MfgBootDir(mi.basePkg.Name())
		if err := mi.copyBinFile(path, dstDir); err != nil {
			return err
		}
	}

	for i, imgTarget := range mi.images {
		imgPaths := imageFromPaths(imgTarget)
		dstDir := MfgImageBinDir(mi.basePkg.Name(), i)
		for _, path := range imgPaths {
			if err := mi.copyBinFile(path, dstDir); err != nil {
				return err
			}
		}
	}

	return nil
}
Exemplo n.º 4
0
func (pw *PackageWriter) fixupPKG() error {
	pkgBase := path.Base(pw.fullName)

	// Move include file to name after package name
	if err := util.MoveFile(pw.targetPath+"/include/your-path/your-file.h",
		pw.targetPath+"/include/your-path/"+pkgBase+".h"); err != nil {
		return err
	}

	// Move source file
	if err := util.MoveFile(pw.targetPath+"/src/your-source.c",
		pw.targetPath+"/src/"+pkgBase+".c"); err != nil {
		return err
	}

	if err := util.CopyDir(pw.targetPath+"/include/your-path/",
		pw.targetPath+"/include/"+pkgBase+"/"); err != nil {
		return err
	}

	if err := os.RemoveAll(pw.targetPath + "/include/your-path/"); err != nil {
		return util.ChildNewtError(err)
	}

	if err := pw.cleanupPackageFile(pw.targetPath + "/pkg.yml"); err != nil {
		return err
	}

	return nil
}
Exemplo n.º 5
0
func (pw *PackageWriter) cleanupPackageFile(pfile string) error {
	f, err := os.Open(pfile)
	if err != nil {
		return util.ChildNewtError(err)
	}
	defer f.Close()

	data, _ := ioutil.ReadAll(f)

	// Search & replace file contents
	re := regexp.MustCompile("your-pkg-name")
	res := re.ReplaceAllString(string(data), pw.fullName)

	if err := ioutil.WriteFile(pfile, []byte(res), 0666); err != nil {
		return util.ChildNewtError(err)
	}

	return nil
}
Exemplo n.º 6
0
func readManifest(path string) (*image.ImageManifest, error) {
	content, err := ioutil.ReadFile(path)
	if err != nil {
		return nil, util.ChildNewtError(err)
	}

	manifest := &image.ImageManifest{}
	if err := json.Unmarshal(content, &manifest); err != nil {
		return nil, util.FmtNewtError(
			"Failure decoding manifest with path \"%s\": %s", err.Error())
	}

	return manifest, nil
}
Exemplo n.º 7
0
func (mi *MfgImage) partFromImage(
	imgPath string, flashAreaName string) (mfgPart, error) {

	part := mfgPart{
		// Boot loader and images always go in device 0.
		device: 0,
	}

	area, ok := mi.bsp.FlashMap.Areas[flashAreaName]
	if !ok {
		return part, util.FmtNewtError(
			"Image at \"%s\" requires undefined flash area \"%s\"",
			imgPath, flashAreaName)
	}

	part.name = fmt.Sprintf("%s (%s)", flashAreaName, filepath.Base(imgPath))
	part.offset = area.Offset

	var err error

	part.data, err = ioutil.ReadFile(imgPath)
	if err != nil {
		return part, util.ChildNewtError(err)
	}

	overflow := len(part.data) - area.Size
	if overflow > 0 {
		return part, util.FmtNewtError(
			"Image \"%s\" is too large to fit in flash area \"%s\"; "+
				"image-size=%d flash-area-size=%d overflow=%d",
			imgPath, flashAreaName, len(part.data), area.Size, overflow)
	}

	// If an image slot is used, the entire flash area is unwritable.  This
	// restriction comes from the boot loader's need to write status at the end
	// of an area.  Pad out part with unwriten flash (0xff).  This probably
	// isn't terribly efficient...
	for i := 0; i < -overflow; i++ {
		part.data = append(part.data, 0xff)
	}

	return part, nil
}
Exemplo n.º 8
0
func (cs *ConnSerial) Open(cp config.NewtmgrConnProfile, readTimeout time.Duration) error {

	c, err := newSerialConfig(cp.ConnString(), readTimeout)
	if err != nil {
		return err
	}

	cs.serialChannel, err = serial.OpenPort(c)
	if err != nil {
		return util.ChildNewtError(err)
	}
	//defer cs.serialChannel.Close()

	// Most of the reading will be done line by line, use the
	// bufio.Scanner to do this
	cs.scanner = bufio.NewScanner(cs.serialChannel)

	return nil
}
Exemplo n.º 9
0
func newSerialConfig(
	connString string, readTimeout time.Duration) (*serial.Config, error) {

	fields := strings.Split(connString, ":")
	if len(fields) == 0 {
		return nil, util.FmtNewtError("invalid connstring: %s", connString)
	}

	name := ""
	baud := 115200

	for _, field := range fields {
		parts := strings.Split(field, "=")
		if len(parts) == 2 {
			if parts[0] == "baud" {
				var err error
				baud, err = strconv.Atoi(parts[1])
				if err != nil {
					return nil, util.ChildNewtError(err)
				}

			}

			if parts[0] == "dev" {
				name = parts[1]
			}
		}
	}

	// Handle old-style conn string (single token indicating dev file).
	if name == "" {
		name = fields[0]
	}

	c := &serial.Config{
		Name:        name,
		Baud:        baud,
		ReadTimeout: readTimeout,
	}

	return c, nil
}