Java TenantUtil.runAsSystemTenant方法代码示例

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
/**
 * @see org.alfresco.service.cmr.site.SiteService#listSites(java.lang.String, int)
 */
public List<SiteInfo> listSites(final String userName, final int size)
{
    // MT share - for activity service remote system callback (deprecated)
    if (tenantService.isEnabled() &&
        TenantUtil.isCurrentDomainDefault() &&
        (AuthenticationUtil.SYSTEM_USER_NAME.equals(AuthenticationUtil.getRunAsUser())) && 
        tenantService.isTenantUser(userName))
    {
        final String tenantDomain = tenantService.getUserDomain(userName);
        
        return TenantUtil.runAsSystemTenant(new TenantRunAsWork<List<SiteInfo>>()
        {
            public List<SiteInfo> doWork() throws Exception
            {
                return listSitesImpl(userName, size);
            }
        }, tenantDomain);
    }
    else
    {
        return listSitesImpl(userName, size);
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
public void listMembers(String shortName, final String nameFilter, final String roleFilter, final boolean collapseGroups, final SiteMembersCallback callback)
{
    // MT share - for activity service system callback
    if (tenantService.isEnabled() && (AuthenticationUtil.SYSTEM_USER_NAME.equals(AuthenticationUtil.getRunAsUser())) && tenantService.isTenantName(shortName))
    {
        final String tenantDomain = tenantService.getDomain(shortName);
        final String sName = tenantService.getBaseName(shortName, true);
        
        TenantUtil.runAsSystemTenant(new TenantRunAsWork<Void>()
        {
            public Void doWork() throws Exception
            {
                listMembersImpl(sName, nameFilter, roleFilter, collapseGroups, callback);
                return null;
            }
        }, tenantDomain);
    }
    else
    {
        listMembersImpl(shortName, nameFilter, roleFilter, collapseGroups, callback);
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
/**
 * Returns limited metadata regarding the shared (content) link.
 * <p>
 * Note: does *not* require authenticated access for (public) shared link.
 */
public QuickShareLink readById(final String sharedId, final Parameters parameters)
{
    checkEnabled();

    try
    {
        Pair<String, NodeRef> pair = quickShareService.getTenantNodeRefFromSharedId(sharedId);
        String networkTenantDomain = pair.getFirst();

        return TenantUtil.runAsSystemTenant(new TenantUtil.TenantRunAsWork<QuickShareLink>()
        {
            public QuickShareLink doWork() throws Exception
            {
                // note: assume noAuth here (rather than rely on getRunAsUser which will be null in non-MT)
                return getQuickShareInfo(sharedId, true, parameters.getInclude());
            }
        }, networkTenantDomain);
    }
    catch (InvalidSharedIdException ex)
    {
        logger.warn("Unable to find: " + sharedId);
        throw new EntityNotFoundException(sharedId);
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
public FavouriteFolder getFolder(String networkId, final NodeRef nodeRef)
  {
  	return TenantUtil.runAsSystemTenant(new TenantRunAsWork<FavouriteFolder>()
{
	@Override
	public FavouriteFolder doWork() throws Exception
	{
		FavouriteFolder folder = null;

    	QName type = nodeService.getType(nodeRef);
    	if(dictionaryService.isSubClass(type, ContentModel.TYPE_FOLDER))
    	{
    		Properties properties = getProperties(nodeRef);
    		folder = FavouriteFolder.getFolder(nodeRef.getId(), nodeRef.getId(), properties);
    	}
    	else
    	{
    		throw new IllegalArgumentException("Not a folder node");
    	}

    	return folder;
	}
}, networkId);
  }
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
private RepositoryInfo getRepositoryInfo(final Network network)
{
	final String networkId = network.getTenantDomain();
    final String tenantDomain = (networkId.equals(TenantUtil.SYSTEM_TENANT) || networkId.equals(TenantUtil.DEFAULT_TENANT)) ? TenantService.DEFAULT_DOMAIN : networkId;

    return TenantUtil.runAsSystemTenant(new TenantRunAsWork<RepositoryInfo>()
    {
        public RepositoryInfo doWork()
        {
            RepositoryInfoImpl repoInfo = (RepositoryInfoImpl)connector.getRepositoryInfo(getContext().getCmisVersion());

            repoInfo.setId(!networkId.equals("") ? networkId : TenantUtil.SYSTEM_TENANT);
            repoInfo.setName(tenantDomain);
            repoInfo.setDescription(tenantDomain);

            return repoInfo;
        }
    }, tenantDomain);
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
public Authentication execute() throws Throwable
{
    try
    {
        // We must set full authentication before calling runAs in order to retain tickets
        Pair<String, String> userTenant = AuthenticationUtil.getUserTenant(userNameIn);
        final String userName = userTenant.getFirst();
        final String tenantDomain = userTenant.getSecond();
        
        Authentication authentication = setCurrentUserImpl(userName);
        TenantUtil.runAsSystemTenant(new TenantRunAsWork<Object>()
        {
            public Object doWork() throws Exception
            {
                String identifier;
                if ((identifier = personService.getUserIdentifier(userName)) == null
                     || !identifier.equals(userName)) 
                {
                    if (logger.isDebugEnabled())
                    {
                        logger.debug("User \"" + userName
                                + "\" does not exist in Alfresco. Failing validation.");
                    }
                    throw new AuthenticationException("User \"" + userName + "\" does not exist in Alfresco");
                }
                return null;
            }
        }, tenantDomain);
        
        TenantContextHolder.setTenantDomain(tenantDomain);
        return authentication;
    }
    catch (AuthenticationException ae)
    {
        this.ae = ae;
        return null;
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
private void assertHomeFolderLocation(String tenantDomain, final String username,
        final String expectedPath) throws Exception
{
    try
    {
        final String domainUsername = tenantService.getDomainUser(username, tenantDomain);
        TenantUtil.runAsSystemTenant(new TenantRunAsWork<Object>()
        {
            public NodeRef doWork() throws Exception
            {
                NodeRef person = personService.getPerson(domainUsername, false);
                NodeRef homeFolder = DefaultTypeConverter.INSTANCE.convert(NodeRef.class,
                        nodeService.getProperty(person, ContentModel.PROP_HOMEFOLDER));
                
                if (expectedPath != null)
                {
                    assertNotNull("User: "+domainUsername+" home folder should exist", homeFolder);
                }
                
                NodeRef rootPath = homeFolderManager.getRootPathNodeRef(largeHomeFolderProvider);
                String actualPath = toPath(rootPath, homeFolder);
                assertEquals("User: "+domainUsername+" home folder location", expectedPath, actualPath);
                return null;
            }
        }, tenantDomain);
    }
    catch (RuntimeException e)
    {
        final Throwable cause = e.getCause();
        if (cause instanceof ComparisonFailure || cause instanceof AssertionError)
        {
            throw (ComparisonFailure)cause;
        }
        else
        {
            throw e;
        }
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
private Set<NodeRef> deleteNonAdminGuestUsers()
{
    final Set<NodeRef> adminGuestUserHomeFolders = new HashSet<NodeRef>();
    for (final NodeRef nodeRef : personService.getAllPeople())
    {
        final String username = DefaultTypeConverter.INSTANCE.convert(String.class,
                nodeService.getProperty(nodeRef, ContentModel.PROP_USERNAME));
        final String domainUsername = tenantService.getBaseNameUser(username);
        String tenantDomain = tenantService.getUserDomain(username);
        boolean disabled = !TenantService.DEFAULT_DOMAIN.equals(tenantDomain) &&
                           !tenantAdminService.isEnabledTenant(tenantDomain);
        try
        {
            if (disabled)
            {
                tenantAdminService.enableTenant(tenantDomain);
            }
            TenantUtil.runAsSystemTenant(new TenantRunAsWork<Object>()
            {
                public Object doWork() throws Exception
                {
                    deleteUser(adminGuestUserHomeFolders, nodeRef, username, domainUsername);
                    return null;
                }
            }, tenantDomain);
        }
        finally
        {
            if (disabled)
            {
                tenantAdminService.disableTenant(tenantDomain);
            }
        }
    }
    return adminGuestUserHomeFolders;
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
protected Set<String> getFollowers(final String userId, String tenantDomain) throws Exception
{
    if (useRemoteCallbacks)
    {
        // note: not implemented
        throw new UnsupportedOperationException("Not implemented");
    }
    
    final Set<String> result = new HashSet<String>();
    
    if (subscriptionService.isActive())
    {
        TenantUtil.runAsSystemTenant(new TenantUtil.TenantRunAsWork<Void>()
        {
            public Void doWork() throws Exception
            {
                PagingFollowingResults fr = subscriptionService.getFollowers(userId, new PagingRequest(1000000, null));
                
                if (fr.getPage() != null)
                {
                    result.addAll(fr.getPage());
                }
                
                return null;
            }
        }, tenantDomain);
    }
    
    return result;
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
/**
 * Calls the feed notifier to do its work
 */
public void execute(JobExecutionContext context) throws JobExecutionException
{
    JobDataMap jobData = context.getJobDetail().getJobDataMap();
    
    final FeedNotifier feedNotifier = (FeedNotifier)jobData.get(KEY_FEED_NOTIFIER);
    final TenantAdminService tenantAdminService = (TenantAdminService)jobData.get(KEY_TENANT_ADMIN_SERVICE);
    
    Long repeatInterval = null;
    Trigger trigger = context.getTrigger();
    if (trigger instanceof SimpleTrigger)
    {
        repeatInterval = ((SimpleTrigger)trigger).getRepeatInterval();
    }
    
    final int repeatIntervalMins = new Long(repeatInterval == null ? 0L : repeatInterval / 1000 / 60).intValue();
    
    AuthenticationUtil.runAs(new RunAsWork<Object>()
    {
        public Object doWork() throws Exception
        {
            feedNotifier.execute(repeatIntervalMins);
            return null;
        }
    }, AuthenticationUtil.getSystemUserName());
    
    if ((tenantAdminService != null) && tenantAdminService.isEnabled())
    {
        List<Tenant> tenants = tenantAdminService.getAllTenants();
        for (Tenant tenant : tenants)
        {
            TenantUtil.runAsSystemTenant(new TenantRunAsWork<Object>()
            {
                public Object doWork() throws Exception
                {
                    feedNotifier.execute(repeatIntervalMins);
                    return null;
                }
            }, tenant.getTenantDomain());
        }
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
public List<Document> createDocuments(final String stringNodeRef, final FTSStatus ftsStatus,
        final boolean indexAllProperties, final boolean includeDirectoryDocuments, final boolean cascade,
        final Set<Pair<Boolean, Path>> pathsToRegenerate,
        final Map<NodeRef, List<ChildAssociationRef>> childAssociationsSinceFlush, final IndexReader deltaReader,
        final IndexReader mainReader)
{
    if (tenantService.isEnabled() && ((AuthenticationUtil.getRunAsUser() == null) || (AuthenticationUtil.isRunAsUserTheSystemUser())))
    {
        // ETHREEOH-2014 - dictionary access should be in context of tenant (eg. full reindex with MT dynamic
        // models)
        return TenantUtil.runAsSystemTenant(new TenantRunAsWork<List<Document>>()
        {
            public List<Document> doWork()
            {
                return createDocumentsImpl(stringNodeRef, ftsStatus, indexAllProperties, includeDirectoryDocuments,
                        cascade, pathsToRegenerate, childAssociationsSinceFlush, deltaReader, mainReader);
            }
        }, tenantService.getDomain(new NodeRef(stringNodeRef).getStoreRef().getIdentifier()));
    }
    else if (tenantService.isEnabled() && !tenantService.getDomain(new NodeRef(stringNodeRef).getStoreRef().getIdentifier()).equals(TenantService.DEFAULT_DOMAIN))
    {
        return TenantUtil.runAsTenant(new TenantRunAsWork<List<Document>>()
        {
            public List<Document> doWork()
            {
                return createDocumentsImpl(stringNodeRef, ftsStatus, indexAllProperties, includeDirectoryDocuments,
                        cascade, pathsToRegenerate, childAssociationsSinceFlush, deltaReader, mainReader);
            }
        }, tenantService.getDomain(new NodeRef(stringNodeRef).getStoreRef().getIdentifier()));
    }
    else
    {
        return createDocumentsImpl(stringNodeRef, ftsStatus, indexAllProperties, includeDirectoryDocuments,
                cascade, pathsToRegenerate, childAssociationsSinceFlush, deltaReader, mainReader);
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
private void initializeNetwork3WithSites() throws Exception
{
    String siteDescription = "description";

    if (network3 == null)
    {
        network3 = getRepoService().createNetwork(this.getClass().getName().toLowerCase() + "-3-" + RUNID, true);
        network3.create();

        TenantUtil.runAsSystemTenant(new TenantRunAsWork<Void>()
        {
            @Override
            public Void doWork() throws Exception
            {
                person4Id = network3.createUser().getId();
                return null;
            }
        }, network3.getId());

        TenantUtil.runAsUserTenant(new TenantRunAsWork<Void>()
        {
            @Override
            public Void doWork() throws Exception
            {
                // Temporary solution for testing as for now creating a site
                // with site preset is not allowed (please see REPO-194)
                site7 = network3.createSite("a-" + GUID.generate(), "site A" + GUID.generate(), siteDescription, preset, SiteVisibility.PRIVATE);
                site8 = network3.createSite("b-" + GUID.generate(), "site B" + GUID.generate(), siteDescription, preset, SiteVisibility.PUBLIC);
                site9 = network3.createSite("c-" + GUID.generate(), "site C" + GUID.generate(), siteDescription, preset, SiteVisibility.PUBLIC);
                site10 = network3.createSite("d-" + GUID.generate(), "site D" + GUID.generate(), siteDescription, "site-dashboard", SiteVisibility.MODERATED);
                return null;
            }
        }, person4Id, network3.getId());
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
@Override
protected Map<String, Object> executeImpl(final WebScriptRequest req, final Status status)
{
    String tenantDomain = TenantService.DEFAULT_DOMAIN;
    
    if (tenantService.isEnabled())
    {
        String inviteeUserName = req.getParameter(PARAM_INVITEE_USER_NAME);
        if (inviteeUserName != null)
        {
            tenantDomain = tenantService.getUserDomain(inviteeUserName);
        }
    }
    
    // run as system user
    String mtAwareSystemUser = tenantService.getDomainUser(AuthenticationUtil.getSystemUserName(), tenantDomain);
    
    Map<String, Object> ret = TenantUtil.runAsSystemTenant(new TenantRunAsWork<Map<String, Object>>()
    {
        public Map<String, Object> doWork() throws Exception
        {
            return execute(req, status);
        }
    }, tenantDomain);
    
    // authenticate as system for the rest of the webscript
    AuthenticationUtil.setRunAsUser(mtAwareSystemUser);
    
    return ret;
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
private void reset(String tenantDomain)
{
    if (logger.isDebugEnabled()) 
    {
        logger.debug("Resetting messages ...");
    }
    
    TenantUtil.runAsSystemTenant(new TenantRunAsWork<Object>()
    {
        public Object doWork()
        {  
            destroy();
            init();
           
            for (final MessageDeployer messageDeployer : messageDeployers)
            {
                messageDeployer.initMessages();
            }
           
            return null;
        }
    }, tenantDomain);

    if (logger.isDebugEnabled()) 
    {
        logger.debug("... resetting messages completed");
    }
}
 

import org.alfresco.repo.tenant.TenantUtil; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
public void execute(final Api api, final WebScriptRequest req, final WebScriptResponse res) throws IOException
{
    try
    {
        final Map<String, Object> respons = new HashMap<String, Object>();
        final Map<String, String> templateVars = req.getServiceMatch().getTemplateVars();
        final ResourceWithMetadata resource = locator.locateResource(api,templateVars, httpMethod);
        final Params params = paramsExtractor.extractParams(resource.getMetaData(),req);
        final boolean isReadOnly = HttpMethod.GET==httpMethod;

        //This execution usually takes place in a Retrying Transaction (see subclasses)
        final Object toSerialize = execute(resource, params, res, isReadOnly);
        
        //Outside the transaction.
        if (toSerialize != null)
        {
            if (toSerialize instanceof BinaryResource)
            {
                // TODO review (experimental) - can we move earlier & wrap complete execute ? Also for QuickShare (in MT/Cloud) needs to be tenant for the nodeRef (TBC).
                boolean noAuth = false;

                if (BinaryResourceAction.Read.class.isAssignableFrom(resource.getResource().getClass()))
                {
                    noAuth = resource.getMetaData().isNoAuth(BinaryResourceAction.Read.class);
                }
                else if (RelationshipResourceBinaryAction.Read.class.isAssignableFrom(resource.getResource().getClass()))
                {
                    noAuth = resource.getMetaData().isNoAuth(RelationshipResourceBinaryAction.Read.class);
                }
                else
                {
                    logger.warn("Unexpected");
                }

                if (noAuth)
                {
                    String networkTenantDomain = TenantUtil.getCurrentDomain();

                    TenantUtil.runAsSystemTenant(new TenantUtil.TenantRunAsWork<Void>()
                    {
                        public Void doWork() throws Exception
                        {
                            streamResponse(req, res, (BinaryResource) toSerialize);
                            return null;
                        }
                    }, networkTenantDomain);
                }
                else
                {
                    streamResponse(req, res, (BinaryResource) toSerialize);
                }
            }
            else
            {
                renderJsonResponse(res, toSerialize, assistant.getJsonHelper());
            }
        }

    }
    catch (AlfrescoRuntimeException | ApiException | WebScriptException xception )
    {
        renderException(xception, res, assistant);
    }
    catch (RuntimeException runtimeException)
    {
        renderException(runtimeException, res, assistant);
    }
}