func NewServer(store datastore.Datastore, config clustering.ConfigurationStore,
acctng accounting.AccountingStore, namespace string, readonly bool,
channel, plusChannel RequestChannel, servicers, plusServicers, maxParallelism int,
timeout time.Duration, signature, metrics bool, enterprise bool) (*Server, errors.Error) {
rv := &Server{
datastore: store,
configstore: config,
acctstore: acctng,
namespace: namespace,
readonly: readonly,
channel: channel,
plusChannel: plusChannel,
signature: signature,
timeout: timeout,
metrics: metrics,
done: make(chan bool),
plusDone: make(chan bool),
enterprise: enterprise,
}
// special case handling for the atomic specfic stuff
atomic.StoreInt64(&rv.servicers, int64(servicers))
atomic.StoreInt64(&rv.plusServicers, int64(plusServicers))
store.SetLogLevel(logging.LogLevel())
rv.SetMaxParallelism(maxParallelism)
sys, err := system.NewDatastore(store)
if err != nil {
return nil, err
}
rv.systemstore = sys
return rv, nil
}
func main() {
var someval atomic.AlignedInt64
atomic.StoreInt64(&someval, int64(512))
fmt.Printf(" Value of someval %v", someval)
rval := atomic.LoadInt64(&someval)
fmt.Printf(" Returned val %v", rval)
}
func (this *Server) SetPlusServicers(plusServicers int) {
this.Lock()
defer this.Unlock()
// Stop the current set of servicers
close(this.plusDone)
logging.Infop("SetPlusServicers - waiting for current plusServicers to finish")
this.plusWg.Wait()
// Set plus servicer count and recreate plus servicers
atomic.StoreInt64(&this.plusServicers, int64(plusServicers))
logging.Infop("SetPlusServicers - starting new plusServicers")
// Start new set of servicers
this.plusDone = make(chan bool)
go this.PlusServe()
}
func (this *Server) SetRequestSizeCap(requestSize int) {
if requestSize <= 0 {
requestSize = math.MaxInt32
}
atomic.StoreInt64(&this.requestSize, int64(requestSize))
}
func (this *Server) SetMaxParallelism(maxParallelism int) {
if maxParallelism <= 0 {
maxParallelism = runtime.NumCPU()
}
atomic.StoreInt64(&this.maxParallelism, int64(maxParallelism))
}
func (this *Server) SetKeepAlive(keepAlive int) {
if keepAlive <= 0 {
keepAlive = KEEP_ALIVE_DEFAULT
}
atomic.StoreInt64(&this.keepAlive, int64(keepAlive))
}
func SetPipelineCap(cap int) {
if cap < 1 {
cap = _ITEM_CAP
}
atomic.StoreInt64(&pipelineCap, int64(cap))
}
func init() {
atomic.StoreInt64(&pipelineCap, int64(_ITEM_CAP))
p := value.NewAnnotatedPool(_BATCH_SIZE)
_BATCH_POOL.Store(p)
}
func SetScanCap(cap int64) {
atomic.StoreInt64(&scanCap, cap)
}
