Examples with AccountVO com.cloud.user.AccountVO used on opensource projects

Example 71 with AccountVO

use of com.cloud.user.AccountVO in project CloudStack-archive by CloudStack-extras.

the class UsageManagerImpl method parse.

public void parse(UsageJobVO job, long startDateMillis, long endDateMillis) {
    // TODO: Shouldn't we also allow parsing by the type of usage?
    boolean success = false;
    long timeStart = System.currentTimeMillis();
    long deleteOldStatsTimeMillis = 0L;
    try {
        if ((endDateMillis == 0) || (endDateMillis > timeStart)) {
            endDateMillis = timeStart;
        }
        long lastSuccess = m_usageJobDao.getLastJobSuccessDateMillis();
        if (lastSuccess != 0) {
            // 1 millisecond after
            startDateMillis = lastSuccess + 1;
        }
        if (startDateMillis >= endDateMillis) {
            if (s_logger.isInfoEnabled()) {
                s_logger.info("not parsing usage records since start time mills (" + startDateMillis + ") is on or after end time millis (" + endDateMillis + ")");
            }
            Transaction jobUpdateTxn = Transaction.open(Transaction.USAGE_DB);
            try {
                jobUpdateTxn.start();
                // everything seemed to work...set endDate as the last success date
                m_usageJobDao.updateJobSuccess(job.getId(), startDateMillis, endDateMillis, System.currentTimeMillis() - timeStart, success);
                // create a new job if this is a recurring job
                if (job.getJobType() == UsageJobVO.JOB_TYPE_RECURRING) {
                    m_usageJobDao.createNewJob(m_hostname, m_pid, UsageJobVO.JOB_TYPE_RECURRING);
                }
                jobUpdateTxn.commit();
            } finally {
                jobUpdateTxn.close();
            }
            return;
        }
        deleteOldStatsTimeMillis = startDateMillis;
        Date startDate = new Date(startDateMillis);
        Date endDate = new Date(endDateMillis);
        if (s_logger.isInfoEnabled()) {
            s_logger.info("Parsing usage records between " + startDate + " and " + endDate);
        }
        List<AccountVO> accounts = null;
        List<UserStatisticsVO> userStats = null;
        Map<String, UsageNetworkVO> networkStats = null;
        Transaction userTxn = Transaction.open(Transaction.CLOUD_DB);
        try {
            Long limit = Long.valueOf(500);
            Long offset = Long.valueOf(0);
            Long lastAccountId = m_usageDao.getLastAccountId();
            if (lastAccountId == null) {
                lastAccountId = Long.valueOf(0);
            }
            do {
                Filter filter = new Filter(AccountVO.class, "id", true, offset, limit);
                accounts = m_accountDao.findActiveAccounts(lastAccountId, filter);
                if ((accounts != null) && !accounts.isEmpty()) {
                    // now update the accounts in the cloud_usage db
                    m_usageDao.updateAccounts(accounts);
                }
                offset = new Long(offset.longValue() + limit.longValue());
            } while ((accounts != null) && !accounts.isEmpty());
            // reset offset
            offset = Long.valueOf(0);
            do {
                Filter filter = new Filter(AccountVO.class, "id", true, offset, limit);
                accounts = m_accountDao.findRecentlyDeletedAccounts(lastAccountId, startDate, filter);
                if ((accounts != null) && !accounts.isEmpty()) {
                    // now update the accounts in the cloud_usage db
                    m_usageDao.updateAccounts(accounts);
                }
                offset = new Long(offset.longValue() + limit.longValue());
            } while ((accounts != null) && !accounts.isEmpty());
            // reset offset
            offset = Long.valueOf(0);
            do {
                Filter filter = new Filter(AccountVO.class, "id", true, offset, limit);
                accounts = m_accountDao.findNewAccounts(lastAccountId, filter);
                if ((accounts != null) && !accounts.isEmpty()) {
                    // now copy the accounts to cloud_usage db
                    m_usageDao.saveAccounts(accounts);
                }
                offset = new Long(offset.longValue() + limit.longValue());
            } while ((accounts != null) && !accounts.isEmpty());
            // reset offset
            offset = Long.valueOf(0);
            // get all the user stats to create usage records for the network usage
            Long lastUserStatsId = m_usageDao.getLastUserStatsId();
            if (lastUserStatsId == null) {
                lastUserStatsId = Long.valueOf(0);
            }
            SearchCriteria<UserStatisticsVO> sc2 = m_userStatsDao.createSearchCriteria();
            sc2.addAnd("id", SearchCriteria.Op.LTEQ, lastUserStatsId);
            do {
                Filter filter = new Filter(UserStatisticsVO.class, "id", true, offset, limit);
                userStats = m_userStatsDao.search(sc2, filter);
                if ((userStats != null) && !userStats.isEmpty()) {
                    // now copy the accounts to cloud_usage db
                    m_usageDao.updateUserStats(userStats);
                }
                offset = new Long(offset.longValue() + limit.longValue());
            } while ((userStats != null) && !userStats.isEmpty());
            // reset offset
            offset = Long.valueOf(0);
            sc2 = m_userStatsDao.createSearchCriteria();
            sc2.addAnd("id", SearchCriteria.Op.GT, lastUserStatsId);
            do {
                Filter filter = new Filter(UserStatisticsVO.class, "id", true, offset, limit);
                userStats = m_userStatsDao.search(sc2, filter);
                if ((userStats != null) && !userStats.isEmpty()) {
                    // now copy the accounts to cloud_usage db
                    m_usageDao.saveUserStats(userStats);
                }
                offset = new Long(offset.longValue() + limit.longValue());
            } while ((userStats != null) && !userStats.isEmpty());
        } finally {
            userTxn.close();
        }
        // TODO:  Fetch a maximum number of events and process them before moving on to the next range of events
        // - get a list of the latest events
        // - insert the latest events into the usage.events table
        List<UsageEventVO> events = _usageEventDao.getRecentEvents(new Date(endDateMillis));
        Transaction usageTxn = Transaction.open(Transaction.USAGE_DB);
        try {
            usageTxn.start();
            // to newest, so just test against the first event)
            if ((events != null) && (events.size() > 0)) {
                Date oldestEventDate = events.get(0).getCreateDate();
                if (oldestEventDate.getTime() < startDateMillis) {
                    startDateMillis = oldestEventDate.getTime();
                    startDate = new Date(startDateMillis);
                }
                // - create the usage records using the parse methods below
                for (UsageEventVO event : events) {
                    event.setProcessed(true);
                    _usageEventDao.update(event.getId(), event);
                    createHelperRecord(event);
                }
            }
            // TODO:  Fetch a maximum number of user stats and process them before moving on to the next range of user stats
            // get user stats in order to compute network usage
            networkStats = m_usageNetworkDao.getRecentNetworkStats();
            Calendar recentlyDeletedCal = Calendar.getInstance(m_usageTimezone);
            recentlyDeletedCal.setTimeInMillis(startDateMillis);
            recentlyDeletedCal.add(Calendar.MINUTE, -1 * THREE_DAYS_IN_MINUTES);
            Date recentlyDeletedDate = recentlyDeletedCal.getTime();
            // Keep track of user stats for an account, across all of its public IPs
            Map<String, UserStatisticsVO> aggregatedStats = new HashMap<String, UserStatisticsVO>();
            int startIndex = 0;
            do {
                userStats = m_userStatsDao.listActiveAndRecentlyDeleted(recentlyDeletedDate, startIndex, 500);
                if (userStats != null) {
                    for (UserStatisticsVO userStat : userStats) {
                        if (userStat.getDeviceId() != null) {
                            String hostKey = userStat.getDataCenterId() + "-" + userStat.getAccountId() + "-Host-" + userStat.getDeviceId();
                            UserStatisticsVO hostAggregatedStat = aggregatedStats.get(hostKey);
                            if (hostAggregatedStat == null) {
                                hostAggregatedStat = new UserStatisticsVO(userStat.getAccountId(), userStat.getDataCenterId(), userStat.getPublicIpAddress(), userStat.getDeviceId(), userStat.getDeviceType(), userStat.getNetworkId());
                            }
                            hostAggregatedStat.setAggBytesSent(hostAggregatedStat.getAggBytesSent() + userStat.getAggBytesSent());
                            hostAggregatedStat.setAggBytesReceived(hostAggregatedStat.getAggBytesReceived() + userStat.getAggBytesReceived());
                            aggregatedStats.put(hostKey, hostAggregatedStat);
                        }
                    }
                }
                startIndex += 500;
            } while ((userStats != null) && !userStats.isEmpty());
            // loop over the user stats, create delta entries in the usage_network helper table
            int numAcctsProcessed = 0;
            for (String key : aggregatedStats.keySet()) {
                UsageNetworkVO currentNetworkStats = null;
                if (networkStats != null) {
                    currentNetworkStats = networkStats.get(key);
                }
                createNetworkHelperEntry(aggregatedStats.get(key), currentNetworkStats, endDateMillis);
                numAcctsProcessed++;
            }
            if (s_logger.isDebugEnabled()) {
                s_logger.debug("created network stats helper entries for " + numAcctsProcessed + " accts");
            }
            // commit the helper records, then start a new transaction
            usageTxn.commit();
            usageTxn.start();
            boolean parsed = false;
            numAcctsProcessed = 0;
            Date currentStartDate = startDate;
            Date currentEndDate = endDate;
            Date tempDate = endDate;
            Calendar aggregateCal = Calendar.getInstance(m_usageTimezone);
            while ((tempDate.after(startDate)) && ((tempDate.getTime() - startDate.getTime()) > 60000)) {
                currentEndDate = tempDate;
                aggregateCal.setTime(tempDate);
                aggregateCal.add(Calendar.MINUTE, -m_aggregationDuration);
                tempDate = aggregateCal.getTime();
            }
            while (!currentEndDate.after(endDate) || (currentEndDate.getTime() - endDate.getTime() < 60000)) {
                Long offset = Long.valueOf(0);
                Long limit = Long.valueOf(500);
                do {
                    Filter filter = new Filter(AccountVO.class, "id", true, offset, limit);
                    accounts = m_accountDao.listAll(filter);
                    if ((accounts != null) && !accounts.isEmpty()) {
                        for (AccountVO account : accounts) {
                            parsed = parseHelperTables(account, currentStartDate, currentEndDate);
                            numAcctsProcessed++;
                        }
                    }
                    offset = new Long(offset.longValue() + limit.longValue());
                } while ((accounts != null) && !accounts.isEmpty());
                if (s_logger.isDebugEnabled()) {
                    s_logger.debug("processed VM/Network Usage for " + numAcctsProcessed + " ACTIVE accts");
                }
                numAcctsProcessed = 0;
                // reset offset
                offset = Long.valueOf(0);
                do {
                    Filter filter = new Filter(AccountVO.class, "id", true, offset, limit);
                    accounts = m_accountDao.findRecentlyDeletedAccounts(null, recentlyDeletedDate, filter);
                    if ((accounts != null) && !accounts.isEmpty()) {
                        for (AccountVO account : accounts) {
                            parsed = parseHelperTables(account, currentStartDate, currentEndDate);
                            List<Long> publicTemplates = m_usageDao.listPublicTemplatesByAccount(account.getId());
                            for (Long templateId : publicTemplates) {
                                //mark public templates owned by deleted accounts as deleted
                                List<UsageStorageVO> storageVOs = m_usageStorageDao.listById(account.getId(), templateId, StorageTypes.TEMPLATE);
                                if (storageVOs.size() > 1) {
                                    s_logger.warn("More that one usage entry for storage: " + templateId + " assigned to account: " + account.getId() + "; marking them all as deleted...");
                                }
                                for (UsageStorageVO storageVO : storageVOs) {
                                    if (s_logger.isDebugEnabled()) {
                                        s_logger.debug("deleting template: " + storageVO.getId() + " from account: " + storageVO.getAccountId());
                                    }
                                    storageVO.setDeleted(account.getRemoved());
                                    m_usageStorageDao.update(storageVO);
                                }
                            }
                            numAcctsProcessed++;
                        }
                    }
                    offset = new Long(offset.longValue() + limit.longValue());
                } while ((accounts != null) && !accounts.isEmpty());
                currentStartDate = new Date(currentEndDate.getTime() + 1);
                aggregateCal.setTime(currentEndDate);
                aggregateCal.add(Calendar.MINUTE, m_aggregationDuration);
                currentEndDate = aggregateCal.getTime();
            }
            if (s_logger.isDebugEnabled()) {
                s_logger.debug("processed Usage for " + numAcctsProcessed + " RECENTLY DELETED accts");
            }
            //        do we want to break out of processing accounts and rollback if there are errors?
            if (!parsed) {
                usageTxn.rollback();
            } else {
                success = true;
            }
        } catch (Exception ex) {
            s_logger.error("Exception in usage manager", ex);
            usageTxn.rollback();
        } finally {
            // everything seemed to work...set endDate as the last success date
            m_usageJobDao.updateJobSuccess(job.getId(), startDateMillis, endDateMillis, System.currentTimeMillis() - timeStart, success);
            // create a new job if this is a recurring job
            if (job.getJobType() == UsageJobVO.JOB_TYPE_RECURRING) {
                m_usageJobDao.createNewJob(m_hostname, m_pid, UsageJobVO.JOB_TYPE_RECURRING);
            }
            usageTxn.commit();
            usageTxn.close();
            // switch back to CLOUD_DB
            Transaction swap = Transaction.open(Transaction.CLOUD_DB);
            if (!success) {
                _alertMgr.sendAlert(AlertManager.ALERT_TYPE_USAGE_SERVER_RESULT, 0, new Long(0), "Usage job failed. Job id: " + job.getId(), "Usage job failed. Job id: " + job.getId());
            } else {
                _alertMgr.clearAlert(AlertManager.ALERT_TYPE_USAGE_SERVER_RESULT, 0, 0);
            }
            swap.close();
        }
    } catch (Exception e) {
        s_logger.error("Usage Manager error", e);
    }
}

