Examples with Contract io.apiman.gateway.engine.beans.Contract used on opensource projects

Example 11 with Contract

use of io.apiman.gateway.engine.beans.Contract in project apiman by apiman.

the class InMemoryRegistry method getContract.

/**
 * @see io.apiman.gateway.engine.IRegistry#getContract(java.lang.String, java.lang.String, java.lang.String, java.lang.String, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void getContract(String apiOrganizationId, String apiId, String apiVersion, String apiKey, IAsyncResultHandler<ApiContract> handler) {
    Client client = null;
    Api api = null;
    String apiIdx = getApiIndex(apiOrganizationId, apiId, apiVersion);
    synchronized (mutex) {
        client = (Client) getMap().get(apiKey);
        api = (Api) getMap().get(apiIdx);
    }
    if (client == null) {
        // $NON-NLS-1$
        Exception error = new ClientNotFoundException(Messages.i18n.format("InMemoryRegistry.NoClientForAPIKey", apiKey));
        handler.handle(AsyncResultImpl.create(error, ApiContract.class));
        return;
    }
    if (api == null) {
        Exception error = new ApiRetiredException(// $NON-NLS-1$
        Messages.i18n.format(// $NON-NLS-1$
        "InMemoryRegistry.ApiWasRetired", apiId, apiOrganizationId));
        handler.handle(AsyncResultImpl.create(error, ApiContract.class));
        return;
    }
    Contract matchedContract = null;
    for (Contract contract : client.getContracts()) {
        if (contract.matches(apiOrganizationId, apiId, apiVersion)) {
            matchedContract = contract;
            break;
        }
    }
    if (matchedContract == null) {
        Exception error = new NoContractFoundException(// $NON-NLS-1$
        Messages.i18n.format(// $NON-NLS-1$
        "InMemoryRegistry.NoContractFound", client.getClientId(), api.getApiId()));
        handler.handle(AsyncResultImpl.create(error, ApiContract.class));
        return;
    }
    ApiContract contract = new ApiContract(api, client, matchedContract.getPlan(), matchedContract.getPolicies());
    handler.handle(AsyncResultImpl.create(contract));
}

Example 12 with Contract

use of io.apiman.gateway.engine.beans.Contract in project apiman by apiman.

the class InMemoryRegistry method registerClient.

/**
 * @see io.apiman.gateway.engine.IRegistry#registerClient(io.apiman.gateway.engine.beans.Client, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void registerClient(Client client, IAsyncResultHandler<Void> handler) {
    Exception error = null;
    synchronized (mutex) {
        // Validate the client first - we need to be able to resolve all the contracts.
        for (Contract contract : client.getContracts()) {
            String apiIdx = getApiIndex(contract.getApiOrgId(), contract.getApiId(), contract.getApiVersion());
            if (!getMap().containsKey(apiIdx)) {
                error = new ApiNotFoundException(// $NON-NLS-1$
                Messages.i18n.format(// $NON-NLS-1$
                "InMemoryRegistry.ApiNotFoundInOrg", contract.getApiId(), contract.getApiOrgId()));
                break;
            }
        }
        if (error == null) {
            // Unregister the client (if it exists)
            unregisterClientInternal(client, true);
            // Now, register the client.
            String clientIdx = getClientIndex(client);
            getMap().put(clientIdx, client);
            getMap().put(client.getApiKey(), client);
            handler.handle(AsyncResultImpl.create((Void) null));
        } else {
            handler.handle(AsyncResultImpl.create(error, Void.class));
        }
    }
}

Example 13 with Contract

use of io.apiman.gateway.engine.beans.Contract in project apiman by apiman.

the class StorageImportDispatcher method registerClients.

/**
 * Registers any clients that were imported in the "Registered" state.
 * @throws StorageException
 */
