public static ResourceId createId(Name<?> name, ResourceTemplate template) { checkNotNull(name,"Resource name cannot be null"); checkNotNull(template,"Template cannot be null"); return createId(name,template.id()); }
ResourceId resourceId() { return ResourceId.createId(this.resourceName, this.template.id()); }
boolean removeMember(ResourceSnapshot member) { if(member==null) { return false; } boolean result = this.members.containsValue(member); if(result) { ResourceId memberId=ResourceId.createId(member.name(),member.templateId()); this.members.remove(memberId); this.newMembers.remove(member); } return result; }
/** * {@inheritDoc} */ @Override public <S extends ResourceSnapshot> S find( Class<? extends S> snapshotClass, Name<?> name, Class<? extends ResourceHandler> handlerClass) { checkNotNull(snapshotClass,"Resource snapshot class cannot be null"); checkNotNull(name,RESOURCE_NAME_CANNOT_BE_NULL); checkNotNull(handlerClass,"Resource handler class cannot be null"); checkArgument(!ContainerSnapshot.class.isAssignableFrom(snapshotClass) || ContainerHandler.class.isAssignableFrom(handlerClass),"Incompatible snapshot and handler classes ('%s' instances are not handled by '%s')",snapshotClass.getCanonicalName(),handlerClass.getCanonicalName()); ResourceTemplate template=this.writeSessionService.templateManagementService().templateOfHandler(handlerClass); checkArgument(template!=null,"Handler class '%s' is not associated to any existing template",handlerClass.getCanonicalName()); checkArgument(Snapshots.areCompatible(snapshotClass,template),"Cannot wrap an object managed by '%s' with an snapshot of type '%s'",handlerClass.getCanonicalName(),snapshotClass.getCanonicalName()); checkState(this.status.equals(Status.ACTIVE),WRITE_SESSION_NOT_ACTIVE,this.status); ResourceId id=ResourceId.createId(name,template); DelegatedResourceSnapshot resource = resolveResource(id, template); return snapshotClass.cast(resource); }
/** * {@inheritDoc} */ @Override public Resource createResource(ResourceTemplate template, Name<?> name) { checkNotNull(name,"Resource name cannot be null"); checkArgument(this.templateLibrary.contains(template),"Unknown template "+template); RootResourceCreator creator= new RootResourceCreator( ResourceId.createId(name,template)); template.accept(creator); return creator.createdResource(); }
/** * {@inheritDoc} */ @Override public Resource createResource(ResourceTemplate template, Name<?> name) { checkNotNull(name,"Resource name cannot be null"); checkArgument(this.templateLibrary.contains(template),"Unknown template "+template); RootResourceCreator creator= new RootResourceCreator( ResourceId.createId(name,template)); template.accept(creator); return creator.createdResource(); }
/** * @param individual * @return */ private ResourceId getIdentifier(final Individual<?, ?> individual) { ResourceId result=null; Object rawId=individual.id(); if(rawId instanceof ManagedIndividualId) { ManagedIndividualId id=(ManagedIndividualId)rawId; result=ResourceId.createId(id.name(),id.managerId()); } return result; }
public static Resource createResource(Name<?> name, String templateId) { return new InMemoryResource(ResourceId.createId(name, templateId)); }
public static Container createContainer(Name<?> name, String templateId) { return new InMemoryContainer(ResourceId.createId(name, templateId)); }
private void assemble() { if(this.cacheAvailable) { return; } this.cacheAvailable=true; if(this.nameValue==null || this.templateId==null) { return; } this.cachedId= ResourceId. createId( Key.fromBase64(this.nameValue), this.templateId); // Self healing... this.nameType=nameTypeOf(this.cachedId.name()); }
@Override DelegatedResourceSnapshot addMember(Name<?> resourceName, DelegatedResourceSnapshot ctx) { checkNotNull(resourceName,"Member resource name cannot be null"); ContainerTemplate containerTemplate=(ContainerTemplate)template(); DelegatedResourceSnapshot newMember=ctx.newChildResource(ResourceId.createId(resourceName, containerTemplate.memberTemplate()),DelegatedResourceSnapshot.class); this.members.addMember(newMember); newMember.markNew(); ctx.markDirty(); if(LOGGER.isTraceEnabled()) { LOGGER.trace("Added member '{}' to '{}'",newMember.resourceId(),ctx.resourceId()); } return newMember; }
private Resource findResource(Name<?> name, Class<? extends ResourceHandler> handlerClass) { ResourceTemplate template = this.templateManagementService.templateOfHandler(handlerClass); ResourceId id = ResourceId.createId(name,template); return this.resourceRepository.resourceOfId(id); }
private PublicResource resolveResource(ManagedIndividualId id) { checkNotNull(id,"Individual identifier cannot be null"); return this.factory.createResource(resolveResource(ResourceId.createId(id.name(), id.managerId()))); }
private ResourceId resourceId(String name) { return ResourceId.createId(NamingScheme.getDefault().name(name), "template"); }
@Override public URI resolve(ResourceSnapshot resource) { ResourceId resourceId = ResourceId.createId( resource.name(), resource.templateId()); try { Endpoint endpoint = context(). resolveResource( resourceId); URI result = null; if(endpoint!=null && endpoint.deleted()==null) { result=this.canonicalBase.resolve(endpoint.path()); } return result; } catch (ApplicationEngineException e) { throw new SnapshotResolutionException("Could not resolve endpoint for resource '"+resourceId+"'",e); } }
@Override <T extends DelegatedResourceSnapshot> T createAttachedResource( Class<? extends T> snapshotClass, String attachmentId, Name<?> name, Class<? extends ResourceHandler> handlerClass, DelegatedResourceSnapshot ctx) { AttachedTemplate attachedTemplate = template().attachedTemplate(attachmentId); checkState(attachedTemplate!=null,"No attachment '%s' is defined for template '%s'",attachmentId,template()); checkState(attachedTemplate.template().handlerClass().isAssignableFrom(handlerClass),"Attachment '%s' of template '%s' is not compatible with '%s' (%s)",attachmentId,template().id(),handlerClass.getCanonicalName(),attachedTemplate.template().handlerClass().getCanonicalName()); checkState(nameFilterForAttachment(attachmentId).isValid(name),"Resource name '%s' is already in use",name); T newSnapshot= ctx.newChildResource(ResourceId.createId(name,attachedTemplate.template()),snapshotClass); DelegatedAttachmentSnapshot newAttachment = AttachmentSnapshotCollection.newAttachment(attachmentId, newSnapshot); this.attachments.add(newAttachment); UnitOfWork.getCurrent().registerDirty(ctx); newSnapshot.markNew(); if(LOGGER.isTraceEnabled()) { LOGGER.trace("Attached '{}' as '{}' to '{}'",newSnapshot.resourceId(),attachmentId,ctx.resourceId()); } return snapshotClass.cast(newSnapshot); }
private Adapter prepareAdapter( final Resource resource, final WriteSessionService service, final WriteSessionConfiguration configuration, final MockResourceSnapshot snapshot, final ResourceHandler handler, final WriteSession session) { new Expectations() {{ service.createSession(configuration);result=session; resource.id();result=ResourceId.createId(resourceName(), templateId()); service.attach((WriteSession)any,resource,handler.getClass());result=snapshot; }}; snapshot.setTemplateId(templateId()); snapshot.setHandler(handler); return AdapterFactory.newAdapter(resource,handler,service,configuration); }
@Test public void adapterExposesResourceIdentifier(final @Mocked Resource resource, final @Mocked WriteSessionService service, final @Mocked WriteSessionConfiguration configuration, final @Mocked WriteSession session) throws Exception { Adapter adapter=prepareAdapter(resource, service,configuration, new MockResourceSnapshot(), new FailingHandler(),session); assertThat(adapter.resourceId(),equalTo(ResourceId.createId(resourceName(), templateId()))); }
@Test public void testResolverSnapshotResolver$resolveSnapshot$resourceGone() throws Exception { final URI base = URI.create("http://www.examples.org/base/"); final ResourceId resourceId = ResourceId.createId(NamingScheme.getDefault().name("name"),"template"); new Expectations() {{ snapshot.name();result=resourceId.name(); snapshot.templateId();result=resourceId.templateId(); engine.unwrap(DefaultApplicationEngine.class);result=engine; engine.activeContext();result=context; context.resolveResource(resourceId);result=endpoint; endpoint.deleted();result=new Date(); }}; new MockUp<ApplicationEngine>() { @Mock public ApplicationEngine engine() throws ApplicationEngineException { return engine; } }; CoreRuntimeDelegate sut=new CoreRuntimeDelegate(); ResourceSnapshotResolver resolver = sut.createResourceResolver(base, session); assertThat(resolver.resolve(snapshot),nullValue()); }
@Test public void testResolverSnapshotResolver$resolveSnapshot$resourceNotfound() throws Exception { final URI base = URI.create("http://www.examples.org/base/"); final ResourceId resourceId = ResourceId.createId(NamingScheme.getDefault().name("name"),"template"); new Expectations() {{ snapshot.name();result=resourceId.name(); snapshot.templateId();result=resourceId.templateId(); engine.unwrap(DefaultApplicationEngine.class);result=engine; engine.activeContext();result=context; context.resolveResource(resourceId);result=null; }}; new MockUp<ApplicationEngine>() { @Mock public ApplicationEngine engine() throws ApplicationEngineException { return engine; } }; CoreRuntimeDelegate sut=new CoreRuntimeDelegate(); ResourceSnapshotResolver resolver = sut.createResourceResolver(base, session); assertThat(resolver.resolve(snapshot),nullValue()); }