public void AddInterfaceAttachmentTest_2Times_Sequencely()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.ShutOff);
if (ss != null)
{
Server server = osm.GetServer(ss.Id);
Trace.WriteLine(string.Format("s.Status : {0}", server.Status));
Trace.WriteLine(string.Format("s.VMState : {0}", server.VMState));
string portId = GetInterfaceAttachmentIdByTesterName();
// the first time
InterfaceAttachment i = osm.AddInterfaceAttachment(ss.Id, portId);
Assert.IsNotNull(i);
Assert.IsNotNull(i.PortId);
Assert.IsNotNull(i.NetId);
Assert.IsNotNull(i.MacAddr);
Assert.IsNotNull(i.PortState);
Trace.WriteLine(string.Format("interface attachment added : {0}", DateTime.Now));
Trace.WriteLine(string.Format("PortId : {0}, NetId : {1}, MacAddress : {2}, PortState : {3}", i.PortId, i.NetId, i.MacAddr, i.PortState));
// the second time, expected BadServiceRequestException but ItemNotFundException occurs
AssertCatch <BadServiceRequestException>(() => i = osm.AddInterfaceAttachment(ss.Id, portId));
// delete interface
Assert.IsTrue(osm.DeleteInterfaceAttachment(ss.Id, i.PortId));
}
}
public void ListVolumesDetailsTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId); // with tenant
var volumes = os.ListVolumesDetails();
Assert.IsNotNull(volumes);
}
public void SetNotificationTest()
{
Trace.WriteLine("on ticket");
var os = new OpenStackMember(UserName, Password, TenantName); // with tenant
var notifications = os.ListNotifications();
Assert.IsNotNull(notifications);
foreach (var n in notifications)
{
var notification = os.GetNotification(n.NotificationCode);
var prevStatus = notification.ReadStatus;
notification = os.SetNotification(n.NotificationCode, "Unread");
Assert.AreEqual(notification.ReadStatus, "Unread");
notification = os.SetNotification(n.NotificationCode, "ReadTitleOnly");
Assert.AreEqual(notification.ReadStatus, "ReadTitleOnly");
notification = os.SetNotification(n.NotificationCode, "Read");
Assert.AreEqual(notification.ReadStatus, "Read");
notification = os.SetNotification(n.NotificationCode, prevStatus);
notification = os.GetNotification(n.NotificationCode);
Assert.AreEqual(notification.ReadStatus, prevStatus);
}
}
public void ListLBMembersTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
var members = os.ListLBMembers();
Assert.IsNotNull(members);
}
public void ListNetworkSecurityRulesTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
var rules = os.ListNetworkSecurityGroupRules();
Assert.IsNotNull(rules);
}
public void CreateNetworkSecurityRuleTest()
{
string name = TesterName;
string description = null;
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
var group = os.CreateNetworkSecurityGroup(name, description);
Assert.IsNotNull(group);
try
{
string direction = "ingress"; // "ingress" or "egress"
string etherType = "IPv4"; // "IPv4" or "IPv6"
string portRangeMin = null;
string portRangeMax = null;
string protocol = null;
string remoteGroupId = null;
string remoteIpPrefix = null;
var rule = os.CreateNetworkSecurityGroupRule(group.Id, direction, etherType, portRangeMin, portRangeMax, protocol, remoteGroupId, remoteIpPrefix);
Assert.IsNotNull(rule);
Assert.IsTrue(os.DeleteNetworkSecurityGroupRule(rule.Id));
}
finally
{
Assert.IsTrue(os.DeleteNetworkSecurityGroup(group.Id));
}
}
public void CreatePoolTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
// create pool
string pool_name = GetTesterNameByEnv();
string TokyoLBaas_subnetId = GetSubnetIdByRegion(region: null);
string[] lbMethods = { "ROUND_ROBIN", "LEAST_CONNECTIONS" };
string protocol = "TCP";
foreach (var lbMethod in lbMethods)
{
var p = osm.CreatePool(pool_name, TokyoLBaas_subnetId, lbMethod, protocol);
try
{
Assert.IsNotNull(p);
Trace.WriteLine(string.Format("pool Name : {0}", p.Name));
Trace.WriteLine(string.Format("pool Id : {0}", p.Id));
Trace.WriteLine(string.Format("pool Protocol : {0}", p.Protocol));
Trace.WriteLine(string.Format("pool Description : {0}", p.Description));
Trace.WriteLine(string.Format("pool LbMethod : {0}", p.LbMethod));
Trace.WriteLine(string.Format("pool HealthMonitors : {0}", string.Join(",", p.HealthMonitors)));
Trace.WriteLine(string.Format("pool Members : {0}", string.Join(",", p.Members)));
}
finally
{
Assert.IsTrue(osm.DeletePool(p.Id));
}
}
}
public void StopServerTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
Server server = osm.GetServer(ss.Id);
// check server status
if (server.VMState == VirtualMachineState.Stopped)
{
if (server.Status != ServerState.Reboot)
{
osm.StartServer(server.Id);
}
// wait for activate
osm.ServersProvider.WaitForServerActive(server.Id);
Trace.WriteLine(String.Format("server activated : {0}", DateTime.Now));
// stop server
bool b = osm.StopServer(server.Id);
Assert.IsTrue(b);
var vmState = server.VMState;
Trace.WriteLine(string.Format("server stopped : {0}", DateTime.Now));
}
else
{
Trace.WriteLine(string.Format("server.Status : {0}", server.Status));
Trace.WriteLine(string.Format("server.VMState : {0}", server.VMState));
}
}
public void StopServerTest_Stop_VM_Not_Exist()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
// expect ItemNotFoundException
bool b = os.StopServer(InvalidId);
}
public void DeleteServerTest_Delete_Server_Not_Exist()
{
var os = new OpenStackMember(UserName, Password, TenantName);
// expect ItemNotFoundException
bool b = os.DeleteServer(InvalidId);
}
public void StartServerTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
Server server = osm.GetServer(ss.Id);
// check server status
if (server.Status == ServerState.Active && server.VMState == VirtualMachineState.Active)
{
osm.StopServer(server.Id);
// wait for stop
WaitForVMState(server.Id, new[] { VirtualMachineState.Stopped }, new[] { VirtualMachineState.Error });
Trace.WriteLine(String.Format("server stopped : {0}", DateTime.Now));
// start server
bool b = osm.StartServer(server.Id);
Assert.IsTrue(b);
Trace.WriteLine(string.Format("server started : {0}", DateTime.Now));
}
else
{
Trace.WriteLine(string.Format("server.Status : {0}", server.Status));
Trace.WriteLine(string.Format("server.VMState : {0}", server.VMState));
}
}
public void GetServerTest_VM_Invalid()
{
var os = new OpenStackMember(UserName, Password, TenantName);
// expect ItemNotFoundException
Server server = os.GetServer(InvalidId);
}
public void GetFlavorTest_Get_Flavor_Invalid()
{
var os = new OpenStackMember(UserName, Password, TenantName);
// expect ItemNotFoundException
var f = os.GetFlavor(InvalidId);
}
private Server WaitForVMState(string serverId, VirtualMachineState[] expectedVMStates, VirtualMachineState[] errorVMStates, int refreshCount = 600, TimeSpan?refreshDelay = null)
{
refreshDelay = refreshDelay ?? TimeSpan.FromMilliseconds(2400);
var os = new OpenStackMember(UserName, Password, TenantName);
Server serverDetails = os.GetServer(serverId);
Func <bool> exitCondition = () => serverDetails.TaskState == null && (expectedVMStates.Contains(serverDetails.VMState) || errorVMStates.Contains(serverDetails.VMState));
int count = 0;
int exitCount = exitCondition() ? 1 : 0;
while (exitCount < 3 && count < refreshCount)
{
System.Threading.Thread.Sleep(refreshDelay ?? TimeSpan.FromMilliseconds(2400));
serverDetails = os.GetServer(serverId);
count++;
if (exitCondition())
{
exitCount++;
}
else
{
exitCount = 0;
}
}
if (errorVMStates.Contains(serverDetails.VMState))
{
throw new ServerEnteredErrorStateException(serverDetails.Status);
}
return(serverDetails);
}
public void DeleteKeypairTest_Delete_Keypair_Not_Exist()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
// expect ItemNotFoundException
os.DeleteKeypair(InvalidItemName);
}
public void RebuildServerTest_FlavorId_Invalid()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = GetServerByNameOrCreate(TesterName);
Server s = os.GetServer(ss.Id);
try
{
Server rebuiltserver = os.RebuildServer(s.Id, s.Image.Id, "newPassword");
}
catch (ServiceConflictException sce)
{
if (sce.Message.Equals("Cannot 'rebuild' while instance is in task_state reboot_started"))
{
// no error for this is what expected.
Trace.WriteLine(string.Format("s.Status : {0}", s.Status));
Trace.WriteLine(string.Format("s.VMState : {0}", s.VMState));
return;
}
// in other cases,
throw;
}
s = os.ServersProvider.WaitForServerActive(s.Id, 100);
}
public void GetInterfaceAttachmentTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
IEnumerable <InterfaceAttachment> interfaces = osm.ListInterfaceAttachments(ss.Id);
Assert.IsNotNull(interfaces);
Trace.WriteLine(string.Format("InterfaceAttachments count : {0}", interfaces.Count()));
if (interfaces.Count() == 0)
{
osm.AddInterfaceAttachment(ss.Id, GetInterfaceAttachmentIdByTesterName());
}
foreach (var _i in interfaces)
{
InterfaceAttachment i = osm.GetInterfaceAttachment(ss.Id, _i.PortId);
Assert.IsNotNull(i);
Assert.IsNotNull(i.PortId);
Assert.IsNotNull(i.NetId);
Assert.IsNotNull(i.MacAddr);
Assert.IsNotNull(i.PortState);
Trace.WriteLine(string.Format("PortId : {0}, NetId : {1}, MacAddress : {2}, PortState : {3}", i.PortId, i.NetId, i.MacAddr, i.PortState));
}
}
public void RevertResizeServerTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.ShutOff);
if (ss != null)
{
Server s = osm.GetServer(ss.Id);
//if (s.Status.Name != "SHUTOFF")
// os.StopServer(s.Id);
if (s.Status != ServerState.VerifyResize)
{
IEnumerable <Flavor> flavors = osm.ListFlavors();
Flavor flavor1g = flavors.Where <Flavor>(x => x.Name == "g-1gb").First <Flavor>();
Flavor flavor2g = flavors.Where <Flavor>(x => x.Name == "g-2gb").First <Flavor>();
osm.ResizeServer(s.Id, (s.Flavor.Id == flavor1g.Id ? flavor2g.Id : flavor1g.Id), DiskConfiguration.FromName("AUTO"));
Trace.WriteLine(String.Format("server requested a resizing : {0}", DateTime.Now));
Trace.WriteLine(String.Format("FlavorId : {0}", s.Flavor.Id));
// wait for request
s = osm.ServersProvider.WaitForServerState(s.Id, ServerState.VerifyResize, new[] { ServerState.Error, ServerState.Unknown, ServerState.Suspended });
Trace.WriteLine(String.Format("server status changed to {0} : {1}", s.Status, DateTime.Now));
}
// resize
bool b = osm.RevertResizeServer(s.Id);
Assert.IsTrue(b);
Trace.WriteLine(String.Format("server reverted a resizing : {0}", DateTime.Now));
// wait for activate
s = osm.ServersProvider.WaitForServerActive(s.Id);
Trace.WriteLine(String.Format("server activated : {0}", DateTime.Now));
}
}
public void AddSubnetForLbTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
var subnet = os.AddSubnetForLb();
Assert.IsNotNull(subnet);
}
public void GetVncConsoleTest_VM_Invalid()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
// expect ItemNotFoundException
VncConsole v = os.GetVncConsole(InvalidId);
}
public void UpdatePoolTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
// string tenantId = os.IdentityProvider.GetToken(os.Identity).Tenant.Id;
// create pool
string pool_name = GetTesterNameByEnv();
string TokyoLBaas_subnetId = GetSubnetIdByRegion(region: null);
string[] lbMethods = { "ROUND_ROBIN", "LEAST_CONNECTIONS" };
string protocol = "TCP";
foreach (var lbMethod in lbMethods)
{
var p = os.CreatePool(pool_name, TokyoLBaas_subnetId, lbMethod, protocol);
Trace.WriteLine(string.Format("pool Status : {0}", p.Status));
System.Threading.Thread.Sleep(1000 * 10);
Trace.WriteLine(string.Format("pool Status : {0}", p.Status));
try
{
foreach (var newLbMethod in lbMethods)
{
os.UpdatePool(p.Id, "newName", newLbMethod);
// not tested yet.
//os.UpdatePool(p.Id, "日本語", lbMethod);
//os.UpdatePool(p.Id, "//", lbMethod);
}
}
finally
{
Assert.IsTrue(os.DeletePool(p.Id));
}
}
}
public void ListServerSecurityGroupTest_InvalidId()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
// expect ItemNotFoundException
IEnumerable <ServerSecurityGroup> groups = os.ListServerSecurityGroups(InvalidId);
}
public void UpdateHealthMonitorTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
string monitorType = "TCP"; // PING or TCP or HTTP
int delay = 5; // 5-10
int maxRetries = 1; // 1-5
string urlPath = null;
string expectedCodes = null;
// create
var monitor = os.CreateHealthMonitor(monitorType, delay, maxRetries, urlPath, expectedCodes);
try
{
// update
int newDelay = 6;
int newMaxRetries = 3;
string newUrlPath = "http://www.google.com";
monitor = os.UpdateHealthMonitor(monitor.Id, newDelay, newMaxRetries, newUrlPath);
Assert.IsNotNull(monitor);
}
finally
{
Assert.IsTrue(os.DeleteHealthMonitor(monitor.Id));
}
}
public void GetKeypairTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
string keypairName = string.Format("keypair-key-{0}", TesterName);
KeypairData[] keypairs = os.ListKeypairs().ToArray <KeypairData>();
string name = (from b in keypairs where b.KeyPair.Name == keypairName select b.KeyPair.Name).FirstOrDefault();
if (string.IsNullOrEmpty(name))
{
// add keypair
Keypair kp = os.AddKeypair(keypairName);
Assert.IsNotNull(kp);
Assert.IsNotNull(kp.PublicKey);
Assert.IsNotNull(kp.FingerPrint);
Assert.IsNotNull(kp.UserId);
Trace.WriteLine(String.Format("keypair added : {0}", DateTime.Now));
Trace.WriteLine(String.Format("KeypairName : {0}", kp.Name));
}
Keypair k = os.GetKeypair(keypairName);
Assert.IsNotNull(k);
Assert.IsNotNull(k.Name);
Trace.WriteLine(k.Name);
Assert.IsNotNull(k.PublicKey);
Trace.WriteLine(k.PublicKey);
}
public void ListGlanceImagesTest()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
var images = os.ListGlanceImages();
Assert.IsNotNull(images);
}
public void ListFlavorsDetailsTest()
{
foreach (var m in TestEnvMembers.Members)
{
var os = new OpenStackMember(m.UserName, m.Password, m.TenantName); // without tenant, can not get endpoints.
IEnumerable <Flavor> flavors = null;
try
{
flavors = os.ListFlavors();
}
catch (net.openstack.Core.Exceptions.UserAuthorizationException uae)
{
Assert.IsTrue(uae.Message.Equals("The user does not have access to the requested service or region."));
return;
}
os = new OpenStackMember(m.UserName, m.Password, m.TenantName); // with tenant
flavors = os.ListFlavorsDetails();
Assert.IsNotNull(flavors);
foreach (var f in flavors)
{
Assert.IsNotNull(f.Id);
Assert.IsNotNull(f.Name);
Assert.IsNotNull(f.Links);
}
}
}
static void Main(string[] args)
{
string username = ""; // input your user name like gncu12345678
string password = ""; // input your own password
string tenantname = ""; // input your own tenant name like gnct12345678
string tenantid = ""; // input your tenant id, which is 32 characters
string region = "tyo1";
var osm = new OpenStackMember(
username,
password,
tenantname,
tenantid,
defaultregion: region,
bLazyProviderSetting: false
);
var activeServer = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
if (activeServer != null)
{
Console.WriteLine(String.Format("{0} is active.", activeServer.Id));
var console = osm.GetVncConsole(activeServer.Id);
Console.WriteLine(console.Url);
System.Diagnostics.Process.Start(console.Url);
}
else
{
Console.WriteLine("there is no active servers.");
}
}
public void GetKeypairTest_Invalid()
{
var os = new OpenStackMember(UserName, Password, TenantName, TenantId);
// expect ItemNotFoundException
os.GetKeypair(InvalidItemName);
}
public void ListProductItemsTest()
{
var os = new OpenStackMember(UserName, Password, TenantName); // with tenant
var productitems = os.ListProducts();
Assert.IsNotNull(productitems);
foreach (var productitem in productitems)
{
Trace.WriteLine("=======================================================");
Trace.WriteLine(string.Format("ServiceName : {0}", productitem.ServiceName));
if (productitem.Products != null)
{
foreach (var p in productitem.Products)
{
Trace.WriteLine("\t=======================================================");
Trace.WriteLine(string.Format("\tProductId : {0}", p.ProductId));
Trace.WriteLine(string.Format("\tProductName : {0}", p.ProductName));
Trace.WriteLine(string.Format("\tMnemonic : {0}", p.Mnemonic));
Trace.WriteLine(string.Format("\tProductPriceId : {0}", p.ProductPriceId));
Trace.WriteLine(string.Format("\tUnitPrice : {0}", p.UnitPrice));
Trace.WriteLine(string.Format("\tStartDate : {0}", p.StartDate));
}
}
}
}
public void AddInterfaceAttachmentTest()
{
var osm = new OpenStackMember(UserName, Password, TenantName, TenantId);
SimpleServer ss = osm.ListServers().FirstOrDefault(s => s.GetDetails().Status == ServerState.Active);
Server server = osm.GetServer(ss.Id);
Trace.WriteLine(string.Format("s.Status : {0}", server.Status));
Trace.WriteLine(string.Format("s.VMState : {0}", server.VMState));
// detach all port
foreach (var _i in osm.ListInterfaceAttachments(ss.Id))
{
Assert.IsTrue(osm.DeleteInterfaceAttachment(ss.Id, _i.PortId));
}
// add interface
var portId = GetInterfaceAttachmentIdByTesterName();
InterfaceAttachment i = osm.AddInterfaceAttachment(ss.Id, portId);
try
{
Trace.WriteLine(string.Format("interface attachment added : {0}", DateTime.Now));
Trace.WriteLine(string.Format("PortId : {0}, NetId : {1}, MacAddress : {2}, PortState : {3}", i.PortId, i.NetId, i.MacAddr, i.PortState));
Assert.IsNotNull(i);
Assert.IsNotNull(i.PortId);
Assert.IsNotNull(i.NetId);
Assert.IsNotNull(i.MacAddr);
Assert.IsNotNull(i.PortState);
}
finally
{
// delete interface
Assert.IsTrue(osm.DeleteInterfaceAttachment(ss.Id, i.PortId));
}
}
