/// <summary>
/// Get the usage amount based on whether it's download/upload and onpeak/offpeak/total
/// </summary>
/// <param name="usage">The usage</param>
/// <param name="directionPeakType">One of the magic strings depicting download/upload and onpeak/offpeak/total</param>
/// <returns></returns>
private double getUsageData(UsageData usage, string directionPeakType)
{
switch (directionPeakType) // ugly as hell, I know
{
case "Download onpeak":
return(usage.OnPeakDownload);
case "Upload onpeak":
return(usage.OnPeakUpload);
case "Download offpeak":
return(usage.OffPeakDownload);
case "Upload offpeak":
return(usage.OffPeakUpload);
case "Download total":
return(usage.OnPeakDownload + usage.OffPeakDownload);
case "Upload total":
return(usage.OnPeakUpload + usage.OffPeakUpload);
default:
throw new Exception("Wrong directionPeakType, baka");
}
}
public GetPricesRequest()
{
UsageData = new UsageData();
SpendData = new SpendData();
EstimatorData = new EstimatorData();
CustomFeatures = new Dictionary <string, string>();
}
async Task <UsageModel> GetCurrentReport(UsageData data)
{
var current = data.Reports.FirstOrDefault(x => x.Dimensions.Date.Date == DateTimeOffset.Now.Date);
if (current == null)
{
var guid = await service.GetUserGuid();
current = UsageModel.Create(guid);
data.Reports.Add(current);
}
current.Dimensions.Lang = CultureInfo.InstalledUICulture.IetfLanguageTag;
current.Dimensions.CurrentLang = CultureInfo.CurrentCulture.IetfLanguageTag;
current.Dimensions.AppVersion = AssemblyVersionInformation.Version;
current.Dimensions.VSVersion = vsservices.VSVersion;
if (connectionManager.Connections.Any(x => x.HostAddress.IsGitHubDotCom()))
{
current.Dimensions.IsGitHubUser = true;
}
if (connectionManager.Connections.Any(x => !x.HostAddress.IsGitHubDotCom()))
{
current.Dimensions.IsEnterpriseUser = true;
}
return(current);
}
static IUsageService CreateUsageService(UsageData data)
{
var result = Substitute.For <IUsageService>();
result.ReadLocalData().Returns(data);
return(result);
}
private void ClockOnSecondChange(object clock, DataEventArgs dataInformation)
{
var usageData = new UsageData();
DateTime date_time = SetTime();
var time = date_time.ToString("mm:ss");
using (var context = new MetricsContext())
{
var metrics =
context.ComputerDetails.FirstOrDefault(n => n.Name == dataInformation.Name);
if (metrics != null)
{
metrics.UsageDataCollection.Add(new UsageData()
{
CpuUsage = dataInformation.CpuUsage,
AvailableDiskSpaceGb = dataInformation.AvailableDiskSpaceGb,
RamUsage = dataInformation.RamUsage,
AverageDiskQueueLength = dataInformation.AverageDiskQueueLength,
Time = date_time
});
context.SaveChanges();
}
}
cpuUsageTextBox.Text = dataInformation.CpuUsage.ToString();
ramUsageTextBox.Text = dataInformation.RamUsage.ToString();
availableDiskSpaceText.Text = dataInformation.AvailableDiskSpaceGb.ToString();
averagediskqueueLengthTextBox.Text = dataInformation.AverageDiskQueueLength.ToString();
chart1.Series[0].Points.AddXY(time, dataInformation.RamUsage);
chart1.Series[1].Points.AddXY(time, dataInformation.CpuUsage);
chart1.Series[2].Points.AddXY(time, dataInformation.AvailableDiskSpaceGb);
averageDiskQueueLengthChart.Series[0].Points.AddXY(time,
dataInformation.AverageDiskQueueLength);
OnlyTenPointsInTheGraph();
}
public BoltStateMachineV1SPI(UsageData usageData, LogService logging, Authentication authentication, TransactionStateMachineSPI transactionStateMachineSPI)
{
this._usageData = usageData;
this._errorReporter = new ErrorReporter(logging);
this._authentication = authentication;
this._transactionSpi = transactionStateMachineSPI;
this._version = BOLT_SERVER_VERSION_PREFIX + Version.Neo4jVersion;
}
public string LoadUsage(string sSKU, string sSessionID)
{
try
{
//don't allow iOS 6 (or any browsers) to cache responses
System.Web.HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.NoCache);
if (!ValidateSession(sSessionID))
{
return(sInvalidSession);
}
//Convert JSON string to object list
List <UsageData> oUsageList = new List <UsageData>();
UsageData oUsage = null;
using (SqlConnection oCN = new SqlConnection(ConfigurationManager.ConnectionStrings["CN_INSIDER"].ConnectionString))
{
oCN.Open();
using (SqlCommand oCMD = new SqlCommand("", oCN))
{
oCMD.CommandText = "SELECT iID, sItemCode, sType, CONVERT(varchar(10), dtTran, 101) As dtTran, CONVERT(varchar(10), dtRequired, 101) As dtRequired, iUnits, sNotes"
+ " FROM SKUP2_FutureUsage"
+ " WHERE sItemCode = @sSKU"
+ " ORDER BY SKUP2_FutureUsage.dtTran";
oCMD.Parameters.AddWithValue("@sSKU", sSKU);
using (SqlDataReader oDR = oCMD.ExecuteReader())
{
while (oDR.Read())
{
oUsage = new UsageData();
oUsage.iID = oDR["iID"].ToString();
oUsage.sItemCode = oDR["sItemCode"].ToString();
oUsage.dtTran = oDR["dtTran"].ToString();
oUsage.dtTran_Init = oUsage.dtTran;
oUsage.dtRequired = oDR["dtRequired"].ToString();
oUsage.dtRequired_Init = oUsage.dtRequired;
oUsage.sType = oDR["sType"].ToString();
oUsage.sType_Init = oUsage.sType;
oUsage.iUnits = oDR["iUnits"].ToString();
oUsage.iUnits_Init = oUsage.iUnits;
oUsage.sNotes = oDR["sNotes"].ToString();
oUsage.sNotes_Init = oUsage.sNotes;
oUsageList.Add(oUsage);
}
}
}
}
return(new JavaScriptSerializer().Serialize(oUsageList));
}
catch (Exception ex)
{
return("WS Error: " + ex.Message.ToString());
}
}
private void UsageSelected(object sender, ItemClickEventArgs e)
{ // Select usage to view details on
ListView lst = sender as ListView;
UsageData u = e.ClickedItem as UsageData;
AppDebug.Line($"Selected usage on [{u.StartTimeString}]");
UsageContext.DisplayUsage = u;
Frame.Navigate(typeof(UsageDisplay));
}
/// <remarks/>
public void ReportUsageAsync(UsageData data, object userState)
{
if ((this.ReportUsageOperationCompleted == null))
{
this.ReportUsageOperationCompleted = new System.Threading.SendOrPostCallback(this.OnReportUsageOperationCompleted);
}
this.InvokeAsync("ReportUsage", new object[] {
data
}, this.ReportUsageOperationCompleted, userState);
}
internal DefaultUdcInformationCollector(Config config, DataSourceManager dataSourceManager, UsageData usageData)
{
this._config = config;
this._usageData = usageData;
if (dataSourceManager != null)
{
dataSourceManager.AddListener(new ListenerAnonymousInnerClass(this));
}
}
private static void Test(string[] usageData, double expectedResult)
{
RateCardData rc = GetRateCardTestData();
var ud = new UsageData();
ud.Values = GetUsageValues(usageData);
var data = Client.Combine(rc, ud);
Assert.AreEqual(expectedResult, data.TotalCosts);
}
public Task <bool> SendLocalUsage(string userId, List <ExampleUsage> usage)
{
// Should be working now.
//return TaskEx.FromResult(true);
UsageData request = new UsageData()
{
UserId = userId, Usage = usage
};
return(Post <UsageData>(request, "Submit"));
}
private static UsageData GetComponent(Node node)
{
var ud = node.Components.Get <UsageData>();
if (ud == null)
{
ud = new UsageData();
node.Components.Add(ud);
createdComponents.Add(ud);
}
return(ud);
}
private async void SubmitFeedback(object sender, TappedRoutedEventArgs e) // Send feedback to server
{
HttpResponseMessage res = null;
UsageUpdateRequest req;
double[] ranks = new double[4];
ranks = GetRanks(questionDictionary);
try
{ // Build request for server
progressRing.IsActive = true;
GlobalContext.CurrentUser.UsageSessions.LastOrDefault().usageFeedback = questionDictionary;
UsageData use = GlobalContext.CurrentUser.UsageSessions.LastOrDefault();
string userId = GlobalContext.CurrentUser.Data.UserID;
req = new UsageUpdateRequest(use.UsageStrain.Name, use.UsageStrain.ID,
userId,
((DateTimeOffset)use.StartTime).ToUnixTimeMilliseconds(),
((DateTimeOffset)use.EndTime).ToUnixTimeMilliseconds(),
ranks[0], ranks[1], ranks[2], use.HeartRateMax, use.HeartRateMin, (int)use.HeartRateAverage, ranks[3],
questionDictionary);
res = await HttpManager.Manager.Post(Constants.MakeUrl("usage"), req); // Send request
if (res != null)
{ // Request sent successfully
if (res.IsSuccessStatusCode)
{
Status.Text = "Usage update Successful!";
var index = GlobalContext.CurrentUser.UsageSessions.Count - 1;
GlobalContext.CurrentUser.UsageSessions[index].UsageId = res.GetContent()["body"];
PagesUtilities.SleepSeconds(0.5);
Frame.Navigate(typeof(DashboardPage));
}
else
{
Status.Text = "Usage update failed! Status = " + res.StatusCode;
}
}
else
{
Status.Text = "Usage update failed!\nPost operation failed";
}
Frame.Navigate(typeof(DashboardPage));
}
catch (Exception x)
{
AppDebug.Exception(x, "UsageUpdate");
}
}
public async Task WriteLocalData(UsageData data)
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(storePath));
var json = SimpleJson.SerializeObject(data);
await WriteAllTextAsync(storePath, json);
}
catch (Exception ex)
{
log.Error(ex, "Failed to write usage data");
}
}
public async Task WriteLocalData(UsageData data)
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(storePath));
var json = SimpleJson.SerializeObject(data);
await WriteAllTextAsync(storePath, json);
}
catch
{
// log.Warn("Failed to write usage data", ex);
}
}
public BoltServer(DatabaseManager databaseManager, JobScheduler jobScheduler, ConnectorPortRegister connectorPortRegister, NetworkConnectionTracker connectionTracker, UsageData usageData, Config config, Clock clock, Monitors monitors, LogService logService, DependencyResolver dependencyResolver)
{
this._databaseManager = databaseManager;
this._jobScheduler = jobScheduler;
this._connectorPortRegister = connectorPortRegister;
this._connectionTracker = connectionTracker;
this._usageData = usageData;
this._config = config;
this._clock = clock;
this._monitors = monitors;
this._logService = logService;
this._dependencyResolver = dependencyResolver;
}
void WriteDynamicDataToDb()
{
UsageData usageData = new UsageData();
usageData.CpuUsage = dataManager.GetCpuUsage();
usageData.RamUsage = dataManager.GetRamUsage();
usageData.AvailableDiskSpaceGb = dataManager.GetAvailableDiskSpaceGb();
usageData.AverageDiskQueueLength = dataManager.GetAverageDiskQueueLength();
usageData.Time = DateTime.Now;
detail.UsageDataCollection = new List <UsageData>();
detail.UsageDataCollection.Add(usageData);
context.UsageDatas.Add(usageData);
context.SaveChanges();
}
static IUsageService CreateUsageService(
UsageData data,
bool sameDay = true,
bool sameWeek = true,
bool sameMonth = true)
{
var result = Substitute.For <IUsageService>();
result.ReadLocalData().Returns(data);
result.IsSameDay(DateTimeOffset.Now).ReturnsForAnyArgs(sameDay);
result.IsSameWeek(DateTimeOffset.Now).ReturnsForAnyArgs(sameWeek);
result.IsSameMonth(DateTimeOffset.Now).ReturnsForAnyArgs(sameMonth);
return(result);
}
public async Task ShouldWriteUpdatedData()
{
var data = new UsageData {
Model = new UsageModel()
};
var service = CreateUsageService(data);
var target = new UsageTracker(
CreateServiceProvider(),
service);
await target.IncrementCounter(x => x.NumberOfClones);
await service.Received(1).WriteLocalData(data);
}
public void UpdateDynamicComputerData()
{
var usageData = new UsageData();
var manager = new FullDataManager();
usageData.AvailableDiskSpaceGb = Int32.Parse(manager.GetMetric(ComputerMetrics.AvailableDiskSpace));
usageData.AverageDiskQueueLength = Int32.Parse(manager.GetMetric(ComputerMetrics.AverageDiskQueueLength));
usageData.CpuUsage = Int32.Parse(manager.GetMetric(ComputerMetrics.CpuUsage));
usageData.RamUsage = Int32.Parse(manager.GetMetric(ComputerMetrics.RamUsage));
usageData.Time = DateTime.Now;
computerDetail.UsageDataCollection.Add(usageData);
context.UsageDatas.Add(usageData);
context.SaveChanges();
}
/// <summary>
/// Combines the ratecard data with the usage data.
/// </summary>
/// <param name="rateCardData">RateCard data</param>
/// <param name="usageData">Usage data</param>
/// <returns>The costs of the resources (combined data of ratecard and usage api)</returns>
public static ResourceCostData Combine(RateCardData rateCardData, UsageData usageData)
{
ResourceCostData rcd = new ResourceCostData()
{
Costs = new List <ResourceCosts>(),
RateCardData = rateCardData
};
// get all used meter ids
var meterIds = (from x in usageData.Values select x.Properties.MeterId).Distinct().ToList();
// aggregates all quantity and will be used to calculate costs (e.g. if quantity is included for free)
// Dictionary<MeterId, Dictionary<YearAndMonthOfBillingCycle, aggregatedQuantity>>
Dictionary <string, Dictionary <string, double> > aggQuant = meterIds.ToDictionary(x => x, x => new Dictionary <string, double>());
foreach (var usageValue in usageData.Values)
{
string meterId = usageValue.Properties.MeterId;
var rateCard = (from x in rateCardData.Meters where x.MeterId.Equals(meterId, StringComparison.OrdinalIgnoreCase) select x).FirstOrDefault();
if (rateCard == null) // e.g. ApplicationInsights: there is no ratecard data for these
{
continue;
}
var billingCycleId = GetBillingCycleIdentifier(usageValue.Properties.UsageStartTimeAsDate);
if (!aggQuant[meterId].ContainsKey(billingCycleId))
{
aggQuant[meterId].Add(billingCycleId, 0.0);
}
var usedQuantity = aggQuant[meterId][billingCycleId];
var curcosts = GetMeterRate(rateCard.MeterRates, rateCard.IncludedQuantity, usedQuantity, usageValue.Properties.Quantity);
aggQuant[meterId][billingCycleId] += usageValue.Properties.Quantity;
rcd.Costs.Add(new ResourceCosts()
{
RateCardMeter = rateCard,
UsageValue = usageValue,
CalculatedCosts = curcosts.Item1,
BillableUnits = curcosts.Item2
});
}
return(rcd);
}
public async Task ShouldIncrementCounter()
{
var model = new UsageModel {
NumberOfClones = 4
};
var usageService = CreateUsageService(model);
var target = new UsageTracker(
CreateServiceProvider(),
usageService);
await target.IncrementCounter(x => x.NumberOfClones);
UsageData result = usageService.ReceivedCalls().First(x => x.GetMethodInfo().Name == "WriteLocalData").GetArguments()[0] as UsageData;
Assert.AreEqual(5, result.Model.NumberOfClones);
}
public bool AddNewItem(UsageData usageData)
{
using (var context = new MetrixContext())
{
try
{
context.UsageDatas.Add(usageData);
context.SaveChanges();
}
catch
{
return(false);
}
return(true);
}
}
public async Task ShouldIncrementCounter()
{
var model = UsageModel.Create(Guid.NewGuid());
model.Measures.NumberOfClones = 4;
var usageService = CreateUsageService(model);
var target = new UsageTracker(
CreateServiceProvider(),
usageService,
CreatePackageSettings());
await target.IncrementCounter(x => x.NumberOfClones);
UsageData result = usageService.ReceivedCalls().First(x => x.GetMethodInfo().Name == "WriteLocalData").GetArguments()[0] as UsageData;
Assert.AreEqual(5, result.Reports[0].Measures.NumberOfClones);
}
async Task Send()
{
var uri = new Uri("http://localhost:40000");
var server = new MetricsServer.Server(uri.Host, uri.Port);
server.Start();
var client = new HttpClient();
client.DefaultRequestHeaders
.Accept
.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var request = new HttpRequestMessage(HttpMethod.Post, new Uri(uri, "/api/usage/visualstudio"));
var model = UsageModel.Create(Guid.NewGuid());
model.Dimensions.AppVersion = "9.9.9";
model.Dimensions.Lang = "en-us";
model.Dimensions.VSVersion = "14";
model.Measures.NumberOfStartups = 1;
var data = new UsageData();
data.Reports = new List <UsageModel> {
model
};
request.Content = SerializeRequest(model);
HttpResponseMessage response = null;
try
{
response = await client.SendAsync(request);
}
catch (Exception ex)
{
Debugger.Break();
}
var ret = await response.Content.ReadAsStringAsync();
Console.WriteLine(response.ToString());
Console.WriteLine(ret);
server.Stop();
}
public static void Register(Task task, long ticks)
{
var id = task.InitialEnumeratorType.ToString();
UsageData ud;
if (records.ContainsKey(id))
{
ud = records[id];
}
else
{
ud = new UsageData(id);
records[id] = ud;
}
ud.ConsumedTicks += ticks;
ud.Updates += 1;
}
private void ListView_RightTapped(object sender, RightTappedRoutedEventArgs e)
{
try
{ // Open right click menu
ListView lst = sender as ListView;
selectedUsage = ((FrameworkElement)e.OriginalSource).DataContext as UsageData;
if (selectedUsage != null)
{
UsageMenu.ShowAt(lst, e.GetPosition(lst));
AppDebug.Line($"Right click usage on [{selectedUsage.StartTimeString}]");
}
}
catch (Exception x)
{
AppDebug.Exception(x, "ListView_RightTapped");
}
}
//seriesTypes = {"Cpu usage", "Average disk quequ lenght", "Used ram"};
public void FillCharts(Chart cCpuChar, Chart cRam, string[] seriesTypes, DataManager data, string userName)
{
UsageData useData = new UsageData(data.GetComputerCpuUsage(), data.GetRam(), 50, data.GetComputerAverageLenght());
SetCharValues(cCpuChar, useData.CpuUsage, _timer, seriesTypes[0]);
SetCharValues(cCpuChar, useData.AverageDiskQueueLength, _timer, seriesTypes[1]);
SetCharValues(cRam, useData.RamUsage, _timer, seriesTypes[2]);
if (cCpuChar.Series[seriesTypes[0]].Points.Count > MaxPoints)
{
cRam.Series[seriesTypes[2]].Points.RemoveAt(0);
cCpuChar.Series[seriesTypes[1]].Points.RemoveAt(0);;
cCpuChar.Series[seriesTypes[0]].Points.RemoveAt(0);
cCpuChar.ResetAutoValues();
cRam.ResetAutoValues();
}
_timer += 5;
}
/// <summary>
/// Updates the device properties.
/// </summary>
/// <param name="usageData">The new usage data.</param>
private void UpdateDeviceProperties(UsageData usageData)
{
if (usageData.UsageTimestamp <= _usageData.UsageTimestamp)
{
return;
}
_usageData = usageData;
foreach (var property in _properties)
{
var newValue = property.GetValue(usageData, null);
if (newValue != null)
{
DevicePropertyChangeNotification(property.Name, newValue);
}
}
DevicePropertyChangeNotification("DemandCost", CalculateDemandPrice());
}
/// <remarks/>
public void ReportUsageAsync(UsageData data, object userState) {
if ((this.ReportUsageOperationCompleted == null)) {
this.ReportUsageOperationCompleted = new System.Threading.SendOrPostCallback(this.OnReportUsageOperationCompleted);
}
this.InvokeAsync("ReportUsage", new object[] {
data}, this.ReportUsageOperationCompleted, userState);
}
public void ReportUsage(UsageData data) {
this.Invoke("ReportUsage", new object[] {
data});
}
/// <remarks/>
public System.IAsyncResult BeginReportUsage(UsageData data, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("ReportUsage", new object[] {
data}, callback, asyncState);
}
/// <remarks/>
public void ReportUsageAsync(UsageData data) {
this.ReportUsageAsync(data, null);
}
