print("Needs IP as arguement")
sys.exit()
ip = sys.argv[1]
def loadCookie():
global cookie
cookie = "NULL"
if (os.path.isfile("cookie")):
cookie = open("cookie", "r").read()
print("Loaded cookie")
return cookie
socketSemaphore = threading.BoundedSemaphore(1)
cookie = loadCookie()
def saveCookie():
global cookie
open("cookie", "w").write(cookie)
print("saved cookie")
def main():
postDaemon = threading.Thread(target=postReader, daemon=True)
postDaemon.start()
while True:
m = input()
reply = sendToSocket(m, ip)
download_history = open(
os.path.join(output_dir, 'download_history.pickle'), 'rb')
tried_urls = pickle.load(download_history)
image_md5s = pickle.load(download_history)
download_history.close()
except (OSError, IOError):
tried_urls = []
if adult_filter:
adlt = ''
else:
adlt = 'off'
if args.adult_filter_off:
adlt = 'off'
elif args.adult_filter_on:
adlt = ''
pool_sema = threading.BoundedSemaphore(args.threads)
if args.search_string:
fetch_images_from_keyword(pool_sema, args.search_string, output_dir,
args.filters, args.limit)
elif args.search_file:
try:
inputFile = open(args.search_file)
except (OSError, IOError):
print("Couldn't open file {}".format(args.search_file))
exit(1)
for keyword in inputFile.readlines():
output_sub_dir = os.path.join(output_dir_origin,
keyword.strip().replace(' ', '_'))
if not os.path.exists(output_sub_dir):
os.makedirs(output_sub_dir)
fetch_images_from_keyword(pool_sema, keyword, output_sub_dir,
import requests
import threading
thread_lock = threading.BoundedSemaphore(value=10)
# 传入参数得到字典
def get_page(url,lib,start):
date = {'kw':'{}'.format(lib),'limit':1000,'start':start}
r = requests.get(url,params=date)
return r.json()
#解析字典的到图片地址
def jiexi(resul):
l = []
urls = resul['data']['object_list']
for ch in urls:
l.append(ch['photo']['path'])
return l
# 输入关键字拿到总共的图片;改变地址 去拿到所有的图片链接
def urls(url,lib):
l1=[]
for start in range(0,1000,100):
page = get_page(url,lib,start)
l = jiexi(page)
l1.extend(l)
return l1
def image(ch,n):
data = requests.get(ch)
def run_tests(tests, verbose=1, cluster_queue=None, tot_nprocs=0):
'''Run tests.
tests: list of tests.
verbose: level of verbosity in output.
cluster_queue: name of cluster system to use. If None, tests are run locally.
Currently only PBS is implemented.
tot_nprocs: total number of processors available to run tests on. As many
tests (in a LIFO fashion from the tests list) are run at the same time as
possible without using more processors than this value. If less than 1 and
cluster_queue is specified, then all tests are submitted to the cluster at
the same time. If less than one and cluster_queue is not set, then
tot_nprocs is ignored and the tests are run sequentially (default).
'''
def run_test_worker(semaphore, semaphore_lock, tests, *run_test_args):
'''Launch a test after waiting until resources are available to run it.
semaphore: threading.Semaphore object containing the number of cores/processors
which can be used concurrently to run tests.
semaphore.lock: threading.Lock object used to restrict acquiring the semaphore
to one thread at a time.
tests: list of (serialized) tests to run in this thread.
run_test_args: arguments to pass to test.run_test method.
'''
# Ensure that only one test attempts to register resources with the
# semaphore at a time. This restricts running the tests to a LIFO
# fashion which is not perfect (we don't attempt to backfill with
# smaller tests, for example) but is a reasonable and (most
# importantly) simple first-order approach.
for test in tests:
semaphore_lock.acquire()
# test.nprocs is <1 when program is run in serial.
nprocs_used = max(1, test.nprocs)
for i in range(nprocs_used):
semaphore.acquire()
semaphore_lock.release()
test.run_test(*run_test_args)
for i in range(nprocs_used):
semaphore.release()
# Check executables actually exist...
compat = testcode2.compatibility
executables = [test.test_program.exe for test in tests]
executables = compat.compat_set(executables)
for exe in executables:
mswin = sys.platform.startswith('win') or sys.platform.startswith(
'cyg')
# The test is not reliable if there's an unholy combination of windows
# and cygwin being used to run the program. We've already warned the
# user (in config.set_program_name) that we struggled to find the
# executable.
if not os.path.exists(exe) and not mswin:
err = 'Executable does not exist: %s.' % (exe)
raise testcode2.exceptions.TestCodeError(err)
if tot_nprocs <= 0 and cluster_queue:
# Running on cluster. Default to submitting all tests at once.
tot_nprocs = sum(test.nprocs for test in tests)
if tot_nprocs > 0:
# Allow at most tot_nprocs cores to be used at once by tests.
max_test_nprocs = max(test.nprocs for test in tests)
if max_test_nprocs > tot_nprocs:
err = (
'Number of available cores less than the number required by '
'the largest test: at least %d needed, %d available.' %
(max_test_nprocs, tot_nprocs))
raise testcode2.exceptions.TestCodeError(err)
# Need to serialize tests that run in the same directory with wildcard
# patterns in the output file--otherwise we can't figure out which
# output file belongs to which test. We might be able to for some
# wildcards, but let's err on the side of caution.
wildcards = re.compile('.*(\*|\?|\[.*\]).*')
serialized_tests = []
test_store = {}
for test in tests:
if test.output and wildcards.match(test.output):
if test.path in test_store:
test_store[test.path].append(test)
else:
test_store[test.path] = [test]
else:
serialized_tests.append([test])
for (key, stests) in test_store.items():
if (len(stests) > 1) and verbose > 2:
print('Warning: cannot run tests in %s concurrently.' %
stests[0].path)
serialized_tests += test_store.values()
semaphore = threading.BoundedSemaphore(tot_nprocs)
slock = threading.Lock()
jobs = [
threading.Thread(target=run_test_worker,
args=(semaphore, slock, test, verbose,
cluster_queue, os.getcwd()))
for test in serialized_tests
]
for job in jobs:
# daemonise so thread terminates when master dies
try:
job.setDaemon(True)
except AttributeError:
job.daemon = True
job.start()
# We avoid .join() which is blocking making it unresponsive to TERM
while threading.activeCount() > 1:
time.sleep(0.5)
else:
# run straight through, one at a time
for test in tests:
test.run_test(verbose, cluster_queue, os.getcwd())
import flask as f
import samehadaku as s
import time
import base64 as b64
import requests
import threading
app = f.Flask(__name__, template_folder='.')
app.cache = {}
app.init_time = time.time()
app.bounded_semaphore = threading.BoundedSemaphore(12)
app.client_bounded_semaphore_list = {}
@app.before_request
def br():
if time.time() - app.init_time >= 2*60*60:
app.cache = {}
app.init_time = time.time()
if f.request.endpoint in ['query', 'get_dl']:
ip_addr = f.request.remote_addr
if ip_addr not in app.client_bounded_semaphore_list:
app.client_bounded_semaphore_list[ip_addr] = threading.BoundedSemaphore(
3)
app.client_bounded_semaphore_list[ip_addr].acquire()
@app.after_request
def ar(resp):
try:
ip_addr = f.request.remote_addr
from flask import Flask
from flask_restful import Resource, Api
import boto3
import requests
import time, threading
from threading import Thread
import os
import logging
import json
logging.basicConfig(level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(message)s")
max_number_of_threads = 15
thread_limiter = threading.BoundedSemaphore(max_number_of_threads)
def rate_limitter(max_per_second: int):
"""Limits rate of function call to `max_per_second`."""
min_interval = 1.0 / float(max_per_second)
lock = threading.Lock()
def decorate(func):
last_time_called = [0.0]
def function_call(args, **kargs):
lock.acquire()
elapsed = time.perf_counter() - last_time_called[0]
wait = min_interval - elapsed
if wait > 0:
time.sleep(wait)
str(self.poli) + " page_size:" + str(self.page) + " tlb_size:" +
str(self.tlb) + " total_handled:" + str(total_handled) +
" total_misses:" + str(total_misses) + " total_hits:" +
str(total_hits) + " miss_rate:" + misses_rate)
data.append(
str(self.pro) + " " + str(self.ins) + " " + str(self.tlb) + " " +
str(self.poli) + " " + str(self.page) + " " + str(misses_rate))
threadLock.release()
threadLimiter.release()
if __name__ == "__main__":
threadLock = threading.Lock()
threadLimiter = threading.BoundedSemaphore(12)
for pro in program:
for ins in ins_size:
for tlb in tlb_size:
for p in policy:
for page in page_size:
t = mythread(p, page, tlb, pro, ins)
t.start()
t.join()
i = len(page_size) * len(tlb_size) * len(policy)
j = 0
filedata = {}
misses_rate = []
for dat in data:
from pytube import YouTube
from moviepy.editor import *
import argparse
import moviepy.editor as mp
import re
import os
from tkinter import Tk
import threading
import time
root = Tk()
linkBuffer = []
semaphor = threading.Semaphore(0)
MAX_YOUTUBE_DL_THREADS = 5
maxthreads = threading.BoundedSemaphore(MAX_YOUTUBE_DL_THREADS)
parser = argparse.ArgumentParser(description='Process the file')
parser.add_argument('--targetd',type=str,help='target directory to place the grabbed files',required=True)
args = parser.parse_args()
def getClipboard():
x = root.clipboard_get()
return x
def watch_clipboard():
print("creating clipboard module.....")
new = getClipboard()
while True:
old = getClipboard()
import time as t
number = 0
lock = td.Lock()
def hello():
print("hello, world")
def plug(lk):
global number
with lk:
for _ in range(1000000):
number += 1
print("子线程%s运算结束后，number = %s" % (td.current_thread().getName(), number))
# print("run the thread: %s" % n)
if __name__ == '__main__':
semaphore = td.BoundedSemaphore(1)
for i in range(6):
d = td.Thread(target=plug, args=(lock,))
# d = td.Thread(target=plug, args=(i, semaphore))
d.start()
ts = Timer(3, hello)
ts.start()
# t.sleep(2)
# print("主线程执行完毕后，number = ", number)
def __init__(self, host, ports):
self.threads = 25
self.host = host
self.ports = ports
self.lock = threading.BoundedSemaphore(value=self.threads)
def _prepare_appcache(self) -> None:
dbname = os.path.join(config.APPCACHE,
os.path.basename(self.script_name))
self.__appcache = shelve.open(dbname, flag="c", writeback=False)
self.__appcache_mutex = threading.BoundedSemaphore(value=1)
def __init__(self):
self.client = connector.ZVMConnector(connection_type='socket',
ip_addr=CONF.sdkserver.bind_addr,
port=CONF.sdkserver.bind_port)
self.dd_semaphore = threading.BoundedSemaphore(
value=CONF.wsgi.max_concurrent_deploy_capture)
asm_command = "arm-none-eabi-gcc -c {USECOLOR} -o output/{OUTPUT_FILE} {ASMFLAGS} {INPUT_FILE}"
compile_command = "arm-none-eabi-gcc -c {USECOLOR} -o output/{OUTPUT_FILE} {CFLAGS} {INPUT_FILE}"
link_command = "arm-none-eabi-gcc {USECOLOR} -o output/{OUTPUT_NAME}.elf {OBJS} {LDFLAGS}"
size_command = "arm-none-eabi-size output/{OUTPUT_NAME}.elf"
copy_obj_command = "arm-none-eabi-objcopy -O binary output/{OUTPUT_NAME}.elf output/{OUTPUT_NAME}.bin"
#excluded_files = [
# ".*_template.c",
#]
THREAD_LIMIT = args.threads
threadLimiter = threading.BoundedSemaphore(THREAD_LIMIT)
locker = threading.Lock()
threadRunning = list()
isStop = False
def find_between(s, first, last):
try:
start = s.index(first)
end = s.index(last, start)
return s[start:end]
except ValueError:
return ""
class CommandRunnerThread(threading.Thread):
if args.nocerts:
s = ssl.wrap_socket(s, cert_reqs=ssl.CERT_NONE)
else:
s = ssl.wrap_socket(s,
keyfile=args.key,
certfile=args.cert,
ca_certs=args.rootca,
cert_reqs=ssl.CERT_REQUIRED)
s.connect((args.host, args.port))
print s.getpeercert()
lastRequestTime = 0.0
# Allow only one transaction at a time
transactSema = threading.BoundedSemaphore(1)
def outputPrinter(s):
"""Print the output in a separate thread."""
try:
while True:
n = s.recv(1)
if n == "":
raise RuntimeError("socket connection broken")
chunks = []
received = 0
n = ord(n)
while received < n:
chunk = s.recv(n - received)
import threading, time
def run(n):
semaphore.acquire() #调用acquire时计数器-1
time.sleep(2.5)
print("run the thread: %s\n" % n)
semaphore.release() #调用release时计数器+1
num = 0
semaphore = threading.BoundedSemaphore(2) # 最多允许5个线程同时运行
for i in range(20):
t = threading.Thread(target=run, args=(i,))
t.start()
while threading.active_count() != 1:
pass
# print(threading.active_count())
else:
print('----all threads done---')
#print(num)
parser.add_argument('--verbose',
help="Verbose output for checking of commands",
action='store_true')
parser.add_argument(
'--threads',
help="Number of connection threads when checking file of IPs (default 10)",
default="10")
args = parser.parse_args()
ip = args.ip
filename = args.file
net = args.net
timeout = args.timeout
verbose = args.verbose
num_threads = int(args.threads)
semaphore = threading.BoundedSemaphore(value=num_threads)
print_lock = threading.Lock()
def calculate_doublepulsar_xor_key(s):
x = (2 * s ^ (((s & 0xff00 | (s << 16)) << 8) |
(((s >> 16) | s & 0xff0000) >> 8)))
x = x & 0xffffffff # this line was added just to truncate to 32 bits
return x
def print_status(ip, message):
global print_lock
with print_lock:
print "[*] [%s] %s" % (ip, message)
import logging
import multiprocessing
import os
import time
import threading
from . import style, util, linter as linter_module
logger = logging.getLogger(__name__)
WILDCARD_SYNTAX = '*'
MAX_CONCURRENT_TASKS = multiprocessing.cpu_count() or 1
task_count = count(start=1)
counter_lock = threading.Lock()
process_limit = threading.BoundedSemaphore(MAX_CONCURRENT_TASKS)
def lint_view(linters, view, view_has_changed, next):
"""Lint the given view.
This is the top level lint dispatcher. It is called
asynchronously.
"""
lint_tasks = get_lint_tasks(linters, view, view_has_changed)
run_concurrently(
partial(run_tasks, tasks, next=partial(next, linter))
for linter, tasks in lint_tasks)
def __init__(self, iterable=dict()):
# s는 semaphore
self.d = iterable
self.s = threading.BoundedSemaphore(1) # s의 초기값 1, 항상 0 <= s <= 1
file_list.extend(gfile.Glob(file_glob))
if not file_list:
print('No files found')
continue
#create sub-directory in destination
sub_folder = os.path.join(FLAGS.dest_image_dir, dir_name)
if not gfile.Exists(sub_folder):
try:
tf.io.gfile.mkdir(sub_folder)
except:
print("Could not create directory '" + sub_folder + "'",
file=sys.stderr)
continue
semaphore = threading.BoundedSemaphore(FLAGS.cores)
for file_name in file_list:
base_name = os.path.basename(file_name)
print("Scaling file '" + base_name + "'")
colorImage = Image.open(
os.path.abspath(os.path.join(FLAGS.src_image_dir, file_name)))
prefix_name = os.path.abspath(
os.path.join(FLAGS.dest_image_dir, dir_name,
os.path.splitext(base_name)[0]))
file_extention = os.path.splitext(file_name)[1]
semaphore.acquire() #decrease counter
#scale image size
t = threading.Thread(target=tranform_data,
import zipfile
'''
使用方法：
urls.txt用于存放目标HOST，然后直接运行此脚本即可 python POC.py
漏洞验证成功的目标存放于success.txt，连接失败的错误信息存放于error.txt中
'''
#消除安全请求的提示信息,增加重试连接次数
urllib3.disable_warnings()
requests.adapters.DEFAULT_RETRIES = 4
s = requests.session()
s.keep_alive = False #关闭连接，防止出现最大连接数限制错误
urllib3.util.ssl_.DEFAULT_CIPHERS += 'HIGH:!DH:!aNULL' #openssl 拒绝短键，防止SSL错误
# 设置最大线程数
thread_max = threading.BoundedSemaphore(value=150)
#HTTP请求-head头
headers = {
'User-Agent':
'Mozilla/5.0 (Macintosh; Intel Mac OS X 12_10) AppleWebKit/600.1.25 (KHTML, like Gecko) Version/12.0 Safari/1200.1.25',
}
proxies = {
'http': 'socks5://127.0.0.1:1081',
'https': 'socks5://127.0.0.1:1081'
}
targets = [] #定义目标列表
threads = [] #定义线程池
import threading, time
def run(n):
semaphore.acquire()
time.sleep(1)
print("run the thread:%s\n" % n)
semaphore.release()
if __name__ == '__main__':
num = 0
semaphore = threading.BoundedSemaphore(3)
for i in range(20):
t = threading.Thread(target=run, args=(i, ))
t.start()
# while threading.active_count() != 1:
# print(threading.active_count())
# else:
# print('-----all threads done----')
# print(num)
# Output:
# 0
# Semaphore
# 管理一个内置的计数器, 每当调用acquire()时-1, 调用release()时+1
# 计数器不能小于0; 当计数器为0时, acquire()将阻塞线程至同步锁定状态, 直到其他线程调用
# release()
# 注意: 同时acquire semaphore的线程仍然可能会有race condition
# BoundedSemaphore
# 在Semaphore的基础上, 不允许计数器超过initial value (设置上限)
# A bounded semaphore with initial value 2
bounded_sema = threading.BoundedSemaphore(value=2)
def func() -> None:
"""
Dummy function.
:return: None
"""
thread_name = threading.current_thread().name
# 请求Semaphore, 成功后计数器-1
print('{th_name} acquiring semaphore...'.format(th_name=thread_name))
# Note that BoundedSemaphore objects can be used in a traditional way, i.e.,
# via acquire() and release() methods, but it can also simply be used as a
# context manager, as a syntax sugar
with bounded_sema: # 释放Semaphore的时候, 计数器+1
print('{th_name} gets semaphore'.format(th_name=thread_name))
def __init__(self, subdomains, ports):
self.subdomains = subdomains
self.ports = ports
self.threads = 20
self.lock = threading.BoundedSemaphore(value=self.threads)
def _calculate_sha256_internal(src_list, sizes, results):
total_size = sum(
size
for size, result in zip(sizes, results)
if result is None or isinstance(result, Exception)
)
# This controls how many parts can be stored in the memory.
# This includes the ones that are being downloaded or hashed.
# The number was chosen empirically.
s3_max_pending_parts = MAX_CONCURRENCY * 4
stopped = False
def get_file_chunks(src, size):
with open(src.path, 'rb') as file:
yield from read_file_chunks(file)
current_file_size = file.tell()
if current_file_size != size:
warnings.warn(
f"Expected the package entry at {src!r} to be {size} B in size, but "
f"found an object which is {current_file_size} B instead. This "
f"indicates that the content of the file changed in between when you "
f"included this entry in the package (via set or set_dir) and now. "
f"This should be avoided if possible."
)
def _process_url(src, size):
hash_obj = hashlib.sha256()
generator, exceptions_to_retry = (
(get_file_chunks(src, size), ())
if src.is_local() else
(
_calculate_hash_get_s3_chunks(s3_context, src, size),
(ConnectionError, HTTPClientError, ReadTimeoutError)
)
)
try:
for chunk in generator:
hash_obj.update(chunk)
progress_update(len(chunk))
if stopped:
return
except exceptions_to_retry as e:
return e
else:
return hash_obj.hexdigest()
finally:
# We want this generator to be finished immediately,
# so it finishes its own tasks.
del generator
with tqdm(desc="Hashing", total=total_size, unit='B', unit_scale=True, disable=DISABLE_TQDM) as progress, \
ThreadPoolExecutor() as executor, \
ThreadPoolExecutor(
MAX_CONCURRENCY,
thread_name_prefix='s3-executor',
) as s3_executor:
s3_context = types.SimpleNamespace(
find_correct_client=with_lock(S3ClientProvider().find_correct_client),
pending_parts_semaphore=threading.BoundedSemaphore(s3_max_pending_parts),
executor=s3_executor,
)
progress_update = with_lock(progress.update)
future_to_idx = {
executor.submit(_process_url, src, size): i
for i, (src, size, result) in enumerate(zip(src_list, sizes, results))
if result is None or isinstance(result, Exception)
}
try:
for future in concurrent.futures.as_completed(future_to_idx):
results[future_to_idx.pop(future)] = future.result()
finally:
stopped = True
while future_to_idx:
future, idx = future_to_idx.popitem()
future.cancel()
return results
host = 'HOSTBBDD'
userbbdd = 'USERBBDD'
bbddpass = '******'
host2 = 'HOSTBBDD2'
userbbdd2 = 'USERBBDD2'
bbddpass2 = 'PASSBBDD2'
password_read = 'PASS_OF_YOUR_TAGS'
# TIME LOOP
t_end = time.time() + 5 # seconds
switchAccion = 0 # 0 add from repair, 1 remove, 2 defective, 3 piece broked, 4 internal use
switchLoopButton = 0
## THREADS
threads = []
threadLimiter = threading.BoundedSemaphore(
40) #Max number of threads 40max mysql
exitLoop = 0
def pintaLCD(mensaje, lcd, color=(0, 0, 0)):
lcd.set_color(color[0], color[1], color[2])
lcd.clear()
lcd.message(mensaje)
def selectEPC(lecturaRFID): #Receive as string, not int encode to hex
EPC = ''
# Extract 96 bits of EPC from read value
for x in range(18, 42):
EPC = EPC + lecturaRFID[x]
return EPC
def __init__(self,
host_and_ports=[('localhost', 61613)],
user=None,
passcode=None,
prefer_localhost=True,
try_loopback_connect=True,
reconnect_sleep_initial=0.1,
reconnect_sleep_increase=0.5,
reconnect_sleep_jitter=0.1,
reconnect_sleep_max=60.0,
use_ssl=False,
ssl_key_file=None,
ssl_cert_file=None,
ssl_ca_certs=None,
ssl_cert_validator=None):
"""
Initialize and start this connection.
\param host_and_ports
a list of (host, port) tuples.
\param prefer_localhost
if True and the local host is mentioned in the (host,
port) tuples, try to connect to this first
\param try_loopback_connect
if True and the local host is found in the host
tuples, try connecting to it using loopback interface
(127.0.0.1)
\param reconnect_sleep_initial
initial delay in seconds to wait before reattempting
to establish a connection if connection to any of the
hosts fails.
\param reconnect_sleep_increase
factor by which the sleep delay is increased after
each connection attempt. For example, 0.5 means
to wait 50% longer than before the previous attempt,
1.0 means wait twice as long, and 0.0 means keep
the delay constant.
\param reconnect_sleep_max
maximum delay between connection attempts, regardless
of the reconnect_sleep_increase.
\param reconnect_sleep_jitter
random additional time to wait (as a percentage of
the time determined using the previous parameters)
between connection attempts in order to avoid
stampeding. For example, a value of 0.1 means to wait
an extra 0%-10% (randomly determined) of the delay
calculated using the previous three parameters.
\param use_ssl
connect using SSL to the socket. This wraps the
socket in a SSL connection. The constructor will
raise an exception if you ask for SSL, but it can't
find the SSL module.
\param ssl_cert_file
The path to a X509 certificate
\param ssl_key_file
The path to a X509 key file
\param ssl_ca_certs
The path to the a file containing CA certificates
to validate the server against. If this is not set,
server side certificate validation is not done.
\param ssl_cert_validator
Function which performs extra validation on the client
certificate, for example checking the returned
certificate has a commonName attribute equal to the
hostname (to avoid man in the middle attacks)
The signature is:
(OK, err_msg) = validation_function(cert, hostname)
where OK is a boolean, and cert is a certificate structure
as returned by ssl.SSLSocket.getpeercert()
"""
sorted_host_and_ports = []
sorted_host_and_ports.extend(host_and_ports)
# If localhost is preferred, make sure all (host, port) tuples
# that refer to the local host come first in the list
if prefer_localhost:
def is_local_host(host):
return host in Connection.__localhost_names
sorted_host_and_ports.sort(lambda x, y: (int(is_local_host(y[0])) -
int(is_local_host(x[0]))))
# If the user wishes to attempt connecting to local ports
# using the loopback interface, for each (host, port) tuple
# referring to a local host, add an entry with the host name
# replaced by 127.0.0.1 if it doesn't exist already
loopback_host_and_ports = []
if try_loopback_connect:
for host_and_port in sorted_host_and_ports:
if is_local_host(host_and_port[0]):
port = host_and_port[1]
if (not ("127.0.0.1", port) in sorted_host_and_ports and
not ("localhost", port) in sorted_host_and_ports):
loopback_host_and_ports.append(("127.0.0.1", port))
# Assemble the final, possibly sorted list of (host, port) tuples
self.__host_and_ports = []
self.__host_and_ports.extend(loopback_host_and_ports)
self.__host_and_ports.extend(sorted_host_and_ports)
self.__recvbuf = ''
self.__listeners = {}
self.__reconnect_sleep_initial = reconnect_sleep_initial
self.__reconnect_sleep_increase = reconnect_sleep_increase
self.__reconnect_sleep_jitter = reconnect_sleep_jitter
self.__reconnect_sleep_max = reconnect_sleep_max
self.__connect_headers = {}
if user is not None and passcode is not None:
self.__connect_headers['login'] = user
self.__connect_headers['passcode'] = passcode
self.__socket = None
self.__socket_semaphore = threading.BoundedSemaphore(1)
self.__current_host_and_port = None
self.__receiver_thread_exit_condition = threading.Condition()
self.__receiver_thread_exited = False
if use_ssl and not ssl:
print "Raising exception ..."
raise Exception(
"SSL connection requested, but SSL library not found.")
self.__ssl = use_ssl
self.__ssl_cert_file = ssl_cert_file
self.__ssl_key_file = ssl_key_file
self.__ssl_ca_certs = ssl_ca_certs
self.__ssl_cert_validator = ssl_cert_validator
class AbstractExternalModule:
"""
Abstract base of all external modules.
When you inherit and make new modules, please inherit like
`class NewLanguage$Filetype($AbstractFiletype, $AbstractLang): ...`.
Stream `stdout` is set to `DEVNULL` in subprocess
for all external modules for better performance.
`originalModulePath` is NOT a real original module path here,
it's meant to be COPIED module's path. `self.executable` or
`self.modulePath` will be executed.
"""
def __init__(self, originalModulePath: Path, fs: TempFileSystem,
parameterInfo: Const.ParamInfoList,
returnInfo: Const.ReturnInfoType,
*args, name: str = "", **kwargs):
self.originalModulePath = originalModulePath
self.fs = fs
self.parameterInfo = parameterInfo
self.returnInfo = returnInfo
self.prepared = False
self.modulePath: Const.OptionalPath = None # Execution Priority #2
self.executable: Const.OptionalPath = None # Execution Priority #1
self.name = name
@classmethod
def generateCompilationArgs(cls, *args, **kwargs) -> Const.ArgType:
"""
Generate arguments to compile.
"""
raise NotImplementedError
@classmethod
def generateExecutionArgs(cls, *args, **kwargs) -> Const.ArgType:
"""
Generate arguments to invoke.
"""
raise NotImplementedError
@staticmethod
def replaceSymbols(sourceCodePath: Path, mapping: dict) -> str:
"""
Read sourcecode and replace symbols by mapping.
"""
with open(sourceCodePath, "r") as sourceCodeFile:
template = StringTemplate(sourceCodeFile.read())
return template.substitute(mapping)
# Global semaphore for invocation
globalInvokeSemaphore = threading.BoundedSemaphore()
@staticmethod
def invoke(
args: Const.ArgType, stdin: Path = None, stderr: Path = None,
timelimit: float = Const.DefaultTimeLimit,
memorylimit: float = Const.DefaultMemoryLimit,
cwd: Path = None) -> Const.ExitCode:
"""
Invoke given args with given stdin, stderr, timelimit and cwd.
Note that stdin and stderr should be either None or existing file's path.
Otherwise, it will be `DEVNULL`.
"""
# Open stdin and stderr, and go
stdin = open(stdin, "r") \
if isExistingFile(stdin) else DEVNULL
stderr = open(stderr, "w") \
if isExistingFile(stderr) else DEVNULL
result = Const.ExitCode.GeneralUnintendedFail
# Make everything to be an absolute path
for i in range(len(args)):
if isinstance(args[i], Path):
args[i] = args[i].absolute()
# Execute
try:
with AbstractExternalModule.globalInvokeSemaphore:
P = Popen(
args, stdin=stdin, stdout=DEVNULL, stderr=stderr,
cwd=cwd, encoding='ascii',
preexec_fn=limitSubprocessResource(timelimit, memorylimit)
)
exitcode = P.wait(60) # One minute for max
for ec in Const.ExitCode:
if ec.value == exitcode or ec.value + 256 == exitcode:
result = ec
break
except TimeoutExpired: # Something went wrong.
result = Const.ExitCode.Killed
P.kill()
finally: # Close file objects
logger.debug("Executed \"%s\" with TL = %ds, ML = %gMB, exitcode = %d (%s)",
P.args, timelimit, memorylimit, P.returncode, result.name)
if stdin != DEVNULL:
stdin.close()
if stderr != DEVNULL:
stderr.close()
# Return exitcode
return result
@classmethod
def generateCode(cls, *args, **kwargs) -> str:
"""
The most abstract method of `generateCode`.
Read each child class's abstract method for details.
"""
raise NotImplementedError
def preparePipeline(self) -> None:
"""
The most abstract method of `preparePipeline`.
Read each child class's abstract method for details.
At the end of this method, `self.prepared` should be set to True.
"""
raise NotImplementedError
def run(self, *args, **kwargs) -> Const.EXOO:
"""
The most abstract method of `run`.
This method should return `(ExitCode, outfile, stderr)`.
Read each child class's abstract method for details.
"""
raise NotImplementedError
def __init__(self):
self.itemlist = []
self.totalDuration = 0
self.processingSemaphore = threading.BoundedSemaphore()
import WateringSysPubSub as wps
import WateringSysVars
import socket
import threading
import json
import sys
import time
#import traceback
sem_publish_AWS = threading.BoundedSemaphore(1)
sem_cmd_water = threading.BoundedSemaphore(1)
sem_cmd_light = threading.BoundedSemaphore(1)
#Bind sockets
UDPServerSocket_water = socket.socket(family=socket.AF_INET,
type=socket.SOCK_DGRAM)
UDPServerSocket_water.bind(
(WateringSysVars.localIP, WateringSysVars.localPort_water))
UDPServerSocket_light = socket.socket(family=socket.AF_INET,
type=socket.SOCK_DGRAM)
UDPServerSocket_light.bind(
(WateringSysVars.localIP, WateringSysVars.localPort_light))
def ServiceCommands(client, userdata, message):
print("Recevied shadow")
print(message.payload)
sem_cmd_water.acquire() #lock the semaphore to update local vars
sem_cmd_light.acquire() #lock the semaphore to update local vars
data = json.loads(message.payload)
def __init__(self, globalData: GlobalData):
self.fileName = os.path.basename(__file__)
# get global configured data
self.globalData = globalData
self.options = self.globalData.options
self.nodes = self.globalData.nodes
self.sensors = self.globalData.sensors
self.managers = self.globalData.managers
self.alerts = self.globalData.alerts
self.sensorAlerts = self.globalData.sensorAlerts
self.serverComm = self.globalData.serverComm
self.pins = self.globalData.pins
self.timeDelayedActivation = self.globalData.timeDelayedActivation
self.audioOutput = self.globalData.audioOutput
self.sensorWarningStates = self.globalData.sensorWarningStates
# lock that is being used so only one thread can update the screen
self.consoleLock = threading.BoundedSemaphore(1)
# urwid object that shows the connection status
self.connectionStatus = None
# urwid object that shows if the alert system is active
self.alertSystemActive = None
# the file descriptor for the urwid callback to update the screen
self.screenFd = None
# this is the urwid object of the pin field
self.pinEdit = None
# this is the urwid object of the options menu
self.menuPile = None
# this is the urwid object of the whole edit part of the screen
self.editPartScreen = None
# gives the time in seconds when the screen was unlocked
# (used to check if it was timed out)
self.screenUnlockedTime = 0
# the main render loop for the interactive session
self.mainLoop = None
# the final body that contains the left and right part of the screen
self.finalBody = None
# the main frame around the final body
self.mainFrame = None
# the urwid object of the warning view
self.warningView = None
# flag that signalizes if the pin view is shown or not
self.inPinView = True
# flag that signalizes if the menu view is shown or not
self.inMenuView = False
# flag that signalizes if the warning view is shown or not
self.inWarningView = False
# callback function of the action that is chosen during the menu view
# (is used to show warnings if some sensors are not in
# the correct state and after confirmation execute the chosen option)
self.callbackOptionToExecute = None
# list of sensors that are in the warning state and need user
# confirmation
self.sensorsToWarn = list()