private OpenAPI updateOpenApi() {
    OpenApiContext openApiContext = OpenApiContextLocator.getInstance().getOpenApiContext(
        OpenApiContext.OPENAPI_CONTEXT_ID_DEFAULT);
    if (openApiContext instanceof GenericOpenApiContext) {
        restfulServices = getAllRestfulService();
        SwaggerConfiguration oasConfig = new SwaggerConfiguration().resourceClasses(restfulServices);
        ((GenericOpenApiContext) openApiContext).getOpenApiScanner().setConfiguration(oasConfig);
        try {
            ((GenericOpenApiContext) openApiContext).setCacheTTL(0);
            return openApiContext.read();
        } finally {
            ((GenericOpenApiContext) openApiContext).setCacheTTL(-1);
        }
    } else {
        return null;
    }
}
 

@Override
public Object getService(
    Bundle bundle,
    ServiceRegistration<Object> serviceRegistration) {

    SwaggerConfiguration
            swaggerConfiguration = new SwaggerConfiguration().
            openAPI(openAPI);

    propertyWrapper.applyLong("cache.ttl", swaggerConfiguration::setCacheTTL);
    propertyWrapper.applyString("id", swaggerConfiguration::id);
    propertyWrapper.applyStringCollection("ignored.routes", swaggerConfiguration::setIgnoredRoutes);
    propertyWrapper.applyBoolean("pretty.print", swaggerConfiguration::setPrettyPrint);
    propertyWrapper.applyBoolean("read.all.resources", swaggerConfiguration::setReadAllResources);

    OpenApiResource openApiResource = new OpenApiResource();

    openApiResource.setOpenApiConfiguration(swaggerConfiguration);

    return openApiResource;
}
 

@Override
public void init(ServletConfig config) throws ServletException {

  OpenAPI oas = new OpenAPI();
  Info info = new Info()
           .title("Submarine Experiment API")
           .description("The Submarine REST API allows you to create, list, and get experiments. The\n" +
                   "API is hosted under the /v1/experiment route on the Submarine server. For example,\n" +
                   "to list experiments on a server hosted at http://localhost:8080, access\n" +
                   "http://localhost:8080/api/v1/experiment/")
           .termsOfService("http://swagger.io/terms/")
           .contact(new Contact()
           .email("[email protected]"))
           .version("0.4.0")
           .license(new License()
           .name("Apache 2.0")
           .url("http://www.apache.org/licenses/LICENSE-2.0.html"));

  oas.info(info);
  List<Server> servers = new ArrayList<>();
  servers.add(new Server().url("/api"));
  oas.servers(servers);
  SwaggerConfiguration oasConfig = new SwaggerConfiguration()
          .openAPI(oas)
          .resourcePackages(Stream.of("org.apache.submarine.server.rest").collect(Collectors.toSet()));

  try {
    new JaxrsOpenApiContextBuilder()
            .servletConfig(config)
            .openApiConfiguration(oasConfig)
            .buildContext(true);
  } catch (OpenApiConfigurationException e) {
    throw new ServletException(e.getMessage(), e);
  }
}
 

