def bind_socket(self): sock = socket.socket() sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: sock.bind((self.host, self.port)) except OSError as exc: logger.error(exc) sys.exit(1) sock.set_inheritable(True) if platform.system() == "Windows" and (self.workers > 1 or self.should_reload): # We need to explicitly share the socket on Windows. sock = socket.fromshare(sock.share(os.getpid())) message = "Uvicorn running on %s://%s:%d (Press CTRL+C to quit)" color_message = ("Uvicorn running on " + click.style("%s://%s:%d", bold=True) + " (Press CTRL+C to quit)") protocol_name = "https" if self.is_ssl else "http" logger.info( message, protocol_name, self.host, self.port, extra={"color_message": color_message}, ) return sock
def detach(self): conn = resource_sharer.get_connection(self._id) try: share = conn.recv_bytes() return socket.fromshare(share) finally: conn.close()
def start_worker(pipeout): parsecli() httpd = ThreadedTCPServer((LISTEN, PORT), Proxy, bind_and_activate=False) mainsock = socket.fromshare(pipeout.recv()) httpd.socket = mainsock serve_forever(httpd)
def _share_socket(sock: socket) -> socket: # Windows requires the socket be explicitly shared across # multiple workers (processes). from socket import fromshare # type: ignore sock_data = sock.share(getpid()) # type: ignore return fromshare(sock_data)
def start_worker(pipeout): parse_config() httpd = ThreadedTCPServer((State.config.get( "proxy", "listen").strip(), State.config.getint("proxy", "port")), Proxy, bind_and_activate=False) mainsock = socket.fromshare(pipeout.recv()) httpd.socket = mainsock serve_forever(httpd)
def getChallengesSocket(self, is_challenges_socket_in_input=False): try: if not is_challenges_socket_in_input: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind( (LOCALHOST, self.configuration["QUARTERMASTER_PORT"])) sock.listen(SOMAXCONN) return sock except Exception: return None challenges_socket_base64 = input() shared_challenges_socket = base64.b64decode(challenges_socket_base64) return socket.fromshare(shared_challenges_socket)
def _recv_listening_sock(self, source_sock): # Other end needs our PID to prepare a handle for us source_sock.sendall(dword.pack(os.getpid(), )) handle_bytes = bytearray(source_sock.recv(8)) if handle_bytes: expected_fd_bytes_length = handle_bytes[0] + 1 while len(handle_bytes) < expected_fd_bytes_length: recvd_bytes = source_sock.recv(8) if not recvd_bytes: # Socket closed during hand-over handle_bytes = b'' break handle_bytes += recvd_bytes if handle_bytes: self._socket = socket.fromshare(handle_bytes) return True return False
def main(): # safeguard in case someone accidentally runs this module if len(sys.argv) < 2 or sys.argv[1] != _serve_arg: return debug_level, options = pickle.loads(base64.b64decode(sys.argv[2])) set_debug_level(debug_level) if _windows: sock = socket.fromshare(sys.stdin.buffer.read()) else: family = int(sys.argv[3]) sock = socket.fromfd(0, family, socket.SOCK_STREAM) devnull_fd = os.open(os.devnull, os.O_RDONLY) os.dup2(devnull_fd, 0) os.close(devnull_fd) try: with Connection.from_socket(sock, options=options) as conn: conn.wait() except KeyboardInterrupt: raise SystemExit
def load_socket(data): if platform.system() == 'Windows': return socket.fromshare(data) return socket.socket(fileno=data)
share_sock_buff = self._sock.share(worker.pid) self._ioutils.write_file( wfd, struct.pack('<I', len(share_sock_buff)), 4) self._ioutils.write_file(wfd, share_sock_buff, len(share_sock_buff)) self._launcher.wait() if __name__ == '__main__': configure_logging() if args.pipe_handle: pipe_handle = int(args.pipe_handle) ioutils = os_win_utilsfactory.get_ioutils() buff = ioutils.get_buffer(4) ioutils.read_file(pipe_handle, buff, 4) socket_buff_sz = struct.unpack('<I', buff)[0] socket_buff = ioutils.get_buffer(socket_buff_sz) ioutils.read_file(pipe_handle, socket_buff, socket_buff_sz) ioutils.close_handle(pipe_handle) sock = socket.fromshare(bytes(socket_buff[:])) worker_count = 0 else: sock = None worker_count = WORKER_COUNT sv = Server(app, worker_count, sock) sv.start()
def detach(self): '''Get the socket. This should only be called once.''' with _resource_sharer.get_connection(self._id) as conn: share = conn.recv_bytes() return socket.fromshare(share)
def update_event(self, inp=-1): self.set_output_val(0, socket.fromshare(self.input(0)))
def fromshare(*args, **kwargs): return from_stdlib_socket(_stdlib_socket.fromshare(*args, **kwargs))
dayhigh = cls.HIGH[input // 10] daylow = cls.LOW[input % 10] return dayhigh + daylow ############################################################################ ############################################################################ init = True ghost = False for retry in range(100): try: if len(sys.argv) > 1: while not os.path.isfile("socket"): pass with open("socket", "rb") as thing2: s = socket.fromshare(thing2.read()) os.remove("socket") init = False BOT.CHANNEL = sys.argv[1] sendmsg("Done! " + repr(time.time() - float(sys.argv[2]))[:4] + " seconds") else: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((BOT.HOST, BOT.PORT)) send("NICK " + BOT.NICK) send("USER " + BOT.IDENT + " " + BOT.HOST + " CaffieNET :" + BOT.REALNAME) except (socket.error, socket.gaierror): time.sleep(5) print(retry) if not retry:
def make_socket(af, stype, proto, protoinfo): return socket.fromshare(protoinfo)
# взаимодействия), AF_INET (семейство сокетов для web взаимодействия). # Параметр type может представлять собой SOCK_STREAM (TCP) или # SOCK_DGRAM (UDP) s.socketpair([family[, type[, proto]]]) # создание пары объектов сокета на основе указанных параметров: # семейство адресов, тип сокета и тип протокола (необязательно) s.create_connection(address[, timeout[, source_address]]) # Вспомогательная функция, которая принимает пару параметров # определения адреса (хост, порт) и возвращает объект socket s.fromfd(fd, family, type, proto=0) # Создание объекта сокета на основе дескриптора открытого файла s.fromshare(data) # Выполняет инициализацию сокета из данных, полученных из метода # socket.share(). Предполагается, что сокет находится в режиме # блокировки. s.SocketType # Это объект типа Python, который представляет тип объекта сокета. # Это то же самое, что и type(socket(...)). s.getaddrinfo(host, port, family=0, type=0, proto=0, flags=0) # Получает информацию адреса в виде последовательности # пятиэлементных кортежей s.getfqdn([name]) # Возвращает полное доменное имя