private void Validate(string license)
        {
            if (_validator != null)
            {
                try
                {
                    _validator.AssertValidLicense();

                    Logger.InfoFormat("Found a {0} license.", _validator.LicenseType);
                    Logger.InfoFormat("Registered to {0}", _validator.Name);
                    Logger.InfoFormat("Expires on {0}", _validator.ExpirationDate);
                    if ((_validator.LicenseAttributes != null) && (_validator.LicenseAttributes.Count > 0))
                    {
                        foreach (var licenseAttribute in _validator.LicenseAttributes)
                        {
                            Logger.InfoFormat("[{0}]: [{1}]", licenseAttribute.Key, licenseAttribute.Value);
                        }
                    }

                    ValidateLicenseVersion();
                    CreateLicense();
                    StoreLicense(license);
                }
                catch (InvalidLicenseException)
                {
                    TrialExpired = true;
                    Logger.Info("Suitable license was not found");
                }
                catch (LicenseExpiredException)
                {
                    TrialExpired = true;
                    Logger.Info("License has expired.");
                }
                catch (LicenseNotFoundException)
                {
                    Logger.Info("License could not be loaded.");
                }
                catch (LicenseFileNotFoundException)
                {
                    Logger.Info("License could not be loaded.");
                }
            }

            if (CurrentLicense == null)
            {
                Logger.Info("No valid license found.");
                CreateTrialLicense();
                ValidateTrialStartDate();
            }
        }
Example #2
0
        private void Validate()
        {
            if (validator != null)
            {
                try
                {
                    validator.AssertValidLicense();

                    Logger.InfoFormat("Found a {0} license.", validator.LicenseType);
                    Logger.InfoFormat("Registered to {0}", validator.Name);
                    Logger.InfoFormat("Expires on {0}", validator.ExpirationDate);
                    if ((validator.LicenseAttributes != null) && (validator.LicenseAttributes.Count > 0))
                    {
                        foreach (var licenseAttribute in validator.LicenseAttributes)
                        {
                            Logger.InfoFormat("[{0}]: [{1}]", licenseAttribute.Key, licenseAttribute.Value);
                        }
                    }

                    CheckIfNServiceBusVersionIsNewerThanLicenseVersion();

                    ConfigureNServiceBusLicense();

                    return;
                }
                catch (LicenseExpiredException)
                {
                    trialPeriodHasExpired = true;
                    Logger.Error("License has expired.");
                }
                catch (LicenseNotFoundException)
                {
                    Logger.Error("License could not be loaded.");
                }
                catch (LicenseFileNotFoundException)
                {
                    Logger.Error("License could not be loaded.");
                }

                Logger.Warn("Falling back to run in Basic1 license mode.");
                RunInBasic1Mode(DateTime.UtcNow);

                return;
            }

            Logger.Info("No valid license found.");
            ConfigureNServiceBusToRunInTrialMode();
        }
Example #3
0
        private void ExecuteInternal(InMemoryRavenConfiguration config)
        {
            var licensePath = GetLicensePath(config);
            var licenseText = GetLicenseText(config);

            if (TryLoadLicense(licenseText) == false)
            {
                return;
            }

            try
            {
                licenseValidator.AssertValidLicense(() =>
                {
                    string value;

                    LicenseAttributes = licenseValidator.LicenseAttributes;

                    AssertForV2(licenseValidator.LicenseAttributes);
                    if (licenseValidator.LicenseAttributes.TryGetValue("OEM", out value) &&
                        "true".Equals(value, StringComparison.InvariantCultureIgnoreCase))
                    {
                        licenseValidator.MultipleLicenseUsageBehavior = AbstractLicenseValidator.MultipleLicenseUsage.AllowSameLicense;
                    }
                });

                CurrentLicense = new LicensingStatus
                {
                    Status  = "Commercial - " + licenseValidator.LicenseType,
                    Error   = false,
                    Message = "Valid license at " + licensePath
                };
            }
            catch (Exception e)
            {
                logger.ErrorException("Could not validate license at " + licensePath + ", " + licenseText, e);

                CurrentLicense = new LicensingStatus
                {
                    Status  = "AGPL - Open Source",
                    Error   = true,
                    Message = "Could not validate license: " + licensePath + ", " + licenseText + Environment.NewLine + e
                };
            }
        }
