5 files changed, 326 insertions, 6 deletions
diff --git a/cmd/podman/networks/create.go b/cmd/podman/networks/create.go
new file mode 100644
index 000000000..2bb75ea9e
--- /dev/null
+++ b/cmd/podman/networks/create.go
@@ -0,0 +1,81 @@
+package network
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/containers/libpod/cmd/podman/registry"
+	"github.com/containers/libpod/libpod"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/containers/libpod/pkg/network"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+var (
+	networkCreateDescription = `create CNI networks for containers and pods`
+	networkCreateCommand     = &cobra.Command{
+		Use:     "create [flags] [NETWORK]",
+		Short:   "network create",
+		Long:    networkCreateDescription,
+		RunE:    networkCreate,
+		Example: `podman network create podman1`,
+		Annotations: map[string]string{
+			registry.ParentNSRequired: "",
+		},
+	}
+)
+
+var (
+	networkCreateOptions entities.NetworkCreateOptions
+)
+
+func networkCreateFlags(flags *pflag.FlagSet) {
+	flags.StringVarP(&networkCreateOptions.Driver, "driver", "d", "bridge", "driver to manage the network")
+	flags.IPVar(&networkCreateOptions.Gateway, "gateway", nil, "IPv4 or IPv6 gateway for the subnet")
+	flags.BoolVar(&networkCreateOptions.Internal, "internal", false, "restrict external access from this network")
+	flags.IPNetVar(&networkCreateOptions.Range, "ip-range", net.IPNet{}, "allocate container IP from range")
+	flags.StringVar(&networkCreateOptions.MacVLAN, "macvlan", "", "create a Macvlan connection based on this device")
+	// TODO not supported yet
+	//flags.StringVar(&networkCreateOptions.IPamDriver, "ipam-driver", "",  "IP Address Management Driver")
+	// TODO enable when IPv6 is working
+	//flags.BoolVar(&networkCreateOptions.IPV6, "IPv6", false, "enable IPv6 networking")
+	flags.IPNetVar(&networkCreateOptions.Subnet, "subnet", net.IPNet{}, "subnet in CIDR format")
+	flags.BoolVar(&networkCreateOptions.DisableDNS, "disable-dns", false, "disable dns plugin")
+}
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: networkCreateCommand,
+		Parent:  networkCmd,
+	})
+	flags := networkCreateCommand.Flags()
+	networkCreateFlags(flags)
+
+}
+
+func networkCreate(cmd *cobra.Command, args []string) error {
+	var (
+		name string
+	)
+	if err := network.IsSupportedDriver(networkCreateOptions.Driver); err != nil {
+		return err
+	}
+	if len(args) > 1 {
+		return errors.Errorf("only one network can be created at a time")
+	}
+	if len(args) > 0 && !libpod.NameRegex.MatchString(args[0]) {
+		return libpod.RegexError
+	}
+
+	if len(args) > 0 {
+		name = args[0]
+	}
+	response, err := registry.ContainerEngine().NetworkCreate(registry.Context(), name, networkCreateOptions)
+	if err != nil {
+		return err
+	}
+	fmt.Println(response.Filename)
+	return nil
+}
diff --git a/cmd/podman/networks/inspect.go b/cmd/podman/networks/inspect.go
new file mode 100644
index 000000000..0bc73579a
--- /dev/null
+++ b/cmd/podman/networks/inspect.go
@@ -0,0 +1,46 @@
+package network
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/containers/libpod/cmd/podman/registry"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/spf13/cobra"
+)
+
+var (
+	networkinspectDescription = `Inspect network`
+	networkinspectCommand     = &cobra.Command{
+		Use:     "inspect NETWORK [NETWORK...] [flags] ",
+		Short:   "network inspect",
+		Long:    networkinspectDescription,
+		RunE:    networkInspect,
+		Example: `podman network inspect podman`,
+		Args:    cobra.MinimumNArgs(1),
+		Annotations: map[string]string{
+			registry.ParentNSRequired: "",
+		},
+	}
+)
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: networkinspectCommand,
+		Parent:  networkCmd,
+	})
+}
+
+func networkInspect(cmd *cobra.Command, args []string) error {
+	responses, err := registry.ContainerEngine().NetworkInspect(registry.Context(), args, entities.NetworkInspectOptions{})
+	if err != nil {
+		return err
+	}
+	b, err := json.MarshalIndent(responses, "", "  ")
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(b))
+	return nil
+}
diff --git a/cmd/podman/networks/list.go b/cmd/podman/networks/list.go
new file mode 100644
index 000000000..e27062255
--- /dev/null
+++ b/cmd/podman/networks/list.go
@@ -0,0 +1,133 @@
+package network
+
+import (
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/containers/libpod/cmd/podman/validate"
+
+	"github.com/containers/libpod/cmd/podman/registry"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/containers/libpod/pkg/network"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+var (
+	networklistDescription = `List networks`
+	networklistCommand     = &cobra.Command{
+		Use:     "ls",
+		Args:    validate.NoArgs,
+		Short:   "network list",
+		Long:    networklistDescription,
+		RunE:    networkList,
+		Example: `podman network list`,
+		Annotations: map[string]string{
+			registry.ParentNSRequired: "",
+		},
+	}
+)
+
+var (
+	networkListOptions entities.NetworkListOptions
+	headers            string = "NAME\tVERSION\tPLUGINS\n"
+	defaultListRow     string = "{{.Name}}\t{{.Version}}\t{{.Plugins}}\n"
+)
+
+func networkListFlags(flags *pflag.FlagSet) {
+	// TODO enable filters based on something
+	//flags.StringSliceVarP(&networklistCommand.Filter, "filter", "f",  []string{}, "Pause all running containers")
+	flags.StringVarP(&networkListOptions.Format, "format", "f", "", "Pretty-print containers to JSON or using a Go template")
+	flags.BoolVarP(&networkListOptions.Quiet, "quiet", "q", false, "display only names")
+}
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: networklistCommand,
+		Parent:  networkCmd,
+	})
+	flags := networklistCommand.Flags()
+	networkListFlags(flags)
+}
+
+func networkList(cmd *cobra.Command, args []string) error {
+	var (
+		w     io.Writer = os.Stdout
+		nlprs []NetworkListPrintReports
+	)
+
+	responses, err := registry.ContainerEngine().NetworkList(registry.Context(), networkListOptions)
+	if err != nil {
+		return err
+	}
+
+	// quiet means we only print the network names
+	if networkListOptions.Quiet {
+		return quietOut(responses)
+	}
+
+	if networkListOptions.Format == "json" {
+		return jsonOut(responses)
+	}
+
+	for _, r := range responses {
+		nlprs = append(nlprs, NetworkListPrintReports{r})
+	}
+
+	row := networkListOptions.Format
+	if len(row) < 1 {
+		row = defaultListRow
+	}
+	if !strings.HasSuffix(row, "\n") {
+		row += "\n"
+	}
+
+	format := "{{range . }}" + row + "{{end}}"
+	if !cmd.Flag("format").Changed {
+		format = headers + format
+	}
+	tmpl, err := template.New("listNetworks").Parse(format)
+	if err != nil {
+		return err
+	}
+	if err := tmpl.Execute(w, nlprs); err != nil {
+		return err
+	}
+	if flusher, ok := w.(interface{ Flush() error }); ok {
+		return flusher.Flush()
+	}
+	return nil
+}
+
+func quietOut(responses []*entities.NetworkListReport) error {
+	for _, r := range responses {
+		fmt.Println(r.Name)
+	}
+	return nil
+}
+
+func jsonOut(responses []*entities.NetworkListReport) error {
+	b, err := json.MarshalIndent(responses, "", "  ")
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(b))
+	return nil
+}
+
+type NetworkListPrintReports struct {
+	*entities.NetworkListReport
+}
+
+func (n NetworkListPrintReports) Version() string {
+	return n.CNIVersion
+}
+
+func (n NetworkListPrintReports) Plugins() string {
+	return network.GetCNIPlugins(n.NetworkConfigList)
+}
diff --git a/cmd/podman/networks/network.go b/cmd/podman/networks/network.go
index e2a928312..56dd390ea 100644
--- a/cmd/podman/networks/network.go
+++ b/cmd/podman/networks/network.go
@@ -1,4 +1,4 @@
-package images
+package network
 
 import (
 	"github.com/containers/libpod/cmd/podman/registry"
@@ -9,7 +9,7 @@ import (
 
 var (
 	// Command: podman _network_
-	cmd = &cobra.Command{
+	networkCmd = &cobra.Command{
 		Use:              "network",
 		Short:            "Manage networks",
 		Long:             "Manage networks",
@@ -18,12 +18,9 @@ var (
 	}
 )
 
-// TODO add the following to main.go to get networks back onto the
-// command list.
-// _ "github.com/containers/libpod/cmd/podman/networks"
 func init() {
 	registry.Commands = append(registry.Commands, registry.CliCommand{
 		Mode:    []entities.EngineMode{entities.ABIMode},
-		Command: cmd,
+		Command: networkCmd,
 	})
 }
diff --git a/cmd/podman/networks/rm.go b/cmd/podman/networks/rm.go
new file mode 100644
index 000000000..dc1eb9909
--- /dev/null
+++ b/cmd/podman/networks/rm.go
@@ -0,0 +1,63 @@
+package network
+
+import (
+	"fmt"
+
+	"github.com/containers/libpod/cmd/podman/registry"
+	"github.com/containers/libpod/cmd/podman/utils"
+	"github.com/containers/libpod/pkg/domain/entities"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+var (
+	networkrmDescription = `Remove networks`
+	networkrmCommand     = &cobra.Command{
+		Use:     "rm [flags] NETWORK [NETWORK...]",
+		Short:   "network rm",
+		Long:    networkrmDescription,
+		RunE:    networkRm,
+		Example: `podman network rm podman`,
+		Args:    cobra.MinimumNArgs(1),
+		Annotations: map[string]string{
+			registry.ParentNSRequired: "",
+		},
+	}
+)
+
+var (
+	networkRmOptions entities.NetworkRmOptions
+)
+
+func networkRmFlags(flags *pflag.FlagSet) {
+	flags.BoolVarP(&networkRmOptions.Force, "force", "f", false, "remove any containers using network")
+}
+
+func init() {
+	registry.Commands = append(registry.Commands, registry.CliCommand{
+		Mode:    []entities.EngineMode{entities.ABIMode},
+		Command: networkrmCommand,
+		Parent:  networkCmd,
+	})
+	flags := networkrmCommand.Flags()
+	networkRmFlags(flags)
+}
+
+func networkRm(cmd *cobra.Command, args []string) error {
+	var (
+		errs utils.OutputErrors
+	)
+
+	responses, err := registry.ContainerEngine().NetworkRm(registry.Context(), args, networkRmOptions)
+	if err != nil {
+		return err
+	}
+	for _, r := range responses {
+		if r.Err == nil {
+			fmt.Println(r.Name)
+		} else {
+			errs = append(errs, r.Err)
+		}
+	}
+	return errs.PrintErrors()
+}