public override void ExecuteCmdlet()
        {
            if (ParameterSetName == ParentObjectParameterSet)
            {
                ResourceGroupName = AccountObject.ResourceGroupName;
                Location          = AccountObject.Location;
                var NameParts = AccountObject.Name.Split('/');
                AccountName = NameParts[0];
            }

            var snapshotPolicyBody = new Management.NetApp.Models.SnapshotPolicy()
            {
                Location        = Location,
                Enabled         = Enabled,
                HourlySchedule  = (HourlySchedule != null) ? HourlySchedule.ConvertFromPs() : null,
                DailySchedule   = (DailySchedule != null) ? DailySchedule.ConvertFromPs() : null,
                WeeklySchedule  = (WeeklySchedule != null) ? WeeklySchedule.ConvertFromPs() : null,
                MonthlySchedule = (MonthlySchedule != null) ? MonthlySchedule.ConvertFromPs() : null
            };

            if (ShouldProcess(Name, string.Format(PowerShell.Cmdlets.NetAppFiles.Properties.Resources.CreateResourceMessage, ResourceGroupName)))
            {
                var anfSnapshotPolicy = AzureNetAppFilesManagementClient.SnapshotPolicies.Create(snapshotPolicyBody, ResourceGroupName, AccountName, snapshotPolicyName: Name);
                WriteObject(anfSnapshotPolicy.ConvertToPs());
            }
        }
Esempio n. 2
0
        public Schedule CreateSchedule(string automationAccountName, HourlySchedule schedule)
        {
            this.ValidateScheduleName(automationAccountName, schedule.Name);

            var scheduleModel = new AutomationManagement.Models.Schedule
            {
                Name         = schedule.Name,
                StartTime    = schedule.StartTime.ToUniversalTime(),
                ExpiryTime   = schedule.ExpiryTime.ToUniversalTime(),
                Description  = schedule.Description,
                HourInterval = schedule.HourInterval,
                ScheduleType =
                    AutomationManagement.Models.ScheduleType
                    .HourlySchedule
            };

            var scheduleCreateParameters = new AutomationManagement.Models.ScheduleCreateParameters
            {
                Schedule = scheduleModel
            };

            var scheduleCreateResponse = this.automationManagementClient.Schedules.Create(
                automationAccountName,
                scheduleCreateParameters);

            return(this.GetSchedule(automationAccountName, new Guid(scheduleCreateResponse.Schedule.Id)));
        }
 public void HourlyScheduleRoundTripDeserializesIntoBaseClass()
 {
     var schedule = new HourlySchedule { Minute = 35 };
     var json = JsonConvert.SerializeObject(schedule);
     var newScheduleBase = JsonConvert.DeserializeObject<ScheduleBase>(json);
     var newScheduleTyped = Assert.IsType<HourlySchedule>(newScheduleBase);
     Assert.Equal(schedule.Minute, newScheduleTyped.Minute);
 }
        protected override void AutomationExecuteCmdlet()
        {
            // Assume local time if DateTimeKind.Unspecified
            if (this.StartTime.Kind == DateTimeKind.Unspecified)
            {
                this.StartTime = DateTime.SpecifyKind(this.StartTime, DateTimeKind.Local);
            }

            if (this.ExpiryTime.Kind == DateTimeKind.Unspecified)
            {
                this.ExpiryTime = DateTime.SpecifyKind(this.ExpiryTime, DateTimeKind.Local);
            }

            if (this.OneTime.IsPresent)
            {
                // ByOneTime
                var oneTimeSchedule = new OneTimeSchedule
                {
                    Name        = this.Name,
                    StartTime   = this.StartTime,
                    Description = this.Description,
                    ExpiryTime  = this.ExpiryTime
                };

                Schedule schedule = this.AutomationClient.CreateSchedule(this.AutomationAccountName, oneTimeSchedule);
                this.WriteObject(schedule);
            }
            else if (this.DayInterval >= 1)
            {
                // ByDaily
                var dailySchedule = new DailySchedule
                {
                    Name        = this.Name,
                    StartTime   = this.StartTime,
                    DayInterval = this.DayInterval,
                    Description = this.Description,
                    ExpiryTime  = this.ExpiryTime
                };

                Schedule schedule = this.AutomationClient.CreateSchedule(this.AutomationAccountName, dailySchedule);
                this.WriteObject(schedule);
            }
            else if (this.HourInterval >= 1)
            {
                // ByHourly
                var hourlySchedule = new HourlySchedule
                {
                    Name         = this.Name,
                    StartTime    = this.StartTime,
                    HourInterval = this.HourInterval,
                    Description  = this.Description,
                    ExpiryTime   = this.ExpiryTime
                };

                Schedule schedule = this.AutomationClient.CreateSchedule(this.AutomationAccountName, hourlySchedule);
                this.WriteObject(schedule);
            }
        }
        public static void HourlySchedule_MinuteInRange_Valid()
        {
            var o = new HourlySchedule {
                Minute = 22
            };

            Assert.NotNull(o);
            o.ThrowIfInvalid();
        }
        public static void IsValid_Invalid_False()
        {
            var o = new HourlySchedule {
                Minute = 100
            };

            Assert.NotNull(o);
            Assert.False(o.IsValid());
        }
 //constructor for existing records
 public ModReservationViewModel(HourlySchedule hourlySchedule)
 {
     base.Init();
     SubmitButtonText = "Update Reservation";
     PageHeaderText   = "Modify an Existing Reservation";
     ResourceSchedule = hourlySchedule.ResourceSchedule;
     SelectedDate     = hourlySchedule.ResourceSchedule.ReservationStartDateTime.Date;
     BuildHourlyScheduleAsync();
 }
        public static HourlySchedule ConvertFromPs(this PSNetAppFilesHourlySchedule psHourlySchedule)
        {
            var hourlySchedule = new HourlySchedule
            {
                Minute          = psHourlySchedule.Minute,
                SnapshotsToKeep = psHourlySchedule.SnapshotsToKeep
            };

            return(hourlySchedule);
        }
        public static PSNetAppFilesHourlySchedule ConvertToPs(this HourlySchedule hourlySchedule)
        {
            PSNetAppFilesHourlySchedule psNetAppFilesHourlySchedule = new PSNetAppFilesHourlySchedule
            {
                Minute          = hourlySchedule.Minute,
                SnapshotsToKeep = hourlySchedule.SnapshotsToKeep,
                UsedBytes       = hourlySchedule.UsedBytes
            };

            return(psNetAppFilesHourlySchedule);
        }
        public void HourlyScheduleRoundtripWillDeserializeIntoBaseClass()
        {
            var schedule = new HourlySchedule {
                Minute = 35
            };
            var json             = this.bsonSerializer.SerializeToString(schedule);
            var newScheduleBase  = this.bsonSerializer.Deserialize <ScheduleBase>(json);
            var newScheduleTyped = Assert.IsType <HourlySchedule>(newScheduleBase);

            Assert.Equal(schedule.Minute, newScheduleTyped.Minute);
            Assert.Equal(schedule, newScheduleTyped);
        }
Esempio n. 11
0
        public static void put_watcher_sample(ElasticClient client)
        {
            // action
            var action = new LoggingAction("mylog")
            {
                Text  = "some node is down",
                Level = LogLevel.Info
            };

            ConditionContainer condition = new AlwaysCondition();

            var my_http = new HttpInputRequest
            {
                Host   = "localhost",
                Port   = 9200,
                Path   = "_cat/nodes",
                Method = HttpInputMethod.Get
            };

            var input = new HttpInput
            {
                Request = my_http
            };



            var hourly = new HourlySchedule();

            int[] intNumbers = new int[] { 30 };
            hourly.Minute = intNumbers;

            var trigger = new ScheduleContainer
            {
                Hourly = hourly
            };


            var             id           = "status-check";
            PutWatchRequest watchRequest = new PutWatchRequest(id)
            {
                Actions   = action,
                Condition = condition,
                Input     = input,
                Trigger   = trigger
            };


            PutWatchResponse response = client.Watcher.Put(watchRequest);


            Console.WriteLine("hello");
        }
        public static void GetCronExpressionFromSchedule_Hourly_Works()
        {
            var schedule = new HourlySchedule {
                Minute = 7
            };
            var cron = ScheduleCronExpressionConverter.ToCronExpression(schedule);

            Assert.Equal("7 * * * *", cron);

            var newSchedule      = ScheduleCronExpressionConverter.FromCronExpression(cron);
            var newScheduleTyped = Assert.IsType <HourlySchedule>(newSchedule);

            Assert.Equal(schedule.GetType(), newScheduleTyped.GetType());
            Assert.Equal(schedule.Minute, newScheduleTyped.Minute);
        }
        public override void ExecuteCmdlet()
        {
            if (ParameterSetName == ResourceIdParameterSet)
            {
                var resourceIdentifier = new ResourceIdentifier(ResourceId);
                ResourceGroupName = resourceIdentifier.ResourceGroupName;
                Name = resourceIdentifier.ResourceName;
            }
            if (ParameterSetName == ParentObjectParameterSet)
            {
                ResourceGroupName = AccountObject.ResourceGroupName;
                Location          = AccountObject.Location;
                var NameParts = AccountObject.Name.Split('/');
                AccountName = NameParts[0];
            }
            Management.NetApp.Models.SnapshotPolicy existingSnapshotPolicy = null;
            try
            {
                existingSnapshotPolicy = AzureNetAppFilesManagementClient.SnapshotPolicies.Get(ResourceGroupName, AccountName, Name);
            }
            catch
            {
                existingSnapshotPolicy = null;
            }
            if (existingSnapshotPolicy == null)
            {
                throw new AzPSResourceNotFoundCloudException($"A Snapshot Policy with name '{this.Name}' in resource group '{this.ResourceGroupName}' does not exists. Please use New-AzNetAppFilesSnapshotPolicy to create a Snapshot Policy.");
            }

            var snapshotPolicyBody = new Management.NetApp.Models.SnapshotPolicy()
            {
                Location        = Location,
                Enabled         = Enabled,
                HourlySchedule  = (HourlySchedule != null) ? HourlySchedule.ConvertFromPs() : null,
                DailySchedule   = (DailySchedule != null) ? DailySchedule.ConvertFromPs() : null,
                WeeklySchedule  = (WeeklySchedule != null) ? WeeklySchedule.ConvertFromPs() : null,
                MonthlySchedule = (MonthlySchedule != null) ? MonthlySchedule.ConvertFromPs() : null
            };

            if (ShouldProcess(Name, string.Format(PowerShell.Cmdlets.NetAppFiles.Properties.Resources.UpdateResourceMessage, ResourceGroupName)))
            {
                var anfSnapshotPolicy = AzureNetAppFilesManagementClient.SnapshotPolicies.Create(snapshotPolicyBody, ResourceGroupName, AccountName, snapshotPolicyName: Name);
                WriteObject(anfSnapshotPolicy.ConvertToPs());
            }
        }
        private static SnapshotPolicy CreatePolicy(string location, string name = "")
        {
            // Create basic policy records with a selection of data
            HourlySchedule HourlySchedule = new HourlySchedule
            {
                SnapshotsToKeep = 2,
                Minute          = 50
            };

            DailySchedule DailySchedule = new DailySchedule
            {
                SnapshotsToKeep = 4,
                Hour            = 14,
                Minute          = 30
            };

            WeeklySchedule WeeklySchedule = new WeeklySchedule
            {
                SnapshotsToKeep = 3,
                Day             = "Wednesday",
                Hour            = 14,
                Minute          = 45
            };

            MonthlySchedule MonthlySchedule = new MonthlySchedule
            {
                SnapshotsToKeep = 5,
                DaysOfMonth     = "10,11,12",
                Hour            = 14,
                Minute          = 15
            };

            SnapshotPolicy testSnapshotPolicy = new SnapshotPolicy(location: location, name: name)
            {
                Enabled         = true,
                HourlySchedule  = HourlySchedule,
                DailySchedule   = DailySchedule,
                WeeklySchedule  = WeeklySchedule,
                MonthlySchedule = MonthlySchedule
            };

            return(testSnapshotPolicy);
        }
        /// <summary>
        /// Update current Snapshot policy hourly schedule
        /// </summary>
        /// <param name="anfClient">ANF client</param>
        /// <param name="resourceGroupName">Resource Group name</param>
        /// <param name="location">Azure location</param>
        /// <param name="accountName">Azure NetApp Files Account name</param>
        /// <param name="snapshotPolicyName">Azure NetApp Files Snapshot Policy name</param>
        /// <param name="currentHourlySchedule">Current Snapshot hourly schedule</param>
        /// <returns>Returns current Snapshot Policy</returns>
        public static async Task <SnapshotPolicy> UpdateANFSnapshotPolicy(AzureNetAppFilesManagementClient anfClient,
                                                                          string resourceGroupName,
                                                                          string location,
                                                                          string accountName,
                                                                          string snapshotPolicyName,
                                                                          HourlySchedule currentHourlySchedule)
        {
            HourlySchedule newHourlySchedule = currentHourlySchedule;

            newHourlySchedule.SnapshotsToKeep = 10;

            SnapshotPolicyPatch snapshotPolicyPatch = new SnapshotPolicyPatch()
            {
                HourlySchedule = newHourlySchedule,
                Enabled        = true,
                Location       = location
            };

            return(await anfClient.SnapshotPolicies.UpdateAsync(snapshotPolicyPatch, resourceGroupName, accountName, snapshotPolicyName));
        }