Example 72 with AccountVO

use of com.cloud.user.AccountVO in project cloudstack by apache.

the class IAMApiServiceImpl method createIAMPolicyResponse.

@Override
public IAMPolicyResponse createIAMPolicyResponse(IAMPolicy policy) {
    IAMPolicyResponse response = new IAMPolicyResponse();
    response.setId(policy.getUuid());
    response.setName(policy.getName());
    response.setDescription(policy.getDescription());
    String domainPath = policy.getPath();
    if (domainPath != null) {
        DomainVO domain = _domainDao.findDomainByPath(domainPath);
        if (domain != null) {
            response.setDomainId(domain.getUuid());
            response.setDomainName(domain.getName());
        }
    }
    long accountId = policy.getAccountId();
    AccountVO owner = _accountDao.findById(accountId);
    if (owner != null) {
        response.setAccountName(owner.getAccountName());
    }
    // find permissions associated with this policy
    List<IAMPolicyPermission> permissions = _iamSrv.listPolicyPermissions(policy.getId());
    if (permissions != null && permissions.size() > 0) {
        for (IAMPolicyPermission permission : permissions) {
            IAMPermissionResponse perm = new IAMPermissionResponse();
            perm.setAction(permission.getAction());
            if (permission.getEntityType() != null) {
                perm.setEntityType(permission.getEntityType());
            }
            if (permission.getScope() != null) {
                perm.setScope(PermissionScope.valueOf(permission.getScope()));
            }
            perm.setScopeId(permission.getScopeId());
            perm.setPermission(permission.getPermission());
            response.addPermission(perm);
        }
    }
    response.setObjectName("aclpolicy");
    return response;
}

