Boltdb-Schlüssel-Wert Datenspeicher rein in Go

Question

Bolt erhält eine Dateisperre für die Datendatei, sodass mehrere Prozesse nicht dieselbe Datenbank gleichzeitig öffnen können. Wenn Sie eine bereits geöffnete Bolt-Datenbank öffnen, bleibt sie hängen, bis der andere Prozess sie schließt.

Wie ist dies der Fall, gibt es ein Konzept für die Verbindungspooling wie verschiedene Clients verbinden und Zugriff auf die Datenbank zur gleichen Zeit.? Ist das in boltdb möglich? Es gibt verschiedene Verbindungen, die gleichzeitig in der Datenbank lesen und schreiben. Wie kann es implementiert werden?

Answer 1

A Bolt-Datenbank wird in der Regel in ein größeres Programm eingebettet ist und nicht über das Netzwerk verwendet, wie Sie mit gemeinsam genutzten Datenbanken würde (man denke SQLite vs MySQL). Die Verwendung von Bolt ist ein bisschen wie eine persistente map[[]byte][]byte, wenn das möglich wäre. Je nachdem, was Sie tun, möchten Sie vielleicht etwas wie Redis verwenden.

Das heißt, wenn Sie Bolzen auf diese Weise verwenden müssen, ist es nicht sehr schwierig, mit einem einfachen Server zu wickeln. Hier ist ein Beispiel, das Schlüssel aus einer Bolt DB über HTTP schreibt/liest. Sie können Keep-Alive für Verbindungspooling verwenden.

-Code an: https://github.com/skyec/boltdb-server

package main 

import (
    "flag" 
    "fmt" 
    "io/ioutil" 
    "log" 
    "net/http" 
    "time" 

    "github.com/boltdb/bolt" 
    "github.com/gorilla/mux" 
) 

type server struct { 
    db *bolt.DB 
} 

func newServer(filename string) (s *server, err error) { 
    s = &server{} 
    s.db, err = bolt.Open(filename, 0600, &bolt.Options{Timeout: 1 * time.Second}) 
    return 
} 

func (s *server) Put(bucket, key, contentType string, val []byte) error { 
    return s.db.Update(func(tx *bolt.Tx) error { 
     b, err := tx.CreateBucketIfNotExists([]byte(bucket)) 
     if err != nil { 
      return err 
     } 
     if err = b.Put([]byte(key), val); err != nil { 
      return err 
     } 
     return b.Put([]byte(fmt.Sprintf("%s-ContentType", key)), []byte(contentType)) 
    }) 
} 

func (s *server) Get(bucket, key string) (ct string, data []byte, err error) { 
    s.db.View(func(tx *bolt.Tx) error { 
     b := tx.Bucket([]byte(bucket)) 
     r := b.Get([]byte(key)) 
     if r != nil { 
      data = make([]byte, len(r)) 
      copy(data, r) 
     } 

     r = b.Get([]byte(fmt.Sprintf("%s-ContentType", key))) 
     ct = string(r) 
     return nil 
    }) 
    return 
} 

func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) { 
    vars := mux.Vars(r) 

    if vars["bucket"] == "" || vars["key"] == "" { 
     http.Error(w, "Missing bucket or key", http.StatusBadRequest) 
     return 
    } 

    switch r.Method { 
    case "POST", "PUT": 
     data, err := ioutil.ReadAll(r.Body) 
     if err != nil { 
      http.Error(w, err.Error(), http.StatusInternalServerError) 
      return 
     } 
     err = s.Put(vars["bucket"], vars["key"], r.Header.Get("Content-Type"), data) 
     w.WriteHeader(http.StatusOK) 
    case "GET": 
     ct, data, err := s.Get(vars["bucket"], vars["key"]) 
     if err != nil { 
      http.Error(w, err.Error(), http.StatusInternalServerError) 
      return 
     } 
     w.Header().Add("Content-Type", ct) 
     w.Write(data) 
    } 
} 

func main() { 
    var (
     addr string 
     dbfile string 
    ) 

    flag.StringVar(&addr, "l", ":9988", "Address to listen on") 
    flag.StringVar(&dbfile, "db", "/var/data/bolt.db", "Bolt DB file") 
    flag.Parse() 

    log.Println("Using Bolt DB file:", dbfile) 
    log.Println("Listening on:", addr) 

    server, err := newServer(dbfile) 
    if err != nil { 
     log.Fatalf("Error: %s", err) 
    } 

    router := mux.NewRouter() 
    router.Handle("/v1/buckets/{bucket}/keys/{key}", server) 
    http.Handle("/", router) 

    log.Fatal(http.ListenAndServe(addr, nil)) 
} 

Answer 2

Es gibt kein Verbindungs-Pooling-Konzept in boltdb, da keine Verbindung besteht. Es ist keine Client/Server-Datenbank, sondern eine eingebettete Datenbank (wie sqlite oder Berkeley-DB).

Boltdb ist so konzipiert, dass mehrere goroutines des gleichen Prozesses auf die Datenbank zur gleichen Zeit (mit verschiedenen Transaktionen) zugreifen können. Das Modell ist ein einzelner Autor, mehrere Leser. Boltdb ist nicht dafür ausgelegt, Zugriffe von mehreren Prozessen zu unterstützen.

Wenn Sie ein Go-Programm benötigen Unterstützung eine eingebettete Datenbank zu verwenden, um Zugriff von mehreren Prozessen gleichzeitig, können Sie einen Blick auf die Wrapper über LMDB haben wollen, wie zum Beispiel:

• https://github.com/szferi/gomdb
• https://github.com/armon/gomdb