public void TestGetBackups()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var backups = client.Backup.GetBackups();
Assert.True(backups.Backups != null);
}
public void TestGetStartupScripts()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var scripts = client.StartupScript.GetStartupScripts();
Assert.True(scripts.StartupScripts.Count > 0);
}
public void TestGetInfo()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var account = client.Account.GetInfo();
Assert.True(float.TryParse(account.Account.balance, out float _));
}
public void TestGetServers()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var servers = client.Server.GetServers();
Assert.True(servers.Servers != null);
}
public void TestGetISOImages()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var images = client.ISOImage.GetISOImages();
Assert.True(images.ISOImages != null);
}
public void TestGetApplications()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var apps = client.Application.GetApplications();
var app = apps.Applications.Single(app => app.Value.name == "WordPress");
Assert.Equal("WordPress", app.Value.name);
}
public void TestGetOperatingSystems()
{
var client = new VultrClient(Settings.Default.VultrApiKey);
var systems = client.OperatingSystem.GetOperatingSystems();
Assert.NotNull(systems.OperatingSystems);
Assert.Contains(
systems.OperatingSystems,
system => system.Value.name == "Debian 10 x64 (buster)");
}
/// <summary>
/// Creates a new snapshot configuration.
/// </summary>
/// <param name="id">The ID of the snapshot.</param>
/// <param name="client">The VultrClient instance to communicate with
/// Vultr.</param>
/// <returns>The configured OS instance.</returns>
public static VultrOperatingSystem CreateSnapshot(string id, VultrClient client)
{
var snapshots = client.Snapshot.GetSnapshots();
if (!snapshots.Snapshots.ContainsKey(id))
{
throw new ArgumentException(
$"Cannot find snapshot with ID {id}", nameof(id));
}
return(new VultrOperatingSystem(SnapshotOsId, snapshotId: id));
}
/// <summary>
/// Creates a new application configuration.
/// </summary>
/// <param name="name">The name of the application.</param>
/// <param name="client">The VultrClient instance to communicate with
/// Vultr.</param>
/// <returns>The configured OS instance.</returns>
public static VultrOperatingSystem CreateApp(string name, VultrClient client)
{
var apps = client.Application.GetApplications();
KeyValuePair <string, Application> app;
try
{
app = apps.Applications.Single(
a => a.Value.deploy_name == name);
}
catch (InvalidOperationException e)
{
throw new ArgumentException(
$"Cannot find app called {name}", nameof(name), e);
}
return(new VultrOperatingSystem(AppOsId, int.Parse(app.Key)));
}
/// <summary>
/// Creates a new ISO configuration.
/// </summary>
/// <param name="name">The name of the ISO.</param>
/// <param name="client">The VultrClient instance to communicate with
/// Vultr.</param>
/// <returns>The configured OS instance.</returns>
public static VultrOperatingSystem CreateIso(string name, VultrClient client)
{
var images = client.ISOImage.GetISOImages();
KeyValuePair <string, ISOImage> iso;
try
{
iso = images.ISOImages.Single(
i => i.Value.filename == name);
}
catch (InvalidOperationException e)
{
throw new ArgumentException(
$"Cannot find ISO called {name}", nameof(name), e);
}
return(new VultrOperatingSystem(IsoOsId, isoId: int.Parse(iso.Key)));
}
/// <summary>
/// Instantiates the instance and overrides the Vultr API URL.
/// </summary>
/// <param name="apiKey">The API key to use for communicating with Vultr.</param>
/// <param name="apiUrl">The API URL for Vultr. Set this to override the
/// Vultr API endpoint (e.g. for testing).</param>
/// <exception cref="ArgumentNullException">If <param name="apiKey"> is null or
/// empty.</param></exception>
public VultrPlatform(string apiKey, string apiUrl)
{
if (string.IsNullOrWhiteSpace(apiKey))
{
throw new ArgumentNullException(
nameof(apiKey), "apiKey must be provided");
}
Client = string.IsNullOrEmpty(apiUrl) ?
new VultrClient(apiKey) : new VultrClient(apiKey, apiUrl);
AddProvisioner <Firewall>(new VultrFirewallProvisioner(Client).Provision);
AddProvisioner <Script>(new VultrScriptProvisioner(Client).Provision);
AddProvisioner <Server>(new VultrServerProvisioner(Client).Provision);
AddDestroyer <Server>(new VultrServerDestroyer(Client).Destroy);
AddDestroyer <Script>(new VultrScriptDestroyer(Client).Destroy);
AddDestroyer <Firewall>(new VultrFirewallDestroyer(Client).Destroy);
}
private static int FindOperatingSystem(string name, VultrClient client)
{
var systems = client.OperatingSystem.GetOperatingSystems();
KeyValuePair <int, OperatingSystem> system;
try
{
system = systems.OperatingSystems.Single(
s => s.Value.name == name);
}
catch (InvalidOperationException e)
{
throw new ArgumentException(
$"Cannot find Operating System called {name}",
nameof(name), e);
}
return(system.Key);
}
/// <summary>
/// Creates a new script configuration.
/// </summary>
/// <param name="name">The name of the Operating System.</param>
/// <param name="scriptName">The name of the script.</param>
/// <param name="client">The VultrClient instance to communicate with
/// Vultr.</param>
/// <returns>The configured OS instance.</returns>
public static VultrOperatingSystem CreateScript(
string name, string scriptName, VultrClient client)
{
var scripts = client.StartupScript.GetStartupScripts();
KeyValuePair <string, StartupScript> script;
try
{
script = scripts.StartupScripts.Single(
system => system.Value.name == scriptName);
}
catch (InvalidOperationException e)
{
throw new ArgumentException(
$"Cannot find script called {scriptName}",
nameof(scriptName), e);
}
return(new VultrOperatingSystem(
FindOperatingSystem(name, client), scriptId: int.Parse(script.Key)));
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to provision servers.</param>
public VultrScriptProvisioner(VultrClient client) : base(client)
{
}
/// <summary>
/// Creates a new Operating System configuration.
/// </summary>
/// <param name="name">The name of the Operating System.</param>
/// <param name="client">The VultrClient instance to communicate with
/// Vultr.</param>
/// <returns>The configured OS instance.</returns>
public static VultrOperatingSystem CreateOs(string name, VultrClient client)
{
return(new VultrOperatingSystem(FindOperatingSystem(name, client)));
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to provision servers.</param>
public VultrServerProvisioner(VultrClient client) : base(client)
{
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to provision
/// infrastructure.</param>
protected VultrProvisioner(VultrClient client)
{
Client = client ?? throw new ArgumentNullException(
nameof(client), "client must not be null");
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to destroy firewalls.</param>
public VultrFirewallDestroyer(VultrClient client) : base(client)
{
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to destroy scripts.</param>
public VultrScriptDestroyer(VultrClient client) : base(client)
{
}
/// <summary>
/// Instantiates a new instance. Starts the mock HTTP server.
/// </summary>
/// <param name="handlers"></param>
/// <exception cref="ArgumentNullException">If <paramref name="handlers"/> is
/// null.</exception>
public MockVultrRequests(params HttpHandler[] handlers) :
base(handlers)
{
Client = new VultrClient("abc123", Url);
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to destroy servers.</param>
public VultrServerDestroyer(VultrClient client) : base(client)
{
}
/// <summary>
/// Instantiates a new instance.
/// </summary>
/// <param name="client">The VultrClient to use to provision firewalls.</param>
public VultrFirewallProvisioner(VultrClient client) : base(client)
{
}
