Prevent the process from generating a core dump.
427983
def _prevent_core_dump(cls):
        """"""
        try:
            # Try to get the current limit
            resource.getrlimit(resource.RLIMIT_CORE)
        except ValueError:
            # System doesn't support the RLIMIT_CORE resource limit
            return
        else:
            # Set the soft and hard limits for core dump size to zero
            resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
1017809
def clean():
        
        shutil.rmtree(BUILD_PATH, ignore_errors=True)
        shutil.rmtree(os.path.join(SOURCE_PATH, 'reference', 'api'),
                      ignore_errors=True)
1277658
def pop_source(self):
        ""
        self.instream.close()
        (self.infile, self.instream, self.lineno) = self.filestack.popleft()
        self.state = ' '
841186
def stop(self):
        """"""
        self._end.value = True
        if self.background_process:
            try:
                self.background_process.terminate()
            except Exception:
                pass
        for task_id, values in self.current_tasks.items():
            try:
                values['proc'].terminate()
            except Exception:
                pass
1296799
public void excludeFrom(int start) {
        Assert.check(currentState != BitsState.UNKNOWN);
        Bits temp = new Bits();
        temp.sizeTo(bits.length);
        temp.inclRange(0, start);
        internalAndSet(temp);
        currentState = BitsState.NORMAL;
    }
899225
def prune_dump(sessionid):
    '''
    

    '''
    out = __salt__['cmd.run_all']("xfsinvutil -s {0} -F".format(sessionid))
    _verify_run(out)

    data = _xfs_prune_output(out['stdout'], sessionid)
    if data:
        return data

    raise CommandExecutionError("Session UUID \"{0}\" was not found.".format(sessionid))
458235
def unset_env():
        """"""
        os.environ.pop('COV_CORE_SOURCE', None)
        os.environ.pop('COV_CORE_DATA_FILE', None)
        os.environ.pop('COV_CORE_CONFIG', None)
956825
def cleanup(self):
        """"""
        try:
            os.remove(self.pid_file)
        except OSError as exc:
            logger.critical("Could not remove pid_file: %s", exc)

        # Save the final status of the flow.
        self.flow.pickle_dump()
973478
def dump(cls):
        """"""
        with cls.lock:
            if not cls.instances: return
            atexit.unregister(cls.dump)

            for self in cls.instances.values():
                self.fh.close()
845484
def _Close(self):
    """"""
    self._cpio_archive_file_entry = None
    self._cpio_archive_file = None

    self._file_system.Close()
    self._file_system = None
1130841
def stop(cls):
        """"""
        if any(cls.streams):
            sys.stdout = cls.streams.pop(-1)
        else:
            sys.stdout = sys.__stdout__
412827
def dump(cls):
        """"""
        with cls.lock:
            if not cls.instances: return
            atexit.unregister(cls.dump)

            cls._pre_dump()

            for self in cls.instances.values():
                self._dump()

            cls._post_dump()
414166
private void shutDownSolrContainer() {

        if (m_coreContainer != null) {
            for (SolrCore core : m_coreContainer.getCores()) {
                // do not unload spellcheck core because otherwise the core.properties file is removed
                // even when calling m_coreContainer.unload(core.getName(), false, false, false);
                if (!core.getName().equals(CmsSolrSpellchecker.SPELLCHECKER_INDEX_CORE)) {
                    m_coreContainer.unload(core.getName(), false, false, true);
                }
            }
            m_coreContainer.shutdown();
            if (CmsLog.INIT.isInfoEnabled()) {
                CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_SOLR_SHUTDOWN_SUCCESS_0));
            }
            m_coreContainer = null;
        }
    }
1249237
def cancel(self):
        """"""
        if self.__process.is_alive():
            self.__process.terminate()

        _raise_exception(self.__timeout_exception, self.__exception_message)
256677
def disable(self):
        """"""
        core_napps_manager = CoreNAppsManager(base_path=self._enabled)
        core_napps_manager.disable(self.user, self.napp)
195043
public void cancel() {
        try {
            // FileOutputStream is also closed cascadingly
            if (outStream != null) {
                outStream.close();
                outStream = null;
            }
            // Clear encryptor:
            encryptor = null;
        } catch (IOException e) {
            Log.w(Log.TAG_BLOB_STORE, "Exception closing buffered output stream", e);
        }
        tempFile.delete();
    }
980745
def stop(self):
        
        # unsetup_fuse()
        self.fuse_process.teardown()
        for uuid in self.processes:
            self.processes[uuid].terminate()