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); } }