Update a Cluster.
333355
def update(self, cluster_id, name=NotUpdated, description=NotUpdated,
               is_public=NotUpdated, is_protected=NotUpdated,
               shares=NotUpdated):
        """"""

        data = {}
        self._copy_if_updated(data, name=name, description=description,
                              is_public=is_public, is_protected=is_protected,
                              shares=shares)

        return self._patch('/clusters/%s' % cluster_id, data)
12510
def update(cls, cluster_id_label, cluster_info):
        
        conn = Qubole.agent(version="v2")
        return conn.put(cls.element_path(cluster_id_label), data=cluster_info)
92297
private void setClusterSize(String clusterName, int newSize)
      throws InterruptedException {
    Preconditions.checkArgument(newSize > 0, "Cluster size must be > 0");
    logger.info("Updating cluster %s to size %d", clusterName, newSize);
    Operation operation = client.updateCluster(Cluster.newBuilder()
        .setName(clusterName)
        .setServeNodes(newSize)
        .build());
    waitForOperation(operation.getName(), 60);
    logger.info("Done updating cluster %s.", clusterName);
  }
864600
private void updatePairs(GvmCluster<S,K> cluster) {
		GvmClusterPair<S,K>[] pairs = cluster.pairs;
		//accelerated path
		if (count == bound) {
			int limit = count - 1;
			for (int i = 0; i < limit; i++) {
				this.pairs.reprioritize(pairs[i]);
			}
		} else {
			int limit = bound - 1;
			for (int i = 0; i < limit; i++) {
				GvmClusterPair<S,K> pair = pairs[i];
				if (pair.c1.removed || pair.c2.removed) continue;
				this.pairs.reprioritize(pair);
			}
		}
	}
265891
def update_config(self, cluster_config):
        
        for key, attr in [
                ('ssh_to', 'ssh_to'),
        ]:
            oldvalue = getattr(self, attr)
            try:
                newvalue = cluster_config[key]
            except KeyError:
                continue
            if key in cluster_config and newvalue != oldvalue:
                setattr(self, attr, newvalue)
                log.debug(
                    "Configuration attribute `%s` updated: %s -> %s",
                    key, oldvalue, newvalue)
619034
def broadcast(self, data):
        """"""
        for destination in self.cluster:
            asyncio.ensure_future(self.send(data, destination), loop=self.loop)
942408
public void reloadPartitions() {

        if (partitions == null) {
            initializePartitions();
            partitions.updateCache();
        } else {

            Partitions loadedPartitions = loadPartitions();
            if (TopologyComparators.isChanged(getPartitions(), loadedPartitions)) {

                logger.debug("Using a new cluster topology");

                List<RedisClusterNode> before = new ArrayList<RedisClusterNode>(getPartitions());
                List<RedisClusterNode> after = new ArrayList<RedisClusterNode>(loadedPartitions);

                getResources().eventBus().publish(new ClusterTopologyChangedEvent(before, after));
            }

            this.partitions.reload(loadedPartitions.getPartitions());
        }

        updatePartitionsInConnections();
    }
516591
def update(connection, silent, hgnc_file_path, hcop_file_path, low_memory):
    """"""
    database.update(connection=connection,
                    silent=silent,
                    hgnc_file_path=hgnc_file_path,
                    hcop_file_path=hcop_file_path,
                    low_memory=low_memory)
10449
void updateReplicas(int partitionId, PartitionReplica[] replicas) {
        InternalPartitionImpl partition = partitions[partitionId];
        partition.setReplicas(replicas);
    }
1113827
def _update_threads(self):
        """"""
        if self.remaining_clusters is not None:
            self.threads = max(1,self.threads_total//self.remaining_clusters.value)
        #otherwise just keep the current (initial) value
        print("{} detected {} threads available to it".format(self.name,self.threads), file = self.log_fh)
444403
def update(self, *args, **kwargs):
        """"""
        self._write_op(self._update_nosync, *args, **kwargs)
186053
def update(self, *args, **kwargs):
        """"""
        self._extend(args, kwargs, 'update', self._update_items)
275925
def update(self, data):
        """"""
        self.name = data["name"]
        self.description = data['description']
        self.win_index = data['win_index']
        # Other attributes are optional
        if conf.use_winpcapy:
            self._update_pcapdata()
        try:
            self.ip = socket.inet_ntoa(get_if_raw_addr(data['guid']))
        except (KeyError, AttributeError, NameError):
            pass
        try:
            self.mac = data['mac']
        except KeyError:
            pass
1170519
def _update_cluster_view(self):
        """"""
        logger.log(5, "Update the cluster view.")
        cluster_ids = [int(c) for c in self.clustering.cluster_ids]
        self.cluster_view.set_rows(cluster_ids)
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);
	}
669194
def cluster_replicate(self, node_id):
        """"""
        fut = self.execute(b'CLUSTER', b'REPLICATE', node_id)
        return wait_ok(fut)
1346752
def update(self,o):
        """"""

        self.open()

        try:
            self._db.update(o._db)
        except AttributeError:
            self._db.update(o)