Example #1
0
func (rs *RombaService) lookup(cmd *commander.Command, args []string) error {
	for _, arg := range args {
		hash, err := hex.DecodeString(arg)
		if err != nil {
			return err
		}

		if len(hash) == sha1.Size {
			dat, err := rs.romDB.GetDat(hash)
			if err != nil {
				return err
			}

			if dat != nil {
				fmt.Fprintf(cmd.Stdout, "dat with sha1 %s = %s\n", arg, types.PrintShortDat(dat))
			}
		}

		r := new(types.Rom)
		switch len(hash) {
		case md5.Size:
			r.Md5 = hash
		case crc32.Size:
			r.Crc = hash
		case sha1.Size:
			r.Sha1 = hash
		default:
			return fmt.Errorf("found unknown hash size: %d", len(hash))
		}

		dats, err := rs.romDB.DatsForRom(r)
		if err != nil {
			return err
		}

		err = rs.romDB.CompleteRom(r)
		if err != nil {
			return err
		}

		if len(dats) > 0 {
			fmt.Fprintf(cmd.Stdout, "rom in %s\n", types.PrintRomInDats(dats))
		}
	}

	return nil
}
Example #2
0
func (rs *RombaService) lookup(cmd *commander.Command, args []string) error {
	size := cmd.Flag.Lookup("size").Value.Get().(int64)
	outpath := cmd.Flag.Lookup("out").Value.Get().(string)

	for _, arg := range args {
		fmt.Fprintf(cmd.Stdout, "----------------------------------------\n")
		fmt.Fprintf(cmd.Stdout, "key: %s\n", arg)

		if strings.HasPrefix(arg, "0x") {
			arg = arg[2:]
		}

		hash, err := hex.DecodeString(arg)
		if err != nil {
			return err
		}

		if len(hash) == sha1.Size {
			dat, err := rs.romDB.GetDat(hash)
			if err != nil {
				return err
			}

			if dat != nil {
				fmt.Fprintf(cmd.Stdout, "-----------------\n")
				fmt.Fprintf(cmd.Stdout, "dat with sha1 %s = %s\n", arg, types.PrintShortDat(dat))
			}
		}

		if size != -1 || len(hash) == sha1.Size {
			r := new(types.Rom)
			r.Size = size
			switch len(hash) {
			case md5.Size:
				r.Md5 = hash
			case crc32.Size:
				r.Crc = hash
			case sha1.Size:
				r.Sha1 = hash
			default:
				return fmt.Errorf("found unknown hash size: %d", len(hash))
			}

			err = rs.lookupRom(cmd, r, outpath)
			if err != nil {
				return err
			}

			fmt.Fprintf(cmd.Stdout, "-----------------\n")
			fmt.Fprintf(cmd.Stdout, "DebugGet:\n%s\n", rs.romDB.DebugGet(hash, size))
		} else {
			suffixes, err := rs.romDB.ResolveHash(hash)
			if err != nil {
				return err
			}

			for i := 0; i < len(suffixes); i += sha1.Size + 8 {
				r := new(types.Rom)
				r.Size = util.BytesToInt64(suffixes[i : i+8])
				switch len(hash) {
				case md5.Size:
					r.Md5 = hash
				case crc32.Size:
					r.Crc = hash
				default:
					return fmt.Errorf("found unknown hash size: %d", len(hash))
				}
				r.Sha1 = suffixes[i+8 : i+8+sha1.Size]

				err = rs.lookupRom(cmd, r, outpath)
				if err != nil {
					return err
				}
			}
		}
	}

	return nil
}
Example #3
0
func (pw *buildWorker) Process(path string, size int64) error {
	hashes, err := archive.HashesForFile(path)
	if err != nil {
		return err
	}

	dat, err := pw.pm.rs.romDB.GetDat(hashes.Sha1)
	if err != nil {
		return err
	}

	if dat == nil {
		glog.Warningf("did not find a DAT for %s, parsing it", path)
		dat, _, err = parser.Parse(path)
		if err != nil {
			return err
		}

		glog.V(4).Infof("parsed dat=%s", types.PrintShortDat(dat))
	}

	reldatdir, err := filepath.Rel(pw.pm.commonRootPath, filepath.Dir(path))
	if err != nil {
		return err
	}

	datdir := filepath.Join(pw.pm.outpath, reldatdir)

	glog.Infof("buildWorker processing %s, reldatdir=%s, datdir=%s", path, reldatdir, datdir)

	err = os.MkdirAll(datdir, 0777)
	if err != nil {
		return err
	}

	for _, game := range dat.Games {
		for _, rom := range game.Roms {
			err = pw.pm.rs.romDB.CompleteRom(rom)
			if err != nil {
				return err
			}
		}
	}

	datInComplete := false
	if pw.pm.fixdatOnly {
		datInComplete, err = pw.pm.rs.depot.FixDat(dat, datdir, pw.pm.numSubWorkers, pw.pm.deduper)
	} else {
		datInComplete, err = pw.pm.rs.depot.BuildDat(dat, datdir, pw.pm.numSubWorkers, pw.pm.deduper)
	}

	if err != nil {
		return err
	}

	glog.Infof("finished building dat %s in directory %s", dat.Name, datdir)
	if datInComplete {
		glog.Info("dat has missing roms")
	}
	return nil
}