public and private vns

pkg/driver/monitoring_helpers.go

@@ -165,7 +165,30 @@ func MonitorNetworks(log *zap.Logger, c *ONeClient) (res *structpb.Value, err er
 		return state
 	}()
 
-	state["private_vnet"] = map[string]interface{}{"error": "Private VNet Pool Monitoring not implemented"}
+	state["private_vnet_tmpl"] = func() (state map[string]interface{}) {
+		state = map[string]interface{}{}
+		private_vnet_tmpl_id, ok := c.vars[PRIVATE_VN_TEMPLATE]
+		if !ok {
+			state["error"] = "VNet Template is not set"
+			return state
+		}
+
+		id, err := GetVarValue(private_vnet_tmpl_id, "default")
+		if err != nil {
+			state["error"] = err.Error()
+			return state
+		}
+		vn_tmpl, err := c.ctrl.VNTemplate(int(id.GetNumberValue())).Info(true)
+		if err != nil {
+			state["error"] = err.Error()
+			return state
+		}
+
+		state["id"] = vn_tmpl.ID
+		state["name"] = vn_tmpl.Name
+		log.Debug("private_vnet_tmpl", zap.Any("state", state))
+		return state
+	}()
 
 	return structpb.NewValue(state)
 }

pkg/driver/template.go

@@ -149,6 +149,17 @@ func (c *ONeClient) InstantiateTemplateHelper(instance *instpb.Instance, group_d
 		tmpl.AddCtx(keys.NetworkCtx, "YES")
 	}
 
+	private_vn := int(group_data["private_vn"].GetNumberValue())
+	for i := 0; i < int(resources["ips_private"].GetNumberValue()); i++ {
+		nic := tmpl.AddNIC()
+		nic.Add(shared.NetworkID, private_vn)
+	}
+	// OpenNebula won't generate Networking context without this key set to YES
+	// so most templates won't generate network interfaces inside the VM
+	if int(resources["ips_private"].GetNumberValue()) > 0 {
+		tmpl.AddCtx(keys.NetworkCtx, "YES")
+	}
+
 	tmpl_string := tmpl.String()
 	c.log.Debug("Resulting Template", zap.String("template", tmpl_string))
 	vmid, err = c.InstantiateTemplate(template_id, vmname, tmpl_string, false)
@@ -161,7 +172,7 @@ func (c *ONeClient) InstantiateTemplateHelper(instance *instpb.Instance, group_d
 	return vmid, nil
 }
 
-func (c *ONeClient) InstantiateTemplate(id int, vmname, tmpl string, pending bool) (vmid int, err error ){
+func (c *ONeClient) InstantiateTemplate(id int, vmname, tmpl string, pending bool) (vmid int, err error) {
 	tc := c.ctrl.Template(id)
 	return tc.Instantiate(vmname, pending, tmpl, false)
-}
+}

pkg/driver/vars.go

@@ -29,6 +29,8 @@ var (
 	SCHED_DS = "sched_ds"
 	// OpenNebula Super VNet public IP addresses to be reserved from
 	PUBLIC_IP_POOL = "public_ip_pool"
+	// OpenNebula Super VNet private IP addresses to be reserved from
+	PRIVATE_VN_TEMPLATE = "private_vnet_tmpl"
 
 	// OpenNebula VM Name Data Key
 	DATA_VM_NAME = "vm_name"
@@ -47,4 +49,4 @@ func GetVarValue(in *proto.Var, key string) (r *structpb.Value, err error) {
 		return r, nil
 	}
 	return nil, fmt.Errorf("keys '%s' and 'default' are not set", key)
-}
+}

pkg/driver/vnet.go

@@ -25,7 +25,8 @@ import (
 )
 
 var (
-	USER_PUBLIC_VNET_NAME_PATTERN = "user-%d-pub-vnet"
+	USER_PUBLIC_VNET_NAME_PATTERN  = "user-%d-pub-vnet"
+	USER_PRIVATE_VNET_NAME_PATTERN = "user-%d-private-vnet"
 )
 
 func (c *ONeClient) ReservePublicIP(u, n int) (pool_id int, err error) {
@@ -46,30 +47,68 @@ func (c *ONeClient) ReservePublicIP(u, n int) (pool_id int, err error) {
 	if err != nil {
 		user_pub_net_id = -1
 	}
-	for i := 0; i < n; i++ {
+	/*for i := 0; i < n; i++ {
 		user_pub_net_id, err = c.ReserveVNet(
 			public_pool.ID, 1, user_pub_net_id,
 			fmt.Sprintf(USER_PUBLIC_VNET_NAME_PATTERN, u))
 		if err != nil {
 			return -1, err
 		}
+	}*/
+	user_pub_net_id, err = c.ReserveVNet(
+		public_pool.ID, n, user_pub_net_id,
+		fmt.Sprintf(USER_PUBLIC_VNET_NAME_PATTERN, u))
+	if err != nil {
+		return -1, err
 	}
-	
+
 	c.Chown(
 		"vn", user_pub_net_id,
-		u, int(c.secrets["group"].GetNumberValue()) )
+		u, int(c.secrets["group"].GetNumberValue()))
 	c.Chmod(
 		"vn", user_pub_net_id,
 		&shared.Permissions{
 			1, 1, 0,
 			0, 0, 0,
-			0, 0, 0 },
+			0, 0, 0},
 	)
 	c.UpdateVNet(user_pub_net_id, "TYPE=\"PUBLIC\"", parameters.Merge)
 
 	return user_pub_net_id, nil
 }
 
