Configure the endpoint factory

@param factory
348465
protected void configureEndpointFactory(AbstractWSDLBasedEndpointFactory factory)
   {
      //Configure binding customization
      if (customization != null)
      {
         ReflectionServiceFactoryBean serviceFactory = factory.getServiceFactory();
         //customize default databinding (early pulls in ServiceFactory default databinding and configure it, as it's lazily loaded)
         serviceFactory.reset();
         DataBinding serviceFactoryDataBinding = serviceFactory.getDataBinding(true);
         configureBindingCustomization(serviceFactoryDataBinding, customization);
         serviceFactory.setDataBinding(serviceFactoryDataBinding);
         //customize user provided databinding (CXF later overrides the ServiceFactory databinding using the user provided one) 
         if (factory.getDataBinding() == null)
         {
            //set the endpoint factory's databinding to prevent CXF resetting everything because user did not provide anything
            factory.setDataBinding(serviceFactoryDataBinding);
         }
         else
         {
            configureBindingCustomization(factory.getDataBinding(), customization);
         }
      }
      //add other configurations here below
   }
1186419
public static void setURLStreamHandlerFactory ( URLStreamHandlerFactory factory ) {
        synchronized ( PROTOCOL_HANDLERS ) {
            if ( Handler.factory != null ) {
                throw new IllegalStateException("URLStreamHandlerFactory already set.");
            }
            PROTOCOL_HANDLERS.clear();
            Handler.factory = factory;
        }
    }
316832
public void setEndpoints(java.util.Collection<EndpointSummary> endpoints) {
        if (endpoints == null) {
            this.endpoints = null;
            return;
        }

        this.endpoints = new java.util.ArrayList<EndpointSummary>(endpoints);
    }
1202841
public void prepareEndPoint(CFEndPointImpl endpoint) throws ChannelFrameworkException {
        if (null == endpoint.getOutboundChainData()) {
            VirtualConnectionFactory vcf = getOutboundVCFactory(endpoint.getOutboundChannelDefs());
            endpoint.setOutboundVCFactory(vcf);
            endpoint.setOutboundChainData(getChain(vcf.getName()));
        }
    }
799941
protected void configureClientProxyFactoryBean(ClientProxyFactoryBean factory)
   {
      //Configure binding customization
      if (customization != null)
      {
         //customize default databinding (early pulls in ServiceFactory default databinding and configure it, as it's lazily loaded)
         ReflectionServiceFactoryBean serviceFactory = factory.getServiceFactory();
         serviceFactory.reset();
         DataBinding serviceFactoryDataBinding = serviceFactory.getDataBinding(true);
         configureBindingCustomization(serviceFactoryDataBinding, customization);
         serviceFactory.setDataBinding(serviceFactoryDataBinding);
         //customize user provided databinding (CXF later overrides the ServiceFactory databinding using the user provided one) 
         if (factory.getDataBinding() == null)
         {
            //set the endpoint factory's databinding to prevent CXF resetting everything because user did not provide anything
            factory.setDataBinding(serviceFactoryDataBinding);
         }
         else
         {
            configureBindingCustomization(factory.getDataBinding(), customization);
         }
      }
      //add other configurations here below
   }
1258706
public void setEndpointDescriptions(java.util.Collection<EndpointDescription> endpointDescriptions) {
        if (endpointDescriptions == null) {
            this.endpointDescriptions = null;
            return;
        }

        this.endpointDescriptions = new java.util.ArrayList<EndpointDescription>(endpointDescriptions);
    }
127696
public static void setKryoFactory(FluoConfiguration config,
      Class<? extends KryoFactory> factoryType) {
    config.getAppConfiguration().setProperty(KRYO_FACTORY_PROP, factoryType.getName());
  }
769045
public static void setKryoFactory(FluoConfiguration config, String factoryType) {
    config.getAppConfiguration().setProperty(KRYO_FACTORY_PROP, factoryType);
  }
658124
public void addConnectionFactory(ConnectionFactory<?> connectionFactory) {
		if (connectionFactories.containsKey(connectionFactory.getProviderId())) {
			throw new IllegalArgumentException("A ConnectionFactory for provider '" + connectionFactory.getProviderId() + "' has already been registered");
		}
		Class<?> apiType = GenericTypeResolver.resolveTypeArgument(connectionFactory.getClass(), ConnectionFactory.class);
		if (apiTypeIndex.containsKey(apiType)) {
			throw new IllegalArgumentException("A ConnectionFactory for API [" + apiType.getName() + "] has already been registered");
		}
		connectionFactories.put(connectionFactory.getProviderId(), connectionFactory);
		apiTypeIndex.put(apiType, connectionFactory.getProviderId());
	}
1139177
public void setActionStubFactory(ActionStubFactory actionStubFactory) {
		this.actionStubFactory = actionStubFactory;
		if (actionStubFactory != null) {
			actionStubFactory.init(new ActionStubFactoryContext() {

				@Override
				public ServiceUrlProvider getServiceUrlProvider() {
					return moduleRegistry.getResourceRegistry().getServiceUrlProvider();
				}

				@Override
				public HttpAdapter getHttpAdapter() {
					return httpAdapter;
				}
			});
		}
	}
