def determine_local_ipaddr(): local_address = None # Most portable (for modern versions of Python) if hasattr(socket, 'gethostbyname_ex'): for ip in socket.gethostbyname_ex(socket.gethostname())[2]: if not ip.startswith('127.'): local_address = ip break # may be none still (nokia) http://www.skweezer.com/s.aspx/-/pypi~python~org/pypi/netifaces/0~4 http://www.skweezer.com/s.aspx?q=http://stackoverflow.com/questions/166506/finding-local-ip-addresses-using-pythons-stdlib has alonger one if sys.platform.startswith('linux'): import fcntl def get_ip_address(ifname): ifname = ifname.encode('latin1') s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) return socket.inet_ntoa(fcntl.ioctl( s.fileno(), 0x8915, # SIOCGIFADDR struct.pack('256s', ifname[:15]) )[20:24]) if not local_address: for devname in os.listdir('/sys/class/net/'): try: ip = get_ip_address(devname) if not ip.startswith('127.'): local_address = ip break except IOError: pass # Jython / Java approach if not local_address and InetAddress: addr = InetAddress.getLocalHost() hostname = addr.getHostName() for ip_addr in InetAddress.getAllByName(hostname): if not ip_addr.isLoopbackAddress(): local_address = ip_addr.getHostAddress() break if not local_address: # really? Oh well lets connect to a remote socket (Google DNS server) # and see what IP we use them s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('8.8.8.8', 53)) ip = s.getsockname()[0] s.close() if not ip.startswith('127.'): local_address = ip return local_address
def getHostName(ipAddress, defaultValue=None): """ @deprecated: Use SocketDnsResolver().resolve_hostnames(ip_address) Resolves the IP address to the host name in the DNS table. On failure to resolve the address the , default value parameter is returned. @param ipAddress: IP address to resolve @type ipAddress: string @param defaultValue: the value to return if the address cannot be resolved @return: host name of the resolved IP address @rtype: string """ if isValidIp(ipAddress): try: dnsName = str(InetAddress.getByName(ipAddress).getHostName()) if dnsName == ipAddress: return defaultValue else: return dnsName except: defultHostName = defaultValue if defultHostName == None: defultHostName = 'null' logger.debug('Could not resolve DNS name for : ', ipAddress, ',returning default value:', defultHostName, ';reason:', str(sys.exc_info()[1])) return defaultValue
def doInstall(info): " do install of activation info" logger.info("OracleDatabaseContainer: doInstall:Enter") hostname = "localhost"; try: hostname = InetAddress.getLocalHost().getCanonicalHostName() except: type, value, traceback = sys.exc_info() logger.severe("Hostname error:" + `value`) dbInstallOption = getVariableValue("DB_INSTALL_OPTION") if dbInstallOption == "INSTALL_DB_AND_CONFIG": globalLockString = "OracleEnabler-" + hostname ContainerUtils.releaseGlobalLock(globalLockString) logger.info("Released global lock with name: " + globalLockString) try: oracleDatabase = getVariableValue("ORACLE_DATABASE_OBJECT") if oracleDatabase: oracleDatabase.installActivationInfo(info) except: type, value, traceback = sys.exc_info() logger.severe("Unexpected error in OracleDatabaseContainer:doInstall:" + `value`) logger.info("OracleDatabaseContainer: doInstall:Exit")
def doInstall(info): " do install of activation info" logger.info("OracleDatabaseContainer: doInstall:Enter") hostname = "localhost" try: hostname = InetAddress.getLocalHost().getCanonicalHostName() except: type, value, traceback = sys.exc_info() logger.severe("Hostname error:" + ` value `) dbInstallOption = getVariableValue("DB_INSTALL_OPTION") if dbInstallOption == "INSTALL_DB_AND_CONFIG": globalLockString = "OracleEnabler-" + hostname ContainerUtils.releaseGlobalLock(globalLockString) logger.info("Released global lock with name: " + globalLockString) try: oracleDatabase = getVariableValue("ORACLE_DATABASE_OBJECT") if oracleDatabase: oracleDatabase.installActivationInfo(info) except: type, value, traceback = sys.exc_info() logger.severe( "Unexpected error in OracleDatabaseContainer:doInstall:" + ` value `) logger.info("OracleDatabaseContainer: doInstall:Exit")
def federationode(nodeName, noOfProcessors=1): from java.net import InetAddress from org.meta.net import FederationNode fNode = FederationNode(InetAddress.getByName(nodeName)) fNode.setNoOfProcessors(noOfProcessors) return fNode
def getMachineName(): if isPython: from platform import uname return uname()[1] elif isJython: from java.net import InetAddress addr = InetAddress.getLocalHost() return str(addr.getHostName()) return False
def issueRequest(cls, targetHost, targetPort, forPlayerName, requestContent, timeoutClock): """ generated source for method issueRequest """ socket = Socket() theHost = InetAddress.getByName(targetHost) socket.connect(InetSocketAddress(theHost.getHostAddress(), targetPort), 5000) HttpWriter.writeAsClient(socket, theHost.getHostName(), requestContent, forPlayerName) response = HttpReader.readAsClient(socket) if (timeoutClock < 0) else HttpReader.readAsClient(socket, timeoutClock) socket.close() return response
def __getHostName(self): "get hostname" self.__hostname = getVariableValue("ENGINE_USERNAME"); try: hostname = InetAddress.getLocalHost().getCanonicalHostName() if hostname != "localhost" and not re.search("[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+", hostname): self.__hostname = hostname except: type, value, traceback = sys.exc_info() logger.severe("get hostname error:" + `value`)
def _parseMixedIPFromIndex(rawIndexValue): rawIndexValue = rawIndexValue.split('.') #split it to array rawIndexValue = ".".join(rawIndexValue[2:]) #the first two elements are irrelevant, ignore them rawIndexValue = OctetString.fromString(rawIndexValue, '.', 10).getValue() ipAddr = None try: ipAddr = InetAddress.getByAddress(rawIndexValue).getHostAddress() except: pass return ipAddr
def check_address(self, addrblobs): for addrblob in addrblobs: addr_arr = addrblob.split("|") rrow = int(addr_arr[0]) addr = addr_arr[1] try: result = InetAddress.getByName(addr) yield [rrow, "Success", result] except UnknownHostException: yield [rrow, "Fail", None]
def __init__(self, host=config.monomeHost, port=config.monomePort, prefix=config.monomePrefix, width=config.monomeWidth, height=config.monomeHeight): self.transmitter = UDPTransmitter(InetAddress.getByName(host), port) self.prefix = prefix self.width = width self.height = height
def __getHostName(self): "get hostname" self.__hostname = getVariableValue("ENGINE_USERNAME") try: hostname = InetAddress.getLocalHost().getCanonicalHostName() if hostname != "localhost" and not re.search( "[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+", hostname): self.__hostname = hostname except: type, value, traceback = sys.exc_info() logger.severe("get hostname error:" + ` value `)
def resolveHostIpWithLocalDns(self, hostName): """ Resolves (or not) IP address by given machine name @param hostName: the machine name to resolve IPs @type hostName: string @rtype: string """ try: return InetAddress.getByName(hostName).getHostAddress() except UnknownHostException: pass
def parseIPv6FromIPv6NetToMediaTableIndex(rawIndexValue): realValue = None try: rawIndexValue = rawIndexValue.split('.') #split it to array rawIndexValue = ".".join(rawIndexValue[2:]) #the first two elements are irrelevant, ignore them rawIndexValue = OctetString.fromString(rawIndexValue, '.', 10).getValue() ipv6Address = InetAddress.getByAddress(rawIndexValue) realValue = ipv6Address.getHostAddress() except: pass return realValue
def parseIPFromIpNetToPhysicalTableIndex(rawIndexValue): realValue = None try: rawIndexValue = rawIndexValue.split('.') #split it to array rawIndexValue = ".".join(rawIndexValue[3:]) #the first three elements are irrelevant, ignore them rawIndexValue = OctetString.fromString(rawIndexValue, '.', 10).getValue() inetAddress = InetAddress.getByAddress(rawIndexValue) realValue = inetAddress.getHostAddress() except: pass return realValue
def __init__(self, node, server, host): self.node = node self.server = server self.host = host ia = InetAddress.getByName(host) if (ia != None): self.host = ia.getCanonicalHostName() self.ipAddr = ia.getHostAddress() self.trustedProxy = self.ipAddr else: self.ipAddr = None self.trustedProxy = host
def resolveHostnamesByIp(self, ip): '''@types: str -> list[str] @raise ResolveException: Failed to resolve hostnames ''' if not ip: raise ValueError("Ip is not specified") dnsName = None try: dnsName = str(InetAddress.getByName(ip).getHostName()) except JException, je: logger.debug(str(je)) raise self._HOSTNAME_RESOLVE_EXCEPTION
def __init__(self, TCP_IP = None, TCP_PORT = 5006): #Automatically assign the IP if the field is left empty if x.getProperty("insideDev") == "false": # MAKE SURE THAT THE INET INTERFACE IS THE MAIN ONE TCP_IP = InetAddress.getLocalHost().getHostAddress() print("Running outside of Dev - IP = "+TCP_IP) else: TCP_IP = 'localhost' print("Running in Dev") self.TCP_IP = TCP_IP self.TCP_PORT = TCP_PORT self.BUFFER_SIZE = 1024 # Normally 1024, but we want fast response
def _discover(self, domainDto=None): ''' if domainDto is None, domain controllers of self domain will be discovered, else controllers for specified domain will be discovered ''' result = AdDiscoveryResult() dtoToOshMap = result.getMap() siteDtoToOshMap = result.getSiteDtoToOshMap() containerOshMap = result.getContainerOshMap() client = self._daoService.getClient() serverDao = self._daoService.getServerDao() domainDao = self._daoService.getDomainDao() siteDao = self._daoService.getSiteDao() if domainDto is None: domainDto = domainDao.createDto(domainDao.obtainSelfDomainId()) serverDtos = serverDao.obtainServers(domainDto) selfControllerId = serverDao.obtainSelfServerId() for dto in serverDtos: hostOsh = None functionality = None #if this is controller that we are triggered on if selfControllerId == dto.id: dto.fullVersion = serverDao.obtainSelfFullVersion() dto.ipAddress = client.getIpAddress() if self.__isConnectionPortReported: dto.port = client.getPort() dto.username = client.getUserName() dto.credentialId = client.getCredentialId() functionality = serverDao.obtainSelfFunctionality() if self._containerOsh: hostOsh = self._containerOsh else: #determine container host try: dto.ipAddress = InetAddress.getByName( dto.dnsName).getHostAddress() hostOsh = HostBuilder.incompleteByIp(dto.ipAddress).build() except JException: logger.debug('Cannot resolve IP address for fqdn %s' % dto.dnsName) if hostOsh: siteDto = siteDao.createDto(dto.siteName) osh = self.createOsh(dto, hostOsh, functionality) dtoToOshMap[dto] = osh siteDtoToOshMap[siteDto] = osh containerOshMap[dto] = hostOsh return result
def resolveIpsByHostname(self, hostname): '''@types: str -> list[str] @raise ResolveException: Failed to resolve IPs @note: When resolved IP is local (loopback) it will be replaced with destination IP address if such was specified while initializing this DNS resolver ''' if not hostname: raise ValueError("hostname is not specified") ip = None try: ip = str(InetAddress.getByName(hostname).getHostAddress()) except JException, ex: logger.debug(str(ex)) raise self._IP_RESOLVE_EXCEPTION
def init(context): if not File("storage/python_console.props").exists(): context.log("storage/python_console.props does not exist") return context.log("storage/python_console.props exists; proceeding with load") props = Properties() props.load(FileInputStream(File("storage/python_console.props"))) server = ServerSocket(int(props["port"]), 20, InetAddress.getByName(props["host"]) if "host" in props else None) class ServerThread(Thread): def run(self): while not server.isClosed(): socket = server.accept() HandlerThread(socket).start() ServerThread().start()
def _discover(self, domainDto=None): ''' if domainDto is None, domain controllers of self domain will be discovered, else controllers for specified domain will be discovered ''' result = AdDiscoveryResult() dtoToOshMap = result.getMap() siteDtoToOshMap = result.getSiteDtoToOshMap() containerOshMap = result.getContainerOshMap() client = self._daoService.getClient() serverDao = self._daoService.getServerDao() domainDao = self._daoService.getDomainDao() siteDao = self._daoService.getSiteDao() if domainDto is None: domainDto = domainDao.createDto(domainDao.obtainSelfDomainId()) serverDtos = serverDao.obtainServers(domainDto) selfControllerId = serverDao.obtainSelfServerId() for dto in serverDtos: hostOsh = None functionality = None #if this is controller that we are triggered on if selfControllerId == dto.id: dto.fullVersion = serverDao.obtainSelfFullVersion() dto.ipAddress = client.getIpAddress() if self.__isConnectionPortReported: dto.port = client.getPort() dto.username = client.getUserName() dto.credentialId = client.getCredentialId() functionality = serverDao.obtainSelfFunctionality() if self._containerOsh: hostOsh = self._containerOsh else: #determine container host try: dto.ipAddress = InetAddress.getByName(dto.dnsName).getHostAddress() hostOsh = HostBuilder.incompleteByIp(dto.ipAddress).build() except JException: logger.debug('Cannot resolve IP address for fqdn %s' % dto.dnsName) if hostOsh: siteDto = siteDao.createDto(dto.siteName) osh = self.createOsh(dto, hostOsh, functionality) dtoToOshMap[dto] = osh siteDtoToOshMap[siteDto] = osh containerOshMap[dto] = hostOsh return result
def isOnDifferentHost(): node = AdminControl.getNode() nodeId = AdminConfig.getid("/Node:" + node + "/") targetHostname = AdminConfig.showAttribute(nodeId, 'hostName') try: localHostname = InetAddress.getLocalHost().getCanonicalHostName() except: localHostname = "cannot_be_determined" if (localHostname.lower()) != (targetHostname.lower()): print "localHostname is: " + localHostname print "targetHostname is: " + targetHostname if localHostname == "cannot_be_determined": print "isOnDifferentHost returns false because hostname cannot be determined" return False else: return True
def getHostAddress(dnsName, defaultValue=None): """ @deprecated: Use SocketDnsResolver().resolve_ips(dnsName) Resolves the host name to the IP Address in DNS table. On failure to resolve the name, the default value parameter is returned. @param dnsName: host name to resolve @type dnsName: string @param defaultValue: the value to return if the host name cannot be resolved @return: IP address of the resolved host name @rtype: string """ if dnsName and dnsName.strip(): try: return str(InetAddress.getByName(dnsName).getHostAddress()) except: logger.debugException('Could not resolve DNS name: ', dnsName) return defaultValue
def handle(self, exchange): if not exchange.getRemoteAddress().getAddress() == InetAddress.getByAddress([127, 0, 0, 1]): exchange.sendResponseHeaders(403, 0) exchange.close() return try: i = exchange.getRequestBody() ibuff = "" while True: temp = i.read() if temp == -1: break ibuff += chr(temp) ibuff = _codecs.utf_8_decode(ibuff)[0] self.handleImpl(exchange, ibuff) except: exchange.sendResponseHeaders(500, 0) exchange.close()
def handle(self, exchange): if not exchange.getRemoteAddress().getAddress( ) == InetAddress.getByAddress([127, 0, 0, 1]): exchange.sendResponseHeaders(403, 0) exchange.close() return try: i = exchange.getRequestBody() ibuff = "" while True: temp = i.read() if temp == -1: break ibuff += chr(temp) ibuff = _codecs.utf_8_decode(ibuff)[0] self.handleImpl(exchange, ibuff) except: exchange.sendResponseHeaders(500, 0) exchange.close()
def __init__(self, port=9001): self.__setPort(port) if self.debug: print 'Creating socket for receiving' # Create the socket for receiving self.sock_receive = MulticastSocket(InetSocketAddress("0", port)) self.sock_receive.joinGroup(InetAddress.getByName(MCAST_IP)) self.sock_receive.setTimeToLive(2) self.sock_receive.setSoTimeout(0) #self.sock_receive.sock_impl.jsocket = jmultisock if self.debug: print 'Socket created, bound to ', port if self.debug: print 'Joining multicast group' if self.debug: print 'Init finished' print '' thread.start_new_thread(self.receiver, ())
def __init__(self, address, port, update_interval, auto_reconnect, definitions_file_path, ftp_port, ftp_username, ftp_password): builder = NetworkDataProvider2.forAddress(InetAddress.getByName(address))\ .withInfoModelPort(port)\ .connectToRealBts()\ .reconnectAutomatically(auto_reconnect)\ .updateIntervalMs(update_interval) if definitions_file_path: object_definitions = ObjectDefinitionsFactory.getObjectDefinitions(File(definitions_file_path)) else: ftp_properties = FtpProperties(address, ftp_port, ftp_username, ftp_password) object_definitions = ObjectDefinitionsFactory.getDefinitionsFromFtp(ftp_properties) builder.objectDefinitions(object_definitions) self.provider = builder.build() self.connection_manager = ConnectionManager() self.change_manager = ModelChangeManager() self.connection_status_monitor = ConnectionStatusChangeMonitor() self.model_change_monitor = ModelChangeMonitor() self.connection_status_monitor.register(self.connection_manager) self.model_change_monitor.register(self.change_manager) self.provider.registerForConnectionStatus(self.connection_status_monitor) self.provider.registerListener(self.model_change_monitor)
# # java -cp bin:../../java-router/build/deploy/lib/RawSocket.jar:../../java-router/build/deploy/lib/JythonRouter.jar:../../java-router/ThirdParty/jython2.5.1/jython.jar Main ../../java-router/code/scripts/preconfig.py ../../java-router/code/scripts/simple-ping.py from code.messy.net.ethernet import Ethertype, ArpHandler from code.messy.net.ip import IpProtocolHandler, PacketToIp, IpPacket from code.messy.net.ip.icmp import IcmpHandler from code.messy.net.ip.route import LocalSubnet from java.net import InetAddress icmp = IcmpHandler() protocol = IpProtocolHandler() protocol.register(IpPacket.Protocol.ICMP, icmp) pak2Ip = PacketToIp(protocol) arp = ArpHandler() address = InetAddress.getByName('10.0.0.2') LocalSubnet.create(address, 24, interface['eth1']) address = InetAddress.getByName('10.1.0.2') LocalSubnet.create(address, 24, interface['eth2']) interface['eth1'].register(Ethertype.ARP, arp) interface['eth2'].register(Ethertype.ARP, arp) interface['eth1'].register(Ethertype.IP, pak2Ip) interface['eth2'].register(Ethertype.IP, pak2Ip) interface['eth1'].start() interface['eth2'].start()
def __init__(self, config): if isinstance(config, basestring): self.config = json.loads(config.decode('utf-8')) else: self.config = config self.runtime = {} #TODO: ugly ugly initialization all around, review, make it sane clusterName = "elasticsearch" host = "localhost" port = 9300 if "host" in self.config: host = self.config["host"] else: host = "localhost" if "port" in self.config: port = self.config["port"] else: port = "9300" if "bulkActions" not in self.config: self.config["bulkActions"] = 1000 if "bulkSize" not in self.config: self.config["bulkSize"] = 107374182400 if "flushInterval" not in self.config: self.config["flushInterval"] = 60000 if "concurrentRequests" not in self.config: self.config["concurrentRequests"] = 1 if "actionRetryTimeout" not in self.config: self.config["actionRetryTimeout"] = 5 if "type" not in self.config: self.config["type"] = "logs" if "indexPrefix" not in self.config: self.config["indexPrefix"] = "sampleindex" if "indexSuffix" not in self.config: self.config["indexSuffix"] = "-%Y.%m.%d" logger.debug("Initializing elasticsearch output %s: %s", self.config["indexPrefix"], json.dumps("self.config")) self.config["settings"] = Settings.builder(); if "options" not in self.config: self.config["options"] = {} if "cluster" in self.config: self.config["options"]["cluster.name"] = self.config["cluster"] else: self.config["options"]["cluster.name"] = "elasticsearch" else: if "cluster.name" not in self.config["options"]: if "cluster" in self.config: self.config["options"]["cluster.name"] = self.config["cluster"] else: self.config["options"]["cluster.name"] = "elasticsearch" for setting in self.config["options"]: value = self.config["options"][setting] logger.info("Setting Elasticsearch options: %s = %s", setting, value) self.config["settings"].put(setting, value) self.config["settings"].build() self.runtime["client"] = PreBuiltTransportClient(self.config["settings"].build(), []) if "host" in self.config: address = InetSocketTransportAddress(InetAddress.getByName(host), int(port)) self.runtime["client"].addTransportAddress(address) if "hosts" in self.config: for hostport in self.config["hosts"]: host, port = hostport.split(":") address = InetSocketTransportAddress(InetAddress.getByName(host), int(port)) logger.info("Setting Elasticsearch host: %s = %s", host, port) self.runtime["client"].addTransportAddress(address) self.readyBulk() self.runtime["indices"] = {}
def getComputerName(cls): """ generated source for method getComputerName """ try: return InetAddress.getLocalHost().getHostName().lower() except Exception as e: return None
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ms_domain_name = Framework.getDestinationAttribute('ms_domain_name') if not ms_domain_name: ms_domain_name = 'NULL' try: netUtil = MsNetworkUtil() hostsOutput = netUtil.doNetServerEnum('NULL', SV_TYPE_SERVER, ms_domain_name) if hostsOutput != None: discoverUnknownIPs = 1 try: strDiscoverUnknownIPs = Framework.getParameter( 'discoverUnknownIPs') discoverUnknownIPs = Boolean.parseBoolean( strDiscoverUnknownIPs) except: pass oshMsDomain = ObjectStateHolder('msdomain') oshMsDomain.setStringAttribute('data_name', ms_domain_name) alreadyDiscoveredIps = HashMap() for hostInfo in hostsOutput: hostType = Long(hostInfo[1]).longValue() hostName = (str(hostInfo[0])).lower() try: ip = InetAddress.getByName(hostInfo[0]).getHostAddress() if netutils.isLocalIp(ip): continue cachedHostName = alreadyDiscoveredIps.get(ip) if cachedHostName != None: logger.debug( 'IP ', ip, ' already reported for host ' + cachedHostName, ' current host ', hostName, ' - skipping') continue else: logger.debug('Discovered IP ' + ip + ' for host ' + hostName) alreadyDiscoveredIps.put(ip, hostName) ipDomain = DomainScopeManager.getDomainByIp(ip) if not discoverUnknownIPs and ipDomain == 'unknown': logger.debug( 'ip: ' + ip + ' is out of probe range and will be excluded') continue if SV_TYPE_CLUSTER_NT & hostType: logger.debug( 'Not reporting the entry %s because it is a Cluster' % hostName) continue hostOsType = 'nt' if SV_TYPE_SERVER_UNIX & hostType: hostOsType = 'unix' oshHost = modeling.createHostOSH(ip, hostOsType) oshHost.setStringAttribute("host_hostname", hostName) OSHVResult.add(oshHost) link = modeling.createLinkOSH('member', oshMsDomain, oshHost) OSHVResult.add(link) ipOSH = modeling.createIpOSH(ip) OSHVResult.add(ipOSH) contained = modeling.createLinkOSH('contained', oshHost, ipOSH) OSHVResult.add(contained) except: errorMsg = str(sys.exc_info()[1]).strip() logger.warn('Failed to resolve host ', hostInfo[0], ' : ', errorMsg) else: message = 'Failed to discover hosts on MS Domain' logger.warn(message) logger.reportWarning(message) except: errorMsg = str(sys.exc_info()[1]).strip() logger.errorException('Failed to discovery MS Domains') errorMessage = errormessages.makeErrorMessage( "msdomain", errorMsg, errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS) errobj = errorobject.createError( errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST, ["msdomain", errorMsg], errorMessage) logger.reportErrorObject(errobj) return OSHVResult
def DiscoveryMain(Framework): OSHVResult = ObjectStateHolderVector() ms_domain_name = Framework.getDestinationAttribute('ms_domain_name') if not ms_domain_name: ms_domain_name = 'NULL' try: netUtil = MsNetworkUtil() hostsOutput = netUtil.doNetServerEnum('NULL',SV_TYPE_SERVER, ms_domain_name) if hostsOutput != None: discoverUnknownIPs = 1 try: strDiscoverUnknownIPs = Framework.getParameter('discoverUnknownIPs'); discoverUnknownIPs = Boolean.parseBoolean(strDiscoverUnknownIPs); except: pass oshMsDomain = ObjectStateHolder('msdomain') oshMsDomain.setStringAttribute('data_name', ms_domain_name) alreadyDiscoveredIps = HashMap() for hostInfo in hostsOutput: hostType = Long(hostInfo[1]).longValue() hostName = (str(hostInfo[0])).lower() try: ip = InetAddress.getByName(hostInfo[0]).getHostAddress() if netutils.isLocalIp(ip): continue cachedHostName = alreadyDiscoveredIps.get(ip) if cachedHostName != None: logger.debug('IP ', ip, ' already reported for host ' + cachedHostName, ' current host ', hostName, ' - skipping') continue else: logger.debug('Discovered IP ' + ip + ' for host ' + hostName) alreadyDiscoveredIps.put(ip, hostName) ipDomain = DomainScopeManager.getDomainByIp(ip) if not discoverUnknownIPs and ipDomain == 'unknown': logger.debug('ip: ' + ip + ' is out of probe range and will be excluded') continue if SV_TYPE_CLUSTER_NT & hostType: logger.debug('Not reporting the entry %s because it is a Cluster' % hostName) continue hostOsType = 'nt' if SV_TYPE_SERVER_UNIX & hostType: hostOsType = 'unix' oshHost = modeling.createHostOSH(ip, hostOsType) oshHost.setStringAttribute("host_hostname", hostName) OSHVResult.add(oshHost) link = modeling.createLinkOSH('member', oshMsDomain, oshHost) OSHVResult.add(link) ipOSH = modeling.createIpOSH(ip) OSHVResult.add(ipOSH) contained = modeling.createLinkOSH('contained', oshHost, ipOSH) OSHVResult.add(contained) except: errorMsg = str(sys.exc_info()[1]).strip() logger.warn('Failed to resolve host ', hostInfo[0], ' : ', errorMsg) else: message = 'Failed to discover hosts on MS Domain' logger.warn(message) logger.reportWarning(message) except: errorMsg = str(sys.exc_info()[1]).strip() logger.errorException('Failed to discovery MS Domains') errorMessage = errormessages.makeErrorMessage("msdomain", errorMsg, errormessages.ERROR_FAILED_DISCOVERING_MSDOMAIN_HOSTS) errobj = errorobject.createError(errorcodes.FAILED_DISCOVERIING_MSDOMAIN_HOST, ["msdomain", errorMsg], errorMessage) logger.reportErrorObject(errobj) return OSHVResult
def __init__(self, config): if isinstance(config, basestring): self.config = json.loads(config.decode('utf-8')) else: self.config = config self.runtime = {} #TODO: ugly ugly initialization all around, review, make it sane clusterName = "elasticsearch" host = "localhost" port = 9300 if "host" in self.config: host = self.config["host"] else: host = "localhost" if "port" in self.config: port = self.config["port"] else: port = "9300" if "bulkActions" not in self.config: self.config["bulkActions"] = 1000 if "bulkSize" not in self.config: self.config["bulkSize"] = 107374182400 if "flushInterval" not in self.config: self.config["flushInterval"] = 60000 if "concurrentRequests" not in self.config: self.config["concurrentRequests"] = 1 if "actionRetryTimeout" not in self.config: self.config["actionRetryTimeout"] = 5 if "type" not in self.config: self.config["type"] = "logs" if "indexPrefix" not in self.config: self.config["indexPrefix"] = "sampleindex" if "indexSuffix" not in self.config: self.config["indexSuffix"] = "-%Y.%m.%d" logger.debug("Initializing elasticsearch output %s: %s", self.config["indexPrefix"], json.dumps("self.config")) self.config["settings"] = Settings.builder() if "options" not in self.config: self.config["options"] = {} if "cluster" in self.config: self.config["options"]["cluster.name"] = self.config["cluster"] else: self.config["options"]["cluster.name"] = "elasticsearch" else: if "cluster.name" not in self.config["options"]: if "cluster" in self.config: self.config["options"]["cluster.name"] = self.config[ "cluster"] else: self.config["options"]["cluster.name"] = "elasticsearch" for setting in self.config["options"]: value = self.config["options"][setting] logger.info("Setting Elasticsearch options: %s = %s", setting, value) self.config["settings"].put(setting, value) self.config["settings"].build() self.runtime["client"] = PreBuiltTransportClient( self.config["settings"].build(), []) if "host" in self.config: address = InetSocketTransportAddress(InetAddress.getByName(host), int(port)) self.runtime["client"].addTransportAddress(address) if "hosts" in self.config: for hostport in self.config["hosts"]: host, port = hostport.split(":") address = InetSocketTransportAddress( InetAddress.getByName(host), int(port)) logger.info("Setting Elasticsearch host: %s = %s", host, port) self.runtime["client"].addTransportAddress(address) self.readyBulk() self.runtime["indices"] = {}
def __init__(self, additionalVariables): " initialize oracle database" self.__hostname = "localhost"; try: self.__hostname = InetAddress.getLocalHost().getCanonicalHostName() except: type, value, traceback = sys.exc_info() logger.severe("Hostname error:" + `value`) additionalVariables.add(RuntimeContextVariable("ORACLE_HOSTNAME", self.__hostname, RuntimeContextVariable.ENVIRONMENT_TYPE)) dbPassword = getVariableValue("DB_PASSWORD_ALL") if dbPassword and dbPassword.strip(): self.__sysPassword = dbPassword additionalVariables.add(RuntimeContextVariable("SYS_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)) additionalVariables.add(RuntimeContextVariable("DBSNMP_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)); additionalVariables.add(RuntimeContextVariable("SYSMAN_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)) additionalVariables.add(RuntimeContextVariable("SYSTEM_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)); else: self.__sysPassword = getVariableValue("SYS_PWD") dbDataLocation = getVariableValue("DB_DATA_LOC") if dbDataLocation and os.path.isdir(dbDataLocation): dbName = getVariableValue("DB_NAME") dbDataDir = os.path.join(dbDataLocation, dbName) if os.path.isdir(dbDataDir): logger.info("DB Data directory already exists:" + dbDataDir + "; Setting DB_INSTALL_OPTION to INSTALL_DB_SWONLY") additionalVariables.add(RuntimeContextVariable( "DB_INSTALL_OPTION", "INSTALL_DB_SWONLY", RuntimeContextVariable.ENVIRONMENT_TYPE)) tcpPort = getVariableValue("TCP_PORT"); self.__serviceName = getVariableValue("DB_GLOBAL_NAME") sb = StringBuilder("jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)") sb.append("(HOST=").append(self.__hostname).append(")") sb.append("(PORT=").append(tcpPort).append("))") sb.append("(CONNECT_DATA=(SERVICE_NAME=").append(self.__serviceName).append(")))") self.__oracleServiceUrl = sb.toString() logger.info("Oracle listener service URL:" + self.__oracleServiceUrl) self.__jdbcUrl = "jdbc:oracle:thin:@" + self.__hostname +":"+ tcpPort + ":" + self.__serviceName runtimeContext.addVariable(RuntimeContextVariable("JDBC_URL", self.__jdbcUrl, RuntimeContextVariable.STRING_TYPE, "Oracle Thin Driver JDBC Url", True, RuntimeContextVariable.NO_INCREMENT)) oracleDriver = "oracle.jdbc.OracleDriver" runtimeContext.addVariable(RuntimeContextVariable("JDBC_DRIVER", oracleDriver, RuntimeContextVariable.STRING_TYPE, "Oracle Thin Driver class", True, RuntimeContextVariable.NO_INCREMENT)) self.__dbControl = Boolean.parseBoolean(getVariableValue("CONFIG_DBCONTROL", "false")) if self.__dbControl: self.__dbCtrlPort = getVariableValue("DBCONTROL_HTTP_PORT") additionalVariables.add(RuntimeContextVariable( "HTTPS_PORT", self.__dbCtrlPort, RuntimeContextVariable.STRING_TYPE)) oracleDir = getVariableValue("ORACLE_DIR") self.__markerFilePath = os.path.join(oracleDir, ".#dsoracle") self.__maintFilePath = getVariableValue("ORACLE_MAINT_FILE") dbInstallOption = getVariableValue("DB_INSTALL_OPTION") if dbInstallOption == "INSTALL_DB_AND_CONFIG": globalLockString = "OracleEnabler-" + self.__hostname logger.info("Requesting Global Lock with name: " + globalLockString) domain = proxy.getContainer().getCurrentDomain() options = domain.getOptions() maxActivationTimeOut = options.getProperty(Options.MAX_ACTIVATION_TIME_IN_SECONDS) lockTimeOut = Long.parseLong(maxActivationTimeOut) * 1000 acquired = ContainerUtils.acquireGlobalLock(globalLockString, lockTimeOut , lockTimeOut) if acquired: logger.info("Acquired Global lock with name: " + globalLockString) else: logger.severe("Could not acquire Global lock with name: " + globalLockString) raise Exception("Could not acquire Global lock with name: " + globalLockString)
def resolveHostIp(hostName): try: return InetAddress.getByName(hostName).getHostAddress() except UnknownHostException: logger.debug("Failed to resolve IP for host '%s'" % hostName)
{rmessage=Successful!, userid=17463581, classid=2836734, assignmentid=7902887, rcode=41} Adding an assignment with another inst {'fid': '4', 'diagnostic': '0', 'ufn': 'StevenIU', 'uln': 'GithensIU', 'username': '******', 'assignid': 'AssignmentTitle2650fcca-b96e-42bd-926e-63660076d2ad', 'aid': '56021', 'src': '9', 'cid': '2836733', 'said': '56021', 'dtstart': '20091225', 'encrypt': '0', 'assign': 'AssignmentTitle2650fcca-b96e-42bd-926e-63660076d2ad', 'uem': '*****@*****.**', 'utp': '2', 'fcmd': '2', 'ctl': 'CourseTitle46abd163-7464-4d21-a2c0-90c5af3312ab', 'dtdue': '20100101'} {rmessage=Successful!, userid=17463581, classid=2836734, assignmentid=7902888, rcode=41} """ import unittest import random import sys from org.sakaiproject.component.cover import ComponentManager from java.net import InetSocketAddress, Proxy, InetAddress from java.util import HashMap debug_proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress(InetAddress.getByName("127.0.0.1"),8008)) tiireview_serv = ComponentManager.get("org.sakaiproject.contentreview.service.ContentReviewService") class SakaiUuid(object): """My Current Jython impl doens't seem to have UUID, so re-implementing it for now""" def __init__(self): self.idmanager = ComponentManager.get("org.sakaiproject.id.api.IdManager") def uuid1(self): return self.idmanager.createUuid() uuid = SakaiUuid()
from java.net import InetAddress as ip website = raw_input("Enter website name: ") #request serviced: print (ip.getByName(website)) print () print ("all address: ") for k in ip.getAllByName(website): print (k)
# # java -cp bin:../../java-router/build/deploy/lib/RawSocket.jar:../../java-router/build/deploy/lib/JythonRouter.jar:../../java-router/ThirdParty/jython2.5.1/jython.jar Main ../../java-router/code/scripts/preconfig.py ../../java-router/code/scripts/simple-ping.py from code.messy.net.ethernet import Ethertype, ArpHandler from code.messy.net.ip import IpProtocolHandler, PacketToIp, IpPacket from code.messy.net.ip.icmp import IcmpHandler from code.messy.net.ip.route import LocalSubnet from java.net import InetAddress icmp = IcmpHandler() protocol = IpProtocolHandler() protocol.register(IpPacket.Protocol.ICMP, icmp) pak2Ip = PacketToIp(protocol) arp = ArpHandler() address = InetAddress.getByName('10.0.0.2') LocalSubnet.create(address, 24, interface['eth1']) address = InetAddress.getByName('10.1.0.2'); LocalSubnet.create(address, 24, interface['eth2']) interface['eth1'].register(Ethertype.ARP, arp) interface['eth2'].register(Ethertype.ARP, arp) interface['eth1'].register(Ethertype.IP, pak2Ip) interface['eth2'].register(Ethertype.IP, pak2Ip) interface['eth1'].start() interface['eth2'].start()
def __init__(self, IPaddress = "localhost", port = 57110): self.IPaddress = InetAddress.getByName(IPaddress) # holds IP address of OSC device to connect with self.port = port # and its listening port self.portOut = OSCPortOut(self.IPaddress, self.port) # create the connection
from code.messy.net.ethernet import Ethertype, ArpHandler, EthernetIpSupport from code.messy.net.ip import IpProtocolHandler, IpPacket from code.messy.net.ip.udp import UdpHandler from code.messy.net.ip.dhcp import DhcpHandler from code.messy.net.ip.route import LocalSubnet, RouteHandler, RoutingTable from java.net import InetAddress route = RouteHandler() eth1ip = EthernetIpSupport(interface['eth1']) eth2ip = EthernetIpSupport(interface['eth2']) address = InetAddress.getByName('10.1.0.1'); eth1network = LocalSubnet.create(address, 24, eth1ip) address = InetAddress.getByName('10.2.0.1'); eth2network = LocalSubnet.create(address, 24, eth2ip) udp1 = UdpHandler() protocol1 = IpProtocolHandler() protocol1.register(IpPacket.Protocol.UDP, udp1) protocol1.register(route) dhcp1 = DhcpHandler(eth1network) udp1.add(None, 67, dhcp1) udp2 = UdpHandler() protocol2 = IpProtocolHandler() protocol2.register(IpPacket.Protocol.UDP, udp2) protocol2.register(route) dhcp2 = DhcpHandler(eth2network) udp2.add(None, 67, dhcp2)
if __name__ == '__main__': from wlstModule import * # @UnusedWildImport from java.net import InetAddress from java.util.logging import * from java.util.logging import Logger import sys logger = Logger.getLogger("scratch") print "" + InetAddress.getLocalHost().getHostName()
def __init__(self, additionalVariables): " initialize oracle database" self.__hostname = "localhost" try: self.__hostname = InetAddress.getLocalHost().getCanonicalHostName() except: type, value, traceback = sys.exc_info() logger.severe("Hostname error:" + ` value `) additionalVariables.add( RuntimeContextVariable("ORACLE_HOSTNAME", self.__hostname, RuntimeContextVariable.ENVIRONMENT_TYPE, "Oracle Hostname", True, RuntimeContextVariable.NO_INCREMENT)) listenAddress = getVariableValue("LISTEN_ADDRESS") additionalVariables.add( RuntimeContextVariable("ORACLE_LISTEN_ADDRESS", listenAddress, RuntimeContextVariable.ENVIRONMENT_TYPE, "Oracle Listen Address", True, RuntimeContextVariable.NO_INCREMENT)) dbPassword = getVariableValue("DB_PASSWORD_ALL") if dbPassword and dbPassword.strip(): self.__sysPassword = dbPassword additionalVariables.add( RuntimeContextVariable( "SYS_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)) additionalVariables.add( RuntimeContextVariable( "DBSNMP_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)) additionalVariables.add( RuntimeContextVariable( "SYSMAN_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)) additionalVariables.add( RuntimeContextVariable( "SYSTEM_PWD", dbPassword, RuntimeContextVariable.ENVIRONMENT_TYPE)) else: self.__sysPassword = getVariableValue("SYS_PWD") dbDataLocation = getVariableValue("DB_DATA_LOC") if dbDataLocation and os.path.isdir(dbDataLocation): dbName = getVariableValue("DB_NAME") dbDataDir = os.path.join(dbDataLocation, dbName) if os.path.isdir(dbDataDir): logger.info("DB Data directory already exists:" + dbDataDir + "; Setting DB_INSTALL_OPTION to INSTALL_DB_SWONLY") additionalVariables.add( RuntimeContextVariable( "DB_INSTALL_OPTION", "INSTALL_DB_SWONLY", RuntimeContextVariable.ENVIRONMENT_TYPE)) tcpPort = getVariableValue("TCP_PORT") self.__serviceName = getVariableValue("DB_GLOBAL_NAME") sb = StringBuilder( "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)") sb.append("(HOST=").append(self.__hostname).append(")") sb.append("(PORT=").append(tcpPort).append("))") sb.append("(CONNECT_DATA=(SERVICE_NAME=").append( self.__serviceName).append(")))") self.__oracleServiceUrl = sb.toString() logger.info("Oracle listener service URL:" + self.__oracleServiceUrl) self.__jdbcUrl = "jdbc:oracle:thin:@" + self.__hostname + ":" + tcpPort + ":" + self.__serviceName additionalVariables.add( RuntimeContextVariable("JDBC_URL", self.__jdbcUrl, RuntimeContextVariable.STRING_TYPE, "Oracle Thin Driver JDBC Url", True, RuntimeContextVariable.NO_INCREMENT)) oracleDriver = "oracle.jdbc.OracleDriver" additionalVariables.add( RuntimeContextVariable("JDBC_DRIVER", oracleDriver, RuntimeContextVariable.STRING_TYPE, "Oracle Thin Driver class", True, RuntimeContextVariable.NO_INCREMENT)) self.__dbControl = Boolean.parseBoolean( getVariableValue("CONFIG_DBCONTROL", "false")) if self.__dbControl: self.__dbCtrlPort = getVariableValue("DBCONTROL_HTTP_PORT") additionalVariables.add( RuntimeContextVariable("HTTPS_PORT", self.__dbCtrlPort, RuntimeContextVariable.STRING_TYPE)) oracleDir = getVariableValue("ORACLE_DIR") self.__markerFilePath = os.path.join(oracleDir, ".#dsoracle") self.__maintFilePath = getVariableValue("ORACLE_MAINT_FILE") dbInstallOption = getVariableValue("DB_INSTALL_OPTION") if dbInstallOption == "INSTALL_DB_AND_CONFIG": globalLockString = "OracleEnabler-" + self.__hostname logger.info("Requesting Global Lock with name: " + globalLockString) domain = proxy.getContainer().getCurrentDomain() options = domain.getOptions() maxActivationTimeOut = options.getProperty( Options.MAX_ACTIVATION_TIME_IN_SECONDS) lockTimeOut = Long.parseLong(maxActivationTimeOut) * 1000 acquired = ContainerUtils.acquireGlobalLock( globalLockString, lockTimeOut, lockTimeOut) if acquired: logger.info("Acquired Global lock with name: " + globalLockString) else: logger.severe("Could not acquire Global lock with name: " + globalLockString) raise Exception("Could not acquire Global lock with name: " + globalLockString)
Adding an assignment with another inst {'fid': '4', 'diagnostic': '0', 'ufn': 'StevenIU', 'uln': 'GithensIU', 'username': '******', 'assignid': 'AssignmentTitle2650fcca-b96e-42bd-926e-63660076d2ad', 'aid': '56021', 'src': '9', 'cid': '2836733', 'said': '56021', 'dtstart': '20091225', 'encrypt': '0', 'assign': 'AssignmentTitle2650fcca-b96e-42bd-926e-63660076d2ad', 'uem': '*****@*****.**', 'utp': '2', 'fcmd': '2', 'ctl': 'CourseTitle46abd163-7464-4d21-a2c0-90c5af3312ab', 'dtdue': '20100101'} {rmessage=Successful!, userid=17463581, classid=2836734, assignmentid=7902888, rcode=41} """ import unittest import random import sys from org.sakaiproject.component.cover import ComponentManager from java.net import InetSocketAddress, Proxy, InetAddress from java.util import HashMap debug_proxy = Proxy( Proxy.Type.HTTP, InetSocketAddress(InetAddress.getByName("127.0.0.1"), 8008)) tiireview_serv = ComponentManager.get( "org.sakaiproject.contentreview.service.ContentReviewService") class SakaiUuid(object): """My Current Jython impl doens't seem to have UUID, so re-implementing it for now""" def __init__(self): self.idmanager = ComponentManager.get( "org.sakaiproject.id.api.IdManager") def uuid1(self): return self.idmanager.createUuid()