Golang gomemcached.IsNotFound函数代码示例

func reloadConfig() {
	for _ = range time.Tick(time.Minute) {
		if err := updateConfig(); err != nil && !gomemcached.IsNotFound(err) {
			log.Printf("Error updating config: %v", err)
		}
	}
}

func sendTagNotification(bugid, tagName, actor string) {
	b, err := getBug(bugid)
	if err != nil {
		log.Printf("Error getting bug %v for tag notification: %v",
			bugid, err)
		return
	}

	tag := Tag{}
	err = db.Get("tag-"+tagName, &tag)
	if err != nil {
		if !gomemcached.IsNotFound(err) {
			log.Printf("Error sending notification for tag %v: %v",
				tagName, err)
		}
		return
	}

	to := filterUnprivelegedEmails(b, removeFromList(tag.Subscribers, actor))

	sendNotifications("tag_notification", to,
		map[string]interface{}{
			"Bug":   b,
			"Tag":   tagName,
			"Actor": actor,
		})
}

func errorCode(err error) int {
	switch {
	case err == bugNotVisible:
		return 401
	case gomemcached.IsNotFound(err):
		return 404
	}
	return 500
}

// Send a custom request and get the response.
func (client *Client) Send(req *gomemcached.MCRequest) (rv *gomemcached.MCResponse, err error) {
	err = transmitRequest(client.conn, req)
	if err != nil {
		client.healthy = false
		return
	}
	resp, err := getResponse(client.conn, client.hdrBuf)
	if err != nil && !gomemcached.IsNotFound(err) {
		client.healthy = false
	}
	return resp, err
}

