private void okButton_Click(object sender, EventArgs e)
        {
            okButton.Enabled = false;
            if (enrollmentCheckBox.Checked && newAuthenticationRadioButton.Checked &&
                !m_ctrlError.PerformCheck(CheckUploadAuthentication))
            {
                okButton.Enabled = true;
                return;
            }

            if (ChangesMade())
            {
                var newCallHomeSettings = new CallHomeSettings(
                    enrollmentCheckBox.Checked ? CallHomeStatus.Enabled : CallHomeStatus.Disabled,
                    (int)(frequencyNumericBox.Value * 7),
                    (DayOfWeek)dayOfWeekComboBox.SelectedValue,
                    (int)timeOfDayComboBox.SelectedValue,
                    CallHomeSettings.DefaultRetryInterval);

                new SaveCallHomeSettingsAction(pool, newCallHomeSettings, authenticationToken, textboxXSUserName.Text, textboxXSPassword.Text, false).RunAsync();
                new TransferCallHomeSettingsAction(pool, newCallHomeSettings, textboxXSUserName.Text, textboxXSPassword.Text, true).RunAsync();
            }
            okButton.Enabled = true;
            DialogResult     = DialogResult.OK;
            Close();
        }
 public TransferCallHomeSettingsAction(Pool pool, CallHomeSettings callHomeSettings, string username, string password, bool suppressHistory)
     : base(pool.Connection, Messages.ACTION_TRANSFER_CALLHOME_SETTINGS, string.Format(Messages.ACTION_TRANSFER_CALLHOME_SETTINGS, pool.Name), suppressHistory)
 {
     this.pool = pool;
     this.callHomeSettings = callHomeSettings;
     this.username = username;
     this.password = password;
 }
Example #3
0
 public TransferCallHomeSettingsAction(Pool pool, CallHomeSettings callHomeSettings, string username, string password, bool suppressHistory)
     : base(pool.Connection, Messages.ACTION_TRANSFER_CALLHOME_SETTINGS, string.Format(Messages.ACTION_TRANSFER_CALLHOME_SETTINGS, pool.Name), suppressHistory)
 {
     this.pool             = pool;
     this.callHomeSettings = callHomeSettings;
     this.username         = username;
     this.password         = password;
 }
 public SaveCallHomeSettingsAction(Pool pool, CallHomeSettings callHomeSettings, string authenticationToken, string userName, string passWord, bool suppressHistory)
     : base(pool.Connection, Messages.ACTION_SAVE_CALLHOME_SETTINGS, string.Format(Messages.ACTION_SAVING_CALLHOME_SETTINGS, pool.Name), suppressHistory)
 {
     this.pool = pool;
     this.callHomeSettings = callHomeSettings;
     this.authenticationToken = authenticationToken;
     this.username = callHomeSettings.Status == CallHomeStatus.Enabled ? userName : null;
     this.password = callHomeSettings.Status == CallHomeStatus.Enabled ? passWord : null;
 }
 public SaveCallHomeSettingsAction(Pool pool, CallHomeSettings callHomeSettings, string authenticationToken, string userName, string passWord, bool suppressHistory)
     : base(pool.Connection, Messages.ACTION_SAVE_CALLHOME_SETTINGS, string.Format(Messages.ACTION_SAVING_CALLHOME_SETTINGS, pool.Name), suppressHistory)
 {
     this.pool                = pool;
     this.callHomeSettings    = callHomeSettings;
     this.authenticationToken = authenticationToken;
     this.username            = callHomeSettings.Status == CallHomeStatus.Enabled ? userName : null;
     this.password            = callHomeSettings.Status == CallHomeStatus.Enabled ? passWord : null;
 }
 public string GetScheduleDescription(CallHomeSettings callHomeSettings)
 {
     {
         var time = new DateTime(1900, 1, 1, callHomeSettings.TimeOfDay, 0, 0);
         return(callHomeSettings.Status == CallHomeStatus.Enabled
             ? string.Format(Messages.CALLHOME_SCHEDULE_DESCRIPTION, callHomeSettings.IntervalInWeeks,
                             callHomeSettings.DayOfWeek, HelpersGUI.DateTimeToString(time, Messages.DATEFORMAT_HM, true))
             : string.Empty);
     }
 }
 public string GetScheduleDescription(CallHomeSettings callHomeSettings)
 {
     {
         var time = new DateTime(1900, 1, 1, callHomeSettings.TimeOfDay, 0, 0);
         return callHomeSettings.Status == CallHomeStatus.Enabled
             ? string.Format(Messages.CALLHOME_SCHEDULE_DESCRIPTION, callHomeSettings.IntervalInWeeks,
                             callHomeSettings.DayOfWeek, HelpersGUI.DateTimeToString(time, Messages.DATEFORMAT_HM, true))
             : string.Empty;
     }
 }
 public CallHomeSettingsDialog(Pool pool)
 {
     this.pool = pool;
     callHomeSettings = pool.CallHomeSettings;
     authenticationToken = callHomeSettings.GetExistingSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_TOKEN_SECRET);
     usetName = callHomeSettings.GetSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_USER_SECRET);
     password = callHomeSettings.GetSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_PASSWORD_SECRET);
     InitializeComponent();
     PopulateControls();
     InitializeControls();
     UpdateButtons();
 }
