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

Example 11 with Api

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

the class DefaultEngineFactoryTest method testCreateEngine.

/**
 * Test method for {@link io.apiman.gateway.engine.impl.AbstractEngineFactory#createEngine()}.
 * @throws ExecutionException
 * @throws InterruptedException
 */
@Test
public void testCreateEngine() throws InterruptedException, ExecutionException {
    DefaultEngineFactory factory = new DefaultEngineFactory() {

        @Override
        protected IComponentRegistry createComponentRegistry(IPluginRegistry pluginRegistry) {
            return new DefaultComponentRegistry() {

                @Override
                protected void registerBufferFactoryComponent() {
                    addComponent(IBufferFactoryComponent.class, new ByteBufferFactoryComponent());
                }
            };
        }

        @Override
        protected IConnectorFactory createConnectorFactory(IPluginRegistry pluginRegistry) {
            return new IConnectorFactory() {

                @Override
                public IApiConnector createConnector(ApiRequest request, Api api, RequiredAuthType requiredAuthType, boolean hasDataPolicy, IConnectorConfig connectorConfig) {
                    Assert.assertEquals("test", api.getEndpointType());
                    Assert.assertEquals("test:endpoint", api.getEndpoint());
                    IApiConnector connector = new IApiConnector() {

                        /**
                         * @see io.apiman.gateway.engine.IApiConnector#connect(io.apiman.gateway.engine.beans.ApiRequest, io.apiman.gateway.engine.async.IAsyncResultHandler)
                         */
                        @Override
                        public IApiConnection connect(ApiRequest request, IAsyncResultHandler<IApiConnectionResponse> handler) throws ConnectorException {
                            final ApiResponse response = new ApiResponse();
                            response.setCode(200);
                            // $NON-NLS-1$
                            response.setMessage("OK");
                            mockApiConnectionResponse = new MockApiConnectionResponse() {

                                @Override
                                public void write(IApimanBuffer chunk) {
                                    handleBody(chunk);
                                }

                                @Override
                                protected void handleHead(ApiResponse head) {
                                    return;
                                }

                                @Override
                                public ApiResponse getHead() {
                                    return response;
                                }

                                @Override
                                public void end() {
                                    handleEnd();
                                }

                                @Override
                                public void transmit() {
                                    transmitHandler.handle((Void) null);
                                }

                                @Override
                                public void abort(Throwable t) {
                                }
                            };
                            IAsyncResult<IApiConnectionResponse> mockResponseResultHandler = mock(IAsyncResult.class);
                            given(mockResponseResultHandler.isSuccess()).willReturn(true);
                            given(mockResponseResultHandler.isError()).willReturn(false);
                            given(mockResponseResultHandler.getResult()).willReturn(mockApiConnectionResponse);
                            mockApiConnection = mock(MockApiConnection.class);
                            given(mockApiConnection.getHead()).willReturn(request);
                            // Handle head
                            handler.handle(mockResponseResultHandler);
                            return mockApiConnection;
                        }
                    };
                    return connector;
                }

                @Override
                public IConnectorConfig createConnectorConfig(ApiRequest request, Api api) {
                    return new TestConnectorConfigImpl();
                }
            };
        }

        @Override
        protected IDelegateFactory createLoggerFactory(IPluginRegistry pluginRegistry) {
            return null;
        }

        @Override
        protected IApiRequestPathParser createRequestPathParser(IPluginRegistry pluginRegistry) {
            return new DefaultRequestPathParser(null);
        }

        @Override
        protected void complete() {
        }
    };
    IEngine engine = factory.createEngine();
    Assert.assertNotNull(engine);
    // create a api
    Api api = new Api();
    api.setEndpointType("test");
    api.setEndpoint("test:endpoint");
    api.setOrganizationId("TestOrg");
    api.setApiId("TestApi");
    api.setVersion("1.0");
    // create a client
    Client app = new Client();
    app.setClientId("TestApp");
    app.setOrganizationId("TestOrg");
    app.setVersion("1.0");
    app.setApiKey("client-12345");
    Contract contract = new Contract();
    contract.setPlan("Gold");
    contract.setApiId("TestApi");
    contract.setApiOrgId("TestOrg");
    contract.setApiVersion("1.0");
    contract.setPolicies(policyList);
    app.addContract(contract);
    // simple api/app config
    engine.getRegistry().publishApi(api, new IAsyncResultHandler<Void>() {

        @Override
        public void handle(IAsyncResult<Void> result) {
        }
    });
    engine.getRegistry().registerClient(app, new IAsyncResultHandler<Void>() {

        @Override
        public void handle(IAsyncResult<Void> result) {
        }
    });
    ApiRequest request = new ApiRequest();
    request.setApiKey("client-12345");
    request.setApiId("TestApi");
    request.setApiOrgId("TestOrg");
    request.setApiVersion("1.0");
    request.setDestination("/");
    request.setUrl("http://localhost:9999/");
    request.setType("TEST");
    IApiRequestExecutor prExecutor = engine.executor(request, new IAsyncResultHandler<IEngineResult>() {

        // At this point, we are either saying *fail* or *response connection is ready*
        @Override
        public void handle(IAsyncResult<IEngineResult> result) {
            IEngineResult er = result.getResult();
            // No exception occurred
            Assert.assertTrue(result.isSuccess());
            // The chain evaluation succeeded
            Assert.assertNotNull(er);
            Assert.assertTrue(!er.isFailure());
            Assert.assertNotNull(er.getApiResponse());
            // $NON-NLS-1$
            Assert.assertEquals("OK", er.getApiResponse().getMessage());
            er.bodyHandler(mockBodyHandler);
            er.endHandler(mockEndHandler);
        }
    });
    prExecutor.streamHandler(new IAsyncHandler<ISignalWriteStream>() {

        @Override
        public void handle(ISignalWriteStream streamWriter) {
            streamWriter.write(mockBufferInbound);
            streamWriter.end();
        }
    });
    transmitHandler = new IAsyncHandler<Void>() {

        @Override
        public void handle(Void result) {
            // NB: This is cheating slightly for testing purposes, we don't have real async here.
            // Only now start writing stuff, so user has had opportunity to set handlers
            mockApiConnectionResponse.write(mockBufferOutbound);
            mockApiConnectionResponse.end();
        }
    };
    prExecutor.execute();
    // Request handler should receive the mock inbound buffer once only
    verify(mockApiConnection, times(1)).write(mockBufferInbound);
    // Ultimately user should receive the contrived response and end in order.
    InOrder order = inOrder(mockBodyHandler, mockEndHandler);
    order.verify(mockBodyHandler).handle(mockBufferOutbound);
    order.verify(mockEndHandler).handle((Void) null);
}

