LOG.info("Running in Debug mode");

            logLevel = Level.DEBUG;

        }

        List<PluginModule> pluginModules = Lists.newArrayList();

            pluginModules.addAll(plugin.modules());

        LOG.debug("Loaded modules: " + pluginModules);

        GuiceInstantiationService instantiationService = new GuiceInstantiationService();

            LOG.error("Radio <{}> not found.", radioId);

            throw new WebApplicationException(404);

        }

        try {

            rir = objectMapper.readValue(body, RegisterInputRequest.class);

        } catch(IOException e) {

            LOG.error("Error while parsing JSON", e);

            throw new WebApplicationException(e, Response.Status.BAD_REQUEST);

        restrictToMaster();

        String msg = "Cycling deflector. Reason: REST request.";

        LOG.info(msg);

        deflector.cycle();

        return Response.ok().build();

    }

                serverStatus.getLifecycle(),

                configuration.getLoadBalancerRecognitionPeriodSeconds());

        Uninterruptibles.sleepUninterruptibly(configuration.getLoadBalancerRecognitionPeriodSeconds(), TimeUnit.SECONDS);

        /*

         * Wait a second to give for example the calling REST call some time to respond

         * to the client. Using a latch or something here might be a bit over-engineered.

         */

 

    @RequiresPermissions(USERS_EDIT)

    @ApiOperation("Removes a user account.")

    @ApiResponses({@ApiResponse(code = 400, message = "When attempting to remove a read only user (e.g. built-in or LDAP user).")})

    public Response deleteUser(@ApiParam(name = "username", value = "The name of the user to delete.", required = true) @PathParam("username") String username) {

        if (user == null) {

            return status(NOT_FOUND).build();

        }

            throw new BadRequestException("Cannot delete readonly user " + username);

        }

        userService.destroy(user);

        return Response.noContent().build();

        } catch (IOException e) {

            throw new BadRequestException(e);

        }

        if (user == null) {

            return status(NOT_FOUND).build();

        }

        try {

            userService.save(user);

        } catch (ValidationException e) {

            LOG.error("Validation error.", e);

            throw new BadRequestException("Validation error for " + username, e);

        } catch (IOException e) {

            throw new BadRequestException(e);

        }

        if (user == null) {

            return status(NOT_FOUND).build();

        }

        try {

            userService.save(user);

        } catch (ValidationException e) {

            LOG.error("Validation error.", e);

            throw new BadRequestException("Validation error for " + username, e);

    @ApiResponses({

            @ApiResponse(code = 500, message = "When saving the user failed.")

    })

    public Response deletePermissions(@ApiParam(name = "username", value = "The name of the user to modify.", required = true) @PathParam("username") String username) {

        if (user == null) {

            return status(NOT_FOUND).build();

        }

        try {

            userService.save(user);

        } catch (ValidationException e) {

            throw new InternalServerErrorException(e);

        }

            LOG.error("Error while parsing JSON", e);

            throw new WebApplicationException(e, BAD_REQUEST);

        }

        if (user == null) {

            return status(NOT_FOUND).build();

        }

            return status(FORBIDDEN).build();

        }

            LOG.error("Cannot change password for LDAP user.");

            return status(FORBIDDEN).build();

        }

        boolean checkOldPassword = true;

        // users with the wildcard permission for password change do not have to supply the old password, unless they try to change their own password.

        // the rationale is to prevent accidental or malicious change of admin passwords (e.g. to prevent locking out legitimate admins)

        if (getSubject().isPermitted(RestPermissions.USERS_PASSWORDCHANGE + ":*")) {

            if (username.equals(getSubject().getPrincipal())) {

                LOG.debug("User {} is allowed to change the password of any user, but attempts to change own password. Must supply the old password.", getSubject().getPrincipal());

                checkOldPassword = true;

            } else {

                LOG.debug("User {} is allowed to change the password for any user, including {}, ignoring old password", getSubject().getPrincipal(), username);

                checkOldPassword = false;

            }

        }

        boolean changeAllowed = false;

        final String secret = configuration.getPasswordSecret();

        if (checkOldPassword) {

            if (cr.old_password == null) {

                LOG.info("Changing password for user {} must supply the old password.", username);

                return status(BAD_REQUEST).build();

            }

                changeAllowed = true;

            }

        } else {

            changeAllowed = true;

        }

        if (changeAllowed) {

            try {

                userService.save(user);

            } catch (ValidationException e) {

                throw new BadRequestException("Validation error for " + username, e);

            }

    @Path("{username}/tokens")

    @RequiresPermissions(RestPermissions.USERS_TOKENLIST)

    @ApiOperation("Retrieves the list of access tokens for a user")

    public TokenList listTokens(@ApiParam(name = "username", required = true) @PathParam("username") String username) {

        final TokenList tokenList = new TokenList();

        for (AccessToken token : tokens) {

            tokenList.addToken(new Token(token));

        }

        return tokenList;

    }