func doGetConfig(w http.ResponseWriter, req *http.Request) {
	err := updateConfig()
	if err != nil && !gomemcached.IsNotFound(err) {
		log.Printf("Error updating config: %v", err)
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(200)

	e := json.NewEncoder(w)
	err = e.Encode(&globalConfig)
	if err != nil {
		log.Printf("Error sending config: %v", err)
	}
}

func doGetBackupInfo(w http.ResponseWriter, req *http.Request) {
	b := backups{}
	err := couchbase.Get(backupKey, &b)
	if err != nil {
		code := 500
		if gomemcached.IsNotFound(err) {
			code = 404
		}
		http.Error(w, err.Error(), code)
		return
	}

	removeDeadBackups(&b)

	sendJson(w, req, &b)
}

func removeDeadBackups(b *backups) {
	// Keep only backups we're pretty sure still exist.
	obn := b.Backups
	b.Backups = nil
	for _, bi := range obn {
		fm := fileMeta{}
		err := couchbase.Get(shortName(bi.Fn), &fm)
		if gomemcached.IsNotFound(err) {
			log.Printf("Dropping previous (deleted) backup: %v",
				bi.Fn)
		} else {
			b.Backups = append(b.Backups, bi)
		}
	}

}

func storeBackupObject(fn, h string) error {
	b := backups{}
	err := couchbase.Get(backupKey, &b)
	if err != nil && !gomemcached.IsNotFound(err) {
		log.Printf("Weird: %v", err)
		// return err
	}

	removeDeadBackups(&b)

	ob := backupItem{fn, h, time.Now().UTC(), *globalConfig}

	b.Latest = ob
	b.Backups = append(b.Backups, ob)

	return couchbase.Set(backupKey, 0, &b)
}

func doFileInfo(w http.ResponseWriter, req *http.Request, fn string) {
	fm := fileMeta{}
	err := couchbase.Get(shortName(fn), &fm)
	switch {
	case err == nil:
	case gomemcached.IsNotFound(err):
		http.Error(w, "not found", 404)
		return
	default:
		http.Error(w, err.Error(), 500)
		return
	}
	sendJson(w, req, map[string]interface{}{
		"path": fn,
		"meta": fm,
	})
}

func doLinkFile(w http.ResponseWriter, req *http.Request) {
	fn := req.URL.Path
	h := req.FormValue("blob")
	t := req.FormValue("type")

	for len(fn) > 0 && fn[0] == '/' {
		fn = fn[1:]
	}

	blob, err := referenceBlob(h)
	if err != nil {
		estat := 500
		if gomemcached.IsNotFound(err) {
			estat = 404
		}
		http.Error(w, err.Error(), estat)
	}

	fm := fileMeta{
		Headers: http.Header{
			"Content-Type": []string{t},
		},
		OID:      h,
		Length:   blob.Length,
		Modified: time.Now().UTC(),
	}

	exp := getExpiration(req.Header)
	if exp != 0 {
		fm.Headers.Set("X-CBFS-Expiration", strconv.Itoa(exp))
	}

	err = maybeStoreMeta(fn, fm, exp, true)
	if err != nil {
		http.Error(w, err.Error(), 500)
		return
	}
	w.WriteHeader(201)
}

func db_init() {
	var ddocVersion uint64
	err := Bucket.Get(db_ddoc_version_key, &ddocVersion)
	if err != nil && !gomemcached.IsNotFound(err) {
		log.Fatalf("fatal error getting ddoc version from database: %v", err)
	}
	if wanted := uint64(1); ddocVersion != wanted {
		log.Printf("updating ddoc from version %d to %d", ddocVersion, wanted)
		err = Bucket.PutDDoc(db_ddoc_name, couchbase.DDocJSON{
			Views: map[string]couchbase.ViewDefinition{
				"discussion-posts": {
					Map: `function( doc, meta ) {
	if ( doc.Type == "post" ) {
		emit( doc.Discussion, null );
	}
}`,
					Reduce: `_count`,
				},

				"updated-discussions": {
					Map: `function( doc, meta ) {
	if ( doc.Type == "discussion" ) {
		emit( dateToArray( doc.Modified ), null );
	}
}`,
				},
			},
		})
		if err != nil {
			log.Fatalf("fatal error storing ddoc: %v", err)
		}
		err = Bucket.Set(db_ddoc_version_key, 0, wanted)
		if err != nil {
			log.Fatalf("fatal error storing ddoc version: %v", err)
		}
	}
}

func main() {
	flag.Parse()

	rand.Seed(time.Now().UnixNano())

	initLogger(*useSyslog)
	initNodeListKeys()

	http.DefaultTransport = TimeoutTransport(*internodeTimeout)
	expvar.Publish("httpclients", httputil.InitHTTPTracker(false))

	if getHash() == nil {
		fmt.Fprintf(os.Stderr,
			"Unsupported hash specified: %v.  Supported hashes:\n",
			globalConfig.Hash)
		for h := range hashBuilders {
			fmt.Fprintf(os.Stderr, " * %v\n", h)
		}
		os.Exit(1)
	}

	err := initServerId()
	if err != nil {
		log.Fatalf("Error initializing server ID: %v", err)
	}

	if *maxStorageString != "" {
		ms, err := humanize.ParseBytes(*maxStorageString)
		if err != nil {
			log.Fatalf("Error parsing max storage parameter: %v",
				err)
		}
		maxStorage = int64(ms)
	}

	couchbase, err = dbConnect()
	if err != nil {
		log.Fatalf("Can't connect to couchbase: %v", err)
	}

	if err = os.MkdirAll(*root, 0777); err != nil {
		log.Fatalf("Couldn't create storage dir: %v", err)
	}

	err = updateConfig()
	if err != nil && !gomemcached.IsNotFound(err) {
		log.Printf("Error updating initial config, using default: %v",
			err)
	}
	if *verbose {
		log.Printf("Server config:")
		globalConfig.Dump(os.Stdout)
	}

	go reloadConfig()

	go dnsServices()

	internodeTaskQueue = make(chan internodeTask, *taskWorkers*1024)
	initTaskQueueWorkers()

	go heartbeat()
	go startTasks()

	time.AfterFunc(time.Second*time.Duration(rand.Intn(30)+5), grabSomeData)

	go serveFrame()

	s := &http.Server{
		Addr:        *bindAddr,
		Handler:     http.HandlerFunc(httpHandler),
		ReadTimeout: *readTimeout,
	}
	log.Printf("Listening to web requests on %s as server %s",
		*bindAddr, serverId)

	l, err := rateListen("tcp", *bindAddr)
	if err != nil {
		log.Fatalf("Error listening: %v", err)
	}
	log.Fatal(s.Serve(l))
}

func loadExistingHashes() (*hashset.Hashset, error) {
	b := backups{}
	err := couchbase.Get(backupKey, &b)
	if err != nil && !gomemcached.IsNotFound(err) {
		return nil, err
	}

	oids := make(chan string)
	hsch := make(chan *hashset.Hashset)
	visitch := make(chan int)
	errch := make(chan error)

	wg := sync.WaitGroup{}

	for i := 0; i < 4; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for o := range oids {
				h, v, e := loadBackupHashes(o)
				if e == nil {
					hsch <- h
				} else {
					errch <- e
				}
				visitch <- v
			}
		}()
	}
	go func() {
		wg.Wait()
		close(hsch)
		close(visitch)
		close(errch)
	}()

	go func() {
		for _, i := range b.Backups {
			log.Printf("Loading backups from %v / %v", i.Oid, i.Fn)
			oids <- i.Oid
		}
		close(oids)
	}()

	visited := 0
	hs := &hashset.Hashset{}
	for {
		// Done getting all the things
		if hsch == nil && visitch == nil && errch == nil {
			break
		}
		select {
		case v, ok := <-visitch:
			visited += v
			if !ok {
				visitch = nil
			}
		case e, ok := <-errch:
			err = e
			if !ok {
				errch = nil
			}
		case h, ok := <-hsch:
			if ok {
				log.Printf("Got %v hashes from a backup",
					h.Len())
				hs.AddAll(h)
			} else {
				hsch = nil
			}
		}
	}

	log.Printf("Visited %v obs, kept %v", visited, hs.Len())

	return hs, err
}

