Golang Dat.Path方法代码示例

func (kvb *kvBatch) IndexRom(rom *types.Rom) error {
	//glog.Infof("indexing rom %s", rom.Name)

	dats, err := kvb.db.DatsForRom(rom)
	if err != nil {
		return err
	}

	if len(dats) > 0 {
		if rom.Crc != nil && rom.Sha1 != nil {
			//glog.Infof("declaring crc %s -> sha1 %s ampping", hex.EncodeToString(rom.Crc), hex.EncodeToString(rom.Sha1))
			err = kvb.crcsha1Batch.Append(rom.Crc, rom.Sha1)
			if err != nil {
				return err
			}
			kvb.size += int64(sha1.Size)
		}
		if rom.Md5 != nil && rom.Sha1 != nil {
			//glog.Infof("declaring md5 %s -> sha1 %s ampping", hex.EncodeToString(rom.Md5), hex.EncodeToString(rom.Sha1))
			err = kvb.md5sha1Batch.Append(rom.Md5, rom.Sha1)
			if err != nil {
				return err
			}
			kvb.size += int64(sha1.Size)
		}
		return nil
	}

	if rom.Sha1 == nil {
		glog.Warningf("indexing rom %s with missing SHA1", rom.Name)
	}

	dat := new(types.Dat)
	dat.Artificial = true
	dat.Generation = kvb.db.generation
	dat.Name = fmt.Sprintf("Artificial Dat for %s", rom.Name)
	dat.Path = rom.Path
	game := new(types.Game)
	game.Roms = []*types.Rom{rom}
	dat.Games = []*types.Game{game}

	var buf bytes.Buffer

	gobEncoder := gob.NewEncoder(&buf)
	err = gobEncoder.Encode(dat)
	if err != nil {
		return err
	}

	hh := sha1.New()
	_, err = io.Copy(hh, &buf)
	if err != nil {
		return err
	}

	return kvb.IndexDat(dat, hh.Sum(nil))
}

func ParseXml(r io.Reader, path string) (*types.Dat, []byte, error) {
	br := bufio.NewReader(r)

	hr := hashingReader{
		ir: br,
		h:  sha1.New(),
	}

	lr := lineCountingReader{
		ir: hr,
	}

	d := new(types.Dat)
	decoder := xml.NewDecoder(lr)

	err := decoder.Decode(d)
	if err != nil {
		return nil, nil, fmt.Errorf("xml parsing error %d: %v", lr.line, err)
	}

	for _, g := range d.Games {
		for _, rom := range g.Roms {
			fixHashes(rom)
		}
		for _, rom := range g.Disks {
			fixHashes(rom)
		}
		for _, rom := range g.Parts {
			fixHashes(rom)
		}
		for _, rom := range g.Regions {
			fixHashes(rom)
		}
	}

	for _, g := range d.Software {
		for _, rom := range g.Roms {
			fixHashes(rom)
		}
		for _, rom := range g.Disks {
			fixHashes(rom)
		}
		for _, rom := range g.Parts {
			fixHashes(rom)
		}
		for _, rom := range g.Regions {
			fixHashes(rom)
		}
	}

	d.Normalize()
	d.Path = path
	return d, hr.h.Sum(nil), nil
}

func writeDiffDat(diffDat *types.Dat, outPath string) error {
	diffDat.Path = outPath

	diffFile, err := os.Create(outPath)
	if err != nil {
		return err
	}
	defer diffFile.Close()

	diffWriter := bufio.NewWriter(diffFile)
	defer diffWriter.Flush()

	return types.ComposeCompliantDat(diffDat, diffWriter)
}

func (depot *Depot) BuildDat(dat *types.Dat, outpath string) (bool, error) {
	datPath := filepath.Join(outpath, dat.Name)

	err := os.Mkdir(datPath, 0777)
	if err != nil {
		return false, err
	}

	var fixDat *types.Dat

	for _, game := range dat.Games {
		fixGame, err := depot.buildGame(game, datPath)
		if err != nil {
			return false, err
		}
		if fixGame != nil {
			if fixDat == nil {
				fixDat = new(types.Dat)
				fixDat.Name = dat.Name
				fixDat.Description = dat.Description
				fixDat.Path = dat.Path
			}
			fixDat.Games = append(fixDat.Games, fixGame)
		}
	}

	if fixDat != nil {
		fixDatPath := filepath.Join(outpath, fixPrefix+dat.Name+datSuffix)

		fixFile, err := os.Create(fixDatPath)
		if err != nil {
			return false, err
		}
		defer fixFile.Close()

		fixWriter := bufio.NewWriter(fixFile)
		defer fixWriter.Flush()

		err = types.ComposeDat(fixDat, fixWriter)
		if err != nil {
			return false, err
		}
	}

	return fixDat == nil, nil
}

