network.go 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340
  1. package client
  2. import (
  3. "fmt"
  4. "net"
  5. "strings"
  6. "text/tabwriter"
  7. "github.com/docker/docker/api/types"
  8. "github.com/docker/docker/api/types/network"
  9. Cli "github.com/docker/docker/cli"
  10. "github.com/docker/docker/opts"
  11. flag "github.com/docker/docker/pkg/mflag"
  12. "github.com/docker/docker/pkg/stringid"
  13. )
  14. // CmdNetwork is the parent subcommand for all network commands
  15. //
  16. // Usage: docker network <COMMAND> [OPTIONS]
  17. func (cli *DockerCli) CmdNetwork(args ...string) error {
  18. cmd := Cli.Subcmd("network", []string{"COMMAND [OPTIONS]"}, networkUsage(), false)
  19. cmd.Require(flag.Min, 1)
  20. err := cmd.ParseFlags(args, true)
  21. cmd.Usage()
  22. return err
  23. }
  24. // CmdNetworkCreate creates a new network with a given name
  25. //
  26. // Usage: docker network create [OPTIONS] <NETWORK-NAME>
  27. func (cli *DockerCli) CmdNetworkCreate(args ...string) error {
  28. cmd := Cli.Subcmd("network create", []string{"NETWORK-NAME"}, "Creates a new network with a name specified by the user", false)
  29. flDriver := cmd.String([]string{"d", "-driver"}, "bridge", "Driver to manage the Network")
  30. flOpts := opts.NewMapOpts(nil, nil)
  31. flIpamDriver := cmd.String([]string{"-ipam-driver"}, "default", "IP Address Management Driver")
  32. flIpamSubnet := opts.NewListOpts(nil)
  33. flIpamIPRange := opts.NewListOpts(nil)
  34. flIpamGateway := opts.NewListOpts(nil)
  35. flIpamAux := opts.NewMapOpts(nil, nil)
  36. cmd.Var(&flIpamSubnet, []string{"-subnet"}, "subnet in CIDR format that represents a network segment")
  37. cmd.Var(&flIpamIPRange, []string{"-ip-range"}, "allocate container ip from a sub-range")
  38. cmd.Var(&flIpamGateway, []string{"-gateway"}, "ipv4 or ipv6 Gateway for the master subnet")
  39. cmd.Var(flIpamAux, []string{"-aux-address"}, "auxiliary ipv4 or ipv6 addresses used by Network driver")
  40. cmd.Var(flOpts, []string{"o", "-opt"}, "set driver specific options")
  41. cmd.Require(flag.Exact, 1)
  42. err := cmd.ParseFlags(args, true)
  43. if err != nil {
  44. return err
  45. }
  46. // Set the default driver to "" if the user didn't set the value.
  47. // That way we can know whether it was user input or not.
  48. driver := *flDriver
  49. if !cmd.IsSet("-driver") && !cmd.IsSet("d") {
  50. driver = ""
  51. }
  52. ipamCfg, err := consolidateIpam(flIpamSubnet.GetAll(), flIpamIPRange.GetAll(), flIpamGateway.GetAll(), flIpamAux.GetAll())
  53. if err != nil {
  54. return err
  55. }
  56. // Construct network create request body
  57. nc := types.NetworkCreate{
  58. Name: cmd.Arg(0),
  59. Driver: driver,
  60. IPAM: network.IPAM{Driver: *flIpamDriver, Config: ipamCfg},
  61. Options: flOpts.GetAll(),
  62. CheckDuplicate: true,
  63. }
  64. resp, err := cli.client.NetworkCreate(nc)
  65. if err != nil {
  66. return err
  67. }
  68. fmt.Fprintf(cli.out, "%s\n", resp.ID)
  69. return nil
  70. }
  71. // CmdNetworkRm deletes one or more networks
  72. //
  73. // Usage: docker network rm NETWORK-NAME|NETWORK-ID [NETWORK-NAME|NETWORK-ID...]
  74. func (cli *DockerCli) CmdNetworkRm(args ...string) error {
  75. cmd := Cli.Subcmd("network rm", []string{"NETWORK [NETWORK...]"}, "Deletes one or more networks", false)
  76. cmd.Require(flag.Min, 1)
  77. if err := cmd.ParseFlags(args, true); err != nil {
  78. return err
  79. }
  80. status := 0
  81. for _, net := range cmd.Args() {
  82. if err := cli.client.NetworkRemove(net); err != nil {
  83. fmt.Fprintf(cli.err, "%s\n", err)
  84. status = 1
  85. continue
  86. }
  87. }
  88. if status != 0 {
  89. return Cli.StatusError{StatusCode: status}
  90. }
  91. return nil
  92. }
  93. // CmdNetworkConnect connects a container to a network
  94. //
  95. // Usage: docker network connect <NETWORK> <CONTAINER>
  96. func (cli *DockerCli) CmdNetworkConnect(args ...string) error {
  97. cmd := Cli.Subcmd("network connect", []string{"NETWORK CONTAINER"}, "Connects a container to a network", false)
  98. cmd.Require(flag.Exact, 2)
  99. if err := cmd.ParseFlags(args, true); err != nil {
  100. return err
  101. }
  102. return cli.client.NetworkConnect(cmd.Arg(0), cmd.Arg(1))
  103. }
  104. // CmdNetworkDisconnect disconnects a container from a network
  105. //
  106. // Usage: docker network disconnect <NETWORK> <CONTAINER>
  107. func (cli *DockerCli) CmdNetworkDisconnect(args ...string) error {
  108. cmd := Cli.Subcmd("network disconnect", []string{"NETWORK CONTAINER"}, "Disconnects container from a network", false)
  109. cmd.Require(flag.Exact, 2)
  110. if err := cmd.ParseFlags(args, true); err != nil {
  111. return err
  112. }
  113. return cli.client.NetworkDisconnect(cmd.Arg(0), cmd.Arg(1))
  114. }
  115. // CmdNetworkLs lists all the netorks managed by docker daemon
  116. //
  117. // Usage: docker network ls [OPTIONS]
  118. func (cli *DockerCli) CmdNetworkLs(args ...string) error {
  119. cmd := Cli.Subcmd("network ls", nil, "Lists networks", true)
  120. quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only display numeric IDs")
  121. noTrunc := cmd.Bool([]string{"-no-trunc"}, false, "Do not truncate the output")
  122. cmd.Require(flag.Exact, 0)
  123. if err := cmd.ParseFlags(args, true); err != nil {
  124. return err
  125. }
  126. networkResources, err := cli.client.NetworkList()
  127. if err != nil {
  128. return err
  129. }
  130. wr := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
  131. // unless quiet (-q) is specified, print field titles
  132. if !*quiet {
  133. fmt.Fprintln(wr, "NETWORK ID\tNAME\tDRIVER")
  134. }
  135. for _, networkResource := range networkResources {
  136. ID := networkResource.ID
  137. netName := networkResource.Name
  138. if !*noTrunc {
  139. ID = stringid.TruncateID(ID)
  140. }
  141. if *quiet {
  142. fmt.Fprintln(wr, ID)
  143. continue
  144. }
  145. driver := networkResource.Driver
  146. fmt.Fprintf(wr, "%s\t%s\t%s\t",
  147. ID,
  148. netName,
  149. driver)
  150. fmt.Fprint(wr, "\n")
  151. }
  152. wr.Flush()
  153. return nil
  154. }
  155. // CmdNetworkInspect inspects the network object for more details
  156. //
  157. // Usage: docker network inspect [OPTIONS] <NETWORK> [NETWORK...]
  158. func (cli *DockerCli) CmdNetworkInspect(args ...string) error {
  159. cmd := Cli.Subcmd("network inspect", []string{"NETWORK [NETWORK...]"}, "Displays detailed information on one or more networks", false)
  160. tmplStr := cmd.String([]string{"f", "-format"}, "", "Format the output using the given go template")
  161. cmd.Require(flag.Min, 1)
  162. if err := cmd.ParseFlags(args, true); err != nil {
  163. return err
  164. }
  165. inspectSearcher := func(name string) (interface{}, []byte, error) {
  166. i, err := cli.client.NetworkInspect(name)
  167. return i, nil, err
  168. }
  169. return cli.inspectElements(*tmplStr, cmd.Args(), inspectSearcher)
  170. }
  171. // Consolidates the ipam configuration as a group from different related configurations
  172. // user can configure network with multiple non-overlapping subnets and hence it is
  173. // possible to corelate the various related parameters and consolidate them.
  174. // consoidateIpam consolidates subnets, ip-ranges, gateways and auxilary addresses into
  175. // structured ipam data.
  176. func consolidateIpam(subnets, ranges, gateways []string, auxaddrs map[string]string) ([]network.IPAMConfig, error) {
  177. if len(subnets) < len(ranges) || len(subnets) < len(gateways) {
  178. return nil, fmt.Errorf("every ip-range or gateway must have a corresponding subnet")
  179. }
  180. iData := map[string]*network.IPAMConfig{}
  181. // Populate non-overlapping subnets into consolidation map
  182. for _, s := range subnets {
  183. for k := range iData {
  184. ok1, err := subnetMatches(s, k)
  185. if err != nil {
  186. return nil, err
  187. }
  188. ok2, err := subnetMatches(k, s)
  189. if err != nil {
  190. return nil, err
  191. }
  192. if ok1 || ok2 {
  193. return nil, fmt.Errorf("multiple overlapping subnet configuration is not supported")
  194. }
  195. }
  196. iData[s] = &network.IPAMConfig{Subnet: s, AuxAddress: map[string]string{}}
  197. }
  198. // Validate and add valid ip ranges
  199. for _, r := range ranges {
  200. match := false
  201. for _, s := range subnets {
  202. ok, err := subnetMatches(s, r)
  203. if err != nil {
  204. return nil, err
  205. }
  206. if !ok {
  207. continue
  208. }
  209. if iData[s].IPRange != "" {
  210. return nil, fmt.Errorf("cannot configure multiple ranges (%s, %s) on the same subnet (%s)", r, iData[s].IPRange, s)
  211. }
  212. d := iData[s]
  213. d.IPRange = r
  214. match = true
  215. }
  216. if !match {
  217. return nil, fmt.Errorf("no matching subnet for range %s", r)
  218. }
  219. }
  220. // Validate and add valid gateways
  221. for _, g := range gateways {
  222. match := false
  223. for _, s := range subnets {
  224. ok, err := subnetMatches(s, g)
  225. if err != nil {
  226. return nil, err
  227. }
  228. if !ok {
  229. continue
  230. }
  231. if iData[s].Gateway != "" {
  232. return nil, fmt.Errorf("cannot configure multiple gateways (%s, %s) for the same subnet (%s)", g, iData[s].Gateway, s)
  233. }
  234. d := iData[s]
  235. d.Gateway = g
  236. match = true
  237. }
  238. if !match {
  239. return nil, fmt.Errorf("no matching subnet for gateway %s", g)
  240. }
  241. }
  242. // Validate and add aux-addresses
  243. for key, aa := range auxaddrs {
  244. match := false
  245. for _, s := range subnets {
  246. ok, err := subnetMatches(s, aa)
  247. if err != nil {
  248. return nil, err
  249. }
  250. if !ok {
  251. continue
  252. }
  253. iData[s].AuxAddress[key] = aa
  254. match = true
  255. }
  256. if !match {
  257. return nil, fmt.Errorf("no matching subnet for aux-address %s", aa)
  258. }
  259. }
  260. idl := []network.IPAMConfig{}
  261. for _, v := range iData {
  262. idl = append(idl, *v)
  263. }
  264. return idl, nil
  265. }
  266. func subnetMatches(subnet, data string) (bool, error) {
  267. var (
  268. ip net.IP
  269. )
  270. _, s, err := net.ParseCIDR(subnet)
  271. if err != nil {
  272. return false, fmt.Errorf("Invalid subnet %s : %v", s, err)
  273. }
  274. if strings.Contains(data, "/") {
  275. ip, _, err = net.ParseCIDR(data)
  276. if err != nil {
  277. return false, fmt.Errorf("Invalid cidr %s : %v", data, err)
  278. }
  279. } else {
  280. ip = net.ParseIP(data)
  281. }
  282. return s.Contains(ip), nil
  283. }
  284. func networkUsage() string {
  285. networkCommands := map[string]string{
  286. "create": "Create a network",
  287. "connect": "Connect container to a network",
  288. "disconnect": "Disconnect container from a network",
  289. "inspect": "Display detailed network information",
  290. "ls": "List all networks",
  291. "rm": "Remove a network",
  292. }
  293. help := "Commands:\n"
  294. for cmd, description := range networkCommands {
  295. help += fmt.Sprintf(" %-25.25s%s\n", cmd, description)
  296. }
  297. help += fmt.Sprintf("\nRun 'docker network COMMAND --help' for more information on a command.")
  298. return help
  299. }