func serveBugDeletion(w http.ResponseWriter, r *http.Request) {
	me := whoami(r)
	bugid := mux.Vars(r)["bugid"]
	_, err := getBugOrDisplayErr(bugid, me, w, r)
	if err != nil {
		return
	}

	cherr := make(chan error)
	deleted := make(chan couchbase.ViewRow)
	delatt := make(chan couchbase.ViewRow)

	wg := &sync.WaitGroup{}

	wg.Add(1)
	go deleteDocsMatching("cbugg", "comments",
		map[string]interface{}{
			"stale":     false,
			"reduce":    false,
			"start_key": []interface{}{bugid},
			"end_key":   []interface{}{bugid, map[string]string{}},
		}, deleted, cherr, wg)

	wg.Add(1)
	go deleteDocsMatching("cbugg", "attachments",
		map[string]interface{}{
			"stale":        false,
			"reduce":       false,
			"start_key":    []interface{}{bugid},
			"end_key":      []interface{}{bugid, map[string]string{}},
			"include_docs": true,
		}, delatt, cherr, wg)

	wg.Add(1)
	go deleteDocsMatching("cbugg", "bug_history",
		map[string]interface{}{
			"stale":     false,
			"reduce":    false,
			"start_key": []interface{}{bugid},
			"end_key":   []interface{}{bugid, map[string]string{}},
		}, deleted, cherr, wg)

	go func() {
		wg.Wait()
		close(cherr)
	}()

	running := true
	for running {
		select {
		case del := <-deleted:
			log.Printf("Deleted %v", del.ID)
		case del := <-delatt:
			log.Printf("Deleted attachment %v", del.ID)
			mo := (*del.Doc).(map[string]interface{})
			mi := mo["json"].(map[string]interface{})
			u := mi["url"].(string)
			err := deleteAttachmentFile(u)
			if err != nil {
				log.Printf("Error deleting attachment %v: %v",
					u, err)
			}
		case err, ok := <-cherr:
			if !ok {
				running = false
			}
			if err != nil {
				log.Printf("Error:  %v", err)
			}
		}
	}

	log.Printf("Done deleting children.")

	// This bug should already be deleted as a bug is also bug
	// history.  But give it a go anyway for clarity.
	err = db.Delete(bugid)
	if err != nil && !gomemcached.IsNotFound(err) {
		log.Printf("Error deleting the bug.")
	}

	w.WriteHeader(204)
}