Example #9
0
        private static int SleepForLockConfirm = 10 * 1000; // 10 seconds
        private static bool getLock(IXenConnection connection, Session session)
        {
            Dictionary <string, string> config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);
            string newUploadLock = Properties.Settings.Default.UUID;

            newUploadLock += "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow);
            config[CallHomeSettings.UPLOAD_LOCK] = newUploadLock;
            Pool.set_health_check_config(session, connection.Cache.Pools[0].opaque_ref, config);
            System.Threading.Thread.Sleep(SleepForLockConfirm);
            config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);
            return(config[CallHomeSettings.UPLOAD_LOCK] == newUploadLock);
        }
Example #10
0
 public string GetLastUploadDescription(CallHomeSettings callHomeSettings)
 {
     if (!string.IsNullOrEmpty(callHomeSettings.LastSuccessfulUpload))
     {
         DateTime lastSuccessfulUpload;
         if (CallHomeSettings.TryParseStringToDateTime(callHomeSettings.LastSuccessfulUpload, out lastSuccessfulUpload))
         {
             return(HelpersGUI.DateTimeToString(lastSuccessfulUpload.ToLocalTime(), Messages.DATEFORMAT_DMY_HM, true));
         }
     }
     return(string.Empty);
 }
 public string GetLastUploadDescription(CallHomeSettings callHomeSettings)
 {
     if (!string.IsNullOrEmpty(callHomeSettings.LastSuccessfulUpload))
     {
         DateTime lastSuccessfulUpload;
         if (CallHomeSettings.TryParseStringToDateTime(callHomeSettings.LastSuccessfulUpload, out lastSuccessfulUpload))
         {
             return HelpersGUI.DateTimeToString(lastSuccessfulUpload.ToLocalTime(), Messages.DATEFORMAT_DMY_HM, true);
         }
     }
     return string.Empty;
 }
 public CallHomeSettingsDialog(Pool pool, bool enrollNow)
 {
     this.pool = pool;
     callHomeSettings = pool.CallHomeSettings;
     if (enrollNow)
         callHomeSettings.Status = CallHomeStatus.Enabled;
     authenticationToken = callHomeSettings.GetExistingSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_TOKEN_SECRET);
     xsUserName = callHomeSettings.GetSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_USER_SECRET);
     xsPassword = callHomeSettings.GetSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_PASSWORD_SECRET);
     InitializeComponent();
     PopulateControls();
     InitializeControls();
     UpdateButtons();
 }
Example #13
0
        public static bool OnDemandRequest(IXenConnection connection, Session session)
        {
            Dictionary <string, string> config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);

            if (BoolKey(config, CallHomeSettings.STATUS) == false)
            {
                log.InfoFormat("Will not report on demand for XenServer {0} that was not Enroll", connection.Hostname);
                return(false);
            }

            //Check if there already some service doing the uploading already
            if (CanLock(Get(config, CallHomeSettings.UPLOAD_LOCK), true) == false)
            {
                log.InfoFormat("Will not report for XenServer {0} that already locked", connection.Hostname);
                return(false);
            }

            var newUploadRequest = Get(config, CallHomeSettings.NEW_UPLOAD_REQUEST);

            if (!string.IsNullOrEmpty(newUploadRequest))
            {
                DateTime newUploadRequestTime;
                try
                {
                    newUploadRequestTime = CallHomeSettings.StringToDateTime(newUploadRequest);
                }
                catch (Exception exn)
                {
                    log.Error("Exception while parsing NEW_UPLOAD_REQUEST", exn);
                    return(false);
                }
                DateTime newUploadRequestDueTime = newUploadRequestTime.AddMinutes(DemandTimeOutMinutes);
                if (DateTime.Compare(newUploadRequestDueTime, DateTime.UtcNow) >= 1)
                {
                    log.InfoFormat("Will report on demand for XenServer {0} since the demand was requested on {1} (UTC time)", connection.Hostname, newUploadRequestTime);
                    return(getLock(connection, session));
                }
                else
                {
                    log.InfoFormat("Will not report on demand for XenServer {0} since the demand requested on {1} (UTC time) expired after {2} minutes",
                                   connection.Hostname, newUploadRequestTime, DemandTimeOutMinutes);
                    return(false);
                }
            }
            else
            {
                return(false);
            }
        }
