github.com/1and1/oneandone-cloudserver-sdk-go@v1.4.1/baremetal_server_test.go (about) 1 package oneandone 2 3 import ( 4 "fmt" 5 "math/rand" 6 "strconv" 7 "strings" 8 "sync" 9 "testing" 10 "time" 11 ) 12 13 var ( 14 set_baremetal_server sync.Once 15 baremetal_server_id string 16 baremetal_server_name string 17 baremetal_ser_app_id string 18 baremetal_server *Server 19 baremetal_ser_lb *LoadBalancer 20 baremetalModel BaremetalModel 21 ) 22 23 func setup_baremetal_server() { 24 fmt.Println("Deploying a baremetal test server...") 25 b_srv_id, b_srv, err := create_baremetal_test_server(false) 26 27 if err != nil { 28 fmt.Printf("Unable to create the baremetal server. Error: %s", err.Error()) 29 return 30 } 31 if b_srv_id == "" || b_srv.Id == "" { 32 fmt.Printf("Unable to create the baremetal server.") 33 return 34 } else { 35 baremetal_server_id = b_srv.Id 36 } 37 38 err = api.WaitForState(b_srv, "POWERED_OFF", 20, 90) 39 40 if err != nil { 41 fmt.Printf("Error: %s", err.Error()) 42 } 43 44 baremetal_server = b_srv 45 } 46 47 func get_baremetal_appliance(max_disk_size int) ServerAppliance { 48 saps, _ := api.ListServerAppliances(1, 500, "", "baremetal", "") 49 for i, sp := range saps { 50 if strings.Contains(strings.ToLower(sp.Os), "centos") { 51 return saps[i] 52 } 53 } 54 return saps[0] 55 } 56 57 func create_baremetal_test_server(power_on bool) (string, *Server, error) { 58 rand.Seed(time.Now().UnixNano()) 59 baremetal_server_name = fmt.Sprintf("GOBAREMETAL_%d", rand.Intn(1000000)) 60 fmt.Printf("Creating test server '%s'...\n", baremetal_server_name) 61 62 sap := get_baremetal_appliance(hdd_size) 63 baremetal_ser_app_id = sap.Id 64 //mp := get_default_mon_policy() 65 baremetalModels, err := api.ListBaremetalModels() 66 baremetalModel = baremetalModels[0] 67 baremetalModelId := baremetalModels[0].Id 68 69 req := ServerRequest{ 70 Name: baremetal_server_name, 71 Description: baremetal_server_name + " description", 72 ApplianceId: baremetal_ser_app_id, 73 DatacenterId: get_random_datacenterID(), 74 PowerOn: power_on, 75 ServerType: "baremetal", 76 Hardware: Hardware{ 77 BaremetalModelId: baremetalModelId, 78 }, 79 } 80 b_ser_id, b_server, err := api.CreateServer(&req) 81 return b_ser_id, b_server, err 82 } 83 84 // /servers tests 85 86 func TestCreateBaremetalServer(t *testing.T) { 87 set_baremetal_server.Do(setup_baremetal_server) 88 89 if baremetal_server == nil { 90 t.Errorf("CreateServer failed.") 91 return 92 } 93 if baremetal_server.Name != baremetal_server_name { 94 t.Errorf("Wrong server name.") 95 } 96 if baremetal_server.Image.Id != baremetal_ser_app_id { 97 t.Errorf("Wrong server image on server '%s'.", baremetal_server.Name) 98 } 99 } 100 101 func TestListAllServers(t *testing.T) { 102 //set_baremetal_server.Do(setup_baremetal_server) 103 fmt.Println("Listing all servers...") 104 105 res, err := api.ListServers() 106 if err != nil { 107 t.Errorf("ListServers failed. Error: " + err.Error()) 108 } 109 if len(res) == 0 { 110 t.Errorf("No server found.") 111 } 112 113 res, err = api.ListServers(1, 2, "name", "", "id,name") 114 115 if err != nil { 116 t.Errorf("ListServers with parameter options failed. Error: " + err.Error()) 117 return 118 } 119 if len(res) == 0 { 120 t.Errorf("No server found.") 121 } 122 if len(res) > 2 { 123 t.Errorf("Wrong number of objects per page.") 124 } 125 if res[0].Hardware != nil { 126 t.Errorf("Filtering parameters failed.") 127 } 128 if res[0].Name == "" { 129 t.Errorf("Filtering parameters failed.") 130 } 131 if len(res) == 2 && res[0].Name >= res[1].Name { 132 t.Errorf("Sorting parameters failed.") 133 } 134 // Test for error response 135 res, err = api.ListServers(0, 0, true, "name", "") 136 if res != nil || err == nil { 137 t.Errorf("ListServers failed to handle incorrect argument type.") 138 } 139 140 res, err = api.ListServers(0, 0, "", baremetal_server_name, "") 141 142 if err != nil { 143 t.Errorf("ListServers with parameter options failed. Error: " + err.Error()) 144 return 145 } 146 if len(res) != 1 { 147 t.Errorf("Search parameter failed.") 148 } 149 if res[0].Name != baremetal_server_name { 150 t.Errorf("Search parameter failed.") 151 } 152 } 153 154 func TestGetBaremetalServer(t *testing.T) { 155 set_baremetal_server.Do(setup_baremetal_server) 156 157 fmt.Println("Getting the server...") 158 b_srv, err := api.GetServer(baremetal_server_id) 159 160 if err != nil { 161 t.Errorf("GetServer failed. Error: " + err.Error()) 162 return 163 } 164 if b_srv.Id != baremetal_server_id { 165 t.Errorf("Wrong server ID.") 166 } 167 } 168 169 func TestGetBaremetalServerStatus(t *testing.T) { 170 set_baremetal_server.Do(setup_baremetal_server) 171 172 fmt.Println("Getting the server's status...") 173 status, err := api.GetServerStatus(baremetal_server_id) 174 175 if err != nil { 176 t.Errorf("GetServerStatus failed. Error: " + err.Error()) 177 return 178 } 179 if status.State != "POWERED_OFF" { 180 t.Errorf("Wrong server status.") 181 } 182 } 183 184 func TestStartBaremetalServer(t *testing.T) { 185 set_baremetal_server.Do(setup_baremetal_server) 186 187 fmt.Println("Starting the server...") 188 b_srv, err := api.StartServer(baremetal_server_id) 189 190 if err != nil { 191 t.Errorf("StartServer failed. Error: " + err.Error()) 192 return 193 } 194 195 err = api.WaitForState(b_srv, "POWERED_ON", 10, 60) 196 197 if err != nil { 198 t.Errorf("Starting the server failed. Error: " + err.Error()) 199 } 200 201 server, err = api.GetServer(b_srv.Id) 202 203 if err != nil { 204 t.Errorf("GetServer failed. Error: " + err.Error()) 205 } else if server.Status.State != "POWERED_ON" { 206 t.Errorf("Wrong server state. Expected: POWERED_ON. Found: %s.", server.Status.State) 207 } 208 } 209 210 func TestRebootBaremetalServer(t *testing.T) { 211 set_baremetal_server.Do(setup_baremetal_server) 212 213 for i := 1; i < 3; i++ { 214 is_hardware := i%2 == 0 215 var method string 216 if is_hardware { 217 method = "HARDWARE" 218 } else { 219 method = "SOFTWARE" 220 } 221 fmt.Printf("Rebooting the server using '%s' method...\n", method) 222 b_srv, err := api.RebootServer(baremetal_server_id, is_hardware) 223 224 if err != nil { 225 t.Errorf("RebootServer using '%s' method failed. Error: %s", method, err.Error()) 226 return 227 } 228 229 err = api.WaitForState(b_srv, "REBOOTING", 5, 60) 230 231 if err != nil { 232 t.Errorf("Rebooting the server using '%s' method failed. Error: %s", method, err.Error()) 233 } 234 235 err = api.WaitForState(b_srv, "POWERED_ON", 10, 60) 236 237 if err != nil { 238 t.Errorf("Rebooting the server using '%s' method failed. Error: %s", method, err.Error()) 239 } 240 } 241 } 242 243 func TestRenameBaremetalServer(t *testing.T) { 244 set_baremetal_server.Do(setup_baremetal_server) 245 b_srvs, err := api.GetServer(baremetal_server_id) 246 if err != nil { 247 t.Errorf("get server failed. Error: " + err.Error()) 248 } 249 api.WaitForState(b_srvs, "POWERED_ON", 10, 60) 250 251 fmt.Println("Renaming the server...") 252 253 new_name := server.Name + "_renamed" 254 new_desc := server.Description + "_renamed" 255 256 b_srv, err := api.RenameServer(baremetal_server_id, new_name, new_desc) 257 258 if err != nil { 259 t.Errorf("Renaming server failed. Error: " + err.Error()) 260 return 261 } 262 if b_srv.Name != new_name { 263 t.Errorf("Wrong server name.") 264 } 265 if b_srv.Description != new_desc { 266 t.Errorf("Wrong server description.") 267 } 268 } 269 270 func TestGetBaremetalServerHardware(t *testing.T) { 271 set_baremetal_server.Do(setup_baremetal_server) 272 273 fmt.Println("Getting the server's hardware...") 274 hardware, err := api.GetServerHardware(baremetal_server_id) 275 baremetalModel, err := api.GetBaremetalModel("81504C620D98BCEBAA5202D145203B4B") 276 277 if err != nil { 278 t.Errorf("GetServerHardware failed. Error: " + err.Error()) 279 return 280 } 281 if hardware == nil { 282 t.Errorf("Unable to get the server's hardware.") 283 } else { 284 if hardware.Vcores != baremetalModel.Hardware.CoresPerProcessor { 285 t.Errorf("Wrong number of processor cores on server '%s'.", server.Name) 286 } 287 if hardware.CoresPerProcessor != baremetalModel.Hardware.Cores { 288 t.Errorf("Wrong number of cores per processor on server '%s'.", server.Name) 289 } 290 if hardware.Ram != baremetalModel.Hardware.Ram { 291 t.Errorf("Wrong RAM size on server '%s'.", server.Name) 292 } 293 } 294 } 295 296 func TestListBaremetalServerHdds(t *testing.T) { 297 set_baremetal_server.Do(setup_baremetal_server) 298 299 fmt.Println("Listing all the server's HDDs...") 300 hdds, err := api.ListServerHdds(baremetal_server_id) 301 302 if err != nil { 303 t.Errorf("ListServerHdds failed. Error: " + err.Error()) 304 return 305 } 306 if len(hdds) != 1 { 307 t.Errorf("Wrong number of the server's hard disks.") 308 } 309 if hdds[0].Id == "" { 310 t.Errorf("Wrong HDD id.") 311 } 312 if hdds[0].Size != 1600 { 313 t.Errorf("Wrong HDD size.") 314 } 315 if hdds[0].IsMain != true { 316 t.Errorf("Wrong main HDD.") 317 } 318 server_hdd = &hdds[0] 319 } 320 321 func TestGetBaremetalServerHdd(t *testing.T) { 322 set_baremetal_server.Do(setup_baremetal_server) 323 hdds, _ := api.ListServerHdds(baremetal_server_id) 324 325 fmt.Println("Getting server HDD...") 326 hdd, err := api.GetServerHdd(baremetal_server_id, hdds[0].Id) 327 328 if err != nil { 329 t.Errorf("GetServerHdd failed. Error: " + err.Error()) 330 return 331 } 332 if hdd.Id != hdds[0].Id { 333 t.Errorf("Wrong HDD id.") 334 } 335 if hdd.Size != hdds[0].Size { 336 t.Errorf("Wrong HDD size.") 337 } 338 if hdd.IsMain != hdds[0].IsMain { 339 t.Errorf("Wrong main HDD.") 340 } 341 } 342 343 func TestGetBaremetalServerImage(t *testing.T) { 344 set_baremetal_server.Do(setup_baremetal_server) 345 346 fmt.Println("Getting the server's image...") 347 img, err := api.GetServerImage(baremetal_server_id) 348 349 if err != nil { 350 t.Errorf("GetServerImage failed. Error: " + err.Error()) 351 return 352 } 353 if img.Id != baremetal_server.Image.Id { 354 t.Errorf("Wrong image ID.") 355 } 356 if img.Name != baremetal_server.Image.Name { 357 t.Errorf("Wrong image name.") 358 } 359 } 360 361 func TestStopBaremetalServer(t *testing.T) { 362 set_baremetal_server.Do(setup_baremetal_server) 363 364 fmt.Println("Stopping the server...") 365 b_srv, err := api.ShutdownServer(baremetal_server_id, false) 366 367 if err != nil { 368 t.Errorf("ShutdownServer failed. Error: " + err.Error()) 369 } else { 370 err = api.WaitForState(b_srv, "POWERED_OFF", 10, 60) 371 if err != nil { 372 t.Errorf("Stopping the server failed. Error: " + err.Error()) 373 } 374 375 baremetal_server, err = api.GetServer(baremetal_server_id) 376 if err != nil { 377 t.Errorf("GetServer failed. Error: " + err.Error()) 378 } 379 if baremetal_server.Status.State != "POWERED_OFF" { 380 t.Errorf("Wrong baremetal_server state. Expected: POWERED_OFF. Found: %s.", baremetal_server.Status.State) 381 } 382 } 383 } 384 385 func TestListBaremetalServerIps(t *testing.T) { 386 set_baremetal_server.Do(setup_baremetal_server) 387 388 b_srv, e := api.GetServer(baremetal_server_id) 389 if e == nil { 390 baremetal_server = b_srv 391 } 392 393 fmt.Println("Listing the baremetal_server's IPs...") 394 ips, err := api.ListServerIps(baremetal_server_id) 395 396 if err != nil { 397 t.Errorf("ListServerIps failed. Error: " + err.Error()) 398 return 399 } 400 if len(ips) != len(baremetal_server.Ips) { 401 t.Errorf("Not all IPs were obtained.") 402 } 403 if ips[0].Id != baremetal_server.Ips[0].Id { 404 t.Errorf("Wrong IP ID.") 405 } 406 if ips[0].Ip != baremetal_server.Ips[0].Ip { 407 t.Errorf("Wrong IP address.") 408 } 409 } 410 411 func TestAssignBaremetalServerIp(t *testing.T) { 412 set_baremetal_server.Do(setup_baremetal_server) 413 414 fmt.Println("Assigning new IP addresses to the baremetal_server...") 415 for i := 2; i < 4; i++ { 416 time.Sleep(time.Second) 417 b_srv, err := api.AssignServerIp(baremetal_server_id, "IPV4") 418 if err != nil { 419 t.Errorf("AssignServerIp failed. Error: " + err.Error()) 420 return 421 } 422 b_srv = wait_for_action_done(b_srv, 10, 30) 423 if len(b_srv.Ips) != i { 424 t.Errorf("IP address not assigned to the baremetal_server.") 425 } 426 baremetal_server = b_srv 427 } 428 } 429 430 func TestGetBaremetalServerIp(t *testing.T) { 431 set_baremetal_server.Do(setup_baremetal_server) 432 433 fmt.Println("Getting the baremetal_server's IP...") 434 baremetal_server, _ = api.GetServer(baremetal_server_id) 435 if baremetal_server == nil { 436 t.Errorf("GetServer failed.") 437 return 438 } 439 time.Sleep(time.Second) 440 ip, err := api.GetServerIp(baremetal_server_id, baremetal_server.Ips[0].Id) 441 442 if err != nil { 443 t.Errorf("GetServerIps failed. Error: " + err.Error()) 444 return 445 } 446 if ip.Id != baremetal_server.Ips[0].Id { 447 t.Errorf("Wrong IP ID.") 448 } 449 if ip.Ip != baremetal_server.Ips[0].Ip { 450 t.Errorf("Wrong IP address.") 451 } 452 } 453 454 func TestDeleteBaremetalServerIp(t *testing.T) { 455 set_baremetal_server.Do(setup_baremetal_server) 456 457 if len(baremetal_server.Ips) <= 1 { 458 for i := 0; i < 2; i++ { 459 time.Sleep(10 * time.Second) 460 s, e := api.AssignServerIp(baremetal_server_id, "IPV4") 461 if s != nil && e == nil { 462 s = wait_for_action_done(s, 10, 30) 463 baremetal_server = s 464 time.Sleep(120 * time.Second) 465 } 466 } 467 } 468 ip_no := len(baremetal_server.Ips) 469 for i := 1; i < ip_no-1; i++ { 470 keep_ip := i%2 == 0 471 fmt.Printf("Deleting the baremetal_server's IP '%s' (keep_ip = %s)...\n", baremetal_server.Ips[i].Ip, strconv.FormatBool(keep_ip)) 472 api.DeleteServerIp(baremetal_server_id, baremetal_server.Ips[i].Id, keep_ip) 473 time.Sleep(280 * time.Second) 474 } 475 } 476 477 func TestAssignBaremetalServerIpLoadBalancer(t *testing.T) { 478 set_baremetal_server.Do(setup_baremetal_server) 479 ips, _ := api.ListServerIps(baremetal_server_id) 480 lb := create_load_balancer() 481 482 fmt.Printf("Assigning a load balancer to the baremetal_server's IP '%s'...\n", ips[0].Ip) 483 b_srv, err := api.AssignServerIpLoadBalancer(baremetal_server_id, ips[0].Id, lb.Id) 484 485 if err != nil { 486 t.Errorf("AssignServerIpLoadBalancer failed. Error: " + err.Error()) 487 return 488 } 489 if len(b_srv.Ips[0].LoadBalancers) == 0 { 490 t.Errorf("Load balancer not assigned.") 491 } 492 if b_srv.Ips[0].LoadBalancers[0].Id != lb.Id { 493 t.Errorf("Wrong load balancer assigned.") 494 } 495 baremetal_ser_lb = lb 496 } 497 498 func TestListBaremetalServerIpLoadBalancers(t *testing.T) { 499 set_baremetal_server.Do(setup_baremetal_server) 500 ips, _ := api.ListServerIps(baremetal_server_id) 501 502 fmt.Println("Listing load balancers assigned to the baremetal_server's IP...") 503 lbs, err := api.ListServerIpLoadBalancers(baremetal_server_id, ips[0].Id) 504 505 if err != nil { 506 t.Errorf("ListServerIpLoadBalancers failed. Error: " + err.Error()) 507 return 508 } 509 if len(lbs) == 0 { 510 t.Errorf("No load balancer was assigned to the baremetal_server's IP.") 511 return 512 } 513 if lbs[0].Id != baremetal_ser_lb.Id { 514 t.Errorf("Wrong load balancer assigned.") 515 } 516 } 517 518 func TestUnassignBaremetalServerIpLoadBalancer(t *testing.T) { 519 set_baremetal_server.Do(setup_baremetal_server) 520 ips, _ := api.ListServerIps(baremetal_server_id) 521 522 fmt.Println("Unassigning the load balancer from the baremetal_server's IP...") 523 b_srv, err := api.UnassignServerIpLoadBalancer(baremetal_server_id, ips[0].Id, baremetal_ser_lb.Id) 524 525 if err != nil { 526 t.Errorf("UnassignServerIpLoadBalancer failed. Error: " + err.Error()) 527 return 528 } 529 if len(b_srv.Ips[0].LoadBalancers) > 0 { 530 t.Errorf("Unassigning the load balancer failed.") 531 } 532 baremetal_ser_lb, err = api.DeleteLoadBalancer(baremetal_ser_lb.Id) 533 if err == nil { 534 api.WaitUntilDeleted(baremetal_ser_lb) 535 } 536 baremetal_ser_lb, _ = api.GetLoadBalancer(baremetal_ser_lb.Id) 537 } 538 539 func TestAssignBaremetalServerIpFirewallPolicy(t *testing.T) { 540 set_baremetal_server.Do(setup_baremetal_server) 541 ips, _ := api.ListServerIps(baremetal_server_id) 542 543 fmt.Println("Assigning a firewall policy to the baremetal_server's IP...") 544 fps, err := api.ListFirewallPolicies(0, 1, "creation_date", "linux", "id,name") 545 if err != nil { 546 t.Errorf("ListFirewallPolicies failed. Error: " + err.Error()) 547 return 548 } 549 b_srv, err := api.AssignServerIpFirewallPolicy(baremetal_server_id, ips[0].Id, fps[0].Id) 550 551 if err != nil { 552 t.Errorf("AssignServerIpFirewallPolicy failed. Error: " + err.Error()) 553 return 554 } 555 if b_srv.Ips[0].Firewall == nil { 556 t.Errorf("Firewall policy not assigned.") 557 } 558 if b_srv.Ips[0].Firewall.Id != fps[0].Id { 559 t.Errorf("Wrong firewall policy assigned.") 560 } 561 } 562 563 func TestGetBaremetalServerIpFirewallPolicy(t *testing.T) { 564 set_baremetal_server.Do(setup_baremetal_server) 565 ips, _ := api.ListServerIps(baremetal_server_id) 566 567 fmt.Println("Getting the firewall policy assigned to the baremetal_server's IP...") 568 fps, err := api.ListFirewallPolicies(0, 1, "creation_date", "linux", "id,name") 569 if err != nil { 570 t.Errorf("ListFirewallPolicies failed. Error: " + err.Error()) 571 } 572 fp, err := api.GetServerIpFirewallPolicy(baremetal_server_id, ips[0].Id) 573 574 if err != nil { 575 t.Errorf("GetServerIpFirewallPolicy failed. Error: " + err.Error()) 576 } 577 if fp == nil { 578 t.Errorf("No firewall policy assigned to the baremetal_server's IP.") 579 } 580 if fp.Id != fps[0].Id { 581 t.Errorf("Wrong firewall policy assigned to the baremetal_server's IP.") 582 } 583 } 584 585 func TestRecoveryRebootServer(t *testing.T) { 586 set_server.Do(setup_server) 587 588 fmt.Print("Rebooting the server using recovery boot") 589 srv, err := api.RecoveryRebootServer(baremetal_server_id, false, get_random_recoveryImage().Id) 590 591 if err != nil { 592 t.Errorf("Rebooting the server using recovery boot. Error: %s", err.Error()) 593 return 594 } 595 596 err = api.WaitForState(srv, "REBOOTING", 10, 60) 597 598 if err != nil { 599 t.Errorf("Rebooting the server using recovery boot. Error: %s", err.Error()) 600 } 601 602 err = api.WaitForState(srv, "POWERED_ON", 20, 60) 603 604 if err != nil { 605 t.Errorf("Rebooting the server using recovery boot. Error: %s", err.Error()) 606 } 607 } 608 609 func TestDeleteBaremetalServer(t *testing.T) { 610 set_baremetal_server.Do(setup_baremetal_server) 611 612 time.Sleep(120 * time.Second) 613 b_srv, err := api.DeleteServer(baremetal_server_id, true) 614 time.Sleep(420 * time.Second) 615 616 if err != nil { 617 t.Errorf("DeleteServer server failed. Error: " + err.Error()) 618 return 619 } 620 fmt.Printf("Deleting baremetal_server '%s', keeping baremetal_server's IP '%s'...\n", b_srv.Name, b_srv.Ips[0].Ip) 621 ip_id := b_srv.Ips[0].Id 622 623 b_srv, err = api.GetServer(baremetal_server_id) 624 625 if b_srv != nil { 626 t.Errorf("Unable to delete the baremetal_server.") 627 } else { 628 baremetal_server = nil 629 } 630 631 ip, _ := api.GetPublicIp(ip_id) 632 if ip == nil { 633 t.Errorf("Failed to keep IP after deleting the baremetal_server.") 634 } else { 635 fmt.Printf("Deleting baremetal_server's IP '%s' after deleting the baremetal_server...\n", ip.IpAddress) 636 ip, err = api.DeletePublicIp(ip_id) 637 if err != nil { 638 t.Errorf("Unable to delete baremetal_server's IP after deleting the baremetal_server.") 639 } else { 640 api.WaitUntilDeleted(ip) 641 } 642 } 643 }