Example #4
0
        private void Validate()
        {
            if (validator != null)
            {
                try
                {
                    validator.AssertValidLicense();

                    tracer.Info((string)"Found a {0} license.", (object)validator.LicenseType);
                    tracer.Info((string)"Registered to {0}", (object)validator.Name);
                    tracer.Info((string)"Expires on {0}", (object)validator.ExpirationDate);

                    CheckIfStudioVersionIsNewerThanLicenseVersion();

                    ConfigureStudioLicense();

                    return;
                }
                catch (LicenseExpiredException)
                {
                    trialPeriodHasExpired = true;
                    tracer.Error("License has expired.");
                }
                catch (LicenseNotFoundException)
                {
                    tracer.Error("License could not be loaded.");
                }
                catch (LicenseFileNotFoundException)
                {
                    tracer.Error("License could not be loaded.");
                }

                return;
            }

            tracer.Info("No valid license found.");
            ConfigureStudioToRunInTrialMode();
        }
Example #5
0
        private void ExecuteInternal(InMemoryRavenConfiguration config, bool firstTime = false, bool forceUpdate = false)
        {
            var licensePath = GetLicensePath(config);
            var licenseText = GetLicenseText(config);

            if (TryLoadLicense(config) == false)
            {
                return;
            }

            string errorMessage = string.Empty;

            try
            {
                try
                {
                    licenseValidator.AssertValidLicense(() =>
                    {
                        string value;

                        errorMessage = AssertLicenseAttributes(licenseValidator.LicenseAttributes, licenseValidator.LicenseType);
                        if (licenseValidator.LicenseAttributes.TryGetValue("OEM", out value) &&
                            "true".Equals(value, StringComparison.OrdinalIgnoreCase))
                        {
                            licenseValidator.MultipleLicenseUsageBehavior = AbstractLicenseValidator.MultipleLicenseUsage.AllowSameLicense;
                        }
                        string allowExternalBundles;
                        if (licenseValidator.LicenseAttributes.TryGetValue("allowExternalBundles", out allowExternalBundles) &&
                            bool.Parse(allowExternalBundles) == false)
                        {
                            var directoryCatalogs = config.Catalog.Catalogs.OfType <DirectoryCatalog>().ToArray();
                            foreach (var catalog in directoryCatalogs)
                            {
                                config.Catalog.Catalogs.Remove(catalog);
                            }
                        }
                    }, config.TurnOffDiscoveryClient, firstTime, forceUpdate);
                }
                catch (LicenseExpiredException ex)
                {
                    errorMessage = ex.Message;
                }

                var attributes = new Dictionary <string, string>(alwaysOnAttributes, StringComparer.OrdinalIgnoreCase);
                foreach (var licenseAttribute in licenseValidator.LicenseAttributes)
                {
                    attributes[licenseAttribute.Key] = licenseAttribute.Value;
                }

                var message = "Valid license at " + licensePath;
                var status  = "Commercial";
                if (licenseValidator.LicenseType != LicenseType.Standard)
                {
                    status += " - " + licenseValidator.LicenseType;
                }

                if (licenseValidator.IsOemLicense() && licenseValidator.ExpirationDate < SystemTime.UtcNow)
                {
                    message = string.Format("Expired ({0}) OEM/ISV license at {1}", licenseValidator.ExpirationDate.ToShortDateString(), licensePath);
                    status += " (Expired)";
                }

                CurrentLicense = new LicensingStatus
                {
                    Status     = status,
                    Error      = !String.IsNullOrEmpty(errorMessage),
                    Message    = String.IsNullOrEmpty(errorMessage) ? message : errorMessage,
                    Attributes = attributes
                };
            }
            catch (Exception e)
            {
                logger.ErrorException("Could not validate license at " + licensePath + ", " + licenseText, e);

                try
                {
                    var xmlDocument = new XmlDocument();
                    xmlDocument.Load(licensePath);
                    var ns = new XmlNamespaceManager(xmlDocument.NameTable);
                    ns.AddNamespace("sig", "http://www.w3.org/2000/09/xmldsig#");
                    var sig = xmlDocument.SelectSingleNode("/license/sig:Signature", ns);
                    if (sig != null)
                    {
                        sig.RemoveAll();
                    }
                    licenseText = xmlDocument.InnerXml;
                }
                catch (Exception)
                {
                    // couldn't remove the signature, maybe not XML?
                }

                CurrentLicense = new LicensingStatus
                {
                    Status     = "AGPL - Open Source",
                    Error      = true,
                    Details    = "License Path: " + licensePath + Environment.NewLine + ", License Text: " + licenseText + Environment.NewLine + ", Exception: " + e,
                    Message    = "Could not validate license: " + e.Message,
                    Attributes = new Dictionary <string, string>(alwaysOnAttributes, StringComparer.OrdinalIgnoreCase)
                };
            }
        }
