Chris Lu
3 years ago
11 changed files with 46 additions and 207 deletions
-
7weed/command/filer.go
-
7weed/command/master.go
-
5weed/command/master_follower.go
-
3weed/command/msg_broker.go
-
10weed/command/volume.go
-
5weed/filer/filechunk_manifest.go
-
8weed/topology/data_node.go
-
4weed/topology/rack.go
-
2weed/topology/store_replicate.go
-
25weed/util/network.go
-
177weed/wdclient/net2/ip.go
@ -1,177 +0,0 @@ |
|||
package net2 |
|||
|
|||
import ( |
|||
"fmt" |
|||
"log" |
|||
"net" |
|||
"os" |
|||
"strings" |
|||
"sync" |
|||
) |
|||
|
|||
var myHostname string |
|||
var myHostnameOnce sync.Once |
|||
|
|||
// Like os.Hostname but caches first successful result, making it cheap to call it
|
|||
// over and over.
|
|||
// It will also crash whole process if fetching Hostname fails!
|
|||
func MyHostname() string { |
|||
myHostnameOnce.Do(func() { |
|||
var err error |
|||
myHostname, err = os.Hostname() |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
}) |
|||
return myHostname |
|||
} |
|||
|
|||
var myIp4 *net.IPAddr |
|||
var myIp4Once sync.Once |
|||
|
|||
// Resolves `MyHostname()` to an Ip4 address. Caches first successful result, making it
|
|||
// cheap to call it over and over.
|
|||
// It will also crash whole process if resolving the IP fails!
|
|||
func MyIp4() *net.IPAddr { |
|||
myIp4Once.Do(func() { |
|||
var err error |
|||
myIp4, err = net.ResolveIPAddr("ip4", MyHostname()) |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
}) |
|||
return myIp4 |
|||
} |
|||
|
|||
var myIp6 *net.IPAddr |
|||
var myIp6Once sync.Once |
|||
|
|||
// Resolves `MyHostname()` to an Ip6 address. Caches first successful result, making it
|
|||
// cheap to call it over and over.
|
|||
// It will also crash whole process if resolving the IP fails!
|
|||
func MyIp6() *net.IPAddr { |
|||
myIp6Once.Do(func() { |
|||
var err error |
|||
myIp6, err = net.ResolveIPAddr("ip6", MyHostname()) |
|||
if err != nil { |
|||
log.Fatal(err) |
|||
} |
|||
}) |
|||
return myIp6 |
|||
} |
|||
|
|||
// This returns the list of local ip addresses which other hosts can connect
|
|||
// to (NOTE: Loopback ip is ignored).
|
|||
// Also resolves Hostname to an address and adds it to the list too, so
|
|||
// IPs from /etc/hosts can work too.
|
|||
func GetLocalIPs() ([]*net.IP, error) { |
|||
hostname, err := os.Hostname() |
|||
if err != nil { |
|||
return nil, fmt.Errorf("Failed to lookup hostname: %v", err) |
|||
} |
|||
// Resolves IP Address from Hostname, this way overrides in /etc/hosts
|
|||
// can work too for IP resolution.
|
|||
ipInfo, err := net.ResolveIPAddr("ip4", hostname) |
|||
if err != nil { |
|||
return nil, fmt.Errorf("Failed to resolve ip: %v", err) |
|||
} |
|||
ips := []*net.IP{&ipInfo.IP} |
|||
|
|||
// TODO(zviad): Is rest of the code really necessary?
|
|||
addrs, err := net.InterfaceAddrs() |
|||
if err != nil { |
|||
return nil, fmt.Errorf("Failed to get interface addresses: %v", err) |
|||
} |
|||
for _, addr := range addrs { |
|||
ipnet, ok := addr.(*net.IPNet) |
|||
if !ok { |
|||
continue |
|||
} |
|||
|
|||
if ipnet.IP.IsLoopback() { |
|||
continue |
|||
} |
|||
|
|||
ips = append(ips, &ipnet.IP) |
|||
} |
|||
return ips, nil |
|||
} |
|||
|
|||
var localhostIPNets []*net.IPNet |
|||
|
|||
func init() { |
|||
for _, mask := range []string{"127.0.0.1/8", "::1/128"} { |
|||
_, ipnet, err := net.ParseCIDR(mask) |
|||
if err != nil { |
|||
panic(err) |
|||
} |
|||
localhostIPNets = append(localhostIPNets, ipnet) |
|||
} |
|||
} |
|||
|
|||
func IsLocalhostIp(ipStr string) bool { |
|||
ip := net.ParseIP(ipStr) |
|||
if ip == nil { |
|||
return false |
|||
} |
|||
for _, ipnet := range localhostIPNets { |
|||
if ipnet.Contains(ip) { |
|||
return true |
|||
} |
|||
} |
|||
return false |
|||
} |
|||
|
|||
// Given a host string, return true if the host is an ip (v4/v6) localhost.
|
|||
func IsLocalhost(host string) bool { |
|||
return IsLocalhostIp(host) || |
|||
host == "localhost" || |
|||
host == "ip6-localhost" || |
|||
host == "ipv6-localhost" |
|||
} |
|||
|
|||
// Resolves hostnames in addresses to actual IP4 addresses. Skips all invalid addresses
|
|||
// and all addresses that can't be resolved.
|
|||
// `addrs` are assumed to be of form: ["<hostname>:<port>", ...]
|
|||
// Returns an error in addition to resolved addresses if not all resolutions succeed.
|
|||
func ResolveIP4s(addrs []string) ([]string, error) { |
|||
resolvedAddrs := make([]string, 0, len(addrs)) |
|||
var lastErr error |
|||
|
|||
for _, server := range addrs { |
|||
hostPort := strings.Split(server, ":") |
|||
if len(hostPort) != 2 { |
|||
lastErr = fmt.Errorf("Skipping invalid address: %s", server) |
|||
continue |
|||
} |
|||
|
|||
ip, err := net.ResolveIPAddr("ip4", hostPort[0]) |
|||
if err != nil { |
|||
lastErr = err |
|||
continue |
|||
} |
|||
resolvedAddrs = append(resolvedAddrs, ip.IP.String()+":"+hostPort[1]) |
|||
} |
|||
return resolvedAddrs, lastErr |
|||
} |
|||
|
|||
func LookupValidAddrs() (map[string]bool, error) { |
|||
hostName, err := os.Hostname() |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
addrs, err := net.LookupHost(hostName) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
validAddrs := make(map[string]bool) |
|||
validAddrs[hostName] = true |
|||
for _, addr := range addrs { |
|||
validAddrs[addr] = true |
|||
} |
|||
// Special case localhost/127.0.0.1 so that this works on devVMs. It should
|
|||
// have no affect in production.
|
|||
validAddrs["127.0.0.1"] = true |
|||
validAddrs["localhost"] = true |
|||
return validAddrs, nil |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue