/**
* Copyright (c) 2009--2015 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.xmlrpc.kickstart.profile;
import com.redhat.rhn.FaultException;
import com.redhat.rhn.common.hibernate.HibernateFactory;
import com.redhat.rhn.common.localization.LocalizationService;
import com.redhat.rhn.common.security.PermissionException;
import com.redhat.rhn.common.util.MD5Crypt;
import com.redhat.rhn.common.validator.ValidatorError;
import com.redhat.rhn.domain.channel.Channel;
import com.redhat.rhn.domain.kickstart.KickstartCommand;
import com.redhat.rhn.domain.kickstart.KickstartCommandName;
import com.redhat.rhn.domain.kickstart.KickstartData;
import com.redhat.rhn.domain.kickstart.KickstartDefaults;
import com.redhat.rhn.domain.kickstart.KickstartFactory;
import com.redhat.rhn.domain.kickstart.KickstartIpRange;
import com.redhat.rhn.domain.kickstart.KickstartPackage;
import com.redhat.rhn.domain.kickstart.KickstartScript;
import com.redhat.rhn.domain.kickstart.KickstartableTree;
import com.redhat.rhn.domain.kickstart.RepoInfo;
import com.redhat.rhn.domain.org.Org;
import com.redhat.rhn.domain.role.RoleFactory;
import com.redhat.rhn.domain.token.ActivationKey;
import com.redhat.rhn.domain.user.User;
import com.redhat.rhn.frontend.action.kickstart.KickstartIpRangeFilter;
import com.redhat.rhn.frontend.action.kickstart.KickstartTreeUpdateType;
import com.redhat.rhn.frontend.dto.kickstart.KickstartOptionValue;
import com.redhat.rhn.frontend.xmlrpc.BaseHandler;
import com.redhat.rhn.frontend.xmlrpc.InvalidChannelLabelException;
import com.redhat.rhn.frontend.xmlrpc.InvalidKickstartScriptException;
import com.redhat.rhn.frontend.xmlrpc.InvalidScriptNameException;
import com.redhat.rhn.frontend.xmlrpc.InvalidScriptTypeException;
import com.redhat.rhn.frontend.xmlrpc.IpRangeConflictException;
import com.redhat.rhn.frontend.xmlrpc.PermissionCheckFailureException;
import com.redhat.rhn.frontend.xmlrpc.ValidationException;
import com.redhat.rhn.frontend.xmlrpc.kickstart.InvalidUpdateTypeAndKickstartTreeException;
import com.redhat.rhn.frontend.xmlrpc.kickstart.InvalidUpdateTypeAndNoBaseTreeException;
import com.redhat.rhn.frontend.xmlrpc.kickstart.InvalidUpdateTypeException;
import com.redhat.rhn.frontend.xmlrpc.kickstart.NoSuchKickstartTreeException;
import com.redhat.rhn.frontend.xmlrpc.kickstart.XmlRpcKickstartHelper;
import com.redhat.rhn.frontend.xmlrpc.kickstart.profile.keys.KeysHandler;
import com.redhat.rhn.manager.channel.ChannelManager;
import com.redhat.rhn.manager.kickstart.IpAddress;
import com.redhat.rhn.manager.kickstart.KickstartEditCommand;
import com.redhat.rhn.manager.kickstart.KickstartFormatter;
import com.redhat.rhn.manager.kickstart.KickstartIpCommand;
import com.redhat.rhn.manager.kickstart.KickstartManager;
import com.redhat.rhn.manager.kickstart.KickstartOptionsCommand;
import com.redhat.rhn.manager.kickstart.KickstartWizardHelper;
import com.redhat.rhn.manager.kickstart.cobbler.CobblerProfileEditCommand;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.cobbler.Profile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/**
* ProfileHandler
* @version $Rev$
* @xmlrpc.namespace kickstart.profile
* @xmlrpc.doc Provides methods to access and modify many aspects of
* a kickstart profile.
*/
public class ProfileHandler extends BaseHandler {
private static final String[] VALIDOPTIONNAMES = {"autostep", "interactive", "install",
"upgrade", "text", "network", "cdrom", "harddrive", "nfs", "url",
"lang", "langsupport", "keyboard", "mouse", "device", "deviceprobe",
"zerombr", "clearpart", "bootloader", "timezone", "auth", "rootpw",
"selinux", "reboot", "firewall", "xconfig", "skipx", "key",
"ignoredisk", "autopart", "cmdline", "firstboot", "graphical", "iscsi",
"iscsiname", "logging", "monitor", "multipath", "poweroff", "halt",
"services", "shutdown", "user", "vnc", "zfcp", "driverdisk",
"md5_crypt_rootpw"};
/**
* Get the kickstart tree for a kickstart profile.
* @param loggedInUser The current user
* @param kslabel label of the kickstart profile to be changed.
* @return kickstart tree label
*
* @xmlrpc.doc Get the kickstart tree for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.returntype
* #param_desc("string", "kstreeLabel", "Label of the kickstart tree.")
*/
public String getKickstartTree(User loggedInUser, String kslabel) {
KickstartData ksdata = KickstartFactory
.lookupKickstartDataByLabelAndOrgId(kslabel, loggedInUser
.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
KickstartDefaults ksdefault = ksdata.getKickstartDefaults();
return ksdefault.getKstree().getLabel();
}
/**
* Get the update type for a kickstart profile.
* @param loggedInUser The current user
* @param kslabel label of the kickstart profile to be changed.
* @return kickstart tree label
*
* @xmlrpc.doc Get the update type for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile.")
* @xmlrpc.returntype
* #param_desc("string", "update_type", "Update type for this Kickstart Profile.")
*/
public String getUpdateType(User loggedInUser, String kslabel) {
KickstartData ksdata = KickstartFactory
.lookupKickstartDataByLabelAndOrgId(kslabel, loggedInUser
.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
return ksdata.getUpdateType();
}
/**
* Get the option to perserve ks.cfg.
* @param loggedInUser The current user
* @param kslabel the kickstart label
* @return Boolean value of the option
*
* @xmlrpc.doc Get ks.cfg preservation option for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.returntype boolean - The value of the option. True means that
* ks.cfg will be copied to /root, false means that it will not.
*/
public Boolean getCfgPreservation(User loggedInUser, String kslabel) {
checkKickstartPerms(loggedInUser);
KickstartData data = lookupKsData(kslabel, loggedInUser.getOrg());
if (data == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
return data.getKsCfg();
}
/**
* Set the option to perserve ks.cfg.
* @param loggedInUser The current user
* @param kslabel the kickstart label
* @param preserve whether to perserve ks.cfg or not
* @return int 1 for success
*
* @xmlrpc.doc Set ks.cfg preservation option for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.param #param_desc("boolean", "preserve", "whether or not
* ks.cfg and all %include fragments will be copied to /root.")
* @xmlrpc.returntype #return_int_success()
*/
public int setCfgPreservation(User loggedInUser, String kslabel, boolean preserve) {
checkKickstartPerms(loggedInUser);
KickstartData data = lookupKsData(kslabel, loggedInUser.getOrg());
if (data == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
data.setKsCfg(preserve);
KickstartFactory.saveKickstartData(data);
return 1;
}
/**
* Set the logging (Pre and post) for a kickstart file
* @param loggedInUser The current user
* @param kslabel the kickstart label
* @param pre whether to log pre scripts or not
* @param post whether to log post scripts or not
* @return int 1 for success
*
* @xmlrpc.doc Set logging options for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.param #param_desc("boolean", "pre", "whether or not to log
* the pre section of a kickstart to /root/ks-pre.log")
* @xmlrpc.param #param_desc("boolean", "post", "whether or not to log
* the post section of a kickstart to /root/ks-post.log")
* @xmlrpc.returntype #return_int_success()
*/
public int setLogging(User loggedInUser, String kslabel, boolean pre, boolean post) {
checkKickstartPerms(loggedInUser);
KickstartData data = lookupKsData(kslabel, loggedInUser.getOrg());
data.setPreLog(pre);
data.setPostLog(post);
KickstartFactory.saveKickstartData(data);
return 1;
}
/**
* Set the kickstart tree for a kickstart profile.
* @param loggedInUser The current user
* @param kslabel label of the kickstart profile to be changed.
* @param kstreeLabel label of the new kickstart tree.
* @return 1 if successful, exception otherwise.
*
* @xmlrpc.doc Set the kickstart tree for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.param #param_desc("string", "kstreeLabel", "Label of new
* kickstart tree.")
* @xmlrpc.returntype #return_int_success()
*/
public int setKickstartTree(User loggedInUser, String kslabel,
String kstreeLabel) {
KickstartData ksdata = KickstartFactory
.lookupKickstartDataByLabelAndOrgId(kslabel, loggedInUser
.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
KickstartableTree tree = KickstartFactory.lookupKickstartTreeByLabel(
kstreeLabel, loggedInUser.getOrg());
if (tree == null) {
throw new NoSuchKickstartTreeException(kstreeLabel);
}
KickstartCommand urlC = ksdata.getCommand("url");
urlC.setArguments("--url " + tree.getDefaultDownloadLocation());
KickstartDefaults ksdefault = ksdata.getKickstartDefaults();
ksdefault.setKstree(tree);
CobblerProfileEditCommand cpec = new CobblerProfileEditCommand(ksdata,
loggedInUser);
cpec.store();
return 1;
}
/**
* Set the update type for a kickstart profile.
* @param loggedInUser The current user
* @param kslabel label of the kickstart profile to be changed.
* @param updateType the new update type.
* @return 1 if successful, exception otherwise.
*
* @xmlrpc.doc Set the update typefor a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.param #param_desc("string", "updateType", "The new update type
* to set. Possible values are 'red_hat', 'all', and 'none'.")
* @xmlrpc.returntype #return_int_success()
*/
public int setUpdateType(User loggedInUser, String kslabel,
String updateType) {
KickstartData ksdata = KickstartFactory
.lookupKickstartDataByLabelAndOrgId(kslabel, loggedInUser
.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
KickstartableTree tree = ksdata.getTree();
KickstartTreeUpdateType realUT = null;
if (updateType.equals(KickstartTreeUpdateType.ALL.getType())) {
if (tree.getChannel() == null) {
throw new InvalidUpdateTypeAndNoBaseTreeException(tree.getLabel());
}
realUT = KickstartTreeUpdateType.ALL;
}
else if (updateType.equals(KickstartTreeUpdateType.RED_HAT.getType())) {
if (tree.getOrgId() != null) {
throw new InvalidUpdateTypeAndKickstartTreeException(tree.getLabel());
}
if (tree.getChannel() == null) {
throw new InvalidUpdateTypeAndNoBaseTreeException(tree.getLabel());
}
realUT = KickstartTreeUpdateType.RED_HAT;
}
else if (updateType.equals(KickstartTreeUpdateType.NONE.getType())) {
realUT = KickstartTreeUpdateType.NONE;
}
else {
throw new InvalidUpdateTypeException(updateType);
}
ksdata.setRealUpdateType(realUT);
return 1;
}
/**
* Get the child channels for a kickstart profile.
* @param loggedInUser The current user
* @param kslabel label of the kickstart profile to be updated.
* @return list of child channels associated with the profile.
*
* @xmlrpc.doc Get the child channels for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile.")
* @xmlrpc.returntype
* #array_single("string", "channelLabel")
*/
public List<String> getChildChannels(User loggedInUser, String kslabel) {
KickstartData ksdata = KickstartFactory.
lookupKickstartDataByLabelAndOrgId(kslabel, loggedInUser.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
List<String> childChannels = new ArrayList<String>();
if (ksdata.getChildChannels() != null) {
for (Iterator itr = ksdata.getChildChannels().iterator(); itr.hasNext();) {
Channel channel = (Channel) itr.next();
childChannels.add(channel.getLabel());
}
}
return childChannels;
}
/**
* Set the child channels for a kickstart profile.
* @param loggedInUser The current user
* @param kslabel label of the kickstart profile to be updated.
* @param channelLabels labels of the child channels to be set in the
* kickstart profile.
* @return 1 if successful, exception otherwise.
*
* @xmlrpc.doc Set the child channels for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "kslabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.param #param_desc("string[]", "channelLabels",
* "List of labels of child channels")
* @xmlrpc.returntype #return_int_success()
*/
public int setChildChannels(User loggedInUser, String kslabel,
List<String> channelLabels) {
KickstartData ksdata = KickstartFactory.
lookupKickstartDataByLabelAndOrgId(kslabel, loggedInUser.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + kslabel);
}
if (ksdata.getChildChannels() != null) {
ksdata.getChildChannels().clear();
}
for (int i = 0; i < channelLabels.size(); i++) {
Channel channel = ChannelManager.lookupByLabelAndUser(channelLabels.get(i),
loggedInUser);
if (channel == null) {
throw new InvalidChannelLabelException();
}
ksdata.addChildChannel(channel);
}
KickstartFactory.saveKickstartData(ksdata);
return 1;
}
/**
* List the pre and post scripts for a kickstart profile in the order
* they will run during the kickstart.
* @param loggedInUser The current user
* @param label the kickstart label
* @return list of kickstartScript objects
*
* @xmlrpc.doc List the pre and post scripts for a kickstart profile
* in the order they will run during the kickstart.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The label of the
* kickstart")
* @xmlrpc.returntype #array() $KickstartScriptSerializer #array_end()
*/
public List<KickstartScript> listScripts(User loggedInUser, String label) {
checkKickstartPerms(loggedInUser);
KickstartData data = lookupKsData(label, loggedInUser.getOrg());
ArrayList<KickstartScript> scripts = new ArrayList<KickstartScript>(
data.getScripts());
Collections.sort(scripts);
return scripts;
}
/**
* Change the order that kickstart scripts will run for this kickstart
* profile. Scripts will run in the order they appear in the array.
* There are three arrays, one for all pre scripts, one for the post
* scripts that run before registration and server actions happen,
* and one for post scripts that run after registration and server
* actinos. All scripts must be included in one of these lists, as
* appropriate.
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param preScripts the ordered list of pre scripts
* @param postScriptsBeforeRegistration the ordered list of post
* scripts that run before registration
* @param postScriptsAfterRegistration the ordered list of post
* scripts that run after registration
* @return 1 on success
*
* @xmlrpc.doc Change the order that kickstart scripts will run for
* this kickstart profile. Scripts will run in the order they appear
* in the array. There are three arrays, one for all pre scripts, one
* for the post scripts that run before registration and server
* actions happen, and one for post scripts that run after registration
* and server actions. All scripts must be included in one of these
* lists, as appropriate.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The label of the
* kickstart")
* @xmlrpc.param #array_single("int",
* "IDs of the ordered pre scripts")
* @xmlrpc.param #array_single("int",
* "IDs of the ordered post scripts that will run
* before registration")
* @xmlrpc.param #array_single("int",
* "IDs of the ordered post scripts that will run
* after registration")
* @xmlrpc.returntype #return_int_success()
*/
public int orderScripts(User loggedInUser, String ksLabel, List<Integer> preScripts,
List<Integer> postScriptsBeforeRegistration,
List<Integer> postScriptsAfterRegistration) {
checkKickstartPerms(loggedInUser);
KickstartData data = lookupKsData(ksLabel, loggedInUser.getOrg());
if (data == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + ksLabel);
}
Set<KickstartScript> scripts = data.getScripts();
// validate the input
List<KickstartScript> myPreScripts = new ArrayList<KickstartScript>();
List<KickstartScript> myPostScripts = new ArrayList<KickstartScript>();
Map<Integer, KickstartScript> idToScript = new HashMap<Integer, KickstartScript>();
for (KickstartScript script : scripts) {
idToScript.put(script.getId().intValue(), script);
if (script.getScriptType().equals(KickstartScript.TYPE_PRE)) {
myPreScripts.add(script);
if (!preScripts.contains(script.getId().intValue())) {
throw new IllegalArgumentException("Kickstart Script ID missing: " +
script.getId());
}
}
else {
myPostScripts.add(script);
if (!(postScriptsBeforeRegistration.contains(script.getId().intValue()) ||
postScriptsAfterRegistration.contains(
script.getId().intValue()))) {
throw new IllegalArgumentException("Kickstart Script ID missing: " +
script.getId());
}
}
}
if (preScripts.size() != myPreScripts.size()) {
throw new IllegalArgumentException("Too many pre script IDs.");
}
if ((postScriptsBeforeRegistration.size() + postScriptsAfterRegistration.size() !=
myPostScripts.size())) {
throw new IllegalArgumentException("Too many post script IDs.");
}
// To avoid db constraint error about two scripts having same position,
// make them something else
Long fakePosition = 10000L;
for (KickstartScript script : scripts) {
script.setPosition(fakePosition);
fakePosition += 1;
HibernateFactory.getSession().save(script);
}
KickstartFactory.saveKickstartData(data);
// create new position values
Long nextPosition = 1L;
Long nextNegativePosition = -1L;
for (Integer id : preScripts) {
KickstartScript script = idToScript.get(id);
script.setPosition(nextPosition);
nextPosition += 1;
HibernateFactory.getSession().save(script);
}
for (Integer id : postScriptsBeforeRegistration) {
KickstartScript script = idToScript.get(id);
script.setPosition(nextNegativePosition);
nextNegativePosition -= 1;
HibernateFactory.getSession().save(script);
}
for (Integer id : postScriptsAfterRegistration) {
KickstartScript script = idToScript.get(id);
script.setPosition(nextPosition);
nextPosition += 1;
HibernateFactory.getSession().save(script);
}
KickstartFactory.saveKickstartData(data);
return 1;
}
/**
* Add a script to a kickstart profile
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param name name of the script
* @param contents the contents
* @param interpreter the script interpreter to use
* @param type "pre" or "post"
* @param chroot true if you want it to be chrooted
* @return the id of the created script
*
* @xmlrpc.doc Add a pre/post script to a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The kickstart label to
* add the script to.")
* @xmlrpc.param #param_desc("string", "name", "The kickstart script name.")
* @xmlrpc.param #param_desc("string", "contents", "The full script to
* add.")
* @xmlrpc.param #param_desc("string", "interpreter", "The path to the
* interpreter to use (i.e. /bin/bash). An empty string will use the
* kickstart default interpreter.")
* @xmlrpc.param #param_desc("string", "type", "The type of script (either
* 'pre' or 'post').")
* @xmlrpc.param #param_desc("boolean", "chroot", "Whether to run the script
* in the chrooted install location (recommended) or not.")
* @xmlrpc.returntype int id - the id of the added script
*
*/
public int addScript(User loggedInUser, String ksLabel, String name, String contents,
String interpreter, String type, boolean chroot) {
return addScript(loggedInUser, ksLabel, name, contents, interpreter, type,
chroot, false);
}
/**
* Add a script to a kickstart profile
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param name name of the script
* @param contents the contents
* @param interpreter the script interpreter to use
* @param type "pre" or "post"
* @param chroot true if you want it to be chrooted
* @param template enable templating using cobbler
* @return the id of the created script
*
* @xmlrpc.doc Add a pre/post script to a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The kickstart label to
* add the script to.")
* @xmlrpc.param #param_desc("string", "name", "The kickstart script name.")
* @xmlrpc.param #param_desc("string", "contents", "The full script to
* add.")
* @xmlrpc.param #param_desc("string", "interpreter", "The path to the
* interpreter to use (i.e. /bin/bash). An empty string will use the
* kickstart default interpreter.")
* @xmlrpc.param #param_desc("string", "type", "The type of script (either
* 'pre' or 'post').")
* @xmlrpc.param #param_desc("boolean", "chroot", "Whether to run the script
* in the chrooted install location (recommended) or not.")
* @xmlrpc.param #param_desc("boolean", "template", "Enable templating using cobbler.")
* @xmlrpc.returntype int id - the id of the added script
*
*/
public int addScript(User loggedInUser, String ksLabel, String name, String contents,
String interpreter, String type, boolean chroot, boolean template) {
return addScript(loggedInUser, ksLabel, name, contents, interpreter, type, chroot,
template, false);
}
/**
* Add a script to a kickstart profile
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param name name of the script
* @param contents the contents
* @param interpreter the script interpreter to use
* @param type "pre" or "post"
* @param chroot true if you want it to be chrooted
* @param template enable templating using cobbler
* @param erroronfail Whether to throw an error if the script fails or not
* @return the id of the created script
*
* @xmlrpc.doc Add a pre/post script to a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The kickstart label to
* add the script to.")
* @xmlrpc.param #param_desc("string", "name", "The kickstart script name.")
* @xmlrpc.param #param_desc("string", "contents", "The full script to
* add.")
* @xmlrpc.param #param_desc("string", "interpreter", "The path to the
* interpreter to use (i.e. /bin/bash). An empty string will use the
* kickstart default interpreter.")
* @xmlrpc.param #param_desc("string", "type", "The type of script (either
* 'pre' or 'post').")
* @xmlrpc.param #param_desc("boolean", "chroot", "Whether to run the script
* in the chrooted install location (recommended) or not.")
* @xmlrpc.param #param_desc("boolean", "template", "Enable templating using cobbler.")
* @xmlrpc.param #param_desc("boolean", "erroronfail", "Whether to throw an
* error if the script fails or not")
* @xmlrpc.returntype int id - the id of the added script
*
*/
public int addScript(User loggedInUser, String ksLabel, String name, String contents,
String interpreter, String type, boolean chroot, boolean template,
boolean erroronfail) {
checkKickstartPerms(loggedInUser);
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
if (!type.equals("pre") && !type.equals("post")) {
throw new InvalidScriptTypeException();
}
if (StringUtils.isBlank(name) || name.length() > 40) {
throw new InvalidScriptNameException();
}
KickstartScript script = new KickstartScript();
script.setScriptName(name);
script.setData(contents.getBytes());
script.setInterpreter(interpreter.equals("") ? null : interpreter);
script.setScriptType(type);
script.setChroot(chroot ? "Y" : "N");
script.setRaw(!template);
script.setErrorOnFail(erroronfail);
script.setKsdata(ksData);
ksData.addScript(script);
HibernateFactory.getSession().save(script);
KickstartFactory.saveKickstartData(ksData);
return script.getId().intValue();
}
/**
* Remove a script from a kickstart profile.
* @param loggedInUser The current user
* @param ksLabel the kickstart to remove a script from
* @param id the id of the kickstart
* @return 1 on success
*
* @xmlrpc.doc Remove a script from a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The kickstart from which
* to remove the script from.")
* @xmlrpc.param #param_desc("int", "scriptId", "The id of the script to
* remove.")
* @xmlrpc.returntype #return_int_success()
*
*/
public int removeScript(User loggedInUser, String ksLabel, Integer id) {
checkKickstartPerms(loggedInUser);
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartScript script = KickstartFactory.lookupKickstartScript(
loggedInUser.getOrg(), id);
if (script == null ||
!script.getKsdata().getLabel().equals(ksData.getLabel())) {
throw new InvalidKickstartScriptException();
}
script.setKsdata(null);
ksData.getScripts().remove(script);
KickstartFactory.removeKickstartScript(script);
KickstartFactory.saveKickstartData(ksData);
return 1;
}
/**
* returns the fully formatted kickstart file
* @param loggedInUser The current user
* @param ksLabel the label to download
* @param host The host/ip to use when referring to the server itself
* @return the kickstart file
*
* @xmlrpc.doc Download the full contents of a kickstart file.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The label of the
* kickstart to download.")
* @xmlrpc.param #param_desc("string", "host", "The host to use when
* referring to the satellite itself (Usually this should be the FQDN of the
* satellite, but could be the ip address or shortname of it as well.")
* @xmlrpc.returntype string - The contents of the kickstart file. Note: if
* an activation key is not associated with the kickstart file, registration
* will not occur in the satellite generated %post section. If one is
* associated, it will be used for registration.
*
*
*/
public String downloadKickstart(User loggedInUser, String ksLabel,
String host) {
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartFormatter form = new KickstartFormatter(host, ksData);
return form.getFileData();
}
/**
* returns the Cobbler-rendered kickstart file
* @param loggedInUser The current user
* @param ksLabel the label to download
* @return the kickstart file
*
* @xmlrpc.doc Downloads the Cobbler-rendered Kickstart file.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The label of the
* kickstart to download.")
* @xmlrpc.returntype string - The contents of the kickstart file.
*/
public String downloadRenderedKickstart(User loggedInUser, String ksLabel) {
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartManager manager = KickstartManager.getInstance();
return manager.renderKickstart(ksData);
}
/**
* Get advanced options for existing kickstart profile.
* @param loggedInUser The current user
* @param ksLabel label of the kickstart profile to be updated.
* @return An array of advanced options
* @throws FaultException A FaultException is thrown if
* the profile associated with ksLabel cannot be found
*
* @xmlrpc.doc Get advanced options for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "Label of kickstart
* profile to be changed.")
* @xmlrpc.returntype
* #array()
* $KickstartAdvancedOptionsSerializer
* #array_end()
*/
public Object[] getAdvancedOptions(User loggedInUser, String ksLabel)
throws FaultException {
KickstartData ksdata = KickstartFactory.
lookupKickstartDataByLabelAndOrgId(ksLabel, loggedInUser.
getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + ksLabel);
}
Set<KickstartCommand> options = ksdata.getOptions();
return options.toArray();
}
/**
* Set advanced options in a kickstart profile
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param options the advanced options to set
* @return 1 if success, exception otherwise
* @throws FaultException A FaultException is thrown if
* the profile associated with ksLabel cannot be found
* or invalid advanced option is provided
*
* @xmlrpc.doc Set advanced options for a kickstart profile.
* If 'md5_crypt_rootpw' is set to 'True', 'root_pw' is taken as plaintext and
* will md5 encrypted on server side, otherwise a hash encoded password
* (according to the auth option) is expected
* @xmlrpc.param #session_key()
* @xmlrpc.param #param("string","ksLabel")
* @xmlrpc.param
* #array()
* #struct("advanced options")
* #prop_desc("string", "name", "Name of the advanced option.
* Valid Option names: autostep, interactive, install, upgrade, text,
* network, cdrom, harddrive, nfs, url, lang, langsupport keyboard,
* mouse, device, deviceprobe, zerombr, clearpart, bootloader,
* timezone, auth, rootpw, selinux, reboot, firewall, xconfig, skipx,
* key, ignoredisk, autopart, cmdline, firstboot, graphical, iscsi,
* iscsiname, logging, monitor, multipath, poweroff, halt, services,
* shutdown, user, vnc, zfcp, driverdisk, md5_crypt_rootpw")
* #prop_desc("string", "arguments", "Arguments of the option")
* #struct_end()
* #array_end()
* @xmlrpc.returntype #return_int_success()
*/
public int setAdvancedOptions(User loggedInUser, String ksLabel, List<Map> options)
throws FaultException {
KickstartData ksdata = KickstartFactory.
lookupKickstartDataByLabelAndOrgId(ksLabel, loggedInUser.
getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + ksLabel);
}
List<String> validOptions = Arrays.asList(VALIDOPTIONNAMES);
Set<String> givenOptions = new HashSet<String>();
for (Map option : options) {
givenOptions.add((String) option.get("name"));
}
if (!validOptions.containsAll(givenOptions)) {
throw new FaultException(-5, "invalidKickstartCommandName",
"Invalid kickstart option present. List of valid options is: " +
validOptions);
}
Long ksid = ksdata.getId();
KickstartOptionsCommand cmd = new KickstartOptionsCommand(ksid, loggedInUser);
//check if all the required options are present
List<KickstartCommandName> requiredOptions = KickstartFactory.
lookupKickstartRequiredOptions();
List<String> requiredOptionNames = new ArrayList<String>();
for (KickstartCommandName kcn : requiredOptions) {
requiredOptionNames.add(kcn.getName());
}
if (!givenOptions.containsAll(requiredOptionNames)) {
throw new FaultException(-6, "requiredOptionMissing",
"Required option missing. List of required options: " +
requiredOptionNames);
}
Set<KickstartCommand> customSet = new HashSet<KickstartCommand>();
for (Iterator itr = cmd.getAvailableOptions().iterator(); itr.hasNext();) {
Map option = null;
KickstartCommandName cn = (KickstartCommandName) itr.next();
if (givenOptions.contains(cn.getName())) {
for (Map o : options) {
if (cn.getName().equals(o.get("name"))) {
option = o;
break;
}
}
KickstartCommand kc = new KickstartCommand();
kc.setCommandName(cn);
kc.setKickstartData(cmd.getKickstartData());
kc.setCreated(new Date());
kc.setModified(new Date());
if (cn.getArgs().booleanValue()) {
// handle password encryption
if (cn.getName().equals("rootpw")) {
String pwarg = (String) option.get("arguments");
// password already encrypted
if (!md5cryptRootPw(options)) {
kc.setArguments(pwarg);
}
// password changed, encrypt it
else {
kc.setArguments(MD5Crypt.crypt(pwarg));
}
}
else {
kc.setArguments((String) option.get("arguments"));
}
}
customSet.add(kc);
}
}
cmd.getKickstartData().setOptions(customSet);
KickstartFactory.saveKickstartData(ksdata);
cmd.store();
return 1;
}
private boolean md5cryptRootPw(List<Map> options) {
for (Map m : options) {
if ("md5_crypt_rootpw".equals(m.get("name"))) {
return BooleanUtils.toBoolean((String)m.get("arguments"));
}
}
return false;
}
/**
* Get custom options for a kickstart profile.
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @return a list of hashes holding this info.
* @throws FaultException A FaultException is thrown if
* the profile associated with ksLabel cannot be found
*
* @xmlrpc.doc Get custom options for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param("string","ksLabel")
*
* @xmlrpc.returntype
* #array()
* $KickstartCommandSerializer
* #array_end()
*/
public Object[] getCustomOptions(User loggedInUser, String ksLabel)
throws FaultException {
KickstartData ksdata = KickstartFactory.lookupKickstartDataByLabelAndOrgId(
ksLabel, loggedInUser.getOrg().getId());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + ksLabel);
}
LinkedHashSet options = ksdata.getCustomOptions();
return options.toArray();
}
/**
* Set custom options for a kickstart profile.
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param options the custom options to set
* @return a int being the number of options set
* @throws FaultException A FaultException is thrown if
* the profile associated with ksLabel cannot be found
*
* @xmlrpc.doc Set custom options for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param("string","ksLabel")
* @xmlrpc.param #param("string[]","options")
* @xmlrpc.returntype #return_int_success()
*/
public int setCustomOptions(User loggedInUser, String ksLabel, List<String> options)
throws FaultException {
KickstartData ksdata =
XmlRpcKickstartHelper.getInstance().lookupKsData(ksLabel,
loggedInUser.getOrg());
if (ksdata == null) {
throw new FaultException(-3, "kickstartProfileNotFound",
"No Kickstart Profile found with label: " + ksLabel);
}
Long ksid = ksdata.getId();
KickstartOptionsCommand cmd = new KickstartOptionsCommand(ksid, loggedInUser);
SortedSet<KickstartCommand> customSet = new TreeSet<KickstartCommand>();
if (options != null) {
for (int i = 0; i < options.size(); i++) {
String option = options.get(i);
KickstartCommand custom = new KickstartCommand();
custom.setCommandName(
KickstartFactory.lookupKickstartCommandName("custom"));
// the following is a workaround to ensure that the options are rendered
// on the UI on separate lines.
if (i < (options.size() - 1)) {
option += "\r";
}
custom.setArguments(option);
custom.setKickstartData(cmd.getKickstartData());
custom.setCustomPosition(customSet.size());
custom.setCreated(new Date());
custom.setModified(new Date());
customSet.add(custom);
}
if (cmd.getKickstartData().getCustomOptions() == null) {
cmd.getKickstartData().setCustomOptions(customSet);
}
else {
cmd.getKickstartData().setCustomOptions(customSet);
}
cmd.store();
}
return 1;
}
/**
* Lists all ip ranges for a kickstart profile.
* @param loggedInUser The current user
* @param ksLabel the label of the kickstart
* @return List of KickstartIpRange objects
*
* @xmlrpc.doc List all ip ranges for a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "label", "The label of the
* kickstart")
* @xmlrpc.returntype #array() $KickstartIpRangeSerializer #array_end()
*
*/
public Set listIpRanges(User loggedInUser, String ksLabel) {
if (!loggedInUser.hasRole(RoleFactory.CONFIG_ADMIN)) {
throw new PermissionCheckFailureException();
}
KickstartData ksdata = lookupKsData(ksLabel, loggedInUser.getOrg());
return ksdata.getIps();
}
/**
* Add an ip range to a kickstart.
* @param loggedInUser The current user
* @param ksLabel the kickstart label
* @param min the min ip address of the range
* @param max the max ip address of the range
* @return 1 on success
*
* @xmlrpc.doc Add an ip range to a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "label", "The label of the
* kickstart")
* @xmlrpc.param #param_desc("string", "min", "The ip address making up the
* minimum of the range (i.e. 192.168.0.1)")
* @xmlrpc.param #param_desc("string", "max", "The ip address making up the
* maximum of the range (i.e. 192.168.0.254)")
* @xmlrpc.returntype #return_int_success()
*
*/
public int addIpRange(User loggedInUser, String ksLabel, String min,
String max) {
KickstartData ksdata = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartIpCommand com = new KickstartIpCommand(ksdata.getId(), loggedInUser);
IpAddress minIp = new IpAddress(min);
IpAddress maxIp = new IpAddress(max);
if (!com.validateIpRange(minIp.getOctets(), maxIp.getOctets())) {
ValidatorError error = new ValidatorError("kickstart.iprange_validate.failure");
throw new ValidationException(error.getMessage());
}
if (!com.addIpRange(minIp.getOctets(), maxIp.getOctets())) {
throw new IpRangeConflictException(min + " - " + max);
}
com.store();
return 1;
}
/**
* Remove an ip range from a kickstart profile.
* @param loggedInUser The current user
* @param ksLabel the kickstart to remove an ip range from
* @param ipAddress an ip address in the range that you want to remove
* @return 1 on removal, 0 if not found, exception otherwise
*
* @xmlrpc.doc Remove an ip range from a kickstart profile.
* @xmlrpc.param #session_key()
* @xmlrpc.param #param_desc("string", "ksLabel", "The kickstart label of
* the ip range you want to remove")
* @xmlrpc.param #param_desc("string", "ip_address", "An Ip Address that
* falls within the range that you are wanting to remove. The min or max of
* the range will work.")
* @xmlrpc.returntype int - 1 on successful removal, 0 if range wasn't found
* for the specified kickstart, exception otherwise.
*/
public int removeIpRange(User loggedInUser, String ksLabel, String ipAddress) {
if (!loggedInUser.hasRole(RoleFactory.CONFIG_ADMIN)) {
throw new PermissionCheckFailureException();
}
KickstartData ksdata = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartIpRangeFilter filter = new KickstartIpRangeFilter();
for (KickstartIpRange range : ksdata.getIps()) {
if (filter.filterOnRange(ipAddress, range.getMinString(), range
.getMaxString())) {
ksdata.getIps().remove(range);
return 1;
}
}
return 0;
}
/**
* Returns a list for each kickstart profile of activation keys that are present
* in that profile but not the other.
*
* @param loggedInUser The current user
* @param kickstartLabel1 identifies a profile to be compared;
* cannot be <code>null</code>
* @param kickstartLabel2 identifies a profile to be compared;
* cannot be <code>null</code>
*
* @return map of kickstart label to a list of keys in that profile but not in
* the other; if no keys match the criteria the list will be empty
*
* @xmlrpc.doc Returns a list for each kickstart profile; each list will contain
* activation keys not present on the other profile.
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "kickstartLabel1")
* @xmlrpc.param #param("string", "kickstartLabel2")
* @xmlrpc.returntype
* #struct("Comparison Info")
* #prop_desc("array", "kickstartLabel1", "Actual label of the first kickstart
* profile is the key into the struct")
* #array()
* $ActivationKeySerializer
* #array_end()
* #prop_desc("array", "kickstartLabel2", "Actual label of the second kickstart
* profile is the key into the struct")
* #array()
* $ActivationKeySerializer
* #array_end()
* #struct_end()
*/
public Map<String, List<ActivationKey>> compareActivationKeys(User loggedInUser,
String kickstartLabel1,
String kickstartLabel2) {
if (kickstartLabel1 == null) {
throw new IllegalArgumentException("kickstartLabel1 cannot be null");
}
if (kickstartLabel2 == null) {
throw new IllegalArgumentException("kickstartLabel2 cannot be null");
}
// Leverage exisitng handler for key loading
KeysHandler keysHandler = new KeysHandler();
List<ActivationKey> keyList1 =
keysHandler.getActivationKeys(loggedInUser, kickstartLabel1);
List<ActivationKey> keyList2 =
keysHandler.getActivationKeys(loggedInUser, kickstartLabel2);
// Set operations to determine deltas
List<ActivationKey> onlyInKickstart1 = new ArrayList<ActivationKey>(keyList1);
onlyInKickstart1.removeAll(keyList2);
List<ActivationKey> onlyInKickstart2 = new ArrayList<ActivationKey>(keyList2);
onlyInKickstart2.removeAll(keyList1);
// Package up for return
Map<String, List<ActivationKey>> results =
new HashMap<String, List<ActivationKey>>(2);
results.put(kickstartLabel1, onlyInKickstart1);
results.put(kickstartLabel2, onlyInKickstart2);
return results;
}
/**
* Returns a list for each kickstart profile of package names that are present
* in that profile but not the other.
*
* @param loggedInUser The current user
* cannot be <code>null</code>
* @param kickstartLabel1 identifies a profile to be compared;
* cannot be <code>null</code>
* @param kickstartLabel2 identifies a profile to be compared;
* cannot be <code>null</code>
*
* @return map of kickstart label to a list of package names in that profile but not in
* the other; if no keys match the criteria the list will be empty
*
* @xmlrpc.doc Returns a list for each kickstart profile; each list will contain
* package names not present on the other profile.
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "kickstartLabel1")
* @xmlrpc.param #param("string", "kickstartLabel2")
* @xmlrpc.returntype
* #struct("Comparison Info")
* #prop_desc("array", "kickstartLabel1", "Actual label of the first kickstart
* profile is the key into the struct")
* #array_single("string", "package name")
* #prop_desc("array", "kickstartLabel2", "Actual label of the second kickstart
* profile is the key into the struct")
* #array_single("string", "package name")
* #struct_end()
*/
public Map<String, Set<String>> comparePackages(User loggedInUser,
String kickstartLabel1, String kickstartLabel2) {
// Validate parameters
if (kickstartLabel1 == null) {
throw new IllegalArgumentException("kickstartLabel1 cannot be null");
}
if (kickstartLabel2 == null) {
throw new IllegalArgumentException("kickstartLabel2 cannot be null");
}
// Load the profiles and their package lists
KickstartData profile1 =
KickstartFactory.lookupKickstartDataByLabelAndOrgId(kickstartLabel1,
loggedInUser.getOrg().getId());
KickstartData profile2 =
KickstartFactory.lookupKickstartDataByLabelAndOrgId(kickstartLabel2,
loggedInUser.getOrg().getId());
// Set operations to determine deltas
Set<String> onlyInProfile1 = getPackageNamesForKS(profile1);
onlyInProfile1.removeAll(getPackageNamesForKS(profile2));
Set<String> onlyInProfile2 = getPackageNamesForKS(profile2);
onlyInProfile2.removeAll(getPackageNamesForKS(profile1));
// Package for return
Map<String, Set<String>> results = new HashMap<String, Set<String>>(2);
results.put(kickstartLabel1, onlyInProfile1);
results.put(kickstartLabel2, onlyInProfile2);
return results;
}
private Set<String> getPackageNamesForKS(KickstartData ksdata) {
Set<String> toRet = new HashSet<String>();
for (KickstartPackage ksPack : ksdata.getKsPackages()) {
toRet.add(ksPack.getPackageName().getName());
}
return toRet;
}
/**
* Returns a list for each kickstart profile of properties that are different between
* the profiles. Each property that is not equal between the two profiles will be
* present in both lists with the current values for its respective profile.
*
* @param loggedInUser The current user
* cannot be <code>null</code>
* @param kickstartLabel1 identifies a profile to be compared;
* cannot be <code>null</code>
* @param kickstartLabel2 identifies a profile to be compared;
* cannot be <code>null</code>
*
* @return map of kickstart label to a list of properties and their values whose
* values are different for each profile
*
* @xmlrpc.doc Returns a list for each kickstart profile; each list will contain the
* properties that differ between the profiles and their values for that
* specific profile .
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "kickstartLabel1")
* @xmlrpc.param #param("string", "kickstartLabel2")
* @xmlrpc.returntype
* #struct("Comparison Info")
* #prop_desc("array", "kickstartLabel1", "Actual label of the first kickstart
* profile is the key into the struct")
* #array()
* $KickstartOptionValueSerializer
* #array_end()
* #prop_desc("array", "kickstartLabel2", "Actual label of the second kickstart
* profile is the key into the struct")
* #array()
* $KickstartOptionValueSerializer
* #array_end()
* #struct_end()
*/
public Map<String, List<KickstartOptionValue>> compareAdvancedOptions(User loggedInUser,
String kickstartLabel1, String kickstartLabel2) {
// Validate parameters
if (kickstartLabel1 == null) {
throw new IllegalArgumentException("kickstartLabel1 cannot be null");
}
if (kickstartLabel2 == null) {
throw new IllegalArgumentException("kickstartLabel2 cannot be null");
}
// Load the profiles
KickstartData profile1 =
KickstartFactory.lookupKickstartDataByLabelAndOrgId(kickstartLabel1,
loggedInUser.getOrg().getId());
KickstartData profile2 =
KickstartFactory.lookupKickstartDataByLabelAndOrgId(kickstartLabel2,
loggedInUser.getOrg().getId());
// Load the options
KickstartOptionsCommand profile1OptionsCommand =
new KickstartOptionsCommand(profile1.getId(), loggedInUser);
KickstartOptionsCommand profile2OptionsCommand =
new KickstartOptionsCommand(profile2.getId(), loggedInUser);
// Set operations to determine which values are different. The equals method
// of KickstartOptionValue will take the name and value into account, so
// only cases where this tuple is present in both will be removed.
List<KickstartOptionValue> onlyInProfile1 =
profile1OptionsCommand.getDisplayOptions();
onlyInProfile1.removeAll(profile2OptionsCommand.getDisplayOptions());
List<KickstartOptionValue> onlyInProfile2 =
profile2OptionsCommand.getDisplayOptions();
onlyInProfile2.removeAll(profile1OptionsCommand.getDisplayOptions());
// Package for transport
Map<String, List<KickstartOptionValue>> results =
new HashMap<String, List<KickstartOptionValue>>(2);
results.put(kickstartLabel1, onlyInProfile1);
results.put(kickstartLabel2, onlyInProfile2);
return results;
}
private void checkKickstartPerms(User user) {
if (!user.hasRole(RoleFactory.CONFIG_ADMIN)) {
throw new PermissionException(LocalizationService.getInstance()
.getMessage("permission.configadmin.needed"));
}
}
private KickstartData lookupKsData(String label, Org org) {
return XmlRpcKickstartHelper.getInstance().lookupKsData(label, org);
}
/**
* Returns a list of kickstart variables associated with the specified kickstart profile
*
* @param loggedInUser The current user
* cannot be <code>null</code>
* @param ksLabel identifies the kickstart profile
* cannot be <code>null</code>
*
* @return map of kickstart variables associated with the specified kickstart
*
* @xmlrpc.doc Returns a list of variables
* associated with the specified kickstart profile
*
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.returntype
* #struct("kickstart variable")
* #prop("string", "key")
* #prop("string or int", "value")
* #struct_end()
*/
public Map<String, Object> getVariables(User loggedInUser, String ksLabel) {
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
return ksData.getCobblerObject(loggedInUser).getKsMeta();
}
/**
* Associates list of kickstart variables with the specified kickstart profile
*
* @param loggedInUser The current user
* cannot be <code>null</code>
* @param ksLabel identifies the kickstart profile
* cannot be <code>null</code>
* @param variables list of variables to set
*
* @return int - 1 on success, exception thrown otherwise
*
* @xmlrpc.doc Associates list of kickstart variables
* with the specified kickstart profile
*
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.param
* #struct("kickstart variable")
* #prop("string", "key")
* #prop("string or int", "value")
* #struct_end()
* @xmlrpc.returntype #return_int_success()
*/
public int setVariables
(User loggedInUser, String ksLabel, Map<String, Object> variables) {
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
Profile profile = ksData.getCobblerObject(loggedInUser);
profile.setKsMeta(variables);
profile.save();
return 1;
}
/**
* @param loggedInUser The current user
* @param ksLabel identifies the kickstart profile
* @return Array of available OS repositories for provided kickstart profile
* @xmlrpc.doc Lists available OS repositories to associate with the provided
* kickstart profile.
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.returntype #array_single("string", "repositoryLabel")
*/
public String[] getAvailableRepositories(User loggedInUser, String ksLabel) {
if (!loggedInUser.hasRole(RoleFactory.CONFIG_ADMIN)) {
throw new PermissionException(LocalizationService.getInstance()
.getMessage("permission.configadmin.needed"));
}
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartableTree ksTree = ksData.getKickstartDefaults().getKstree();
List<String> repos = new ArrayList<String>();
for (RepoInfo repo : RepoInfo.getStandardRepos(ksTree)) {
if (repo.isAvailable()) {
repos.add(repo.getName());
}
}
return (String[]) repos.toArray(new String[]{});
}
/**
* @param loggedInUser The current user
* @param ksLabel identifies the kickstart profile
* @return Array of available OS repositories
* @xmlrpc.doc Lists all OS repositories associated with provided kickstart profile.
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.returntype #array_single("string", "repositoryLabel")
*/
public String[] getRepositories(User loggedInUser, String ksLabel) {
if (!loggedInUser.hasRole(RoleFactory.CONFIG_ADMIN)) {
throw new PermissionException(LocalizationService.getInstance()
.getMessage("permission.configadmin.needed"));
}
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartableTree ksTree = ksData.getKickstartDefaults().getKstree();
List<String> items = new ArrayList<String>();
if (ksTree != null && !ksTree.getInstallType().isRhel2() &&
!ksTree.getInstallType().isRhel3() &&
!ksTree.getInstallType().isRhel4()) {
Set<RepoInfo> selected = ksData.getRepoInfos();
for (RepoInfo repo : selected) {
items.add(repo.getName());
}
}
return (String[]) items.toArray(new String[]{});
}
/**
* @param loggedInUser The current user
* @param ksLabel ksLabel identifies the kickstart profile
* @param reposIn OS repositories to set
* @return int - 1 on success, exception thrown otherwise
* @xmrpc.doc Associates OS repository to a kickstart profile.
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.param #array_single("string", "repositoryLabel")
* @xmlrpc.returntype #return_int_success()
*/
public int setRepositories(User loggedInUser, String ksLabel, List<String> reposIn) {
if (!loggedInUser.hasRole(RoleFactory.CONFIG_ADMIN)) {
throw new PermissionException(LocalizationService.getInstance()
.getMessage("permission.configadmin.needed"));
}
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
if (ksData.isRhel5OrGreater()) {
List<RepoInfo> repoList = RepoInfo.getStandardRepos(
ksData.getKickstartDefaults().getKstree());
Map<String, RepoInfo> repoSet = new HashMap<String, RepoInfo>();
for (Iterator<RepoInfo> ri = repoList.iterator(); ri.hasNext();) {
RepoInfo rInfo = ri.next();
repoSet.put(rInfo.getName(), rInfo);
}
Set<RepoInfo> selected = new HashSet <RepoInfo>();
for (int i = 0; i < reposIn.size(); i++) {
RepoInfo repoInfo = repoSet.get(reposIn.get(i));
if (repoInfo != null) {
selected.add(repoInfo);
}
}
ksData.setRepoInfos(selected);
KickstartWizardHelper ksHelper = new KickstartWizardHelper(loggedInUser);
ksHelper.processSkipKey(ksData);
}
return 1;
}
/**
* @param loggedInUser The Current user
* @param ksLabel Kickstart profile label
* @return Label of virtualization type for given profile
* @xmlrpc.doc For given kickstart profile label returns label of
* virtualization type it's using
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.returntype #param_desc("string", "virtLabel",
* "Label of virtualization type.")
*/
public String getVirtualizationType(User loggedInUser, String ksLabel) {
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartEditCommand cmd = new KickstartEditCommand(ksData.getId(), loggedInUser);
return cmd.getVirtualizationType().getLabel();
}
/**
* @param loggedInUser The Current user
* @param ksLabel Kickstart profile label
* @param typeLabel virtualization type label
* @return int - 1 on success, exception thrown otherwise
* @xmlrpc.doc For given kickstart profile label sets its virtualization type.
* @xmlrpc.param #param("string", "sessionKey")
* @xmlrpc.param #param("string", "ksLabel")
* @xmlrpc.param #param_desc("string", "typeLabel", "One of the following: 'none',
* 'qemu', 'para_host', 'xenpv', 'xenfv'")
* @xmlrpc.returntype #return_int_success()
*/
public int setVirtualizationType(User loggedInUser, String ksLabel, String typeLabel) {
KickstartData ksData = lookupKsData(ksLabel, loggedInUser.getOrg());
KickstartEditCommand cmd = new KickstartEditCommand(ksData.getId(), loggedInUser);
cmd.setVirtualizationType(KickstartFactory.
lookupKickstartVirtualizationTypeByLabel(typeLabel));
cmd.store();
return 1;
}
}