Golang MasterInfo.GetIp方法代码示例

func MasterConnStr(masterInfo *mesos.MasterInfo) string {
	ip := make([]byte, 4)
	native.PutUint32(ip, masterInfo.GetIp())
	addr := net.IP(ip).To4().String()
	port := masterInfo.GetPort()
	return fmt.Sprintf("%s:%d", addr, port)
}

func masterHostPort(info *mesos.MasterInfo) string {
	host := info.GetHostname()

	if host == "" {
		// unpack IPv4
		octets := make([]byte, 4)
		binary.BigEndian.PutUint32(octets, info.GetIp())
		ipv4 := net.IP(octets)
		host = ipv4.String()
	}

	return net.JoinHostPort(host, masterPort(info))
}

// masterAddr returns an address (ip:port) from the given *mesos.MasterInfo or
// an empty string if it nil.
//
// BUG(tsenart): The byte order of the `ip` field in MasterInfo is platform
// dependent. We assume that Mesos is compiled with the same architecture as
// Mesos-DNS and hence same byte order. If this isn't the case, the address
// returned will be wrong. This only affects Mesos versions < 0.24.0
func masterAddr(info *mesos.MasterInfo) string {
	if info == nil {
		return ""
	}
	ip, port := "", int64(0)
	if addr := info.GetAddress(); addr != nil { // Mesos >= 0.24.0
		ip, port = addr.GetIp(), int64(addr.GetPort())
	} else { // Mesos < 0.24.0
		ipv4 := make([]byte, net.IPv4len)
		byteOrder.PutUint32(ipv4, info.GetIp())
		ip, port = net.IP(ipv4).String(), int64(info.GetPort())
	}
	return net.JoinHostPort(ip, strconv.FormatInt(port, 10))
}

func (d *ZkLeaderDetector) onLeaderChange(info *mesos.MasterInfo) {
	if info == nil {
		log.Errorln("No leader available in Zookeeper")
	} else {
		leader := ""
		if host := info.GetHostname(); host != "" {
			leader = host
		} else {
			// unpack IPv4
			octets := make([]byte, 4, 4)
			binary.BigEndian.PutUint32(octets, info.GetIp())
			ipv4 := net.IP(octets)
			leader = ipv4.String()
		}
		leader = fmt.Sprintf("%s:%d", leader, info.GetPort())
		log.Infoln("New master in Zookeeper", leader)
		d.newLeader <- &leader
	}
}

func extractMasterAddress(info *mesos.MasterInfo) (host string, port int) {
	if info != nil {
		host = info.GetAddress().GetHostname()
		if host == "" {
			host = info.GetAddress().GetIp()
		}

		if host != "" {
			// use port from Address
			port = int(info.GetAddress().GetPort())
		} else {
			// deprecated: get host and port directly from MasterInfo (and not Address)
			host = info.GetHostname()
			if host == "" {
				host = unpackIPv4(info.GetIp())
			}
			port = int(info.GetPort())
		}
	}
	return
}

func (m *Mesos) hostFromMasterInfo(mi *mesosproto.MasterInfo) MesosHost {
	var ipstring = ""
	var port = ""

	if mi != nil {
		if host := mi.GetHostname(); host != "" {
			ip, err := net.LookupIP(host)
			if err != nil {
				ipstring = host
			} else {
				for _, i := range ip {
					four := i.To4()
					if four != nil {
						ipstring = i.String()
						break
					}
				}
				// If control reaches here there are no IPv4 addresses
				// returned by net.LookupIP. Use the hostname as ipstring
				//
				ipstring = host
			}
		} else {
			octets := make([]byte, 4, 4)
			binary.BigEndian.PutUint32(octets, mi.GetIp())
			ipv4 := net.IP(octets)
			ipstring = ipv4.String()
		}
	}

	if len(ipstring) > 0 {
		port = fmt.Sprint(mi.GetPort())
	}

	return MesosHost{
		host:     ipstring,
		port:     port,
		isLeader: false,
	}
}

func ProtoBufToMesosHost(mi *proto.MasterInfo) *MesosHost {
	ipstring := ""
	port := ""

	log.WithField("mi.GetHostname()", mi.GetHostname()).Debug("protobuf MasterInfo")
	log.WithField("mi.GetIp()", packedIpToString(mi.GetIp())).Debug("protobuf MasterInfo")
	log.WithField("mi.GetPort()", fmt.Sprint(mi.GetPort())).Debug("protobuf MasterInfo")

	if host := mi.GetHostname(); host != "" {
		if ip, err := net.LookupIP(host); err == nil {
			for _, i := range ip {
				if four := i.To4(); four != nil {
					ipstring = i.String()
					break
				}
			}
		}
	}

	if ipstring == "" {
		ipstring = packedIpToString(mi.GetIp())
	}

	if ipstring == "" {
		ipstring = mi.GetHostname()
	}

	if len(ipstring) > 0 {
		port = fmt.Sprint(mi.GetPort())
	}

	return &MesosHost{
		Host:         mi.GetHostname(),
		Ip:           ipstring,
		Port:         int(mi.GetPort()),
		PortString:   port,
		IsLeader:     false,
		IsRegistered: false,
	}
}

func (sched *testScheduler) Reregistered(dr SchedulerDriver, mi *mesos.MasterInfo) {
	log.Infoln("Sched.Reregistered() called")
	sched.s.Equal(mi.GetIp(), uint32(123456))
	sched.ch <- true
}

func (sched *testScheduler) Registered(dr SchedulerDriver, fw *mesos.FrameworkID, mi *mesos.MasterInfo) {
	log.Infoln("Sched.Registered() called.")
	sched.s.Equal(fw.GetValue(), sched.s.registeredFrameworkId.GetValue(), "driver did not register the expected framework ID")
	sched.s.Equal(mi.GetIp(), uint32(123456))
	sched.ch <- true
}

func (self *MesosManager) Reregistered(driver sched.SchedulerDriver, mi *mesos.MasterInfo) {
	log.Printf("OnReregisterd master:%v:%v", Inet_itoa(mi.GetIp()), mi.GetPort())
}

func (self *MesosManager) Registered(driver sched.SchedulerDriver, fid *mesos.FrameworkID, mi *mesos.MasterInfo) {
	log.Printf("OnRegisterd master:%v:%v, frameworkId:%v", Inet_itoa(mi.GetIp()), mi.GetPort(), fid.GetValue())

}

func masterString(info *mesos.MasterInfo) string {
	return fmt.Sprintf("Id %v Ip %v Hostname %v Port %v Version %v Pid %v",
		info.GetId(), info.GetIp(), info.GetHostname(), info.GetPort(), info.GetVersion(), info.GetPid())
}

func validMasterInfo(info *mesos.MasterInfo) bool {
	return info.GetHostname() != "" || info.GetIp() != 0
}