Esempio n. 16
0
 public void IsValid_Invalid_False()
 {
     var o = new HourlySchedule { Minute = 100 };
     Assert.NotNull(o);
     Assert.False(o.IsValid());
 }
        public void GetCronExpressionFromSchedule_Hourly_Works()
        {
            var schedule = new HourlySchedule { Minute = 7 };
            var cron = ScheduleCronExpressionConverter.ToCronExpression(schedule);
            Assert.Equal("7 * * * *", cron);

            var newSchedule = ScheduleCronExpressionConverter.FromCronExpression(cron);
            var newScheduleTyped = Assert.IsType<HourlySchedule>(newSchedule);
            Assert.Equal(schedule.GetType(), newScheduleTyped.GetType());
            Assert.Equal(schedule.Minute, newScheduleTyped.Minute);
        }
 //constructor for editing existing resource schedules
 public ModReservationPage(HourlySchedule hourlySchedule)
 {
     InitializeComponent();
     BindingContext = viewModel = new ModReservationViewModel(hourlySchedule);
 }
        private static void zConfigureHourlySchedule(List <TriggerBuilder> triggerBuilderList, HourlySchedule schedule)
        {
            SimpleScheduleBuilder sb = zCreateSimpleSchedule(schedule)
                                       .WithInterval(schedule.HourlyRecurrence)
                                       .RepeatForever();

            triggerBuilderList.Add(TriggerBuilder.Create().WithSchedule(sb));
        }
