kunt

mapfs.go (3734B)

---

 // Copyright 2013 TLH and dsp. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Simple fs backed up dictionary implementation
 package mapfs
 
 import (
 	"fmt"
 	"log"
 	"math/rand"
 	"os"
 	"path"
 	"path/filepath"
 	"strconv"
 	"sync"
 )
 
 type Mapfs struct {
 	name   string
 	path   string
 	prefix string
 	mapper Mapper
 	sync.Mutex
 }
 
 type Mapper interface {
 	rawRead(string) ([]byte, error)
 	rawWrite(string, []byte) error
 	get(int) ([]byte, error)
 	put(int, []byte) error
 	add([]byte) (int, error)
 	countMatches([]byte) int
 	virtSync() error
 	syncEntry(string, int) error
 	size() int
 	string() string
 }
 
 type MapIter func() (key int, data []byte, ok bool)
 
 func MakeMapIter(m *Mapfs) MapIter {
 	i := 0
 	return func() (key int, data []byte, ok bool) {
 		m.Lock()
 		defer m.Unlock()
 		for i < m.mapper.size() {
 			b, err := m.mapper.get(i)
 			if err == nil {
 				i++
 				return i - 1, b, true
 			}
 			i++
 		}
 		return -1, nil, false
 	}
 }
 
 func NewMapfs(m Mapper, name string, path string, prefix string) *Mapfs {
 	return &Mapfs{
 		name:   name,
 		path:   path,
 		prefix: prefix,
 		mapper: m,
 	}
 }
 
 func (m *Mapfs) rawRead(key int) ([]byte, error) {
 	path := fmt.Sprintf("%s/%s%d.txt", m.path, m.prefix, key)
 	return m.mapper.rawRead(path)
 }
 
 func (m *Mapfs) rawWrite(key int, buf []byte) error {
 	path := fmt.Sprintf("%s/%s%d.txt", m.path, m.prefix, key)
 	return m.mapper.rawWrite(path, buf)
 }
 
 func (m *Mapfs) Get(key int) ([]byte, error) {
 	m.Lock()
 	defer m.Unlock()
 	if m.mapper.size() == 0 {
 		return nil, fmt.Errorf("Empty map, can't fetch entry")
 	}
 	return m.mapper.get(key)
 }
 
 func (m *Mapfs) Put(key int, buf []byte) error {
 	m.Lock()
 	defer m.Unlock()
 	if key < 0 {
 		return fmt.Errorf("Invalid key: %d", key)
 	}
 	return m.mapper.put(key, buf)
 }
 
 func (m *Mapfs) Append(buf []byte) (int, error) {
 	m.Lock()
 	defer m.Unlock()
 	return m.mapper.add(buf)
 }
 
 func (m *Mapfs) CountMatches(buf []byte) int {
 	m.Lock()
 	defer m.Unlock()
 	return m.mapper.countMatches(buf)
 }
 
 func (m *Mapfs) Sync() error {
 	m.Lock()
 	defer m.Unlock()
 	for i := 0; i < m.mapper.size(); i++ {
 		_, err := m.mapper.get(i)
 		if err == nil {
 			path := fmt.Sprintf("%s/%s%d.txt",
 				m.path, m.prefix, i)
 			err = m.mapper.syncEntry(path, i)
 			if err != nil {
 				return err
 			}
 		}
 	}
 	return nil
 }
 
 func (m *Mapfs) virtSync() error {
 	m.Lock()
 	defer m.Unlock()
 	return m.mapper.virtSync()
 }
 
 func (m *Mapfs) Size() int {
 	m.Lock()
 	defer m.Unlock()
 	return m.mapper.size()
 }
 
 func (m *Mapfs) Empty() bool {
 	m.Lock()
 	defer m.Unlock()
 	if m.mapper.size() == 0 {
 		return true
 	}
 	return false
 }
 
 func (m *Mapfs) String() string {
 	m.Lock()
 	defer m.Unlock()
 	fmt.Printf("*** %s MAP DUMP ***\n", m.name)
 	return m.mapper.string()
 }
 
 func (m *Mapfs) Load() error {
 	_, err := os.Stat(m.path)
 	if err != nil {
 		// Just create the db if it does not exist
 		return os.MkdirAll(m.path, 0755)
 	}
 	walkFunc := func(p string, fi os.FileInfo, err error) error {
 		if fi.IsDir() {
 			return nil
 		}
 		if err != nil {
 			return err
 		}
 		base, ext := path.Base(p), path.Ext(p)
 		entry := base[len(m.prefix) : len(base)-len(ext)]
 		i, err := strconv.Atoi(entry)
 		if err != nil {
 			return err
 		}
 		b, err := m.rawRead(i)
 		if err != nil {
 			return err
 		}
 		err = m.Put(i, b)
 		if err != nil {
 			return err
 		}
 		return nil
 	}
 	err = filepath.Walk(m.path, walkFunc)
 	if err == nil {
 		m.virtSync()
 	}
 	return err
 }
 
 func (m *Mapfs) Rand() ([]byte, int) {
 	m.Lock()
 	defer m.Unlock()
 	idx := rand.Intn(m.mapper.size())
 	for i := 0; i < m.mapper.size(); i++ {
 		if i == idx {
 			b, err := m.mapper.get(i)
 			if err != nil {
 				log.Fatal(err)
 			}
 			return b, i
 		}
 	}
 	return nil, -1
 }