func ParseXml(r io.Reader, path string) (*types.Dat, []byte, error) {
	br := bufio.NewReader(r)

	hr := hashingReader{
		ir: br,
		h:  sha1.New(),
	}

	lr := lineCountingReader{
		ir: hr,
	}

	d := new(types.Dat)
	decoder := xml.NewDecoder(lr)

	err := decoder.Decode(d)
	if err != nil {
		derrStr := fmt.Sprintf("error in file %s on line %d: %v", path, lr.line, err)
		derr := XMLParseError.NewWith(derrStr, setErrorFilePath(path), setErrorLineNumber(lr.line))
		return nil, nil, derr
	}

	for _, g := range d.Games {
		for _, rom := range g.Roms {
			fixHashes(rom)
		}
		for _, rom := range g.Parts {
			fixHashes(rom)
		}
		for _, rom := range g.Regions {
			fixHashes(rom)
		}
	}

	for _, g := range d.Software {
		for _, rom := range g.Roms {
			fixHashes(rom)
		}
		for _, rom := range g.Parts {
			fixHashes(rom)
		}
		for _, rom := range g.Regions {
			fixHashes(rom)
		}
	}

	for _, g := range d.Machines {
		for _, rom := range g.Roms {
			fixHashes(rom)
		}
		for _, rom := range g.Parts {
			fixHashes(rom)
		}
		for _, rom := range g.Regions {
			fixHashes(rom)
		}
	}

	d.Normalize()
	d.Path = path
	return d, hr.h.Sum(nil), nil
}

func (depot *Depot) BuildDat(dat *types.Dat, outpath string, numSubworkers int, deduper dedup.Deduper) (bool, error) {

	datPath := filepath.Join(outpath, dat.Name)

	err := os.Mkdir(datPath, 0777)
	if err != nil {
		return false, err
	}

	fixDat := new(types.Dat)
	fixDat.FixDat = true
	fixDat.Name = "fix_" + dat.Name
	fixDat.Description = dat.Description
	fixDat.Path = dat.Path
	fixDat.UnzipGames = dat.UnzipGames

	wc := make(chan *types.Game)
	erc := make(chan error)
	closeC := make(chan bool)
	mutex := new(sync.Mutex)

	for i := 0; i < numSubworkers; i++ {
		gb := new(gameBuilder)
		gb.depot = depot
		gb.wc = wc
		gb.erc = erc
		gb.mutex = mutex
		gb.datPath = datPath
		gb.fixDat = fixDat
		gb.index = i
		gb.deduper = deduper
		gb.closeC = closeC

		go gb.work()
	}

	var minionErr error

endLoop:
	for _, game := range dat.Games {
		select {
		case wc <- game:
		case err := <-erc:
			minionErr = err
			break endLoop
		}
	}
	close(wc)

	finishedSubworkers := 0

endLoop2:
	for {
		glog.V(4).Infof("builder master: finished so far %d", finishedSubworkers)

		select {
		case <-closeC:
			glog.V(4).Infof("builder master: finished another subworker")
			finishedSubworkers++
			if finishedSubworkers == numSubworkers {
				break endLoop2
			}
		case err := <-erc:
			glog.V(4).Infof("builder master: minion error")
			minionErr = err
		}
	}

	if minionErr != nil {
		return false, minionErr
	}

	if len(fixDat.Games) > 0 {
		fixDatPath := filepath.Join(outpath, fixPrefix+dat.Name+datSuffix)

		fixFile, err := os.Create(fixDatPath)
		if err != nil {
			return false, err
		}
		defer fixFile.Close()

		fixWriter := bufio.NewWriter(fixFile)
		defer fixWriter.Flush()

		err = types.ComposeCompliantDat(fixDat, fixWriter)
		if err != nil {
			return false, err
		}
	}

	return len(fixDat.Games) > 0, nil
}