/**
* Copyright (c) 2009--2014 Red Hat, Inc.
*
* This software is licensed to you under the GNU General Public License,
* version 2 (GPLv2). There is NO WARRANTY for this software, express or
* implied, including the implied warranties of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
* along with this software; if not, see
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
*
* Red Hat trademarks are not licensed under GPLv2. No permission is
* granted to use or replicate Red Hat trademarks that are incorporated
* in this software or its documentation.
*/
package com.redhat.rhn.frontend.action.kickstart;
import com.redhat.rhn.common.conf.ConfigDefaults;
import com.redhat.rhn.common.validator.ValidatorError;
import com.redhat.rhn.common.validator.ValidatorException;
import com.redhat.rhn.domain.kickstart.KickstartData;
import com.redhat.rhn.domain.kickstart.KickstartFactory;
import com.redhat.rhn.domain.kickstart.KickstartVirtualizationType;
import com.redhat.rhn.domain.kickstart.builder.KickstartBuilder;
import com.redhat.rhn.domain.user.User;
import com.redhat.rhn.frontend.struts.RequestContext;
import com.redhat.rhn.frontend.struts.RhnValidationHelper;
import com.redhat.rhn.frontend.struts.StrutsDelegate;
import com.redhat.rhn.frontend.xmlrpc.kickstart.InvalidVirtualizationTypeException;
import com.redhat.rhn.manager.kickstart.BaseKickstartCommand;
import com.redhat.rhn.manager.kickstart.KickstartEditCommand;
import com.redhat.rhn.manager.kickstart.KickstartFileDownloadCommand;
import com.redhat.rhn.manager.kickstart.KickstartManager;
import com.redhat.rhn.manager.kickstart.KickstartWizardHelper;
import com.redhat.rhn.manager.kickstart.cobbler.CobblerProfileCommand;
import com.redhat.rhn.manager.kickstart.cobbler.CobblerProfileEditCommand;
import com.redhat.rhn.manager.kickstart.cobbler.CobblerXMLRPCHelper;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.DynaActionForm;
import org.cobbler.Distro;
import org.cobbler.Profile;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* KickstartDetailsEdit extends RhnAction
* @version $Rev: 1 $
*/
public class KickstartDetailsEditAction extends BaseKickstartEditAction {
public static final String LABEL = "label";
public static final String ACTIVE = "active";
public static final String COMMENTS = "comments";
public static final String ORG_DEFAULT = "org_default";
public static final String POST_LOG = "post_log";
public static final String PRE_LOG = "pre_log";
public static final String KS_CFG = "ksCfg";
public static final String KERNEL_OPTIONS = "kernel_options";
public static final String POST_KERNEL_OPTIONS = "post_kernel_options";
public static final String VIRTUALIZATION_TYPES = "virtualizationTypes";
public static final String VIRTUALIZATION_TYPE_LABEL = "virtualizationTypeLabel";
public static final String IS_VIRT = "is_virt";
public static final String VIRT_CPU = "virt_cpus";
public static final String VIRT_DISK_SIZE = "virt_disk_size";
public static final String VIRT_MEMORY = "virt_mem_mb";
public static final String VIRT_BRIDGE = "virt_bridge";
public static final String INVALID = "invalid";
/** {@inheritDoc} */
public ActionForward execute(ActionMapping mapping,
ActionForm formIn,
HttpServletRequest request,
HttpServletResponse response) {
RequestContext context = new RequestContext(request);
KickstartData data = context.lookupAndBindKickstartData();
if (data.isRawData()) {
return getStrutsDelegate().forwardParam(
mapping.findForward("raw_mode"), RequestContext.KICKSTART_ID,
data.getId().toString());
}
return super.execute(mapping, formIn, request, response);
}
/**
* {@inheritDoc}
*/
protected void setupFormValues(RequestContext ctx,
DynaActionForm form, BaseKickstartCommand cmdIn) {
KickstartEditCommand cmd = (KickstartEditCommand) cmdIn;
form.set(LABEL, cmd.getLabel());
if (!cmdIn.getKickstartData().isValid()) {
ctx.getRequest().setAttribute(INVALID, Boolean.TRUE);
return;
}
form.set(COMMENTS, cmd.getComments());
form.set(ACTIVE, cmd.getActive());
form.set(ORG_DEFAULT, cmd.getKickstartData().isOrgDefault());
form.set(POST_LOG, cmd.getKickstartData().getPostLog());
form.set(PRE_LOG, cmd.getKickstartData().getPreLog());
form.set(KS_CFG, cmd.getKickstartData().getKsCfg());
setupCobblerFormValues(ctx, form, cmd.getKickstartData());
KickstartWizardHelper wizardHelper = new
KickstartWizardHelper(ctx.getCurrentUser());
// Lookup the kickstart virtualization types and pre-select the current one:
List types = wizardHelper.getVirtualizationTypes();
form.set(VIRTUALIZATION_TYPES, types);
form.set(VIRTUALIZATION_TYPE_LABEL, cmd.getVirtualizationType().getLabel());
KickstartFileDownloadCommand dcmd = new KickstartFileDownloadCommand(
cmd.getKickstartData().getId(),
cmd.getUser(),
ctx.getRequest());
ctx.getRequest().setAttribute(KickstartFileDownloadAction.KSURL,
dcmd.getOrgDefaultUrl());
checkKickstartFile(ctx, getStrutsDelegate());
}
/**
* Setup cobbler form values These include, kernel options and virt options
* @param ctx the RequestContext
* @param form The form
* @param data the kickstart data
*/
public static void setupCobblerFormValues(RequestContext ctx,
DynaActionForm form, KickstartData data) {
Profile prof = Profile.lookupById(CobblerXMLRPCHelper.getConnection(
ctx.getCurrentUser()), data.getCobblerId());
if (prof != null) {
form.set(KERNEL_OPTIONS, prof.getKernelOptionsString());
form.set(POST_KERNEL_OPTIONS, prof.getKernelPostOptionsString());
}
KickstartVirtualizationType type = data.getKickstartDefaults().
getVirtualizationType();
//Should we show virt options?
if (!type.equals(KickstartVirtualizationType.paraHost()) &&
!type.equals(KickstartVirtualizationType.none())) {
if (prof == null) {
form.set(VIRT_BRIDGE, data.getDefaultVirtBridge());
form.set(VIRT_CPU, ConfigDefaults.get().getDefaultVirtCpus());
form.set(VIRT_DISK_SIZE, ConfigDefaults.get().getDefaultVirtDiskSize());
form.set(VIRT_MEMORY, ConfigDefaults.get()
.getDefaultVirtMemorySize(data));
}
else {
setFormValueOrDefault(form, VIRT_BRIDGE, prof.getVirtBridge(),
data.getDefaultVirtBridge());
setFormValueOrDefault(form, VIRT_CPU, prof.getVirtCpus(),
ConfigDefaults.get().getDefaultVirtCpus());
setFormValueOrDefault(form, VIRT_DISK_SIZE, prof.getVirtFileSize(),
ConfigDefaults.get().getDefaultVirtDiskSize());
setFormValueOrDefault(form, VIRT_MEMORY, prof.getVirtRam(),
ConfigDefaults.get().getDefaultVirtMemorySize(data));
}
ctx.getRequest().setAttribute(IS_VIRT, Boolean.TRUE);
}
}
private static void setFormValueOrDefault(DynaActionForm form, String key,
Object value, Object defaultValue) {
if (value == null || StringUtils.isBlank(value.toString()) || value.equals(0)) {
form.set(key, defaultValue);
}
else {
form.set(key, value);
}
}
/**
* {@inheritDoc}
*/
protected ValidatorError processFormValues(HttpServletRequest request,
DynaActionForm form,
BaseKickstartCommand cmdIn) {
ValidatorError error = null;
KickstartEditCommand cmd = (KickstartEditCommand) cmdIn;
RequestContext ctx = new RequestContext(request);
KickstartBuilder builder = new KickstartBuilder(ctx.getCurrentUser());
cmd.setComments(form.getString(COMMENTS));
try {
KickstartVirtualizationType vType =
KickstartFactory.lookupKickstartVirtualizationTypeByLabel(
form.getString(VIRTUALIZATION_TYPE_LABEL));
Distro distro = CobblerProfileCommand.getCobblerDistroForVirtType(
cmdIn.getKickstartData().getTree(), vType, ctx.getCurrentUser());
if (distro == null) {
ValidatorException.raiseException("kickstart.cobbler.profile.invalidvirt");
}
if (!cmdIn.getKickstartData().getLabel().equals(form.getString(LABEL))) {
builder.validateNewLabel(form.getString(LABEL));
}
cmd.setLabel(form.getString(LABEL));
cmd.setActive(Boolean.valueOf(
BooleanUtils.toBoolean((Boolean) form.get(ACTIVE))));
cmd.setIsOrgDefault(Boolean.valueOf(
BooleanUtils.toBoolean((Boolean) form.get(ORG_DEFAULT))));
cmd.getKickstartData().setPostLog(
BooleanUtils.toBoolean((Boolean) form.get(POST_LOG)));
cmd.getKickstartData().setPreLog(
BooleanUtils.toBoolean((Boolean) form.get(PRE_LOG)));
cmd.getKickstartData().setKsCfg(
BooleanUtils.toBoolean((Boolean) form.get(KS_CFG)));
processCobblerFormValues(cmd.getKickstartData(), form, ctx.getCurrentUser());
String virtTypeLabel = form.getString(VIRTUALIZATION_TYPE_LABEL);
KickstartVirtualizationType ksVirtType = KickstartFactory.
lookupKickstartVirtualizationTypeByLabel(virtTypeLabel);
if (ksVirtType == null) {
throw new InvalidVirtualizationTypeException(virtTypeLabel);
}
cmd.setVirtualizationType(ksVirtType);
return null;
}
catch (ValidatorException ve) {
return ve.getResult().getErrors().get(0);
}
}
protected String getSuccessKey() {
return "kickstart.details.success";
}
/**
* {@inheritDoc}
*/
protected BaseKickstartCommand getCommand(RequestContext ctx) {
return new KickstartEditCommand(ctx.getRequiredParam(RequestContext.KICKSTART_ID),
ctx.getCurrentUser());
}
/**
* Should i save virt options?
* @param data the kickstart data
* @param form the form
* @return true if you should save the kickstart options
*/
private static boolean canSaveVirtOptions(KickstartData data, DynaActionForm form) {
//if the form was not part of the values submitted, don't save values
if (form.get(VIRT_DISK_SIZE) == null) {
return false;
}
//or if it was there, but we switched to none-type, don't save it either
String virtType = (String) form.get(VIRTUALIZATION_TYPE_LABEL);
return virtType != null && !virtType.equals(
KickstartFactory.VIRT_TYPE_PV_HOST.getLabel());
}
/**
* Proccess Cobbler form values, pulling in the form
* and pushing the values to cobbler
* @param ksdata the kickstart data
* @param form the form
* @param user the user
* @throws ValidatorException if there is not enough ram
*/
public static void processCobblerFormValues(KickstartData ksdata, DynaActionForm form,
User user) throws ValidatorException {
if (KickstartDetailsEditAction.canSaveVirtOptions(ksdata, form)) {
int virtMemory = (Integer) form.get(VIRT_MEMORY);
if (ksdata.isRhel7OrGreater() && virtMemory < 1024) {
ValidatorException
.raiseException("kickstart.cobbler.profile.notenoughmemory");
}
else if (ksdata.isSUSE() && virtMemory < 512) {
ValidatorException
.raiseException("kickstart.cobbler.profile.notenoughmemorysuse");
}
}
CobblerProfileEditCommand cmd = new CobblerProfileEditCommand(ksdata, user);
cmd.setKernelOptions(StringUtils.defaultString(form.getString(KERNEL_OPTIONS)));
cmd.setPostKernelOptions(StringUtils.defaultString(
form.getString(POST_KERNEL_OPTIONS)));
cmd.store();
Profile prof = Profile.lookupById(CobblerXMLRPCHelper.getConnection(user),
ksdata.getCobblerId());
if (prof == null) {
return;
}
if (KickstartDetailsEditAction.canSaveVirtOptions(ksdata, form)) {
prof.setVirtRam((Integer) form.get(VIRT_MEMORY));
prof.setVirtCpus((Integer) form.get(VIRT_CPU));
prof.setVirtFileSize((Integer) form.get(VIRT_DISK_SIZE));
prof.setVirtBridge(form.getString(VIRT_BRIDGE));
}
prof.save();
}
/**
* Method used to check if when/after a kickstart file was generated
* if there is any glitch (like parser error) in the template that got created
* @param context the request context
* @param strutsDelegate the strutsdelegate associated to the action.
*/
public static void checkKickstartFile(RequestContext context,
StrutsDelegate strutsDelegate) {
try {
KickstartManager.getInstance().validateKickstartFile(
context.lookupAndBindKickstartData());
}
catch (ValidatorException ve) {
RhnValidationHelper.setFailedValidation(context.getRequest());
strutsDelegate.saveMessages(context.getRequest(), ve.getResult());
}
}
}