public override void Execute(IReader reader)
{
IPrimitiveUpdateItem[] puis;
IRelationUpdateItem[] ruis;
if (Parent is CreateContainer)
{
CreateContainer createContainer = (CreateContainer)Parent;
puis = createContainer.Primitives;
ruis = createContainer.Relations;
}
else if (Parent is UpdateContainer)
{
UpdateContainer updateContainer = (UpdateContainer)Parent;
puis = updateContainer.Primitives;
ruis = updateContainer.Relations;
}
else
{
throw new Exception("Unsupported " + typeof(IChangeContainer).Name + " of type '" + Parent.GetType().FullName + "'");
}
Object entity = ObjectFuture.Value;
IEntityMetaData metadata = ((IEntityMetaDataHolder)entity).Get__EntityMetaData();
ApplyPrimitiveUpdateItems(entity, puis, metadata);
if (ruis != null && ruis.Length > 0)
{
ApplyRelationUpdateItems((IObjRefContainer)entity, ruis, Parent is UpdateContainer, metadata, reader);
}
}
private void PutContainer(string storageUri, String containerName)
{
var createContainer = new CreateContainer(storageUri, containerName);
IResponse response = new GenerateRequestByType().Submit(createContainer, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
}
public void CreateContainer_BadTransport_Exception()
{
Assert.Throws <DotNetWorkQueueException>(
delegate
{
var creator = new CreateContainer <NoOpBadTransport>();
creator.Create(QueueContexts.NotSet, x => { }, new QueueConnection(string.Empty, string.Empty), new NoOpBadTransport(), ConnectionTypes.NotSpecified, y => { });
});
}
public void Should_return_created_status_when_the_container_does_not_exist()
{
CreateContainer createContainer = new CreateContainer(storageUrl, Constants.CONTAINER_NAME);
IResponse response = new GenerateRequestByType( ).Submit(createContainer, authToken);
Assert.That(response.Status, Is.EqualTo(HttpStatusCode.Created));
DeleteContainer(storageUrl, Constants.CONTAINER_NAME);
}
public void CreateContainer_NoWarnings_NoOpReceiveTransport()
{
var creator = new CreateContainer <NoOpReceiveTransport>();
var c = creator.Create(QueueContexts.NotSet, x => { }, new QueueConnection(string.Empty, string.Empty), new NoOpReceiveTransport(), ConnectionTypes.Receive, y => { });
// Assert
Container container = c.Container;
var results = Analyzer.Analyze(container);
Assert.False(results.Any(), Environment.NewLine +
string.Join(Environment.NewLine,
from result in results
select result.Description));
}
public void CreateContainer_NoWarnings_SchedulerInitTransport()
{
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
var creator = new CreateContainer <SchedulerInit>();
var c = creator.Create(QueueContexts.TaskScheduler, x => { }, fixture.Create <SchedulerInit>(), y => { });
// Assert
Container container = c.Container;
var results = Analyzer.Analyze(container);
Assert.False(results.Any(), Environment.NewLine +
string.Join(Environment.NewLine,
from result in results
select result.Description));
}
public ICreateOrUpdateContainer Build()
{
if (IsCreate())
{
CreateContainer cc = new CreateContainer();
cc.Reference = Reference;
cc.Primitives = cudResultHelper.CompactPUIs(GetFullPUIs(), GetPuiCount());
cc.Relations = cudResultHelper.CompactRUIs(GetFullRUIs(), GetRuiCount());
return(cc);
}
if (IsUpdate())
{
UpdateContainer uc = new UpdateContainer();
uc.Reference = Reference;
uc.Primitives = cudResultHelper.CompactPUIs(GetFullPUIs(), GetPuiCount());
uc.Relations = cudResultHelper.CompactRUIs(GetFullRUIs(), GetRuiCount());
return(uc);
}
throw new Exception("Must never happen");
}
public ICUDResult CreateCUDResult(MergeHandle mergeHandle)
{
ILinkedMap <Type, ICUDResultExtension> typeToCudResultExtension = extensions.GetExtensions();
foreach (Entry <Type, ICUDResultExtension> entry in typeToCudResultExtension)
{
entry.Value.Extend(mergeHandle);
}
IdentityLinkedMap <Object, IList <IUpdateItem> > objToModDict = mergeHandle.objToModDict;
IdentityHashSet <Object> objToDeleteSet = mergeHandle.objToDeleteSet;
HashMap <Type, IPrimitiveUpdateItem[]> entityTypeToFullPuis = new HashMap <Type, IPrimitiveUpdateItem[]>();
HashMap <Type, IRelationUpdateItem[]> entityTypeToFullRuis = new HashMap <Type, IRelationUpdateItem[]>();
List <IChangeContainer> allChanges = new List <IChangeContainer>(objToModDict.Count);
List <Object> originalRefs = new List <Object>(objToModDict.Count);
foreach (Object objToDelete in objToDeleteSet)
{
IObjRef ori = OriHelper.GetCreateObjRef(objToDelete, mergeHandle);
DeleteContainer deleteContainer = new DeleteContainer();
deleteContainer.Reference = ori;
allChanges.Add(deleteContainer);
originalRefs.Add(objToDelete);
}
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
foreach (Entry <Object, IList <IUpdateItem> > entry in objToModDict)
{
Object obj = entry.Key;
IList <IUpdateItem> modItems = entry.Value;
IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(obj.GetType());
IPrimitiveUpdateItem[] fullPuis = GetEnsureFullPUIs(metaData, entityTypeToFullPuis);
IRelationUpdateItem[] fullRuis = GetEnsureFullRUIs(metaData, entityTypeToFullRuis);
int puiCount = 0, ruiCount = 0;
for (int a = modItems.Count; a-- > 0;)
{
IUpdateItem modItem = modItems[a];
Member member = metaData.GetMemberByName(modItem.MemberName);
if (modItem is IRelationUpdateItem)
{
fullRuis[metaData.GetIndexByRelation(member)] = (IRelationUpdateItem)modItem;
ruiCount++;
}
else
{
fullPuis[metaData.GetIndexByPrimitive(member)] = (IPrimitiveUpdateItem)modItem;
puiCount++;
}
}
IRelationUpdateItem[] ruis = CompactRUIs(fullRuis, ruiCount);
IPrimitiveUpdateItem[] puis = CompactPUIs(fullPuis, puiCount);
IObjRef ori = OriHelper.GetCreateObjRef(obj, mergeHandle);
originalRefs.Add(obj);
if (ori is IDirectObjRef)
{
CreateContainer createContainer = new CreateContainer();
((IDirectObjRef)ori).CreateContainerIndex = allChanges.Count;
createContainer.Reference = ori;
createContainer.Primitives = puis;
createContainer.Relations = ruis;
allChanges.Add(createContainer);
}
else
{
UpdateContainer updateContainer = new UpdateContainer();
updateContainer.Reference = ori;
updateContainer.Primitives = puis;
updateContainer.Relations = ruis;
allChanges.Add(updateContainer);
}
}
return(new CUDResult(allChanges, originalRefs));
}
protected override void SetupContext()
{
createContainer = new CreateContainer("http://storageurl", "containername");
mock = new Mock <ICloudFilesRequest>();
createContainer.Apply(mock.Object);
}
protected ICUDResult ApplyIntern(ICUDResult cudResult, bool checkBaseState, IncrementalMergeState incrementalState)
{
ICache stateCache = incrementalState.GetStateCache();
IList <IChangeContainer> allChanges = cudResult.AllChanges;
IList <Object> originalRefs = cudResult.GetOriginalRefs();
IList <Object> allObjects = GetAllExistingObjectsFromCache(stateCache, allChanges);
List <Object> hardRefs = new List <Object>();
hardRefs.Add(allObjects); // add list as item intended. adding each item of the source is NOT needed
List <IObjRef> toFetchFromCache = new List <IObjRef>();
List <DirectValueHolderRef> toPrefetch = new List <DirectValueHolderRef>();
List <IBackgroundWorkerDelegate> runnables = new List <IBackgroundWorkerDelegate>();
IEntityFactory entityFactory = this.EntityFactory;
IdentityHashMap <IObjRef, StateEntry> newObjRefToStateEntryMap = new IdentityHashMap <IObjRef, StateEntry>();
IdentityHashMap <IChangeContainer, IChangeContainer> alreadyClonedMap = new IdentityHashMap <IChangeContainer, IChangeContainer>();
List <IChangeContainer> newAllChanges = new List <IChangeContainer>(allChanges.Count);
for (int a = 0, size = allChanges.Count; a < size; a++)
{
IChangeContainer changeContainer = allChanges[a];
Object originalEntity = originalRefs[a];
StateEntry stateEntry = incrementalState.entityToStateMap.Get(originalEntity);
IChangeContainer newChangeContainer;
if (changeContainer is CreateContainer)
{
newChangeContainer = new CreateContainer();
}
else if (changeContainer is UpdateContainer)
{
newChangeContainer = new UpdateContainer();
}
else
{
newChangeContainer = new DeleteContainer();
}
newAllChanges.Add(newChangeContainer);
alreadyClonedMap.Put(changeContainer, newChangeContainer);
if (!(changeContainer is CreateContainer))
{
Object stateCacheEntity2 = allObjects[a];
stateEntry = incrementalState.entityToStateMap.Get(stateCacheEntity2);
if (stateEntry == null)
{
stateEntry = new StateEntry(stateCacheEntity2, changeContainer.Reference, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity2, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
}
// delete & update do not need further handling
continue;
}
Type realType = changeContainer.Reference.RealType;
Object stateCacheEntity;
if (stateEntry == null)
{
stateCacheEntity = entityFactory.CreateEntity(realType);
DirectObjRef directObjRef = new DirectObjRef(realType, stateCacheEntity);
directObjRef.CreateContainerIndex = a;
stateEntry = new StateEntry(stateCacheEntity, directObjRef, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
newObjRefToStateEntryMap.Put(changeContainer.Reference, stateEntry);
}
else
{
stateCacheEntity = stateEntry.entity;
}
allObjects[a] = stateCacheEntity;
}
cloneStateTL.Value = new CloneState(newObjRefToStateEntryMap, incrementalState);
try
{
for (int a = allChanges.Count; a-- > 0;)
{
IChangeContainer changeContainer = allChanges[a];
IObjRefContainer entity = (IObjRefContainer)allObjects[a];
changeContainer = FillClonedChangeContainer(changeContainer, alreadyClonedMap);
IPrimitiveUpdateItem[] puis;
IRelationUpdateItem[] ruis;
if (changeContainer is CreateContainer)
{
CreateContainer createContainer = (CreateContainer)changeContainer;
puis = createContainer.Primitives;
ruis = createContainer.Relations;
}
else if (changeContainer is UpdateContainer)
{
UpdateContainer updateContainer = (UpdateContainer)changeContainer;
puis = updateContainer.Primitives;
ruis = updateContainer.Relations;
}
else
{
((IDataObject)entity).ToBeDeleted = true;
continue;
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)entity).Get__EntityMetaData();
ApplyPrimitiveUpdateItems(entity, puis, metaData);
if (ruis != null)
{
bool isUpdate = changeContainer is UpdateContainer;
foreach (IRelationUpdateItem rui in ruis)
{
ApplyRelationUpdateItem(entity, rui, isUpdate, metaData, toPrefetch, toFetchFromCache, checkBaseState, runnables);
}
}
}
while (toPrefetch.Count > 0 || toFetchFromCache.Count > 0 || runnables.Count > 0)
{
if (toPrefetch.Count > 0)
{
PrefetchHelper.Prefetch(toPrefetch);
toPrefetch.Clear();
}
if (toFetchFromCache.Count > 0)
{
IList <Object> fetchedObjects = stateCache.GetObjects(toFetchFromCache, CacheDirective.None);
hardRefs.Add(fetchedObjects); // add list as item intended. adding each item of the source is NOT needed
toFetchFromCache.Clear();
}
IBackgroundWorkerDelegate[] runnableArray = runnables.ToArray();
runnables.Clear();
foreach (IBackgroundWorkerDelegate runnable in runnableArray)
{
runnable();
}
}
List <Object> newObjects = new List <Object>(allObjects.Count);
List <DirectValueHolderRef> changedRelationRefs = new List <DirectValueHolderRef>();
for (int a = allObjects.Count; a-- > 0;)
{
IChangeContainer newChange = newAllChanges[a];
IRelationUpdateItem[] ruis = null;
Object entity = allObjects[a];
if (newChange is CreateContainer)
{
newObjects.Add(entity);
ruis = ((CreateContainer)newChange).Relations;
}
else if (newChange is UpdateContainer)
{
ruis = ((UpdateContainer)newChange).Relations;
}
if (ruis == null)
{
continue;
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entity.GetType());
foreach (IRelationUpdateItem rui in ruis)
{
Member member = metaData.GetMemberByName(rui.MemberName);
changedRelationRefs.Add(new DirectValueHolderRef((IObjRefContainer)entity, (RelationMember)member));
}
}
if (newObjects.Count > 0)
{
((IWritableCache)stateCache).Put(newObjects);
}
if (changedRelationRefs.Count > 0)
{
PrefetchHelper.Prefetch(changedRelationRefs);
}
return(new CUDResult(newAllChanges, allObjects));
}
finally
{
cloneStateTL.Value = null;
}
}
protected bool EqualsChangeContainer(CUDResultDiff cudResultDiff, IChangeContainer left, IChangeContainer right)
{
if (left.GetType() != right.GetType())
{
throw new Exception("Must never happen");
}
cudResultDiff.SetLeftContainer(left);
try
{
if (left is CreateContainer)
{
CreateContainer leftCreate = (CreateContainer)left;
CreateContainer rightCreate = (CreateContainer)right;
bool isEqual = EqualsPUIs(cudResultDiff, leftCreate.Primitives, rightCreate.Primitives);
if (!isEqual)
{
if (!cudResultDiff.doFullDiff)
{
return(false);
}
}
isEqual &= EqualsRUIs(cudResultDiff, leftCreate.Relations, rightCreate.Relations);
if (!isEqual)
{
if (!cudResultDiff.doFullDiff)
{
return(false);
}
}
return(isEqual);
}
if (left is UpdateContainer)
{
UpdateContainer leftUpdate = (UpdateContainer)left;
UpdateContainer rightUpdate = (UpdateContainer)right;
bool isEqual = EqualsPUIs(cudResultDiff, leftUpdate.Primitives, rightUpdate.Primitives);
if (!isEqual)
{
if (!cudResultDiff.doFullDiff)
{
return(false);
}
}
isEqual &= EqualsRUIs(cudResultDiff, leftUpdate.Relations, rightUpdate.Relations);
if (!isEqual)
{
if (!cudResultDiff.doFullDiff)
{
return(false);
}
}
return(isEqual);
}
// a DeleteContainer is only compared by the reference. But we know that this is already equal since we entered this method
return(true);
}
finally
{
cudResultDiff.SetLeftContainer(null);
}
}
