Retrieve all the clients for the AbstractClientStatsCollectors.
4649
def Run(self):
    """"""
    try:

      self.stats = {}

      self.BeginProcessing()

      processed_count = 0

      for client_info_batch in _IterateAllClients(
          recency_window=self.recency_window):
        for client_info in client_info_batch:
          self.ProcessClientFullInfo(client_info)
        processed_count += len(client_info_batch)
        self.Log("Processed %d clients.", processed_count)
        self.HeartBeat()

      self.FinishProcessing()
      for fd in itervalues(self.stats):
        fd.Close()

      logging.info("%s: processed %d clients.", self.__class__.__name__,
                   processed_count)
    except Exception as e:  # pylint: disable=broad-except
      logging.exception("Error while calculating stats: %s", e)
      raise
873247
def collections(self):
        """"""
        # if cache server is configured, load collection from there
        if self.cache:
            return self.cache.get(
                self.app.config['COLLECTIONS_CACHE_KEY'])
370983
def ReadAllClientLabels(self):
    """"""
    result = set()
    for labels_dict in itervalues(self.labels):
      for owner, names in iteritems(labels_dict):
        for name in names:
          result.add(rdf_objects.ClientLabel(owner=owner, name=name))

    return list(result)
786311
public List<ClientlibElement> getChildren() {
        List<ClientlibElement> children = new ArrayList<>();
        for (Resource child : resource.getChildren()) {
            if (isFile(child)) children.add(new ClientlibFile(null, type, child, getAdditionalProperties()));
            else children.add(new ClientlibResourceFolder(type, child, this));
        }
        return children;
    }
277537
def client_list(self, _type=None):
        
        "Returns a list of currently connected clients"
        if _type is not None:
            client_types = ('normal', 'master', 'replica', 'pubsub')
            if str(_type).lower() not in client_types:
                raise DataError("CLIENT LIST _type must be one of %r" % (
                                client_types,))
            return self.execute_command('CLIENT LIST', Token.get_token('TYPE'),
                                        _type)
        return self.execute_command('CLIENT LIST')
703990
def get_client(self, provider):
        ""
        if self.client_class is not None:
            return self.client_class(provider)
        return get_client(provider)
325466
public Map<Integer, ClientAffinityStats> getAffinityStats()
    {
        Map<Integer, ClientAffinityStats> retval = new TreeMap<Integer, ClientAffinityStats>();
        for (Entry<Integer, ClientAffinityStats> e : m_currentAffinity.entrySet()) {
            if (m_baselineAffinity.containsKey(e.getKey())) {
                retval.put(e.getKey(), ClientAffinityStats.diff(e.getValue(), m_baselineAffinity.get(e.getKey())));
            }
            else {
                retval.put(e.getKey(), (ClientAffinityStats) e.getValue().clone());
            }
        }
        return retval;
    }
178075
def get_clients(self, limit=None, offset=None):
        
        data = {}
        if limit:
            data['limit'] = limit
        if offset:
            data['offset'] = offset
        result = self._request('GET', '/clients', data=json.dumps(data))
        return result.json()
811728
def CountClientPlatformReleasesByLabel(self, day_buckets):
    """"""
    return self._CountClientStatisticByLabel(
        day_buckets, lambda client_info: client_info.last_snapshot.Uname())
702297
def query_clients(self):
        

        try:
            data = self.call("clients", {'client': 'None'})
            if len(data) > 0:
                return pd.DataFrame(data).drop(
                    ['commandLine',
                     'processId'],
                    axis=1
                )
            else:
                return pd.DataFrame(
                    None,
                    columns=[
                        'id',
                        'name',
                        'windowsTitle',
                        'accountInfo',
                        'status'
                    ]
                )
        except Exception as e:
            return False, e
849793
public function getClients()
  {
    $clients = array();

    $this->Client->byOrganization($this->AuthenticationManager->getCurrentUserOrganizationId())->each(function($Client) use (&$clients)
    {
      array_push($clients, array('label'=> $Client->name , 'value'=>$Client->id));
    });

    return $clients;
  }
36609
public List<Client> findAllClients(int profileId) throws Exception {
        ArrayList<Client> clients = new ArrayList<Client>();

        PreparedStatement query = null;
        ResultSet results = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            query = sqlConnection.prepareStatement(
                "SELECT * FROM " + Constants.DB_TABLE_CLIENT +
                    " WHERE " + Constants.GENERIC_PROFILE_ID + " = ?"
            );
            query.setInt(1, profileId);
            results = query.executeQuery();
            while (results.next()) {
                clients.add(this.getClientFromResultSet(results));
            }
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                if (results != null) {
                    results.close();
                }
            } catch (Exception e) {
            }
            try {
                if (query != null) {
                    query.close();
                }
            } catch (Exception e) {
            }
        }
        return clients;
    }
319946
def get_performance_signatures(self, project, **params):
        '''
        
        '''
        results = self._get_json(self.PERFORMANCE_SIGNATURES_ENDPOINT, project, **params)
        return PerformanceSignatureCollection(results)
894238
def ReadMostRecentClientGraphSeries(self, client_label,
                                      report_type
                                     ):
    """"""
    series_with_timestamps = self.ReadAllClientGraphSeries(
        client_label, report_type)
    if not series_with_timestamps:
      return None
    _, latest_series = list(sorted(iteritems(series_with_timestamps)))[-1]
    return latest_series
258414
public java.util.List<ClientPropertiesResult> getClientPropertiesList() {
        if (clientPropertiesList == null) {
            clientPropertiesList = new com.amazonaws.internal.SdkInternalList<ClientPropertiesResult>();
        }
        return clientPropertiesList;
    }
243759
def MultiReadClientLabels(self, client_ids, cursor=None):
    """"""

    int_ids = [db_utils.ClientIDToInt(cid) for cid in client_ids]
    query = ("SELECT client_id, owner_username, label "
             "FROM client_labels "
             "WHERE client_id IN ({})").format(", ".join(["%s"] *
                                                         len(client_ids)))

    ret = {client_id: [] for client_id in client_ids}
    cursor.execute(query, int_ids)
    for client_id, owner, label in cursor.fetchall():
      ret[db_utils.IntToClientID(client_id)].append(
          rdf_objects.ClientLabel(name=label, owner=owner))

    for r in itervalues(ret):
      r.sort(key=lambda label: (label.owner, label.name))
    return ret
584064
protected List<Object> syncAndReturnAll() {
        List<Object> responseList = new ArrayList<>(clients.size());
        innerSync(responseList);
        return responseList;
    }