Remove a runner.

<pre><code>GitLab Endpoint: DELETE /runners/:id</code></pre>

@param runnerId The ID of a runner
@throws GitLabApiException if any exception occurs
173936
public void removeRunner(Integer runnerId) throws GitLabApiException {

        if (runnerId == null) {
            throw new RuntimeException("runnerId cannot be null");
        }

        delete(Response.Status.NO_CONTENT, null, "runners", runnerId);
    }
144981
public GitlabSystemHook deleteSystemHook(Integer hookId) throws IOException {
        String tailUrl = GitlabSystemHook.URL + "/" + hookId;
        return retrieve().method(DELETE).to(tailUrl, GitlabSystemHook.class);
    }
283495
public GitlabRunner getRunnerDetail(int id) throws IOException {
        String tailUrl = String.format("%s/%d", GitlabRunner.URL, id);
        return retrieve().to(tailUrl, GitlabRunner.class);
    }
12231
public synchronized ID removeOnline(final USER user)
	{
		final ID sessionId = usersOnline.remove(user);
		if (sessionId != null)
		{
			sessionIdToUser.remove(sessionId);
		}
		return sessionId;
	}
785274
public void remove(Id id) {
        readCache.remove(new CacheKey(id));
        writeCache.remove(id);
    }
880006
def delete(self, id):
        """"""
        run = self.backend_store.get_run(id)
        if not run:
            return abort(http_client.NOT_FOUND,
                         message="Run {} doesn't exist".format(id))
        if not self.manager.delete_run(run):
            return abort(http_client.BAD_REQUEST,
                         message="Failed to find the task queue "
                                 "manager of run {}.".format(id))
        return '', http_client.NO_CONTENT
584091
@Route(method = HttpMethod.DELETE, uri = "/{id}")
    public Result uninstallBundle(@Parameter("id") long id) {
        final Bundle bundle = context.getBundle(id);
        if (bundle == null) {
            return notFound("Bundle " + id + " not found");
        } else {
            return async(new Callable<Result>() {
                @Override
                public Result call() throws Exception {
                    try {
                        logger().info("Uninstalling bundle {}", bundle.getSymbolicName());
                        bundle.uninstall();
                        return ok();
                    } catch (BundleException e) {
                        logger().error("Cannot uninstall bundle {}", bundle.getSymbolicName(), e);
                        return badRequest(e);
                    }
                }
            });
        }
    }
73636
public void deleteNote(Serializable projectId, Integer issueId, GitlabNote noteToDelete) throws IOException {
        String tailUrl = GitlabProject.URL + "/" + sanitizeProjectId(projectId)
                + GitlabIssue.URL + "/" + issueId + GitlabNote.URL
                + "/" + noteToDelete.getId();
        retrieve().method(DELETE).to(tailUrl, GitlabNote.class);
    }
307497
public void deleteGroupMember(GitlabGroup group, GitlabUser user) throws IOException {
        deleteGroupMember(group.getId(), user.getId());
    }
427460
public GitlabJob eraseJob(Integer projectId, Integer jobId) throws IOException {
        String tailUrl = GitlabProject.URL + "/" + sanitizeProjectId(projectId) + GitlabJob.URL + "/" + sanitizeId(jobId, "JobID") + "/erase";
        return dispatch().to(tailUrl, GitlabJob.class);
    }
444169
public void remove(Featurable featurable, Integer id)
    {
        for (final Class<?> type : featurable.getClass().getInterfaces())
        {
            remove(type, featurable);
        }

        for (final Class<? extends Feature> feature : featurable.getFeaturesType())
        {
            final Feature object = featurable.getFeature(feature);
            remove(feature, object);
            for (final Class<?> other : UtilReflection.getInterfaces(feature, Feature.class))
            {
                remove(other, object);
            }

        }
        remove(featurable.getClass(), featurable);
        removeSuperClass(featurable, featurable.getClass());

        featurables.remove(id);
    }
1018720
def remove(cls, id):
        

        api = Client.instance().api
        api.index(id).delete()
291521
public void delete(final String referenceId) {
        final CriteriaBuilder builder = getSession().getCriteriaBuilder();
        final CriteriaDelete<PrintJobStatusExtImpl> delete =
                builder.createCriteriaDelete(PrintJobStatusExtImpl.class);
        final Root<PrintJobStatusExtImpl> root = delete.from(PrintJobStatusExtImpl.class);
        delete.where(builder.equal(root.get("referenceId"), referenceId));
        getSession().createQuery(delete).executeUpdate();
    }
703941
def delete(self, run_id):
        
        self.generic_dao.delete_record(
            self.metrics_collection_name,
            {"run_id": self._parse_run_id(run_id)})
406801
public synchronized USER remove(final ID sessionId)
	{
		final USER user = getUser(sessionId);
		if (user != null)
		{
			usersOnline.remove(user);
		}
		sessionIdToUser.remove(sessionId);
		return user;
	}
1318810
public void deleteService(String id, boolean force) {
        try {
            if (id == null || id.isEmpty()) {
                id = selectRunningService();
            }
            final String idFinal = id;
            int input = 'Y';
            if (!force) {
                OutputStreamFormater.printValue(String.format(
                    "Do you really want to delete the connector: %s (Y/n): ", id));
                input = keyboard.read();
            }
            if ('n' != (char) input && 'N' != (char) input) {
                SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        serviceManager.delete(idFinal);
                        return null;
                    }
                });
                OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
            }
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.err.println("Could not delete service");
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Unexpected Error");
        }
    }
598459
public void deleteEvse(Long chargingStationTypeId, Long id) {
        ChargingStationType chargingStationType = chargingStationTypeRepository.findOne(chargingStationTypeId);

        chargingStationType.getEvses().remove(getEvseById(chargingStationType, id));

        updateChargingStationType(chargingStationType.getId(), chargingStationType);
    }