Unregister SDC from MDM/SIO Cluster
        :param sdcObj: ScaleIO SDC object
        :return: POST request response
        :rtype: Requests POST response object
184703
def unregisterSdc(self, sdcObj):
        
        # TODO:
        # Add code that unmap volume if mapped
        self.conn.connection._check_login()
        response = self.conn.connection._do_post("{}/{}{}/{}".format(self.conn.connection._api_url, "instances/Sdc::", sdcObj.id, 'action/removeSdc'))    
        return response
638404
def unregisterAPI(self, name):
        
        if name.startswith('public/'):
            target = 'public'
            name = name[len('public/'):]
        else:
            target = self.servicename
            name = name
        removes = [m for m in self.handler.handlers.keys() if m.target == target and m.name == name]
        for m in removes:
            self.handler.unregisterHandler(m)
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
1241757
public static void unregister(MBeanServer server, String object_name) throws Exception {
        Set<ObjectName> mbeans = server.queryNames(new ObjectName(object_name), null);
        if(mbeans != null)
            for (ObjectName name: mbeans)
                server.unregisterMBean(name);
    }
1308374
def unsubscribe(self):
        
        # Trying to unsubscribe if already unsubscribed, or not yet
        # subscribed, fails silently
        if self._has_been_unsubscribed or not self.is_subscribed:
            return

        # Cancel any auto renew
        self._auto_renew_thread_flag.set()
        # Send an unsubscribe request like this:
        # UNSUBSCRIBE publisher path HTTP/1.1
        # HOST: publisher host:publisher port
        # SID: uuid:subscription UUID
        headers = {
            'SID': self.sid
        }
        response = None
        try:
            response = requests.request(
                'UNSUBSCRIBE',
                self.service.base_url + self.service.event_subscription_url,
                headers=headers,
                timeout=3)
        except requests.exceptions.RequestException:
            pass

        self.is_subscribed = False
        self._timestamp = None
        log.info(
            "Unsubscribed from %s, sid: %s",
            self.service.base_url + self.service.event_subscription_url,
            self.sid)
        # remove queue from event queues and sid to service mappings

        with _subscriptions_lock:
            try:
                del _subscriptions[self.sid]
            except KeyError:
                pass
        self._has_been_unsubscribed = True

        # Ignore "412 Client Error: Precondition Failed for url:"
        # from rebooted speakers.
        if response and response.status_code != 412:
            response.raise_for_status()
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)
1052916
protected final void unregisterProducer( AbstractMessageProducer producerToRemove )
    {
        if (producersMap.remove(producerToRemove.getId()) == null)
            log.warn("Unknown producer : "+producerToRemove);
    }
1061680
def unregister_all(self):
        
        aliases = list(self._service_objects.keys())
        for alias in aliases:
            self.unregister(alias)
263947
def _unregister_service(self):
        
        if self._registration is not None:
            # Ignore error
            try:
                self._registration.unregister()
            except BundleException as ex:
                # Only log the error at this level
                logger = logging.getLogger(
                    "-".join((self._ipopo_instance.name, "ServiceRegistration"))
                )
                logger.error("Error unregistering a service: %s", ex)

            # Notify the component (even in case of error)
            self._ipopo_instance.safe_callback(
                ipopo_constants.IPOPO_CALLBACK_POST_UNREGISTRATION,
                self._svc_reference,
            )

            self._registration = None
            self._svc_reference = None
311092
def remove(self):
        
        LOGGER.debug("Cluster.remove - " + self.name)
        if self.id is None:
            return None
        else:
            params = SessionService.complete_transactional_req({
                'name': self.name
            })

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                params['OPERATION'] = 'deleteCluster'
                args = {'properties': params}
            else:
                args = {'http_operation': 'GET', 'operation_path': 'delete', 'parameters': params}

            response = ClusterService.requester.call(args)

            if MappingService.driver_type != DriverFactory.DRIVER_REST:
                response = response.get()

            if response.rc != 0:
                LOGGER.warning(
                    'Cluster.remove - Problem while deleting cluster ' + self.name +
                    '. Reason: ' + str(response.response_content) + ' - ' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
                if response.rc == 500 and ArianeMappingOverloadError.ERROR_MSG in response.error_message:
                    raise ArianeMappingOverloadError("Cluster.remove", ArianeMappingOverloadError.ERROR_MSG)
                # traceback.print_stack()
                return self
            else:
                return None
780394
private void unregister( final Bundle bundle )
    {
    	if (bundle == null)
    		return; // no need to go any further, system probably stopped. 
        LOG.debug( "Releasing bundle [" + bundle.getSymbolicName() + "]" );
        final List<T> resources = m_mappings.get( bundle );
        if( resources != null && resources.size() > 0 )
        {
            LOG.debug( "Un-registering " + resources );
            for( BundleObserver<T> observer : m_observers )
            {
                try
                {
                    observer.removingEntries( bundle, Collections.unmodifiableList( resources ) );
                }
                catch( Throwable ignore )
                {
                    LOG.error( "Ignored exception during un-register", ignore );
                }
            }
        }
        m_mappings.remove( bundle );
    }
92983
def unregister(name, server_url):
    '''
    
    '''

    try:
        client, key = _get_session(server_url)
    except Exception as exc:
        err_msg = 'Exception raised when connecting to spacewalk server ({0}): {1}'.format(server_url, exc)
        log.error(err_msg)
        return {name: err_msg}

    systems_list = client.system.getId(key, name)

    if systems_list:
        for system in systems_list:
            out = client.system.deleteSystem(key, system['id'])
            if out == 1:
                return {name: 'Successfully unregistered from {0}'.format(server_url)}
            else:
                return {name: 'Failed to unregister from {0}'.format(server_url)}
    else:
        return {name: 'System does not exist in spacewalk server ({0})'.format(server_url)}
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)
560929
def removeMapIdentity(self, subject, vendorSpecific=None):
        
        response = self.removeMapIdentityResponse(subject, vendorSpecific)
        return self._read_boolean_response(response)
1178022
public void unregisterServiceInstance(String serviceName, String instanceId){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UnregisterServiceInstance);

        UnregisterServiceInstanceProtocol p = new UnregisterServiceInstanceProtocol(serviceName, instanceId);
        connection.submitRequest(header, p, null);
    }
1225958
private static void unregister(ObjectName objectName) {
    MBeanServer server = ManagementFactory.getPlatformMBeanServer();
    try {
      for (ObjectName name : server.queryNames(objectName, null)) {
        server.unregisterMBean(name);
      }
    } catch (MBeanRegistrationException | InstanceNotFoundException e) {
      throw new CacheException("Error unregistering " + objectName, e);
    }
  }
1088736
private void unregisterJmxExpose() {
		if (jmxNames.isEmpty()) {
			return;
		}
		try {
			final MBeanServer platformMBeanServer = MBeans.getPlatformMBeanServer();
			for (final ObjectName name : jmxNames) {
				platformMBeanServer.unregisterMBean(name);
			}
		} catch (final JMException e) {
			LOG.warn("failed to unregister JMX beans", e);
		}
	}