def create_user(session: Session, user: User) -> User:
"""
Create a new user if username isn't already taken.
:param session: SQLAlchemy database session.
:type session: Session
:param user: New user record to create.
:type user: User
:return: Optional[User]
"""
try:
existing_user = (
session.query(User).filter(User.username == user.username).first()
)
if existing_user is None:
session.add(user) # Add the user
session.commit() # Commit the change
LOGGER.success(f"Created user: {user}")
else:
LOGGER.warning(f"Users already exists in database: {existing_user}")
return session.query(User).filter(User.username == user.username).first()
except IntegrityError as e:
LOGGER.error(e.orig)
raise e.orig
except SQLAlchemyError as e:
LOGGER.error(f"Unexpected error when creating user: {e}")
raise e
def create_post(session: Session, post: Post) -> Post:
"""
Create a post.
:param session: SQLAlchemy database session.
:type session: Session
:param post: Blog post to be created.
:type post: Post
:return: Post
"""
try:
existing_post = session.query(Post).filter(Post.slug == post.slug).first()
if existing_post is None:
session.add(post) # Add the post
session.commit() # Commit the change
LOGGER.success(
f"Created post {post} published by user {post.author.username}"
)
return session.query(Post).filter(Post.slug == post.slug).first()
else:
LOGGER.warning(f"Post already exists in database: {post}")
return existing_post
except IntegrityError as e:
LOGGER.error(e.orig)
raise e.orig
except SQLAlchemyError as e:
LOGGER.error(f"Unexpected error when creating user: {e}")
raise e
def tovala_counter(user_name: str) -> str:
"""
Keep track of consecutive Tovalas.
:param str user_name: Name of user reporting a Tovala sighting.
:returns: str
"""
try:
r.hincrby("tovala", user_name, 1)
r.expire("tovala", 60)
tovala_users = r.hgetall("tovala")
tovala_contributors = tally_tovala_sightings_by_user(tovala_users)
session_total_sightings = total_tovala_sightings(tovala_users)
standing_total_sightings = get_current_total()
LOGGER.success(
f"Saved Tovala sighting to Redis: (tovala, {user_name})")
return emojize(
f"\n\n<b>:shallow_pan_of_food: {session_total_sightings} CONSECUTIVE TOVALAS!</b>\n{tovala_contributors}\n:keycap_#: Highest streak: {standing_total_sightings}"
)
except RedisError as e:
LOGGER.error(
f"RedisError while saving Tovala streak from @{user_name}: {e}")
return emojize(
f":warning: my b @{user_name}, broughbert just broke like a littol BITCH :warning:",
use_aliases=True,
)
except Exception as e:
LOGGER.error(
f"Unexpected error while saving Tovala streak from @{user_name}: {e}"
)
return emojize(
f":warning: my b @{user_name}, broughbert just broke like a littol BITCH :warning:",
use_aliases=True,
)
def __call__(self, args=[], stdin=None): # stdin byte stream
args = list(filter(lambda x: x != "", args))
if self.DEBUG_LEVEL > 0 and self.timeout > -1:
LOGGER.info(self.namespace, f"Setting timeout {self.timeout} {self.path_to_executable} ")
cmd = ["timeout", f"{self.timeout}"] + [self.path_to_executable] if self.timeout > -1 else [self.path_to_executable]
p = Popen(cmd + args, stdout=PIPE, stderr=PIPE, stdin=PIPE)
if stdin is not None:
p.stdin.write(stdin)
start = time.time()
std, err = p.communicate()
delta = time.time() - start
if self.debug:
LOGGER.success(self.namespace, "Command -> %s (%.2f s)" % (self.name, delta))
LOGGER.info(self.namespace, " ".join([self.path_to_executable] + args))
rc = p.returncode
if rc != 0:
LOGGER.error(self.namespace, "%s %s %s" % (err.decode("utf-8"), rc, std.decode("utf-8")))
if rc == 124:
raise TimeoutException()
raise CallException("Error on stage: %s" % (self.name,), err)
# Specific implementation process over the std out
res = self.processInner(std, err)
if self.debug and self.DEBUG_LEVEL > 0:
LOGGER.debug(self.namespace, "============================= Command -> %s\n\n" % (self.name,), res)
if err:
LOGGER.debug(self.namespace, "stderr \n\n %s \n\n" % (err.decode("utf-8"),))
return res
def cleanup_data():
try:
session.execute(text("SET FOREIGN_KEY_CHECKS=0;"))
session.commit()
session.execute(text("TRUNCATE TABLE comment;"))
session.commit()
session.execute(text("TRUNCATE TABLE post;"))
session.commit()
session.execute(text("TRUNCATE TABLE user;"))
session.commit()
session.execute(text("SET FOREIGN_KEY_CHECKS=1;"))
session.commit()
LOGGER.success("Successfully reset all data.")
except IntegrityError as e:
LOGGER.error(e.orig)
raise e.orig
except SQLAlchemyError as e:
LOGGER.error(f"Unexpected error when resetting data: {e}")
raise e
def orm_delete_user(session: Session, user: User):
"""
Delete a user if it exists.
:param session: SQLAlchemy database session.
:type session: Session
:param user: User to be deleted.
:type user: User
:return: None
"""
try:
session.delete(user) # Delete the user
session.commit() # Commit the change
LOGGER.success(f"Deleted user: {user}")
except IntegrityError as e:
LOGGER.error(e.orig)
raise e.orig
except SQLAlchemyError as e:
LOGGER.error(f"Unexpected error when deleting user: {e}")
raise e
def create_comment(session: Session, comment: Comment) -> Comment:
"""
Create a comment posted by `regular_user` on `admin_user`'s post.
:param session: SQLAlchemy database session.
:type session: Session
:param comment: User comment left on published post.
:type comment: Comment
:return: Comment
"""
try:
session.add(comment) # Add the Comment
session.commit() # Commit the change
LOGGER.success(f"Created comment {comment} from user {comment.user.username}.")
return comment
except IntegrityError as e:
LOGGER.error(e.orig)
raise e.orig
except SQLAlchemyError as e:
LOGGER.error(f"Unexpected error when creating comment: {e}")
raise e
def orm_create_user(session: Session, user: User) -> User:
"""
Create a new instance of our `User` model.
:param session: SQLAlchemy database session.
:type session: Session
:param user: User data model for creation.
:type user: User
:return: User
"""
try:
session.add(user) # Add the user
session.commit() # Commit the change
LOGGER.success(f"Created new user: {user}")
return user
except IntegrityError as e:
LOGGER.error(e.orig)
raise e.orig
except SQLAlchemyError as e:
LOGGER.error(f"Unexpected error when creating user: {e}")
raise e
def listen(port, q, program):
HOST = '127.0.0.1' # Standard loopback interface address (localhost)
PORT = port
result = {}
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind((HOST, PORT))
LOGGER.info(program, f"Listening...{port}")
s.listen()
conn, addr = s.accept()
with conn:
LOGGER.success(program, f'Connected by {addr}')
while True:
data = conn.recv(1024 << 6)
data = data.replace('\\'.encode(), '\\\\'.encode()).replace(
'\n'.encode(), '\\n'.encode())
st = f"[{data.decode()[:-1]}]"
try:
js = json.loads(st)
for kvpair in js:
k, v = kvpair["key"], kvpair["value"]
if k not in result:
result[k] = []
result[k].append(v)
q.put([k, v])
LOGGER.success(
program,
f"Populating results...{len(result.keys())} keys")
s = np.prod([len(t) for t in result.values()])
LOGGER.success(
program,
f"Populating results...{s} temptative replacements")
except Exception as e:
print(st)
if not data:
break
def processLevel(self, levels, program_name, port, bc, OUT_FOLDER, onlybc,
meta, outResult):
pool = ThreadPoolExecutor(
max_workers=config["DEFAULT"].getint("workers"))
results = {}
socket_port = config["souper"].getint("socket_port") + port
q = queue.Queue()
for level in levels:
results[level] = {}
LOGGER.success(
program_name,
"%s: Searching level (increasing execution time) %s: %s souper-workers:%s souper-port:%s"
% (program_name, level,
config["souper"]["souper-level-%s" % level],
config["souper"].getint("workers"), socket_port))
try:
bctocand = BCCountCandidates(
program_name,
level=level,
souper_workers=config["souper"].getint("workers"),
timeout=config["DEFAULT"].getint("exploration-timeout"),
socket_port=socket_port)
except Exception as e:
LOGGER.error(program_name, traceback.format_exc())
return
with ContentToTmpFile(content=bc) as TMP_BC:
try:
serverThread = threading.Thread(
target=listen, args=[socket_port, q, program_name])
serverThread.start()
bctocand(args=[TMP_BC.file], std=None)
except TimeoutException as e:
LOGGER.warning(program_name, f"Timeout reached")
except Exception as e:
LOGGER.error(program_name, traceback.format_exc())
raise e
waitFor = 5
LOGGER.warning(
program_name,
f"Sleeping for {waitFor} seconds waiting for free ports...")
time.sleep(waitFor)
while not q.empty():
i = q.get()
k, v = i
if k not in results[level]:
results[level][k] = []
results[level][k].append(v)
return results
def generateVariant(self, job, program_name, merging, port, bc, OUT_FOLDER,
onlybc, meta, outResult, current, total):
if len(job) == 0:
LOGGER.info(program_name, f"Empty job...")
return []
variants = []
LOGGER.info(program_name, f"Generating {len(job)} variants...")
r = redis.Redis(host="localhost", port=port)
for jindex, j in enumerate(job):
LOGGER.info(
program_name,
f"Cleaning previous cache for variant generation...{port}")
try:
LOGGER.success(program_name, f"Flushing redis DB...")
result = r.flushall()
LOGGER.success(program_name,
f"DB flushed away: result({result})")
except Exception as e:
LOGGER.error(program_name, traceback.format_exc())
# Set keys
name = ""
try:
keys = list(merging.keys())
for k, v in j.items():
LOGGER.info(program_name, f"Setting redis db")
if v is not None:
name += "[%s-%s]" % (keys.index(k),
merging[k].index(v))
r.hset(k, "result", v)
else:
# search for infer word
rer = re.compile(r"infer %(\d+)")
kl = k
if rer.search(kl):
r.hset(
k, "result",
("result %%%s\n" %
(rer.search(kl).group(1), )).encode("utf-8"))
LOGGER.info(program_name,
f"Replacing redundant key-value pair...")
LOGGER.info(program_name,
f"Preparing new variant generation...")
with ContentToTmpFile(content=bc, LOG_LEVEL=2) as BCIN:
tmpIn = BCIN.file
with ContentToTmpFile(LOG_LEVEL=2) as BCOUT:
tmpOut = BCOUT.file
try:
sanitized_set_name = name
LOGGER.info(
program_name,
f"Generating variant {sanitized_set_name}...")
optBc = BCToSouper(program_name,
level=1,
debug=True,
redisport=port)
optBc(args=[tmpIn, tmpOut], std=None)
bsOpt = open(tmpOut, 'rb').read()
# Generate wasm
n = "%s[%s]" % (program_name, sanitized_set_name)
hex, size, wasmFile, watFile = self.generateWasm(
program_name,
bsOpt,
OUT_FOLDER,
name,
debug=True,
generateOnlyBc=onlybc)
variants.append([
hex, n,
[[k, v if v is not None else "No replace"]
for k, v in j.items()]
])
except Exception as e:
LOGGER.error(program_name, traceback.format_exc())
raise e
# call Souper and the linker again
except Exception as e:
LOGGER.error(program_name, traceback.format_exc())
finally:
LOGGER.info(program_name,
"Cleaning cache from variant generation...")
result = r.flushdb()
LOGGER.success(program_name,
f"Flushing redis DB: result({result})")
r.close()
return variants
if not os.path.exists(OUT_FOLDER):
os.mkdir(OUT_FOLDER)
if __name__ == "__main__":
redis_interfaces = sys.argv[1]
redisports = [6379]
if re.compile(r"(,\d+)+").match(redis_interfaces):
max_workers = len(redis_interfaces.split(",")) - 1
redisports = [int(t) for t in redis_interfaces.split(",")[1:]]
else:
max_workers = 1
levelPool = ThreadPoolExecutor(
max_workers=config["DEFAULT"].getint("workers"))
generationPool = ThreadPoolExecutor(max_workers=max_workers)
updatesettings(sys.argv[2:-1])
if not os.path.exists("out"):
os.mkdir("out")
RUNTIME_CONFIG["USE_REDIS"] = True
f = sys.argv[-1]
LOGGER.success("general", "STARTING")
main(f, redisports)
