Create firewall policy

@param config firewall policy config
@return OperationFuture wrapper for firewall policy
767316
public OperationFuture<FirewallPolicy> create(FirewallPolicyConfig config) {
        String dataCenterId = dataCenterService.findByRef(config.getDataCenter()).getId();

        FirewallPolicyMetadata firewall = firewallPolicyClient.create(
            dataCenterId,
            composeFirewallPolicyRequest(config)
        );

        return new OperationFuture<>(
            FirewallPolicy.refById(
                firewall.getId(),
                DataCenter.refById(dataCenterId)
            ),
            new NoWaitingJobFuture()
        );
    }
508898
@SuppressWarnings("unchecked")
  protected VersionSelectionPolicy<DatasetVersion> createSelectionPolicy(Config selectionConfig, Config jobConfig) {
    try {
      String selectionPolicyKey =
          StringUtils.substringAfter(ConfigurableCleanableDataset.SELECTION_POLICY_CLASS_KEY,
              ConfigurableCleanableDataset.CONFIGURATION_KEY_PREFIX);
      Preconditions.checkArgument(selectionConfig.hasPath(selectionPolicyKey));
      String className = selectionConfig.getString(selectionPolicyKey);
      return (VersionSelectionPolicy<DatasetVersion>) GobblinConstructorUtils.invokeFirstConstructor(
          this.versionSelectionAliasResolver.resolveClass(className), ImmutableList.<Object> of(selectionConfig),
          ImmutableList.<Object> of(selectionConfig, ConfigUtils.configToProperties(jobConfig)),
          ImmutableList.<Object> of(ConfigUtils.configToProperties(jobConfig)));
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException
        | ClassNotFoundException e) {
      throw new IllegalArgumentException(e);
    }
  }
1143793
public static ServerSocketFactory createSSLServerSocketFactory(Configuration config) throws Exception {
		SSLContext sslContext = createInternalSSLContext(config);
		if (sslContext == null) {
			throw new IllegalConfigurationException("SSL is not enabled");
		}

		String[] protocols = getEnabledProtocols(config);
		String[] cipherSuites = getEnabledCipherSuites(config);

		SSLServerSocketFactory factory = sslContext.getServerSocketFactory();
		return new ConfiguringSSLServerSocketFactory(factory, protocols, cipherSuites);
	}
1232979
public OperationFuture<Server> addSecondaryNetwork(Server server, AddNetworkConfig config) {
        ServerMetadata serverMetadata = findByRef(server);

        NetworkLink link = client.addSecondaryNetwork(
            idByRef(server),
            buildSecondaryNetworkRequest(config, serverMetadata.getLocationId())
        );

        return new OperationFuture<>(
            server,
            link.getOperationId(),
            experimentalQueueClient
        );
    }
606286
public static SocketFactory createSSLClientSocketFactory(Configuration config) throws Exception {
		SSLContext sslContext = createInternalSSLContext(config);
		if (sslContext == null) {
			throw new IllegalConfigurationException("SSL is not enabled");
		}

		return sslContext.getSocketFactory();
	}
774320
public static ThorntailConfigurationBuilder create(Configuration config)
    {
        ThorntailConfigurationBuilder builder = new ThorntailConfigurationBuilder();

        ConfigurationElement propertiesElem = null;
        try
        {
            propertiesElem = config.getConfigurationElement("properties");
        }
        catch (RuntimeException e)
        {
            // Do nothing
        }
        if (propertiesElem != null)
        {
            Map<String, String> properties = new TreeMap<>();
            propertiesElem.getChildren().stream()
                        .filter(ConfigurationElement.class::isInstance)
                        .map(ConfigurationElement.class::cast)
                        .forEach(elem -> properties.put(elem.getName(), elem.getText()));
            builder.properties(properties);
        }
        return builder;
    }
560223
public BucketingSink<T> setFSConfig(Configuration config) {
		this.fsConfig = new Configuration();
		fsConfig.addAll(config);
		return this;
	}