Example 12 with Api

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

the class InMemoryRegistry method getApi.

/**
 * @see io.apiman.gateway.engine.IRegistry#getApi(java.lang.String, java.lang.String, java.lang.String, io.apiman.gateway.engine.async.IAsyncResultHandler)
 */
@Override
public void getApi(String organizationId, String apiId, String apiVersion, IAsyncResultHandler<Api> handler) {
    Api api = getApiInternal(organizationId, apiId, apiVersion);
    handler.handle(AsyncResultImpl.create(api));
}

Example 13 with Api

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

the class InMemoryRegistry method getApiInternal.

/**
 * Gets an API by its unique identifying info (orgid, id, version).
 *
 * @return an Api or null if not found
 */
private Api getApiInternal(String apiOrgId, String apiId, String apiVersion) {
    String key = getApiIndex(apiOrgId, apiId, apiVersion);
    Api api;
    synchronized (mutex) {
        api = (Api) getMap().get(key);
    }
    return api;
}

Example 14 with Api

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

the class PolicyTester method publishApi.

/**
 * Publish a API configured with the correct policy and policy config.
 * @param method
 * @throws Throwable
 */
protected void publishApi(FrameworkMethod method) {
    version++;
    try {
        // Get the policy class under test.
        TestingPolicy tp = method.getMethod().getAnnotation(TestingPolicy.class);
        if (tp == null) {
            tp = getTestClass().getJavaClass().getAnnotation(TestingPolicy.class);
        }
        if (tp == null) {
            throw new Exception("Missing test annotation @TestingPolicy.");
        }
        Class<? extends IPolicy> policyUnderTest = tp.value();
        // Get the configuration JSON to use
        Configuration config = method.getMethod().getAnnotation(Configuration.class);
        if (config == null) {
            config = getTestClass().getJavaClass().getAnnotation(Configuration.class);
        }
        if (config == null) {
            throw new Exception("Missing test annotation @Configuration.");
        }
        // Get the back end API simulator to use
        BackEndApi backEnd = method.getMethod().getAnnotation(BackEndApi.class);
        if (backEnd == null) {
            backEnd = getTestClass().getJavaClass().getAnnotation(BackEndApi.class);
        }
        Class<? extends IPolicyTestBackEndApi> backEndApi;
        if (backEnd == null) {
            backEndApi = EchoBackEndApi.class;
        } else {
            backEndApi = backEnd.value();
        }
        final Set<Throwable> errorHolder = new HashSet<>();
        Policy policy = new Policy();
        policy.setPolicyImpl("class:" + policyUnderTest.getName());
        policy.setPolicyJsonConfig(getPolicyConfiguration(config));
        Api api = new Api();
        api.setEndpoint(backEndApi.getName());
        api.setEndpointType("TEST");
        api.setOrganizationId(orgId);
        api.setApiId(apiId);
        api.setVersion(String.valueOf(version));
        api.setPublicAPI(true);
        api.setApiPolicies(Collections.singletonList(policy));
        api.setParsePayload(true);
        getEngine().getRegistry().publishApi(api, new IAsyncResultHandler<Void>() {

            @Override
            public void handle(IAsyncResult<Void> result) {
                if (result.isError()) {
                    errorHolder.add(result.getError());
                }
            }
        });
        if (!errorHolder.isEmpty()) {
            throw errorHolder.iterator().next();
        }
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }
}

