This operation unregisters a portal machine from a portal site. The
        operation can only performed when there are two machines
        participating in a portal site.
163308
def unregisterMachine(self, machineName):
        
        url = self._url + "/machines/unregister"
        params = {
            "f" : "json",
            "machineName" : machineName
        }
        return self._post(url=url,
                          param_dict=params,
                          proxy_url=self._proxy_url,
                          proxy_port=self._proxy_port)
168274
def unregister_action(self, name):
        

        name = self.__normalize_name(name)
        action = self.get_action(name)
        if not action:
            return False

        action.triggered.disconnect(self.__actions_signals_slots.pop(action))

        category = foundations.namespace.get_namespace(name)
        name = foundations.namespace.remove_namespace(name)
        self.remove_from_category(category, name)
        return True
590406
public synchronized void unregister() throws Exception {
        if (mbeanName == null) {
            throw new Exception("Agent not registered");
        }
        logger.info("Unregistering JMX agent " + mbeanName);
        ManagementFactory.getPlatformMBeanServer().unregisterMBean(mbeanName);
        logger.info("JMX agent " + mbeanName + " unregistered");
    }
84375
private void unregisterJobFromHighAvailability() {
		try {
			runningJobsRegistry.setJobFinished(jobGraph.getJobID());
		}
		catch (Throwable t) {
			log.error("Could not un-register from high-availability services job {} ({})." +
					"Other JobManager's may attempt to recover it and re-execute it.",
					jobGraph.getName(), jobGraph.getJobID(), t);
		}
	}
517900
void unregisterJob(final ExecutionGraph eg) {

		final Iterator<ExecutionVertex> it = new ExecutionGraphIterator(eg, true);
		while (it.hasNext()) {
			this.splitMap.remove(it.next().getID());
		}
	}
275083
def remove_invoices(portal):
    
    logger.info("Unlink Invoices")

    invoices = portal.get("invoices")
    if invoices is None:
        return

    for batch in invoices.objectValues():
        for invoice in batch.objectValues():
            invoice_id = invoice.getId()
            client = invoice.getClient()
            if not client:
                # invoice w/o a client -> remove
                batch.manage_delObjects(invoice_id)
                continue

            if invoice_id in client.objectIds():
                continue

            # move invoices inside the client
            cp = batch.manage_cutObjects(invoice_id)
            client.manage_pasteObjects(cp)

    # delete the invoices folder
    portal.manage_delObjects(invoices.getId())
1067157
def unregister(self, model_or_iterable):
        
        if isinstance(model_or_iterable, ModelBase):
            model_or_iterable = [model_or_iterable]
        for model in model_or_iterable:
            # Check if the model is actually registered (``get_options_for_model``
            # throws an exception if it's not).
            self.get_options_for_model(model)
            # Invalidate all submodels options and forget about
            # the model itself.
            for desc, desc_opts in list(self._registry.items()):
                if not issubclass(desc, model):
                    continue
                if model != desc and desc_opts.registered:
                    # Allowing to unregister a base would necessitate
                    # repatching all submodels.
                    raise DescendantRegistered(
                        'You need to unregister descendant "%s" before'
                        ' unregistering its base "%s"' %
                        (desc.__name__, model.__name__))
                del self._registry[desc]
832563
private function processUnregister(Session $session, UnregisterMessage $msg)
    {
        $registration = $this->getRegistrationById($msg->getRegistrationId());

        if ($registration && $this->procedures[$registration->getProcedureName()]) {
            $procedure = $this->procedures[$registration->getProcedureName()];
            if ($procedure) {
                if ($procedure->processUnregister($session, $msg)) {
                    // Unregistration was successful - remove from this sessions
                    // list of registrations
                    if ($this->registrationsBySession->contains($session) &&
                        in_array($procedure, $this->registrationsBySession[$session], true)
                    ) {
                        $registrationsInSession = $this->registrationsBySession[$session];
                        array_splice($registrationsInSession, array_search($procedure, $registrationsInSession, true), 1);
                    }
                }
            }

            return;
        }

        // apparently we didn't find anything to unregister
        $session->sendMessage(ErrorMessage::createErrorMessageFromMessage($msg, 'wamp.error.no_such_procedure'));
    }
515556
def unregister(self, fd):
        
        if fd in self.__fd_set:
            raise ValueError(
                'This fd is a special USB event fd, it must stay registered.'
            )
        self.__poller.unregister(fd)
354788
def remove_log_action(portal):
    
    logger.info("Removing Log Tab ...")
    portal_types = api.get_tool("portal_types")
    for name in portal_types.listContentTypes():
        ti = portal_types[name]
        actions = map(lambda action: action.id, ti._actions)
        for index, action in enumerate(actions):
            if action == "log":
                logger.info("Removing Log Action for {}".format(name))
                ti.deleteActions([index])
                break
    logger.info("Removing Log Tab [DONE]")
143741
def unregisterall(self, runnable):
        '''
        
        '''
        if runnable in self.registerIndex:
            for m in self.registerIndex[runnable]:
                self.matchtree.remove(m, runnable)
                if m.indices[0] == PollEvent._classname0 and len(m.indices) >= 2:
                    self.polling.onmatch(m.indices[1], None if len(m.indices) <= 2 else m.indices[2], False)
            del self.registerIndex[runnable]
            self.daemons.discard(runnable)
1024862
def handle_unregistration(config, pconn):
    
    if config.legacy_upload:
        return _legacy_handle_unregistration(config, pconn)
    unreg = pconn.unregister()
    if unreg:
        # only set if unreg was successful
        write_unregistered_file()
        get_scheduler(config).remove_scheduling()
    return unreg
465769
def _legacy_handle_unregistration(config, pconn):
    
    check = get_registration_status(config, pconn)

    for m in check['messages']:
        logger.debug(m)

    if check['unreachable']:
        # Run connection test and exit
        return None

    if check['status']:
        unreg = pconn.unregister()
    else:
        unreg = True
        logger.info('This system is already unregistered.')
    if unreg:
        # only set if unreg was successful
        write_unregistered_file()
        get_scheduler(config).remove_scheduling()
    return unreg
1368340
public void discardOperation(final PathAddress address, ModelVersion version, final String operationName) {
        registerTransformer(address.iterator(), version, operationName, OperationTransformerRegistry.DISCARD);
    }
683437
def unregisterPolling(self, fd, daemon = False):
        '''
        
        '''
        self.polling.unregister(fd, daemon)
174778
def unregister(name, delete=False):
    '''
    
    '''
    nodes = list_nodes_min()
    if name not in nodes:
        raise CommandExecutionError(
            'The specified VM ({0}) is not registered.'.format(name)
        )

    cmd = '{0} unregistervm {1}'.format(vboxcmd(), name)
    if delete is True:
        cmd += ' --delete'
    ret = salt.modules.cmdmod.run_all(cmd)
    if ret['retcode'] == 0:
        return True
    return ret['stderr']
46424
def system_unregister_worker # :nodoc
      self.class.with_global_lock do
        workers = self.class.system_registered_workers
        workers.delete(self.id)
        self.class.store_global_property(WORKERS_KEY, workers.join(','))
      end
    end