Example #14
0
 public void UpdateUploadRequestDescription(CallHomeSettings callHomeSettings)
 {
     {
         if (!callHomeSettings.CanRequestNewUpload)
         {
             uploadRequestLinkLabel.Text = string.Format(Messages.HEALTHCHECK_ON_DEMAND_REQUESTED_AT,
                                                         HelpersGUI.DateTimeToString(callHomeSettings.NewUploadRequestTime.ToLocalTime(),
                                                                                     Messages.DATEFORMAT_HM, true));
             uploadRequestLinkLabel.LinkArea = new LinkArea(0, 0);
             return;
         }
         uploadRequestLinkLabel.Text     = Messages.HEALTHCHECK_ON_DEMAND_REQUEST;
         uploadRequestLinkLabel.LinkArea = new LinkArea(0, uploadRequestLinkLabel.Text.Length);
     }
 }
Example #15
0
 public CallHomeSettingsDialog(Pool pool, bool enrollNow)
 {
     this.pool        = pool;
     callHomeSettings = pool.CallHomeSettings;
     if (enrollNow)
     {
         callHomeSettings.Status = CallHomeStatus.Enabled;
     }
     authenticationToken = callHomeSettings.GetExistingSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_TOKEN_SECRET);
     xsUserName          = callHomeSettings.GetSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_USER_SECRET);
     xsPassword          = callHomeSettings.GetSecretyInfo(pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_PASSWORD_SECRET);
     InitializeComponent();
     PopulateControls();
     InitializeControls();
     UpdateButtons();
 }
        public void updateCallHomeSettings(bool success, DateTime time, string uploadUuid = "")
        {
            Session session = new Session(connection.Hostname, 80);

            session.login_with_password(connection.Username, connection.Password);
            connection.LoadCache(session);

            // Round-trip format time
            DateTime rtime = DateTime.SpecifyKind(time, DateTimeKind.Utc);
            string   stime = CallHomeSettings.DateTimeToString(rtime);

            // record upload_uuid,
            // release the lock,
            // set the time of LAST_SUCCESSFUL_UPLOAD or LAST_FAILED_UPLOAD
            Dictionary <string, string> config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);

            config[CallHomeSettings.UPLOAD_LOCK] = "";
            if (success)
            {
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = stime;
                config[CallHomeSettings.UPLOAD_UUID]            = uploadUuid;
                // reset the NEW_UPLOAD_REQUEST field, if the current successful upload was started after the request
                DateTime newUploadRequestTime;
                if (CallHomeSettings.TryParseStringToDateTime(config[CallHomeSettings.NEW_UPLOAD_REQUEST], out newUploadRequestTime))
                {
                    if (rtime > newUploadRequestTime)
                    {
                        config[CallHomeSettings.NEW_UPLOAD_REQUEST] = "";
                    }
                }
            }
            else
            {
                config[CallHomeSettings.LAST_FAILED_UPLOAD] = stime;
            }
            Pool.set_health_check_config(session, connection.Cache.Pools[0].opaque_ref, config);

            if (session != null)
            {
                session.logout();
            }
            session = null;
        }
Example #17
0
        private void uploadRequestLinkLabel_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            if (poolsDataGridView.SelectedRows.Count != 1 || !(poolsDataGridView.SelectedRows[0] is PoolRow))
            {
                return;
            }

            var poolRow          = (PoolRow)poolsDataGridView.SelectedRows[0];
            var callHomeSettings = poolRow.Pool.CallHomeSettings;

            if (callHomeSettings.CanRequestNewUpload)
            {
                callHomeSettings.NewUploadRequest = CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                var token    = callHomeSettings.GetSecretyInfo(poolRow.Pool.Connection, CallHomeSettings.UPLOAD_TOKEN_SECRET);
                var user     = callHomeSettings.GetSecretyInfo(poolRow.Pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_USER_SECRET);
                var password = callHomeSettings.GetSecretyInfo(poolRow.Pool.Connection, CallHomeSettings.UPLOAD_CREDENTIAL_PASSWORD_SECRET);
                new SaveCallHomeSettingsAction(poolRow.Pool, callHomeSettings, token, user, password, false).RunAsync();
            }
        }