+func (c *ONeClient) ReservePrivateIP(u int) (pool_id int, err error) {
+	private_tmpl_id, ok := c.vars[PRIVATE_VN_TEMPLATE]
+	if !ok {
+		return -1, errors.New("VNet Tmpl ID is not set")
+	}
+
+	id, err := GetVarValue(private_tmpl_id, "default")
+	if err != nil {
+		return -1, err
+	}
+
+	//extra := fmt.Sprintf("VLAN_ID=%d", ar)
+	user_private_net_id, err := c.ctrl.VNTemplate(int(id.GetNumberValue())).Instantiate(fmt.Sprintf(USER_PRIVATE_VNET_NAME_PATTERN, u), "VLAN_ID=0")
+	if err != nil {
+		user_private_net_id = -1
+	}
+
+	c.Chown(
+		"vn", user_private_net_id,
+		u, int(c.secrets["group"].GetNumberValue()))
+	c.Chmod(
+		"vn", user_private_net_id,
+		&shared.Permissions{
+			1, 1, 0,
+			0, 0, 0,
+			0, 0, 0},
+	)
+	c.UpdateVNet(user_private_net_id, "TYPE=\"PRIVATE\"", parameters.Merge)
+
+	return user_private_net_id, nil
+}
+
 func (c *ONeClient) GetVNet(id int) (*vnet.VirtualNetwork, error) {
 	vnc := c.ctrl.VirtualNetwork(id)
 	return vnc.Info(true)
@@ -80,7 +119,12 @@ func (c *ONeClient) GetUserPublicVNet(user int) (id int, err error) {
 	return vnsc.ByName(fmt.Sprintf(USER_PUBLIC_VNET_NAME_PATTERN, user))
 }
 
-func(c *ONeClient) UpdateVNet(id int, tmpl string, uType parameters.UpdateType) error {
+func (c *ONeClient) GetUserPrivateVNet(user int) (id int, err error) {
+	vnsc := c.ctrl.VirtualNetworks()
+	return vnsc.ByName(fmt.Sprintf(USER_PRIVATE_VNET_NAME_PATTERN, user))
+}
+
+func (c *ONeClient) UpdateVNet(id int, tmpl string, uType parameters.UpdateType) error {
 	vnc := c.ctrl.VirtualNetwork(id)
 	return vnc.Update(tmpl, uType)
 }
@@ -100,4 +144,4 @@ func (c *ONeClient) ReserveVNet(id, size, to int, name string) (int, error) {
 		tmpl += fmt.Sprintf("VNET=%d", to)
 	}
 	return vnc.Reserve(tmpl)
-}
+}

pkg/server/server.go

@@ -156,12 +156,12 @@ func (s *DriverServiceServer) PrepareService(ctx context.Context, igroup *ipb.In
 		public_ips_amount = int(resources["ips_public"].GetNumberValue())
 	}
 
-	var free int = 0
+	var freePubIps int = 0
 	if data["public_ips_free"] != nil {
-		free = int(data["public_ips_free"].GetNumberValue())
+		freePubIps = int(data["public_ips_free"].GetNumberValue())
 	}
-	if public_ips_amount > 0 && public_ips_amount > free {
-		public_ips_amount -= free
+	if public_ips_amount > 0 && public_ips_amount > freePubIps {
+		public_ips_amount -= freePubIps
 		public_ips_pool_id, err := client.ReservePublicIP(oneID, public_ips_amount)
 		if err != nil {
 			s.log.Debug("Couldn't reserve Public IP addresses",
@@ -175,7 +175,26 @@ func (s *DriverServiceServer) PrepareService(ctx context.Context, igroup *ipb.In
 		}
 		data["public_ips_total"] = structpb.NewNumberValue(total)
 
-		data["public_ips_free"] = structpb.NewNumberValue(float64(free + public_ips_amount))
+		data["public_ips_free"] = structpb.NewNumberValue(float64(freePubIps + public_ips_amount))
+	}
+
+	var private_ips_amount int = 0
+	if resources["ips_private"] != nil {
+		private_ips_amount = int(resources["ips_private"].GetNumberValue())
+	}
+
+	/*var address_range_id int = -1
+	if data["address_range_id"] != nil {
+		address_range_id = int(data["address_range_id"].GetNumberValue())
+	}*/
+	if private_ips_amount > 0 {
+		private_ips_pool_id, err := client.ReservePrivateIP(oneID)
+		if err != nil {
+			s.log.Debug("Couldn't reserve Private IP addresses",
+				zap.Error(err), zap.Int("amount", private_ips_amount), zap.Int("user", oneID))
+			return nil, status.Error(codes.Internal, "Couldn't reserve Private IP addresses")
+		}
+		data["private_vn"] = structpb.NewNumberValue(float64(private_ips_pool_id))
 	}
 
 	return data, nil
@@ -212,6 +231,7 @@ func (s *DriverServiceServer) Up(ctx context.Context, input *pb.UpRequest) (*pb.
 		log.Error("Error Preparing Service", zap.Any("group", igroup), zap.Error(err))
 		return nil, err
 	}
+
 	userid := int(data["userid"].GetNumberValue())
 	for _, instance := range igroup.GetInstances() {
 		token, err := auth.MakeTokenInstance(instance.GetUuid())