Example #6
0
        private void ExecuteInternal(InMemoryRavenConfiguration config)
        {
            var licensePath = GetLicensePath(config);
            var licenseText = GetLicenseText(config);

            if (TryLoadLicense(licenseText) == false)
            {
                return;
            }

            try
            {
                licenseValidator.AssertValidLicense(() =>
                {
                    string value;

                    AssertForV2(licenseValidator.LicenseAttributes);
                    if (licenseValidator.LicenseAttributes.TryGetValue("OEM", out value) &&
                        "true".Equals(value, StringComparison.OrdinalIgnoreCase))
                    {
                        licenseValidator.MultipleLicenseUsageBehavior = AbstractLicenseValidator.MultipleLicenseUsage.AllowSameLicense;
                    }
                    string allowExternalBundles;
                    if (licenseValidator.LicenseAttributes.TryGetValue("allowExternalBundles", out allowExternalBundles) &&
                        bool.Parse(allowExternalBundles) == false)
                    {
                        var directoryCatalogs = config.Catalog.Catalogs.OfType <DirectoryCatalog>().ToArray();
                        foreach (var catalog in directoryCatalogs)
                        {
                            config.Catalog.Catalogs.Remove(catalog);
                        }
                    }
                });

                var attributes = new Dictionary <string, string>(alwaysOnAttributes, StringComparer.OrdinalIgnoreCase);
                foreach (var licenseAttribute in licenseValidator.LicenseAttributes)
                {
                    attributes[licenseAttribute.Key] = licenseAttribute.Value;
                }

                CurrentLicense = new LicensingStatus
                {
                    Status     = "Commercial - " + licenseValidator.LicenseType,
                    Error      = false,
                    Message    = "Valid license at " + licensePath,
                    Attributes = attributes
                };
            }
            catch (Exception e)
            {
                logger.ErrorException("Could not validate license at " + licensePath + ", " + licenseText, e);

                try
                {
                    var xmlDocument = new XmlDocument();
                    xmlDocument.LoadXml(licensePath);
                    var sig = xmlDocument.SelectSingleNode("/license/Signature");
                    if (sig != null && sig.ParentNode != null)
                    {
                        sig.ParentNode.RemoveChild(sig);
                    }
                    var stringBuilder = new StringBuilder();
                    xmlDocument.WriteTo(XmlWriter.Create(stringBuilder));
                    licenseText = stringBuilder.ToString();
                }
                catch (Exception)
                {
                    // couldn't remove the signature, maybe not XML?
                }

                CurrentLicense = new LicensingStatus
                {
                    Status     = "AGPL - Open Source",
                    Error      = true,
                    Message    = "Could not validate license: " + licensePath + ", " + licenseText + Environment.NewLine + e,
                    Attributes = new Dictionary <string, string>(alwaysOnAttributes, StringComparer.OrdinalIgnoreCase)
                };
            }
        }
Example #7
0
        public void Execute(DocumentDatabase database)
        {
            string publicKey;

            using (var stream = typeof(ValidateLicense).Assembly.GetManifestResourceStream("Raven.Database.Commercial.RavenDB.public"))
            {
                if (stream == null)
                {
                    throw new InvalidOperationException("Could not find public key for the license");
                }
                publicKey = new StreamReader(stream).ReadToEnd();
            }

            var licensePath = GetLicensePath(database);
            var licenseText = GetLicenseText(database);

            licenseValidator = new StringLicenseValidator(publicKey, licenseText)
            {
                DisableFloatingLicenses = true,
            };
            licenseValidator.LicenseInvalidated             += LicenseValidatorOnLicenseInvalidated;
            licenseValidator.MultipleLicensesWereDiscovered += LicenseValidatorOnMultipleLicensesWereDiscovered;

            if (string.IsNullOrEmpty(licenseText))
            {
                CurrentLicense = new LicensingStatus
                {
                    Status  = "AGPL - Open Source",
                    Error   = false,
                    Message = "No license file was found at " + licenseText +
                              "\r\nThe AGPL license restrictions apply, only Open Source / Development work is permitted."
                };
                return;
            }

            try
            {
                licenseValidator.AssertValidLicense(() =>
                {
                    string value;
                    if (licenseValidator.LicenseAttributes.TryGetValue("OEM", out value) &&
                        "true".Equals(value, StringComparison.InvariantCultureIgnoreCase))
                    {
                        licenseValidator.MultipleLicenseUsageBehavior = AbstractLicenseValidator.MultipleLicenseUsage.AllowSameLicense;
                    }
                });


                CurrentLicense = new LicensingStatus
                {
                    Status  = "Commercial - " + licenseValidator.LicenseType,
                    Error   = false,
                    Message = "Valid license at " + licensePath
                };
            }
            catch (Exception e)
            {
                logger.ErrorException("Could not validate license at " + licensePath + ", " + licenseText, e);

                CurrentLicense = new LicensingStatus
                {
                    Status  = "AGPL - Open Source",
                    Error   = true,
                    Message = "Could not validate license: " + licensePath + ", " + licenseText + Environment.NewLine + e
                };
            }
        }