Example 73 with AccountVO

use of com.cloud.user.AccountVO in project cloudstack by apache.

the class IAMApiServiceImpl method configure.

@Override
public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException {
    _messageBus.subscribe(AccountManager.MESSAGE_ADD_ACCOUNT_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            HashMap<Long, Long> acctGroupMap = (HashMap<Long, Long>) obj;
            for (Long accountId : acctGroupMap.keySet()) {
                Long groupId = acctGroupMap.get(accountId);
                s_logger.debug("MessageBus message: new Account Added: " + accountId + ", adding it to groupId :" + groupId);
                addAccountToIAMGroup(accountId, groupId);
                // add it to domain group too
                AccountVO account = _accountDao.findById(accountId);
                Domain domain = _domainDao.findById(account.getDomainId());
                if (domain != null) {
                    List<IAMGroup> domainGroups = listDomainGroup(domain);
                    if (domainGroups != null) {
                        for (IAMGroup group : domainGroups) {
                            addAccountToIAMGroup(accountId, new Long(group.getId()));
                        }
                    }
                }
            }
        }
    });
    _messageBus.subscribe(AccountManager.MESSAGE_REMOVE_ACCOUNT_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Long accountId = ((Long) obj);
            if (accountId != null) {
                s_logger.debug("MessageBus message: Account removed: " + accountId + ", releasing the group associations");
                removeAccountFromIAMGroups(accountId);
            }
        }
    });
    _messageBus.subscribe(DomainManager.MESSAGE_ADD_DOMAIN_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Long domainId = ((Long) obj);
            if (domainId != null) {
                s_logger.debug("MessageBus message: new Domain created: " + domainId + ", creating a new group");
                Domain domain = _domainDao.findById(domainId);
                _iamSrv.createIAMGroup("DomainGrp-" + domain.getUuid(), "Domain group", domain.getPath());
            }
        }
    });
    _messageBus.subscribe(DomainManager.MESSAGE_REMOVE_DOMAIN_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Long domainId = ((Long) obj);
            if (domainId != null) {
                s_logger.debug("MessageBus message: Domain removed: " + domainId + ", removing the domain group");
                Domain domain = _domainDao.findById(domainId);
                List<IAMGroup> groups = listDomainGroup(domain);
                for (IAMGroup group : groups) {
                    _iamSrv.deleteIAMGroup(group.getId());
                }
            }
        }
    });
    _messageBus.subscribe(TemplateManager.MESSAGE_REGISTER_PUBLIC_TEMPLATE_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Long templateId = (Long) obj;
            if (templateId != null) {
                s_logger.debug("MessageBus message: new public template registered: " + templateId + ", grant permission to default root admin, domain admin and normal user policies");
                _iamSrv.addIAMPermissionToIAMPolicy(new Long(Account.ACCOUNT_TYPE_ADMIN + 1), VirtualMachineTemplate.class.getSimpleName(), PermissionScope.RESOURCE.toString(), templateId, "listTemplates", AccessType.UseEntry.toString(), Permission.Allow, false);
                _iamSrv.addIAMPermissionToIAMPolicy(new Long(Account.ACCOUNT_TYPE_DOMAIN_ADMIN + 1), VirtualMachineTemplate.class.getSimpleName(), PermissionScope.RESOURCE.toString(), templateId, "listTemplates", AccessType.UseEntry.toString(), Permission.Allow, false);
                _iamSrv.addIAMPermissionToIAMPolicy(new Long(Account.ACCOUNT_TYPE_NORMAL + 1), VirtualMachineTemplate.class.getSimpleName(), PermissionScope.RESOURCE.toString(), templateId, "listTemplates", AccessType.UseEntry.toString(), Permission.Allow, false);
            }
        }
    });
    _messageBus.subscribe(TemplateManager.MESSAGE_RESET_TEMPLATE_PERMISSION_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Long templateId = (Long) obj;
            if (templateId != null) {
                s_logger.debug("MessageBus message: reset template permission: " + templateId);
                resetTemplatePermission(templateId);
            }
        }
    });
    _messageBus.subscribe(EntityManager.MESSAGE_REMOVE_ENTITY_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Pair<Class<?>, Long> entity = (Pair<Class<?>, Long>) obj;
            if (entity != null) {
                String entityType = entity.first().getSimpleName();
                Long entityId = entity.second();
                s_logger.debug("MessageBus message: delete an entity: (" + entityType + "," + entityId + "), remove its related permission");
                _iamSrv.removeIAMPermissionForEntity(entityType, entityId);
            }
        }
    });
    _messageBus.subscribe(EntityManager.MESSAGE_GRANT_ENTITY_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Map<String, Object> permit = (Map<String, Object>) obj;
            if (permit != null) {
                Class<?> entityType = (Class<?>) permit.get(ApiConstants.ENTITY_TYPE);
                Long entityId = (Long) permit.get(ApiConstants.ENTITY_ID);
                AccessType accessType = (AccessType) permit.get(ApiConstants.ACCESS_TYPE);
                String action = (String) permit.get(ApiConstants.IAM_ACTION);
                List<Long> acctIds = (List<Long>) permit.get(ApiConstants.ACCOUNTS);
                s_logger.debug("MessageBus message: grant accounts permission to an entity: (" + entityType + "," + entityId + ")");
                grantEntityPermissioinToAccounts(entityType.getSimpleName(), entityId, accessType, action, acctIds);
            }
        }
    });
    _messageBus.subscribe(EntityManager.MESSAGE_REVOKE_ENTITY_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Map<String, Object> permit = (Map<String, Object>) obj;
            if (permit != null) {
                Class<?> entityType = (Class<?>) permit.get(ApiConstants.ENTITY_TYPE);
                Long entityId = (Long) permit.get(ApiConstants.ENTITY_ID);
                AccessType accessType = (AccessType) permit.get(ApiConstants.ACCESS_TYPE);
                String action = (String) permit.get(ApiConstants.IAM_ACTION);
                List<Long> acctIds = (List<Long>) permit.get(ApiConstants.ACCOUNTS);
                s_logger.debug("MessageBus message: revoke from accounts permission to an entity: (" + entityType + "," + entityId + ")");
                revokeEntityPermissioinFromAccounts(entityType.getSimpleName(), entityId, accessType, action, acctIds);
            }
        }
    });
    _messageBus.subscribe(EntityManager.MESSAGE_ADD_DOMAIN_WIDE_ENTITY_EVENT, new MessageSubscriber() {

        @Override
        public void onPublishMessage(String senderAddress, String subject, Object obj) {
            Map<String, Object> params = (Map<String, Object>) obj;
            if (params != null) {
                addDomainWideResourceAccess(params);
            }
        }
    });
    return super.configure(name, params);
}