464033
public OperationFuture<List<AntiAffinityPolicy>> modify(List<AntiAffinityPolicy> policyRefs,
        AntiAffinityPolicyConfig modifyConfig) {

        policyRefs.forEach(ref -> modify(ref, modifyConfig));

        return new OperationFuture<>(
            policyRefs,
            new NoWaitingJobFuture()
        );
    }
1273431
def fw_policy_create(self, data, fw_name=None, cache=False):
        
        LOG.debug("FW Policy Debug")
        self._fw_policy_create(fw_name, data, cache)
504541
private OperationFuture<Group> createServers(GroupHierarchyConfig config, String rootGroupId) {
        List<CreateServerConfig> configs = config.getServerConfigs();

        List<JobFuture> futures = configs.stream()
            .map(serverConfig -> serverService().create(serverConfig).jobFuture())
            .collect(toList());

        return new OperationFuture<>(Group.refById(rootGroupId), new ParallelJobsFuture(futures));
    }
572638
public static NetworkSystemBartender
  createAndAddSystem(SystemManager systemManager,
                     ServerBartender selfServer,
                     Config config)
  {
    NetworkSystemBartender clusterSystem
      = new NetworkSystemBartender(systemManager, selfServer, config);
    
    createAndAddSystem(clusterSystem);
    
    return clusterSystem;
  }
146325
public OperationFuture<Group> create(GroupConfig groupConfig) {
        checkNotNull(groupConfig, "GroupConfig must be not null");
        checkNotNull(groupConfig.getName(), "Name of GroupConfig must be not null");
        checkNotNull(groupConfig.getParentGroup(), "ParentGroup of GroupConfig must be not null");

        GroupMetadata group = client.createGroup(
                converter.createGroupRequest(groupConfig, idByRef(groupConfig.getParentGroup()),
                    groupConfig.getCustomFields() == null || groupConfig.getCustomFields().size() == 0 ?
                        null : client.getCustomFields()
                ));

        return new OperationFuture<>(
            Group.refById(group.getId()),
            new NoWaitingJobFuture()
        );
    }
936239
def configure_firewall(self, FirewallRules):
        
        firewall_rule_bodies = [
            FirewallRule.to_dict()
            for FirewallRule in FirewallRules
        ]
        return self.cloud_manager.configure_firewall(self, firewall_rule_bodies)
1113033
protected ConnectorController createConnectorController(ServletConfig config)
	{
		ConnectorController connectorController = new ConnectorController();

		connectorController
				.setCommandExecutorFactory(createCommandExecutorFactory(config));
		connectorController.setFsServiceFactory(createServiceFactory(config));

		return connectorController;
	}
499695
public void createBucket(BucketConfiguration config) throws BucketAlreadyExistsException, IOException {
        if (!config.validate()) {
            throw new IllegalArgumentException("Invalid bucket configuration");
        }

        synchronized (buckets) {
            if (buckets.containsKey(config.name)) {
                throw new BucketAlreadyExistsException(config.name);
            }

            Bucket bucket = Bucket.create(this, config);
            BucketAdminServer adminServer = new BucketAdminServer(bucket, httpServer, this);
            adminServer.register();
            bucket.setAdminServer(adminServer);

            HttpAuthVerifier verifier = new HttpAuthVerifier(bucket, authenticator);

            if (config.type == BucketType.COUCHBASE) {
                CAPIServer capi = new CAPIServer(bucket, verifier);
                capi.register(httpServer);
                bucket.setCAPIServer(capi);
            }

            buckets.put(config.name, bucket);
            bucket.start();
        }
    }
499302
protected static ManagedMessagingService buildMessagingService(ClusterConfig config) {
    return new NettyMessagingService(
        config.getClusterId(),
        config.getNodeConfig().getAddress(),
        config.getMessagingConfig());
  }
753737
@Override
	public <T extends Endpoint> Strategy<T> create() {
		if (transporter == null) {
			return new RoundRobinStrategy<T>(broker, preferLocal);
		}
		return new NetworkLatencyStrategy<T>(broker, preferLocal, maxTries, this);
	}