Kills the given component

        :param name: Name of the component to kill
        :raise ValueError: Invalid component name
778716
def kill(self, name):
        # type: (str) -> None
        
        if not name:
            raise ValueError("Name can't be None or empty")

        with self.__instances_lock:
            try:
                # Running instance
                stored_instance = self.__instances.pop(name)

                # Store the reference to the factory context
                factory_context = stored_instance.context.factory_context

                # Kill it
                stored_instance.kill()

                # Update the singleton state flag
                factory_context.is_singleton_active = False
            except KeyError:
                # Queued instance
                try:
                    # Extract the component context
                    context, _ = self.__waiting_handlers.pop(name)

                    # Update the singleton state flag
                    context.factory_context.is_singleton_active = False
                except KeyError:
                    raise ValueError(
                        "Unknown component instance '{0}'".format(name)
                    )
126910
def kill
      return false unless hostname == Socket.gethostname
      begin
        Process.kill('KILL', pid)
        self.state = "killed"
        self.save!
      rescue Errno::ESRCH
        puts "pid #{pid} does not exist!"
        mark_dead
      end
    end
1024179
def delete(self, name):
    '''
    
    '''
    conn = self._client.connect()
    conn.execute( self._table.delete().where(self._table.c.name==name) )
1003811
def disconnect(self, name=None):
        
        if name is None:
            self._channels = {}
        else:
            self._channels.pop(name)
        if self._ctxt is not None:
            self._ctxt.disconnect(name)
1170760
def delete(user_name, repo_name, component_id, params={})
      _update_user_repo_params(user_name, repo_name)
      _validate_user_repo_params(user, repo) unless user? && repo?

      _validate_presence_of component_id
      normalize! params

      delete_request("/1.0/repositories/#{user}/#{repo.downcase}/issues/components/#{component_id}", params)
    end
30356
def stop(name):
    '''
    
    '''
    if not exists(name):
        raise ContainerNotExists("The container (%s) does not exist!" % name)
    cmd = ['lxc-stop', '-n', name]
    subprocess.check_call(cmd)
1303206
def kill(self):
        

        logger.info("Killing external module (pid=%d) for module %s...",
                    self.process.pid, self.name)
        if os.name == 'nt':
            self.process.terminate()
        else:
            self.process.terminate()
            # Wait for 10 seconds before killing the process abruptly
            self.process.join(timeout=KILL_TIME)
            # You do not let me another choice guy...
            if self.process.is_alive():
                logger.warning("%s is still living %d seconds after a normal kill, "
                               "I help it to die", self.name, KILL_TIME)
                os.kill(self.process.pid, signal.SIGKILL)
                self.process.join(1)
                if self.process.is_alive():
                    logger.error("%s still living after brutal kill, I leave it.", self.name)
            logger.info("External module killed")
1189942
def kill(self, id, signal=signal.SIGTERM):
        
        args = {
            'id': id,
            'signal': int(signal),
        }
        self._kill_chk.check(args)
        return self._client.json('job.kill', args)
905714
protected void stop(MoleculerComponent component) {
		if (component == null) {
			return;
		}
		try {
			component.stopped();
			logger.info(nameOf(component, true) + " stopped.");
		} catch (Exception cause) {
			logger.warn("Unable to stop component!", cause);
		}
	}
638266
def kill_pane(self, pane):
        
        assert isinstance(pane, Pane)

        # Send kill signal.
        if not pane.process.is_terminated:
            pane.process.kill()

        # Remove from layout.
        self.arrangement.remove_pane(pane)
1208610
def destroy(name, call=None):
    '''
    
    '''
    if call == 'function':
        raise SaltCloudSystemExit(
            'The destroy action must be called with -d, --destroy, '
            '-a or --action.'
        )

    __utils__['cloud.fire_event'](
        'event',
        'destroying instance',
        'salt/cloud/{0}/destroying'.format(name),
        args={'name': name},
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    response = _query('grid', 'server/delete', args={'name': name})

    __utils__['cloud.fire_event'](
        'event',
        'destroyed instance',
        'salt/cloud/{0}/destroyed'.format(name),
        args={'name': name},
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    if __opts__.get('update_cachedir', False) is True:
        __utils__['cloud.delete_minion_cachedir'](name, __active_provider_name__.split(':')[0], __opts__)

    return response
1244650
def addon_destroy(self, name):
        """"""
        self._run(
            [
                "heroku",
                "addons:destroy",
                name,
                "--app",
                self.name,
                "--confirm",
                self.name,
            ]
        )
386487
def reset_component(self, component):
		
		if isinstance(component, str) is True:
			component = WURI.Component(component)
		self.__components[component] = None
1043019
def delete(self, name):
        
        try:
            super(StaticCompilerFileStorage, self).delete(name)
        except OSError, e:
            if e.errno != errno.ENOENT:
                raise
850373
def kill(self):
        
        if os.path.isfile(self.filename):
            os.remove(self.filename)
        return
575230
def replace_component(self, name, callable, provides=None, depends=None):
        """"""
        self.remove_component(name)
        self.add_component(name, callable, provides, depends)
371561
def kill_window(pymux, variables):
    "  "
    for pane in pymux.arrangement.get_active_window().panes:
        pymux.kill_pane(pane)