コード例 #1
0
 public static void ExecuteMethod_PopulateMonitoringItems(RequestResourceUsageCollection[] resourcesToIncludeInMonitoring, UsageMonitorItem[] newMonitoringItems)
 {
     if (resourcesToIncludeInMonitoring.Length == 0 || newMonitoringItems.Length == 0)
         return;
     int currMonitoringItemIX = 0;
     var resourcesCombined = resourcesToIncludeInMonitoring.SelectMany(coll => coll.CollectionContent).ToArray();
     var currMonitoringItem = newMonitoringItems[currMonitoringItemIX];
     foreach (var resourceItem in resourcesCombined)
     {
         DateTime resourceItemTime = resourceItem.ProcessorUsage.TimeRange.EndTime;
         while (resourceItemTime >= currMonitoringItem.TimeRangeInclusiveStartExclusiveEnd.EndTime)
         {
             currMonitoringItemIX++;
             if (currMonitoringItemIX == newMonitoringItems.Length)
                 return;
             currMonitoringItem = newMonitoringItems[currMonitoringItemIX];
         }
         DateTime currMonitorStartTime = currMonitoringItem.TimeRangeInclusiveStartExclusiveEnd.StartTime;
         bool matchesTimes = currMonitorStartTime <= resourceItemTime &&
                             currMonitoringItem.TimeRangeInclusiveStartExclusiveEnd.EndTime > resourceItemTime;
         if(matchesTimes == false)
             throw new InvalidDataException("Invalid data processing to feed invalid data to populating items");
         var diffFromMonitorBegin = resourceItemTime - currMonitorStartTime;
         var completeMinutes = Math.Floor(diffFromMonitorBegin.TotalMinutes);
         int stepIndex = (int) (completeMinutes/currMonitoringItem.StepSizeInMinutes);
         // Add data to index entries
         addValuesToMonitorItem(resourceItem, currMonitoringItem, stepIndex);
     }
 }
コード例 #2
0
ファイル: UsageMonitorItem.cs プロジェクト: kallex/Caloom
 public void AggregateValuesFrom(UsageMonitorItem[] sourceItems)
 {
     foreach (var item in sourceItems)
     {
         DateTime sourceStart = item.TimeRangeInclusiveStartExclusiveEnd.StartTime;
         DateTime sourceEnd = item.TimeRangeInclusiveStartExclusiveEnd.EndTime;
         DateTime targetStart = TimeRangeInclusiveStartExclusiveEnd.StartTime;
         DateTime targetEnd = TimeRangeInclusiveStartExclusiveEnd.EndTime;
         if(sourceStart < targetStart || sourceEnd > targetEnd)
             throw new InvalidDataException("The aggregation target needs to contain full source item date range");
         for (int sourceIX = 0; sourceIX < item.ProcessorUsages.CollectionContent.Count; sourceIX++)
         {
             DateTime currSourceStart = sourceStart.AddMinutes(item.StepSizeInMinutes*sourceIX);
             var timeDelta = currSourceStart - targetStart;
             int targetIX = (int) (timeDelta.TotalMinutes/StepSizeInMinutes);
             addProcessorUsageToTarget(ProcessorUsages.CollectionContent[targetIX],
                                       item.ProcessorUsages.CollectionContent[sourceIX]);
             addStorageTransactionUsageToTraget(StorageTransactionUsages.CollectionContent[targetIX],
                                                item.StorageTransactionUsages.CollectionContent[sourceIX]);
             addNetworkUsageToTarget(NetworkUsages.CollectionContent[targetIX],
                                     item.NetworkUsages.CollectionContent[sourceIX]);
             setStorageUsageToTarget(StorageUsages.CollectionContent[targetIX],
                                     item.StorageUsages.CollectionContent[sourceIX]);
         }
     }
 }
コード例 #3
0
ファイル: UsageMonitorItem.cs プロジェクト: kallex/Caloom
 public static UsageMonitorItem Create(DateTime startTime, DateTime endTime, int stepSizeInMinutes)
 {
     UsageMonitorItem item = new UsageMonitorItem
         {
             TimeRangeInclusiveStartExclusiveEnd = new TimeRange
                 {
                     StartTime = startTime,
                     EndTime = endTime
                 },
             StepSizeInMinutes = stepSizeInMinutes
         };
     item.InitializeSteppedCollections();
     return item;
 }
