def connect(self): host = self._host port = self._port if self._fd is None: #try to find the server on the same sub-net if host is None or port is None: udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) # go through all interfaces, and issue broadcast on each for addr in ip4_broadcast_addresses(host is None): udp.sendto('Hello', (addr, protocol.DEFAULT_UDP_SERVER_PORT)) timeout = 3. server_found = [] while 1: rlist, _, _ = select.select([udp], [], [], timeout) if not rlist: if port is None: if server_found: msg = "Could not find the conductor on host %s\n" % self._host msg += "But other conductor servers replied:\n" msg += '\n'.join( ('%s on port %s' % (host, port) for host, port in server_found)) raise ConnectionException(msg) else: raise ConnectionException( "Could not find the conductor") else: break else: msg, address = udp.recvfrom(8192) host, port = msg.split('|') port = int(port) if self._host == 'localhost': localhost = socket.gethostname() if localhost == host: break elif self._host is not None and host != self._host: server_found.append((host, port)) host, port = None, None timeout = 1. else: break self._host = host self._port = port self._fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self._fd.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self._fd.setsockopt(socket.SOL_IP, socket.IP_TOS, 0x10) self._fd.connect((host, port)) self._raw_read_task = gevent.spawn(self._raw_read) self._cnx = self._fd if posix_ipc: self._g_event.clear() self._fd.sendall( protocol.message(protocol.POSIX_MQ_QUERY, socket.gethostname())) self._g_event.wait(1.)
def connect(self): host = self._host port = self._port if self._fd is None: #try to find the server on the same sub-net if host is None or port is None: udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) # go through all interfaces, and issue broadcast on each for addr in ip4_broadcast_addresses(host is None): udp.sendto('Hello',(addr,protocol.DEFAULT_UDP_SERVER_PORT)) timeout = 3. server_found = [] while 1: rlist,_,_ = select.select([udp],[],[],timeout) if not rlist: if port is None: if server_found: msg = "Could not find the conductor on host %s\n" % self._host msg += "But other conductor servers replied:\n" msg += '\n'.join(('%s on port %s' % (host,port) for host,port in server_found)) raise ConnectionException(msg) else: raise ConnectionException("Could not find the conductor") else: break else: msg,address = udp.recvfrom(8192) host,port = msg.split('|') port = int(port) if self._host == 'localhost': localhost = socket.gethostname() if localhost == host: break elif self._host is not None and host != self._host: server_found.append((host,port)) host,port = None,None timeout = 1. else: break self._host = host self._port = port self._fd = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self._fd.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1) self._fd.setsockopt(socket.SOL_IP, socket.IP_TOS, 0x10) self._fd.connect((host,port)) self._raw_read_task = gevent.spawn(self._raw_read) self._cnx = self._fd if posix_ipc: self._g_event.clear() self._fd.sendall(protocol.message(protocol.POSIX_MQ_QUERY,socket.gethostname())) self._g_event.wait(1.)
def broadcast_service(self): if self.listen_address == '0.0.0.0': raise Exception('NetRNG server: zeroconf currently requires a specific listen address in /etc/netrng.conf') desc = {'version': __version__} info = ServiceInfo('_netrng._tcp.local.', '{}._netrng._tcp.local.'.format(socket.gethostname()), socket.inet_aton(self.listen_address), self.port, 0, 0, desc) log.info('NetRNG server: registering service with Bonjour: %s', info) self.zeroconf_controller.register_service(info)
def __init__(self, louper, *args, **kwargs): super(LoupeDashboard, self).__init__(*args, **kwargs) self.loupe_pool = louper.loupe_pool self.total_loupes = louper.total_count self.results = louper.results self.inputs = louper.input_classes self.failed_stats = louper.failed_stats self.fetch_failures = louper.fetch_failures self.start_time = time.time() self.tpool = None self.start_time = kwargs.get("start_time") or time.time() self.start_cmd = kwargs.get("start_cmd") or " ".join(sys.argv) self.host_machine = kwargs.get("hostname") or socket.gethostname() self.open_toolserver_queries = self.get_toolserver_openlog() if self.open_toolserver_queries > 0: print "\nNote: there are", self.open_toolserver_queries, "open queries on toolserver\n" self.send_toolserver_log("start", start_time=self.start_time) self.toolserver_uptime = self.get_toolserver_uptime() self.route("/", callback=self.render_dashboard, template="dashboard") self.route("/summary", callback=self.get_summary_dict, template="summary") self.route("/all_results", callback=self.get_all_results) self.route("/static/<filepath:path>", callback=self.serve_static) self.uninstall(JSONPlugin) self.install(JSONPlugin(better_dumps)) self.install(TemplatePlugin()) self.sys_peaks = defaultdict(float)
def monitor_worker(self, monitor_socket, log_name): monitor_socket.linger = 0 poller = zmq.Poller() poller.register(monitor_socket, zmq.POLLIN) while True: socks = poller.poll(1) gevent.sleep(0.1) if len(socks) > 0: data = recv_monitor_message(monitor_socket) event = data['event'] value = data['value'] if event == zmq.EVENT_CONNECTED: logger.info('Connected to {0}'.format(log_name)) if 'outgoing' in log_name: send_zmq_push('inproc://serverRelay', '{0}'.format(Messages.PING)) own_ip = gevent.socket.gethostbyname(socket.gethostname()) send_zmq_push('inproc://serverRelay', '{0} {1}'.format(Messages.IP, own_ip)) send_zmq_push('inproc://serverRelay', '{0}'.format(Messages.DRONE_CONFIG)) elif 'incomming': pass else: assert False elif event == zmq.EVENT_DISCONNECTED: logger.warning('Disconnected from {0}, will reconnect in {1} seconds.'.format(log_name, 5)) gevent.sleep()
def create_self_signed_cert(cert_dir, hostname=None, year=10): from OpenSSL import crypto, SSL CERT_FILE = "ssl_certificate.crt" KEY_FILE = "ssl_self_signed.key" if not os.path.exists(os.path.join(cert_dir, CERT_FILE)) or not os.path.exists(os.path.join(cert_dir, KEY_FILE)): k = crypto.PKey() k.generate_key(crypto.TYPE_RSA, 4096) cert = crypto.X509() cert.get_subject().C = "AQ" cert.get_subject().ST = "State" cert.get_subject().L = "City" cert.get_subject().O = "Company" cert.get_subject().OU = "Organization" if hostname is None : cert.get_subject().CN = socket.gethostname() else: cert.get_subject().CN = hostname cert.set_serial_number(1000) cert.gmtime_adj_notBefore(0) cert.gmtime_adj_notAfter(year*365*24*60*60) cert.set_issuer(cert.get_subject()) cert.set_pubkey(k) cert.sign(k, 'sha1') with open(os.path.join(cert_dir, CERT_FILE), "wt") as f: f.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert)) with open(os.path.join(cert_dir, KEY_FILE), "wt") as f: f.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, k)) print('Create SSL key and cert done') else: print('SSL key and cert already exist')
def _resubscribe(self, url, sid=None): headers = {'TIMEOUT': 'infinite'} if sid is not None: headers['SID'] = sid else: host = socket.gethostbyname(socket.gethostname()) headers.update({ "CALLBACK": '<http://%s:8989>' % host, "NT": "upnp:event" }) try: response = requests.request(method="SUBSCRIBE", url=url, headers=headers) timeout = 50 try: timeout = int(response.headers['timeout'].replace('Second-', '')) except: log.info("Error parse timeout") print "Error parse timeout" timeout = 50 try: sid = response.headers['sid'] except: log.info("Error parse sid") print "Error parse sid" gevent.spawn_later(timeout, self._resubscribe, url, sid) except: log.info("Error parse timeout") gevent.spawn_later(10, self._resubscribe, url, sid)
def __init__(self): #get server ip (current machine) self.ip = self.ip = socket.gethostbyname(socket.gethostname()) print "Starting server: %s:1337" % self.ip self.chs = Characters.Characters()
def init_global(): global gConfig, CONFIGFILE parser = OptionParser() parser.add_option("-c", "--config", dest="config", action="store", default="config.ini", help="specify a config file to load") parser.add_option("--signcert_enable", action="store_true", dest="signcert_enable", default=False, help="generate ssl cert and key") parser.add_option("--signcert_directory", action="store", dest="signcert_directory", default='.', help="specify the directory to store ssl cert and key file") parser.add_option("--signcert_year", action="store", type="int", dest="signcert_year", default=10, help="specify year to generate ssl cert") parser.add_option("--signcert_hostname", action="store", dest="signcert_hostname", default=socket.gethostname(), help="specify host's name to generate ssl cert") parser.add_option("--cluster_enable", action="store_true", dest="cluster_enable", default=False, help="enable cluster mode") (options, args) = parser.parse_args() print('parsing %s...' % options.config) CONFIGFILE = options.config gConfig = init_config({'gConfig':gConfig},CONFIGFILE) # if gConfig['wsgi']['application'].lower() == 'chat_platform': # gJoinableQueue = gevent.queue.JoinableQueue(maxsize=int(gConfig['chat_platform']['queue']['max_queue_size'])) return options
def handshake(self, sck): # read conn request payload = utils.read_payload_response(sck) log.debug(payload) resp = WirePayload() resp.connect_response.auth_method.append(SIMPLE) resp.connect_response.protocol = "text" resp.connect_response.server_name = socket.gethostname() utils.send_payload(sck, resp) payload = utils.read_payload_response(sck) if not payload.initial_auth_request.IsInitialized(): return False resp = WirePayload() resp.auth_response.complete = True resp.auth_response.challenge = "" resp_buf = resp.SerializeToString() utils.send_payload(sck, resp) payload = utils.read_payload_response(sck) if not payload.properties_request.IsInitialized(): return False resp = WirePayload() resp.properties_response.server_pid = str(os.getpid()) utils.send_payload(sck, resp) return True
def monitor_worker(self, monitor_socket, log_name): monitor_socket.linger = 0 poller = zmq.Poller() poller.register(monitor_socket, zmq.POLLIN) while True: socks = poller.poll(1) gevent.sleep(0.1) if len(socks) > 0: data = recv_monitor_message(monitor_socket) event = data['event'] value = data['value'] if event == zmq.EVENT_CONNECTED: logger.info('Connected to {0}'.format(log_name)) if 'outgoing' in log_name: send_zmq_push('inproc://serverRelay', '{0}'.format(Messages.PING)) own_ip = gevent.socket.gethostbyname( socket.gethostname()) send_zmq_push('inproc://serverRelay', '{0} {1}'.format(Messages.IP, own_ip)) send_zmq_push('inproc://serverRelay', '{0}'.format(Messages.DRONE_CONFIG)) elif 'incomming': pass else: assert False elif event == zmq.EVENT_DISCONNECTED: logger.warning( 'Disconnected from {0}, will reconnect in {1} seconds.' .format(log_name, 5)) gevent.sleep()
def __init__(self): self.connected = False self.user('niaxbot', socket.gethostname(), 'Niaxbot') self.welcomed = False self.queries = {} self.logger = logging.getLogger('irc.server') self.raw_logger = logging.getLogger('irc.server.raw')
def connect(self): host = self._host port = self._port if self._fd is None: #try to find the server on the same sub-net if host is None or port is None: udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) udp.bind(("", protocol.DEFAULT_UDP_CLIENT_PORT)) udp.sendto( 'Hello', ('255.255.255.255', protocol.DEFAULT_UDP_SERVER_PORT)) timeout = 10. while 1: rlist, _, _ = select.select([udp], [], [], timeout) if not rlist: if port is None: raise ConnectionException( "Could not find the conductor") else: break else: msg, address = udp.recvfrom(8192) host, port = msg.split('|') port = int(port) if self._host == 'localhost': localhost = socket.gethostname() if localhost == host: break elif self._host is not None and host != self._host: host, port = None, None timeout = 1. else: break self._fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self._fd.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self._fd.connect((host, port)) self._raw_read_task = gevent.spawn(self._raw_read) self._cnx = self._fd if posix_ipc: self._g_event.clear() self._fd.sendall( protocol.message(protocol.POSIX_MQ_QUERY, socket.gethostname())) self._g_event.wait(1.)
def __init__(self, ca=None, cert=None, key=None, hostname=None): self._hosts = [] self._ca = ca self._cert = cert self._key = key if hostname is None: hostname = socket.gethostname() self._hostname = hostname
def __init__(self): self.subscribed = 0 self._generator = None self.fqdn = socket.getfqdn() self.hostname = socket.gethostname() self._events = Queue() self.register()
def connect(self) : host = self._host port = self._port if self._fd is None: #try to find the server on the same sub-net if host is None or port is None: udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) udp.bind(("",protocol.DEFAULT_UDP_CLIENT_PORT)) # go through all interfaces, and issue broadcast on each for addr in ip4_broadcast_addresses(): udp.sendto('Hello',(addr,protocol.DEFAULT_UDP_SERVER_PORT)) timeout = 3. while 1: rlist,_,_ = select.select([udp],[],[],timeout) if not rlist: if port is None: raise ConnectionException("Could not find the conductor") else: break else: msg,address = udp.recvfrom(8192) host,port = msg.split('|') port = int(port) if self._host == 'localhost': localhost = socket.gethostname() if localhost == host: break elif self._host is not None and host != self._host: host,port = None,None timeout = 1. else: break self._fd = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self._fd.setsockopt(socket.IPPROTO_TCP,socket.TCP_NODELAY,1) self._fd.connect((host,port)) self._raw_read_task = gevent.spawn(self._raw_read) self._cnx = self._fd if posix_ipc: self._g_event.clear() self._fd.sendall(protocol.message(protocol.POSIX_MQ_QUERY,socket.gethostname())) self._g_event.wait(1.)
def connect(self, port): host_name = socket.gethostname() try: self.socket = socket.create_connection((host_name, port)) except socket.error as exc: self.logger.error('Could not connect to %s, because of %s', (host_name, port, exc)) return False self.logger.info('Connected to %s', (host_name, port)) return True
def __init__(self, handler, mcast_ip='239.255.255.250', mcast_port=1900, bind=None): if bind is None: host = socket.gethostbyname(socket.gethostname()) port = 54321 bind = '{0}:{1}'.format(host, port) self.bind = bind self.mcast_ip = mcast_ip self.mcast_port = mcast_port self.clients = {} self._handler = handler
def __init__(self, actor_config, batch=0, batch_size=1, set_size=1, sleep=1, value=1, tags=()): Actor.__init__(self, actor_config) if batch == 0: self.generateNextBatchAllowed = self.__returnTrue else: self.generateNextBatchAllowed = self.__evaluateCounter self.pool.createQueue("outbox") self.hostname = gethostname()
def connect(self): if self.host is None: self.host = socket.gethostname() self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if self.port is None: self.sock.bind((self.host, 0)) self.port = self.sock.getsockname()[1] else: self.sock.bind((self.host, self.port)) _log.debug('Bound to %r on %r' % (self.port, self.host))
def server(): #start server running s = socket.socket() host = socket.gethostname() address = (host, 5000) s.bind(address) s.listen(1) while True: conn, addr = s.accept() if debug: print(conn) buffer_length = 8 message_complete = False response = b'' while not message_complete: part = conn.recv(buffer_length) response += part if len(part) < buffer_length: break message = response #returns resource (file ext) from get request resource = parse_request(message) #resolve_uri takes resource from packet sent and opens file gets data repackages packet = resolve_uri(resource) #encodes http packet created and sends to client conn.send(packet.encode()) strMessage = message.decode() if debug: print(resource) #tests functionality before http packet was added #ok response if strMessage == "testOK": ok = response_ok() conn.send(ok.encode()) #test sending error response if strMessage == "testError": error = response_error() conn.send(error.encode()) conn.close() if message.decode() == 'q': break
def __init__(self, name, port=None, host=None, listen=True, *args, **kwargs): super(TCPOut, self).__init__(name, *args, **kwargs) self.blockdiag_config["shape"] = "cloud" self.port = port or DEFAULT_PORT self.host = host or socket.gethostbyname(socket.gethostname())
def metricProducer(self): '''A greenthread which collects the queue metrics at the defined interval.''' self.__run.wait() hostname = socket.gethostname() while self.loop(): for queue in self.pool.listQueues(names=True): for metric, value in self.pool.getQueue(queue).stats().iteritems(): event = Wishbone_Event(self.name) event.data = Metric(time=time(), type="wishbone", source=hostname, name="module.%s.queue.%s.%s" % (self.name, queue, metric), value=value, unit="", tags=()) self.submit(event, self.pool.queue.metrics) sleep(self.frequency)
def __init__(self, node_name, port, cookie, connected_event=None): super(OutgoingNodeConnection, self).__init__() self.port = port self.cookie = cookie if '@' in node_name: self.node_name = node_name else: self.node_name = '{}@{}'.format(node_name, socket.gethostname()) self.channel = Channel(self.actor_ref) self.channel.connect(self.port) self.connected_event = connected_event self._state = None
def __init__(self, config): self.config = config self.interval = config['master']['heartbeat_secs'] self.hostname = socket.gethostname() self.port = config['worker']['port'] self.slots = self.max_slots = config['worker']['available_slots'] self.secret = config['master']['shared_secret'] self.min_srv_port = config['worker']['port_range_start'] self.max_srv_port = config['worker']['port_range_end'] self.srv_port = self.min_srv_port self.matches = {} self.heartbeat_greenlet = gevent.spawn(self.send_heartbeat)
def cli(host, port, wwwport): click.echo('\r\nService listening on %s:%s' % ( host, port, )) web_list = list() client_connect_list = list() web_list.append('local: http://127.0.0.1:%s' % wwwport) client_connect_list.append( 'local: python client.py --host 127.0.0.1 --port %s' % port) if host == '0.0.0.0': wan_ip = get_wan_ip() lan_ip = socket.gethostbyname(socket.gethostname()) if lan_ip != wan_ip: web_list.append('lan : http://%s:%s' % (lan_ip, wwwport)) client_connect_list.append( 'lan : python client.py --host %s --port %s' % (lan_ip, port)) if wan_ip: web_list.append( 'wan : http://%s:%s PS: Maybe need to set up port forwarding' % (wan_ip, wwwport)) client_connect_list.append( 'wan : python client.py --host %s --port %s PS: Maybe need to set up port forwarding' % (wan_ip, port)) click.echo('\r\nAccess console via:') for item in web_list: click.echo(item) click.echo('\r\nClient connection use:') for item in client_connect_list: click.echo(item) click.echo('\r\nListening ...') global_process_var = Manager().dict() GlobalHelper.init(global_process_var) web_ui = Process(target=web_start, args=(global_process_var, host, wwwport)) web_ui.start() global slave_record slave_record = SlaveRecord.get_instance() GlobalHelper.set('salve_record', slave_record.slave_record) socket_server(host, port) web_ui.join()
def get_host_ip(): ret = [] if sys.platform == 'win32': ret.append('127.0.0.1') localIP = socket.gethostbyname(socket.gethostname()) #print ("local ip:%s " % localIP) ipList = socket.gethostbyname_ex(socket.gethostname()) for i in ipList: if i != localIP: #if isinstance(i, str): #print(re.findall('\d+\.\d+\.\d+\.\d+',i)) if isinstance(i, list): for ii in i: if len(re.findall('\d+\.\d+\.\d+\.\d+',ii))>0: ret.append(ii) #print("external IP:%s" % i ) elif 'linux' in sys.platform: import commands ips = commands.getoutput("/sbin/ifconfig | grep -i \"inet\" | grep -iv \"inet6\" | awk {'print $2'} | sed -ne 's/addr\:/ /p'") arr = ips.split('\n') for i in arr: ret.append(i.strip()) return ret
def __init__(self, hostname, nick, port=IRC_PORT, local_hostname=None, server_name=None, real_name=None): self.hostname = hostname self.port = port self.nick = nick self._socket = None self.real_name = real_name or nick self.local_hostname = local_hostname or socket.gethostname() self.server_name = server_name or 'gevent-irc' self._recv_queue = gevent.queue.Queue() self._send_queue = gevent.queue.Queue() self._group = gevent.pool.Group() self._handlers = {} self._global_handlers = set([])
class RpcChannel(service.RpcChannel): def __init__(self, addr, port): self._seq_id = 0 self._addr = addr self._port = port self._conn = None self.reconnect() self._rlock = Semaphore() self._wlock = Semaphore() def reconnect(self): if self._conn != None: self._conn.close() try: sck = socket.create_connection((self._addr, self._port)) except socket.error, e: raise RpcException(e) self._seq_id += 1 # send connect request req = WirePayload() req.connect_request.version = 1 << 16 utils.send_payload(sck, req) payload = utils.read_payload_response(sck) if not payload.connect_response.IsInitialized(): raise # send initauth request req = WirePayload() req.initial_auth_request.auth_method = SIMPLE req.initial_auth_request.initial_response = "wdj-rpc" utils.send_payload(sck, req) payload = utils.read_payload_response(sck) if not payload.auth_response.IsInitialized(): raise # send properties request req = WirePayload() req.properties_request.client_host_name = socket.gethostname() req.properties_request.client_port = 1234 req.properties_request.client_pid = str(os.getpid()) utils.send_payload(sck, req) payload = utils.read_payload_response(sck) if not payload.properties_response.IsInitialized(): raise self._conn = sck
def __init__(self): pygame.init() self.screen = pygame.display.set_mode(WINDOW_SIZE) self.w, self.h = WINDOW_SIZE[0], WINDOW_SIZE[1] self.screen.fill((255,255,255)) pygame.display.flip() self.ip = socket.gethostbyname(socket.gethostname()) print "Client IP: %s" % self.ip #self.serverip = raw_input("What is the server IP address?\n\n") self.serverip = '192.168.1.100' self.serverport = '1337' print "\n-----------------------\n\n"
def handle(self): send_ack = True response = False try: self.process_query() response = True except socket.error as e: self.logger.error("Failed connection from %s (child of %s): %s."\ %(repr(self.address), repr(self.server.address), unicode(e))) except NetworkException as e: self.logger.error("RaisedNetworkException:\n"+unicode(e)) e.log_forward((socket.gethostname(),self.server.address[1])) self.send(e) send_ack = False except Exception as e: self.logger.error("RaisedException:\n"+traceback.format_exc()) ne = NetworkException(type(e).__name__+': '+unicode(e)) ne.log_forward((socket.gethostname(),self.server.address[1])) self.send(ne) send_ack = False finally: if __debug__: self.logger.debug("executing finally statement.") try: if send_ack: self.send(0 if response else -1) if __debug__: self.logger.debug("Closing connection.") self.socket.shutdown(socket.SHUT_WR) self.socket.close() except Exception as e: if __debug__: self.logger.debug("ERROR: %s",unicode(e)) pass
def __init__(self, hostname, nick, port=IRC_PORT, local_hostname=None, server_name=None, real_name=None, ssl=False, logger=None): self.hostname = hostname self.port = port self.nick = nick self.ssl = ssl self._socket = None self.real_name = real_name or nick self.local_hostname = local_hostname or socket.gethostname() #@UndefinedVariable self.server_name = server_name or 'gevent-irc' self._recv_queue = gevent.queue.Queue() self._send_queue = gevent.queue.Queue() self._group = gevent.pool.Group() self._handlers = {} self._global_handlers = set() self.channels = set() self.logger = logger or module_logger
def getLocalIP(): ''' Get the local IP address as a string Derived from https://github.com/n8henrie/fauxmo ''' hostname = socket.gethostname() ip_address = socket.gethostbyname(hostname) # Workaround for Linux returning localhost # See: SO question #166506 by @UnkwnTech if ip_address in ['127.0.1.1', '127.0.0.1', 'localhost']: tempsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) tempsock.connect(('8.8.8.8', 0)) ip_address = tempsock.getsockname()[0] tempsock.close() return ip_address
def _resubscribe(self, url, sid=None): headers = {'TIMEOUT': 'infinite'} if sid is not None: headers['SID'] = sid else: host = socket.gethostbyname(socket.gethostname()) headers.update({ "CALLBACK": '<http://%s:8989>' % host, "NT": "upnp:event" }) response = requests.request(method="SUBSCRIBE", url=url, headers=headers) timeout = int(response.headers['timeout'].replace('Second-', '')) sid = response.headers['sid'] gevent.spawn_later(timeout, self._resubscribe, url, sid)
def cli(host, port, wwwport): click.echo('\r\nService listening on %s:%s' % (host, port,)) web_list = list() client_connect_list = list() web_list.append('local: http://127.0.0.1:%s' % wwwport) client_connect_list.append('local: python client.py --host 127.0.0.1 --port %s' % port) if host == '0.0.0.0': wan_ip = get_wan_ip() lan_ip = socket.gethostbyname(socket.gethostname()) if lan_ip != wan_ip: web_list.append('lan : http://%s:%s' % (lan_ip, wwwport)) client_connect_list.append('lan : python client.py --host %s --port %s' % (lan_ip, port)) if wan_ip: web_list.append('wan : http://%s:%s PS: Maybe need to set up port forwarding' % (wan_ip, wwwport)) client_connect_list.append( 'wan : python client.py --host %s --port %s PS: Maybe need to set up port forwarding' % (wan_ip, port)) click.echo('\r\nAccess console via:') for item in web_list: click.echo(item) click.echo('\r\nClient connection use:') for item in client_connect_list: click.echo(item) click.echo('\r\nListening ...') global_process_var = Manager().dict() GlobalHelper.init(global_process_var) web_ui = Process(target=web_start, args=(global_process_var, host, wwwport)) web_ui.start() global slave_record slave_record = SlaveRecord.get_instance() GlobalHelper.set('salve_record', slave_record.slave_record) socket_server(host, port) web_ui.join()
def _send_posix_mq_connection(client_id, client_hostname): ok_flag = False try: if posix_ipc is not None and not isinstance(client_id, posix_ipc.MessageQueue): if client_hostname == socket.gethostname(): # same host # open a message queue new_mq = _PosixQueue() client_id._pmq = new_mq mq_name = new_mq.names() ok_flag = True except: import traceback traceback.print_exc() finally: if ok_flag: client_id.sendall(protocol.message(protocol.POSIX_MQ_OK, "|".join(mq_name))) return new_mq else: client_id.sendall(protocol.message(protocol.POSIX_MQ_FAILED))
def index(self): start_time = time.time() host = socket.gethostname() # 获取本地主机名 port = 12345 # 设置端口号 s = socket.create_connection((host, port), 30) s.sendall("11") watcher = gevent.get_hub().loop.io(s.fileno(), 1) watcher.start(s.recv(8)) s.close() # s = socket.socket() # 创建 socket 对象 # s.connect((host, port)) # s.send("11") total_time = int((time.time() - start_time) * 1000) events.request_success.fire(request_type="Request", name="test", response_time=total_time, response_length=0)
def metricProducer(self): '''A greenthread which collects the queue metrics at the defined interval.''' self.__run.wait() hostname = socket.gethostname() while self.loop(): for queue in self.pool.listQueues(names=True): for metric, value in list( self.pool.getQueue(queue).stats().items()): metric = Metric(time=time(), type="wishbone", source=hostname, name="module.%s.queue.%s.%s" % (self.name, queue, metric), value=value, unit="", tags=()) event = Wishbone_Event(metric) self.submit(event, self.pool.queue.metrics) sleep(self.frequency)
def pair(self, env): uuid = env['mapper.vault'] if not check_uuid4(uuid): raise HTTPReturn(http.NOT_FOUND) model = instance(Model) vault = model.get_vault(uuid) if not vault: raise HTTPReturn(http.NOT_FOUND) self._do_auth_hmac_cb(uuid) # Sign the certificate request that was sent to tus certinfo = self.entity if not certinfo or not isinstance(certinfo, dict): raise HTTPReturn(http.BAD_REQUEST) model.add_certificate(uuid, certinfo) # And send our own certificate request in return certinfo = { 'node': vault['node'], 'name': socket.gethostname() } certkeys = certinfo['keys'] = {} for key in vault['keys']: certkeys[key] = { 'key': vault['keys'][key]['public'], 'keytype': vault['keys'][key]['keytype'] } return certinfo
def __metricProducer(self): ''' A greenthread collecting the queue metrics at the defined interval. ''' self._run.wait() hostname = socket.gethostname() while self.loop(): for queue in self.pool.listQueues(names=True): for metric, value in list(self.pool.getQueue(queue).stats().items()): event = Wishbone_Event({ "time": time(), "type": "wishbone", "source": hostname, "name": "module.%s.queue.%s.%s" % (self.name, queue, metric), "value": value, "unit": "", "tags": () }) self.submit(event, "_metrics") sleep(self.config.frequency)
def _send_posix_mq_connection(client_id, client_hostname): ok_flag = False try: if (posix_ipc is not None and not isinstance(client_id, posix_ipc.MessageQueue)): if client_hostname == socket.gethostname(): # same host #open a message queue new_mq = _PosixQueue() client_id._pmq = new_mq mq_name = new_mq.names() ok_flag = True except: import traceback traceback.print_exc() finally: if ok_flag: client_id.sendall( protocol.message(protocol.POSIX_MQ_OK, '|'.join(mq_name))) return new_mq else: client_id.sendall(protocol.message(protocol.POSIX_MQ_FAILED))
def __init__(self, host='', port=0, local_hostname=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT): """Initialize a new instance. If specified, `host' is the name of the remote host to which to connect. If specified, `port' specifies the port to which to connect. By default, smtplib.SMTP_PORT is used. If a host is specified the connect method is called, and if it returns anything other than a success code an SMTPConnectError is raised. If specified, `local_hostname` is used as the FQDN of the local host for the HELO/EHLO command. Otherwise, the local hostname is found using socket.getfqdn(). """ self.timeout = timeout self.esmtp_features = {} if host: (code, msg) = self.connect(host, port) if code != 220: raise SMTPConnectError(code, msg) if local_hostname is not None: self.local_hostname = local_hostname else: # RFC 2821 says we should use the fqdn in the EHLO/HELO verb, and # if that can't be calculated, that we should use a domain literal # instead (essentially an encoded IP address like [A.B.C.D]). fqdn = socket.getfqdn() if '.' in fqdn: self.local_hostname = fqdn else: # We can't find an fqdn hostname, so use a domain literal addr = '127.0.0.1' try: addr = socket.gethostbyname(socket.gethostname()) except socket.gaierror: pass self.local_hostname = '[%s]' % addr
def pair(self, env): uuid = env['mapper.vault'] if not check_uuid4(uuid): raise HTTPReturn(http.NOT_FOUND) model = instance(Model) vault = model.get_vault(uuid) if not vault: raise HTTPReturn(http.NOT_FOUND) self._do_auth_hmac_cb(uuid) # Sign the certificate request that was sent to tus certinfo = self.entity if not certinfo or not isinstance(certinfo, dict): raise HTTPReturn(http.BAD_REQUEST) model.add_certificate(uuid, certinfo) # And send our own certificate request in return certinfo = {'node': vault['node'], 'name': socket.gethostname()} certkeys = certinfo['keys'] = {} for key in vault['keys']: certkeys[key] = { 'key': vault['keys'][key]['public'], 'keytype': vault['keys'][key]['keytype'] } return certinfo
def main(): # proxy server part import signal, os global pipe_write pipe_read, pipe_write = os.pipe() def _stop_server(*args): #import os os.close(pipe_write) signal.signal(signal.SIGINT, _stop_server) signal.signal(signal.SIGTERM, _stop_server) import argparse parser = argparse.ArgumentParser() parser.add_argument("--channel-name", dest="channel_name", default=None, help="channel where proxy url is stored") parser.add_argument("--host", dest="host", help="destination host") parser.add_argument("--port", dest="port", type=int, help="destination port") _options = parser.parse_args() tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM) tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) tcp.bind(("", 0)) tcp.listen(16) proxy_port = tcp.getsockname()[1] proxy_host = socket.gethostname() server_url = "%s:%d" % (proxy_host, proxy_port) global dont_reset_channel dont_reset_channel = False def channel_cbk(value): global dont_reset_channel if value != server_url: dont_reset_channel = True try: os.close(pipe_write) except OSError: pass channel_name = _options.channel_name or 'proxy:%s:%d' % (_options.host, _options.port) channel = Channel(channel_name, value=server_url, callback=channel_cbk) runFlag = True fd_list = [tcp, pipe_read] global client global dest client = None dest = None try: while runFlag: rlist, _, _ = select.select(fd_list, [], []) for s in rlist: if s == tcp: accept_flag = True try: if dest is None: dest = socket.socket(socket.AF_INET, socket.SOCK_STREAM) dest.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) dest.connect((_options.host, _options.port)) fd_list.append(dest) except: dest = None accept_flag = False if client is not None: fd_list.remove(client) client.close() client = None client, addr = tcp.accept() if accept_flag: client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) fd_list.append(client) else: client.close() client = None elif s == client: try: raw_data = client.recv(16 * 1024) except: raw_data = None if raw_data: dest.sendall(raw_data) else: fd_list.remove(client) client.close() client = None elif s == dest: try: raw_data = dest.recv(16 * 1024) except: raw_data = None if raw_data: client.sendall(raw_data) else: dest.close() fd_list.remove(dest) dest = None fd_list.remove(client) client.close() client = None elif s == pipe_read: runFlag = False break finally: if dont_reset_channel is False: channel.value = None gevent.sleep(0)
def get_hostname(): return socket.gethostname()
def __init__(self, handler, mcast_ip="239.255.255.250", port=1900): self.ip = socket.gethostbyname(socket.gethostname()) self.mcast_ip = mcast_ip self.port = port self.clients = {} self._handler = handler
#!/usr/bin/python3 from gevent import socket s = socket.socket() host = socket.gethostname() port = 8002 s.bind((host, port)) s.listen(5) s.settimeout(4) while True: while True: try: c, addr = s.accept() break except socket.timeout: print 'timeout' pass try: c.settimeout(4) c.sendall('f**k you') except socket.timeout: print 'timeout sending' break
try: import simplejson as json except ImportError: import json # pyflakes.ignore from . import protocol as nsq from . import errors from .message import Message from .httpclient import HTTPClient from .states import INIT, CONNECTED, DISCONNECTED from .stream import Stream from .decorators import cached_property from .version import __version__ HOSTNAME = socket.gethostname() SHORTNAME = HOSTNAME.split('.')[0] USERAGENT = 'gnsq/%s' % __version__ class Nsqd(HTTPClient): """Low level object representing a TCP or HTTP connection to nsqd. :param address: the host or ip address of the nsqd :param tcp_port: the nsqd tcp port to connect to :param http_port: the nsqd http port to connect to :param timeout: the timeout for read/write operations (in seconds)
def _get_hostname(self): name = socket.gethostname() pos = name.find('.') if pos != -1: name = name[:pos] return name
* round trip info for recent downloads. * failure rate per host ... """ while True: gevent.sleep(SLOT_HEARTBEAT_INTERVAL) self.sched.reportSlots(slot_list) if __name__ == "__main__": if len(argv) != 2: print >> sys.stdout, "Usage: %s <pack_id>" % (os.path.basename(argv[0]), ) sys.exit(-1) ## machine id import socket ip = socket.gethostbyname(socket.gethostname()) if not ip: raise "Need to get IP address as machine Id!" ## pack id pack_id = 0 try: pack_id = int(argv[1]) except ValueError: print >> sys.stdout, "Usage: %s <pack_id>" % (os.path.basename(argv[0]), ) sys.exit(-1) pack = SpiderPack(ip, pack_id, 5) pack.run()