/**
* Create a one time activation key for use with a kickstart
*
* @param creator of the key
* @param ksdata associated with the key
* @param server being kickstarted (can be null)
* @param session associated with the kickstart (NOT NULL)
* @param note to add to key
* @param usageLimit to apply to the key. null for unlimited.
* @return ActivationKey that has been saved to the DB.
*/
public static ActivationKey createKickstartActivationKey(
User creator,
KickstartData ksdata,
Server server,
KickstartSession session,
Long usageLimit,
String note) {
// Now create ActivationKey
ActivationKey key =
ActivationKeyManager.getInstance().createNewReActivationKey(creator, server, note, session);
key.addEntitlement(ServerConstants.getServerGroupTypeProvisioningEntitled());
key.setDeployConfigs(false);
key.setUsageLimit(usageLimit);
if (KickstartVirtualizationType.paraHost()
.equals(ksdata.getKickstartDefaults().getVirtualizationType())) {
// we'll have to setup the key for virt
key.addEntitlement(ServerConstants.getServerGroupTypeVirtualizationEntitled());
}
ActivationKeyFactory.save(key);
// Add child channels to the key
if (ksdata.getChildChannels() != null && ksdata.getChildChannels().size() > 0) {
Iterator i = ksdata.getChildChannels().iterator();
log.debug("Add the child Channels");
while (i.hasNext()) {
key.addChannel((Channel) i.next());
}
}
log.debug("** Saving new token");
ActivationKeyFactory.save(key);
log.debug("** Saved new token: " + key.getId());
return key;
}
public void testKeyGeneration() throws Exception {
ActivationKey k = createTestActivationKey(user);
String note = k.getNote();
String key = k.getKey();
TestUtils.saveAndFlush(k);
ActivationKey k2 = ActivationKeyFactory.lookupByKey(key);
assertEquals(key, k2.getKey());
assertEquals(note, k2.getNote());
ActivationKey k3 = ActivationKeyFactory.lookupByKey(TestUtils.randomString());
assertNull(k3);
// Make sure we got the entitlements correct
Server server = k2.getServer();
assertEquals(1, server.getEntitlements().size());
assertEquals(1, k2.getEntitlements().size());
Entitlement e = server.getEntitlements().iterator().next();
ServerGroupType t2 = k2.getEntitlements().iterator().next();
assertEquals(e.getLabel(), t2.getLabel());
// test out ActivationKeyManager.findByServer while we're here...
ActivationKey k4 =
ActivationKeyManager.getInstance().findByServer(server, user).iterator().next();
assertNotNull(k4);
assertEquals(key, k4.getKey());
try {
k3 = ActivationKeyManager.getInstance().findByServer(null, user).iterator().next();
String msg =
"Permission check failed :(.."
+ " Activation key should not have existed"
+ " for a server of 'null' id. An exception "
+ "should have been raised for this.";
fail(msg);
} catch (Exception ie) {
// great!.. Exception for passing in invalid keys always welcome
}
User user1 = UserTestUtils.findNewUser("testuser", "testorg");
Server server2 = ServerFactoryTest.createTestServer(user1);
try {
k3 = ActivationKeyManager.getInstance().findByServer(server2, user1).iterator().next();
String msg =
"Permission check failed :(.."
+ " Activation key should not have existed"
+ " for a server of the associated id. An exception "
+ "should have been raised for this.";
fail(msg);
} catch (Exception ie) {
// great!.. Exception for passing in invalid keys always welcome
}
}
public void testLookupBySession() throws Exception {
// Still have that weird error creating a test server
// sometimes in hosted.
ActivationKey k = createTestActivationKey(user);
KickstartData ksdata = KickstartDataTest.createKickstartWithOptions(k.getOrg());
KickstartFactory.saveKickstartData(ksdata);
KickstartSession sess = KickstartSessionTest.createKickstartSession(ksdata, k.getCreator());
KickstartFactory.saveKickstartSession(sess);
k.setKickstartSession(sess);
ActivationKeyFactory.save(k);
k = (ActivationKey) reload(k);
ActivationKey lookedUp = ActivationKeyFactory.lookupByKickstartSession(sess);
assertNotNull(lookedUp);
}
public static ActivationKey createTestActivationKey(User u, Server s) {
String note = "" + TestUtils.randomString() + " -- Java unit test activation key.";
ActivationKey key = ActivationKeyManager.getInstance().createNewReActivationKey(u, s, note);
ActivationKeyFactory.save(key);
return key;
}
private void storeActivationKeyInfo() {
// If the target system exists already, remove any existing activation keys
// it might have associated with it.
log.debug("** ActivationType : Existing profile..");
if (getTargetServer() != null) {
List oldkeys = ActivationKeyFactory.lookupByServer(getTargetServer());
if (oldkeys != null) {
log.debug("** Removing old tokens");
Iterator i = oldkeys.iterator();
while (i.hasNext()) {
log.debug("removing key.");
ActivationKey oldkey = (ActivationKey) i.next();
ActivationKeyFactory.removeKey(oldkey);
}
}
}
String note = null;
if (getTargetServer() != null) {
note =
LocalizationService.getInstance()
.getMessage("kickstart.session.newtokennote", getTargetServer().getName());
} else {
// TODO: translate this
note = "Automatically generated activation key.";
}
RegistrationType regType = getKsdata().getRegistrationType(user);
if (regType.equals(RegistrationType.REACTIVATION)) {
// Create a new activation key for the target system.
boolean reactivation = RegistrationType.REACTIVATION.equals(regType);
createKickstartActivationKey(
this.user,
this.ksdata,
reactivation ? getTargetServer() : null,
this.kickstartSession,
1L,
note);
}
this.createdProfile = processProfileType(this.profileType);
log.debug("** profile created: " + createdProfile);
}
public void testLookupByServer() throws Exception {
ActivationKey k = createTestActivationKey(user);
Server s = k.getServer();
createTestActivationKey(user, s);
createTestActivationKey(user, s);
createTestActivationKey(user, s);
List keys = ActivationKeyFactory.lookupByServer(s);
assertTrue(keys.size() == 4);
}
public void testDeployConfig() throws Exception {
UserTestUtils.addUserRole(user, RoleFactory.ACTIVATION_KEY_ADMIN);
// need a tools channel for config deploy
Channel base = ChannelTestUtils.createBaseChannel(user);
ChannelTestUtils.setupBaseChannelForVirtualization(user, base);
ActivationKey key = createActivationKey();
// Create a config channel
ConfigChannel cc = ConfigTestUtils.createConfigChannel(user.getOrg());
ConfigChannelListProcessor proc = new ConfigChannelListProcessor();
proc.add(key.getConfigChannelsFor(user), cc);
key.setDeployConfigs(true);
ActivationKeyFactory.save(key);
assertTrue(key.getDeployConfigs());
assertFalse(key.getChannels().isEmpty());
assertFalse(key.getPackages().isEmpty());
}
public void testNullServer() throws Exception {
ActivationKey key = ActivationKeyFactory.createNewKey(user, TestUtils.randomString());
assertNotNull(key.getEntitlements());
assertTrue(key.getEntitlements().size() == 1);
}
protected void updateCloneDetails(KickstartData cloned, User user, String newLabel) {
cloned.setLabel(newLabel);
cloned.setActive(this.isActive());
cloned.setPostLog(this.getPostLog());
cloned.setPreLog(this.getPreLog());
cloned.setKsCfg(this.getKsCfg());
cloned.setComments(this.getComments());
cloned.setNonChrootPost(this.getNonChrootPost());
cloned.setVerboseUp2date(this.getVerboseUp2date());
cloned.setOrg(this.getOrg());
cloned.setChildChannels(new HashSet<Channel>(this.getChildChannels()));
cloned.setPartitionData(getPartitionData());
copyKickstartCommands(getCommands(), cloned);
// Gotta remember to create a new HashSet with
// the other objects. Otherwise hibernate will
// complain that you are using the same collection
// in two objects.
if (this.getCryptoKeys() != null) {
cloned.setCryptoKeys(new HashSet<CryptoKey>(this.getCryptoKeys()));
}
// NOTE: Make sure we *DONT* clone isOrgDefault
cloned.setIsOrgDefault(Boolean.FALSE);
cloned.setKernelParams(this.getKernelParams());
if (this.getKickstartDefaults() != null) {
cloned.setKickstartDefaults(this.getKickstartDefaults().deepCopy(cloned));
}
cloned.setOrg(this.getOrg());
if (this.getKsPackages() != null) {
for (KickstartPackage kp : this.getKsPackages()) {
cloned.getKsPackages().add(kp.deepCopy(cloned));
}
}
if (this.getPreserveFileLists() != null) {
cloned.setPreserveFileLists(new HashSet<FileList>(this.getPreserveFileLists()));
}
if (this.getScripts() != null) {
Iterator<KickstartScript> i = this.getScripts().iterator();
while (i.hasNext()) {
KickstartScript kss = i.next();
KickstartScript ksscloned = kss.deepCopy(cloned);
cloned.getScripts().add(ksscloned);
}
}
// copy all of the non-session related kickstarts
Set<Token> newTokens = new HashSet<Token>();
if (this.getDefaultRegTokens() != null) {
for (Token tok : this.getDefaultRegTokens()) {
ActivationKey key = ActivationKeyFactory.lookupByToken(tok);
if (key == null || key.getKickstartSession() == null) {
newTokens.add(tok);
}
}
}
cloned.setDefaultRegTokens(newTokens);
cloned.setNoBase(this.getNoBase());
cloned.setIgnoreMissing(this.getIgnoreMissing());
}