def handler():
"""
Monitor a website and upload analytics to a database.
"""
website_response = monitor()
producer(website_response)
response = create_http_response(200, "Success!")
return response
def main():
parser = make_parser()
args = parser.parse_args()
if not valid_args(args):
parser.print_help()
elif args.consumer:
consumer(args)
elif args.producer:
producer(args)
else:
parser.print_help()
def main():
parser = make_parser()
args = parser.parse_args()
if not valid_args(args):
parser.print_help()
elif args.consumer:
consumer(args)
elif args.producer:
producer(args)
else:
parser.print_help()
def __init__(self, name, parent=None):
UVMComponent.__init__(self, name, parent)
UVMPhase.m_phase_trace = True
self.p1 = producer("producer1", self)
self.p2 = producer("producer2", self)
self.f = UVMTLMFIFO("fifo", self)
self.c = consumer("consumer", self)
# Create connections between components
self.p1.out.connect(self.c.input)
self.p2.out.connect(self.f.blocking_put_export)
self.c.out.connect(self.f.get_export)
self.error = False
def ranch_socket(ws: WebSocket):
client_token = ws.environ["HTTP_AUTHORIZATION"].split()[1]
client_id = check_token(client_token)
# client_id = ":".join((ws.environ["REMOTE_ADDR"], ws.environ["REMOTE_PORT"]))
app.logger.info(f"Client came: {client_id}")
if current_user.is_authenticated:
if current_user.role == "0":
response = f"Client {client_id} does not have read permissions!"
app.logger.info(response)
return jsonify(response), 403
else:
while not ws.closed:
message = producer()
app.logger.info(f"Sending {message} to {client_id}")
if message is None:
app.logger.info("Message from backend was None!")
continue
clients = ws.handler.server.clients.values()
try:
for client in clients:
client.ws.send(message)
except geventwebsocket.exceptions.WebSocketError:
app.logger.info(f"Client {client_id} disappeared")
ws.close()
for i in frange(0, SLEEP_TIMEOUT, SLEEP_STEP):
time.sleep(SLEEP_STEP)
else:
response = f"Client {client_id} is not authenticated!"
app.logger.info(response)
# return redirect(url_for("login"))
return jsonify(response), 401
def __init__(self, name, parent=None):
super().__init__(name, parent)
self.prods = []
self.prods2 = []
self.cons = []
self.fifos = []
self.n = 128
for i in range(self.n):
self.prods.append(producer("producer" + str(i), self))
self.prods2.append(producer("producer2_" + str(i), self))
self.cons.append(consumer("consumer" + str(i), self))
self.fifos.append(UVMTLMFIFO("fifo" + str(i), self))
for i in range(self.n):
self.prods[i].out.connect(self.cons[i].input)
self.prods2[i].out.connect(self.fifos[i].blocking_put_export)
self.cons[i].out.connect(self.fifos[i].get_export)
def main():
parser = make_parser()
args = parser.parse_args()
# setup logging
numeric_log_level = getattr(logging, args.log_level.upper(), None)
if not isinstance(numeric_log_level, int):
raise ValueError('invalid log level: %s' % args.log_level)
logging.basicConfig(level=numeric_log_level)
clean_kafka_configs(args)
if not valid_args(args):
parser.print_help()
elif args.consumer:
consumer(args)
elif args.producer:
producer(args)
else:
parser.print_help()
def main():
parser = make_parser()
args = parser.parse_args()
# setup logging
numeric_log_level = getattr(logging, args.log_level.upper(), None)
if not isinstance(numeric_log_level, int):
raise ValueError('invalid log level: %s' % args.log_level)
logging.basicConfig(level=numeric_log_level)
clean_kafka_configs(args)
if not valid_args(args):
parser.print_help()
elif args.consumer:
consumer(args)
elif args.producer:
producer(args)
else:
parser.print_help()
def __init__(self): self.dbhelper = dbhelper() self.outputer = outputer(self.dbhelper) self.eManager = eventManager(self.dbhelper, self.outputer) self.uManager = userManager(self.dbhelper, self.outputer) self.pro = producer(self.dbhelper.mongo_conn, self.dbhelper.redis_conn) self.algone = algOne(self.dbhelper, self.outputer) # self.userList = [] self.lock1 = threading.Lock() self.lock2 = threading.Lock() self.lock3 = threading.Lock()
async def handle(self):
msg = await self.zmqSubSocket.recv_multipart()
topic = msg[0]
body = msg[1]
sequence = "Unknown"
if len(msg[-1]) == 4:
msgSequence = struct.unpack('<I', msg[-1])[-1]
sequence = str(msgSequence)
if topic == b"hashblock":
print('- HASH BLOCK (' + sequence + ') -')
context = zmq.Context()
zmq_socket = context.socket(zmq.PUSH)
zmq_socket.bind("tcp://127.0.0.1:55551")
block_id = binascii.hexlify(body)
block_id = block_id.decode("utf-8")
data = {'data': block_id}
zmq_socket.send_json(data)
elif topic == b"hashtx":
print('- HASH TX (' + sequence + ') -')
txid = binascii.hexlify(body)
txid = txid.decode("utf-8")
print(txid)
producer(txid)
#txid = binascii.hexlify(body)
#txid = txid.decode("utf-8")
#print(txid)
#d = get_rawtransaction(txid)
#print(d)
elif topic == b"rawblock":
print('- RAW BLOCK HEADER (' + sequence + ') -')
print(binascii.hexlify(body[:80]))
elif topic == b"rawtx":
print('- RAW TX (' + sequence + ') -')
print(binascii.hexlify(body))
# schedule ourselves to receive the next message
asyncio.ensure_future(self.handle())
def parse(self, response):
title = response.css('title::text').get()
text = response.css('span.text::text').get()
author = response.css('small.author::text').get()
print("author ->", author)
tags = response.css('div.tags a.tag::text').getall()
d = {"title": title, "text": text, "author": author, "tags": tags}
if len(text) > 0:
h_text = text[:10]
print("h_text ->", h_text)
print("author ->", author)
str = h_text + author
hash_object = hashlib.sha1(str.encode())
result = hash_object.hexdigest()
d["hash"] = result
else:
d["hash"] = 0
producer(msg=d)
# if __name__ =="__main__":
# process = CrawlerProcess()
# process.crawl(QuotesSpider)
# process.start()
def send_data_producer(result): return producer.producer(result)
from flask.ext.sqlalchemy import SQLAlchemy
import time
import simpleChecking
import main
import monitoring
import onosCore
from uuid import uuid4
#database name
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///MIRAI4.db"
db = SQLAlchemy(app)
#multiprocessing call, checking module call, monitoring module call
t = producer.producer()
checking = simpleChecking.check()
truechecking = main.mainclass()
monitor = monitoring.monitor()
clear = onosCore.test()
token = 1
from sqlalchemy import Column, Integer, String
#database class
class Mirai4(db.Model):
#table name & components (creation)
__tablename__ = 'mirai4'
id = db.Column(Integer, primary_key=True)
containerName = db.Column(String(120))
result = db.Column(String(50) )
code = db.Column(String(120))
import sys,os,time,commands
import sorts
import oper
import features
import producer
from optparse import OptionParser
if(__name__=='__main__'):
usage = "%prog [options] [netcard name]"
desc ="Manage Network"
parser = OptionParser(usage=usage, description=desc)
# parser.add_option("-i", "--info", dest="info", action="store_true", help="Get netcard info")
parser.add_option("-p", "--path", dest="path", action="store", help="File path")
# parser.add_option("-f", "--fresh", dest="fresh", help="Fresh DNS config ")
(options, args) = parser.parse_args()
# get path
if not options.path is None:
rpath = options.path
else:
# rpath = os.getcwd()
print 'Not take dirs'
exit(0)
oper.free_result(rpath)
oper.json_init(rpath+'/conf/codeeye.json')
features.walk_files(rpath)
# res = oper.read_result(rpath+'/conf/topo.txt')
print oper.date_day_identify(rpath+'/conf/topo.txt')
producer.producer(rpath)
