// parseFreeVolumeIndex parse free index from local.
func (s *Store) parseFreeVolumeIndex() (err error) {
var (
i int
id int32
bfile string
ifile string
v *volume.Volume
data []byte
ids []int32
lines []string
bfs []string
ifs []string
)
if data, err = ioutil.ReadAll(s.fvf); err != nil {
log.Errorf("ioutil.ReadAll() error(%v)", err)
return
}
lines = strings.Split(string(data), "\n")
if _, ids, bfs, ifs, err = s.parseIndex(lines); err != nil {
return
}
for i = 0; i < len(bfs); i++ {
id, bfile, ifile = ids[i], bfs[i], ifs[i]
if v, err = newVolume(id, bfile, ifile, s.conf); err != nil {
return
}
v.Close()
s.FreeVolumes = append(s.FreeVolumes, v)
if id = s.fileFreeId(bfile); id > s.FreeId {
s.FreeId = id
}
}
log.V(1).Infof("current max free volume id: %d", s.FreeId)
return
}
// AddFreeVolume add free volumes.
func (s *Store) AddFreeVolume(n int, bdir, idir string) (sn int, err error) {
var (
i int
bfile, ifile string
v *volume.Volume
)
s.flock.Lock()
for i = 0; i < n; i++ {
s.FreeId++
bfile, ifile = s.freeFile(s.FreeId, bdir, idir)
if myos.Exist(bfile) || myos.Exist(ifile) {
continue
}
if v, err = newVolume(volumeFreeId, bfile, ifile, s.conf); err != nil {
// if no free space, delete the file
os.Remove(bfile)
os.Remove(ifile)
break
}
v.Close()
s.FreeVolumes = append(s.FreeVolumes, v)
sn++
}
err = s.saveFreeVolumeIndex()
s.flock.Unlock()
return
}
// Close close the store.
// WARN the global variable store must first set nil and reject any other
// requests then safty close.
func (s *Store) Close() {
var v *volume.Volume
if s.vf != nil {
s.vf.Close()
}
if s.fvf != nil {
s.fvf.Close()
}
if s.Volumes != nil {
for _, v = range s.Volumes {
v.Close()
}
}
if s.zk != nil {
s.zk.Close()
}
return
}
func TestZookeeper(t *testing.T) {
var (
v *volume.Volume
zk *Zookeeper
err error
lines []string
root = "/rack"
rack = "rack-a"
serverId = "store-a"
bfile = "./test/hijohn_1"
ifile = "./test/hijohn_1.idx"
)
os.Remove(bfile)
os.Remove(ifile)
defer os.Remove(bfile)
defer os.Remove(ifile)
if zk, err = NewZookeeper([]string{"localhost:2181"}, time.Second, root, rack, serverId); err != nil {
t.Errorf("Newzookeeper() error(%v)", err)
t.FailNow()
}
zk.DelVolume(1)
zk.DelVolume(2)
if v, err = newVolume(1, bfile, ifile, testConf); err != nil {
t.Errorf("NewVolume() error(%v)", err)
t.FailNow()
}
v.Close()
if err = zk.AddVolume(v); err != nil {
t.Errorf("zk.AddVolume() error(%v)", err)
t.FailNow()
}
v.Id = 2
if err = zk.AddVolume(v); err != nil {
t.Errorf("zk.AddVolume() error(%v)", err)
t.FailNow()
}
if lines, err = zk.Volumes(); err != nil {
t.Errorf("zk.Volumes() error(%v)", err)
t.FailNow()
}
if len(lines) != 2 || lines[0] != fmt.Sprintf("%s,%s,%d", bfile, ifile, 1) || lines[1] != fmt.Sprintf("%s,%s,%d", bfile, ifile, 2) {
t.FailNow()
}
}
// CompactVolume compact a super block to another file.
func (s *Store) CompactVolume(id int32) (err error) {
var (
v, nv *volume.Volume
bdir, idir string
)
// try check volume
if v = s.Volumes[id]; v != nil {
if v.Compact {
return errors.ErrVolumeInCompact
}
} else {
return errors.ErrVolumeExist
}
// find a free volume
if nv, err = s.freeVolume(id); err != nil {
return
}
// no lock here, Compact is no side-effect
if err = v.StartCompact(nv); err != nil {
v.StopCompact(nil)
return
}
s.vlock.Lock()
if v = s.Volumes[id]; v != nil {
if err = v.StopCompact(nv); err == nil {
// WARN no need update volumes map, use same object, only update
// zookeeper the local index cause the block and index file changed.
if err = s.saveVolumeIndex(); err == nil {
err = s.zk.SetVolume(v)
}
}
} else {
err = errors.ErrVolumeExist
}
s.vlock.Unlock()
if err == nil {
// nv now has old block/index
nv.Close()
nv.Destroy()
bdir, idir = filepath.Dir(nv.Block.File), filepath.Dir(nv.Indexer.File)
_, err = s.AddFreeVolume(1, bdir, idir)
}
return
}
// DelVolume del the volume by volume id.
func (s *Store) DelVolume(id int32) (err error) {
var v *volume.Volume
s.vlock.Lock()
if v = s.Volumes[id]; v != nil {
if !v.Compact {
s.delVolume(id)
if err = s.saveVolumeIndex(); err == nil {
err = s.zk.DelVolume(id)
}
} else {
err = errors.ErrVolumeInCompact
}
} else {
err = errors.ErrVolumeNotExist
}
s.vlock.Unlock()
if err == nil {
v.Close()
}
return
}