private void registerClients() throws StorageException {
    // $NON-NLS-1$
    logger.info(Messages.i18n.format("StorageExporter.RegisteringClients"));
    for (EntityInfo info : clientsToRegister) {
        // $NON-NLS-1$
        logger.info(Messages.i18n.format("StorageExporter.RegisteringClient", info));
        ClientVersionBean versionBean = storage.getClientVersion(info.organizationId, info.id, info.version);
        Iterator<ContractBean> contractBeans = storage.getAllContracts(info.organizationId, info.id, info.version);
        Client client = new Client();
        client.setOrganizationId(versionBean.getClient().getOrganization().getId());
        client.setClientId(versionBean.getClient().getId());
        client.setVersion(versionBean.getVersion());
        client.setApiKey(versionBean.getApikey());
        Set<Contract> contracts = new HashSet<>();
        while (contractBeans.hasNext()) {
            ContractBean contractBean = contractBeans.next();
            EntityInfo apiInfo = new EntityInfo(contractBean.getApi().getApi().getOrganization().getId(), contractBean.getApi().getApi().getId(), contractBean.getApi().getVersion());
            if (apisToPublish.contains(apiInfo)) {
                Contract contract = new Contract();
                contract.setPlan(contractBean.getPlan().getPlan().getId());
                contract.setApiId(contractBean.getApi().getApi().getId());
                contract.setApiOrgId(contractBean.getApi().getApi().getOrganization().getId());
                contract.setApiVersion(contractBean.getApi().getVersion());
                contract.getPolicies().addAll(aggregateContractPolicies(contractBean, info));
                contracts.add(contract);
            }
        }
        client.setContracts(contracts);
        // Next, register the client with *all* relevant gateways.  This is done by
        // looking up all referenced apis and getting the gateway information for them.
        // Each of those gateways must be told about the client.
        Map<String, IGatewayLink> links = new HashMap<>();
        for (Contract contract : client.getContracts()) {
            ApiVersionBean svb = storage.getApiVersion(contract.getApiOrgId(), contract.getApiId(), contract.getApiVersion());
            Set<ApiGatewayBean> gateways = svb.getGateways();
            if (gateways == null) {
                // $NON-NLS-1$
                throw new PublishingException("No gateways specified for api: " + svb.getApi().getName());
            }
            for (ApiGatewayBean apiGatewayBean : gateways) {
                String gatewayId = apiGatewayBean.getGatewayId();
                if (!links.containsKey(gatewayId)) {
                    IGatewayLink gatewayLink = createGatewayLink(gatewayId);
                    links.put(gatewayId, gatewayLink);
                }
            }
        }
        for (IGatewayLink gatewayLink : links.values()) {
            try {
                gatewayLink.registerClient(client);
            } catch (Exception e) {
                throw new StorageException(e);
            }
        }
    }
}

Example 14 with Contract

use of io.apiman.gateway.engine.beans.Contract in project apiman by apiman.

the class SharedGlobalDataRegistry method registerClient.

// CompositeFuture.all(list) requires raw futures.
@SuppressWarnings("rawtypes")
@Override
public void registerClient(Client client, IAsyncResultHandler<Void> resultHandler) {
    List<Future> futures = new ArrayList<>(client.getContracts().size());
    List<Contract> contracts = new ArrayList<>(client.getContracts());
    String clientIndex = getClientIndex(client);
    // Future for each contract and execute get.
    for (Contract contract : contracts) {
        Future future = Future.future();
        futures.add(future);
        String apiIndex = getApiIndex(contract.getApiOrgId(), contract.getApiId(), contract.getApiVersion());
        objectMap.get(apiIndex, future.completer());
    }
    CompositeFuture.all(futures).setHandler(compositeResult -> {
        if (compositeResult.succeeded()) {
            // If any contract didn't correspond to a stored API.
            Contract failedContract = null;
            for (int i = 0; i < futures.size(); i++) {
                if (futures.get(i).result() == null) {
                    failedContract = contracts.get(0);
                    break;
                }
            }
            // If we found an invalid contract.
            if (failedContract != null) {
                Exception ex = new ApiNotFoundException(Messages.i18n.format("InMemoryRegistry.ApiNotFoundInOrg", failedContract.getApiId(), failedContract.getApiOrgId()));
                resultHandler.handle(AsyncResultImpl.create(ex));
            } else {
                Future<Object> putNewApiKeyFuture = Future.future();
                Future<Object> endFuture = Future.future();
                // Order: Create new API Key reference; Replace old ID -> API mapping; Delete old key reference)
                // This should ensure no breaking/irreconcilable behaviour.
                objectMap.putIfAbsent(client.getApiKey(), client, putNewApiKeyFuture.completer());
                // Replace API Key reference
                putNewApiKeyFuture.compose(clientWithSameApiKey -> {
                    Future<Object> replaceClientFuture = Future.future();
                    // only in hard-coded tests. Generally sameKeyReplace will be null.
                    if (clientWithSameApiKey != null) {
                        // System.err.println("!!!!! Same API Key -- Replacing. Must not delete later. !!!!!!");
                        objectMap.replace(client.getApiKey(), client, replaceClientFuture.completer());
                    } else {
                        objectMap.putIfAbsent(clientIndex, client, replaceClientFuture.completer());
                    }
                    return replaceClientFuture;
                // Remove old API key reference
                }).compose(oldClientRaw -> {
                    Client oldClient = (Client) oldClientRaw;
                    if (oldClientRaw != null && !oldClient.getApiKey().equals(client.getApiKey())) {
                        objectMap.remove(oldClient.getApiKey(), endFuture.completer());
                    } else {
                        endFuture.complete();
                    }
                }, endFuture).setHandler(handleResult(resultHandler));
            }
        } else {
            resultHandler.handle(AsyncResultImpl.create(compositeResult.cause()));
        }
    });
}

Example 15 with Contract

use of io.apiman.gateway.engine.beans.Contract in project apiman by apiman.

the class ActionService method registerClient.

/**
 * Registers a client (along with all of its contracts) to the gateway.
 */