Example 74 with AccountVO

use of com.cloud.user.AccountVO in project cloudstack by apache.

the class QuotaManagerImplTest method testAggregatePendingQuotaRecordsForAccount.

@Test
public void testAggregatePendingQuotaRecordsForAccount() {
    AccountVO accountVO = new AccountVO();
    accountVO.setId(2L);
    accountVO.setDomainId(1L);
    accountVO.setType(Account.ACCOUNT_TYPE_NORMAL);
    UsageVO usageVO = new UsageVO();
    usageVO.setQuotaCalculated(0);
    usageVO.setUsageType(UsageTypes.ALLOCATED_VM);
    List<UsageVO> usageVOList = new ArrayList<UsageVO>();
    usageVOList.add(usageVO);
    Pair<List<? extends UsageVO>, Integer> usageRecords = new Pair<List<? extends UsageVO>, Integer>(usageVOList, usageVOList.size());
    QuotaUsageVO quotaUsageVO = new QuotaUsageVO();
    quotaUsageVO.setAccountId(2L);
    Mockito.doReturn(quotaUsageVO).when(quotaManager).updateQuotaAllocatedVMUsage(Mockito.eq(usageVO), Mockito.any(BigDecimal.class));
    assertTrue(quotaManager.aggregatePendingQuotaRecordsForAccount(accountVO, new Pair<List<? extends UsageVO>, Integer>(null, 0)).size() == 0);
    assertTrue(quotaManager.aggregatePendingQuotaRecordsForAccount(accountVO, usageRecords).size() == 1);
}

Example 75 with AccountVO

use of com.cloud.user.AccountVO in project cloudstack by apache.

the class DynamicRoleBasedAPIAccessCheckerTest method testDefaultRootAdminAccess.

@Test
public void testDefaultRootAdminAccess() {
    Mockito.when(accountService.getAccount(Mockito.anyLong())).thenReturn(new AccountVO("root admin", 1L, null, (short) 1, "some-uuid"));
    Mockito.when(roleService.findRole(Mockito.anyLong())).thenReturn(new RoleVO(1L, "SomeRole", RoleType.Admin, "default root admin role"));
    assertTrue(apiAccessChecker.checkAccess(getTestUser(), "anyApi"));
}