github/kata-containers
1
0
Fork 1
mirror of https://github.com/kata-containers/kata-containers.git synced 2025-08-23 18:21:27 +00:00
Code Issues Projects Releases Wiki Activity

virtcontainers: Decouple the network API from the sandbox one

Browse Source 
In order to fix #1059, we want to create a hypervisor package. Some of
the hypervisor implementations (qemu) depend on the network and endpoint
interfaces. We can not have a virtcontainers -> hypervisor -> network,
endpoint -> virtcontainers cyclic dependency.
So before creating the hypervisor package, we need to decouple the
network API from the virtcontainers one.

Fixes: #1180

Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
This commit is contained in:
Samuel Ortiz 2019-01-25 14:45:26 +01:00
parent b39cb1d13a
commit 18dcd2c2f7
2 changed files with 28 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
virtcontainers/network.go
View File

@ -1300,7 +1300,7 @@ func networkInfoFromLink(handle *netlink.Handle, link netlink.Link) (NetworkInfo
}, nil }, nil
} }
func createEndpointsFromScan(networkNSPath string, config NetworkConfig) ([]Endpoint, error) { func createEndpointsFromScan(networkNSPath string, config *NetworkConfig) ([]Endpoint, error) {
var endpoints []Endpoint var endpoints []Endpoint
netnsHandle, err := netns.GetFromPath(networkNSPath) netnsHandle, err := netns.GetFromPath(networkNSPath)
@ -1441,26 +1441,24 @@ func (n *Network) Run(networkNSPath string, cb func() error) error {
} }
// Add adds all needed interfaces inside the network namespace. // Add adds all needed interfaces inside the network namespace.
func (n *Network) Add(s *Sandbox, hotplug bool) error { func (n *Network) Add(ctx context.Context, config *NetworkConfig, hypervisor hypervisor, hotplug bool) ([]Endpoint, error) {
span, _ := n.trace(s.ctx, "add") span, _ := n.trace(ctx, "add")
defer span.Finish() defer span.Finish()
endpoints, err := createEndpointsFromScan(s.config.NetworkConfig.NetNSPath, s.config.NetworkConfig) endpoints, err := createEndpointsFromScan(config.NetNSPath, config)
if err != nil { if err != nil {
return err return endpoints, err
} }
s.networkNS.Endpoints = endpoints err = doNetNS(config.NetNSPath, func(_ ns.NetNS) error {
for _, endpoint := range endpoints {
err = doNetNS(s.config.NetworkConfig.NetNSPath, func(_ ns.NetNS) error {
for _, endpoint := range s.networkNS.Endpoints {
networkLogger().WithField("endpoint-type", endpoint.Type()).WithField("hotplug", hotplug).Info("Attaching endpoint") networkLogger().WithField("endpoint-type", endpoint.Type()).WithField("hotplug", hotplug).Info("Attaching endpoint")
if hotplug { if hotplug {
if err := endpoint.HotAttach(s.hypervisor); err != nil { if err := endpoint.HotAttach(hypervisor); err != nil {
return err return err
} }
} else { } else {
if err := endpoint.Attach(s.hypervisor); err != nil { if err := endpoint.Attach(hypervisor); err != nil {
return err return err
} }
} }
@ -1469,30 +1467,30 @@ func (n *Network) Add(s *Sandbox, hotplug bool) error {
return nil return nil
}) })
if err != nil { if err != nil {
return err return []Endpoint{}, err
} }
networkLogger().Debug("Network added") networkLogger().Debug("Network added")
return nil return endpoints, nil
} }
// Remove network endpoints in the network namespace. It also deletes the network // Remove network endpoints in the network namespace. It also deletes the network
// namespace in case the namespace has been created by us. // namespace in case the namespace has been created by us.
func (n *Network) Remove(s *Sandbox, hotunplug bool) error { func (n *Network) Remove(ctx context.Context, ns *NetworkNamespace, hypervisor hypervisor, hotunplug bool) error {
span, _ := n.trace(s.ctx, "remove") span, _ := n.trace(ctx, "remove")
defer span.Finish() defer span.Finish()
for _, endpoint := range s.networkNS.Endpoints { for _, endpoint := range ns.Endpoints {
// Detach for an endpoint should enter the network namespace // Detach for an endpoint should enter the network namespace
// if required. // if required.
networkLogger().WithField("endpoint-type", endpoint.Type()).WithField("hotunplug", hotunplug).Info("Detaching endpoint") networkLogger().WithField("endpoint-type", endpoint.Type()).WithField("hotunplug", hotunplug).Info("Detaching endpoint")
if hotunplug { if hotunplug {
if err := endpoint.HotDetach(s.hypervisor, s.networkNS.NetNsCreated, s.networkNS.NetNsPath); err != nil { if err := endpoint.HotDetach(hypervisor, ns.NetNsCreated, ns.NetNsPath); err != nil {
return err return err
} }
} else { } else {
if err := endpoint.Detach(s.networkNS.NetNsCreated, s.networkNS.NetNsPath); err != nil { if err := endpoint.Detach(ns.NetNsCreated, ns.NetNsPath); err != nil {
return err return err
} }
} }
@ -1500,9 +1498,9 @@ func (n *Network) Remove(s *Sandbox, hotunplug bool) error {
networkLogger().Debug("Network removed") networkLogger().Debug("Network removed")
if s.networkNS.NetNsCreated { if ns.NetNsCreated {
networkLogger().Infof("Network namespace %q deleted", s.networkNS.NetNsPath) networkLogger().Infof("Network namespace %q deleted", ns.NetNsPath)
return deleteNetNS(s.networkNS.NetNsPath) return deleteNetNS(ns.NetNsPath)
} }
return nil return nil

12
virtcontainers/sandbox.go
View File

@ -797,10 +797,13 @@ func (s *Sandbox) createNetwork() error {
// after vm is started. // after vm is started.
if s.factory == nil { if s.factory == nil {
// Add the network // Add the network
if err := s.network.Add(s, false); err != nil { endpoints, err := s.network.Add(s.ctx, &s.config.NetworkConfig, s.hypervisor, false)
if err != nil {
return err return err
} }
s.networkNS.Endpoints = endpoints
if s.config.NetworkConfig.NetmonConfig.Enable { if s.config.NetworkConfig.NetmonConfig.Enable {
if err := s.startNetworkMonitor(); err != nil { if err := s.startNetworkMonitor(); err != nil {
return err return err
@ -822,7 +825,7 @@ func (s *Sandbox) removeNetwork() error {
} }
} }
return s.network.Remove(s, s.factory != nil) return s.network.Remove(s.ctx, &s.networkNS, s.hypervisor, s.factory != nil)
} }
func (s *Sandbox) generateNetInfo(inf *vcTypes.Interface) (NetworkInfo, error) { func (s *Sandbox) generateNetInfo(inf *vcTypes.Interface) (NetworkInfo, error) {
@ -954,10 +957,13 @@ func (s *Sandbox) startVM() error {
// In case of vm factory, network interfaces are hotplugged // In case of vm factory, network interfaces are hotplugged
// after vm is started. // after vm is started.
if s.factory != nil { if s.factory != nil {
if err := s.network.Add(s, true); err != nil { endpoints, err := s.network.Add(s.ctx, &s.config.NetworkConfig, s.hypervisor, true)
if err != nil {
return err return err
} }
s.networkNS.Endpoints = endpoints
if s.config.NetworkConfig.NetmonConfig.Enable { if s.config.NetworkConfig.NetmonConfig.Enable {
if err := s.startNetworkMonitor(); err != nil { if err := s.startNetworkMonitor(); err != nil {
return err return err