func authenticate(t *testing.T) (string, common.Authenticator, common.AuthenticationParameters) {
ap := getAuthenticationParameters(t)
authenticator := identity.Authenticate(ap)
authenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
tokenID, err := authenticator.GetToken()
testUtil.IsNil(t, err)
testUtil.Assert(t, tokenID != "", "No tokenID was found.")
return tokenID, &authenticator, ap
}
func TestAuthenticate(t *testing.T) {
//Authenticate with Global envs
ap := getAuthenticationParameters(t)
authenticator := identity.Authenticate(ap)
authenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
tokenID, err := authenticator.GetToken()
if tokenID == "" || err != nil {
t.Fatal("Error while authenticating")
}
tokenBasedAp := common.AuthenticationParameters{
AuthURL: ap.AuthURL,
TenantID: ap.TenantID,
TenantName: ap.TenantName,
Region: ap.Region,
CACert: ap.CACert,
AuthToken: tokenID,
}
tokenBasedAuthenticator := identity.Authenticate(tokenBasedAp)
tokenBasedAuthenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
otherToken, err := tokenBasedAuthenticator.GetToken()
if otherToken == "" || err != nil {
t.Fatal("Error while authenticating with token")
}
//Test if able to connect to compute, and get Flavors
serviceURL, err := tokenBasedAuthenticator.GetServiceURL("compute", "2")
if serviceURL == "" || err != nil {
t.Fatal("Error while fetching Compute Service with Token")
}
computeService := compute.NewService(&tokenBasedAuthenticator)
_, err = computeService.Flavors()
if err != nil {
t.Fatal("Error while fetching Compute flavors with Token")
}
}
// Image examples.
func TestDatabaseServiceScenarios(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
if os.Getenv("OS_AUTH_URL") == "" {
t.Skip("Cannot run integration test as the Openstack env vars aren't set.")
}
authenticator, err := identity.AuthenticateFromEnvVars()
authenticator.(requester.Manager).SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
if err != nil {
t.Fatal("Cannot authenticate from env vars:", err)
}
databaseService := database.NewService(authenticator)
user := database.UserParameter{Name: "User1", Password: "******"}
db := database.CreateDatabaseParameters{Name: "newDb"}
createInstanceParams := database.CreateInstanceParameters{
Databases: []database.CreateDatabaseParameters{db},
FlavorRef: "1001",
Name: "Instance1",
Users: []database.UserParameter{user},
}
instance, err := databaseService.CreateInstance(createInstanceParams)
if err != nil {
t.Fatal("Cannot create instance:", err)
}
WaitUntilActiveOrError(t, databaseService, instance.ID)
foundInstance := false
instances, err := databaseService.Instances()
if err != nil {
t.Fatal("Cannot query Instances:", err)
}
for _, i := range instances {
if i.ID == instance.ID {
foundInstance = true
break
}
}
if !foundInstance {
t.Fatal("Cannot find new instance")
}
err = databaseService.CreateUser(instance.ID, database.UserParameter{Name: "username", Password: "******"})
if err != nil {
t.Fatal("Cannot create user", err)
}
err = databaseService.DeleteUser(instance.ID, "username")
if err != nil {
t.Fatal("Cannot delete user", err)
}
pwd, err := databaseService.EnableRoot(instance.ID)
if err != nil {
t.Fatal("Cannot enable root", err)
}
testUtil.Assert(t, pwd.Name != "", "No Name")
backup, err := databaseService.CreateBackup(database.CreateBackupParameters{Name: "NewBackup", InstanceID: instance.ID, Description: "Test Description"})
if err != nil {
t.Fatal("Cannot make backup", err)
}
WaitUntilActiveOrError(t, databaseService, instance.ID)
err = databaseService.DeleteInstance(instance.ID)
if err != nil {
t.Fatal("Delete instance didn't work:", err)
}
newInstance, err := databaseService.RestoreBackupInstance(database.RestoreBackupParameters{Name: "Instance1", RestorePoint: database.RestorePoint{BackupRef: backup.ID}, FlavorRef: "1001"})
if err != nil {
t.Fatal("Cannot restore a backup", err)
}
WaitUntilActiveOrError(t, databaseService, newInstance.ID)
err = databaseService.DeleteBackup(backup.ID)
if err != nil {
t.Fatal("Cannot delete backup", err)
}
err = databaseService.DeleteInstance(newInstance.ID)
if err != nil {
t.Fatal("Delete instance didn't work:", err)
}
}
func TestNetworkServiceScenarios(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
if os.Getenv("OS_AUTH_URL") == "" {
t.Skip("No openstack auth configured so skipping test")
}
authParameters, err := common.FromEnvVars()
if err != nil {
t.Fatal("There was an error getting authentication env variables:", err)
}
authenticator := identity.Authenticate(authParameters)
authenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
networkService := network.NewService(&authenticator)
networkName := "OtherNetwork"
createdNetwork, err := networkService.CreateNetwork(
network.CreateNetworkParameters{
AdminStateUp: true,
Shared: false,
Name: networkName,
TenantID: authParameters.TenantID})
if err != nil {
t.Fatal("There was an error creating a network:", err)
}
networks, err := networkService.Networks()
if err != nil {
t.Fatal("There was an error getting a list of networks:", err)
}
networkIDs, err := networkService.NetworkIDsByName(networkName)
if err != nil {
t.Fatal("There was an error getting a list of networks ids by name", err)
}
if len(networkIDs) > 1 {
t.Fatalf("Wrong number of networks with the name %s: %v", networkName, err)
}
if networkIDs[0] != createdNetwork.ID {
t.Fatalf("Didn't find the correct networkID by its name %s: %v", networkName, err)
}
foundCreatedNetwork := false
for _, networkFound := range networks {
if reflect.DeepEqual(createdNetwork, networkFound) {
foundCreatedNetwork = true
}
}
if !foundCreatedNetwork {
t.Fatal("Cannot find network called OtherNetwork when getting a list of networks.")
}
// Might be nice to have some sugar api that can do this easily for a developer...
// Keep iterating until active or until more than 10 tries has been exceeded.
numTries := 0
activeNetwork := createdNetwork
for numTries < 10 || activeNetwork.Status != "ACTIVE" {
activeNetwork, _ = networkService.Network(createdNetwork.ID)
numTries++
fmt.Println("Sleeping 50ms on try:" + string(numTries) + " with status currently " + activeNetwork.Status)
sleepDuration, _ := time.ParseDuration("50ms")
time.Sleep(sleepDuration)
}
foundNetworksByName, err := networkService.QueryNetworks(network.QueryParameters{
Name: networkName,
})
if err != nil {
t.Fatal("There was an error getting a list of networks by name", err)
}
if len(foundNetworksByName) > 1 {
t.Fatalf("Wrong number of networks with the name %s: %v", networkName, err)
}
if foundNetworksByName[0].Name != networkName && foundNetworksByName[0].ID != createdNetwork.ID {
t.Fatalf("Didn't find the correct network by its name %s: %v", networkName, err)
}
err = networkService.DeleteNetwork(activeNetwork.ID)
if err != nil {
t.Fatal("Error in deleting OtherNetwork:", err)
}
networks, err = networkService.Networks()
if err != nil {
t.Fatal("There was an error getting a list of networks to verify the network was deleted:", err)
}
networkDeleted := true
for _, networkFound := range networks {
if reflect.DeepEqual(createdNetwork, networkFound) {
networkDeleted = false
}
}
if !networkDeleted {
t.Fatal("Delete of 'NewNetwork' did not occur")
}
}
func initTask(c *cli.Context) {
var err error
config, err = readConfigFile(c.GlobalString(Config))
if err != nil {
log.Fatal(err.Error())
}
for k := range config.Nodes {
config.OrderedNodeKeys = append(config.OrderedNodeKeys, k)
}
sort.Strings(config.OrderedNodeKeys)
config.Log()
log.Printf("%-20s - %s\n", AuthURLEnv, c.GlobalString(AuthURL))
log.Printf("%-20s - %s\n", TenantIDEnv, c.GlobalString(TenantID))
log.Printf("%-20s - %s\n", TenantNameEnv, c.GlobalString(TenantName))
log.Printf("%-20s - %s\n", UsernameEnv, c.GlobalString(Username))
log.Printf("%-20s - %s\n", RegionNameEnv, c.GlobalString(RegionName))
log.Printf("%-20s - %s\n", AuthTokenEnv, c.GlobalString(AuthToken))
log.Printf("%-20s - %s\n", CACertEnv, c.GlobalString(CACert))
log.Printf("%-20s - %v\n", SkipSSLValidation, c.GlobalBool(SkipSSLValidation))
log.Printf("%-20s - %v\n", Debug, c.GlobalBool(Debug))
authParameters := common.AuthenticationParameters{
AuthURL: c.GlobalString(AuthURL),
Username: c.GlobalString(Username),
Password: c.GlobalString(Password),
Region: c.GlobalString(RegionName),
TenantID: c.GlobalString(TenantID),
TenantName: c.GlobalString(TenantName),
CACert: c.GlobalString(CACert),
}
var transport *http.Transport
if c.GlobalString(CACert) != "" {
pemData, err := ioutil.ReadFile(c.GlobalString(CACert))
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s\n", "error:", "Unable to load CA Certificate file", c.GlobalString(CACert)))
}
certPool := x509.NewCertPool()
if !certPool.AppendCertsFromPEM(pemData) {
log.Fatal(fmt.Sprintf("%-20s - %s %s\n", "error:", "Invalid CA Certificates in file", c.GlobalString(CACert)))
}
transport = &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: certPool,
InsecureSkipVerify: c.GlobalBool(SkipSSLValidation),
},
}
misc.Transport(transport)
} else {
transport = &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: c.GlobalBool(SkipSSLValidation),
},
}
misc.Transport(transport)
}
authenticator := identity.Authenticate(authParameters)
authenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, &http.Client{Transport: transport}, c.GlobalBool(Debug)))
token, err := authenticator.GetToken()
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s\n", "error:", err.Error()))
}
log.Printf("%-20s - %s\n", "token", token)
computeService = compute.NewService(&authenticator)
networkService = network.NewService(&authenticator)
imageService = image.NewService(&authenticator)
keypair, err = computeService.KeyPair(config.SSHKey)
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s %s\n", "error:", "get keypair", config.SSHKey, err.Error()))
}
var q = network.QueryParameters{Name: config.Network}
networks, err := networkService.QueryNetworks(q)
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s %s\n", "error:", "get network by name", config.Network, err.Error()))
}
netwrk, err = networkService.Network(networks[0].ID)
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s %s\n", "error:", "getting network by id", networks[0].ID, err.Error()))
}
log.Printf("%-20s - %s\n", "network", netwrk.ID)
subnets, err = networkService.Subnets()
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s\n", "error:", "get subnets", err.Error()))
}
ports, err = networkService.Ports()
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s\n", "error:", "get ports", err.Error()))
}
sort.Sort(PortByName(ports))
servers, err = computeService.Servers()
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s\n", "error:", "get servers", err.Error()))
}
sort.Sort(ServerByName(servers))
flavors, err := computeService.Flavors()
if err != nil {
log.Fatal(fmt.Sprintf("%-20s - %s %s\n", "error:", "get flavors", err.Error()))
}
flavorMap = make(map[string]string)
for _, p := range flavors {
flavorMap[p.Name] = p.ID
}
}
func TestSecurityGroupScenarios(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
authParameters, err := common.FromEnvVars()
if err != nil {
t.Fatal("There was an error getting authentication env variables:", err)
}
authenticator := identity.Authenticate(authParameters)
authenticator.SetFunction(requester.DebugRequestMakerGenerator(nil, nil, testing.Verbose()))
networkService := network.NewService(&authenticator)
sampleSecurityGroup := network.CreateSecurityGroupParameters{
Description: "Description",
Name: "NewCustomSecurityGroup",
}
securityGroup, err := networkService.CreateSecurityGroup(sampleSecurityGroup)
if err != nil {
t.Fatal("Cannot create security group:", err)
}
tcp := network.TCP
cidr := "0.0.0.0/0"
sampleRule := network.CreateSecurityGroupRuleParameters{
PortRangeMin: intPointer(80),
PortRangeMax: intPointer(80),
IPProtocol: &tcp,
RemoteIPPrefix: &cidr,
SecurityGroupID: securityGroup.ID,
Direction: "ingress",
}
securityGroupRule, err := networkService.CreateSecurityGroupRule(sampleRule)
if err != nil {
t.Error("Cannot create security group rule:", err)
}
testUtil.Equals(t, 80, *securityGroupRule.PortRangeMin)
testUtil.Equals(t, 80, *securityGroupRule.PortRangeMax)
testUtil.Equals(t, cidr, *securityGroupRule.RemoteIPPrefix)
sampleRule2 := network.CreateSecurityGroupRuleParameters{
PortRangeMin: nil,
PortRangeMax: nil,
IPProtocol: &tcp,
SecurityGroupID: securityGroup.ID,
Direction: "ingress",
RemoteGroupID: &securityGroup.ID,
}
securityGroupRule2, err := networkService.CreateSecurityGroupRule(sampleRule2)
if err != nil {
t.Error("Cannot create security group rule:", err)
}
testUtil.Equals(t, (*int)(nil), securityGroupRule2.PortRangeMin)
testUtil.Equals(t, (*int)(nil), securityGroupRule2.PortRangeMax)
testUtil.Equals(t, securityGroup.ID, *securityGroupRule2.RemoteGroupID)
testUtil.Equals(t, (*string)(nil), securityGroupRule2.RemoteIPPrefix)
queriedSecurityGroup, err := networkService.SecurityGroup(securityGroup.ID)
if err != nil {
t.Error("Cannot requery security group:", err)
}
testUtil.Equals(t, 4, len(queriedSecurityGroup.SecurityGroupRules))
err = networkService.DeleteSecurityGroupRule(securityGroupRule.ID)
if err != nil {
t.Error("Cannot delete security group rule:", err)
}
err = networkService.DeleteSecurityGroup(queriedSecurityGroup.ID)
if err != nil {
t.Error("Cannot delete security group:", err)
}
}