private OpenAPI buildOpenApi() {
    try {
        restfulServices = getAllRestfulService();
        SwaggerConfiguration oasConfig = new SwaggerConfiguration().resourceClasses(restfulServices);

        OpenApiContext oac = new JaxrsOpenApiContextBuilder()
            .openApiConfiguration(oasConfig)
            .buildContext(true);
        return oac.read();
    } catch (OpenApiConfigurationException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}
 

public static OpenAPIConfiguration deepCopy(OpenAPIConfiguration config) {
	if (config == null) {
		return null;
	}
	try {
		return Json.mapper().readValue(Json.pretty(config), SwaggerConfiguration.class);
	} catch (Exception e) {
		LOGGER.error("Exception cloning config: " + e.getMessage(), e);
		return config;
	}
}
 

private void setupOAS() {
    OpenAPI oas = new OpenAPI();
    Info oasInfo = new Info();
    oas.setInfo(oasInfo);
    oasInfo.setVersion(MCRCoreVersion.getVersion());
    oasInfo.setTitle(getApplicationName());
    License oasLicense = new License();
    oasLicense.setName("GNU General Public License, version 3");
    oasLicense.setUrl("http://www.gnu.org/licenses/gpl-3.0.txt");
    oasInfo.setLicense(oasLicense);
    URI baseURI = URI.create(MCRFrontendUtil.getBaseURL());
    Server oasServer = new Server();
    oasServer.setUrl(baseURI.resolve("api").toString());
    oas.addServersItem(oasServer);
    SwaggerConfiguration oasConfig = new SwaggerConfiguration()
        .openAPI(oas)
        .resourcePackages(Stream.of(getRestPackages()).collect(Collectors.toSet()))
        .ignoredRoutes(
            MCRConfiguration2.getString("MCR.RestAPI.V2.OpenAPI.IgnoredRoutes")
                .map(MCRConfiguration2::splitValue)
                .orElseGet(Stream::empty)
                .collect(Collectors.toSet()))
        .prettyPrint(true);
    try {
        new JaxrsOpenApiContextBuilder()
            .application(getApplication())
            .openApiConfiguration(oasConfig)
            .buildContext(true);
    } catch (OpenApiConfigurationException e) {
        throw new InternalServerErrorException(e);
    }
}
 

private void configureSwagger() {
    OpenAPI oas = new OpenAPI();
    Info info = new Info().title("PNC")
            .description("PNC build system")
            .termsOfService("http://swagger.io/terms/")
            .license(new License().name("Apache 2.0").url("http://www.apache.org/licenses/LICENSE-2.0.html"));
    oas.info(info);
    oas.addServersItem(new Server().url("/pnc-rest-new"));

    final SecurityScheme authScheme = getAuthScheme();
    if (authScheme == null) {
        logger.warn("Not adding auth scheme to openapi definition as auth scheme could not been generated.");
    } else {
        oas.schemaRequirement(KEYCLOAK_AUTH, authScheme);
        oas.addSecurityItem(new SecurityRequirement().addList(KEYCLOAK_AUTH));
    }

    SwaggerConfiguration oasConfig = new SwaggerConfiguration().openAPI(oas);

    try {
        new JaxrsOpenApiContextBuilder().servletConfig(servletConfig)
                .application(this)
                .openApiConfiguration(oasConfig)
                .buildContext(true);
    } catch (OpenApiConfigurationException ex) {
        throw new IllegalArgumentException("Failed to setup OpenAPI configuration", ex);
    }
}
 

public Reader(OpenAPI openAPI)
{
	this();

	setConfiguration(new SwaggerConfiguration().openAPI(openAPI));
}
 

@Override
public void initialize(Server server, Bus bus) {
    final JAXRSServiceFactoryBean sfb = (JAXRSServiceFactoryBean)server
            .getEndpoint()
            .get(JAXRSServiceFactoryBean.class.getName());

    final ServerProviderFactory factory = (ServerProviderFactory)server
            .getEndpoint()
            .get(ServerProviderFactory.class.getName());

    final Set<String> packages = new HashSet<>();
    if (resourcePackages != null) {
        packages.addAll(resourcePackages);
    }

    // Generate random Context ID for Swagger
    if (useContextBasedConfig) {
        ctxId = UUID.randomUUID().toString();
    }

    Properties swaggerProps = null;
    GenericOpenApiContextBuilder<?> openApiConfiguration;
    final Application application = DefaultApplicationFactory.createApplicationOrDefault(server, factory,
            sfb, bus, resourcePackages, isScan());

    String defaultConfigLocation = getConfigLocation();
    if (scanKnownConfigLocations && StringUtils.isEmpty(defaultConfigLocation)) {
        defaultConfigLocation = OpenApiDefaultConfigurationScanner.locateDefaultConfiguration().orElse(null);
    }

    if (StringUtils.isEmpty(defaultConfigLocation)) {
        swaggerProps = getSwaggerProperties(propertiesLocation, bus);

        if (isScan()) {
            packages.addAll(scanResourcePackages(sfb));
        }

        final OpenAPI oas = new OpenAPI().info(getInfo(swaggerProps));
        registerComponents(securityDefinitions).ifPresent(oas::setComponents);

        final SwaggerConfiguration config = new SwaggerConfiguration()
                .openAPI(oas)
                .prettyPrint(getOrFallback(isPrettyPrint(), swaggerProps, PRETTY_PRINT_PROPERTY))
                .readAllResources(isReadAllResources())
                .ignoredRoutes(getIgnoredRoutes())
                .filterClass(getOrFallback(getFilterClass(), swaggerProps, FILTER_CLASS_PROPERTY))
                .resourceClasses(getResourceClasses())
                .resourcePackages(getOrFallback(packages, swaggerProps, RESOURCE_PACKAGE_PROPERTY));
        
        if (!StringUtils.isEmpty(getScannerClass())) {
            config.setScannerClass(getScannerClass());
        }

        openApiConfiguration = new JaxrsOpenApiContextBuilder<>()
                .application(application)
                .openApiConfiguration(config)
                .ctxId(ctxId); /* will be null if not used */
    } else {
        openApiConfiguration = new JaxrsOpenApiContextBuilder<>()
                .application(application)
                .configLocation(defaultConfigLocation)
                .ctxId(ctxId); /* will be null if not used */
    }

    try {
        final OpenApiContext context = openApiConfiguration.buildContext(true);
        final Properties userProperties = getUserProperties(
                context
                        .getOpenApiConfiguration()
                        .getUserDefinedOptions());
        registerOpenApiResources(sfb, packages, context.getOpenApiConfiguration());
        registerSwaggerUiResources(sfb, combine(swaggerProps, userProperties), factory, bus);
        registerSwaggerContainerRequestFilter(factory, application);

        if (useContextBasedConfig) {
            registerServletConfigProvider(factory);
        }

        if (customizer != null) {
            customizer.setApplicationInfo(factory.getApplicationProvider());
        }

        bus.setProperty("openapi.service.description.available", "true");
    } catch (OpenApiConfigurationException ex) {
        throw new RuntimeException("Unable to initialize OpenAPI context", ex);
    }
}
 

@SuppressWarnings("rawtypes")
protected void generateSpec() throws Exception
{
	Set<Class<?>> classes = this.registeredControllers;

	OpenAPIExtensions.setExtensions(Collections.singletonList(new ServerParameterExtension()));

	OpenAPI openApi = new OpenAPI();
	Info info = mapper.convertValue(openAPIConfig.getValue("info").unwrapped(), Info.class);

	openApi.setInfo(info);

	Map<String, SecurityScheme> securitySchemes = mapper.convertValue(	openAPIConfig.getValue("securitySchemes").unwrapped(),new TypeReference<Map<String, SecurityScheme>>(){});

	if (openApi.getComponents() == null)
	{
		openApi.setComponents(new Components());
	}

	openApi.getComponents().setSecuritySchemes(securitySchemes);

	List<Server> servers = mapper.convertValue(openAPIConfig.getValue("servers").unwrapped(), new TypeReference<List<Server>>(){});

	openApi.setServers(servers);

	SwaggerConfiguration config = new SwaggerConfiguration().resourceClasses(classes.stream().map(Class::getName).collect(Collectors.toSet())).openAPI(openApi);

	if(jsonViewQueryParameterName != null) {

		if(config.getUserDefinedOptions() == null)
		{
			config.setUserDefinedOptions(new HashMap<>());
		}

		config.getUserDefinedOptions().put("jsonViewQueryParameterName", jsonViewQueryParameterName);
	}

	Set<String> modelConverterClasses = new HashSet<>();

	modelConverterClasses.add(ServerModelResolver.class.getName());

	List<String> additionalConverterClasses = openAPIConfig.getStringList("converterClasses");

	modelConverterClasses.addAll(additionalConverterClasses);

	config.setModelConverterClassess(modelConverterClasses);

	OpenApiContext ctx = new GenericOpenApiContext().openApiConfiguration(config)
			.openApiReader(new Reader(config))
			.openApiScanner(new JaxrsApplicationAndAnnotationScanner().openApiConfiguration(config))
			.init();

	openApi = ctx.read();
	this.openApi = openApi;
	this.spec = writer.writeValueAsString(openApi);
}