Use this API to add clusternodegroup resources.
1628
public static base_responses add(nitro_service client, clusternodegroup resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			clusternodegroup addresources[] = new clusternodegroup[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new clusternodegroup();
				addresources[i].name = resources[i].name;
				addresources[i].strict = resources[i].strict;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
691994
public static ns_cluster[] get(nitro_service client) throws Exception
	{
		ns_cluster resource = new ns_cluster();
		resource.validate("get");
		return (ns_cluster[]) resource.get_resources(client);
	}
837355
public void addGroupFieldSet(String group, CmsFieldSet fieldSet) {

        // can't add a group field set twice
        if (!m_groupFieldSets.containsKey(group)) {
            m_groupFieldSets.put(group, fieldSet);
            m_panel.add(fieldSet);
        }
    }
705202
public static base_response update(nitro_service client, clusternodegroup resource) throws Exception {
		clusternodegroup updateresource = new clusternodegroup();
		updateresource.name = resource.name;
		updateresource.strict = resource.strict;
		return updateresource.update_resource(client);
	}
245780
public static base_response add(nitro_service client, servicegroup resource) throws Exception {
		servicegroup addresource = new servicegroup();
		addresource.servicegroupname = resource.servicegroupname;
		addresource.servicetype = resource.servicetype;
		addresource.cachetype = resource.cachetype;
		addresource.td = resource.td;
		addresource.maxclient = resource.maxclient;
		addresource.maxreq = resource.maxreq;
		addresource.cacheable = resource.cacheable;
		addresource.cip = resource.cip;
		addresource.cipheader = resource.cipheader;
		addresource.usip = resource.usip;
		addresource.pathmonitor = resource.pathmonitor;
		addresource.pathmonitorindv = resource.pathmonitorindv;
		addresource.useproxyport = resource.useproxyport;
		addresource.healthmonitor = resource.healthmonitor;
		addresource.sc = resource.sc;
		addresource.sp = resource.sp;
		addresource.rtspsessionidremap = resource.rtspsessionidremap;
		addresource.clttimeout = resource.clttimeout;
		addresource.svrtimeout = resource.svrtimeout;
		addresource.cka = resource.cka;
		addresource.tcpb = resource.tcpb;
		addresource.cmp = resource.cmp;
		addresource.maxbandwidth = resource.maxbandwidth;
		addresource.monthreshold = resource.monthreshold;
		addresource.state = resource.state;
		addresource.downstateflush = resource.downstateflush;
		addresource.tcpprofilename = resource.tcpprofilename;
		addresource.httpprofilename = resource.httpprofilename;
		addresource.comment = resource.comment;
		addresource.appflowlog = resource.appflowlog;
		addresource.netprofile = resource.netprofile;
		addresource.autoscale = resource.autoscale;
		addresource.memberport = resource.memberport;
		return addresource.add_resource(client);
	}
390985
protected synchronized void addMapping(String contextRoot, WebGroup group) throws Exception {
        if (TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
            logger.logp(Level.FINE, CLASS_NAME, "addMapping", " contextRoot -->" + contextRoot + " group -->" + group.getName() + " : " + this.hashCode());
        }
        requestMapper.addMapping(contextRoot, group);
    }
309812
def add_cluster(
        self, 
        name, 
        server=None,
        certificate_authority_data=None,
        **attrs):
        """"""
        if self.cluster_exists(name):
            raise KubeConfError("Cluster with the given name already exists.")

        clusters = self.get_clusters()
        
        # Add parameters.
        new_cluster = {'name': name, 'cluster':{}}
        attrs_ = new_cluster['cluster']
        if server is not None:
            attrs_['server'] = server
        if certificate_authority_data is not None:
            attrs_['certificate-authority-data'] = certificate_authority_data

        attrs_.update(attrs)
        clusters.append(new_cluster)
777219
void addGroupVertex(final ManagementGroupVertex groupVertex) {

		this.groupVertices.add(groupVertex);

		this.managementGraph.addGroupVertex(groupVertex.getID(), groupVertex);
	}
902563
def member_add(self, cluster_id, params):
        """"""
        cluster = self._storage[cluster_id]
        result = cluster.member_add(params.get('id', None), params.get('shardParams', {}))
        self._storage[cluster_id] = cluster
        return result
1240946
def create_cluster_meta(cluster_groups):
    """"""
    meta = ClusterMeta()
    meta.add_field('group')

    cluster_groups = cluster_groups or {}
    data = {c: {'group': v} for c, v in cluster_groups.items()}
    meta.from_dict(data)

    return meta
1282814
private static List<Tag<?>> addClusterNameTags(List<? extends Tag<?>> tags) {
    return ImmutableList.<Tag<?>>builder().addAll(tags).addAll(Tag.fromMap(ClusterNameTags.getClusterNameTags()))
        .build();
  }
412917
public void setClusters(java.util.Collection<String> clusters) {
        if (clusters == null) {
            this.clusters = null;
            return;
        }

        this.clusters = new java.util.ArrayList<String>(clusters);
    }
54740
public static base_response add(nitro_service client, bridgegroup resource) throws Exception {
		bridgegroup addresource = new bridgegroup();
		addresource.id = resource.id;
		addresource.ipv6dynamicrouting = resource.ipv6dynamicrouting;
		return addresource.add_resource(client);
	}
193530
public void addGroup(Group section) {
    if (section != null) {
      if (section.isAnyAgent()) {
        if (this.defaultSection == null) {
          this.defaultSection = section;
        } else {
          this.defaultSection.getAccessList().importAccess(section.getAccessList());
        }
      } else {
        Group exact = findExactSection(section);
        if (exact == null) {
          groups.add(section);
        } else {
          exact.getAccessList().importAccess(section.getAccessList());
        }
      }
    }
  }
762423
def placement_group_setup(group_name):
  """"""

  existing_placement_groups = u.get_placement_group_dict()

  group = existing_placement_groups.get(group_name, None)
  if group:
    assert group.state == 'available'
    assert group.strategy == 'cluster'
    print("Reusing group ", group.name)
    return group

  print("Creating group " + group_name)
  ec2 = u.get_ec2_resource()
  group = ec2.create_placement_group(GroupName=group_name, Strategy='cluster')
  return group
1068476
public static base_responses update(nitro_service client, clusternode resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			clusternode updateresources[] = new clusternode[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new clusternode();
				updateresources[i].nodeid = resources[i].nodeid;
				updateresources[i].state = resources[i].state;
				updateresources[i].backplane = resources[i].backplane;
				updateresources[i].priority = resources[i].priority;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
430519
private ClusterDasVmSettings createClusterDasVmSettings(String restartPriority) {
        ClusterDasVmSettings clusterDasVmSettings = new ClusterDasVmSettings();
        clusterDasVmSettings.setRestartPriority(restartPriority);
        return clusterDasVmSettings;
    }