Example 15 with Api

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

the class StorageImportDispatcher method publishApis.

/**
 * Publishes any apis that were imported in the "Published" state.
 * @throws StorageException
 */
private void publishApis() throws StorageException {
    // $NON-NLS-1$
    logger.info(Messages.i18n.format("StorageExporter.PublishingApis"));
    try {
        for (EntityInfo info : apisToPublish) {
            // $NON-NLS-1$
            logger.info(Messages.i18n.format("StorageExporter.PublishingApi", info));
            ApiVersionBean versionBean = storage.getApiVersion(info.organizationId, info.id, info.version);
            Api gatewayApi = new Api();
            gatewayApi.setEndpoint(versionBean.getEndpoint());
            gatewayApi.setEndpointType(versionBean.getEndpointType().toString());
            gatewayApi.setEndpointProperties(versionBean.getEndpointProperties());
            gatewayApi.setOrganizationId(versionBean.getApi().getOrganization().getId());
            gatewayApi.setApiId(versionBean.getApi().getId());
            gatewayApi.setVersion(versionBean.getVersion());
            gatewayApi.setPublicAPI(versionBean.isPublicAPI());
            gatewayApi.setParsePayload(versionBean.isParsePayload());
            if (versionBean.isPublicAPI()) {
                List<Policy> policiesToPublish = new ArrayList<>();
                Iterator<PolicyBean> apiPolicies = storage.getAllPolicies(info.organizationId, info.id, info.version, PolicyType.Api);
                while (apiPolicies.hasNext()) {
                    PolicyBean apiPolicy = apiPolicies.next();
                    Policy policyToPublish = new Policy();
                    policyToPublish.setPolicyJsonConfig(apiPolicy.getConfiguration());
                    policyToPublish.setPolicyImpl(apiPolicy.getDefinition().getPolicyImpl());
                    policiesToPublish.add(policyToPublish);
                }
                gatewayApi.setApiPolicies(policiesToPublish);
            }
            // Publish the api to all relevant gateways
            Set<ApiGatewayBean> gateways = versionBean.getGateways();
            if (gateways == null) {
                // $NON-NLS-1$
                throw new RuntimeException("No gateways specified for api!");
            }
            for (ApiGatewayBean apiGatewayBean : gateways) {
                IGatewayLink gatewayLink = createGatewayLink(apiGatewayBean.getGatewayId());
                gatewayLink.publishApi(gatewayApi);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}