Adds a Probe instance to this hop's results.
977540
def add_probe(self, probe):
        """"""
        if self.probes:
            probe_last = self.probes[-1]
            if not probe.ip:
                probe.ip = probe_last.ip
                probe.name = probe_last.name
        self.probes.append(probe)
337263
public void run() {

    ResponseWrapper response = null;

    LOGGER.info("Received probe id: " + probe.getProbeId());

    // Only handle probes that we haven't handled before
    // The Probe Generator needs to send a stream of identical UDP packets
    // to compensate for UDP reliability issues. Therefore, the Responder
    // will likely get more than 1 identical probe. We should ignore
    // duplicates.
    if (!isProbeHandled(probe.getProbeId())) {

      if (this.noBrowser && probe.isNaked()) {
        LOGGER.warn("Responder set to noBrowser mode. Discarding naked probe with id [" + probe.getProbeId() + "]");
      } else {

        for (ProbeHandlerPlugin handler : handlers) {
          response = handler.handleProbeEvent(probe);
          if (!response.isEmpty()) {
            LOGGER.debug("Response to probe [" + probe.getProbeId() + "] includes " + response.numberOfServices());
            Iterator<RespondToURL> respondToURLs = probe.getRespondToURLs().iterator();

            if (probe.getRespondToURLs().isEmpty())
              LOGGER.warn("Processed probe [" + probe.getProbeId() + "] with no respondTo address. That's odd.");

            if (respondToURLs.hasNext()) {
              RespondToURL respondToURL = respondToURLs.next();
              // we are ignoring the label for now
              boolean success = sendResponse(respondToURL.url, probe.getRespondToPayloadType(), response);
              if (!success) {
                LOGGER.warn("Issue sending probe [" + probe.getProbeId() + "] response to [" + respondToURL.url + "]");
              }
            }

          } else {
            LOGGER.error("Response to probe [" + probe.getProbeId() + "] is empty.  Not sending empty response.");
          }
        }

      }

      markProbeAsHandled(probe.getProbeId());

      responder.probeProcessed();

    } else {
      LOGGER.info("Discarding duplicate/handled probe with id: " + probe.getProbeId());
    }
  }
883288
public SwimMembershipProtocolConfig setProbeTimeout(Duration probeTimeout) {
    checkNotNull(probeTimeout, "probeTimeout cannot be null");
    checkArgument(!probeTimeout.isNegative() && !probeTimeout.isZero(), "probeTimeout must be positive");
    this.probeTimeout = probeTimeout;
    return this;
  }
694164
def update_probes(self, progress):
        
        new_values = self.read_probes.probes_values
        probe_count = len(self.read_probes.probes)

        if probe_count > self.tree_probes.topLevelItemCount():
            # when run for the first time, there are no probes in the tree, so we have to fill it first
            self.fill_treewidget(self.tree_probes, new_values)
        else:
            for x in range(probe_count):
                topLvlItem = self.tree_probes.topLevelItem(x)
                for child_id in range(topLvlItem.childCount()):
                    child = topLvlItem.child(child_id)
                    child.value = new_values[topLvlItem.name][child.name]
                    child.setText(1, str(child.value))

        if self.probe_to_plot is not None:
            self.probe_to_plot.plot(self.matplotlibwidget_1.axes)
            self.matplotlibwidget_1.draw()


        if self.chk_probe_log.isChecked():
            data = ','.join(list(np.array([[str(p) for p in list(p_dict.values())] for instr, p_dict in new_values.items()]).flatten()))
            self.probe_file.write('{:s}\n'.format(data))
115641
private static synchronized void addTransformer() {
        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.entry(tc, "addTransformer");

        if (registeredTransformer == null && instrumentation != null) {
            registeredTransformer = new LibertyRuntimeTransformer();
            instrumentation.addTransformer(registeredTransformer, true);
        }

        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.exit(tc, "addTransformer");
    }