112001
public final void setEntryViewFactory(
            Callback<Entry<?>, MonthEntryView> factory) {
        requireNonNull(factory);
        entryViewFactoryProperty().set(factory);
    }
760426
public void setTileFactory(TileFactory factory)
    {
        if (factory == null)
            throw new NullPointerException("factory must not be null");

        this.factory.removeTileListener(tileLoadListener);
        this.factory.dispose();

        this.factory = factory;
        this.setZoom(factory.getInfo().getDefaultZoomLevel());

        factory.addTileListener(tileLoadListener);

        repaint();
    }
1038347
public void setEndpointConfigs(java.util.Collection<EndpointConfigSummary> endpointConfigs) {
        if (endpointConfigs == null) {
            this.endpointConfigs = null;
            return;
        }

        this.endpointConfigs = new java.util.ArrayList<EndpointConfigSummary>(endpointConfigs);
    }
277151
public void endpointDeactivation(MessageEndpointFactory endpointFactory,
      ActivationSpec spec) {
    VertxActivation activation = activations.remove(spec);
    if (activation != null)
      activation.stop();

    log.finest("endpointDeactivation()");

  }
262376
public void endpointActivation(MessageEndpointFactory endpointFactory,
      ActivationSpec spec) throws ResourceException {
    VertxActivation activation = new VertxActivation(this, endpointFactory,
        (VertxActivationSpec) spec);
    activations.put((VertxActivationSpec) spec, activation);
    activation.start();

    log.finest("endpointActivation()");

  }
609711
public static void configureFactory( ConnectionFactory factory, Map<String,String> configuration )
	throws IOException {

		final Logger logger = Logger.getLogger( RabbitMqUtils.class.getName());
		logger.fine( "Configuring a connection factory for RabbitMQ." );

		String messageServerIp = configuration.get( RABBITMQ_SERVER_IP );
		if( messageServerIp != null ) {
			Map.Entry<String,Integer> entry = Utils.findUrlAndPort( messageServerIp );
			factory.setHost( entry.getKey());
			if( entry.getValue() > 0 )
				factory.setPort( entry.getValue());
		}

		factory.setUsername( configuration.get( RABBITMQ_SERVER_USERNAME ));
		factory.setPassword( configuration.get( RABBITMQ_SERVER_PASSWORD ));

		// Timeout for connection establishment: 5s
		factory.setConnectionTimeout( 5000 );

		// Configure automatic reconnection
		factory.setAutomaticRecoveryEnabled( true );

		// Recovery interval: 10s
		factory.setNetworkRecoveryInterval( 10000 );

		// Exchanges and so on should be redeclared if necessary
		factory.setTopologyRecoveryEnabled( true );

		// SSL
		if( Boolean.parseBoolean( configuration.get( RABBITMQ_USE_SSL ))) {
			logger.fine( "Connection factory for RabbitMQ: SSL is used." );

			InputStream clientIS = null;
			InputStream storeIS = null;
			try {
				clientIS = new FileInputStream( configuration.get( RABBITMQ_SSL_KEY_STORE_PATH ));
				storeIS = new FileInputStream( configuration.get( RABBITMQ_SSL_TRUST_STORE_PATH ));

				char[] keyStorePassphrase = configuration.get( RABBITMQ_SSL_KEY_STORE_PASSPHRASE ).toCharArray();
				KeyStore ks = KeyStore.getInstance( getValue( configuration, RABBITMQ_SSL_KEY_STORE_TYPE, DEFAULT_SSL_KEY_STORE_TYPE ));
				ks.load( clientIS, keyStorePassphrase );

				String value = getValue( configuration, RABBITMQ_SSL_KEY_MNGR_FACTORY, DEFAULT_SSL_MNGR_FACTORY );
				KeyManagerFactory kmf = KeyManagerFactory.getInstance( value );
				kmf.init( ks, keyStorePassphrase );

				char[] trustStorePassphrase = configuration.get( RABBITMQ_SSL_TRUST_STORE_PASSPHRASE ).toCharArray();
				KeyStore tks = KeyStore.getInstance( getValue( configuration, RABBITMQ_SSL_TRUST_STORE_TYPE, DEFAULT_SSL_TRUST_STORE_TYPE ));
				tks.load( storeIS, trustStorePassphrase );

				value = getValue( configuration, RABBITMQ_SSL_TRUST_MNGR_FACTORY, DEFAULT_SSL_MNGR_FACTORY );
				TrustManagerFactory tmf = TrustManagerFactory.getInstance( value );
				tmf.init( tks );

				SSLContext c = SSLContext.getInstance( getValue( configuration, RABBITMQ_SSL_PROTOCOL, DEFAULT_SSL_PROTOCOL ));
				c.init( kmf.getKeyManagers(), tmf.getTrustManagers(), null );
				factory.useSslProtocol( c );

			} catch( GeneralSecurityException e ) {
				throw new IOException( "SSL configuration for the RabbitMQ factory failed.", e );

			} finally {
				Utils.closeQuietly( storeIS );
				Utils.closeQuietly( clientIS );
			}
		}
	}
766992
@Override
  public void setEndpointAddress(BindingProvider soapClient, String endpointAddress) {
    soapClient.getRequestContext().put(
        BindingProvider.ENDPOINT_ADDRESS_PROPERTY, endpointAddress);
  }