docs: protected Connector[] createConnectors(IJettyConfiguration iJettyConfiguration, Server server) throws JettyBootstrapException {
          LOG.trace("Creating Jetty Connectors...");
  
          List<Connector> connectors = new ArrayList<>();
  
          if (iJettyConfiguration.hasJettyConnector(JettyConnector.HTTP)) {
              LOG.trace("Adding HTTP Connector...");
  
              ServerConnector serverConnector;
  
              if (iJettyConfiguration.hasJettyConnector(JettyConnector.HTTPS)) {
                  HttpConfiguration httpConfiguration = new HttpConfiguration();
                  httpConfiguration.setSecurePort(iJettyConfiguration.getSslPort());
                  httpConfiguration.setSecureScheme(HttpScheme.HTTPS.asString());
                  httpConfiguration.setIdleTimeout(iJettyConfiguration.getIdleTimeout());
                  httpConfiguration.setBlockingTimeout(iJettyConfiguration.getBlockingTimeout());
  
                  HttpConnectionFactory httpConnectionFactory = new HttpConnectionFactory(httpConfiguration);
  
                  serverConnector = new ServerConnector(server, httpConnectionFactory);
              } else {
                  serverConnector = new ServerConnector(server);
  
                  serverConnector.getConnectionFactories().stream()
                          .filter(HttpConnectionFactory.class::isInstance)
                          .map(HttpConnectionFactory.class::cast)
                          .forEach(httpConnectionFactory -> httpConnectionFactory.getHttpConfiguration().setBlockingTimeout(iJettyConfiguration.getBlockingTimeout()));
              }
  
              serverConnector.setIdleTimeout(iJettyConfiguration.getIdleTimeout());
              serverConnector.setHost(iJettyConfiguration.getHost());
              serverConnector.setPort(iJettyConfiguration.getPort());
  
              connectors.add(serverConnector);
          }
          if (iJettyConfiguration.hasJettyConnector(JettyConnector.HTTPS)) {
              LOG.trace("Adding HTTPS Connector...");
  
              SslContextFactory sslContextFactory = new SslContextFactory();
  
              if (iJettyConfiguration.getSslKeyStore() != null) { //Use keyStore object if available
                  sslContextFactory.setKeyStore(iJettyConfiguration.getSslKeyStore());
              } else if (iJettyConfiguration.getSslPrivateKeyPath() != null && !iJettyConfiguration.getSslPrivateKeyPath().isEmpty() &&
                  iJettyConfiguration.getSslCertificatePath() != null && !iJettyConfiguration.getSslCertificatePath().isEmpty()) { //Use private key and certificate if available
  
                  JettyKeystoreConvertorBuilder jettyKeystoreConvertorBuilder = new JettyKeystoreConvertorBuilder();
                  try {
                      File sslPrivateKeyFile = new File(iJettyConfiguration.getSslPrivateKeyPath());
                      if (!sslPrivateKeyFile.exists() || !sslPrivateKeyFile.canRead()) {
                          throw new JettyBootstrapException("Private key not exists or unreadable");
                      }
  
                      File sslCertificateFile = new File(iJettyConfiguration.getSslCertificatePath());
                      if (!sslCertificateFile.exists() || !sslCertificateFile.canRead()) {
                          throw new JettyBootstrapException("Certificate not exists or unreadable");
                      }
  
                      try (InputStream sslPrivateKeyInputStream = new FileInputStream(sslPrivateKeyFile);
                              InputStream sslCertificateInputStream = new FileInputStream(sslCertificateFile)) {
  
                          switch (iJettyConfiguration.getSslCertificateFormat()) {
                              case PKCS8:
                                  jettyKeystoreConvertorBuilder.setCertificateFromPKCS8(sslCertificateInputStream);
                                  break;
                              case PKCS12:
                                  jettyKeystoreConvertorBuilder.setCertificateFromPKCS12(sslCertificateInputStream, iJettyConfiguration.getSslCertificatePassword());
                                  break;
                              case UNKNOWN:
                                  throw new JettyBootstrapException("Unknown Certificate Format");
                              default:
                                  throw new JettyBootstrapException("Certificate Format not setted");
                          }
  
                          switch (iJettyConfiguration.getSslPrivateKeyFormat()) {
                              case PKCS8:
                                  jettyKeystoreConvertorBuilder.setPrivateKeyFromPKCS8(sslPrivateKeyInputStream);
                                  break;
                              case PKCS12:
                                  jettyKeystoreConvertorBuilder.setPrivateKeyFromPKCS12(sslPrivateKeyInputStream, iJettyConfiguration.getSslPrivateKeyPassword());
                                  break;
                              case UNKNOWN:
                                  throw new JettyBootstrapException("Unknown Private key Format");
                              default:
                                  throw new JettyBootstrapException("Private key Format not setted");
                          }
                      }
  
                      KeyStore keyStore = jettyKeystoreConvertorBuilder.build(iJettyConfiguration.getSslKeyStoreAlias(), iJettyConfiguration.getSslKeyStorePassword());
  
                      sslContextFactory.setKeyStore(keyStore);
                  } catch (JettyKeystoreException | IOException e) {
                      throw new JettyBootstrapException("Can not load SSL private key or SSL certificate", e);
                  }
              } else { //Use keystore path
                  sslContextFactory.setKeyStorePath(iJettyConfiguration.getSslKeyStorePath());
              }
              sslContextFactory.setKeyStorePassword(iJettyConfiguration.getSslKeyStorePassword());
              ServerConnector serverConnector = new ServerConnector(server, sslContextFactory);
  
              serverConnector.setIdleTimeout(iJettyConfiguration.getIdleTimeout());
              serverConnector.setHost(iJettyConfiguration.getHost());
              serverConnector.setPort(iJettyConfiguration.getSslPort());
  
              connectors.add(serverConnector);
          }
  
          return connectors.toArray(new Connector[connectors.size()]);
      }