Example #18
0
        public void checkDemandLock()
        {
            DatabaseManager.CreateNewConnection(dbName);
            IXenConnection connection = DatabaseManager.ConnectionFor(dbName);
            Session        _session   = DatabaseManager.ConnectionFor(dbName).Session;

            DatabaseManager.ConnectionFor(dbName).LoadCache(_session);
            try
            {
                Dictionary <string, string> config = cleanStack();
                connection.LoadCache(_session);
                //1 Uploading is inprocess by current service, demand will be ignore
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK]        = UUID + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                config[CallHomeSettings.NEW_UPLOAD_REQUEST] = CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.OnDemandRequest(connection, _session));

                //2 Uploading is inprocess by other service, demand will be ignore
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK]        = "test2-test2" + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                config[CallHomeSettings.NEW_UPLOAD_REQUEST] = CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.OnDemandRequest(connection, _session));

                //3 Uploading is not due and demand due,  demand will be ignore
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK]        = "test2-test2" + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                config[CallHomeSettings.NEW_UPLOAD_REQUEST] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(31)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.OnDemandRequest(connection, _session));

                //4 Uploading is due and demand not due, lock will be set
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK]        = "test2-test2" + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                config[CallHomeSettings.NEW_UPLOAD_REQUEST] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(28)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsTrue(RequestUploadTask.OnDemandRequest(connection, _session));
            }
            catch (Exception)
            { }
        }
