Example #1
0
        public static void Start()
        {
            CurrentLicenses = OnlineCatalogLicenses.FromLicenseFile();

            PendingClientLicenseRequests = new PendingClientLicenseRequests();
            ActivedLicenses   = new PendingClientLicenseRequests();
            AvailableLicenses = new AvailableLicenses();
            DAL.Managers.ConnectionManager.AtumClientLicenseResponse += ConnectionManager_AtumClientLicenseResponse;

            _licenseRequestPoller          = new Timer();
            _licenseRequestPoller.Interval = 2000;
            _licenseRequestPoller.Tick    += _licenseRequestPoller_Tick;
            //  _licenseRequestPoller.Start();
        }
Example #2
0
        public static void ConnectionManager_AtumClientLicenseResponse(PendingClientLicenseResponse clientLicenseResponse)
        {
            lock (PendingClientLicenseRequests)
            {
                foreach (var pendingLicense in PendingClientLicenseRequests)
                {
                    if (pendingLicense.Id == clientLicenseResponse.Id)
                    {
                        if (!ActivedLicenses.Exists(s => s.Id == pendingLicense.Id))
                        {
                            ActivedLicenses.Add(pendingLicense);
                        }

                        PendingClientLicenseRequests.Remove(pendingLicense);
                        DAL.Managers.LoggingManager.WriteToLog("License Manager", "Pending License: " + clientLicenseResponse.LicenseType.ToString(), "Removed");
                        break;
                    }
                }
            }

            lock (AvailableLicenses)
            {
                var currentLicenseFound = false;
                foreach (var availableLicense in AvailableLicenses)
                {
                    if (availableLicense.LicenseType == clientLicenseResponse.LicenseType)
                    {
                        currentLicenseFound             = true;
                        availableLicense.ExpirationDate = availableLicense.ExpirationDate.AddHours(4);
                        DAL.Managers.LoggingManager.WriteToLog("License Manager", "License: " + clientLicenseResponse.LicenseType.ToString(), "EndsOn Timestamp updated");

                        PendingLicensesChanged?.Invoke(null, null);
                        break;
                    }
                }

                if (!currentLicenseFound)
                {
                    AvailableLicenses.Add(new AvailableLicense()
                    {
                        Activated = true, ExpirationDate = DateTime.Now.AddDays(1), LicenseType = clientLicenseResponse.LicenseType
                    });
                    DAL.Managers.LoggingManager.WriteToLog("License Manager", "License: " + clientLicenseResponse.LicenseType.ToString(), "Added");

                    AvailableLicensesChanged?.Invoke(null, null);
                }
            }
        }
Example #3
0
        public static void Start()
        {
            //obsolete timer start
            tmrObsoleteLicenses.Interval = 300000;
            tmrObsoleteLicenses.Elapsed += TmrObsoleteLicenses_Elapsed;
            tmrObsoleteLicenses.Start();


            //online licenses
            LicenseServerOnlineCatalogManager.OnCatalogLicensesFetched += OnCatalogLicensesFetched;

            ConnectionManager.Start(11006, false);
            ConnectionManager.AtumClientLicenseRequest       += ConnectionManager_AtumClientLicenseRequest;
            ConnectionManager.AtumClientRemoveLicenseRequest += ConnectionManager_AtumClientRemoveLicenseRequest;


            AvailableLicenses = new AvailableLicenses();

            //check if previous license file exists then preload them
            if (File.Exists(DAL.ApplicationSettings.Settings.LocalLicenseFilePath))
            {
                var offlineLicenses = OnlineCatalogLicenses.FromLicenseFile();

                if (offlineLicenses != null)
                {
                    foreach (var offlineLicense in offlineLicenses)
                    {
                        if (offlineLicense.Activated && offlineLicense.Amount > 0 && offlineLicense.ExpirationDate >= DateTime.Now)
                        {
                            AvailableLicenses.Add(new AvailableLicense()
                            {
                                Activated      = offlineLicense.Activated,
                                LicenseGUID    = offlineLicense.LicenseGUID,
                                ExpirationDate = offlineLicense.ExpirationDate,
                                LicenseType    = offlineLicense.LicenseType,
                                Amount         = offlineLicense.Amount
                            });
                        }
                    }
                }

                EventLogManager.WriteToEventLog("Offline license(s) found", "Amount " + AvailableLicenses.Count);
            }
        }
Example #4
0
        public static void Stop()
        {
            if (_licenseRequestPoller != null)
            {
                _licenseRequestPoller.Stop();

                PendingClientLicenseRequests.Clear();
                ActivedLicenses.Clear();
                AvailableLicenses.Clear();

                PendingLicensesChanged?.Invoke(null, null);
                AvailableLicensesChanged?.Invoke(null, null);

                if (!string.IsNullOrEmpty(UserProfileManager.UserProfile.LicenseServer_ServerName))
                {
                    var clientRemoveLicenseRequestAsEncodedXml   = new RemoveActiveClientLicenseRequest().ToEncodedXml();
                    var clientEncodedRemoveLicenseRequestMessage = new RemoveActiveClientLicenseRequestMessage();
                    clientEncodedRemoveLicenseRequestMessage.Message = clientRemoveLicenseRequestAsEncodedXml;
                    try
                    {
                        var ipAddresses = Dns.GetHostAddresses(UserProfileManager.UserProfile.LicenseServer_ServerName);
                        if (ipAddresses != null && ipAddresses.Length > 0)
                        {
                            foreach (var ipAddress in ipAddresses)
                            {
                                if (ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                                {
                                    DAL.Managers.ConnectionManager.SendAsXML(clientEncodedRemoveLicenseRequestMessage, ipAddress, 11006);
                                    DAL.Managers.LoggingManager.WriteToLog("License Manager", "Remove active licenses from server", "Send to server: " + ipAddress.ToString());
                                }
                            }
                        }
                    }
                    catch (Exception exc)
                    {
                        DAL.Managers.LoggingManager.WriteToLog("License Manager Error", "Remove active licenses from server", "Send to server (" + exc.Message + ")");
                    }
                }
            }
        }