// CreateExternalRouter creates a router on the external network. This requires
// the OS_EXTGW_ID environment variable to be set. An error is returned if the
// creation failed.
func CreateExternalRouter(t *testing.T, client *gophercloud.ServiceClient) (*routers.Router, error) {
var router *routers.Router
choices, err := clients.AcceptanceTestChoicesFromEnv()
if err != nil {
return router, err
}
routerName := tools.RandomString("TESTACC-", 8)
t.Logf("Attempting to create external router: %s", routerName)
adminStateUp := true
gatewayInfo := routers.GatewayInfo{
NetworkID: choices.ExternalNetworkID,
}
createOpts := routers.CreateOpts{
Name: routerName,
AdminStateUp: &adminStateUp,
GatewayInfo: &gatewayInfo,
}
router, err = routers.Create(client, createOpts).Extract()
if err != nil {
return router, err
}
if err := WaitForRouterToCreate(client, router.ID, 60); err != nil {
return router, err
}
t.Logf("Created router: %s", routerName)
return router, nil
}
// CreateRouter creates a router on a specified Network ID. An error will be
// returned if the creation failed.
func CreateRouter(t *testing.T, client *gophercloud.ServiceClient, networkID string) (*routers.Router, error) {
routerName := tools.RandomString("TESTACC-", 8)
t.Logf("Attempting to create router: %s", routerName)
adminStateUp := true
gatewayInfo := routers.GatewayInfo{
NetworkID: networkID,
}
createOpts := routers.CreateOpts{
Name: routerName,
AdminStateUp: &adminStateUp,
GatewayInfo: &gatewayInfo,
}
router, err := routers.Create(client, createOpts).Extract()
if err != nil {
return router, err
}
if err := WaitForRouterToCreate(client, router.ID, 60); err != nil {
return router, err
}
t.Logf("Created router: %s", routerName)
return router, nil
}
func resourceNetworkingRouterV2Create(d *schema.ResourceData, meta interface{}) error {
config := meta.(*Config)
networkingClient, err := config.networkingV2Client(d.Get("region").(string))
if err != nil {
return fmt.Errorf("Error creating OpenStack networking client: %s", err)
}
createOpts := RouterCreateOpts{
routers.CreateOpts{
Name: d.Get("name").(string),
TenantID: d.Get("tenant_id").(string),
},
MapValueSpecs(d),
}
if asuRaw, ok := d.GetOk("admin_state_up"); ok {
asu := asuRaw.(bool)
createOpts.AdminStateUp = &asu
}
if dRaw, ok := d.GetOk("distributed"); ok {
d := dRaw.(bool)
createOpts.Distributed = &d
}
externalGateway := d.Get("external_gateway").(string)
if externalGateway != "" {
gatewayInfo := routers.GatewayInfo{
NetworkID: externalGateway,
}
createOpts.GatewayInfo = &gatewayInfo
}
log.Printf("[DEBUG] Create Options: %#v", createOpts)
n, err := routers.Create(networkingClient, createOpts).Extract()
if err != nil {
return fmt.Errorf("Error creating OpenStack Neutron router: %s", err)
}
log.Printf("[INFO] Router ID: %s", n.ID)
log.Printf("[DEBUG] Waiting for OpenStack Neutron Router (%s) to become available", n.ID)
stateConf := &resource.StateChangeConf{
Pending: []string{"BUILD", "PENDING_CREATE", "PENDING_UPDATE"},
Target: []string{"ACTIVE"},
Refresh: waitForRouterActive(networkingClient, n.ID),
Timeout: 10 * time.Minute,
Delay: 5 * time.Second,
MinTimeout: 3 * time.Second,
}
_, err = stateConf.WaitForState()
d.SetId(n.ID)
return resourceNetworkingRouterV2Read(d, meta)
}
// deploy achieves the aims of Deploy().
func (p *openstackp) deploy(resources *Resources, requiredPorts []int) (err error) {
// the resource name can only contain letters, numbers, underscores,
// spaces and hyphens
if !openstackValidResourceNameRegexp.MatchString(resources.ResourceName) {
err = Error{"openstack", "deploy", ErrBadResourceName}
return
}
// get/create key pair
kp, err := keypairs.Get(p.computeClient, resources.ResourceName).Extract()
if err != nil {
if _, notfound := err.(gophercloud.ErrDefault404); notfound {
// create a new keypair; we can't just let Openstack create one for
// us because in latest versions it does not return a DER encoded
// key, which is what GO built-in library supports.
privateKey, errk := rsa.GenerateKey(rand.Reader, 1024)
if errk != nil {
err = errk
return
}
privateKeyPEM := &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)}
privateKeyPEMBytes := pem.EncodeToMemory(privateKeyPEM)
pub, errk := ssh.NewPublicKey(&privateKey.PublicKey)
if errk != nil {
err = errk
return err
}
publicKeyStr := ssh.MarshalAuthorizedKey(pub)
kp, err = keypairs.Create(p.computeClient, keypairs.CreateOpts{Name: resources.ResourceName, PublicKey: string(publicKeyStr)}).Extract()
if err != nil {
return
}
resources.PrivateKey = string(privateKeyPEMBytes)
} else {
return
}
}
resources.Details["keypair"] = kp.Name
// based on hostname, see if we're currently running on an openstack server,
// in which case we'll use this server's security group and network.
hostname, err := os.Hostname()
inCloud := false
if err == nil {
pager := servers.List(p.computeClient, servers.ListOpts{})
err = pager.EachPage(func(page pagination.Page) (bool, error) {
serverList, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
for _, server := range serverList {
if server.Name == hostname {
p.ownName = hostname
// get the first networkUUID we come across *** not sure
// what the other possibilities are and what else we can do
// instead
for networkName := range server.Addresses {
networkUUID, _ := networks.IDFromName(p.networkClient, networkName)
if networkUUID != "" {
p.networkName = networkName
p.networkUUID = networkUUID
break
}
}
// get the first security group *** again, not sure how to
// pick the "best" if more than one
for _, smap := range server.SecurityGroups {
if value, found := smap["name"]; found && value.(string) != "" {
p.securityGroup = value.(string)
break
}
}
if p.networkUUID != "" && p.securityGroup != "" {
inCloud = true
return false, nil
}
}
}
return true, nil
})
}
//*** actually, if in cloud, we should create a security group that allows
// the given ports, only accessible by things in the current security group
// don't create any more resources if we're already running in OpenStack
if inCloud {
return
}
// get/create security group
pager := secgroups.List(p.computeClient)
var group *secgroups.SecurityGroup
foundGroup := false
err = pager.EachPage(func(page pagination.Page) (bool, error) {
groupList, err := secgroups.ExtractSecurityGroups(page)
if err != nil {
return false, err
}
for _, g := range groupList {
if g.Name == resources.ResourceName {
group = &g
foundGroup = true
return false, nil
}
}
return true, nil
})
if err != nil {
return
}
if !foundGroup {
// create a new security group with rules allowing the desired ports
group, err = secgroups.Create(p.computeClient, secgroups.CreateOpts{Name: resources.ResourceName, Description: "access amongst wr-spawned nodes"}).Extract()
if err != nil {
return
}
//*** check if the rules are already there, in case we previously died
// between previous line and this one
for _, port := range requiredPorts {
_, err = secgroups.CreateRule(p.computeClient, secgroups.CreateRuleOpts{
ParentGroupID: group.ID,
FromPort: port,
ToPort: port,
IPProtocol: "TCP",
CIDR: "0.0.0.0/0", // FromGroupID: group.ID if we were creating a head node and then wanted a rule for all worker nodes...
}).Extract()
if err != nil {
return
}
}
// ICMP may help networking work as expected
_, err = secgroups.CreateRule(p.computeClient, secgroups.CreateRuleOpts{
ParentGroupID: group.ID,
FromPort: 0,
ToPort: 0, // *** results in a port of '0', which is not the same as "ALL ICMP" which then says "Any" in the web interface
IPProtocol: "ICMP",
CIDR: "0.0.0.0/0",
}).Extract()
if err != nil {
return
}
}
resources.Details["secgroup"] = group.ID
p.securityGroup = resources.ResourceName
// get/create network
var network *networks.Network
networkID, err := networks.IDFromName(p.networkClient, resources.ResourceName)
if err != nil {
if _, notfound := err.(gophercloud.ErrResourceNotFound); notfound {
// create a network for ourselves
network, err = networks.Create(p.networkClient, networks.CreateOpts{Name: resources.ResourceName, AdminStateUp: gophercloud.Enabled}).Extract()
if err != nil {
return
}
networkID = network.ID
} else {
return
}
} else {
network, err = networks.Get(p.networkClient, networkID).Extract()
if err != nil {
return
}
}
resources.Details["network"] = networkID
p.networkName = resources.ResourceName
p.networkUUID = networkID
// get/create subnet
var subnetID string
if len(network.Subnets) == 1 {
subnetID = network.Subnets[0]
// *** check it's valid? could we end up with more than 1 subnet?
} else {
// add a big enough subnet
var gip = new(string)
*gip = "192.168.0.1"
var subnet *subnets.Subnet
subnet, err = subnets.Create(p.networkClient, subnets.CreateOpts{
NetworkID: networkID,
CIDR: "192.168.0.0/16",
GatewayIP: gip,
DNSNameservers: dnsNameServers[:], // this is critical, or servers on new networks can't be ssh'd to for many minutes
IPVersion: 4,
Name: resources.ResourceName,
}).Extract()
if err != nil {
return
}
subnetID = subnet.ID
}
resources.Details["subnet"] = subnetID
// get/create router
var routerID string
pager = routers.List(p.networkClient, routers.ListOpts{Name: resources.ResourceName})
err = pager.EachPage(func(page pagination.Page) (bool, error) {
routerList, err := routers.ExtractRouters(page)
if err != nil {
return false, err
}
routerID = routerList[0].ID
// *** check it's valid? could we end up with more than 1 router?
return false, nil
})
if err != nil {
return
}
if routerID == "" {
var router *routers.Router
router, err = routers.Create(p.networkClient, routers.CreateOpts{
Name: resources.ResourceName,
GatewayInfo: &routers.GatewayInfo{NetworkID: p.externalNetworkID},
AdminStateUp: gophercloud.Enabled,
}).Extract()
if err != nil {
return
}
routerID = router.ID
// add our subnet
_, err = routers.AddInterface(p.networkClient, routerID, routers.AddInterfaceOpts{SubnetID: subnetID}).Extract()
if err != nil {
// if this fails, we'd be stuck with a useless router, so we try and
// delete it
routers.Delete(p.networkClient, router.ID)
return
}
}
resources.Details["router"] = routerID
return
}
// Create network
func (os *OpenStack) CreateNetwork(network *provider.Network) error {
if len(network.Subnets) == 0 {
return errors.New("Subnets is null")
}
// create network
opts := networks.CreateOpts{
Name: network.Name,
AdminStateUp: &adminStateUp,
TenantID: network.TenantID,
}
osNet, err := networks.Create(os.network, opts).Extract()
if err != nil {
glog.Errorf("Create openstack network %s failed: %v", network.Name, err)
return err
}
// create router
routerOpts := routers.CreateOpts{
Name: network.Name,
TenantID: network.TenantID,
GatewayInfo: &routers.GatewayInfo{NetworkID: os.ExtNetID},
}
osRouter, err := routers.Create(os.network, routerOpts).Extract()
if err != nil {
glog.Errorf("Create openstack router %s failed: %v", network.Name, err)
delErr := os.DeleteNetwork(network.Name)
if delErr != nil {
glog.Errorf("Delete openstack network %s failed: %v", network.Name, delErr)
}
return err
}
// create subnets and connect them to router
networkID := osNet.ID
network.Status = os.ToProviderStatus(osNet.Status)
network.Uid = osNet.ID
for _, sub := range network.Subnets {
// create subnet
subnetOpts := subnets.CreateOpts{
NetworkID: networkID,
CIDR: sub.Cidr,
Name: sub.Name,
IPVersion: gophercloud.IPv4,
TenantID: network.TenantID,
GatewayIP: &sub.Gateway,
DNSNameservers: sub.Dnsservers,
}
s, err := subnets.Create(os.network, subnetOpts).Extract()
if err != nil {
glog.Errorf("Create openstack subnet %s failed: %v", sub.Name, err)
delErr := os.DeleteNetwork(network.Name)
if delErr != nil {
glog.Errorf("Delete openstack network %s failed: %v", network.Name, delErr)
}
return err
}
// add subnet to router
opts := routers.AddInterfaceOpts{
SubnetID: s.ID,
}
_, err = routers.AddInterface(os.network, osRouter.ID, opts).Extract()
if err != nil {
glog.Errorf("Create openstack subnet %s failed: %v", sub.Name, err)
delErr := os.DeleteNetwork(network.Name)
if delErr != nil {
glog.Errorf("Delete openstack network %s failed: %v", network.Name, delErr)
}
return err
}
}
return nil
}
