def __init__(self, board, threadno):
self.board = board
self.threadno = threadno
self.sitekey = "6Ldp2bsSAAAAAAJ5uyx_lx34lJeEpTLVkP5k04qc"
self.captcha2_url = "https://www.google.com/recaptcha/api/fallback?k=" + self.sitekey
self.captcha2_payload_url = "https://www.google.com/recaptcha/api2/payload"
self.captcha2_image_base_url = ""
self.site_ref = "https://boards.4chan.org/"
self.user_agent = 'Mozilla/5.0 (X11; Linux x86_64; rv:58.0) Gecko/20100101 Firefox/58.0'
self.captcha2_challenge_text = None # "Select all images with ducks."
self.captcha2_challenge_id = None
self.captcha2_image = "" # Binary image
self.captcha2_image_filename = "yottu-captcha.jpg" # TODO don't save the image
self.captcha2_solution = None # Array of integers associated to the captcha checkboxes, usually 0-8
self.captcha2_response = None # Response the Reply post form wants (the actual solution)
self.lock = thread.allocate_lock()
self.dictOutput = None
self.bp = None
self.dlog = DebugLog()
def __init__(self, stdscr):
self.curses = curses
self.stdscr = stdscr
curses.use_default_colors() # @UndefinedVariable
# assign color to post number, pairs 1-10 are reserved
for i in range(0, curses.COLORS): # @UndefinedVariable
curses.init_pair(i + 10, i, -1) # @UndefinedVariable
# reserved color pairs
curses.init_pair(1, curses.COLOR_BLACK,
curses.COLOR_GREEN) # @UndefinedVariable
curses.init_pair(2, curses.COLOR_YELLOW,
curses.COLOR_GREEN) # @UndefinedVariable
curses.init_pair(3, curses.COLOR_RED,
curses.COLOR_GREEN) # @UndefinedVariable
curses.init_pair(4, curses.COLOR_RED, -1) # @UndefinedVariable
self.dlog = DebugLog(self)
try:
self.cfg = Config()
self.cfg.register(self)
self.sb = None
self.tw = None
self.db = Database(self)
self.tw = ThreadWatcher(self)
self.windowList = [] # Array of all window objects (i.e. Pads)
self.windowListProperties = {
} # Associating a window object with its properties
self.ci = None # Set by CommandInterpreter.__init__()
self.compad = CommandPad(stdscr, self)
self.msgpad = MessagePad(stdscr, self)
self.append_pad(self.compad)
self.append_pad(self.msgpad)
self.set_active_window(0)
self.nickname = ""
# Thread.__init__(self)
# self._stop = threading.Event()
except Exception as err:
self.dlog.excpt(err,
msg=">>>in WindowLogic.__init__()",
cn=self.__class__.__name__)
raise
def __init__(self, argvtest):
self.argvtest = argvtest
self.debug = DebugLog(argvtest.debugFileGet())
self.yinParse = YinOutput(self.debug, argvtest)
self.keyword = None
self.argument = None
self.stringstart = StringStart.NO
self.keywordtype = KeywordType.NONE
self.statementstate = StatementState.KEYWORD
self.yangRegularExpressions = [
(r'(/\*.*?\*/)', re.DOTALL, self.commentFunc),
(r'(//.*?\n)', 0, self.commentFunc),
(r'\s+', 0, self.whitespaceFunc),
(r';', 0, self.semicolonFunc),
(r'{', 0, self.openBraceFunc),
(r'}', 0, self.closeBraceFunc),
(r'(contact|description|fraction-digits|must|organization|presence|reference)',
0, self.keywordTextFunc),
(r'(action|anydata|anyxml|argument|augment|base|belongs-to|bit|case|choice|config|container|default|deviate|deviation|enum|error-app-tag|error-message|extension|feature|grouping|identity|if-feature|import|include|input|key|leaf-list|leaf|length|list|mandatory|max-elements|min-elements|modifier|module|namespace|notification|ordered-by|output|path|pattern|position|prefix|range|refine|require-instance|revision-date|revision|rpc|status|submodule|typedef|type|unique|units|uses|value|when|yang-version|yin-element)',
0, self.keywordAllTheRestFunc),
(r'([_A-Za-z][._\-A-Za-z0-9]*):([_A-Za-z][._\-A-Za-z0-9]*)', 0,
self.prefixExtensionFunc),
(r'([^\s\'\";{}]+)', re.DOTALL, self.unquotedStringFunc
), # additional filtering required of comment sequences
(r'\'(.*?)\'', re.DOTALL, self.quotedStringFunc),
(r'\"(.*?)\"', re.DOTALL, self.quotedStringFunc)
]
self.reCompiled = []
self.reCount = len(self.yangRegularExpressions)
for index in range(self.reCount):
data = self.yangRegularExpressions[index]
regex = data[0]
flags = data[1]
refunc = re.compile(regex, flags)
self.reCompiled.append(refunc)
self.inputFile = argvtest.yangFileGet()
self.outputFile = argvtest.yinoutFileGet()
self.handleinputfile = io.open(self.inputFile, "r", encoding="utf-8")
self.handleoutputfile = io.open(self.outputFile, "w", encoding="utf-8")
self.inputfilecontents = self.handleinputfile.read()
self.handleinputfile.close()
self.yangimport = YangImport(self.debug, self.inputfilecontents,
argvtest.yangDirsGet())
self.root = None
self.makeGeneralTree()
# Set up options
usage = """usage: %prog [options]
"""
parser = OptionParser(usage)
parser.add_option("-d",
"--debug_messages",
action="store_true",
dest="debug_messages",
default=False,
help="print debug messages to stdout")
## fetch the args
(options, args) = parser.parse_args()
debug_handle = DebugLog()
debug_handle.init()
class map_type:
def __init__(self):
self.description = "This is a map tile."
def __str__(self):
return str(self.description)
class at_location:
def __init__(self):
self.inventory = []
def __init__(self,
gc,
bfrt_info,
switch_ip,
switch_mac,
switch_udp_port=0xbee0,
switch_udp_port_mask=0xfff0,
workers=None,
ports_file=None,
job_file=None):
# call Cmd constructor
super(Job, self).__init__()
self.intro = "SwitchML command loop. Use 'help' or '?' to list commands."
self.prompt = "-> "
# capture connection state
self.gc = gc
self.bfrt_info = bfrt_info
# set up RPC server
self.grpc_server = GRPCServer()
# self.thrift_connection = ThriftInterface('switchml', '127.0.0.1')
# self.thrift_client = self.thrift_connection.setup()
# self.conn_mgr = self.thrift_connection.conn_mgr
# self.sess_hdl = self.thrift_connection.conn_mgr.client_init()
# print('Connected to Device %d, Session %d' % (self.dev_id, self.sess_hdl))
# set up ports object
self.ports = Ports(self.gc, self.bfrt_info)
self.ports.enable_loopback_ports()
# capture job state
self.switch_mac = switch_mac
self.switch_ip = switch_ip
self.switch_udp_port = switch_udp_port
self.switch_udp_port_mask = switch_udp_port_mask
self.switch_partition_key = 0xffff
self.workers = workers
# set swithcml MGID and all nodes MGID
self.switchml_workers_mgid = 0x1234
self.all_ports_mgid = 0x1235
# allocate storage
self.registers_to_clear = []
self.tables_to_clear = []
self.counters_to_clear = []
#
# create objects for each block
#
self.arp_and_icmp = ARPandICMP(self.gc, self.bfrt_info)
self.get_worker_bitmap = GetWorkerBitmap(self.gc, self.bfrt_info)
self.tables_to_clear.append(self.get_worker_bitmap)
self.counters_to_clear.append(self.get_worker_bitmap)
self.rdma_receiver = RDMAReceiver(self.gc, self.bfrt_info)
self.tables_to_clear.append(self.rdma_receiver)
self.counters_to_clear.append(self.rdma_receiver)
# add update rules for bitmap and clear register
self.update_and_check_worker_bitmap = UpdateAndCheckWorkerBitmap(
self.gc, self.bfrt_info)
self.registers_to_clear.append(self.update_and_check_worker_bitmap)
# add rules for worker count and clear register
self.count_workers = CountWorkers(self.gc, self.bfrt_info)
self.registers_to_clear.append(self.count_workers)
# add rules for exponent max calculation and clear register
self.exponent_max = ExponentMax(self.gc, self.bfrt_info)
self.registers_to_clear.append(self.exponent_max)
# add rules for data registers and clear registers
self.significands = []
for i in range(32):
x = SignificandSum(self.gc, self.bfrt_info, i)
self.significands.append(x)
self.registers_to_clear.append(x)
# self.significands_00_01_02_03 = SignificandStage(self.gc, self.bfrt_info, 0, 1, 2, 3)
# self.registers_to_clear.append(self.significands_00_01_02_03)
# self.significands_04_05_06_07 = SignificandStage(self.gc, self.bfrt_info, 4, 5, 6, 7)
# self.registers_to_clear.append(self.significands_04_05_06_07)
# self.significands_08_09_10_11 = SignificandStage(self.gc, self.bfrt_info, 8, 9, 10, 11)
# self.registers_to_clear.append(self.significands_08_09_10_11)
# self.significands_12_13_14_15 = SignificandStage(self.gc, self.bfrt_info, 12, 13, 14, 15)
# self.registers_to_clear.append(self.significands_12_13_14_15)
# self.significands_16_17_18_19 = SignificandStage(self.gc, self.bfrt_info, 16, 17, 18, 19)
# self.registers_to_clear.append(self.significands_16_17_18_19)
# self.significands_20_21_22_23 = SignificandStage(self.gc, self.bfrt_info, 20, 21, 22, 23)
# self.registers_to_clear.append(self.significands_20_21_22_23)
# self.significands_24_25_26_27 = SignificandStage(self.gc, self.bfrt_info, 24, 25, 26, 27)
# self.registers_to_clear.append(self.significands_24_25_26_27)
# self.significands_28_29_30_31 = SignificandStage(self.gc, self.bfrt_info, 28, 29, 30, 31)
# self.registers_to_clear.append(self.significands_28_29_30_31)
# add workers to multicast groups.
self.cpu_port = 320 # dev port for CPU mirroring
self.pre = PRE(self.gc, self.bfrt_info, self.ports,
self.switchml_workers_mgid, self.all_ports_mgid,
self.cpu_port)
self.mirror = Mirror(self.gc, self.bfrt_info, self.cpu_port)
# set up drop simulator
self.drop_simulator = DropSimulator(self.gc, self.bfrt_info)
self.tables_to_clear.append(self.drop_simulator)
# setup debug log
self.debug_log = DebugLog(self.gc, self.bfrt_info)
self.tables_to_clear.append(self.debug_log)
self.registers_to_clear.append(self.debug_log)
# set up counters in next step table
self.next_step = NextStep(self.gc, self.bfrt_info)
self.tables_to_clear.append(self.next_step)
# add workers to non-switchml forwarding table
self.non_switchml_forward = NonSwitchMLForward(self.gc, self.bfrt_info,
self.ports,
self.all_ports_mgid)
# now add workers to set_dst_addr table in egress
self.set_dst_addr = SetDstAddr(self.gc, self.bfrt_info,
self.switch_mac, self.switch_ip)
self.tables_to_clear.append(self.set_dst_addr)
self.counters_to_clear.append(self.set_dst_addr)
self.rdma_sender = RDMASender(self.gc, self.bfrt_info, self.switch_mac,
self.switch_ip)
#message_size = 1 << 12,
#message_size = 1 << 10, #32768, #16384, #4096, #1024,
#message_size = 1 << 11,
#packet_size = 256)
self.tables_to_clear.append(self.rdma_sender)
self.counters_to_clear.append(self.rdma_sender)
# do this last to print more cleanly
self.counters_to_clear.append(self.next_step)
# # configure job
# self.configure_job()
# If list of worker objects isn't provided, expect to load worker info from yaml files
if self.workers:
for worker in self.workers:
self.port_add(worker.front_panel_port, worker.lane,
worker.speed, worker.fec)
self.mac_address_add(worker.mac, worker.front_panel_port,
worker.lane)
elif ports_file:
self.port_load_file(ports_file)
if self.switch_mac and self.switch_ip:
self.arp_and_icmp.add_switch_mac_and_ip(self.switch_mac,
self.switch_ip)
# start listening for RPCs
self.grpc_server.serve(self)
