/// <summary>
/// Get model returns the IModel model to work with
/// </summary>
/// <returns></returns>
private IModel getModel()
{
IModel model = null;
switch (this)
{
case Triggers.Http.LocationTZ locationTZ:
model = new Models.LocationTZ(this._backend, this._logger);
break;
case Triggers.Http.Setting setting:
model = new Models.Setting(this._backend, this._logger);
break;
case Triggers.Http.Subscription subscription:
model = new Models.Subscription(this._backend, this._logger);
break;
default:
_logger.Fatal("Model is not known to the system: {model}", this.GetType().Name);
break;
}
if (model != null)
{
_logger.Verbose("Creating model instance: {Model}", model.GetType().Name);
}
return(model);
}
public bool Process(List <Models.Subscription> subscriptions, Models.LocationTZ locationTZ)
{
// bool error = false;
// Uri webhook_url = null;
// Create a list of resource group candidates that may be deleted
List <string> resource_group_candidates = new List <string>();
// Define a variable to accept the response from SlackClient
HttpResponseMessage response = new HttpResponseMessage();
bool destroy = Convert.ToBoolean(settings.First(s => s.name == "destroy").value);
bool manage_vms = Convert.ToBoolean(settings.First(s => s.name == "manage_vms").value);
// get a list of the timezones to work with
timezones = locationTZ.GetByName().GetData();
// Create a connection to Slack
// ensure that the webhook url can be turned into a URI
/*
* try
* {
* webhook_url = new Uri(settings.First(s => s.name == "webhook_url").value);
* }
* catch
* {
* string msg = (String.Format("Unable to create a URI from `webhook_url`: {0}", settings.First(s => s.name == "webhook_url").value));
* log.LogInformation(msg);
* error = true;
* }
*/
// if (!error)
// {
// SlackClient slackClient = new SlackClient(
// webhook_url,
// settings.First(s => s.name == "bot_username").value,
// settings.First(s => s.name == "icon_url").value,
// settings.First(s => s.name == "token").value,
// log,
// Convert.ToBoolean(settings.First(s => s.name == "slack_enabled").value)
// );
// // Get all the subscriptions that have the reaper enabled on them
// IEntity subscription = new Subscription(client, log);
// // dynamic subscriptions = subscription.Get(subscription);
// IEnumerable<Subscription> subscriptions = subscription.GetUsingSQL("SELECT * FROM subscriptions t WHERE t.enabled = true");
// // Get al the timezones
// LocationTZ timezone = new LocationTZ(client, log);
// IEnumerable<LocationTZ> timezones = timezone.GetAll();
// Define timestamp to work against so it is the same time for all checks
// DateTime timeNowUtc = DateTime.UtcNow;
// Create a NotificationDelay object to use to
// get previous notification alerts and add new ones
// NotificationDelay notificationDelay = new NotificationDelay(client, log);
// iterate around the subscriptions and check the resource groups and vms in each
foreach (Subscription sub in subscriptions)
{
// only proceed if the reaper has been enabled on the subscription
/*
* if (!sub.reaper) {
* _logger.Information("Reaper is not enabled on subscription: {name} [{id}]", sub.name, sub.subscription_id);
* continue;
* }
*/
// Determine the timenow to be used as criteria
// This is done on each subscription because there might be a lot of groups to enumerate
timeNowUtc = DateTime.UtcNow;
string time_now = timeNowUtc.ToString("yyyy-MM-ddTHH:mm:ssZ");
// Login to Azure with the credentials for this subscription
azure = Utilities.AzureLogin(sub, AzureEnvironment.AzureGlobalCloud, _logger);
// get a list of resource groups in the subscription
IEnumerable <IResourceGroup> resource_groups = azure.ResourceGroups.List();
// iterate around the resource groups
foreach (IResourceGroup resource_group in resource_groups)
{
Resources.Group rg = new Resources.Group(
resource_group,
_backend,
_logger,
settings,
_notificationDelay,
sub.subscription_id,
timezones,
timeNowUtc
);
// Determine if the resource group has expired or not
bool notify = rg.ShouldNotify();
bool expired = rg.ShouldDelete();
_logger.Information(
"Considering {group}: Notify = {notify}, Delete = {delete}",
resource_group.Name,
notify.ToString(),
expired.ToString()
);
/*
* if (notify)
* {
* // Attempt to get the slack userid for the email address
* //slackClient.GetUserIdByEmail(rg.emailAddress);
*
* // Set the properties of the slack message
* //slackClient.AddField("Name", resource_group.Name);
* //slackClient.AddField("Expiry Date", rg.expiryDate.ToString("yyyy-MM-ddTHH:mm:ss"));
*
* // Add the message to the slack client
* //slackClient.AddAttachmentItem(rg.message, rg.level);
*
* // Send the slack message
* //response = await slackClient.SendMessageAsync();
*
* // Set a record in the notification delay that this resource group has had
* // a notification sent out
* NotificationDelay nd = new NotificationDelay();
* nd.subscription_id = sub.subscription_id;
* nd.group_name = resource_group.Name;
* nd.type = "resource_group";
*
* await _notificationDelay.Upsert(nd);
* }
*/
// If the group has expired, delete it
// Otherwise work out what machines need to be powered on or off
if (expired)
{
azure.ResourceGroups.DeleteByNameAsync(resource_group.Name);
}
else
{
// Initialise the powerstatistics to be used for notifications
powerStats = new PowerStatistics();
// So that the Slack user is not inundated with messages, ensure that all machines that have been
// found to be in violation of running times are bundled up
// List<string> stopped = new List<string>();
// List<string> started = new List<string>();
/*
* // as the resource group is valid look at the virtual machines that are running
* // and determine if they should be shutdown or not
* IEnumerable<IVirtualMachine> vms = azure.VirtualMachines.ListByResourceGroup(resource_group.Name);
*
* foreach (IVirtualMachine vm in vms)
* {
* // create a virtualMachine object to work with
* VirtualMachine virtualMachine = new VirtualMachine(
* sub.subscription_id,
* vm,
* _logger,
* settings,
* _notificationDelay,
* rg,
* timezones,
* timeNowUtc
* );
*
* // Set the power state of the machine
* VirtualMachine.Status powerStatus = virtualMachine.SetPowerState();
*
* // Using the powerStatus determine what has been started and what has been stopped
* if (powerStatus == VirtualMachine.Status.Started && !virtualMachine.NotifiedWithinTimePeriod())
* {
* started.Add(virtualMachine.GetName());
* }
*
* if (powerStatus == VirtualMachine.Status.Stopped && !virtualMachine.NotifiedWithinTimePeriod())
* {
* stopped.Add(virtualMachine.GetName());
* }
*
* // Add a notification for this machine
* /*
* NotificationDelay nd = new NotificationDelay();
* nd.subscription_id = sub.subscription_id;
* nd.group_name = resource_group.Name;
* nd.type = "virtual_machine";
* nd.name = virtualMachine.GetName();
*
* await _notificationDelay.Upsert(nd);
*
*
* }
*/
manageVirtualMachines(resource_group);
manageK8sClusters(resource_group);
// only send out messages for VMs if there are some
//if (vms.Count() > 0 && (started.Count > 0 || stopped.Count > 0))
// {
// // Define the properties of the slack message to send
// slackClient.AddField("Name", resource_group.Name);
// slackClient.AddField("VMs Started", String.Join("\n", started));
// slackClient.AddField("VMs Stopped", String.Join("\n", stopped));
// // Define the message that needs to be attached
// string message = "The following machines have been stopped or started.";
// if (!manage_vms)
// {
// message += " Reaper is not currently running in active mode, no machines have been stopped or started.";
// }
// slackClient.AddAttachmentItem(message, "warning");
// // Send a slack message to the owner
// response = await slackClient.SendMessageAsync();
// }
}
}
}
// }
return(true);
}