func main() {
log.Println("Running tocrawl tool, to generate crawling list")
log.Println("NonCrawlHosts: ", gcse.NonCrawlHosts)
log.Println("CrawlGithubUpdate: ", gcse.CrawlGithubUpdate)
log.Println("CrawlByGodocApi: ", gcse.CrawlByGodocApi)
// Load CrawlerDB
cDB = gcse.LoadCrawlerDB()
if gcse.CrawlGithubUpdate || gcse.CrawlByGodocApi {
// load pkgUTs
pkgUTs, err := loadPackageUpdateTimes(
sophie.LocalFsPath(gcse.DocsDBPath.S()))
if err != nil {
log.Fatalf("loadPackageUpdateTimes failed: %v", err)
}
if gcse.CrawlGithubUpdate {
touchByGithubUpdates(pkgUTs)
}
if gcse.CrawlByGodocApi {
httpClient := gcse.GenHttpClient("")
pkgs, err := gcse.FetchAllPackagesInGodoc(httpClient)
if err != nil {
log.Fatalf("FetchAllPackagesInGodoc failed: %v", err)
}
log.Printf("FetchAllPackagesInGodoc returns %d entries", len(pkgs))
for _, pkg := range pkgs {
cDB.AppendPackage(pkg, func(pkg string) bool {
_, ok := pkgUTs[pkg]
return ok
})
}
}
syncDatabases()
}
log.Printf("Package DB: %d entries", cDB.PackageDB.Count())
log.Printf("Person DB: %d entries", cDB.PersonDB.Count())
pathToCrawl := gcse.DataRoot.Join(gcse.FnToCrawl)
kvPackage := kv.DirOutput(sophie.LocalFsPath(
pathToCrawl.Join(gcse.FnPackage).S()))
kvPackage.Clean()
if err := generateCrawlEntries(cDB.PackageDB, gcse.HostOfPackage, kvPackage); err != nil {
log.Fatalf("generateCrawlEntries %v failed: %v", kvPackage.Path, err)
}
kvPerson := kv.DirOutput(sophie.LocalFsPath(
pathToCrawl.Join(gcse.FnPerson).S()))
kvPerson.Clean()
if err := generateCrawlEntries(cDB.PersonDB, func(id string) string {
site, _ := gcse.ParsePersonId(id)
return site
}, kvPerson); err != nil {
log.Fatalf("generateCrawlEntries %v failed: %v", kvPerson.Path, err)
}
}
func main() {
defer func() {
tmpFn := villa.Path("/tmp/gddo")
if err := tmpFn.RemoveAll(); err != nil {
log.Printf("Delete %v failed: %v", tmpFn, err)
}
}()
singlePackge := ""
singleETag := ""
flag.StringVar(&singlePackge, "pkg", singlePackge, "Crawling single package")
flag.StringVar(&singleETag, "etag", singleETag, "ETag for single package crawling")
flag.Parse()
httpClient := gcse.GenHttpClient("")
if singlePackge != "" {
log.Printf("Crawling single package %s ...", singlePackge)
p, err := gcse.CrawlPackage(httpClient, singlePackge, singleETag)
if err != nil {
fmtp.Printfln("Crawling package %s failured: %v", singlePackge, err)
} else {
fmtp.Printfln("Package %s: %+v", singlePackge, p)
}
return
}
log.Println("crawler started...")
// Load CrawlerDB
cDB = gcse.LoadCrawlerDB()
fpDataRoot := sophie.FsPath{
Fs: sophie.LocalFS,
Path: gcse.DataRoot.S(),
}
fpDocs := fpDataRoot.Join(gcse.FnDocs)
if err := loadAllDocsPkgs(kv.DirInput(fpDocs)); err != nil {
log.Fatalf("loadAllDocsPkgs: %v", err)
}
log.Printf("%d docs loaded!", len(allDocsPkgs))
AppStopTime = time.Now().Add(gcse.CrawlerDuePerRun)
//pathToCrawl := gcse.DataRoot.Join(gcse.FnToCrawl)
fpCrawler := fpDataRoot.Join(gcse.FnCrawlerDB)
fpToCrawl := fpDataRoot.Join(gcse.FnToCrawl)
fpNewDocs := fpCrawler.Join(gcse.FnNewDocs)
fpNewDocs.Remove()
pkgEnd := make(chan error, 1)
go crawlPackages(httpClient, fpToCrawl.Join(gcse.FnPackage), fpNewDocs,
pkgEnd)
psnEnd := make(chan error, 1)
go crawlPersons(httpClient, fpToCrawl.Join(gcse.FnPerson), psnEnd)
errPkg, errPsn := <-pkgEnd, <-psnEnd
if errPkg != nil || errPsn != nil {
log.Fatalf("Some job may failed, package: %v, person: %v",
errPkg, errPsn)
}
if err := processImports(); err != nil {
log.Printf("processImports failed: %v", err)
}
syncDatabases()
log.Println("crawler stopped...")
}
func crawlEntriesLoop() {
httpClient := gcse.GenHttpClient("")
for time.Now().Before(AppStopTime) {
checkImports()
if gcse.CrawlByGodocApi {
processGodoc(httpClient)
}
didSomething := false
var wg sync.WaitGroup
pkgGroups := listPackagesByHost(5, 50)
if len(pkgGroups) > 0 {
didSomething = true
log.Printf("Crawling packages of %d groups", len(pkgGroups))
wg.Add(len(pkgGroups))
for host, ents := range pkgGroups {
go func(host string, ents []EntryInfo) {
failCount := 0
for _, ent := range ents {
if time.Now().After(AppStopTime) {
break
}
runtime.GC()
p, err := gcse.CrawlPackage(httpClient, ent.ID, ent.Etag)
if err != nil && err != gcse.ErrPackageNotModifed {
log.Printf("Crawling pkg %s failed: %v", ent.ID, err)
if gcse.IsBadPackage(err) {
// a wrong path
deletePackage(ent.ID)
log.Printf("Remove wrong package %s", ent.ID)
} else {
failCount++
schedulePackage(ent.ID, time.Now().Add(
12*time.Hour), ent.Etag)
if failCount >= 10 {
durToSleep := 10 * time.Minute
if time.Now().Add(durToSleep).After(AppStopTime) {
break
}
log.Printf("Last ten crawling %s packages failed, sleep for a while...",
host)
time.Sleep(durToSleep)
failCount = 0
}
}
continue
}
failCount = 0
if err == gcse.ErrPackageNotModifed {
log.Printf("Package %s unchanged!", ent.ID)
schedulePackageNextCrawl(ent.ID, ent.Etag)
continue
}
log.Printf("Crawled package %s success!", ent.ID)
pushPackage(p)
log.Printf("Package %s saved!", ent.ID)
}
wg.Done()
}(host, ents)
}
}
personGroups := listPersonsByHost(5, 100)
if len(personGroups) > 0 {
didSomething = true
log.Printf("Crawling persons of %d groups", len(personGroups))
wg.Add(len(personGroups))
for host, ents := range personGroups {
go func(host string, ents []EntryInfo) {
failCount := 0
for _, ent := range ents {
if time.Now().After(AppStopTime) {
break
}
p, err := gcse.CrawlPerson(httpClient, ent.ID)
if err != nil {
failCount++
log.Printf("Crawling person %s failed: %v", ent.ID, err)
schedulePerson(ent.ID, time.Now().Add(12*time.Hour))
if failCount >= 10 {
durToSleep := 10 * time.Minute
if time.Now().Add(durToSleep).After(AppStopTime) {
break
}
log.Printf("Last ten crawling %s persons failed, sleep for a while...",
host)
time.Sleep(durToSleep)
failCount = 0
}
continue
}
log.Printf("Crawled person %s success!", ent.ID)
pushPerson(p)
log.Printf("Push person %s success", ent.ID)
failCount = 0
}
wg.Done()
}(host, ents)
}
}
wg.Wait()
syncDatabases()
if gcse.CrawlGithubUpdate {
if touchByGithubUpdates() {
didSomething = true
}
}
if !didSomething {
log.Printf("Nothing to crawl sleep for a while...")
time.Sleep(2 * time.Minute)
}
}
}
func main() {
log.Println("Running tocrawl tool, to generate crawling list")
log.Println("NonCrawlHosts: ", configs.NonCrawlHosts)
log.Println("CrawlGithubUpdate: ", configs.CrawlGithubUpdate)
log.Println("CrawlByGodocApi: ", configs.CrawlByGodocApi)
log.Printf("Using personal: %v", configs.CrawlerGithubPersonal)
gcse.GithubSpider = github.NewSpiderWithToken(configs.CrawlerGithubPersonal)
// Load CrawlerDB
cDB = gcse.LoadCrawlerDB()
if configs.CrawlGithubUpdate || configs.CrawlByGodocApi {
// load pkgUTs
pkgUTs, err := loadPackageUpdateTimes(
sophie.LocalFsPath(configs.DocsDBPath().S()))
if err != nil {
log.Fatalf("loadPackageUpdateTimes failed: %v", err)
}
if configs.CrawlGithubUpdate {
touchByGithubUpdates(pkgUTs)
}
if configs.CrawlByGodocApi {
httpClient := gcse.GenHttpClient("")
pkgs, err := gcse.FetchAllPackagesInGodoc(httpClient)
if err != nil {
log.Fatalf("FetchAllPackagesInGodoc failed: %v", err)
}
gcse.AddBiValueAndProcess(bi.Max, "godoc.doc-count", len(pkgs))
log.Printf("FetchAllPackagesInGodoc returns %d entries", len(pkgs))
now := time.Now()
for _, pkg := range pkgs {
cDB.AppendPackage(pkg, func(pkg string) bool {
_, ok := pkgUTs[pkg]
return ok
})
site, path := utils.SplitPackage(pkg)
if err := store.AppendPackageEvent(site, path, "godoc", now, sppb.HistoryEvent_Action_None); err != nil {
log.Printf("UpdatePackageHistory %s %s failed: %v", site, path, err)
}
}
}
syncDatabases()
}
log.Printf("Package DB: %d entries", cDB.PackageDB.Count())
log.Printf("Person DB: %d entries", cDB.PersonDB.Count())
pathToCrawl := configs.DataRoot.Join(configs.FnToCrawl)
kvPackage := kv.DirOutput(sophie.LocalFsPath(
pathToCrawl.Join(configs.FnPackage).S()))
kvPackage.Clean()
if err := generateCrawlEntries(cDB.PackageDB, gcse.HostOfPackage, kvPackage); err != nil {
log.Fatalf("generateCrawlEntries %v failed: %v", kvPackage.Path, err)
}
kvPerson := kv.DirOutput(sophie.LocalFsPath(
pathToCrawl.Join(configs.FnPerson).S()))
kvPerson.Clean()
if err := generateCrawlEntries(cDB.PersonDB, func(id string) string {
site, _ := gcse.ParsePersonId(id)
return site
}, kvPerson); err != nil {
log.Fatalf("generateCrawlEntries %v failed: %v", kvPerson.Path, err)
}
}
func main() {
runtime.GOMAXPROCS(2)
log.Printf("Using personal: %v", configs.CrawlerGithubPersonal)
gcse.GithubSpider = github.NewSpiderWithToken(configs.CrawlerGithubPersonal)
if db, err := bh.Open(configs.DataRoot.Join("filecache.bolt").S(), 0644, nil); err == nil {
log.Print("Using file cache!")
gcse.GithubSpider.FileCache = spider.BoltFileCache{
DB: db,
IncCounter: bi.Inc,
}
} else {
log.Printf("Open file cache failed: %v", err)
}
cleanTempDir()
defer cleanTempDir()
singlePackage := flag.String("pkg", "", "Crawling a single package")
singleETag := flag.String("etag", "", "ETag for the single package crawling")
singlePerson := flag.String("person", "", "Crawling a single person")
flag.Parse()
httpClient := gcse.GenHttpClient("")
if *singlePerson != "" {
log.Printf("Crawling single person %s ...", *singlePerson)
p, err := gcse.CrawlPerson(httpClient, *singlePerson)
if err != nil {
fmtp.Printfln("Crawling person %s failed: %v", *singlePerson, err)
} else {
fmtp.Printfln("Person %s: %+v", *singlePerson, p)
}
}
if *singlePackage != "" {
log.Printf("Crawling single package %s ...", *singlePackage)
p, flds, err := gcse.CrawlPackage(httpClient, *singlePackage, *singleETag)
if err != nil {
fmtp.Printfln("Crawling package %s failed: %v, folders: %v", *singlePackage, err, flds)
} else {
fmtp.Printfln("Package %s: %+v, folders: %v", *singlePackage, p, flds)
}
}
if *singlePackage != "" || *singlePerson != "" {
return
}
log.Println("crawler started...")
// Load CrawlerDB
cDB = gcse.LoadCrawlerDB()
fpDataRoot := sophie.FsPath{
Fs: sophie.LocalFS,
Path: configs.DataRoot.S(),
}
fpDocs := fpDataRoot.Join(configs.FnDocs)
if err := loadAllDocsPkgs(kv.DirInput(fpDocs)); err != nil {
log.Fatalf("loadAllDocsPkgs: %v", err)
}
log.Printf("%d docs loaded!", len(allDocsPkgs))
AppStopTime = time.Now().Add(configs.CrawlerDuePerRun)
//pathToCrawl := gcse.DataRoot.Join(gcse.FnToCrawl)
fpCrawler := fpDataRoot.Join(configs.FnCrawlerDB)
fpToCrawl := fpDataRoot.Join(configs.FnToCrawl)
fpNewDocs := fpCrawler.Join(configs.FnNewDocs)
fpNewDocs.Remove()
if err := processImports(); err != nil {
log.Printf("processImports failed: %v", err)
}
pkgEnd := make(chan error, 1)
go crawlPackages(httpClient, fpToCrawl.Join(configs.FnPackage), fpNewDocs, pkgEnd)
psnEnd := make(chan error, 1)
go crawlPersons(httpClient, fpToCrawl.Join(configs.FnPerson), psnEnd)
errPkg, errPsn := <-pkgEnd, <-psnEnd
bi.Flush()
bi.Process()
syncDatabases()
if errPkg != nil || errPsn != nil {
log.Fatalf("Some job may failed, package: %v, person: %v", errPkg, errPsn)
}
log.Println("crawler stopped...")
}
