public static void ClassInitialize(TestContext testContext)
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
string serverName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName();
Flavor flavor = UserComputeTests.ListAllFlavorsWithDetails(provider).OrderBy(i => i.RAMInMB).ThenBy(i => i.DiskSizeInGB).FirstOrDefault();
if (flavor == null)
Assert.Inconclusive("Couldn't find a flavor to use for the test server.");
SimpleServerImage[] images = UserComputeTests.ListAllImages(provider).ToArray();
SimpleServerImage image = images.FirstOrDefault(i => i.Name.IndexOf("CentOS 6.0", StringComparison.OrdinalIgnoreCase) >= 0);
if (image == null)
Assert.Inconclusive("Couldn't find the CentOS 6.0 image to use for the test server.");
Stopwatch timer = Stopwatch.StartNew();
Console.Write("Creating server for image {0}...", image.Name);
NewServer server = provider.CreateServer(serverName, image.Id, flavor.Id);
Assert.IsNotNull(server);
Assert.IsFalse(string.IsNullOrEmpty(server.Id));
_password = server.AdminPassword;
_server = provider.WaitForServerActive(server.Id);
Assert.IsNotNull(_server);
Assert.AreEqual(server.Id, _server.Id);
Assert.AreEqual(ServerState.Active, _server.Status);
Console.WriteLine("done. {0} seconds", timer.Elapsed.TotalSeconds);
}
public void TestInitialize()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
Server server = provider.GetDetails(_server.Id);
if (server.Status != ServerState.Active)
Assert.Inconclusive("Could not run test because the server is in the '{0}' state (expected '{1}').", server.Status, ServerState.Active);
}
private async Task<CloudServersServerNode> CreateServerNodeAsync(CloudServersProvider provider, Server server, FlavorDetails[] flavors, ServerImage[] images)
{
FlavorDetails flavor = flavors.FirstOrDefault(i => server.Flavor != null && string.Equals(server.Flavor.Id, i.Id, StringComparison.OrdinalIgnoreCase));
try
{
if (flavor == null && server.Flavor != null)
flavor = await Task.Run(() => provider.GetFlavor(server.Flavor.Id));
}
catch (ResponseException)
{
// ignore
flavor = null;
}
ServerImage image = images.FirstOrDefault(i => server.Image != null && string.Equals(server.Image.Id, i.Id, StringComparison.OrdinalIgnoreCase));
try
{
if (image == null && server.Image != null)
image = await Task.Run(() => provider.GetImage(server.Image.Id));
}
catch (ResponseException)
{
// ignore
image = null;
}
return new CloudServersServerNode(provider, server, flavor, image);
}
public void Should_Return_At_Least_One_Image_When_Searching_By_Valid_Name()
{
var validImage = _allImages.First();
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImages(imageName: validImage.Name);
Assert.IsTrue(images.Any());
}
public void Should_Return_At_Least_One_Image_When_Searching_By_Valid_Change_Since_Date()
{
var validImage = _allImages.First();
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImages(changesSince: validImage.Updated.AddSeconds(-1));
Assert.IsTrue(images.Any());
}
public void Should_Create_A_New_Server_In_DFW()
{
var provider = new CloudServersProvider(_testIdentity);
_newTestServer = provider.CreateServer("net-sdk-test-server", _initImage.Id, _initFlavor.Id);
Assert.IsNotNull(_newTestServer);
Assert.IsNotNull(_newTestServer.Id);
}
public void Should_Return_One_Image_With_Details_When_Searching_By_Valid_Id()
{
var validImage = _allImages.First(i => i.Server != null);
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(server: validImage.Server.Id);
Assert.IsTrue(images.Any());
}
public void Should_Return_At_Least_One_Image_With_Details_When_Searching_By_Valid_Status()
{
var validImage = _allImages.First();
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(imageStatus: validImage.Status);
Assert.IsTrue(images.Any());
}
public void Should_Get_List_All_Images_With_Details()
{
var provider = new CloudServersProvider(_testIdentity);
_allImages = provider.ListImagesWithDetails(identity: _testIdentity);
Assert.IsTrue(_allImages.Any());
}
public void Should_Create_A_New_Server_In_DFW()
{
var provider = new CloudServersProvider(_testIdentity);
_testServer = provider.CreateServer("net-sdk-test-server", "d531a2dd-7ae9-4407-bb5a-e5ea03303d98", "2");
Assert.IsNotNull(_testServer);
Assert.IsNotNull(_testServer.Id);
}
public void Should_Create_A_New_Complex_Server_In_DFW()
{
var provider = new CloudServersProvider(_testIdentity);
_newTestServer2 = provider.CreateServer("net-sdk-test-server2", _initImage.Id, _initFlavor.Id, metadata: new Metadata { { "Key1", "Value1" }, { "Key2", "Value2" } }, attachToPublicNetwork: true, attachToServiceNetwork: true);
Assert.IsNotNull(_newTestServer2);
Assert.IsNotNull(_newTestServer2.Id);
}
public void Should_Create_A_New_Complex_Server_In_DFW()
{
var provider = new CloudServersProvider(_testIdentity);
_testServer2 = provider.CreateServer("net-sdk-test-server2", "d531a2dd-7ae9-4407-bb5a-e5ea03303d98", "2", metadata: new Metadata{{"Key1", "Value1"}, {"Key2", "Value2"}}, attachToPublicNetwork: true, attachToServiceNetwork: true);
Assert.IsNotNull(_testServer2);
Assert.IsNotNull(_testServer2.Id);
}
public void Should_Create_A_New_Server_In_DFW()
{
var provider = new CloudServersProvider(_testIdentity);
_newTestServer = provider.CreateServer("net-sdk-test-server", _initImage.Id, _initFlavor.Id);
Assert.IsNotNull(_newTestServer);
Assert.IsNotNull(_newTestServer.Id);
}
public static void Init(TestContext context)
{
_testIdentity = new RackspaceCloudIdentity(Bootstrapper.Settings.TestIdentity);
var provider = new CloudServersProvider(_testIdentity);
_initImage = provider.ListImages(imageName: "CentOS 6.3").First();
_initFlavor = provider.ListFlavors().OrderBy(f => f.Id).First();
}
public void Should_Wait_Until_Server_Becomes_Active_Or_A_Maximum_Of_10_Minutes()
{
var provider = new CloudServersProvider(_testIdentity);
var serverDetails = provider.WaitForServerActive(_testServer.Id);
Assert.IsNotNull(serverDetails);
Assert.AreEqual("ACTIVE", serverDetails.Status);
}
public void Should_Retrieve_Image_By_Name()
{
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails();
_testImage = images.First(i => i.Name == _testImageName);
Assert.IsNotNull(_testImage);
}
public static void Init(TestContext context)
{
_testIdentity = new RackspaceCloudIdentity(Bootstrapper.Settings.TestIdentity);
var provider = new CloudServersProvider(_testIdentity);
_initImage = provider.ListImages(imageName: "CentOS 6.3").First();
_initFlavor = provider.ListFlavors().OrderBy(f => f.Id).First();
}
public void Should_Get_A_List_Of_Servers_With_Details_Which_Should_Include_The_Newly_Created_Server()
{
var provider = new CloudServersProvider(_testIdentity);
var servers = provider.ListServersWithDetails();
Assert.IsNotNull(servers);
Assert.IsTrue(servers.Any());
Assert.IsNotNull(servers.FirstOrDefault(s => s.Id == _testServer.Id));
}
public static void Main(string[] args)
{
if (args.Length < 2 || args.Length > 3)
{
Console.WriteLine("Usage: {0} username api_key [region (US|UK)]", Environment.CommandLine);
Environment.Exit(1);
}
RackspaceImpersonationIdentity auth = new RackspaceImpersonationIdentity();
auth.Username = args[0];
auth.APIKey = args[1];
if (args.Length == 3)
{
if (args[2] != "UK" && args[2] != "US")
{
Console.WriteLine("region must be either US or UK", Environment.CommandLine);
Environment.Exit(1);
}
switch (args[2])
{
case "UK": { auth.CloudInstance = CloudInstance.UK; }; break;
case "US": { auth.CloudInstance = CloudInstance.Default; }; break;
}
}
else
{
auth.CloudInstance = CloudInstance.Default;
}
try
{
IIdentityProvider identityProvider = new CloudIdentityProvider();
var userAccess = identityProvider.Authenticate(auth);
}
catch (ResponseException ex2)
{
Console.WriteLine("Authentication failed with the following message: {0}", ex2.Message);
Environment.Exit(1);
}
var cloudServers = new CloudServersProvider(auth);
var servers = cloudServers.ListServers();
foreach (Server serv in servers)
{
var date = System.DateTime.Now;
var success = serv.CreateSnapshot(serv.Name + "_" + date.Year + "-" + date.Month + "-" + date.Day);
if (success)
{
Console.WriteLine("Image for server {0} has been created successfully.", serv.Name);
}
else
{
Console.WriteLine("Image for server {0} could not be created.", serv.Name);
}
}
}
public void TestSoftRebootServer()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
bool rebootResult = provider.RebootServer(_server.Id, RebootType.Soft);
Assert.IsTrue(rebootResult);
Server rebootServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, rebootServer.Status);
}
public void TestInitialize()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
Server server = provider.GetDetails(_server.Id);
if (server.Status != ServerState.Active)
{
Assert.Inconclusive("Could not run test because the server is in the '{0}' state (expected '{1}').", server.Status, ServerState.Active);
}
}
public async Task Run(string username, string apiKey, string region)
{
// Configure authentication
var identity = new CloudIdentity
{
Username = username,
APIKey = apiKey
};
var identityService = new CloudIdentityProvider(identity);
var result = identityService.Authenticate();
var serverService = new CloudServersProvider(identity, region, null, null);
var rackConnectService = new RackConnectService(identityService, region);
// Create a cloud server on your hybrid network
Console.WriteLine($"Looking up your RackConnect network in {region}...");
var networks = await rackConnectService.ListNetworksAsync();
var network = networks.FirstOrDefault();
if (network == null)
{
throw new Exception($"You do not have a Hybrid Cloud / RackConnect network configured in the {region} which is required to run this sample.");
}
Console.WriteLine("Creating sample cloud server... ");
// Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)
const string ubuntuImageId = "09de0a66-3156-48b4-90a5-1cf25a905207";
// 512MB Standard Instance
const string standardFlavorId = "2";
var requestedServer = serverService.CreateServer("sample", ubuntuImageId, standardFlavorId,
networks: new string[] { network.Id });
serverService.WaitForServerActive(requestedServer.Id);
Console.WriteLine("Allocating a public IP address...");
var ip = await rackConnectService.CreatePublicIPAsync(
new PublicIPCreateDefinition { ShouldRetain = true });
await ip.WaitUntilActiveAsync();
Console.WriteLine($"Acquired {ip.PublicIPv4Address}!");
Console.WriteLine("Assigning the public IP to the sample cloud server...");
await ip.AssignAsync(requestedServer.Id);
await ip.WaitUntilActiveAsync();
Console.WriteLine("Deleting sample cloud server...");
serverService.DeleteServer(requestedServer.Id);
Console.WriteLine("Deallocating the public IP address...");
await ip.DeleteAsync();
}
public void Should_Rebuild_Server()
{
_preBuildDetails = _testServer.GetDetails();
var provider = new CloudServersProvider(_testIdentity);
var image = provider.ListImages().First(i => i.Name.Contains("CentOS") && i.Id != _preBuildDetails.Image.Id);
var flavor = int.Parse(_preBuildDetails.Flavor.Id) + 1;
_rebuildServerSuccess = _testServer.Rebuild(string.Format("{0}_REBUILD", _preBuildDetails.Name), image.Id, flavor.ToString(), _newTestServer.AdminPassword);
Assert.IsTrue(_rebuildServerSuccess);
}
public void Should_Create_A_New_Complex_Server_In_DFW()
{
var provider = new CloudServersProvider(_testIdentity);
_newTestServer2 = provider.CreateServer("net-sdk-test-server2", _initImage.Id, _initFlavor.Id, metadata: new Metadata {
{ "Key1", "Value1" }, { "Key2", "Value2" }
}, attachToPublicNetwork: true, attachToServiceNetwork: true);
Assert.IsNotNull(_newTestServer2);
Assert.IsNotNull(_newTestServer2.Id);
}
public CloudServersServerNode(CloudServersProvider provider, Server server, FlavorDetails flavor, ServerImage image)
{
if (provider == null)
throw new ArgumentNullException("provider");
if (server == null)
throw new ArgumentNullException("server");
this._provider = provider;
this._server = server;
this._flavor = flavor;
this._image = image;
}
public static void ClassCleanup()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
Stopwatch timer = Stopwatch.StartNew();
Console.Write(" Deleting...");
bool deleted = provider.DeleteServer(_server.Id);
Assert.IsTrue(deleted);
provider.WaitForServerDeleted(_server.Id);
Console.Write("done. {0} seconds", timer.Elapsed.TotalSeconds);
}
public void TestServerMetadata()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
Metadata initialMetadata = provider.ListServerMetadata(_server.Id);
if (initialMetadata.Count > 0)
{
Console.WriteLine("Actual metadata");
foreach (KeyValuePair <string, string> meta in initialMetadata)
{
Console.WriteLine(" {0}: {1}", meta.Key, meta.Value);
}
Assert.Inconclusive("Expected the server to not have any initial metadata.");
}
Assert.IsTrue(provider.SetServerMetadataItem(_server.Id, "Item 1", "Value"));
Assert.AreEqual("Value", provider.GetServerMetadataItem(_server.Id, "Item 1"));
Assert.IsTrue(provider.SetServerMetadataItem(_server.Id, "Item 2", "Value ²"));
Assert.AreEqual("Value ²", provider.GetServerMetadataItem(_server.Id, "Item 2"));
// setting the same key overwrites the previous value
Assert.IsTrue(provider.SetServerMetadataItem(_server.Id, "Item 1", "Value 1"));
Assert.AreEqual("Value 1", provider.GetServerMetadataItem(_server.Id, "Item 1"));
Assert.IsTrue(provider.DeleteServerMetadataItem(_server.Id, "Item 1"));
Assert.IsFalse(provider.ListServerMetadata(_server.Id).ContainsKey("Item 1"));
Metadata metadata = new Metadata()
{
{ "Different", "Variables" },
};
Assert.IsTrue(provider.UpdateServerMetadata(_server.Id, metadata));
Metadata actual = provider.ListServerMetadata(_server.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(2, actual.Count);
Assert.AreEqual("Value ²", actual["Item 2"]);
Assert.AreEqual("Variables", actual["Different"]);
// a slight tweak
metadata["Different"] = "Values";
Assert.IsTrue(provider.SetServerMetadata(_server.Id, metadata));
actual = provider.ListServerMetadata(_server.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual("Values", actual["Different"]);
Assert.IsTrue(provider.SetServerMetadata(_server.Id, new Metadata()));
Assert.AreEqual(0, provider.ListServerMetadata(_server.Id).Count);
}
public static void Init(TestContext context)
{
_testIdentity = new RackspaceCloudIdentity(Bootstrapper.Settings.TestIdentity);
var provider = new CloudServersProvider(_testIdentity);
_initImage = provider.ListImages(imageName: "CentOS 6.3").First();
_initFlavor = provider.ListFlavors().OrderBy(f => f.Id).First();
var netProvider = new CloudNetworksProvider(_testIdentity);
var networks = netProvider.ListNetworks();
_testNetwork = networks.FirstOrDefault(n => !n.Label.Equals("public") && !n.Label.Equals("private"));
}
public void TestChangeAdministratorPassword()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
string password = Path.GetTempPath();
bool changePasswordResult = provider.ChangeAdministratorPassword(_server.Id, password);
Assert.IsTrue(changePasswordResult);
_password = password;
Server changePasswordServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, changePasswordServer.Status);
}
public void TestAttachServerVolume()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
IBlockStorageProvider blockStorageProvider = new CloudBlockStorageProvider(Bootstrapper.Settings.TestIdentity);
VolumeType volumeType = UserBlockStorageTests.GetSsdVolumeTypeOrDefault(blockStorageProvider);
string volumeName = UserBlockStorageTests.UnitTestVolumePrefix + Path.GetRandomFileName();
Volume volume = blockStorageProvider.CreateVolume(UserBlockStorageTests.MinimumVolumeSize, displayName: volumeName, volumeType: volumeType != null ? volumeType.Id : null);
Assert.AreEqual(VolumeState.Available, blockStorageProvider.WaitForVolumeAvailable(volume.Id).Status);
/* AttachServerVolume
*/
ServerVolume serverVolume = provider.AttachServerVolume(_server.Id, volume.Id);
Assert.IsNotNull(serverVolume);
Assert.IsFalse(string.IsNullOrEmpty(serverVolume.Id));
Assert.AreEqual(_server.Id, serverVolume.ServerId);
Assert.AreEqual(volume.Id, serverVolume.VolumeId);
Assert.AreEqual(VolumeState.InUse, blockStorageProvider.WaitForVolumeState(volume.Id, VolumeState.InUse, new[] { VolumeState.Available, VolumeState.Error }).Status);
/* ListServerVolumes
*/
ServerVolume[] serverVolumes = provider.ListServerVolumes(_server.Id).ToArray();
Assert.IsNotNull(serverVolumes);
Assert.AreEqual(1, serverVolumes.Length);
Assert.AreEqual(serverVolume.Id, serverVolumes[0].Id);
Assert.AreEqual(serverVolume.ServerId, serverVolumes[0].ServerId);
Assert.AreEqual(serverVolume.VolumeId, serverVolumes[0].VolumeId);
/* GetServerVolumeDetails
*/
ServerVolume volumeDetails = provider.GetServerVolumeDetails(_server.Id, volume.Id);
Assert.IsNotNull(volumeDetails);
Assert.AreEqual(serverVolume.Id, volumeDetails.Id);
Assert.AreEqual(serverVolume.ServerId, volumeDetails.ServerId);
Assert.AreEqual(serverVolume.VolumeId, volumeDetails.VolumeId);
bool detach = provider.DetachServerVolume(_server.Id, volume.Id);
Assert.IsTrue(detach);
ServerVolume[] remainingVolumes = provider.ListServerVolumes(_server.Id).ToArray();
Assert.AreEqual(0, remainingVolumes.Length);
Assert.AreEqual(VolumeState.Available, blockStorageProvider.WaitForVolumeAvailable(volume.Id).Status);
bool deleted = blockStorageProvider.DeleteVolume(volume.Id);
Assert.IsTrue(blockStorageProvider.WaitForVolumeDeleted(volume.Id));
}
public static void ClassCleanup()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
Stopwatch timer = Stopwatch.StartNew();
Console.Write(" Deleting...");
bool deleted = provider.DeleteServer(_server.Id);
Assert.IsTrue(deleted);
provider.WaitForServerDeleted(_server.Id);
Console.Write("done. {0} seconds", timer.Elapsed.TotalSeconds);
}
public void Should_Verify_Server_Is_Deleted()
{
var provider = new CloudServersProvider(_testIdentity);
try
{
var server = provider.GetDetails(_created_server_id);
Assert.Fail("Deleted server was still found");
}
catch (Exception ex)
{
Assert.AreEqual(ex.GetType(), typeof(net.openstack.Core.Exceptions.Response.ItemNotFoundException), "Expected ItemNotFoundException was not thrown");
}
}
public static void Init(TestContext context)
{
_testIdentity = new RackspaceCloudIdentity(Bootstrapper.Settings.TestIdentity);
var provider = new CloudServersProvider(_testIdentity);
_initImage = provider.ListImages(imageName: "CentOS 6.3").First();
_initFlavor = provider.ListFlavors().OrderBy(f => f.Id).First();
var netProvider = new CloudNetworksProvider(_testIdentity);
var networks = netProvider.ListNetworks();
_testNetwork = networks.FirstOrDefault(n => !n.Label.Equals("public") && !n.Label.Equals("private"));
}
public void Should_Get_List_All_Images_Which_should_Equal_Base_And_Snapshot_Combined()
{
var provider = new CloudServersProvider(_testIdentity);
var allImages = provider.ListImages(identity: _testIdentity);
var baseImages = provider.ListImages(imageType: ImageType.Base);
var snapImages = provider.ListImages(imageType: ImageType.Snapshot);
Assert.IsTrue(allImages.Any());
Assert.IsTrue(allImages.Count() == (baseImages.Count() + snapImages.Count()));
foreach (var image in allImages)
{
Assert.IsTrue(baseImages.Any(i => i.Id.Equals(image.Id, StringComparison.OrdinalIgnoreCase)) ^ snapImages.Any(i => i.Id.Equals(image.Id, StringComparison.OrdinalIgnoreCase)));
}
}
public void TestUpdateServer()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
string newName = UserComputeTests.UnitTestServerPrefix + Path.GetRandomFileName() + "²";
bool updated = provider.UpdateServer(_server.Id, name: newName);
Assert.IsTrue(updated);
Server updatedServer = provider.GetDetails(_server.Id);
Assert.AreEqual(_server.Id, updatedServer.Id);
Assert.AreEqual(newName, updatedServer.Name);
Assert.AreNotEqual(_server.Name, updatedServer.Name);
_server = updatedServer;
}
public void Should_Create_A_Server_With_New_Network_And_Wait_For_Active()
{
var provider = new CloudServersProvider(_testIdentity);
var networks = new List <Guid>()
{
new Guid(_created_network_id2)
};
var testServer = provider.CreateServer("net-sdk-test-server", "d531a2dd-7ae9-4407-bb5a-e5ea03303d98", "2", networks: networks);
Assert.IsNotNull(testServer.Id);
_created_server_id = testServer.Id;
var serverDetails = provider.WaitForServerActive(_created_server_id);
Assert.AreEqual("ACTIVE", serverDetails.Status);
}
public async Task Run(string username, string apiKey, string region)
{
// Configure authentication
var identity = new CloudIdentity
{
Username = username,
APIKey = apiKey
};
var identityService = new CloudIdentityProvider(identity);
var result = identityService.Authenticate();
var serverService = new CloudServersProvider(identity, region, null, null);
var rackConnectService = new RackConnectService(identityService, region);
// Create a cloud server on your hybrid network
Console.WriteLine($"Looking up your RackConnect network in {region}...");
var networks = await rackConnectService.ListNetworksAsync();
var network = networks.FirstOrDefault();
if (network == null)
throw new Exception($"You do not have a Hybrid Cloud / RackConnect network configured in the {region} which is required to run this sample.");
Console.WriteLine("Creating sample cloud server... ");
// Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)
const string ubuntuImageId = "09de0a66-3156-48b4-90a5-1cf25a905207";
// 512MB Standard Instance
const string standardFlavorId = "2";
var requestedServer = serverService.CreateServer("sample", ubuntuImageId, standardFlavorId,
networks: new string[] {network.Id});
serverService.WaitForServerActive(requestedServer.Id);
Console.WriteLine("Allocating a public IP address...");
var ip = await rackConnectService.CreatePublicIPAsync(
new PublicIPCreateDefinition {ShouldRetain = true});
await ip.WaitUntilActiveAsync();
Console.WriteLine($"Acquired {ip.PublicIPv4Address}!");
Console.WriteLine("Assigning the public IP to the sample cloud server...");
await ip.AssignAsync(requestedServer.Id);
await ip.WaitUntilActiveAsync();
Console.WriteLine("Deleting sample cloud server...");
serverService.DeleteServer(requestedServer.Id);
Console.WriteLine("Deallocating the public IP address...");
await ip.DeleteAsync();
}
public void TestRescueServer()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
string rescueResult = provider.RescueServer(_server.Id);
Assert.IsFalse(string.IsNullOrEmpty(rescueResult));
Server rescueServer = provider.WaitForServerState(_server.Id, ServerState.Rescue, new[] { ServerState.Error });
Assert.AreEqual(ServerState.Rescue, rescueServer.Status);
bool unrescueResult = provider.UnRescueServer(_server.Id);
Assert.IsTrue(unrescueResult);
Server unrescueServer = provider.WaitForServerActive(_server.Id);
Assert.AreEqual(ServerState.Active, unrescueServer.Status);
}
public void TestGetImageMetadataItem()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
IEnumerable <ServerImage> images = ListAllImagesWithDetails(provider);
Assert.IsNotNull(images);
if (!images.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any images.");
}
int hadMetadata = 0;
int metadataCount = 0;
foreach (ServerImage image in images)
{
Assert.IsNotNull(image);
Metadata metadata = provider.ListImageMetadata(image.Id);
if (metadata.Count == 0)
{
continue;
}
hadMetadata++;
metadataCount += metadata.Count;
Console.WriteLine("Checking {0} metadata items for image '{1}'...", metadata.Count, image.Name);
foreach (KeyValuePair <string, string> pair in metadata)
{
Assert.AreEqual(pair.Value, provider.GetImageMetadataItem(image.Id, pair.Key));
}
if (hadMetadata >= 3 && metadataCount >= 30)
{
// this can be slow for a large number of images and metadata items,
// so stop after several are tested
break;
}
}
if (hadMetadata == 0)
{
Assert.Inconclusive("None of the images contained metadata.");
}
}
public void CleanupServers()
{
var provider = new CloudServersProvider(_testIdentity);
var srvs = provider.ListServers();
foreach (var svr in srvs.Where(s => s.Name == "net-sdk-test-server"))
{
provider.DeleteServer(svr.Id);
}
var networkProvider = new CloudNetworksProvider(_testIdentity);
var networks = networkProvider.ListNetworks();
foreach (var network in networks.Where(n => n.Label == "net-sdk-test-network" || n.Label == "net-sdk-test-network-for-server"))
{
networkProvider.DeleteNetwork(network.Id);
}
}
static void Main(string[] args)
{
var identity = new CloudIdentity
{
Username = Environment.GetEnvironmentVariable("OPENSTACKNET_USER"),
APIKey = Environment.GetEnvironmentVariable("OPENSTACKNET_APIKEY")
};
var authProvider = new CloudIdentityProvider(identity);
Console.WriteLine("--- Servers ---");
var serversProvider = new CloudServersProvider(identity);
var servers = serversProvider.ListServers();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Id\t\t\t\t\tName");
Console.ResetColor();
Console.WriteLine();
foreach (var server in servers)
{
Console.WriteLine("{0}\t{1}", server.Id, server.Name);
}
Console.WriteLine();
Console.WriteLine("--- CDN Services ---");
var cdnService = new ContentDeliveryNetworkService(authProvider, "DFW");
var cdns = cdnService.ListServices();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Id\t\t\t\t\tName");
Console.ResetColor();
Console.WriteLine();
foreach (var cdn in cdns)
{
Console.WriteLine("{0}\t{1}", cdn.Id, cdn.Name);
}
Console.WriteLine();
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
static void Main(string[] args)
{
var identity = new CloudIdentity
{
Username = Environment.GetEnvironmentVariable("OPENSTACKNET_USER"),
APIKey = Environment.GetEnvironmentVariable("OPENSTACKNET_APIKEY")
};
var authProvider = new CloudIdentityProvider(identity);
Console.WriteLine("--- Servers ---");
var serversProvider = new CloudServersProvider(identity);
var servers = serversProvider.ListServers();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Id\t\t\t\t\tName");
Console.ResetColor();
Console.WriteLine();
foreach (var server in servers)
{
Console.WriteLine("{0}\t{1}", server.Id, server.Name);
}
Console.WriteLine();
Console.WriteLine("--- CDN Services ---");
var cdnService = new ContentDeliveryNetworkService(authProvider, "DFW");
var cdns = cdnService.ListServices();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Id\t\t\t\t\tName");
Console.ResetColor();
Console.WriteLine();
foreach (var cdn in cdns)
{
Console.WriteLine("{0}\t{1}", cdn.Id, cdn.Name);
}
Console.WriteLine();
Console.WriteLine("Press any key to exit...");
Console.ReadLine();
}
public void TestListFlavors()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
IEnumerable <Flavor> flavors = ListAllFlavors(provider);
Assert.IsNotNull(flavors);
if (!flavors.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any configured flavors.");
}
Console.WriteLine("Flavors");
foreach (Flavor flavor in flavors)
{
Assert.IsNotNull(flavor);
Console.WriteLine(" {0}: {1}", flavor.Id, flavor.Name);
Assert.IsFalse(string.IsNullOrEmpty(flavor.Id));
Assert.IsFalse(string.IsNullOrEmpty(flavor.Name));
}
}
public void TestListServers()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
IEnumerable <SimpleServer> servers = UserComputeTests.ListAllServers(provider);
Assert.IsNotNull(servers);
if (!servers.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any configured servers.");
}
Console.WriteLine("Servers");
foreach (SimpleServer server in servers)
{
Assert.IsNotNull(server);
Console.WriteLine(" {0}: {1}", server.Id, server.Name);
Assert.IsFalse(string.IsNullOrEmpty(server.Id));
Assert.IsFalse(string.IsNullOrEmpty(server.Name));
}
}
public void TestListImages()
{
IComputeProvider provider = new CloudServersProvider(Bootstrapper.Settings.TestIdentity);
IEnumerable <SimpleServerImage> images = ListAllImages(provider);
Assert.IsNotNull(images);
if (!images.Any())
{
Assert.Inconclusive("The test could not proceed because the specified account and/or region does not appear to contain any images.");
}
Console.WriteLine("Images");
foreach (SimpleServerImage image in images)
{
Assert.IsNotNull(image);
Console.WriteLine(" {0}: {1}", image.Id, image.Name);
Assert.IsFalse(string.IsNullOrEmpty(image.Id));
Assert.IsFalse(string.IsNullOrEmpty(image.Name));
}
}
static void Main(string[] args)
{
const string region = "RegionOne";
// Configure OpenStack.NET
OpenStackNet.Configure(options => options.DefaultTimeout=TimeSpan.FromSeconds(5));
// Authenticate
var identityUrl = new Uri("http://example.com");
var user = new CloudIdentityWithProject();
var identity = new OpenStackIdentityProvider(identityUrl, user);
identity.Authenticate();
// Use legacy and new providers
var legacyNetworking = new CloudNetworksProvider(null, identity);
legacyNetworking.ListNetworks();
var networks = new NetworkingService(identity, region);
networks.ListNetworks();
var legacyCompute = new CloudServersProvider(null, identity);
legacyCompute.ListServers();
var compute = new ComputeService(identity, region);
compute.ListServers();
}
public void Should_Return_One_Image_With_Details_When_Searching_By_Valid_Id()
{
var validImage = _allImages.First(i => i.Server != null);
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(server: validImage.Server.Id);
Assert.IsTrue(images.Any());
}
public void Should_Get_A_List_Of_Servers_With_Details_Which_Should_Include_The_Newly_Created_Server()
{
var provider = new CloudServersProvider(_testIdentity);
var servers = provider.ListServersWithDetails();
Assert.IsNotNull(servers);
Assert.IsTrue(servers.Any());
Assert.IsNotNull(servers.FirstOrDefault(s => s.Id == _testServer.Id));
}
public ServerProperties(CloudServersProvider provider, Server server, FlavorDetails flavor, ServerImage image)
{
if (provider == null)
throw new ArgumentNullException("provider");
if (server == null)
throw new ArgumentNullException("server");
_provider = provider;
_server = server;
_flavor = flavor;
_image = image;
}
public void Should_Get_List_Of_Snapshot_Images()
{
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImages(imageType: ImageType.Snapshot);
Assert.IsTrue(images.Any());
}
public void Should_Retrieve_Image_By_Name()
{
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails();
_testImage = images.First(i => i.Name == _testImageName);
Assert.IsNotNull(_testImage);
}
public void Should_Get_List_All_Images_With_Details()
{
var provider = new CloudServersProvider(_testIdentity);
_allImages = provider.ListImagesWithDetails(identity: _testIdentity);
Assert.IsTrue(_allImages.Any());
}
public void Should_Get_List_All_Images_Which_should_Equal_Base_And_Snapshot_Combined()
{
var provider = new CloudServersProvider(_testIdentity);
var allImages = provider.ListImages(identity: _testIdentity);
var baseImages = provider.ListImages(imageType: ImageType.Base);
var snapImages = provider.ListImages(imageType: ImageType.Snapshot);
Assert.IsTrue(allImages.Any());
Assert.IsTrue(allImages.Count() == (baseImages.Count() + snapImages.Count()));
foreach (var image in allImages)
{
Assert.IsTrue(baseImages.Any(i => i.Id.Equals(image.Id, StringComparison.OrdinalIgnoreCase)) ^ snapImages.Any(i => i.Id.Equals(image.Id, StringComparison.OrdinalIgnoreCase)));
}
}
public void Should_Return_At_Least_One_Image_With_Details_When_Searching_By_Valid_Status()
{
var validImage = _allImages.First();
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(imageStatus: validImage.Status);
Assert.IsTrue(images.Any());
}
public void Should_Return_At_Least_One_Image_When_Searching_By_Valid_Name()
{
var validImage = _allImages.First();
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImages(imageName: validImage.Name);
Assert.IsTrue(images.Any());
}
public void Should_Rebuild_Server()
{
_preBuildDetails = _testServer.GetDetails();
var provider = new CloudServersProvider(_testIdentity);
var image = provider.ListImages().First(i => i.Name.Contains("CentOS") && i.Id != _preBuildDetails.Image.Id);
var flavor = int.Parse(_preBuildDetails.Flavor.Id) + 1;
_rebuildServerSuccess = _testServer.Rebuild(string.Format("{0}_REBUILD", _preBuildDetails.Name), image.Id, flavor.ToString(), _newTestServer.AdminPassword);
Assert.IsTrue(_rebuildServerSuccess);
}
public void Should_Update_The_Admin_Password()
{
var provider = new CloudServersProvider(_testIdentity);
var result = provider.ChangeAdministratorPassword(_testServer.Id, NewPassword);
Assert.IsTrue(result);
}
public void Should_Return_All_Images_With_Details_When_Using_A_Limit_Greater_Than_What_Actually_Exists()
{
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(limit: _allImages.Count() * 2);
Assert.IsTrue(images.Count() == _allImages.Count());
}
public void Should_Return_At_Least_One_Image_With_Details_When_Searching_By_Valid_Change_Since_Date()
{
var validImage = _allImages.First();
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(changesSince: validImage.Updated.AddSeconds(-1));
Assert.IsTrue(images.Any());
}
public void Should_Return_Exactly_Two_Images_With_Details()
{
var provider = new CloudServersProvider(_testIdentity);
var images = provider.ListImagesWithDetails(limit: 2);
Assert.IsTrue(images.Count() == 2);
}
