Lists available Ssl options for configuring Ssl policy.

@throws IllegalArgumentException thrown if parameters fail the validation
@return the observable to the ApplicationGatewayAvailableSslOptionsInner object
553675
public Observable<ServiceResponse<ApplicationGatewayAvailableSslOptionsInner>> listAvailableSslOptionsWithServiceResponseAsync() {
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        final String apiVersion = "2018-06-01";
        return service.listAvailableSslOptions(this.client.subscriptionId(), apiVersion, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ApplicationGatewayAvailableSslOptionsInner>>>() {
                @Override
                public Observable<ServiceResponse<ApplicationGatewayAvailableSslOptionsInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ApplicationGatewayAvailableSslOptionsInner> clientResponse = listAvailableSslOptionsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
615656
public static sslwrapkey[] get_filtered(nitro_service service, String filter) throws Exception{
		sslwrapkey obj = new sslwrapkey();
		options option = new options();
		option.set_filter(filter);
		sslwrapkey[] response = (sslwrapkey[]) obj.getfiltered(service, option);
		return response;
	}
436257
public Observable<Page<AzureFirewallInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<AzureFirewallInner>>, Page<AzureFirewallInner>>() {
                @Override
                public Page<AzureFirewallInner> call(ServiceResponse<Page<AzureFirewallInner>> response) {
                    return response.body();
                }
            });
    }
871247
public static ssl_key[] get(nitro_service client) throws Exception
	{
		ssl_key resource = new ssl_key();
		resource.validate("get");
		return (ssl_key[]) resource.get_resources(client);
	}
764786
public Observable<ServiceResponse<PolicyDefinitionInner>> getBuiltInWithServiceResponseAsync(String policyDefinitionName) {
        if (policyDefinitionName == null) {
            throw new IllegalArgumentException("Parameter policyDefinitionName is required and cannot be null.");
        }
        if (this.client.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiVersion() is required and cannot be null.");
        }
        return service.getBuiltIn(policyDefinitionName, this.client.apiVersion(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<PolicyDefinitionInner>>>() {
                @Override
                public Observable<ServiceResponse<PolicyDefinitionInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<PolicyDefinitionInner> clientResponse = getBuiltInDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1209571
public Observable<Page<VpnSiteInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<VpnSiteInner>>, Page<VpnSiteInner>>() {
                @Override
                public Page<VpnSiteInner> call(ServiceResponse<Page<VpnSiteInner>> response) {
                    return response.body();
                }
            });
    }
296225
private SSLOptions getSSLOptions() {
        SSLContext sslContext = null;
        try {
            sslContext = getSSLContext(getParamString("truststore"),
                                       getParamString("truststorepassword"),
                                       getParamString("keystore"),
                                       getParamString("keystorepassword"));
        } catch (Exception e) {
            throw new RuntimeException("Unable to build SSLContext", e);
        }
        List<String> cipherSuites = getParamList("dbtls_cipher_suites");
        if (cipherSuites == null) {
            cipherSuites = new ArrayList<>();
        }
        return new SSLOptions(sslContext, cipherSuites.toArray(new String[]{}));
    }
905233
public Observable<ServiceResponse<DeploymentLocationsInner>> getSubscriptionDeploymentLocationsWithServiceResponseAsync() {
        if (this.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.subscriptionId() is required and cannot be null.");
        }
        if (this.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.apiVersion() is required and cannot be null.");
        }
        return service.getSubscriptionDeploymentLocations(this.subscriptionId(), this.apiVersion(), this.acceptLanguage(), this.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<DeploymentLocationsInner>>>() {
                @Override
                public Observable<ServiceResponse<DeploymentLocationsInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<DeploymentLocationsInner> clientResponse = getSubscriptionDeploymentLocationsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1179500
public Observable<ServiceResponse<Page<PremierAddOnOfferInner>>> listPremierAddOnOffersSinglePageAsync() {
        if (this.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.subscriptionId() is required and cannot be null.");
        }
        if (this.apiVersion() == null) {
            throw new IllegalArgumentException("Parameter this.apiVersion() is required and cannot be null.");
        }
        return service.listPremierAddOnOffers(this.subscriptionId(), this.apiVersion(), this.acceptLanguage(), this.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Page<PremierAddOnOfferInner>>>>() {
                @Override
                public Observable<ServiceResponse<Page<PremierAddOnOfferInner>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<PageImpl<PremierAddOnOfferInner>> result = listPremierAddOnOffersDelegate(response);
                        return Observable.just(new ServiceResponse<Page<PremierAddOnOfferInner>>(result.body(), result.response()));
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1294922
public ServiceCall<Gateway> getGateway(GetGatewayOptions getGatewayOptions) {
    Validator.notNull(getGatewayOptions, "getGatewayOptions cannot be null");
    String[] pathSegments = { "v1/environments", "gateways" };
    String[] pathParameters = { getGatewayOptions.environmentId(), getGatewayOptions.gatewayId() };
    RequestBuilder builder = RequestBuilder.get(RequestBuilder.constructHttpUrl(getEndPoint(), pathSegments,
        pathParameters));
    builder.query("version", versionDate);
    Map<String, String> sdkHeaders = SdkCommon.getSdkHeaders("discovery", "v1", "getGateway");
    for (Entry<String, String> header : sdkHeaders.entrySet()) {
      builder.header(header.getKey(), header.getValue());
    }
    builder.header("Accept", "application/json");
    return createServiceCall(builder.build(), ResponseConverterUtils.getObject(Gateway.class));
  }
1209528
public static sslvserver[] get(nitro_service service) throws Exception{
		sslvserver obj = new sslvserver();
		sslvserver[] response = (sslvserver[])obj.get_resources(service);
		return response;
	}
540808
public Observable<Page<P2SVpnGatewayInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<P2SVpnGatewayInner>>, Page<P2SVpnGatewayInner>>() {
                @Override
                public Page<P2SVpnGatewayInner> call(ServiceResponse<Page<P2SVpnGatewayInner>> response) {
                    return response.body();
                }
            });
    }
193237
public Observable<Page<AppServiceCertificateOrderInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<AppServiceCertificateOrderInner>>, Page<AppServiceCertificateOrderInner>>() {
                @Override
                public Page<AppServiceCertificateOrderInner> call(ServiceResponse<Page<AppServiceCertificateOrderInner>> response) {
                    return response.body();
                }
            });
    }
14542
public Observable<ServiceResponse<List<String>>> listDomainsWithServiceResponseAsync() {
        if (this.client.endpoint() == null) {
            throw new IllegalArgumentException("Parameter this.client.endpoint() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{Endpoint}", this.client.endpoint());
        return service.listDomains(this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<String>>>>() {
                @Override
                public Observable<ServiceResponse<List<String>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<String>> clientResponse = listDomainsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
582850
public Observable<ServiceResponse<Page<ApplicationGatewaySslPredefinedPolicyInner>>> listAvailableSslPredefinedPoliciesWithServiceResponseAsync() {
        return listAvailableSslPredefinedPoliciesSinglePageAsync()
            .concatMap(new Func1<ServiceResponse<Page<ApplicationGatewaySslPredefinedPolicyInner>>, Observable<ServiceResponse<Page<ApplicationGatewaySslPredefinedPolicyInner>>>>() {
                @Override
                public Observable<ServiceResponse<Page<ApplicationGatewaySslPredefinedPolicyInner>>> call(ServiceResponse<Page<ApplicationGatewaySslPredefinedPolicyInner>> page) {
                    String nextPageLink = page.body().nextPageLink();
                    if (nextPageLink == null) {
                        return Observable.just(page);
                    }
                    return Observable.just(page).concatWith(listAvailableSslPredefinedPoliciesNextWithServiceResponseAsync(nextPageLink));
                }
            });
    }
192000
public static sslcipher[] get(nitro_service service) throws Exception{
		sslcipher obj = new sslcipher();
		sslcipher[] response = (sslcipher[])obj.get_resources(service);
		return response;
	}
920903
@SuppressWarnings("StringSplitter")
    protected String[] getProtocolList() {
        SSLSocket socket = null;
        String[] availableProtocols = null;
        final String[] preferredProtocols = settings.getString(
                Settings.KEYS.DOWNLOADER_TLS_PROTOCOL_LIST,
                "TLSv1.1,TLSv1.2,TLSv1.3")
                .split(",");
        try {
            final SSLSocketFactory factory = sslCtxt.getSocketFactory();
            socket = (SSLSocket) factory.createSocket();

            availableProtocols = socket.getSupportedProtocols();
            Arrays.sort(availableProtocols);
            if (LOGGER.isDebugEnabled() && !protocolsLogged) {
                protocolsLogged = true;
                LOGGER.debug("Available Protocols:");
                for (String p : availableProtocols) {
                    LOGGER.debug(p);
                }
            }
        } catch (Exception ex) {
            LOGGER.debug("Error getting protocol list, using TLSv1.1-1.3", ex);
            return new String[]{"TLSv1.1", "TLSv1.2", "TLSv1.3"};
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException ex) {
                    LOGGER.trace("Error closing socket", ex);
                }
            }
        }

        final List<String> aa = new ArrayList<>();
        for (String preferredProtocol : preferredProtocols) {
            final int idx = Arrays.binarySearch(availableProtocols, preferredProtocol);
            if (idx >= 0) {
                aa.add(preferredProtocol);
            }
        }

        return aa.toArray(new String[0]);
    }