530874
private void probe(ImmutableMember member) {
    LOGGER.trace("{} - Probing {}", localMember.id(), member);
    bootstrapService.getMessagingService().sendAndReceive(
        member.address(), MEMBERSHIP_PROBE, SERIALIZER.encode(Pair.of(localMember.copy(), member)), false, config.getProbeTimeout())
        .whenCompleteAsync((response, error) -> {
          if (error == null) {
            updateState(SERIALIZER.decode(response));
          } else {
            LOGGER.debug("{} - Failed to probe {}", this.localMember.id(), member, error);
            // Verify that the local member term has not changed and request probes from peers.
            SwimMember swimMember = members.get(member.id());
            if (swimMember != null && swimMember.getIncarnationNumber() == member.incarnationNumber()) {
              requestProbes(swimMember.copy());
            }
          }
        }, swimScheduler);
  }
938328
@Indexable(type = IndexableType.REINDEX)
	@Override
	public CPInstance addCPInstance(CPInstance cpInstance) {
		cpInstance.setNew(true);

		return cpInstancePersistence.update(cpInstance);
	}
170214
public static void addSampler(Sampler sampler) {
    synchronized (samplerLock) {
      Sampler[] samplers = additionalSamplers;
      /* create a new list of samplers from the old, adding this sampler */
      if (samplers != null) {
        Sampler[] newSamplers = new Sampler[samplers.length + 1];
        System.arraycopy(samplers, 0, newSamplers, 0, samplers.length);
        newSamplers[samplers.length] = sampler;
        additionalSamplers = newSamplers;
      } else {
        Sampler[] newSamplers = new Sampler[1];
        newSamplers[0] = sampler;
        additionalSamplers = newSamplers;
      }
    }
  }
898185
def run(self):
        
        if self.probes is None:
            self._stop = True
        while True:

            if self._stop:
                break

            self.probes_values = {
                instrument_name:
                    {probe_name: probe_instance.value for probe_name, probe_instance in probe.items()}
                for instrument_name, probe in self.probes.items()
                }

            self.updateProgress.emit(1)

            self.msleep(int(1e3*self.refresh_interval))
315595
def add(self, extension):
        
        index = len(self.extensions)
        self.extensions[index] = extension
        for protocol in extension.protocols:
            self.registry[protocol] = index
119428
public void appendRow(JoinProbe probe, LookupSource lookupSource, long joinPosition)
    {
        // probe side
        appendProbeIndex(probe);

        // build side
        buildPageBuilder.declarePosition();
        lookupSource.appendTo(joinPosition, buildPageBuilder, 0);
    }
646233
async def probe(self):
        

        resp = await self._execute(self._adapter.probe_sync)
        _raise_error(None, 'probe', resp)
991479
synchronized void addProbesByListener(ProbeListener listener, Collection<ProbeImpl> probes) {
        Set<ProbeImpl> listenerProbes = probesByListener.get(listener);
        if (listenerProbes == null) {
            listenerProbes = new HashSet<ProbeImpl>();
            probesByListener.put(listener, listenerProbes);
        }
        listenerProbes.addAll(probes);
    }
436710
public final static void fireProbe(long probeId, Object instance, Object target, Object args) {
        // Load statics onto the stack to avoid a window where they can be cleared
        // between the test for null and the invocation of the method
        Object proxyTarget = fireProbeTarget;
        Method method = fireProbeMethod;
        if (proxyTarget == null || method == null) {
            return;
        }
        try {
            method.invoke(proxyTarget, probeId, instance, target, args);
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
350107
private static synchronized void addTransformer() {
        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.entry(tc, "addTransformer");

        if (registeredTransformer == null && instrumentation != null) {
            registeredTransformer = new LibertyJava8WorkaroundRuntimeTransformer();
            instrumentation.addTransformer(registeredTransformer, false);
        }

        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.exit(tc, "addTransformer");
    }
1089512
def added(self, context):
        """"""
        context.ansi = ANSIFormatter(self._enable)
        context.aprint = context.ansi.aprint
1284238
def addSkip(self, test, reason):
        
        super().addSkip(test, reason)
        self.test_info(test)
        self._call_test_results('addSkip', test, reason)