Disable a probe on a webaccelerator
171427
def probe_disable(cls, resource):
        
        oper = cls.call('hosting.rproxy.probe.disable',
                        cls.usable_id(resource))
        cls.echo('Desactivating probe on %s' % resource)
        cls.display_progress(oper)
        cls.echo('The probe have been desactivated')
        return oper
605660
public synchronized void disableAutomaticReconnection() {
        if (!automaticReconnectEnabled) {
            return;
        }
        XMPPConnection connection = weakRefConnection.get();
        if (connection == null) {
            throw new IllegalStateException("Connection instance no longer available");
        }
        connection.removeConnectionListener(connectionListener);
        automaticReconnectEnabled = false;
    }
500871
def RemoveAccessPoint(self, dev_path, ap_path):
    '''
    '''

    dev_obj = dbusmock.get_object(dev_path)

    aps = dev_obj.Get(WIRELESS_DEVICE_IFACE, 'AccessPoints')
    aps.remove(ap_path)
    dev_obj.Set(WIRELESS_DEVICE_IFACE, 'AccessPoints', aps)

    dev_obj.access_points.remove(ap_path)

    dev_obj.EmitSignal(WIRELESS_DEVICE_IFACE, 'AccessPointRemoved', 'o', [ap_path])

    self.object_manager_emit_removed(ap_path)
    self.RemoveObject(ap_path)
953451
def deactivatePdpContextAccept():
    """"""
    a = TpPd(pd=0x8)
    b = MessageType(mesType=0x47)  # 01000111
    packet = a / b
    return packet
120660
function off(element, type, handler, opt) {
    util.removeEventListener(element, type, handler, opt, true);
  }
1127492
public static function disable()
    {

        if (self::isEnabled()) {
            // stop any timers still on stack (those might be stopped after calculation otherwise)
            $stackCopy = self::$stack;
            while ($timerName = array_pop($stackCopy)) {
                self::stop($timerName);
            }
        }
        self::$_enabled = false;

        self::calculate();
    }
103425
def _disable(self):
        
        if self._enabled:
            self._real_onCannotSend()
            has_cancelled = 0
            for block in self._aio_recv_block_list + self._aio_send_block_list:
                try:
                    self._aio_context.cancel(block)
                except OSError as exc:
                    trace(
                        'cancelling %r raised: %s' % (block, exc),
                    )
                else:
                    has_cancelled += 1
            if has_cancelled:
                noIntr(functools.partial(self._aio_context.getEvents, min_nr=None))
            self._enabled = False
651844
protected void disableStop() {
    EventTarget targ = svgp.getDocument().getRootElement();
    targ.removeEventListener(SVGConstants.SVG_EVENT_MOUSEMOVE, this, false);
    targ.removeEventListener(SVGConstants.SVG_EVENT_MOUSEUP, this, false);
    // FIXME: listen on the background object!
    targ.removeEventListener(SVGConstants.SVG_EVENT_MOUSEOUT, this, false);
  }
1037500
function() {

        // Don't continue if the probe portion was what changed.
        var thisMonitor = JSON.stringify(monitor.toMonitorJSON());
        if (thisMonitor === t.priorMonitor) {
          return;
        }

        // Remove the component listeners
        log.info('render.monitorChange', t.logCtxt);
        component.off('change:css change:viewOptions', applyStyles);
        component.off('change:monitor', onMonitorChange, t);

        // Disconnect, then build a fresh component
        t.connectMonitor(false, function(){
          UI.pageView.removeComponent(t.model);
          UI.pageView.addComponent(t.model);
        });
      }
362538
synchronized void removeInterestedByClass(Class<?> clazz, ProbeListener listener) {
        Set<ProbeListener> listeners = listenersByClass.get(clazz);
        if (listeners != null) {
            listeners.remove(listener);
            if (listeners.isEmpty()) {
                listenersByClass.remove(clazz);
            }
        }
    }
1004197
private void suppressSeleniumJavaUtilLogging() {
        if ( ! seleniumLoggingSuppressed.getAndSet(true) ) {
            try {
                // Log4j logging is annoyingly difficult to turn off, it usually requires a config file but we can also do it with an InputStream
                Properties properties = new Properties();
                properties.setProperty("org.openqa.selenium.remote.ProtocolHandshake.level", "OFF");
                properties.setProperty("org.openqa.selenium.remote.ProtocolHandshake.useParentHandlers", "false");

                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                properties.store(byteArrayOutputStream, "seleniumLoggingProperties");
                byte[] bytes = byteArrayOutputStream.toByteArray();

                ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
                LogManager.getLogManager().readConfiguration(byteArrayInputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
572016
public static void disableURLCaches() {
        BeanDesc bd = BeanDescFactory.getBeanDesc(URLConnection.class);
        LdiFieldUtil.set(bd.getField("defaultUseCaches"), null, Boolean.FALSE);
    }
521285
function(error, probe) {
          if (error) {return callback(error);}
          probeJSON = probe.toJSON();
          probeJSON.probeId = probeJSON.id; delete probeJSON.id;
          monitor.probe = probe;

          // Perform the initial set silently.  This assures the initial
          // probe contents are available on the connect event,
          // but doesn't fire a change event before connect.
          monitor.set(probeJSON, {silent:true});

          // Watch the probe for changes.
          monitor.probeChange = function(){
            monitor.set(probe.changedAttributes());
            log.info('probeChange', {probeId: probeJSON.probeId, changed: probe.changedAttributes()});
          };
          probe.on('change', monitor.probeChange);

          // Call the callback.  This calls the original caller, issues
          // the connect event, then fires the initial change event.
          callback(null);
        }
1064700
public void disableAccessToken()
        throws DbxException
    {
        String host = this.host.getApi();
        String apiPath = "1/disable_access_token";

        doPost(host, apiPath, null, null, new DbxRequestUtil.ResponseHandler</*@Nullable*/Void>() {
            @Override
            public /*@Nullable*/Void handle(HttpRequestor.Response response) throws DbxException
            {
                if (response.getStatusCode() != 200) {
                    String requestId = DbxRequestUtil.getRequestId(response);
                    throw new BadResponseException(requestId, "unexpected response code: " + response.getStatusCode());
                }
                return null;
            }
        });
    }
1312612
function(probeId, callback) {
      var t = this, probeImpl = t.runningProbesById[probeId];
      if (!probeImpl) {return callback('Probe not running');}
      if (--probeImpl.refCount === 0) {

        // Release probe resources & internal references if still no references after a while
        setTimeout(function() {
          if (probeImpl.refCount === 0) {
            try {
              probeImpl.release();
            } catch (e){}
            delete t.runningProbesByKey[probeImpl.probeKey];
            delete t.runningProbesById[probeId];
          }
        }, PROBE_TIMEOUT_MS);
      }
      callback(null, probeImpl);
    }
934561
def deactivateAaPdpContextAccept():
    """"""
    a = TpPd(pd=0x8)
    b = MessageType(mesType=0x54)  # 01010100
    packet = a / b
    return packet
595535
def enable(gandi, resource, backend, port, probe):
    
    result = []
    if backend:
        backends = backend
        for backend in backends:
            if 'port' not in backend:
                if not port:
                    backend['port'] = click.prompt('Please set a port for '
                                                   'backends. If you want to '
                                                   ' different port for '
                                                   'each backend, use `-b '
                                                   'ip:port`', type=int)
                else:
                    backend['port'] = port
            result = gandi.webacc.backend_enable(backend)

    if probe:
        if not resource:
            gandi.echo('You need to indicate the Webaccelerator name')
            return
        result = gandi.webacc.probe_enable(resource)

    return result