Stop all the actions
187379
def _stop_actions(self):
        
        Global.LOGGER.info("stopping actions")

        list(map(lambda x: x.stop(), self.actions))

        Global.LOGGER.info("actions stopped")
984200
def _stop(self):
        
        self._pause()
        self._cmds_q.put(("stop",))
        try:
            self._recorder.terminate()
        except Exception:
            pass
        self._recording = False
858198
def stop_all_components
      logger.info "Stopping all controller components"
      @active_components.each do |component|
        begin
          component.stop!
        rescue Adhearsion::Rayo::Component::InvalidActionError
        end
      end
    end
595628
def stop():
  '''  '''

  output, err = cli_syncthing_adapter.sys(exit=True)
  click.echo("%s" % output, err=err)
1283794
def stop(*args):
    """"""
    if _debug: stop._debug("stop")
    global running, taskManager

    if args:
        sys.stderr.write("===== TERM Signal, %s\n" % time.strftime("%d-%b-%Y %H:%M:%S"))
        sys.stderr.flush()

    running = False

    # trigger the task manager event
    if taskManager and taskManager.trigger:
        if _debug: stop._debug("    - trigger")
        taskManager.trigger.set()
1045127
def stop(self):
        """"""
        for child_name, child in dict.items(self.children):
            # Catch child exceptions when stopping so we make sure to stop all children
            # that want to listen.
            try:
                child.stop()
            except Exception:
                self._logger.exception('Exception stopping child {!r}'
                                       .format(child_name))
449540
def stop(ctx, rm=False):
    ''''''
    with ctx.cd(ROOT):
        compose(ctx, 'stop')
        if rm:
            compose(ctx, 'rm --force')
259599
def stop(self):
        '''  '''
        Global.LOGGER.debug(f"action {self.name} stopped")
        self.is_running = False
        self.on_stop()
1089258
def stop(self):
        """"""

        for tile in self._tiles.values():
            tile.signal_stop()

        for tile in self._tiles.values():
            tile.wait_stopped()

        super(TileBasedVirtualDevice, self).stop()
565062
def stop_actions(self):
        
        self._stop_actions, value = self.get_attr_set(self._stop_actions, 'stop_actions')
        return value
341943
def stop(self):
        
        if self.socket is not None:
            self.socket.close()
            self.socket = None
            self.data = None
1180217
def stop(self):
        
        should_sleep = self._is_running
        super(Sensor, self).stop()
        if should_sleep:
            # Make sure everything has enough time to exit
            time.sleep(max(self._select_timeout, self._retransmit_timeout) + 1)
        if self._listen_socket is not None:
            self._shutdown_listen_socket()
559089
def stop(self) -> None:
        """"""
        if self._stop and not self._posted_kork:
            self._stop()
            self._stop = None
363611
public function stop()
    {
        if ($this->isBusy()) {
            posix_kill($this->workPid, \SIGKILL);
            $this->getWorkState(true);
        }
    }
1319763
public void stop() {
        this.eventManager.fireEvent(EventType.SERVER_STOPPING, new Event().attribute("blade", this));
        this.server.stopAndWait();
        this.eventManager.fireEvent(EventType.SERVER_STOPPED, new Event().attribute("blade", this));
    }
599075
async def stop(self, force: bool=False) -> None:
        ''''''

        Log.debug('stopping task %s', self.name)
        self.running = False

        if force:
            self.task.cancel()
991811
def stop(self, api=None):
        
        api = api or self._API

        return api.post(
            url=self._URL['actions'].format(
                id=self.id, action=AutomationRunActions.STOP
            )
        ).content