コード例 #4
0
        public static void ExecuteMethod_CreateUsageMonitoringSummaries(IContainerOwner owner, int amountOfDays, UsageMonitorItem[] sourceItems)
        {
            var groupedByDay =
                sourceItems.OrderBy(item => item.RelativeLocation)
                           .GroupBy(item => item.TimeRangeInclusiveStartExclusiveEnd.StartTime.Date);
            if(amountOfDays < 31)
                throw new ArgumentException("Amount of days needs to be at least 31 so that last month makes sense with data");
            // Last 7 days
            UsageSummary lastWeekHourlySummary = null;
            DateTime today = DateTime.UtcNow.Date;
            DateTime weekAgoStartDay = today.AddDays(-7);
            DateTime todayEndTime = today.AddDays(1);
            lastWeekHourlySummary = new UsageSummary
                {
                    SummaryName = "Last Week (7 days) Summary",
                    SummaryMonitoringItem = UsageMonitorItem.Create(weekAgoStartDay, todayEndTime, 60)
                };
            lastWeekHourlySummary.SetLocationAsOwnerContent(owner, "LastWeekSummary_Hourly");

            // Last month
            DateTime monthAgoStartDay = today.AddMonths(-1);
            UsageSummary lastMonthDailySummary = new UsageSummary
                {
                    SummaryName = "Last Week Summary",
                    SummaryMonitoringItem = UsageMonitorItem.Create(monthAgoStartDay, todayEndTime, 60 * 24)
                };
            lastMonthDailySummary.SetLocationAsOwnerContent(owner, "LastMonthSummary_Daily");

            foreach (var dayList in groupedByDay)
            {
                //UsageMonitorItemCollection hourlyCollection = new UsageMonitorItemCollection();
                //hourlyCollection.
                string hourlySummaryName = "Hourly Summary of " + dayList.Key.ToShortDateString();
                DateTime startTime = dayList.Key;
                DateTime endTime = startTime.AddDays(1);
                var currDaysData = dayList.ToArray();
                UsageSummary dailyHourlySummary = new UsageSummary
                    {
                        SummaryName = hourlySummaryName,
                        SummaryMonitoringItem = UsageMonitorItem.Create(startTime, endTime, 60)
                    };
                dailyHourlySummary.SummaryMonitoringItem.AggregateValuesFrom(currDaysData);
                string prefixName = startTime.ToString("yyyyMMdd");
                dailyHourlySummary.SetLocationAsOwnerContent(owner, prefixName + "_Hourly");
                dailyHourlySummary.StoreInformation(null, true);
                string detailedSummaryName = "Detailed (5 min) Summary of " + dayList.Key.ToShortDateString();
                UsageSummary dailyDetailedSummary = new UsageSummary
                    {
                        SummaryName = detailedSummaryName,
                        SummaryMonitoringItem = UsageMonitorItem.Create(startTime, endTime, 5)
                    };
                dailyDetailedSummary.SummaryMonitoringItem.AggregateValuesFrom(currDaysData);
                dailyDetailedSummary.SetLocationAsOwnerContent(owner, prefixName + "_Detailed");
                dailyDetailedSummary.StoreInformation(null, true);

                // Weekly summary
                if (startTime >=
                    lastWeekHourlySummary.SummaryMonitoringItem.TimeRangeInclusiveStartExclusiveEnd.StartTime)
                {
                    lastWeekHourlySummary.SummaryMonitoringItem.AggregateValuesFrom(currDaysData);
                }
                if (startTime >=
                    lastMonthDailySummary.SummaryMonitoringItem.TimeRangeInclusiveStartExclusiveEnd.StartTime)
                {
                    lastMonthDailySummary.SummaryMonitoringItem.AggregateValuesFrom(currDaysData);
                }
            }

            lastWeekHourlySummary.StoreInformation(null, true);
            lastMonthDailySummary.StoreInformation(null, true);
        }
コード例 #5
0
 private void CopyContentFrom(UsageMonitorItem sourceObject)
 {
     OwnerInfo = sourceObject.OwnerInfo;
             ProcessorUsages = sourceObject.ProcessorUsages;
             StorageTransactionUsages = sourceObject.StorageTransactionUsages;
             StorageUsages = sourceObject.StorageUsages;
             NetworkUsages = sourceObject.NetworkUsages;
 }
コード例 #6
0
partial         static void CreateCustomDemo(ref UsageMonitorItem customDemoObject);
コード例 #7
0
        public static UsageMonitorItem CreateDemoDefault()
        {
            UsageMonitorItem customDemo = null;
                    UsageMonitorItem.CreateCustomDemo(ref customDemo);
                    if(customDemo != null)
                        return customDemo;
                    var result = new UsageMonitorItem();
                    result.OwnerInfo = InformationOwnerInfo.CreateDemoDefault();
                    result.ProcessorUsages = ProcessorUsageCollection.CreateDemoDefault();
                    result.StorageTransactionUsages = StorageTransactionUsageCollection.CreateDemoDefault();
                    result.StorageUsages = StorageUsageCollection.CreateDemoDefault();
                    result.NetworkUsages = NetworkUsageCollection.CreateDemoDefault();

                    return result;
        }
コード例 #8
0
 public static UsageMonitorItem CreateDefault()
 {
     var result = new UsageMonitorItem();
             result.OwnerInfo = InformationOwnerInfo.CreateDefault();
             result.ProcessorUsages = ProcessorUsageCollection.CreateDefault();
             result.StorageTransactionUsages = StorageTransactionUsageCollection.CreateDefault();
             result.StorageUsages = StorageUsageCollection.CreateDefault();
             result.NetworkUsages = NetworkUsageCollection.CreateDefault();
             return result;
 }