public void registerClient(String orgId, String clientId, String clientVersion) throws ActionException, NotAuthorizedException {
    ClientVersionBean versionBean;
    List<ContractSummaryBean> contractBeans;
    try {
        versionBean = clientAppService.getClientVersion(orgId, clientId, clientVersion);
    } catch (ClientVersionNotFoundException e) {
        // $NON-NLS-1$
        throw ExceptionFactory.actionException(Messages.i18n.format("clientVersionDoesNotExist", clientId, clientVersion));
    }
    try {
        contractBeans = query.getClientContracts(orgId, clientId, clientVersion);
        // Any awaiting approval then don't let them republish.
        List<ContractSummaryBean> awaitingApproval = contractBeans.stream().filter(f -> f.getStatus() == ContractStatus.AwaitingApproval).collect(Collectors.toList());
        if (!awaitingApproval.isEmpty()) {
            throw ExceptionFactory.contractNotYetApprovedException(awaitingApproval);
        }
    } catch (StorageException e) {
        // $NON-NLS-1$
        throw ExceptionFactory.actionException(Messages.i18n.format("ClientNotFound"), e);
    }
    boolean isReregister = false;
    // Validate that it's ok to perform this action
    if (versionBean.getStatus() == ClientStatus.Registered) {
        Date modOn = versionBean.getModifiedOn();
        Date publishedOn = versionBean.getPublishedOn();
        int c = modOn.compareTo(publishedOn);
        if (c <= 0) {
            // $NON-NLS-1$
            throw ExceptionFactory.actionException(Messages.i18n.format("ClientReRegisterNotRequired"));
        }
        isReregister = true;
    }
    Client client = new Client();
    client.setOrganizationId(versionBean.getClient().getOrganization().getId());
    client.setClientId(versionBean.getClient().getId());
    client.setVersion(versionBean.getVersion());
    client.setApiKey(versionBean.getApikey());
    Set<Contract> contracts = new HashSet<>();
    for (ContractSummaryBean contractBean : contractBeans) {
        Contract contract = new Contract();
        contract.setPlan(contractBean.getPlanId());
        contract.setApiId(contractBean.getApiId());
        contract.setApiOrgId(contractBean.getApiOrganizationId());
        contract.setApiVersion(contractBean.getApiVersion());
        contract.getPolicies().addAll(contractService.aggregateContractPolicies(contractBean));
        contracts.add(contract);
    }
    client.setContracts(contracts);
    // Each of those gateways must be told about the client.
    try {
        Map<String, IGatewayLink> links = new HashMap<>();
        for (Contract contract : client.getContracts()) {
            ApiVersionBean svb = storage.getApiVersion(contract.getApiOrgId(), contract.getApiId(), contract.getApiVersion());
            Set<ApiGatewayBean> gateways = svb.getGateways();
            if (gateways == null) {
                // $NON-NLS-1$
                throw new PublishingException("No gateways specified for API: " + svb.getApi().getName());
            }
            for (ApiGatewayBean apiGatewayBean : gateways) {
                if (!links.containsKey(apiGatewayBean.getGatewayId())) {
                    IGatewayLink gatewayLink = createGatewayLink(apiGatewayBean.getGatewayId());
                    links.put(apiGatewayBean.getGatewayId(), gatewayLink);
                }
            }
        }
        if (isReregister) {
            // Once we figure out which gateways to register with, make sure we also "unregister"
            // the client app from all other gateways.  This is necessary because we may have broken
            // contracts we previously had on APIs that are published to other gateways.  And thus
            // it's possible we need to remove a contract from a Gateway that is not otherwise/currently
            // referenced.
            // 
            // This is a fix for:  https://issues.jboss.org/browse/APIMAN-895
            Iterator<GatewayBean> gateways = storage.getAllGateways();
            while (gateways.hasNext()) {
                GatewayBean gbean = gateways.next();
                if (!links.containsKey(gbean.getId())) {
                    IGatewayLink gatewayLink = createGatewayLink(gbean.getId());
                    try {
                        gatewayLink.unregisterClient(client);
                    } catch (Exception e) {
                    // We need to catch the error, but ignore it,
                    // in the event that the gateway is invalid.
                    }
                    gatewayLink.close();
                }
            }
        }
        for (IGatewayLink gatewayLink : links.values()) {
            gatewayLink.registerClient(client);
            gatewayLink.close();
        }
    } catch (Exception e) {
        // $NON-NLS-1$
        throw ExceptionFactory.actionException(Messages.i18n.format("RegisterError"), e);
    }
    ClientStatus oldStatus = versionBean.getStatus();
    versionBean.setStatus(ClientStatus.Registered);
    versionBean.setPublishedOn(new Date());
    try {
        storage.updateClientVersion(versionBean);
        storage.createAuditEntry(AuditUtils.clientRegistered(versionBean, securityContext));
        clientAppService.fireClientStatusChangeEvent(versionBean, oldStatus);
    } catch (Exception e) {
        // $NON-NLS-1$
        throw ExceptionFactory.actionException(Messages.i18n.format("RegisterError"), e);
    }
    LOGGER.debug(// $NON-NLS-1$
    String.format(// $NON-NLS-1$
    "Successfully registered Client %s on specified gateways: %s", versionBean.getClient().getName(), versionBean.getClient()));
}