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 Dir2Dat(dat *types.Dat, srcpath, outpath string) error {
glog.Infof("composing DAT from source %s into output %s", srcpath, outpath)
rw := &romWalker{
dat: dat,
sourcePath: srcpath,
}
err := filepath.Walk(srcpath, rw.visit)
if err != nil {
return err
}
outf, err := os.Create(outpath)
if err != nil {
return err
}
defer outf.Close()
outbuf := bufio.NewWriter(outf)
defer outbuf.Flush()
return types.ComposeCompliantDat(dat, outbuf)
}
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
}
func (rs *RombaService) diffdat(cmd *commander.Command, args []string) error {
oldDatPath := cmd.Flag.Lookup("old").Value.Get().(string)
newDatPath := cmd.Flag.Lookup("new").Value.Get().(string)
outPath := cmd.Flag.Lookup("out").Value.Get().(string)
givenName := cmd.Flag.Lookup("name").Value.Get().(string)
givenDescription := cmd.Flag.Lookup("description").Value.Get().(string)
if oldDatPath == "" {
fmt.Fprintf(cmd.Stdout, "-old argument required")
return errors.New("missing old argument")
}
if newDatPath == "" {
fmt.Fprintf(cmd.Stdout, "-new argument required")
return errors.New("missing new argument")
}
if outPath == "" {
fmt.Fprintf(cmd.Stdout, "-out argument required")
return errors.New("missing out argument")
}
glog.Infof("diffdat new dat %s and old dat %s into %s", newDatPath, oldDatPath, outPath)
oldDat, _, err := parser.Parse(oldDatPath)
if err != nil {
return err
}
newDat, _, err := parser.Parse(newDatPath)
if err != nil {
return err
}
if givenName == "" {
givenName = strings.TrimSuffix(filepath.Base(outPath), filepath.Ext(outPath))
}
if givenDescription == "" {
givenDescription = givenName
}
dd, err := dedup.NewLevelDBDeduper()
if err != nil {
return err
}
defer dd.Close()
err = dedup.Declare(oldDat, dd)
if err != nil {
return err
}
diffDat, err := dedup.Dedup(newDat, dd)
if err != nil {
return err
}
diffDat = diffDat.FilterRoms(func(r *types.Rom) bool {
return r.Size > 0
})
var endMsg string
if diffDat != nil {
diffDat.Name = givenName
diffDat.Description = givenDescription
diffDat.Path = outPath
diffFile, err := os.Create(outPath)
if err != nil {
return err
}
defer diffFile.Close()
diffWriter := bufio.NewWriter(diffFile)
defer diffWriter.Flush()
err = types.ComposeCompliantDat(diffDat, diffWriter)
if err != nil {
return err
}
endMsg = fmt.Sprintf("diffdat finished, %d games with diffs found, written diffdat file %s",
len(diffDat.Games), outPath)
} else {
endMsg = "diffdat finished, no diffs found, no diffdat file written"
}
glog.Infof(endMsg)
fmt.Fprintf(cmd.Stdout, endMsg)
rs.broadCastProgress(time.Now(), false, true, endMsg)
return nil
}