mirror of
https://github.com/containers/podman.git
synced 2025-12-12 17:57:31 +08:00
5952486df8
Like docker podman network inspect should output the information of
running container with their ip/mac address on this network.
However the output format is not docker compatible as this cannot
include all the info we have and the previous output was already not
compatible so this is not new.
New example output:
```
[
{
...
"containers": {
"7c0d295779cee4a6db7adc07a99e635909413a390eeab9f951edbc4aac406bf1": {
"name": "c2",
"interfaces": {
"eth0": {
"subnets": [
{
"ipnet": "10.89.0.4/24",
"gateway": "10.89.0.1"
},
{
"ipnet": "fda3:b4da:da1e:7e9d::4/64",
"gateway": "fda3:b4da:da1e:7e9d::1"
}
],
"mac_address": "1a:bd:ca:ea:4b:3a"
}
}
},
"b17c6651ae6d9cc7d5825968e01d6b1e67f44460bb0c140bcc32bd9d436ac11d": {
"name": "c1",
"interfaces": {
"eth0": {
"subnets": [
{
"ipnet": "10.89.0.3/24",
"gateway": "10.89.0.1"
},
{
"ipnet": "fda3:b4da:da1e:7e9d::3/64",
"gateway": "fda3:b4da:da1e:7e9d::1"
}
],
"mac_address": "f6:50:e6:22:d9:55"
}
}
}
}
}
]
```
Fixes #14126
Fixes https://issues.redhat.com/browse/RHEL-3153
Signed-off-by: Paul Holzinger <pholzing@redhat.com>
113 lines
4.0 KiB
Go
113 lines
4.0 KiB
Go
package tunnel
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/containers/common/libnetwork/types"
|
|
"github.com/containers/podman/v5/libpod/define"
|
|
"github.com/containers/podman/v5/pkg/bindings/network"
|
|
"github.com/containers/podman/v5/pkg/domain/entities"
|
|
"github.com/containers/podman/v5/pkg/errorhandling"
|
|
)
|
|
|
|
func (ic *ContainerEngine) NetworkUpdate(ctx context.Context, netName string, opts entities.NetworkUpdateOptions) error {
|
|
options := new(network.UpdateOptions).WithAddDNSServers(opts.AddDNSServers).WithRemoveDNSServers(opts.RemoveDNSServers)
|
|
return network.Update(ic.ClientCtx, netName, options)
|
|
}
|
|
|
|
func (ic *ContainerEngine) NetworkList(ctx context.Context, opts entities.NetworkListOptions) ([]types.Network, error) {
|
|
options := new(network.ListOptions).WithFilters(opts.Filters)
|
|
return network.List(ic.ClientCtx, options)
|
|
}
|
|
|
|
func (ic *ContainerEngine) NetworkInspect(ctx context.Context, namesOrIds []string, opts entities.InspectOptions) ([]entities.NetworkInspectReport, []error, error) {
|
|
var (
|
|
reports = make([]entities.NetworkInspectReport, 0, len(namesOrIds))
|
|
errs = []error{}
|
|
)
|
|
options := new(network.InspectOptions)
|
|
for _, name := range namesOrIds {
|
|
report, err := network.Inspect(ic.ClientCtx, name, options)
|
|
if err != nil {
|
|
errModel, ok := err.(*errorhandling.ErrorModel)
|
|
if !ok {
|
|
return nil, nil, err
|
|
}
|
|
if errModel.ResponseCode == 404 {
|
|
errs = append(errs, fmt.Errorf("network %s: %w", name, define.ErrNoSuchNetwork))
|
|
continue
|
|
}
|
|
return nil, nil, err
|
|
}
|
|
reports = append(reports, report)
|
|
}
|
|
return reports, errs, nil
|
|
}
|
|
|
|
func (ic *ContainerEngine) NetworkReload(ctx context.Context, names []string, opts entities.NetworkReloadOptions) ([]*entities.NetworkReloadReport, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (ic *ContainerEngine) NetworkRm(ctx context.Context, namesOrIds []string, opts entities.NetworkRmOptions) ([]*entities.NetworkRmReport, error) {
|
|
reports := make([]*entities.NetworkRmReport, 0, len(namesOrIds))
|
|
options := new(network.RemoveOptions).WithForce(opts.Force)
|
|
if opts.Timeout != nil {
|
|
options = options.WithTimeout(*opts.Timeout)
|
|
}
|
|
for _, name := range namesOrIds {
|
|
response, err := network.Remove(ic.ClientCtx, name, options)
|
|
if err != nil {
|
|
report := &entities.NetworkRmReport{
|
|
Name: name,
|
|
Err: err,
|
|
}
|
|
reports = append(reports, report)
|
|
} else {
|
|
reports = append(reports, response...)
|
|
}
|
|
}
|
|
return reports, nil
|
|
}
|
|
|
|
func (ic *ContainerEngine) NetworkCreate(ctx context.Context, net types.Network, createOptions *types.NetworkCreateOptions) (*types.Network, error) {
|
|
options := new(network.ExtraCreateOptions)
|
|
if createOptions != nil {
|
|
options = options.WithIgnoreIfExists(createOptions.IgnoreIfExists)
|
|
}
|
|
net, err := network.CreateWithOptions(ic.ClientCtx, &net, options)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &net, nil
|
|
}
|
|
|
|
// NetworkDisconnect removes a container from a given network
|
|
func (ic *ContainerEngine) NetworkDisconnect(ctx context.Context, networkname string, opts entities.NetworkDisconnectOptions) error {
|
|
options := new(network.DisconnectOptions).WithForce(opts.Force)
|
|
return network.Disconnect(ic.ClientCtx, networkname, opts.Container, options)
|
|
}
|
|
|
|
// NetworkConnect removes a container from a given network
|
|
func (ic *ContainerEngine) NetworkConnect(ctx context.Context, networkname string, opts entities.NetworkConnectOptions) error {
|
|
return network.Connect(ic.ClientCtx, networkname, opts.Container, &opts.PerNetworkOptions)
|
|
}
|
|
|
|
// NetworkExists checks if the given network exists
|
|
func (ic *ContainerEngine) NetworkExists(ctx context.Context, networkname string) (*entities.BoolReport, error) {
|
|
exists, err := network.Exists(ic.ClientCtx, networkname, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &entities.BoolReport{
|
|
Value: exists,
|
|
}, nil
|
|
}
|
|
|
|
// Network prune removes unused networks
|
|
func (ic *ContainerEngine) NetworkPrune(ctx context.Context, options entities.NetworkPruneOptions) ([]*entities.NetworkPruneReport, error) {
|
|
opts := new(network.PruneOptions).WithFilters(options.Filters)
|
|
return network.Prune(ic.ClientCtx, opts)
|
|
}
|