Example #19
0
        public static bool Request(IXenConnection connection, Session session)
        {
            bool needRetry = false;
            Dictionary <string, string> config = Pool.get_health_check_config(session, connection.Cache.Pools[0].opaque_ref);

            if (BoolKey(config, CallHomeSettings.STATUS) == false)
            {
                ServerListHelper.instance.removeServerCredential(connection.Hostname);
                log.InfoFormat("Will not report for XenServer {0} that was not Enroll", connection.Hostname);
                return(false);
            }
            //Check if there already some service doing the uploading already
            if (CanLock(Get(config, CallHomeSettings.UPLOAD_LOCK), false) == false)
            {
                log.InfoFormat("Will not report for XenServer {0} that already locked", connection.Hostname);
                return(false);
            }

            //No Lock has been set before, Check upload is due
            int      intervalInDays       = IntKey(config, CallHomeSettings.INTERVAL_IN_DAYS, CallHomeSettings.intervalInDaysDefault);
            DateTime lastSuccessfulUpload = DateTime.UtcNow;
            bool     haveSuccessfulUpload = false;

            if (config.ContainsKey(CallHomeSettings.LAST_SUCCESSFUL_UPLOAD))
            {
                try
                {
                    lastSuccessfulUpload = CallHomeSettings.StringToDateTime(Get(config, CallHomeSettings.LAST_SUCCESSFUL_UPLOAD));
                    haveSuccessfulUpload = true;
                }
                catch (Exception exn)
                {
                    log.Error("Catch exception when Parse LAST_SUCCESSFUL_UPLOAD", exn);
                }
            }

            if (haveSuccessfulUpload)
            {//If last successful update not due. return
                if (DateTime.Compare(DateTime.UtcNow, lastSuccessfulUpload.AddDays(intervalInDays)) < 0)
                {
                    log.InfoFormat("Will not report for XenServer {0} that was not due {1} days", connection.Hostname, intervalInDays);
                    return(false);
                }
            }

            if (config.ContainsKey(CallHomeSettings.LAST_FAILED_UPLOAD))
            {
                try
                {
                    DateTime LastFailedUpload = CallHomeSettings.StringToDateTime(Get(config, CallHomeSettings.LAST_FAILED_UPLOAD));

                    if (haveSuccessfulUpload)
                    {
                        if (DateTime.Compare(lastSuccessfulUpload, LastFailedUpload) > 0)
                        {
                            return(false); //A retry is not needed
                        }
                    }

                    int retryInterval = IntKey(config, CallHomeSettings.RETRY_INTERVAL, CallHomeSettings.RetryIntervalDefault);
                    if (DateTime.Compare(LastFailedUpload.AddDays(retryInterval), DateTime.UtcNow) <= 0)
                    {
                        log.InfoFormat("Retry since retryInterval{0} - {1} > {2} meeted", LastFailedUpload, DateTime.UtcNow, retryInterval);
                        needRetry = true;
                    }
                    else
                    {
                        return(false);
                    }
                }
                catch (Exception exn)
                {
                    log.Error("Catch exception when check if retry was needed", exn);
                }
            }

            DateTime currentTime = DateTime.UtcNow;

            if (!needRetry)
            {//Check if uploading schedule meet only for new upload
                DayOfWeek dayOfWeek;
                if (!Enum.TryParse(Get(config, CallHomeSettings.DAY_OF_WEEK), out dayOfWeek))
                {
                    log.Error("DAY_OF_WEEK not existed");
                    return(false);
                }
                if (!config.ContainsKey(CallHomeSettings.TIME_OF_DAY))
                {
                    log.Error("TIME_OF_DAY not existed");
                    return(false);
                }

                int TimeOfDay = IntKey(config, CallHomeSettings.TIME_OF_DAY, CallHomeSettings.GetDefaultTime());
                if (currentTime.DayOfWeek != dayOfWeek && currentTime.Hour != TimeOfDay)
                {
                    log.InfoFormat("Will not report for XenServer {0} for incorrect schedule", connection.Hostname);
                    return(false);
                }
            }

            return(getLock(connection, session));
        }
 public void UpdateUploadRequestDescription(CallHomeSettings callHomeSettings)
 {
     {
         if (!callHomeSettings.CanRequestNewUpload)
         {
                 uploadRequestLinkLabel.Text = string.Format(Messages.HEALTHCHECK_ON_DEMAND_REQUESTED_AT,
                                                             HelpersGUI.DateTimeToString(callHomeSettings.NewUploadRequestTime.ToLocalTime(),
                                                                 Messages.DATEFORMAT_HM, true));
             uploadRequestLinkLabel.LinkArea = new LinkArea(0, 0);
             return;
         }
         uploadRequestLinkLabel.Text = Messages.HEALTHCHECK_ON_DEMAND_REQUEST;
         uploadRequestLinkLabel.LinkArea = new LinkArea(0, uploadRequestLinkLabel.Text.Length);
     }
 }
        private void okButton_Click(object sender, EventArgs e)
        {
            if (ChangesMade())
            {
                var newCallHomeSettings = new CallHomeSettings(
                    enrollmentCheckBox.Checked ? CallHomeStatus.Enabled : CallHomeStatus.Disabled,
                    (int) (frequencyNumericBox.Value * 7),
                    (DayOfWeek) dayOfWeekComboBox.SelectedValue,
                    (int) timeOfDayComboBox.SelectedValue,
                    CallHomeSettings.DefaultRetryInterval);

                new SaveCallHomeSettingsAction(pool, newCallHomeSettings, authenticationToken, usetName, password, false).RunAsync();
                new TransferCallHomeSettingsAction(pool, newCallHomeSettings, usetName, password, true).RunAsync();
            }
            DialogResult = DialogResult.OK;
            Close();
        }
 public void UpdateUploadRequestDescription(CallHomeSettings callHomeSettings)
 {
     {
         double uploadRequest;
         if (!callHomeSettings.CanRequestNewUpload && double.TryParse(callHomeSettings.NewUploadRequest, out uploadRequest))
         {
             uploadRequestLinkLabel.Text = string.Format(Messages.HEALTHCHECK_ON_DEMAND_REQUESTED_AT,
                                  HelpersGUI.DateTimeToString(Util.FromUnixTime(uploadRequest), Messages.DATEFORMAT_HM, true));
             uploadRequestLinkLabel.LinkArea = new LinkArea(0, 0);
             return;
         }
         uploadRequestLinkLabel.Text = Messages.HEALTHCHECK_ON_DEMAND_REQUEST;
         uploadRequestLinkLabel.LinkArea = new LinkArea(0, uploadRequestLinkLabel.Text.Length);
     }
 }
        private void okButton_Click(object sender, EventArgs e)
        {
            okButton.Enabled = false;
            if (enrollmentCheckBox.Checked && newAuthenticationRadioButton.Checked
                && !m_ctrlError.PerformCheck(CheckUploadAuthentication))
            {
                okButton.Enabled = true;
                return;
            }

            if (ChangesMade())
            {
                var newCallHomeSettings = new CallHomeSettings(
                    enrollmentCheckBox.Checked ? CallHomeStatus.Enabled : CallHomeStatus.Disabled,
                    (int)(frequencyNumericBox.Value * 7),
                    (DayOfWeek)dayOfWeekComboBox.SelectedValue,
                    (int)timeOfDayComboBox.SelectedValue,
                    CallHomeSettings.DefaultRetryInterval);

                new SaveCallHomeSettingsAction(pool, newCallHomeSettings, authenticationToken, textboxXSUserName.Text, textboxXSPassword.Text, false).RunAsync();
                new TransferCallHomeSettingsAction(pool, newCallHomeSettings, textboxXSUserName.Text, textboxXSPassword.Text, true).RunAsync();
            }
            okButton.Enabled = true;
            DialogResult = DialogResult.OK;
            Close();
        }
