EndGame v3

sourcecode/gobalance/pkg/onionbalance/param.go

@@ -0,0 +1,529 @@
+package onionbalance
+
+import (
+	"sync"
+	"time"
+)
+
+var (
+	params     *Param
+	paramsOnce sync.Once
+)
+
+func Params() *Param {
+	paramsOnce.Do(func() {
+		params = new(Param)
+		params.adaptWg = &sync.WaitGroup{}
+		params.FetchChannel = make(chan bool)
+		params.PublishChannel = make(chan bool)
+	})
+	return params
+}
+
+type Param struct {
+	sync.Mutex
+
+	initialCallbackDelay            int64
+	fetchDescriptorFrequency        int64
+	publishDescriptorCheckFrequency int64
+	frontendDescriptorLifetime      int64
+	instanceDescriptorTooOld        int64
+	hsdirNReplicas                  int
+
+	hsdirSpreadStore   int
+	nIntrosPerInstance int
+	nIntrosWanted      int
+	tightTimings       bool
+	newnymSleep        time.Duration
+
+	// NInstances configures on boot. Don't change default value.
+	nInstances    int64
+	nDescriptors  int64
+	nIntroduction int64
+
+	adaptEnabled   bool
+	adaptStrict    bool
+	adaptWg        *sync.WaitGroup
+	adaptWgCount   int64
+	adaptWgEnabled bool
+	FetchChannel   chan bool
+	PublishChannel chan bool
+
+	adaptDistinctDescriptors int64
+	adaptStartTime           int64
+	adaptDelay               int64
+	adaptHSDirCount          int64
+	adaptHSDirFailureCount   int64
+
+	adaptCount            int64
+	adaptUp               int64
+	adaptDown             int64
+	adaptDownNoDescriptor int64
+	adaptDownInstanceOld  int64
+	adaptIntroChanged     int64
+	adaptDescriptorFail   int64
+	adaptFetchFail        int64
+
+	adaptForcePublish int64
+
+	adaptShuffle int64
+
+	dirStart int
+	dirEnd   int
+}
+
+func (p *Param) InitialCallbackDelay() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.initialCallbackDelay
+}
+
+func (p *Param) SetInitialCallbackDelay(initialCallbackDelay int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.initialCallbackDelay = initialCallbackDelay
+}
+
+func (p *Param) FetchDescriptorFrequency() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.fetchDescriptorFrequency
+}
+
+func (p *Param) SetFetchDescriptorFrequency(fetchDescriptorFrequency int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.fetchDescriptorFrequency = fetchDescriptorFrequency
+}
+
+func (p *Param) PublishDescriptorCheckFrequency() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.publishDescriptorCheckFrequency
+}
+
+func (p *Param) SetPublishDescriptorCheckFrequency(publishDescriptorCheckFrequency int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.publishDescriptorCheckFrequency = publishDescriptorCheckFrequency
+}
+
+func (p *Param) FrontendDescriptorLifetime() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.frontendDescriptorLifetime
+}
+
+func (p *Param) SetFrontendDescriptorLifetime(frontendDescriptorLifetime int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.frontendDescriptorLifetime = frontendDescriptorLifetime
+}
+
+func (p *Param) InstanceDescriptorTooOld() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.instanceDescriptorTooOld
+}
+
+func (p *Param) SetInstanceDescriptorTooOld(instanceDescriptorTooOld int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.instanceDescriptorTooOld = instanceDescriptorTooOld
+}
+
+func (p *Param) HsdirNReplicas() int {
+	p.Lock()
+	defer p.Unlock()
+	return p.hsdirNReplicas
+}
+
+func (p *Param) SetHsdirNReplicas(hsdirNReplicas int) {
+	p.Lock()
+	defer p.Unlock()
+	p.hsdirNReplicas = hsdirNReplicas
+}
+
+func (p *Param) HsdirSpreadStore() int {
+	p.Lock()
+	defer p.Unlock()
+	return p.hsdirSpreadStore
+}
+
+func (p *Param) SetHsdirSpreadStore(hsdirSpreadStore int) {
+	p.Lock()
+	defer p.Unlock()
+	p.hsdirSpreadStore = hsdirSpreadStore
+}
+
+func (p *Param) NIntrosPerInstance() int {
+	p.Lock()
+	defer p.Unlock()
+	return p.nIntrosPerInstance
+}
+
+func (p *Param) SetNIntrosPerInstance(nIntrosPerInstance int) {
+	p.Lock()
+	defer p.Unlock()
+	p.nIntrosPerInstance = nIntrosPerInstance
+}
+
+func (p *Param) NIntrosWanted() int {
+	p.Lock()
+	defer p.Unlock()
+	return p.nIntrosWanted
+}
+
+func (p *Param) SetNIntrosWanted(nIntrosWanted int) {
+	p.Lock()
+	defer p.Unlock()
+	p.nIntrosWanted = nIntrosWanted
+}
+
+func (p *Param) TightTimings() bool {
+	p.Lock()
+	defer p.Unlock()
+	return p.tightTimings
+}
+
+func (p *Param) SetTightTimings(tightTimings bool) {
+	p.Lock()
+	defer p.Unlock()
+	p.tightTimings = tightTimings
+}
+
+func (p *Param) NewnymSleep() time.Duration {
+	p.Lock()
+	defer p.Unlock()
+	return p.newnymSleep
+}
+
+func (p *Param) SetNewnymSleep(newnymSleep time.Duration) {
+	p.Lock()
+	defer p.Unlock()
+	p.newnymSleep = newnymSleep
+}
+
+func (p *Param) NInstances() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.nInstances
+}
+
+func (p *Param) SetNInstances(nInstances int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.nInstances = nInstances
+}
+
+func (p *Param) NDescriptors() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.nDescriptors
+}
+
+func (p *Param) SetNDescriptors(nDescriptors int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.nDescriptors = nDescriptors
+}
+
+func (p *Param) NIntroduction() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.nIntroduction
+}
+
+func (p *Param) SetNIntroduction(nIntroduction int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.nIntroduction = nIntroduction
+}
+
+func (p *Param) AdaptEnabled() bool {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptEnabled
+}
+
+func (p *Param) SetAdaptEnabled(adaptEnabled bool) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptEnabled = adaptEnabled
+}
+
+func (p *Param) AdaptStrict() bool {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptStrict
+}
+
+func (p *Param) SetAdaptStrict(adaptStrict bool) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptStrict = adaptStrict
+}
+
+func (p *Param) AdaptWg() *sync.WaitGroup {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptWg
+}
+
+func (p *Param) SetAdaptWg(adaptWg *sync.WaitGroup) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptWg = adaptWg
+}
+
+func (p *Param) AdaptWgCount() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptWgCount
+}
+
+func (p *Param) SetAdaptWgCount(adaptWgCount int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptWgCount = adaptWgCount
+}
+
+func (p *Param) AdaptWgEnabled() bool {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptWgEnabled
+}
+
+func (p *Param) SetAdaptWgEnabled(adaptWgEnabled bool) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptWgEnabled = adaptWgEnabled
+}
+
+func (p *Param) AdaptDistinctDescriptors() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptDistinctDescriptors
+}
+
+func (p *Param) SetAdaptDistinctDescriptors(adaptDistinctDescriptors int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptDistinctDescriptors = adaptDistinctDescriptors
+}
+
+func (p *Param) AdaptStartTime() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptStartTime
+}
+
+func (p *Param) SetAdaptStartTime(adaptStartTime int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptStartTime = adaptStartTime
+}
+
+func (p *Param) AdaptDelay() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptDelay
+}
+
+func (p *Param) SetAdaptDelay(adaptDelay int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptDelay = adaptDelay
+}
+
+func (p *Param) AdaptHSDirCount() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptHSDirCount
+}
+
+func (p *Param) SetAdaptHSDirCount(adaptHSDirCount int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptHSDirCount = adaptHSDirCount
+}
+
+func (p *Param) AdaptHSDirFailureCount() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptHSDirFailureCount
+}
+
+func (p *Param) SetAdaptHSDirFailureCount(adaptHSDirFailureCount int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptHSDirFailureCount = adaptHSDirFailureCount
+}
+
+func (p *Param) AdaptCount() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptCount
+}
+
+func (p *Param) SetAdaptCount(adaptCount int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptCount = adaptCount
+}
+
+func (p *Param) AdaptUp() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptUp
+}
+
+func (p *Param) SetAdaptUp(adaptUp int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptUp = adaptUp
+}
+
+func (p *Param) AdaptDown() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptDown
+}
+
+func (p *Param) SetAdaptDown(adaptDown int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptDown = adaptDown
+}
+
+func (p *Param) AdaptDownNoDescriptor() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptDownNoDescriptor
+}
+
+func (p *Param) SetAdaptDownNoDescriptor(adaptDownNoDescriptor int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptDownNoDescriptor = adaptDownNoDescriptor
+}
+
+func (p *Param) AdaptDownInstanceOld() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptDownInstanceOld
+}
+
+func (p *Param) SetAdaptDownInstanceOld(adaptDownInstanceOld int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptDownInstanceOld = adaptDownInstanceOld
+}
+
+func (p *Param) AdaptIntroChanged() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptIntroChanged
+}
+
+func (p *Param) SetAdaptIntroChanged(adaptIntroChanged int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptIntroChanged = adaptIntroChanged
+}
+
+func (p *Param) AdaptDescriptorFail() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptDescriptorFail
+}
+
+func (p *Param) SetAdaptDescriptorFail(adaptDescriptorFail int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptDescriptorFail = adaptDescriptorFail
+}
+
+func (p *Param) AdaptFetchFail() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptFetchFail
+}
+
+func (p *Param) SetAdaptFetchFail(adaptFetchFail int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptFetchFail = adaptFetchFail
+}
+
+func (p *Param) AdaptForcePublish() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptForcePublish
+}
+
+func (p *Param) SetAdaptForcePublish(adaptForcePublish int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptForcePublish = adaptForcePublish
+}
+
+func (p *Param) AdaptShuffle() int64 {
+	p.Lock()
+	defer p.Unlock()
+	return p.adaptShuffle
+}
+
+func (p *Param) SetAdaptShuffle(adaptShuffle int64) {
+	p.Lock()
+	defer p.Unlock()
+	p.adaptShuffle = adaptShuffle
+}
+
+func (p *Param) DirStart() int {
+	p.Lock()
+	defer p.Unlock()
+	return p.dirStart
+}
+
+func (p *Param) SetDirStart(dirStart int) {
+	p.Lock()
+	defer p.Unlock()
+	p.dirStart = dirStart
+}
+
+func (p *Param) DirEnd() int {
+	p.Lock()
+	defer p.Unlock()
+	return p.dirEnd
+}
+
+func (p *Param) SetDirEnd(dirEnd int) {
+	p.Lock()
+	defer p.Unlock()
+	p.dirEnd = dirEnd
+}
+
+//const (
+//	// FrontendDescriptorLifetime How long should we keep a frontend descriptor before we expire it (in
+//	// seconds)?
+//	FrontendDescriptorLifetime        = 60 * 60
+//	FrontendDescriptorLifetimeTestnet = 20
+//
+//	// HsdirNReplicas Number of replicas per descriptor
+//	HsdirNReplicas = 2
+//
+//	// HsdirSpreadStore How many uploads per replica
+//	// [TODO: Get these from the consensus instead of hardcoded]
+//	HsdirSpreadStore = 4
+//
+//	// InstanceDescriptorTooOld If we last received a descriptor for this instance more than
+//	// INSTANCE_DESCRIPTOR_TOO_OLD seconds ago, consider the instance to be down.
+//	InstanceDescriptorTooOld = 60 * 60
+//
+//	// NIntrosPerInstance How many intros should we use from each instance in the final frontend
+//	// descriptor?
+//	// [TODO: This makes no attempt to hide the use of onionbalance. In the future we
+//	// should be smarter and sneakier here.]
+//	NIntrosPerInstance = 2
+//)