// NewAOF ...
func NewAOF(path string) *AOF {
file, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0600)
utils.PanicOnError(err)
rdr := bufio.NewReader(file)
wtr := bufio.NewWriter(file)
return &AOF{file, bufio.NewReadWriter(rdr, wtr), sync.RWMutex{}}
}
func parseConfigTOML() *Config {
cfg := &Config{}
if _, err := toml.Decode(defaultTomlConfig, &cfg); err != nil {
utils.PanicOnError(err)
}
configPath := os.Getenv("SKIZZE_CONFIG")
if configPath != "" {
_, err := os.Open(configPath)
if err != nil {
logger.Warningf("Unable to find config file, using defaults")
return cfg
}
if _, err := toml.DecodeFile(configPath, &cfg); err != nil {
logger.Warningf("Error parsing config file, using defaults")
}
}
// make paths absolute
infodir, err := utils.FullPath(cfg.InfoDir)
if err != nil {
panic(err)
}
datadir, err := utils.FullPath(cfg.DataDir)
if err != nil {
panic(err)
}
cfg.InfoDir = infodir
cfg.DataDir = datadir
return cfg
}
func parseConfigTOML() *Config {
configPath := os.Getenv("SKZ_CONFIG")
if configPath == "" {
path, err := os.Getwd()
utils.PanicOnError(err)
path, err = filepath.Abs(path)
utils.PanicOnError(err)
configPath = filepath.Join(path, "src/config/default.toml")
}
_, err := os.Open(configPath)
utils.PanicOnError(err)
config = &Config{}
if _, err := toml.DecodeFile(configPath, &config); err != nil {
utils.PanicOnError(err)
}
return config
}
func (server *serverStruct) replay() {
fmt.Println("Replaying ...")
for {
e, err := server.storage.Read()
if err != nil && err.Error() == "EOF" {
break
} else {
utils.PanicOnError(err)
}
switch e.Op() {
case storage.Add:
req := &pb.AddRequest{}
err = proto.Unmarshal(e.Args(), req)
utils.PanicOnError(err)
if _, err := server.add(context.Background(), req); err != nil {
fmt.Println(err)
}
case storage.CreateSketch:
sketch := unmarshalSketch(e)
if _, err := server.createSketch(context.Background(), sketch); err != nil {
fmt.Println(err)
}
case storage.DeleteSketch:
sketch := unmarshalSketch(e)
if _, err := server.deleteSketch(context.Background(), sketch); err != nil {
fmt.Println(err)
}
case storage.CreateDom:
dom := unmarshalDom(e)
if _, err := server.createDomain(context.Background(), dom); err != nil {
fmt.Println(err)
}
case storage.DeleteDom:
dom := unmarshalDom(e)
if _, err := server.deleteDomain(context.Background(), dom); err != nil {
fmt.Println(err)
}
default:
continue
}
}
}
func (server *serverStruct) replay() {
logger.Infof("Replaying ...")
for {
e, err := server.storage.Read()
if err != nil && err.Error() == "EOF" {
break
} else {
utils.PanicOnError(err)
}
switch e.OpType() {
case storage.Add:
req := &pb.AddRequest{}
err = proto.Unmarshal(e.RawMsg(), req)
utils.PanicOnError(err)
if _, err := server.add(context.Background(), req); err != nil {
logger.Errorf("an error has occurred while replaying: %s", err.Error())
}
case storage.CreateSketch:
sketch := unmarshalSketch(e)
if _, err := server.createSketch(context.Background(), sketch); err != nil {
logger.Errorf("an error has occurred while replaying: %s", err.Error())
}
case storage.DeleteSketch:
sketch := unmarshalSketch(e)
if _, err := server.deleteSketch(context.Background(), sketch); err != nil {
logger.Errorf("an error has occurred while replaying: %s", err.Error())
}
case storage.CreateDom:
dom := unmarshalDom(e)
if _, err := server.createDomain(context.Background(), dom); err != nil {
logger.Errorf("an error has occurred while replaying: %s", err.Error())
}
case storage.DeleteDom:
dom := unmarshalDom(e)
if _, err := server.deleteDomain(context.Background(), dom); err != nil {
logger.Errorf("an error has occurred while replaying: %s", err.Error())
}
default:
continue
}
}
}
// GetConfig returns a singleton Configuration
func GetConfig() *Config {
if config == nil {
config = parseConfigTOML()
usr, err := user.Current()
utils.PanicOnError(err)
dir := usr.HomeDir
infoDir := strings.TrimSpace(os.Getenv("SKZ_INFO_DIR"))
if len(infoDir) == 0 {
if config.InfoDir[:2] == "~/" {
infoDir = strings.Replace(config.InfoDir, "~", dir, 1)
}
}
dataDir := strings.TrimSpace(os.Getenv("SKZ_DATA_DIR"))
if len(dataDir) == 0 {
if config.DataDir[:2] == "~/" {
dataDir = strings.Replace(config.DataDir, "~", dir, 1)
}
}
portInt, err := strconv.Atoi(strings.TrimSpace(os.Getenv("SKZ_PORT")))
port := uint(portInt)
if err != nil {
port = config.Port
}
saveThresholdSecondsInt, err := strconv.Atoi(strings.TrimSpace(os.Getenv("SKZ_SAVE_TRESHOLD_SECS")))
saveThresholdSeconds := uint(saveThresholdSecondsInt)
if err != nil {
saveThresholdSeconds = config.SaveThresholdSeconds
}
if saveThresholdSeconds < 3 {
saveThresholdSeconds = 3
}
config = &Config{
infoDir,
dataDir,
config.SliceSize,
config.CacheSize,
config.SliceCacheSize,
port,
saveThresholdSeconds,
}
}
return config
}
// NewAOF ...
func NewAOF(path string) *AOF {
file, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0600)
utils.PanicOnError(err)
rdr := bufio.NewReader(file)
wtr := bufio.NewWriter(file)
inChan := make(chan *Entry, 100)
tickChan := time.NewTicker(time.Second).C
return &AOF{
file: file,
buffer: bufio.NewReadWriter(rdr, wtr),
lock: sync.RWMutex{},
inChan: inChan,
tickChan: tickChan,
}
}
func parseConfigTOML() *Config {
cfg := &Config{}
if _, err := toml.Decode(defaultTomlConfig, &cfg); err != nil {
utils.PanicOnError(err)
}
configPath := os.Getenv("SKIZZE_CONFIG")
if configPath != "" {
_, err := os.Open(configPath)
if err != nil {
logger.Warningf("Unable to find config file, using defaults")
return cfg
}
if _, err := toml.DecodeFile(configPath, &cfg); err != nil {
logger.Warningf("Error parsing config file, using defaults")
}
}
return cfg
}
// SetupTests ...
func SetupTests() {
dataDir := fmt.Sprintf("/tmp/skizze_storage_data_test")
infoDir := fmt.Sprintf("/tmp/skizze_storage_info_test")
// Cleanup any previously aborted test runs
utils.PanicOnError(os.RemoveAll(dataDir))
utils.PanicOnError(os.RemoveAll(infoDir))
utils.PanicOnError(os.Setenv("SKIZZE_DATA_DIR", dataDir))
utils.PanicOnError(os.Setenv("SKIZZE_INFO_DIR", infoDir))
utils.PanicOnError(os.Mkdir(os.Getenv("SKIZZE_DATA_DIR"), 0777))
utils.PanicOnError(os.Mkdir(os.Getenv("SKIZZE_INFO_DIR"), 0777))
path, err := os.Getwd()
utils.PanicOnError(err)
path = filepath.Dir(path)
configPath := filepath.Join(path, "config/default.toml")
utils.PanicOnError(os.Setenv("SKIZZE_CONFIG", configPath))
config.DataDir = dataDir
config.InfoDir = infoDir
}
func main() {
var port uint
flag.UintVar(&port, "p", 3596, "specifies the port for Skizze to run on")
flag.Parse()
//TODO: Add arguments for dataDir and infoDir
err := os.Setenv("SKIZZE_PORT", strconv.Itoa(int(port)))
utils.PanicOnError(err)
logger.Infof("Starting Skizze...")
logger.Infof("Using data dir: %s", config.GetConfig().DataDir)
//server, err := server.New()
//utils.PanicOnError(err)
//server.Run()
mngr := manager.NewManager()
if p, err := strconv.Atoi(os.Getenv("SKIZZE_PORT")); err == nil {
server.Run(mngr, uint(p))
}
}
func unmarshalDom(e *storage.Entry) *pb.Domain {
dom := &pb.Domain{}
err := proto.Unmarshal(e.Args(), dom)
utils.PanicOnError(err)
return dom
}
func unmarshalSketch(e *storage.Entry) *pb.Sketch {
sketch := &pb.Sketch{}
err := proto.Unmarshal(e.Args(), sketch)
utils.PanicOnError(err)
return sketch
}
// TearDownTests ...
func TearDownTests() {
utils.PanicOnError(os.RemoveAll(os.Getenv("SKIZZE_DATA_DIR")))
utils.PanicOnError(os.RemoveAll(os.Getenv("SKIZZE_INFO_DIR")))
time.Sleep(50 * time.Millisecond)
config.Reset()
}