コード例 #9
0
        public static UsageMonitorItem[] GetTarget_NewMonitoringItems(IContainerOwner owner, int monitoringItemTimeSpanInMinutes, int monitoringIntervalInMinutes, DateTime startingTimeOfNewItems, DateTime endingTimeOfNewItems)
        {
            if(startingTimeOfNewItems == endingTimeOfNewItems)
                return new UsageMonitorItem[0];
            DateTime currentStartingTime = startingTimeOfNewItems;
            DateTime currentEndingTime = currentStartingTime.AddMinutes(monitoringItemTimeSpanInMinutes);
            List<UsageMonitorItem> usageMonitorItems = new List<UsageMonitorItem>();
            while (currentEndingTime <= endingTimeOfNewItems)
            {
                string currName = String.Format("{0}_{1}",
                                currentStartingTime.ToString("yyyyMMddHHmmssfff"),
                                currentEndingTime.ToString("yyyyMMddHHmmssfff"));

                var currItem = new UsageMonitorItem();
                currItem.SetLocationAsOwnerContent(owner, currName);
                currItem.TimeRangeInclusiveStartExclusiveEnd = new TimeRange
                    {
                        StartTime = currentStartingTime,
                        EndTime = currentEndingTime
                    };
                currItem.StepSizeInMinutes = monitoringIntervalInMinutes;
                //currItem.InitializeStepCollections();
                currItem.OwnerInfo = new InformationOwnerInfo
                    {
                        OwnerType = owner.ContainerName,
                        OwnerIdentifier = owner.LocationPrefix
                    };
                currentStartingTime = currentEndingTime;
                currentEndingTime = currentEndingTime.AddMinutes(monitoringItemTimeSpanInMinutes);
                currItem.InitializeSteppedCollections();
                usageMonitorItems.Add(currItem);
            }
            return usageMonitorItems.ToArray();
        }
コード例 #10
0
 public static void ExecuteMethod_StoreObjects(UsageMonitorItem[] newMonitoringItems)
 {
     foreach (var monitoringItem in newMonitoringItems)
         monitoringItem.StoreInformation();
 }
コード例 #11
0
        private static void addValuesToMonitorItem(RequestResourceUsage resourceItem, UsageMonitorItem currMonitoringItem, int stepIndex)
        {
            var srcProcessorUsage = resourceItem.ProcessorUsage;
            var tgtProcessorUsage = currMonitoringItem.ProcessorUsages.CollectionContent[stepIndex];
            tgtProcessorUsage.Milliseconds += srcProcessorUsage.Milliseconds;
            tgtProcessorUsage.TimeRange.EndTime = tgtProcessorUsage.TimeRange.EndTime.Add(srcProcessorUsage.TimeRange.EndTime -
                                                    srcProcessorUsage.TimeRange.StartTime);
            tgtProcessorUsage.AmountOfTicks += srcProcessorUsage.AmountOfTicks;

            var srcStorageTransactionUsage = resourceItem.StorageTransactionUsage;
            if (srcStorageTransactionUsage != null)
            {
                var tgtStorageTransactionUsage = currMonitoringItem.StorageTransactionUsages.CollectionContent[stepIndex];
                tgtStorageTransactionUsage.AmountOfTransactions += srcStorageTransactionUsage.AmountOfTransactions;
            }

            var srcNetworkUsage = resourceItem.NetworkUsage;
            var tgtNetworkUsage = currMonitoringItem.NetworkUsages.CollectionContent[stepIndex];
            tgtNetworkUsage.AmountOfBytes += srcNetworkUsage.AmountOfBytes;
        }
コード例 #12
0
ファイル: TheBallCore.designer.cs プロジェクト: kallex/Caloom
        void IInformationObject.SetInstanceTreeValuesAsUnmodified()
        {
            _unmodified_SummaryName = SummaryName;

                    _unmodified_SummaryMonitoringItem = SummaryMonitoringItem;
                    if(SummaryMonitoringItem != null)
                        ((IInformationObject) SummaryMonitoringItem).SetInstanceTreeValuesAsUnmodified();
        }
コード例 #13
0
ファイル: TheBallCore.designer.cs プロジェクト: kallex/Caloom
 private void CopyContentFrom(UsageMonitorItem sourceObject)
 {
     OwnerInfo = sourceObject.OwnerInfo;
             TimeRangeInclusiveStartExclusiveEnd = sourceObject.TimeRangeInclusiveStartExclusiveEnd;
             StepSizeInMinutes = sourceObject.StepSizeInMinutes;
             ProcessorUsages = sourceObject.ProcessorUsages;
             StorageTransactionUsages = sourceObject.StorageTransactionUsages;
             StorageUsages = sourceObject.StorageUsages;
             NetworkUsages = sourceObject.NetworkUsages;
 }