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 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):
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 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 make_socket(af, stype, proto, protoinfo):
return socket.fromshare(protoinfo)
def fromshare(*args, **kwargs):
return from_stdlib_socket(_stdlib_socket.fromshare(*args, **kwargs))
# взаимодействия), 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]) # Возвращает полное доменное имя