Esempio n. 20
0
        public CronDummyFactory()
        {
            AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <ScheduleBase>();

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new DailyScheduleInUtc
                {
                    Hour   = A.Dummy <int>().ThatIsInRange(0, 23),
                    Minute = A.Dummy <int>().ThatIsInRange(0, 59),
                };

                return(result);
            });

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new ExpressionSchedule
                {
                    CronExpression = "*/" + A.Dummy <int>().ThatIsInRange(1, 4) + " * * * *",
                };

                return(result);
            });

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new HourlySchedule
                {
                    Minute = A.Dummy <int>().ThatIsInRange(0, 59),
                };

                return(result);
            });

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new IntervalSchedule()
                {
                    Interval = new TimeSpan(A.Dummy <long>().ThatIsInRange(0, 10000))
                };

                return(result);
            });

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new MonthlyScheduleInUtc()
                {
                    DaysOfMonth = new[]
                    {
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                    }.Distinct().ToArray(),
                    Hour   = A.Dummy <int>().ThatIsInRange(0, 23),
                    Minute = A.Dummy <int>().ThatIsInRange(0, 59),
                };

                return(result);
            });

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new WeeklyScheduleInUtc()
                {
                    DaysOfWeek = Some.Dummies <DayOfWeek>(3).ToArray(),
                    Hour       = A.Dummy <int>().ThatIsInRange(0, 23),
                    Minute     = A.Dummy <int>().ThatIsInRange(0, 59),
                };

                return(result);
            });

            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                var result = new YearlyScheduleInUtc()
                {
                    MonthsOfYear = Some.Dummies <MonthOfYear>(4).ToArray(),
                    DaysOfMonth  = new[]
                    {
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                        A.Dummy <int>().ThatIsInRange(0, 28),
                    }.Distinct().ToArray(),
                    Hour   = A.Dummy <int>().ThatIsInRange(0, 23),
                    Minute = A.Dummy <int>().ThatIsInRange(0, 59),
                };

                return(result);
            });
        }
Esempio n. 21
0
 public void HourlySchedule_MinuteInRange_Valid()
 {
     var o = new HourlySchedule { Minute = 22 };
     Assert.NotNull(o);
     o.ThrowIfInvalid();
 }