Unload specified fault manager module

    module: string
        module to unload

    CLI Example:

    .. code-block:: bash

        salt '*' fmadm.unload software-response
169097
def unload(module):
    '''
    
    '''
    ret = {}
    fmadm = _check_fmadm()
    cmd = '{cmd} unload {module}'.format(
        cmd=fmadm,
        module=module
    )
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    result = {}
    if retcode != 0:
        result['Error'] = res['stderr']
    else:
        result = True

    return result
735358
def load(path):
    '''
    
    '''
    ret = {}
    fmadm = _check_fmadm()
    cmd = '{cmd} load {path}'.format(
        cmd=fmadm,
        path=path
    )
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    result = {}
    if retcode != 0:
        result['Error'] = res['stderr']
    else:
        result = True

    return result
88164
def delete_module(modname, paranoid=None):
    
    from sys import modules
    try:
        thismod = modules[modname]
    except KeyError:
        raise ValueError(modname)
    these_symbols = dir(thismod)
    if paranoid:
        try:
            paranoid[:]  # sequence support
        except:
            raise ValueError('must supply a finite list for paranoid')
        else:
            these_symbols = paranoid[:]
    del modules[modname]
    for mod in modules.values():
        try:
            delattr(mod, modname)
        except AttributeError:
            pass
        if paranoid:
            for symbol in these_symbols:
                if symbol[:2] == '__':  # ignore special symbols
                    continue
                try:
                    delattr(mod, symbol)
                except AttributeError:
                    pass
1282237
def __cleanup_module(self, event):
        
        pid     = event.get_pid()
        process = event.get_process()
        module  = event.get_module()

        # Cleanup thread breakpoints on this module
        for tid in process.iter_thread_ids():
            thread = process.get_thread(tid)

            # Running breakpoints
            if tid in self.__runningBP:
                bplist = list(self.__runningBP[tid])
                for bp in bplist:
                    bp_address = bp.get_address()
                    if process.get_module_at_address(bp_address) == module:
                        self.__cleanup_breakpoint(event, bp)
                        self.__runningBP[tid].remove(bp)

            # Hardware breakpoints
            if tid in self.__hardwareBP:
                bplist = list(self.__hardwareBP[tid])
                for bp in bplist:
                    bp_address = bp.get_address()
                    if process.get_module_at_address(bp_address) == module:
                        self.__cleanup_breakpoint(event, bp)
                        self.__hardwareBP[tid].remove(bp)

        # Cleanup code breakpoints on this module
        for (bp_pid, bp_address) in compat.keys(self.__codeBP):
            if bp_pid == pid:
                if process.get_module_at_address(bp_address) == module:
                    bp = self.__codeBP[ (bp_pid, bp_address) ]
                    self.__cleanup_breakpoint(event, bp)
                    del self.__codeBP[ (bp_pid, bp_address) ]

        # Cleanup page breakpoints on this module
        for (bp_pid, bp_address) in compat.keys(self.__pageBP):
            if bp_pid == pid:
                if process.get_module_at_address(bp_address) == module:
                    bp = self.__pageBP[ (bp_pid, bp_address) ]
                    self.__cleanup_breakpoint(event, bp)
                    del self.__pageBP[ (bp_pid, bp_address) ]
772310
def unpackage(package_):
    '''
    
    '''
    return salt.utils.msgpack.loads(package_, use_list=True,
                                    _msgpack_module=msgpack)
1369325
private void unpack() throws InstallationFailedException {
		System.out.println("Preparing FEDORA_HOME...");

		if (!_installDir.exists() && !_installDir.mkdirs()) {
			throw new InstallationFailedException(
					"Unable to create FEDORA_HOME: "
							+ _installDir.getAbsolutePath());
		}
		if (!_installDir.isDirectory()) {
			throw new InstallationFailedException(_installDir.getAbsolutePath()
					+ " is not a directory");
		}
		try {
			Zip.unzip(_dist.get(Distribution.FEDORA_HOME), _installDir);
			setScriptsExecutable(new File(_installDir, "client"
					+ File.separator + "bin"));

			File serverDir = new File(_installDir, "server");
			if (_clientOnlyInstall) {
				FileUtils.delete(serverDir);
			} else {
				setScriptsExecutable(new File(serverDir, "bin"));
			}
		} catch (IOException e) {
			throw new InstallationFailedException(e.getMessage(), e);
		}
	}