Example #24
0
        public void checkUploadLock()
        {
            DatabaseManager.CreateNewConnection(dbName);
            IXenConnection connection = DatabaseManager.ConnectionFor(dbName);
            Session        _session   = DatabaseManager.ConnectionFor(dbName).Session;

            DatabaseManager.ConnectionFor(dbName).LoadCache(_session);
            try
            {
                Dictionary <string, string> config = cleanStack();
                connection.LoadCache(_session);

                //1. If XenServer has not enroll, lock will not been set.
                config = cleanStack();
                config[CallHomeSettings.STATUS] = "false";
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));

                //2.If the lock has already set by current service and not due, the lock should not been set again.
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK] = UUID + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));


                //3. If the lock already due or no one set the lock, but current schedule DayOfWeek and TimeOfDay is not correct, the lock should not been set.
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK] = UUID + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));

                //4. For lock due or not set by others and schedule meet, lock should be set.
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK] = UUID + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                config[CallHomeSettings.DAY_OF_WEEK] = DateTime.UtcNow.DayOfWeek.ToString();
                config[CallHomeSettings.TIME_OF_DAY] = DateTime.UtcNow.Hour.ToString();
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsTrue(RequestUploadTask.Request(connection, _session));

                //5. For Lock set by other service and not due, the lock should not been set by us.
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK] = "test2-test2" + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow);
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));

                //6. For Lock set by other service but already due, the lock can be set by current service
                config = cleanStack();
                config[CallHomeSettings.UPLOAD_LOCK] = "test2-test2" + "|" + CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                config[CallHomeSettings.DAY_OF_WEEK] = DateTime.UtcNow.DayOfWeek.ToString();
                config[CallHomeSettings.TIME_OF_DAY] = DateTime.UtcNow.Hour.ToString();
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsTrue(RequestUploadTask.Request(connection, _session));

                //7 Check LastFailedUpload is not empty and > LastSuccessfulUpload && INTERVAL_IN_DAYS using default, lock can be set
                config = cleanStack();
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                config[CallHomeSettings.LAST_FAILED_UPLOAD]     = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(8)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsTrue(RequestUploadTask.Request(connection, _session));

                //8 For not due uploading, lock should not been set
                config = cleanStack();
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(6)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));

                //9 For failed upload, retry was needed but not meet RetryIntervalInDays, lock should not been set
                config = cleanStack();
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(14)));
                config[CallHomeSettings.LAST_FAILED_UPLOAD]     = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(5)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));

                //10 For failed upload, retry was needed and meet RetryIntervalInDays, lock should be set
                config = cleanStack();
                config[CallHomeSettings.LAST_FAILED_UPLOAD] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(7)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsTrue(RequestUploadTask.Request(connection, _session));


                //11 Retry needed because no LAST_SUCCESSFUL_UPLOAD but not meet RetryIntervalInDays, lock should not be set
                config = cleanStack();
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = "";
                config[CallHomeSettings.LAST_FAILED_UPLOAD]     = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(8)));
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsTrue(RequestUploadTask.Request(connection, _session));

                //12 For no LAST_FAILED_UPLOAD or invalid LAST_FAILED_UPLOAD, lock should not be set if not due
                config = cleanStack();
                config[CallHomeSettings.LAST_SUCCESSFUL_UPLOAD] = CallHomeSettings.DateTimeToString(DateTime.UtcNow.Subtract(TimeSpan.FromDays(13)));
                config[CallHomeSettings.LAST_FAILED_UPLOAD]     = "asd";
                Pool.set_health_check_config(_session, connection.Cache.Pools[0].opaque_ref, config);
                Assert.IsFalse(RequestUploadTask.Request(connection, _session));
            }
            catch (Exception)
            {}
        }