func init() {
router := mux.NewRouter()
router.StrictSlash(true)
listIndexesHandler := bleveHttp.NewListIndexesHandler()
router.Handle("/api", listIndexesHandler).Methods("GET")
docCountHandler := bleveHttp.NewDocCountHandler("")
docCountHandler.IndexNameLookup = indexNameLookup
router.Handle("/api/{indexName}/_count", docCountHandler).Methods("GET")
searchHandler := bleveHttp.NewSearchHandler("")
searchHandler.IndexNameLookup = indexNameLookup
router.Handle("/api/{indexName}/_search", searchHandler).Methods("POST")
http.Handle("/", &CORSWrapper{router})
log.Printf("opening indexes")
// walk the data dir and register index names
dirEntries, err := ioutil.ReadDir(indexDir)
if err != nil {
log.Printf("error reading data dir: %v", err)
return
}
for _, dirInfo := range dirEntries {
indexPath := indexDir + string(os.PathSeparator) + dirInfo.Name()
// skip single files in data dir since a valid index is a directory that
// contains multiple files
if !dirInfo.IsDir() {
log.Printf("not registering %s, skipping", indexPath)
continue
}
i, err := bleve.OpenUsing(indexPath, map[string]interface{}{
"read_only": true,
})
if err != nil {
log.Printf("error opening index %s: %v", indexPath, err)
} else {
log.Printf("registered index: %s", dirInfo.Name())
bleveHttp.RegisterIndexName(dirInfo.Name(), i)
}
}
}
func init() {
router := mux.NewRouter()
router.StrictSlash(true)
listIndexesHandler := bleveHttp.NewListIndexesHandler()
router.Handle("/api", listIndexesHandler).Methods("GET")
docCountHandler := bleveHttp.NewDocCountHandler("")
docCountHandler.IndexNameLookup = indexNameLookup
router.Handle("/api/{indexName}/_count", docCountHandler).Methods("GET")
searchHandler := bleveHttp.NewSearchHandler("")
searchHandler.IndexNameLookup = indexNameLookup
router.Handle("/api/{indexName}/_search", searchHandler).Methods("POST")
http.Handle("/", &CORSWrapper{router})
log.Printf("opening indexes")
// walk the data dir and register index names
dirEntries, err := ioutil.ReadDir(indexDir)
if err != nil {
log.Printf("error reading data dir: %v", err)
return
}
for _, dirInfo := range dirEntries {
indexPath := indexDir + string(os.PathSeparator) + dirInfo.Name()
if !dirInfo.IsDir() {
log.Printf("see file %s, this is not supported in the appengine environment", dirInfo.Name())
} else {
i, err := bleve.OpenUsing(indexPath, map[string]interface{}{
"read_only": true,
})
if err != nil {
log.Printf("error opening index %s: %v", indexPath, err)
} else {
log.Printf("registered index: %s", dirInfo.Name())
bleveHttp.RegisterIndexName(dirInfo.Name(), i)
}
}
}
}
func getIndex(indexName string) (bleve.Index, error) {
if _, err := os.Stat(indexName); os.IsNotExist(err) {
log.Printf("Creating Bleve index at %s\n", indexName)
log.Println("Setting up index...")
indexMapping := bleve.NewIndexMapping()
// Add Accession as a specific document map
accessionMapping := bleve.NewDocumentMapping()
// Now add specific accession fields
titleMapping := bleve.NewTextFieldMapping()
titleMapping.Analyzer = "en"
titleMapping.Store = true
titleMapping.Index = true
accessionMapping.AddFieldMappingsAt("title", titleMapping)
descriptionMapping := bleve.NewTextFieldMapping()
descriptionMapping.Analyzer = "en"
descriptionMapping.Store = true
descriptionMapping.Index = true
accessionMapping.AddFieldMappingsAt("content_description", descriptionMapping)
subjectsMapping := bleve.NewTextFieldMapping()
subjectsMapping.Analyzer = "en"
subjectsMapping.Store = true
subjectsMapping.Index = true
subjectsMapping.IncludeTermVectors = true
accessionMapping.AddFieldMappingsAt("subjects", subjectsMapping)
subjectsFunctionMapping := bleve.NewTextFieldMapping()
subjectsFunctionMapping.Analyzer = "en"
subjectsFunctionMapping.Store = true
subjectsFunctionMapping.Index = true
subjectsFunctionMapping.IncludeTermVectors = true
accessionMapping.AddFieldMappingsAt("subjects_function", subjectsFunctionMapping)
subjectsTopicalMapping := bleve.NewTextFieldMapping()
subjectsTopicalMapping.Analyzer = "en"
subjectsTopicalMapping.Store = true
subjectsTopicalMapping.Index = true
subjectsTopicalMapping.IncludeTermVectors = true
accessionMapping.AddFieldMappingsAt("subjects_topical", subjectsTopicalMapping)
objectTitleMapping := bleve.NewTextFieldMapping()
objectTitleMapping.Analyzer = "en"
objectTitleMapping.Store = true
objectTitleMapping.Index = false
accessionMapping.AddFieldMappingsAt("digital_objects.title", objectTitleMapping)
objectFileURIMapping := bleve.NewTextFieldMapping()
objectFileURIMapping.Analyzer = ""
objectFileURIMapping.Store = true
objectFileURIMapping.Index = false
accessionMapping.AddFieldMappingsAt("digital_objects.file_uris", objectFileURIMapping)
extentsMapping := bleve.NewTextFieldMapping()
extentsMapping.Analyzer = "en"
extentsMapping.Store = true
extentsMapping.Index = true
accessionMapping.AddFieldMappingsAt("extents", extentsMapping)
accessionDateMapping := bleve.NewTextFieldMapping()
accessionDateMapping.Analyzer = "en"
accessionDateMapping.Store = true
accessionDateMapping.Index = false
accessionMapping.AddFieldMappingsAt("accession_date", accessionDateMapping)
datesMapping := bleve.NewTextFieldMapping()
datesMapping.Store = true
datesMapping.Index = false
accessionMapping.AddFieldMappingsAt("date_expression", datesMapping)
createdMapping := bleve.NewDateTimeFieldMapping()
createdMapping.Store = true
createdMapping.Index = false
accessionMapping.AddFieldMappingsAt("created", createdMapping)
// Finally add this mapping to the main index mapping
indexMapping.AddDocumentMapping("accession", accessionMapping)
index, err := bleve.New(indexName, indexMapping)
if err != nil {
return nil, fmt.Errorf("Can't create new bleve index %s, %s", indexName, err)
}
return index, nil
}
log.Printf("Opening Bleve index at %s", indexName)
index, err := bleve.OpenUsing(indexName, map[string]interface{}{
"read_only": false,
})
if err != nil {
return nil, fmt.Errorf("Can't create new bleve index %s, %s", indexName, err)
}
return index, nil
}
func main() {
var err error
appName := path.Base(os.Args[0])
cfg := cli.New(appName, "CAIT", fmt.Sprintf(license, appName, cait.Version), cait.Version)
cfg.UsageText = fmt.Sprintf(usage, appName)
cfg.DescriptionText = fmt.Sprintf(description, appName, appName)
cfg.OptionsText = "OPTIONS\n"
flag.Parse()
if showHelp == true {
fmt.Println(cfg.Usage())
os.Exit(0)
}
if showVersion == true {
fmt.Println(cfg.Version())
os.Exit(0)
}
if showLicense == true {
fmt.Println(cfg.License())
os.Exit(0)
}
siteURL = check(cfg, "site_url", cfg.MergeEnv("site_url", siteURL))
serviceURL, err := url.Parse(siteURL)
if err != nil {
log.Fatal(err)
}
htdocsDir = check(cfg, "htdocs", cfg.MergeEnv("htdocs", htdocsDir))
bleveNames = check(cfg, "bleve", cfg.MergeEnv("bleve", bleveNames))
templatesDir = check(cfg, "templates", cfg.MergeEnv("templates", templatesDir))
webhookPath = cfg.MergeEnv("webhook_path", webhookPath)
webhookSecret = cfg.MergeEnv("webhook_secret", webhookSecret)
webhookCommand = cfg.MergeEnv("webhook_command", webhookCommand)
templateName := path.Join(templatesDir, "advanced-search.html")
advancedPage, err = ioutil.ReadFile(templateName)
if err != nil {
log.Fatalf("Can't read templates, e.g. %s, %s", templateName, err)
}
templateName = path.Join(templatesDir, "basic-search.html")
basicPage, err = ioutil.ReadFile(templateName)
if err != nil {
log.Fatalf("Can't read %s, %s", templateName, err)
}
handleSignals()
// Wake up our search engine
indexList := strings.Split(bleveNames, ":")
availableIndex := false
if enableSearch == true {
for i := 0; i < len(indexList) && availableIndex == false; i++ {
indexName := indexList[i]
log.Printf("Opening %q", indexName)
index, err = bleve.OpenUsing(indexName, map[string]interface{}{
"read_only": true,
})
if err != nil {
log.Printf("Can't open Bleve index %q, %s, trying next index", indexName, err)
} else {
indexAlias = bleve.NewIndexAlias(index)
availableIndex = true
}
}
if availableIndex == false {
log.Fatalf("No index available %s", bleveNames)
}
defer index.Close()
}
// Send static file request to the default handler,
// search routes are handled by middleware customRoutes()
http.Handle("/", http.FileServer(http.Dir(htdocsDir)))
log.Printf("%s %s\n", appName, cait.Version)
log.Printf("Listening on %s\n", serviceURL.String())
err = http.ListenAndServe(serviceURL.Host, requestLogger(customRoutes(http.DefaultServeMux)))
if err != nil {
log.Fatal(err)
}
}
func OpenOfferIndex(path string) (bleve.Index, error) {
return bleve.OpenUsing(path, map[string]interface{}{
"nosync": false,
})
}