public void EatStubOptions(ISnapshot snapshot, ICSharpExpression options)
{
if (options is IConditionalAndExpression)
{
EatStubOptions(snapshot, (options as IConditionalAndExpression).LeftOperand);
EatStubOptions(snapshot, (options as IConditionalAndExpression).RightOperand);
return;
}
if (options is IEqualityExpression)
{
EatStubOptions(snapshot, (options as IEqualityExpression).LeftOperand);
var kind = _eater.Eat(snapshot, (options as IEqualityExpression).RightOperand);
EatOptionValue(snapshot, kind, (options as IEqualityExpression).RightOperand);
return;
}
if (options is IInvocationExpression)
{
var optType = _moqStubOptionTargetEater.EatOption(snapshot, options as IInvocationExpression);
snapshot.Add(optType, options);
return;
}
if (options is IReferenceExpression)
{
var optType = _moqStubOptionTargetEater.EatOption(snapshot, options as IReferenceExpression);
snapshot.Add(optType, options);
return;
}
throw new MoqStubOptionWrongTypeException(this, options);
}
public void Eat(ISnapshot snapshot, IVariableDeclaration variableDeclaration)
{
if (variableDeclaration == null)
throw new ArgumentNullException("variableDeclaration");
GetEater(variableDeclaration).Eat(snapshot, variableDeclaration);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventSourcedAggregate{T}"/> class.
/// </summary>
/// <param name="snapshot">A snapshot of the aggregate's built-up state.</param>
protected internal EventSourcedAggregate(ISnapshot snapshot)
: this(snapshot.IfNotNull()
.Then(s => s.AggregateId)
.ElseThrow(() => new ArgumentNullException(nameof(snapshot))))
{
sourceSnapshot = snapshot;
}
public ExpressionKind Eat(ISnapshot snapshot, IQueryClause queryClause)
{
if (queryClause == null)
throw new ArgumentNullException("queryClause");
return GetEater(queryClause).Eat(snapshot, queryClause);
}
public OptimisticEventStream(ISnapshot snapshot, ICommitEvents persistence, int maxRevision)
: this(snapshot.BucketId, snapshot.StreamId, persistence)
{
IEnumerable<ICommit> commits = persistence.GetFrom(snapshot.BucketId, snapshot.StreamId, snapshot.StreamRevision, maxRevision);
PopulateStream(snapshot.StreamRevision + 1, maxRevision, commits);
StreamRevision = snapshot.StreamRevision + _committed.Count;
}
public void Eat(ISnapshot snapshot, ICSharpStatement statement)
{
if (statement == null)
throw new ArgumentNullException("statement");
GetEater(statement).Eat(snapshot, statement);
}
public ExpressionKind Eat(ISnapshot snapshot, ICSharpExpression expression)
{
if (expression == null)
throw new ArgumentNullException("expression");
return GetEater(expression).Eat(snapshot, expression);
}
public FakeOptionType EatOption(ISnapshot snapshot, IReferenceExpression referenceExpression)
{
if (referenceExpression.QualifierExpression == null)
{
throw new MoqStubWrongSyntaxException("Moq-stub property-option has not parent reference", this,
referenceExpression);
}
if (referenceExpression.QualifierExpression is IInvocationExpression)
{
return EatOption(snapshot, referenceExpression.QualifierExpression as IInvocationExpression);
}
if (referenceExpression.QualifierExpression is IReferenceExpression)
{
var declaredElement = _eatExpressionHelper.GetReferenceElement(referenceExpression.QualifierExpression as IReferenceExpression);
if (declaredElement is ILambdaParameterDeclaration)
{
return FakeOptionType.Property;
}
return EatOption(snapshot, referenceExpression.QualifierExpression as IReferenceExpression);
}
throw new MoqStubOptionTargetWrongTypeException(this, referenceExpression.QualifierExpression);
}
public void Invalidate(ISnapshot tentativeSnapshot)
{
lock (synchRoot)
{
snapshots = null;
}
}
public virtual ITextNode LoadIncludeFile(SnapshotParseContext snapshotParseContext, ISnapshot snapshot, string includeFileName)
{
var extension = PathHelper.GetExtension(snapshot.SourceFile.AbsoluteFileName);
var projectDirectory = snapshot.SourceFile.AbsoluteFileName.Left(snapshot.SourceFile.AbsoluteFileName.Length - snapshot.SourceFile.ProjectFileName.Length - extension.Length + 1);
string sourceFileName;
if (includeFileName.StartsWith("~/"))
{
sourceFileName = PathHelper.Combine(projectDirectory, includeFileName.Mid(2));
}
else
{
sourceFileName = PathHelper.Combine(Path.GetDirectoryName(snapshot.SourceFile.AbsoluteFileName) ?? string.Empty, includeFileName);
}
if (!FileSystem.FileExists(sourceFileName))
{
throw new FileNotFoundException("Include file not found", sourceFileName);
}
var projectFileName = "~/" + PathHelper.NormalizeItemPath(PathHelper.UnmapPath(projectDirectory, PathHelper.GetDirectoryAndFileNameWithoutExtensions(sourceFileName))).TrimStart('/');
var sourceFile = Factory.SourceFile(FileSystem, sourceFileName, projectFileName);
var includeSnapshot = LoadSnapshot(snapshotParseContext, sourceFile) as TextSnapshot;
return includeSnapshot?.Root ?? TextNode.Empty;
}
private void EatOptionValue(ISnapshot snapshot, ExpressionKind kind, ICSharpExpression optionValue)
{
var addableKinds = new[] { ExpressionKind.Target, ExpressionKind.Stub, ExpressionKind.Mock };
if (addableKinds.Contains(kind))
{
snapshot.Add(kind, optionValue);
}
}
public void SaveShapshot(ISnapshot source)
{
FileInfo file = source.EventSourceId.GetSnapshotFileInfo(_path);
if (!file.Exists && !file.Directory.Exists)
file.Directory.Create();
var jo = JObject.FromObject(source);
WriteSnapshotTest(source, file.FullName, jo.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="EventSourcedAggregate{T}"/> class.
/// </summary>
/// <param name="snapshot">A snapshot of the aggregate's built-up state.</param>
/// <param name="eventHistory">The event history.</param>
protected internal EventSourcedAggregate(ISnapshot snapshot, IEnumerable<IEvent> eventHistory = null) :
this(snapshot.IfNotNull()
.Then(s => s.AggregateId)
.ElseThrow(() => new ArgumentNullException("snapshot")))
{
sourceEvents = eventHistory.OrEmpty().ToArray();
SourceSnapshot = snapshot;
}
public Commit(long id, Guid targetId, long targetVersion, IList<IDomainEvent> events, long? snapshotId = null, ISnapshot snapshot = null)
{
Id = id;
TargetId = targetId;
TargetVersion = targetVersion;
Events = events;
SnapshotId = snapshotId;
Snapshot = snapshot;
}
public async Task SaveSnapshot(ISnapshot snapshot)
{
if (snapshot == null)
{
throw new ArgumentNullException(nameof(snapshot));
}
snapshots[snapshot.AggregateId] = snapshot;
}
public IncrementalCachingSnapshot(ISnapshot parentSnapshot, ICommandExecutor commandExecutor, IChangeSet changeSet)
{
this.parentSnapshot = parentSnapshot;
this.commandExecutor = commandExecutor;
foreach (var command in changeSet.Commands)
{
Load(command);
}
}
public async Task<bool> AddSnapshot(ISnapshot snapshot)
{
bool result = await _persistence.AddSnapshot(snapshot);
if (result)
{
_counters.CountSnapshot();
}
return result;
}
protected override void DoBuildFromSnapshot(ISnapshot snapshot)
{
SourcedCustomerSnapshot s = (SourcedCustomerSnapshot)snapshot;
this.Birth = s.Birth;
this.Email = s.Email;
this.FirstName = s.FirstName;
this.LastName = s.LastName;
this.Password = s.Password;
this.Username = s.Username;
}
public bool AddSnapshot(ISnapshot snapshot)
{
bool result = _persistence.AddSnapshot(snapshot);
if (result)
{
_counters.CountSnapshot();
}
return result;
}
public virtual IEventStream OpenStream(ISnapshot snapshot, int maxRevision)
{
if (snapshot == null)
{
throw new ArgumentNullException("snapshot");
}
Logger.Debug(Resources.OpeningStreamWithSnapshot, snapshot.StreamId, snapshot.StreamRevision, maxRevision);
maxRevision = maxRevision <= 0 ? int.MaxValue : maxRevision;
return new OptimisticEventStream(snapshot, this, maxRevision);
}
private static void WriteSnapshotTest(ISnapshot source, string path, string jsonData)
{
try
{
source.EventSourceId.GetWriteLock("snapshot");
File.WriteAllText(path, source.GetType().AssemblyQualifiedName + "\n\r" + jsonData);
} finally
{
source.EventSourceId.ReleaseWriteLock("snapshot");
}
}
public void Add(ChangeSetId changeSetId, ISnapshot snapshot)
{
lock (synchRoot)
{
if (snapshots.ContainsKey(changeSetId))
{
throw new InvalidOperationException(
string.Format("Another change set with the id {0} has already been loaded.", changeSetId));
}
snapshots[changeSetId] = snapshot;
}
}
public void SaveShapshot(ISnapshot source)
{
using (var session = _documentStore.OpenSession())
{
session.Store(new StoredSnaphot
{
Id = source.EventSourceId.ToString(),
Data = source,
EventSourceId = source.EventSourceId
});
session.SaveChanges();
}
}
/// <summary>
/// Creates a new FuzzController. Once the snapshotBreakpoint is reached a snapshot is created.
/// The snapshot gets restored once restore Breakpoint is reached
/// </summary>
/// <param name="connector">connector to use</param>
/// <param name="snapshotBreakpoint">Location to create a snapshot</param>
/// <param name="restoreBreakpoint">Location to restore the snapshot</param>
public FuzzController(ITargetConnector connector, string logDestination,
IDataLogger logger, FuzzDescription fuzzDescription, IFuzzLocation[] preConditions)
{
_connector = connector;
_snapshot = null;
_dataLogger = logger;
_logDestination = logDestination;
_errorLog = new ErrorLog (_logDestination);
_fuzzDescription = fuzzDescription;
_fuzzDescription.Init ();
_preConditions = preConditions;
}
protected override void TraceLine(ITraceService trace, int msg, string text, ITextNode textNode, ISnapshot snapshot, string details)
{
if (textNode != null)
{
trace.TraceInformation(msg, text, textNode, details);
}
else if (snapshot != null)
{
trace.TraceInformation(msg, text, snapshot.SourceFile, details);
}
else
{
trace.TraceInformation(msg, text, details);
}
}
protected override void TraceLine(int msg, string text, ITextNode textNode, ISnapshot snapshot, string details)
{
if (textNode != null)
{
Trace.TraceError(msg, text, textNode, details);
}
else if (snapshot != null)
{
Trace.TraceError(msg, text, snapshot.SourceFile, details);
}
else
{
Trace.TraceError(msg, text, details);
}
}
public IParseContext With(IProject project, ISnapshot snapshot, PathMappingContext pathMappingContext)
{
Project = project;
Snapshot = snapshot;
FilePath = pathMappingContext.FilePath;
ItemName = pathMappingContext.ItemName;
ItemPath = pathMappingContext.ItemPath;
DatabaseName = pathMappingContext.DatabaseName;
UploadMedia = pathMappingContext.UploadMedia;
Trace = new ProjectDiagnosticTraceService(Configuration, Console, Factory).With(Project);
return this;
}
private ExpressionKind EatResults(ISnapshot snapshot, ICSharpExpression initialExpression)
{
ExpressionKind expressionKind = _eater.Eat(snapshot, initialExpression);
if (expressionKind == ExpressionKind.StubCandidate)
{
return ExpressionKind.Stub;
}
if (expressionKind == ExpressionKind.TargetCall)
{
return ExpressionKind.Result;
}
return expressionKind;
}
public IParseContext With(IProject project, ISnapshot snapshot)
{
Project = project;
Snapshot = snapshot;
Trace = new ProjectDiagnosticTraceService(Configuration, Console, Factory).With(Project);
var fileContext = FileContext.GetFileContext(Project, Configuration, snapshot.SourceFile);
FilePath = fileContext.FilePath;
ItemName = fileContext.ItemName;
ItemPath = fileContext.ItemPath;
DatabaseName = fileContext.DatabaseName;
IsExtern = fileContext.IsExtern;
UploadMedia = fileContext.UploadMedia;
return this;
}
public void Init()
{
m_SnapshotDic = new Dictionary<NetWorkType, List<ISnapshot>>();
gsmSnapshot = new MockGSMSnapshot();
r99Snapshot = new UMTSR99Snapshot();
List<ISnapshot> gsmList = new List<ISnapshot>();
gsmList.Add(gsmSnapshot);
List<ISnapshot> umtsList = new List<ISnapshot>();
umtsList.Add(r99Snapshot);
m_SnapshotDic.Add(NetWorkType.GSM, gsmList);
m_SnapshotDic.Add(NetWorkType.UMTS, umtsList);
m_VersionDic = new Dictionary<NetVersion, NetWorkType>();
m_VersionDic.Add(NetVersion.GSM, NetWorkType.GSM);
m_VersionDic.Add(NetVersion.UMTSR99, NetWorkType.UMTS);
m_VersionDic.Add(NetVersion.UMTSHSUPA, NetWorkType.UMTS);
m_SimulationGroup = new MockSimulationGroup();
NetworkParam networkParam = new NetworkParam();
Dictionary<NetWorkType,object> netWorkTypeDic = new Dictionary<NetWorkType,object>();
netWorkTypeDic.Add(NetWorkType.UMTS, null);
netWorkTypeDic.Add(NetWorkType.GSM, null);
networkParam.Param = netWorkTypeDic;
UnionUIParam unionParam = new UnionUIParam();
unionParam.AllocateType = AllocateUserType.Load;
List<NetWorkType> netTypes = new List<NetWorkType>();
netTypes.Add(NetWorkType.GSM);
netTypes.Add(NetWorkType.UMTS);
unionParam.NETS = netTypes;
unionParam.UnionIterationNumber = 2;
networkParam.UnionParam = unionParam;
m_SimulationGroup.AdvanceParam = networkParam;
IApplicationContext context = new MockAppContext();
m_SimulationGroup.Region = CreatRegion();
IProject project = new MockProject();
ProjectSingleton.CurrentProject = project;
m_Target = new CoSnapshot(m_SimulationGroup, m_SnapshotDic, m_VersionDic,context);
}
public ItemServer(Guid id, ISnapshot snapshot) : base(id, snapshot)
{
}
public SidecarValues(ISnapshot valuesFactory)
{
_values = valuesFactory;
}
ProjectionStream LoadProjectionStream(Type projectionType, ProjectionVersion projectionVersion, IBlobId projectionId, ISnapshot snapshot)
{
if (ReferenceEquals(null, projectionVersion))
{
throw new ArgumentNullException(nameof(projectionVersion));
}
if (ReferenceEquals(null, projectionId))
{
throw new ArgumentNullException(nameof(projectionId));
}
if (ReferenceEquals(null, snapshot))
{
throw new ArgumentNullException(nameof(snapshot));
}
ISnapshot currentSnapshot = snapshot;
string contractId = projectionVersion.ProjectionContractId;
List <ProjectionCommit> projectionCommits = new List <ProjectionCommit>();
int snapshotMarker = snapshot.Revision;
while (true)
{
snapshotMarker++;
var loadedCommits = projectionStore.Load(projectionVersion, projectionId, snapshotMarker).ToList();
projectionCommits.AddRange(loadedCommits);
bool isSnapshotable = typeof(IAmNotSnapshotable).IsAssignableFrom(projectionType) == false;
if (isSnapshotable && snapshotStrategy.ShouldCreateSnapshot(projectionCommits, snapshot.Revision))
{
ProjectionStream checkpointStream = new ProjectionStream(projectionId, projectionCommits, currentSnapshot);
var projectionState = checkpointStream.RestoreFromHistory(projectionType).Projection.State;
ISnapshot newSnapshot = new Snapshot(projectionId, contractId, projectionState, snapshot.Revision + 1);
snapshotStore.Save(newSnapshot, projectionVersion);
currentSnapshot = newSnapshot;
projectionCommits.Clear();
log.Debug(() => $"Snapshot created for projection `{contractId}` with id={projectionId} where ({loadedCommits.Count}) were zipped. Snapshot: `{snapshot.GetType().Name}`");
}
else if (loadedCommits.Count() < snapshotStrategy.EventsInSnapshot)
{
break;
}
else
{
log.Warn($"Potential memory leak. The system will be down fairly soon. The projection `{contractId}` with id={projectionId} loads a lot of projection commits ({loadedCommits.Count}) and snapshot `{snapshot.GetType().Name}` which puts a lot of CPU and RAM pressure. You can resolve this by configuring the snapshot settings`.");
}
}
ProjectionStream stream = new ProjectionStream(projectionId, projectionCommits, currentSnapshot);
return(stream);
}
public Promotions(Guid id, ISnapshot snapshot) : base(id, snapshot)
{
var state = (PromotionsSnapshot)snapshot;
this.points = state.Points;
}
private async Task <ProjectionStream> LoadProjectionStreamAsync(ProjectionVersion version, IBlobId projectionId, ISnapshot snapshot)
{
bool shouldLoadMore = true;
Func <ISnapshot> loadSnapshot = () => snapshot;
List <ProjectionCommit> projectionCommits = new List <ProjectionCommit>();
int snapshotMarker = snapshot.Revision;
while (shouldLoadMore)
{
snapshotMarker++;
var loadProjectionCommits = projectionStore.LoadAsync(version, projectionId, snapshotMarker).ConfigureAwait(false);
bool checkNextSnapshotMarker = await projectionStore.HasSnapshotMarkerAsync(version, projectionId, snapshotMarker + 1).ConfigureAwait(false);
shouldLoadMore = checkNextSnapshotMarker;
await foreach (var commit in loadProjectionCommits)
{
projectionCommits.Add(commit);
}
}
ProjectionStream stream = new ProjectionStream(projectionId, projectionCommits, loadSnapshot);
return(stream);
}
private IAggregateEx GetAggregate <TAggregate>(ISnapshot snapshot, IEventStream stream)
{
IMementoEx memento = snapshot == null ? null : snapshot.Payload as IMementoEx;
return(this._factory.Build(typeof(TAggregate), _identityConverter.ToIdentity(stream.StreamId), memento));
}
public abstract void Eat(ISnapshot snapshot, T statement);
public virtual void AddSnapshot(ISnapshot snapshot)
{
_snapshots.Add(snapshot);
}
public OriginalValues(InternalEntityEntry entry)
{
_values = entry.EntityType.GetOriginalValuesFactory()(entry);
}
public EventSourced(Guid id, ISnapshot snapshot)
: this(id)
{
this.version = snapshot.Version;
}
public ReadOptions Snapshot(ISnapshot snapshot)
{
_snapshot = snapshot;
return(this);
}
public CustomerAccount(
ISnapshot snapshot,
IEnumerable <IEvent> additionalEvents = null) : base(snapshot, additionalEvents)
{
}
public RelationshipsSnapshot(InternalEntityEntry entry)
{
_values = ((EntityType)entry.EntityType).RelationshipSnapshotFactory(entry);
}
public abstract IReadOnlyList <ISendable <ITransmittable> > Create(ISnapshot <TUser, TTransmission> input);
public void AddSnapshot(ISnapshot snapshot)
{
snapshots.Add(snapshot);
}
public HomeController(ISnapshot snapshot)
{
this.Snapshot = snapshot;
}
protected abstract void DoLoadFromSnapshot(ISnapshot snapshot);
///GENMHASH:5BA6C6B418238F9AAD214C5F09B6E1CB:1EB84A49445D7528CE46D6A009A82F9E
public DiskImpl FromSnapshot(ISnapshot snapshot)
{
return(FromSnapshot(snapshot.Id));
}
private static SnapshotContainer CreateSnapshotContainer(ISnapshot snapshot)
{
return(new SnapshotContainer(
snapshot,
new SnapshotMetadata()));
}
private async Task OnRestoreSnapshotExecuteAsync(ISnapshot snapshot)
{
Log.Info($"Restoring snapshot '{snapshot}'");
await _snapshotManager.RestoreSnapshotAsync(snapshot);
}
public OriginalValues(InternalEntityEntry entry)
{
_values = ((EntityType)entry.EntityType).OriginalValuesFactory(entry);
}
///GENMHASH:317134690AC492A13AB6664204ABFD95:2CD52FED9DD80D3ACA7A05FE17CBFC89
public VirtualMachineCustomImageImpl WithLinuxFromSnapshot(ISnapshot sourceSnapshot, OperatingSystemStateTypes osState)
{
return(this.WithLinuxFromSnapshot(sourceSnapshot.Id, osState));
}
public virtual SourceProperty <T> AddSourceTextNode([NotNull] ISnapshot snapshot)
{
return(AddAdditionalSourceTextNode(new FileNameTextNode(PathHelper.GetFileNameWithoutExtensions(snapshot.SourceFile.AbsoluteFileName), snapshot)));
}
public void Eat(ISnapshot snapshot, IVariableDeclaration variableDeclaration)
{
}
public override ExpressionKind Eat(ISnapshot snapshot, IQueryWhereClause queryClause)
{
return(ExpressionKind.None);
}
public Task SaveAsync(ISnapshot snapshot, ProjectionVersion version)
{
return(Task.CompletedTask);
}
public FileNameTextNode([NotNull] string fileName, [NotNull] ISnapshot snapshot)
{
Value = fileName;
Snapshot = snapshot;
}
public void BuildFromSnapshot(ISnapshot snapshot)
{
throw new NotImplementedException();
}
public bool AddSnapshot(ISnapshot snapshot)
{
return(_original.AddSnapshot(snapshot));
}
protected abstract void ApplySnapshot(ISnapshot snapshot);
