/**
   * 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);
 }
Esempio n. 9
0
  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());
  }