public AccessSafely AfterCompleting <TState, TSource>(int times)
{
_access = AccessSafely.AfterCompleting(times);
_access
.WritingWith <int>("confirmDispatchedResultedIn", increment => _confirmDispatchedResultedIn.AddAndGet(increment))
.ReadingWith("confirmDispatchedResultedIn", () => _confirmDispatchedResultedIn.Get())
.WritingWith <StoreData <TSource> >("writeStoreData", data =>
{
_writeObjectResultedIn.AddAndGet(data.ResultedIn);
_objectWriteResult.Set(data.Result);
_objectWriteAccumulatedResults.Enqueue(data.Result);
_objectState.Set(data.State);
data.Sources.ForEach(source => _sources.Enqueue(source));
_metadataHolder.Set(data.Metadata);
if (data.ErrorCauses != null)
{
_errorCauses.Enqueue(data.ErrorCauses);
}
})
.WritingWith <StoreData <TSource> >("readStoreData", data =>
{
_readObjectResultedIn.AddAndGet(data.ResultedIn);
_objectReadResult.Set(data.Result);
_objectWriteAccumulatedResults.Enqueue(data.Result);
_objectState.Set(data.State);
data.Sources.ForEach(source => _sources.Enqueue(source));
_metadataHolder.Set(data.Metadata);
if (data.ErrorCauses != null)
{
_errorCauses.Enqueue(data.ErrorCauses);
}
})
.ReadingWith("readObjectResultedIn", () => _readObjectResultedIn.Get())
.ReadingWith("objectReadResult", () => _objectReadResult.Get())
.ReadingWith("objectWriteResult", () => _objectWriteResult.Get())
.ReadingWith("objectWriteAccumulatedResults", () =>
{
_objectWriteAccumulatedResults.TryDequeue(out var result);
return(result);
})
.ReadingWith("objectWriteAccumulatedResultsCount", () => _objectWriteAccumulatedResults.Count)
.ReadingWith("metadataHolder", () => _metadataHolder.Get())
.ReadingWith("objectState", () => (TState)_objectState.Get())
.ReadingWith("sources", () =>
{
_sources.TryDequeue(out var result);
return(result);
})
.ReadingWith("errorCauses", () =>
{
_errorCauses.TryDequeue(out var result);
return(result);
})
.ReadingWith("errorCausesCount", () => _errorCauses.Count)
.ReadingWith("writeObjectResultedIn", () => _writeObjectResultedIn.Get());
return(_access);
}
internal virtual void SetErrorState(Exception t)
{
CheckErrorState();
Log.Error("Worker " + name + " failed.", t);
state.Set(TestAppendSnapshotTruncate.Worker.State.Error);
thrown = t;
}
/// <inheritdoc />
public void ReadResultedIn <TState>(IOutcome <StorageException, Result> outcome, string?id, TState state, int stateVersion, Metadata?metadata, object? @object)
{
outcome.AndThen(result =>
{
_readBundles.Add(new TypedStateBundle(id, state, stateVersion, metadata));
return(result);
})
.Otherwise(cause =>
{
_readOutcome.Set(outcome);
_success.Set(false);
return(cause.Result);
});
}
public void Run()
{
while (running)
{
try
{
Thread.Sleep(reloadInterval);
}
catch (Exception)
{
}
//NOP
if (running && NeedsReload())
{
try
{
trustManagerRef.Set(LoadTrustManager());
}
catch (Exception ex)
{
Log.Warn("Could not load truststore (keep using existing one) : " + ex.ToString()
, ex);
}
}
}
}
public AccessSafely AfterCompleting(int times)
{
Access = AccessSafely.AfterCompleting(times);
Access
.WritingWith <int>("confirmDispatched", i => _confirmDispatchedResultedIn.IncrementAndGet())
.WritingWith <int>("readTextResultedIn", i => _readTextResultedIn.IncrementAndGet())
.WritingWith <int>("writeTextResultedIn", i => _writeTextResultedIn.IncrementAndGet())
.WritingWith <Result>("textReadResult", i => _textReadResult.Set(i))
.WritingWith <Result>("textWriteResult", i => _textWriteResult.Set(i))
.WritingWith <object>("stateHolder", i => _stateHolder.Set(i))
.WritingWith <Result>("textWriteAccumulatedResults", i => _textWriteAccumulatedResults.Enqueue(i))
.WritingWith <Metadata>("metadataHolder", i => _metadataHolder.Set(i))
.WritingWith <StorageException>("errorCauses", i => _errorCauses.Enqueue(i))
.ReadingWith("confirmDispatched", () => _confirmDispatchedResultedIn.Get())
.ReadingWith("readTextResultedIn", () => _readTextResultedIn.IncrementAndGet())
.ReadingWith("writeTextResultedIn", () => _writeTextResultedIn.IncrementAndGet())
.ReadingWith("textReadResult", () => _textReadResult.Get())
.ReadingWith("textWriteResult", () => _textWriteResult.Get())
.ReadingWith("stateHolder", () => _stateHolder.Get())
.ReadingWith("textWriteAccumulatedResults", () =>
{
_textWriteAccumulatedResults.TryDequeue(out var writeResult);
return(writeResult);
})
.ReadingWith("metadataHolder", () => _metadataHolder.Get())
.ReadingWith("errorCauses", () =>
{
_errorCauses.TryDequeue(out var exception);
return(exception);
});
return(Access);
}
/// <summary>Initialize a reference to an on-disk object directory.</summary>
/// <remarks>Initialize a reference to an on-disk object directory.</remarks>
/// <param name="cfg">configuration this directory consults for write settings.</param>
/// <param name="dir">the location of the <code>objects</code> directory.</param>
/// <param name="alternatePaths">a list of alternate object directories</param>
/// <param name="fs">
/// the file system abstraction which will be necessary to perform
/// certain file system operations.
/// </param>
/// <exception cref="System.IO.IOException">an alternate object cannot be opened.</exception>
public ObjectDirectory(Config cfg, FilePath dir, FilePath[] alternatePaths, FS fs
)
{
config = cfg;
objects = dir;
infoDirectory = new FilePath(objects, "info");
packDirectory = new FilePath(objects, "pack");
alternatesFile = new FilePath(infoDirectory, "alternates");
cachedPacksFile = new FilePath(infoDirectory, "cached-packs");
packList = new AtomicReference <ObjectDirectory.PackList>(NO_PACKS);
cachedPacks = new AtomicReference <ObjectDirectory.CachedPackList>();
unpackedObjectCache = new UnpackedObjectCache();
this.fs = fs;
alternates = new AtomicReference <FileObjectDatabase.AlternateHandle[]>();
if (alternatePaths != null)
{
FileObjectDatabase.AlternateHandle[] alt;
alt = new FileObjectDatabase.AlternateHandle[alternatePaths.Length];
for (int i = 0; i < alternatePaths.Length; i++)
{
alt[i] = OpenAlternate(alternatePaths[i]);
}
alternates.Set(alt);
}
}
public virtual void TestCloseTwice()
{
DistributedFileSystem fs = cluster.GetFileSystem();
FSDataOutputStream os = fs.Create(new Path("/test"));
DFSOutputStream dos = (DFSOutputStream)Whitebox.GetInternalState(os, "wrappedStream"
);
AtomicReference <IOException> ex = (AtomicReference <IOException>)Whitebox.GetInternalState
(dos, "lastException");
NUnit.Framework.Assert.AreEqual(null, ex.Get());
dos.Close();
IOException dummy = new IOException("dummy");
ex.Set(dummy);
try
{
dos.Close();
}
catch (IOException e)
{
NUnit.Framework.Assert.AreEqual(e, dummy);
}
NUnit.Framework.Assert.AreEqual(null, ex.Get());
dos.Close();
}
public void Refresh()
{
try
{
Counters <Item> itemPreferenceCounts = new Counters <Item>();
lock (this)
{
int numUsers = 0;
foreach (User user in dataModel.GetUsers())
{
Preference[] prefs = user.GetPreferencesAsArray();
foreach (Preference preference in prefs)
{
itemPreferenceCounts.Increment(preference.Item);
}
numUsers++;
}
Dictionary <Item, double> newIufFactors =
new Dictionary <Item, double>(1 + (4 * itemPreferenceCounts.Count) / 3);
double logFactor = Math.Log(logBase);
foreach (KeyValuePair <Item, MutableInteger> entry in itemPreferenceCounts.Map)
{
int count = entry.Value.Value;
newIufFactors.Add(entry.Key,
Math.Log((double)numUsers / (double)count) / logFactor);
}
iufFactors.Set(newIufFactors /* readonly */);
}
}
catch (TasteException dme)
{
log.Warn("Unable to refresh", dme);
}
}
public override void Read(AtomicReference <ReaderWriterState <T> > state, Action <T> dataCallback)
{
dataStorage.Read(data =>
{
dataCallback?.Invoke(data);
state.Set(new DataWasReceivedState <T>(dataStorage));
});
}
/// <summary>
/// Clears all recorded values.
/// </summary>
public void Clear()
{
sample.Clear();
count.Set(0);
max.Set(Int64.MinValue);
min.Set(Int64.MaxValue);
sum.Set(0);
variance.Set(new double[] { -1, 0 });
}
public virtual void TestDatanodeDetect()
{
AtomicReference <DatanodeProtocolProtos.BlockReportRequestProto> request = new AtomicReference
<DatanodeProtocolProtos.BlockReportRequestProto>();
// just capture the outgoing PB
DatanodeProtocolPB mockProxy = Org.Mockito.Mockito.Mock <DatanodeProtocolPB>();
Org.Mockito.Mockito.DoAnswer(new _Answer_205(request)).When(mockProxy).BlockReport
(Matchers.Any <RpcController>(), Matchers.Any <DatanodeProtocolProtos.BlockReportRequestProto
>());
DatanodeProtocolClientSideTranslatorPB nn = new DatanodeProtocolClientSideTranslatorPB
(mockProxy);
DatanodeRegistration reg = DFSTestUtil.GetLocalDatanodeRegistration();
NamespaceInfo nsInfo = new NamespaceInfo(1, "cluster", "bp", 1);
reg.SetNamespaceInfo(nsInfo);
Replica r = new FinalizedReplica(new Block(1, 2, 3), null, null);
BlockListAsLongs bbl = BlockListAsLongs.Encode(Sharpen.Collections.Singleton(r));
DatanodeStorage storage = new DatanodeStorage("s1");
StorageBlockReport[] sbr = new StorageBlockReport[] { new StorageBlockReport(storage
, bbl) };
// check DN sends new-style BR
request.Set(null);
nsInfo.SetCapabilities(NamespaceInfo.Capability.StorageBlockReportBuffers.GetMask
());
nn.BlockReport(reg, "pool", sbr, new BlockReportContext(1, 0, Runtime.NanoTime())
);
DatanodeProtocolProtos.BlockReportRequestProto proto = request.Get();
NUnit.Framework.Assert.IsNotNull(proto);
NUnit.Framework.Assert.IsTrue(proto.GetReports(0).GetBlocksList().IsEmpty());
NUnit.Framework.Assert.IsFalse(proto.GetReports(0).GetBlocksBuffersList().IsEmpty
());
// back up to prior version and check DN sends old-style BR
request.Set(null);
nsInfo.SetCapabilities(NamespaceInfo.Capability.Unknown.GetMask());
nn.BlockReport(reg, "pool", sbr, new BlockReportContext(1, 0, Runtime.NanoTime())
);
proto = request.Get();
NUnit.Framework.Assert.IsNotNull(proto);
NUnit.Framework.Assert.IsFalse(proto.GetReports(0).GetBlocksList().IsEmpty());
NUnit.Framework.Assert.IsTrue(proto.GetReports(0).GetBlocksBuffersList().IsEmpty(
));
}
/// <summary>Creates a reloadable trustmanager.</summary>
/// <remarks>
/// Creates a reloadable trustmanager. The trustmanager reloads itself
/// if the underlying trustore file has changed.
/// </remarks>
/// <param name="type">type of truststore file, typically 'jks'.</param>
/// <param name="location">local path to the truststore file.</param>
/// <param name="password">password of the truststore file.</param>
/// <param name="reloadInterval">
/// interval to check if the truststore file has
/// changed, in milliseconds.
/// </param>
/// <exception cref="System.IO.IOException">
/// thrown if the truststore could not be initialized due
/// to an IO error.
/// </exception>
/// <exception cref="GeneralSecurityException">
/// thrown if the truststore could not be
/// initialized due to a security error.
/// </exception>
public ReloadingX509TrustManager(string type, string location, string password, long
reloadInterval)
{
this.type = type;
file = new FilePath(location);
this.password = password;
trustManagerRef = new AtomicReference <X509TrustManager>();
trustManagerRef.Set(LoadTrustManager());
this.reloadInterval = reloadInterval;
}
public UDTSender(UDTSession session, UDPEndPoint endpoint)
{
if (!session.isReady())
{
Log.Write(this.ToString(), "UDTSession is not ready.");
}
this.endpoint = endpoint;
this.session = session;
statistics = session.getStatistics();
senderLossList = new SenderLossList();
sendBuffer = new Dictionary <long, DataPacket>(session.getFlowWindowSize());
sendQueue = new Queue <DataPacket>(1000);
lastAckSequenceNumber = (int)session.getInitialSequenceNumber();
currentSequenceNumber = (int)session.getInitialSequenceNumber() - 1;
waitForAckLatch.Set(new CountDownLatch(1));
waitForSeqAckLatch.Set(new CountDownLatch(1));
storeStatistics = false; //Boolean.getBoolean("udt.sender.storeStatistics");
initMetrics();
doStart();
}
public override void Close()
{
unpackedObjectCache.Clear();
ObjectDirectory.PackList packs = packList.Get();
packList.Set(NO_PACKS);
foreach (PackFile p in packs.packs)
{
p.Close();
}
// Fully close all loaded alternates and clear the alternate list.
FileObjectDatabase.AlternateHandle[] alt = alternates.Get();
if (alt != null)
{
alternates.Set(null);
foreach (FileObjectDatabase.AlternateHandle od in alt)
{
od.Close();
}
}
}
public MockCompletes(int times)
: base((Scheduler)null)
{
_safely = AccessSafely.AfterCompleting(times)
.WritingWith <T>("outcome", val =>
{
_outcome.Set(val);
_withCount.IncrementAndGet();
})
.ReadingWith("outcome", _outcome.Get)
.ReadingWith("count", _withCount.Get);
}
public ClientClusterService(HazelcastClient client)
{
_membersRef.Set(new Dictionary <Address, IMember>());
_client = client;
var networkConfig = GetClientConfig().GetNetworkConfig();
var connAttemptLimit = networkConfig.GetConnectionAttemptLimit();
_connectionAttemptPeriod = networkConfig.GetConnectionAttemptPeriod();
_connectionAttemptLimit = connAttemptLimit == 0 ? int.MaxValue : connAttemptLimit;
_shuffleMemberList = EnvironmentUtil.ReadBool("hazelcast.client.shuffle.member.list") ?? false;
var listenerConfigs = client.GetClientConfig().GetListenerConfigs();
foreach (var listenerConfig in listenerConfigs)
{
var listener = listenerConfig.GetImplementation();
if (listener == null)
{
try
{
var className = listenerConfig.GetClassName();
var type = Type.GetType(className);
if (type != null)
{
listener = Activator.CreateInstance(type) as IEventListener;
}
}
catch (Exception e)
{
Logger.Severe(e);
}
}
var membershipListener = listener as IMembershipListener;
if (membershipListener != null)
{
AddMembershipListenerWithoutInit(membershipListener);
}
}
}
public IUnlaunchDataStore GetDataStore()
{
if (_refreshableUnlaunchFetcherRef.Get() != null)
{
return(_refreshableUnlaunchFetcherRef.Get());
}
var dataStore = new UnlaunchHttpDataStore(_restWrapper, _s3BucketClient, _initialDownloadDoneEvent, _downloadSuccessful, _dataStoreRefreshDelay);
_refreshableUnlaunchFetcherRef.Set(dataStore);
return(dataStore);
}
public virtual int AddToIndex(E o)
{
int index = item2Index[o];
if (index != null)
{
return(index);
}
Lock.Lock();
try
{
// Recheck state
if (item2Index.Contains(o))
{
return(item2Index[o]);
}
else
{
int newIndex = indexSize++;
object[] arr = index2Item.Get();
System.Diagnostics.Debug.Assert(newIndex <= arr.Length);
if (newIndex == arr.Length)
{
// Increase size of array if necessary
object[] newArr = new object[2 * newIndex];
System.Array.Copy(arr, 0, newArr, 0, arr.Length);
arr = newArr;
}
arr[newIndex] = o;
index2Item.Set(arr);
item2Index[o] = newIndex;
return(newIndex);
}
}
finally
{
Lock.Unlock();
}
}
/// <summary>Update the scheduleCache to match current conditions in callCounts.</summary>
private void RecomputeScheduleCache()
{
IDictionary <object, int> nextCache = new Dictionary <object, int>();
foreach (KeyValuePair <object, AtomicLong> entry in callCounts)
{
object id = entry.Key;
AtomicLong value = entry.Value;
long snapshot = value.Get();
int computedLevel = ComputePriorityLevel(snapshot);
nextCache[id] = computedLevel;
}
// Swap in to activate
scheduleCacheRef.Set(Collections.UnmodifiableMap(nextCache));
}
private void AppendConsidering <TSource, TSnapshotState>(IOutcome <StorageException, Result> outcome)
{
outcome
.AndThen(result =>
{
if (result == Result.Success)
{
Appended();
}
return(result);
})
.Otherwise(ex =>
{
_exception.Set(ex);
return(outcome.GetOrNull());
});
}
private void InitFeatureStore(Data data)
{
_projectNameRef.Set(data.projectName);
_environmentNameRef.Set(data.envName);
var featureFlags = FlagMapper.GetFeatureFlags(data.flags);
var flagMap = featureFlags.ToDictionary(x => x.Key);
_flagMapReference.Set(flagMap);
if (!_downloadSuccessful.Get())
{
_downloadSuccessful.Set(true);
}
if (!_initialDownloadDoneEvent.IsSet)
{
_initialDownloadDoneEvent.Signal();
}
}
/// <summary>
/// Replaces active queue with the newly requested one and transfers
/// all calls to the newQ before returning.
/// </summary>
public virtual void SwapQueue(Type queueClassToUse, int maxSize, string ns, Configuration
conf)
{
lock (this)
{
BlockingQueue <E> newQ = CreateCallQueueInstance(queueClassToUse, maxSize, ns, conf
);
// Our current queue becomes the old queue
BlockingQueue <E> oldQ = putRef.Get();
// Swap putRef first: allow blocked puts() to be unblocked
putRef.Set(newQ);
// Wait for handlers to drain the oldQ
while (!QueueIsReallyEmpty(oldQ))
{
}
// Swap takeRef to handle new calls
takeRef.Set(newQ);
Log.Info("Old Queue: " + StringRepr(oldQ) + ", " + "Replacement: " + StringRepr(newQ
));
}
}
private static void FindValueExpr(
ExprNode child,
ExprNode parent,
AtomicReference<IList<ExprNodeWithParentPair>> pairsRef)
{
var valueVisitor = new FilterSpecExprNodeVisitorValueLimitedExpr();
child.Accept(valueVisitor);
// not by itself a value expression, but itself it may decompose into some value expressions
if (!valueVisitor.IsLimited) {
FindValueExpressionsDeepRecursive(child, pairsRef);
return;
}
// add value expression, don't traverse child
IList<ExprNodeWithParentPair> pairs = pairsRef.Get();
if (pairs == null) {
pairs = new List<ExprNodeWithParentPair>(2);
pairsRef.Set(pairs);
}
pairs.Add(new ExprNodeWithParentPair(child, parent));
}
/// <summary>
/// Set up writer and reader of state.
/// </summary>
private void SetUpWriteRead()
{
Access
.WritingWith <object>("reference", value => reference.Set(value))
.ReadingWith("reference", () => reference.Get());
}
/// <summary>Initialize a reference to an on-disk object directory.</summary>
/// <remarks>Initialize a reference to an on-disk object directory.</remarks>
/// <param name="cfg">configuration this directory consults for write settings.</param>
/// <param name="dir">the location of the <code>objects</code> directory.</param>
/// <param name="alternatePaths">a list of alternate object directories</param>
/// <param name="fs">
/// the file system abstraction which will be necessary to perform
/// certain file system operations.
/// </param>
/// <exception cref="System.IO.IOException">an alternate object cannot be opened.</exception>
public ObjectDirectory(Config cfg, FilePath dir, FilePath[] alternatePaths, FS fs
)
{
config = cfg;
objects = dir;
infoDirectory = new FilePath(objects, "info");
packDirectory = new FilePath(objects, "pack");
alternatesFile = new FilePath(infoDirectory, "alternates");
cachedPacksFile = new FilePath(infoDirectory, "cached-packs");
packList = new AtomicReference<ObjectDirectory.PackList>(NO_PACKS);
cachedPacks = new AtomicReference<ObjectDirectory.CachedPackList>();
unpackedObjectCache = new UnpackedObjectCache();
this.fs = fs;
alternates = new AtomicReference<FileObjectDatabase.AlternateHandle[]>();
if (alternatePaths != null)
{
FileObjectDatabase.AlternateHandle[] alt;
alt = new FileObjectDatabase.AlternateHandle[alternatePaths.Length];
for (int i = 0; i < alternatePaths.Length; i++)
{
alt[i] = OpenAlternate(alternatePaths[i]);
}
alternates.Set(alt);
}
}
static FnExpr()
{
_baseClassMapRef.Set(_baseClassMapRef.Get().assoc(typeof(RestFn), typeof(RestFnImpl)));
//_baseClassMapRef.Set(_baseClassMapRef.Get().assoc(typeof(AFn),typeof(AFnImpl)));
}
internal virtual void SetMembersRef(IDictionary <Address, IMember> map)
{
_membersRef.Set(map);
}
public static ExprTimePeriod TimePeriodGetExprAllParams(
EsperEPL2GrammarParser.TimePeriodContext ctx,
IDictionary<ITree, ExprNode> astExprNodeMap,
VariableCompileTimeResolver variableCompileTimeResolver,
StatementSpecRaw spec,
Configuration config,
TimeAbacus timeAbacus)
{
ExprNode[] nodes = new ExprNode[9];
for (int i = 0; i < ctx.ChildCount; i++)
{
IParseTree unitRoot = ctx.GetChild(i);
ExprNode valueExpr;
if (ASTUtil.IsTerminatedOfType(unitRoot.GetChild(0), EsperEPL2GrammarLexer.IDENT))
{
string ident = unitRoot.GetChild(0).GetText();
valueExpr = ASTExprHelper.ResolvePropertyOrVariableIdentifier(ident, variableCompileTimeResolver, spec);
}
else
{
AtomicReference<ExprNode> @ref = new AtomicReference<ExprNode>();
ExprAction action = (exprNode, astExprNodeMapX, node) => {
astExprNodeMapX.Remove(node);
@ref.Set(exprNode);
};
ASTExprHelper.RecursiveFindRemoveChildExprNode(unitRoot.GetChild(0), astExprNodeMap, action);
valueExpr = @ref.Get();
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_microsecondPart)
{
nodes[8] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_millisecondPart)
{
nodes[7] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_secondPart)
{
nodes[6] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_minutePart)
{
nodes[5] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_hourPart)
{
nodes[4] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_dayPart)
{
nodes[3] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_weekPart)
{
nodes[2] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_monthPart)
{
nodes[1] = valueExpr;
}
if (ASTUtil.GetRuleIndexIfProvided(unitRoot) == EsperEPL2GrammarParser.RULE_yearPart)
{
nodes[0] = valueExpr;
}
}
ExprTimePeriod timeNode = new ExprTimePeriodImpl(
nodes[0] != null, nodes[1] != null,
nodes[2] != null, nodes[3] != null,
nodes[4] != null, nodes[5] != null,
nodes[6] != null, nodes[7] != null,
nodes[8] != null, timeAbacus);
foreach (ExprNode node in nodes)
{
if (node != null)
{
timeNode.AddChildNode(node);
}
}
return timeNode;
}
private Variation EvaluateInternal(FeatureFlag flag, UnlaunchUser user, AtomicReference <string> evaluationReasonRef)
{
if (flag == null)
{
throw new ArgumentException("unlaunchFlag must not be null");
}
if (user == null)
{
throw new ArgumentException("user must not be null");
}
Variation variationToServe;
var evaluationReason = string.Empty;
if (!flag.Enabled)
{
Logger.Debug($"FLAG_DISABLED, {flag.Key}, OFF_VARIATION is served to user {user.GetId()}");
variationToServe = flag.OffVariation;
evaluationReason = "Default Variation served. Because the flag is disabled.";
}
else if (!CheckDependencies(flag, user))
{
Logger.Info($"PREREQUISITE_FAILED for flag {flag.Key}, OFF_VARIATION is served to user {user.GetId()}");
variationToServe = flag.OffVariation;
evaluationReason = "Default Variation served. Because Pre-requisite failed.";
}
else if ((variationToServe = GetVariationIfUserInAllowList(flag, user)) != null)
{
Logger.Info($"USER_IN_TARGET_USER for flag {flag.Key}, VARIATION {variationToServe} is served to user {user.GetId()}");
evaluationReason = $"Target User rules matched for userId: {user.GetId()}";
}
else
{
var bucketNumber = GetBucket(user.GetId(), flag.Key);
foreach (var rule in flag.Rules)
{
if (!rule.IsDefault() && rule.Matches(user))
{
variationToServe = GetVariationToServeByRule(rule, bucketNumber);
Logger.Debug($"RULE_MATCHED for flag {flag.Key}, {variationToServe.Key} Target Rule is served to user {user.GetId()}");
evaluationReason = $"Targeting Rule (priority #{rule.GetPriority()}) matched.";
break;
}
}
// No variation matched by rule. Use the default rule.
if (variationToServe == null)
{
var defaultRule = flag.DefaultRule;
variationToServe = GetVariationToServeByRule(defaultRule, bucketNumber);
Logger.Debug($"RULE_NOT_MATCHED for flag {flag.Key}, {variationToServe.Key} Default Rule is served to user {user.GetId()}");
evaluationReason = "Default Rule served. This is because the flag is Enabled and Target User and Targeting Rules didn't match.";
}
}
evaluationReasonRef?.Set(evaluationReason);
return(variationToServe);
}
public void Dispose()
{
_timer?.Dispose();
_flagMapReference.Set(new Dictionary <string, FeatureFlag>());
_isTaskRunning.Set(true);
}