698521
def uninstall(ctx, module_list):
    
    if not module_list:
        raise AnthemError(u"You have to provide a list of "
                          "module's name to uninstall")

    mods = ctx.env['ir.module.module'].search([('name', 'in', module_list)])
    try:
        mods.button_immediate_uninstall()
    except Exception:
        raise AnthemError(u'Cannot s. See the logs')
729345
function(script) {
			script.module.uninstall();
			if (Loader.loading === script) {
				Loader.loading = null;
			}
			script.destroy();
			if (!script.next()) {
				delete this.pending[script.id];
				this.failed[script.id] = script;
			}
			Loader.next();
		}
1149390
def unload_plugin(self, name):
        
        self._logger.debug("Unloading {}.".format(name))

        self._logger.debug("Removing plugin instance.")
        del self._plugins[name]

        self._logger.debug("Unloading module.")
        del self._modules[name]

        self._logger.debug("Unloading manifest...")
        manifest = self.get_manifest(name)
        self._manifests.remove(manifest)

        self._logger.debug("{} unloaded.".format(name))
734368
public void stopModule(EJBModuleMetaDataImpl mmd) {
        try { //210058
            uninstall(mmd, false);
        } catch (Throwable t) { //210058
            FFDCFilter.processException(t, CLASS_NAME + ".stop", "3059", this);
            throw new ContainerEJBException("Failed to stop - caught Throwable", t);
        }
    }
894951
def reset(module, serd=None):
    '''
    
    '''
    ret = {}
    fmadm = _check_fmadm()
    cmd = '{cmd} reset {serd}{module}'.format(
        cmd=fmadm,
        serd='-s {0} '.format(serd) if serd else '',
        module=module
    )
    res = __salt__['cmd.run_all'](cmd)
    retcode = res['retcode']
    result = {}
    if retcode != 0:
        result['Error'] = res['stderr']
    else:
        result = True

    return result
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']
693733
def unregister_module(self, module):
        
        if module not in self._namespaces.values():
            raise NoRegisteredError("Module '{0}' is not registered on loader.".format(module))

        for ns, mod in list(self._namespaces.items()):
            if mod == module:
                self.unregister_namespace(ns)
897740
public function unload()
    {
        if (null === $this->state) {
            throw new NotLoadedException('The type descriptor is not loaded.');
        }

        $this->containingModule = null;
        $this->state = null;
    }
923620
async def unload_by_path(self, path):
        
        p, module = findModule(path, False)
        if module is None:
            raise ModuleLoadException('Cannot find module: ' + repr(path))
        return await self.unloadmodule(module)
990068
def ungrab_server(self, onerror = None):
        """"""
        request.UngrabServer(display = self.display,
                             onerror = onerror)
1018475
public function unload()
    {

        // load the unique application name + the naming directory
        $uniqueName = $this->getUniqueName();
        $namingDirectory = $this->getNamingDirectory();

        // unbind the environment references of the application
        $namingDirectory->unbind(sprintf('php:env/%s/webappPath', $uniqueName));
        $namingDirectory->unbind(sprintf('php:env/%s/tmpDirectory', $uniqueName));
        $namingDirectory->unbind(sprintf('php:env/%s/dataDirectory', $uniqueName));
        $namingDirectory->unbind(sprintf('php:env/%s/cacheDirectory', $uniqueName));
        $namingDirectory->unbind(sprintf('php:env/%s/sessionDirectory', $uniqueName));
        $namingDirectory->unbind(sprintf('php:env/%s', $uniqueName));

        // unbind the global references of the application
        $namingDirectory->unbind(sprintf('php:global/%s/env/ApplicationInterface', $uniqueName));
        $namingDirectory->unbind(sprintf('php:global/%s/env/persistence', $uniqueName));
        $namingDirectory->unbind(sprintf('php:global/%s/env', $uniqueName));
        $namingDirectory->unbind(sprintf('php:global/%s', $uniqueName));
    }