Use this API to disable lbmonitor.
433471
public static base_response disable(nitro_service client, lbmonitor resource) throws Exception {
		lbmonitor disableresource = new lbmonitor();
		disableresource.servicename = resource.servicename;
		disableresource.servicegroupname = resource.servicegroupname;
		disableresource.monitorname = resource.monitorname;
		return disableresource.perform_operation(client,"disable");
	}
51479
def unmonitor(self, target):
        
        if 'monitor-notify' in self._capabilities and self.is_monitoring(target):
            yield from self.rawmsg('MONITOR', '-', target)
            self._monitoring.remove(target)
            return True
        else:
            return False
695473
def stop(self):
        
        self.shutdown.set()

        for monitor in self.observers:
            monitor.stop()

        self.wind_down()

        for monitor in self.observers:
            monitor.join()

        for thread in self.thread_pool.values():
            thread.join()

        self.work_pool.shutdown()
73338
def stop_sync(self):
        """"""

        # Disconnect connected device
        if self.connected:
            self.disconnect_sync(self._connection_handle)

        # Disable advertising
        self.set_advertising(False)
        # Stop the baBLE interface
        self.bable.stop()

        self.actions.queue.clear()
1330260
public void stopLeaseMonitor() throws InterruptedException {
    if (lmmonitor != null) {
      lmmonitor.stop();
      InjectionHandler
          .processEvent(InjectionEvent.FSNAMESYSTEM_STOP_LEASEMANAGER);
    }
    if (lmthread != null) {
      // interrupt the lease monitor thread. We need to make sure the
      // interruption does not happen during
      // LeaseManager.checkLeases(), which would possibly interfere with writing
      // to edit log, and hence with clean shutdown. It essential during
      // failover, as it could exclude edit log streams!!!
      writeLock();
      try {
        lmthread.interrupt();
      } finally {
        writeUnlock();
      }
      lmthread.join();
    }
  }
1330703
def disable(self, idx):
        """"""
        if idx not in self.uid.keys():
            self.log('Element index {0} does not exist.'.format(idx))
            return
        self.u[self.uid[idx]] = 0
27925
public void stopWatching() {
		if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("Stopping resource watching");
		}

		this.stopWatching.set(true);
		jawrEvtProcessor.stopProcessing();
		jawrEvtProcessor.interrupt();
	}
272688
protected void unsetMonitor(ServiceReference<FileMonitor> monitorRef) {
        MonitorHolder holder = fileMonitors.remove(monitorRef);

        if (holder != null) {
            holder.destroy();
        }
    }
933527
def cancel_lb(self, loadbal_id):
        

        lb_billing = self.lb_svc.getBillingItem(id=loadbal_id)
        billing_id = lb_billing['id']
        billing_item = self.client['Billing_Item']
        return billing_item.cancelService(id=billing_id)
738477
private void setMonitorAttribute(Long monitorInterval) {
        if (MONITOR_OFF.equals(monitorInterval)) {
            this.fileMonitorProps.remove(FileMonitor.MONITOR_INTERVAL);
        } else {
            this.fileMonitorProps.put(FileMonitor.MONITOR_INTERVAL, monitorInterval);
        }
    }
381969
def disable(self):
        """"""
        with self._lock:
            if self._event_listener_thread is not None:
                self._event_listener_thread.stop()
                self._event_listener_thread = None
256548
@Override
	@Transactional
	public synchronized void enableMonitoring() {
		requireNotDisposed();
		_logger.info("Globally enabling all system monitoring.");
		_setServiceEnabled(true);
		_checkAlertExistence(true);
		_logger.info("All system monitoring globally enabled.");
	}
1283238
def disable(cls, args):
        """"""
        mgr = NAppsManager()

        if args['all']:
            napps = mgr.get_enabled()
        else:
            napps = args['<napp>']

        for napp in napps:
            mgr.set_napp(*napp)
            LOG.info('NApp %s:', mgr.napp_id)
            cls.disable_napp(mgr)
980290
private void cancelScan() {
        if (cleanTask != null) {
            cleanTask.cancel(true);
            cleanTask = null;
        }
        client.close();
    }
547995
public void stopMonitor() {
        logger.info("Stopping Directory Update Monitor");
        try {
            monitor.stop();
        } catch (IllegalStateException e) {
            logger.info("File alteration monitor is already stopped: " + e.getMessage());
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }
1280886
def disable(self):
        """"""
        self.post("disable")
        if self.service.restart_required:
            self.service.restart(120)
        return self
178324
protected function disarmTimeoutMonitor()
    {
        if (isset($this->timeout)) {
            $this->timeout->cancel();
            $this->timeout = null;
        }
    }