public void SetUserSeat(UserBE user, LicenseData license)
{
if (!IsSeatLicensingEnabled(license))
{
throw new MindTouchLicenseSeatLicensingNotInUseException();
}
if (_userBL.IsAnonymous(user))
{
throw new MindTouchLicenseAnonymousSeat();
}
if (user.LicenseSeat)
{
// giving a seat to a seated user is not an error
_log.DebugFormat("user {0} already has a seat license", user.ID);
return;
}
if (AreSeatsExceedingLicense(license))
{
throw new MindTouchLicenseInsufficientSeatsException(GetSeatsLicensed(license));
}
_log.DebugFormat("settings licenseSeat to true for user {0}", user.ID);
user.LicenseSeat = true;
_userBL.UpdateUser(user);
// ensure that another server or thread hasn't concurrently granted a seat thus going over the limit.
// Both seats may potentially be revoked.
if (AreSeatsExceedingLicense(license))
{
RemoveSeatFromUserInternal(user, license);
throw new MindTouchLicenseInsufficientSeatsException(GetSeatsLicensed(license));
}
_log.InfoFormat("Seat licensing: Granted a seat to '{0}'", user.Name);
}
public void SetOwnerUserSeat(LicenseData checkedLicense)
{
// Give a seat to the site owner if they don't already have one (the owner id has already been validated)
var ownerUserId = GetSiteOwnerUserId(checkedLicense) ?? 0;
if (ownerUserId == 0)
{
_log.Warn("Unable to assign a seat to the owner since it was not defined in the license");
return;
}
var siteOwner = _userBL.GetUserById((uint)ownerUserId);
if (siteOwner == null)
{
_log.Warn(String.Format("Unable to look up site owner user id '{0}'", ownerUserId));
return;
}
SetUserSeat(siteOwner, checkedLicense);
// reset current user to reflect seat status of owner
if (_userContext.User != null && _userContext.User.ID == siteOwner.ID)
{
_userContext.User = siteOwner;
}
}
protected LicenseData HandleLicenseTransition(XDoc licenseDoc, LicenseData currentLicense, ISeatingBL seatingBL, ILicenseBL licenseBL) {
var seatingEnabledInNewLicense = seatingBL.IsSeatLicensingEnabled(licenseDoc);
var tempLicense = licenseBL.BuildLicenseData(licenseDoc, true, seatingEnabledInNewLicense);
var newLicense = licenseBL.ValidateNewLicenseTransition(tempLicense, currentLicense);
_log.DebugFormat("new license with state '{0}' has passed validation and will be accepted", newLicense.LicenseState);
// Ensure that all seats are cleared if seat licensing is disabled.
// This will allow a known clean seat state if it becomes enabled.
if(!seatingBL.IsSeatLicensingEnabled(currentLicense)) {
_log.Debug("old license did not have seat licensing");
seatingBL.RevokeSeats(currentLicense);
}
// Seat licensing
if(seatingEnabledInNewLicense) {
var seats = seatingBL.HandleSeatTransition(licenseDoc);
if(seats.Assigned > seats.Allowed) {
HandleExcessSeats(currentLicense, seatingBL, seats);
}
// set a seat for the owner
seatingBL.SetOwnerUserSeat(newLicense);
} else {
_log.Debug("new license does not contain seat licensing");
// Clear the seat state when going to non-seat license
seatingBL.RevokeSeats(newLicense);
}
_log.DebugFormat("transitioned license from '{0}' to '{1}'", currentLicense.LicenseState, newLicense.LicenseState);
return newLicense;
}
public void RemoveSeatFromUser(UserBE user, LicenseData licenseData)
{
if (!IsSeatLicensingEnabled(licenseData))
{
throw new MindTouchLicenseSeatLicensingNotInUseException();
}
RemoveSeatFromUserInternal(user, licenseData);
}
public static bool AreSame(this LicenseData a, LicenseData b) {
return a.LicenseExpiration == b.LicenseExpiration
&& a.LicenseState == b.LicenseState
&& a.LicenseStateChecked == b.LicenseStateChecked
&& a.SiteOwnerUserId == b.SiteOwnerUserId
&& a.AnonymousPermissions == b.AnonymousPermissions
&& a.LicenseDoc == b.LicenseDoc;
}
//--- Methods ---
public virtual LicenseData UpdateLicense(XDoc license, LicenseData currentLicense, ILicenseBL licenseBL, ISeatingBL seatingBL) {
licenseBL.Validate(license);
// Only site owner of a license can upload a license that has seat licensing enabled.
seatingBL.ValidateLicenseUpdateUser(license);
var newLicense = HandleLicenseTransition(license, currentLicense, seatingBL, licenseBL);
_licenseStoragePlug.At(_wikiId, LICENSE_FILE).Put(license);
return newLicense;
}
//--- Constructors ---
public LicenseManager(ILicenseController licenseController, IUserBL userBL, LicenseData licenseData, ILicenseBL licenseBL, IInstanceSettings settings, ISeatingBL seatingBL, LicenseStateTransitionCallback licenseStateTransitionCallback)
{
_licenseController = licenseController;
_userBL = userBL;
_licenseData = licenseData;
_licenseBL = licenseBL;
_settings = settings;
_seatingBL = seatingBL;
_licenseStateTransitionCallback = licenseStateTransitionCallback;
}
public ulong?GetSiteOwnerUserId(LicenseData license)
{
if (IsSeatLicensingEnabled(license))
{
if (license.SiteOwnerUserId == null)
{
_log.Warn("Seat licensing is enabled but no site owner is defined.");
}
return(license.SiteOwnerUserId);
}
return(null);
}
private bool AreSeatsExceedingLicense(LicenseData license)
{
// enforce seat licensing limits
var seatsAssigned = GetSeatedUsers().Count();
var seatsAllowed = GetSeatsLicensed(license);
// ensure a seat is available
if (seatsAllowed < seatsAssigned)
{
_log.Warn(String.Format("Seat licensing: Number of seats used is exceeding allowed. Seats allowed: {0}; Seats assigned:{1}", seatsAllowed, seatsAssigned));
return(true);
}
return(false);
}
public void RevokeSeats(LicenseData license)
{
var ownerUserId = GetSiteOwnerUserId(license) ?? 0;
var seatedUsers = GetSeatedUsers().Where(u => u.ID != ownerUserId).ToArray();
foreach (var u in seatedUsers)
{
RemoveSeatFromUserInternal(u, license);
}
if (seatedUsers.Any())
{
_log.Warn(String.Format("Seat licensing: Revoked {0} seats from users", seatedUsers.Count()));
}
}
public override LicenseData VerifyLicenseData(LicenseData licenseData, ILicenseBL licenseBL, ISeatingBL seatingBL)
{
_log.Debug("verifying license: " + licenseData.LicenseState);
// load authoritative license from remote
var license = LicenseDoc;
var verified = licenseBL.DetermineLicenseState(new LicenseData().WithLicenseDocument(license), true, seatingBL.IsSeatLicensingEnabled(licenseData));
if (!(new[] { LicenseStateType.COMMERCIAL, LicenseStateType.TRIAL, LicenseStateType.INACTIVE, LicenseStateType.EXPIRED }).Contains(verified.LicenseState))
{
_log.DebugFormat("license state '{0}' is not allowed for remotely managed instances", verified.LicenseState);
throw new MindTouchRemoteLicenseFailedException();
}
_log.Debug("verified license: " + verified.LicenseState);
return(verified);
}
private void RemoveSeatFromUserInternal(UserBE user, LicenseData license)
{
if (!user.LicenseSeat)
{
return;
}
// Site owner may not have their license removed
var siteOwnerUserId = GetSiteOwnerUserId(license) ?? 0;
if (user.ID == siteOwnerUserId)
{
throw new MindTouchLicenseRemovalFromSiteOwnerException();
}
user.LicenseSeat = false;
_userBL.UpdateUser(user);
_log.InfoFormat("Seat licensing: Removed a seat from '{0}'", user.Name);
}
public virtual void UpdateLicense(XDoc currentLicense, XDoc newLicense)
{
LicenseData currentLicenseData;
if (currentLicense == null)
{
currentLicenseData = LicenseData.Clone();
}
else
{
var tempLicense = new LicenseData().WithLicenseDocument(currentLicense);
currentLicenseData = _licenseBL.DetermineLicenseState(tempLicense, false, _seatingBL.IsSeatLicensingEnabled(tempLicense));
}
lock (_sync) {
var updated = _licenseController.UpdateLicense(newLicense, currentLicenseData, _licenseBL, _seatingBL).Checked(DateTime.UtcNow);
_settings.ClearConfigCache();
_licenseData.Update(updated);
_licenseStateTransitionCallback(currentLicenseData, updated);
}
_log.DebugFormat("license updated to state {0} and last checked date {1}", _licenseData.LicenseState, _licenseData.LicenseStateChecked);
}
//--- Methods ---
public void Update(LicenseData licenseData)
{
_data = licenseData._data;
}
protected override void HandleExcessSeats(LicenseData license, ISeatingBL seatingBL, SeatAssignmentInfo seats)
{
_log.WarnFormat("site '{0}' has {1} assigned seats, but is only licensed for {2} (not revoking)", _wikiId, seats.Assigned, seats.Allowed);
}
public static bool AreSameDoc(this LicenseData a, LicenseData b) {
return a.LicenseDoc == b.LicenseDoc;
}
//--- Methods ---
public override LicenseData UpdateLicense(XDoc license, LicenseData currentLicense, ILicenseBL licenseBL, ISeatingBL seatingBL)
{
_log.DebugFormat("updating license from '{1}' to '{0}'", license["@type"].Contents, currentLicense.LicenseState);
licenseBL.Validate(license);
return(HandleLicenseTransition(license, currentLicense, seatingBL, licenseBL));
}
protected virtual void HandleExcessSeats(LicenseData license, ISeatingBL seatingBL, SeatAssignmentInfo seats) {
_log.WarnFormat("site has {0} assigned seats, but is only licensed for {1} (revoking seats)", seats.Assigned, seats.Allowed);
seatingBL.RevokeSeats(license);
}
private int GetSeatsLicensed(LicenseData license)
{
return(_licenseBL.GetSeatsLicensed(license.LicenseDoc));
}
public virtual LicenseData VerifyLicenseData(LicenseData licenseData, ILicenseBL licenseBL, ISeatingBL seatingBL) {
if(licenseData.LicenseDoc.IsEmpty) {
licenseData = licenseData.WithLicenseDocument(LicenseDoc);
}
return licenseBL.DetermineLicenseState(licenseData, true, seatingBL.IsSeatLicensingEnabled(licenseData));
}
public bool IsSeatLicensingEnabled(LicenseData license)
{
return(IsSeatLicensingEnabled(license.LicenseDoc));
}
