Ejemplo n.º 1
0
func TestLoadPEMNoFile(t *testing.T) {
	inst := NewCAPool(util.NewLogger("fatal"))

	err := inst.LoadPEM("iugvWROCBWqufbhOIGWfc9qgiucwb")

	assert.NotNil(t, err)
}
Ejemplo n.º 2
0
func TestStartStop(t *testing.T) {
	logger := util.NewLogger("error")
	inst := NewKVStore(logger)
	inst.Start()
	assert.True(t, inst.running)
	inst.Stop()
	time.Sleep(1000 * time.Millisecond)
	assert.False(t, inst.running)
}
Ejemplo n.º 3
0
func TestGetSet(t *testing.T) {
	logger := util.NewLogger("error")
	inst := NewKVStore(logger)

	data := []byte{0, 1, 2}
	inst.Set("one", data, 1, nil)

	val, flag, ok := inst.Get("one")
	assert.Equal(t, val, data)
	assert.Equal(t, flag, int16(1))
	assert.True(t, ok)
	val, flag, ok = inst.Get("two")
	assert.Nil(t, val)
	assert.Equal(t, flag, int16(0))
	assert.False(t, ok)

}
Ejemplo n.º 4
0
func TestInit(t *testing.T) {
	logger := util.NewLogger("error")
	inst := NewKVStore(logger)

	inst.Init()
}
Ejemplo n.º 5
0
func main() {

	// Load Configuration
	config := config.NewConfig()

	// Start logging
	logger := util.NewLogger(*config.LogLevel)

	// Validate Configuration
	if i, errs := config.Validate(); !i {
		for _, err := range errs {
			logger.Error("Config", err.Error())
		}
		os.Exit(-1)
		logger.Fatal("Main", "Bad Configuration, Exiting")
	}

	// Key/Value Store
	kv := kvstore.NewKVStore(logger)
	kv.Init()
	kv.Start()

	// Banner
	logger.Raw("Main", "---------------------------------------")
	logger.Raw("Main", "Trinity DB - v%s", VERSION)
	logger.Raw("Main", "---------------------------------------")

	// Config Debug
	logger.Debug("Config", "Nodes: %s", config.Nodes.String())
	logger.Debug("Config", "Certificate: %s", *config.Certificate)
	logger.Debug("Config", "Port: %d", *config.Port)
	logger.Debug("Config", "LogLevel: %s (%d)", *config.LogLevel, logger.LogLevel)

	// CA
	capool := network.NewCAPool(logger)
	err := capool.LoadPEM(*config.CA)
	if err != nil {
		logger.Error("Main", "Cannot Load CA '%s': %s", *config.CA, err.Error())
		os.Exit(-1)
	}
	logger.Debug("Main", "CA Certiticate Loaded")

	// Server
	svr := network.NewTLSServer(logger, capool, kv, *config.HostAddr)
	logger.Info("Main", "Trinity Node ID %02X", svr.ServerNode.ID)

	// Certificate
	err = svr.LoadPEMCert(*config.Certificate, *config.Certificate)
	if err != nil {
		logger.Error("Main", "Cannot Load Certificate '%s': %s", *config.Certificate, err.Error())
		os.Exit(-1)
	}
	logger.Debug("Main", "Cert Loaded")

	// Listen
	err = svr.Listen(uint16(*config.Port))
	if err != nil {
		logger.Error("Main", "Cannot Start Server: %s", err.Error())
		os.Exit(-1)
	}

	var memcache *network.MemcacheServer

	// Memcache
	if *config.MemcacheEnabled {
		memcache = network.NewMemcacheServer(logger, *config.MemcachePort, svr)
		memcache.Init()
		memcache.Start()
	}

	for _, remoteAddr := range config.Nodes {
		svr.ConnectTo(remoteAddr)
	}

	TrinityMainLoop(svr, logger)

	// Shutdown Memcache
	if memcache != nil {
		memcache.Stop()
	}

	// Shutdown Server and wait for close
	svr.Stop()
	_ = <-svr.StatusChannel

	// Shutdown KV Store
	kv.Stop()

	logger.Info("Main", "Shutdown Complete, exiting")
	os.Exit(0)
}