Unregister remote commands.
966170
private void unregisterRemoteCommands()
   {
      if (rpcService != null)
      {
         rpcService.unregisterCommand(suspend);
         rpcService.unregisterCommand(resume);
         rpcService.unregisterCommand(requestForResponsibleForResuming);
      }
      
   }
282834
public void unregisterAll() {
		for (KvStateInfo kvState : registeredKvStates) {
			registry.unregisterKvState(jobId, jobVertexId, kvState.keyGroupRange, kvState.registrationName, kvState.kvStateId);
		}
	}
69456
def do_uninstall(ctx, verbose, fake):
    """"""
    aliases = cli.list_commands(ctx)
    # Add deprecated aliases
    aliases.extend(['graft', 'harvest', 'sprout', 'resync', 'settings', 'install', 'uninstall'])
    for alias in aliases:
        system_command = 'git config --global --unset-all alias.{0}'.format(alias)
        verbose_echo(system_command, verbose, fake)
        if not fake:
            os.system(system_command)
    if not fake:
        click.echo('\nThe following git aliases are uninstalled:\n')
        output_aliases(aliases)
90809
async def unmount(self):
        """"""
        self._data = await self._handler.unmount(
            system_id=self.node.system_id, id=self.id)
1247756
async def stop(self):
        """"""
        await self._command_task.future_command(['_set_mode', 0, 0])  # Disable advertising
        await self._cleanup_old_connections()

        self._command_task.stop()
        self._stream.stop()
        self._serial_port.close()

        await super(BLED112Server, self).stop()
647555
def unregisterAddon(cls, name):
        
        prop = '_{0}__addons'.format(cls.__name__)
        cmds = getattr(cls, prop, {})
        cmds.pop(name, None)
1292356
def payload_unregister(klass, pid):
    
    cmd = ['payload-unregister']
    for x in [klass, pid]:
        cmd.append(x)
    subprocess.check_call(cmd)
910262
def disown(cmd):
    """"""
    subprocess.Popen(cmd,
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL)
592215
def unregister_service(self, info):
        """"""
        try:
            del(self.services[info.name.lower()])
        except:
            pass
        now = current_time_millis()
        next_time = now
        i = 0
        while i < 3:
            if now < next_time:
                self.wait(next_time - now)
                now = current_time_millis()
                continue
            out = DNSOutgoing(_FLAGS_QR_RESPONSE | _FLAGS_AA)
            out.add_answer_at_time(
                    DNSPointer(info.type,
                        _TYPE_PTR, _CLASS_IN, 0, info.name), 0)
            out.add_answer_at_time(
                    DNSService(info.name,
                        _TYPE_SRV, _CLASS_IN, 0, info.priority,
                        info.weight, info.port, info.name), 0)
            out.add_answer_at_time(
                    DNSText(info.name, _TYPE_TXT, _CLASS_IN, 0, info.text), 0)
            for k in info.address:
                out.add_answer_at_time(
                        DNSAddress(info.server, _TYPE_A, _CLASS_IN, 0, k), 0)
            self.send(out)
            i += 1
            next_time += _UNREGISTER_TIME
1329339
public static function unregister()
    {
        self::$registered = false;
        in_array(vfsStream::SCHEME, stream_get_wrappers()) and
            stream_wrapper_unregister(vfsStream::SCHEME);
    }
965886
def command_repo_remove(self):
        
        if len(self.args) == 2 and self.args[0] == "repo-remove":
            Repo().remove(self.args[1])
        else:
            usage("")
16776
def _uninstall_signal_handlers(self):
        
        signal.signal(signal.SIGINT, signal.SIG_DFL)
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
211682
def _release_command_buffer(self, command_buffer):
        """"""
        if command_buffer.closed:
            return

        self._cb_poll.unregister(command_buffer.host_id)
        self.connection_pool.release(command_buffer.connection)
        command_buffer.connection = None
851868
public synchronized void unregister() {
        if (this.service != null) {
            LOG.info("unregister servlet on mountpoint {} with contextParams {}", getAlias(),
                contextParams);
            this.service.unregister(getAlias());
            this.service = null;
        }
    }
576000
public void unbindCommand(Control control) {
		Command command = (Command) commands.remove(control);
		if (command != null) {
			if (!commands.keySet().contains(command)) {
				commandState.remove(command);
			}
		}
	}
1297842
def disconnect(remote):
    """"""
    # User must be authenticated
    if not current_user.is_authenticated:
        return current_app.login_manager.unauthorized()

    external_method = 'github'
    external_ids = [i.id for i in current_user.external_identifiers
                    if i.method == external_method]
    if external_ids:
        oauth_unlink_external_id(dict(id=external_ids[0],
                                      method=external_method))

    user_id = int(current_user.get_id())
    token = RemoteToken.get(user_id, remote.consumer_key)
    if token:
        extra_data = token.remote_account.extra_data

        # Delete the token that we issued for GitHub to deliver webhooks
        webhook_token_id = extra_data.get('tokens', {}).get('webhook')
        ProviderToken.query.filter_by(id=webhook_token_id).delete()

        # Disable GitHub webhooks from our side
        db_repos = Repository.query.filter_by(user_id=user_id).all()
        # Keep repositories with hooks to pass to the celery task later on
        repos_with_hooks = [(r.github_id, r.hook) for r in db_repos if r.hook]
        for repo in db_repos:
            try:
                Repository.disable(user_id=user_id,
                                   github_id=repo.github_id,
                                   name=repo.name)
            except NoResultFound:
                # If the repository doesn't exist, no action is necessary
                pass
        db.session.commit()

        # Send Celery task for webhooks removal and token revocation
        disconnect_github.delay(token.access_token, repos_with_hooks)
        # Delete the RemoteAccount (along with the associated RemoteToken)
        token.remote_account.delete()

    return redirect(url_for('invenio_oauthclient_settings.index'))
96821
@Override
	public void unregisterIrObs(IREventObserver obs)
	{
		if (obs != null && irObserver == obs)
		{
			irObserver = null;
		}
	}