Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def setup_remote_actuation(self, vip_destination):
event = gevent.event.Event()
agent = Agent(address=vip_destination)
gevent.spawn(agent.core.run, event)
event.wait(timeout=15)
return agent
app = Flask(__name__)
app.config['DEBUG'] = False
app.config['WTF_CSRF_ENABLED'] = True
app.config['SECRET_KEY'] = ''.join(random.choice(string.lowercase) for x in range(random.randint(16, 32)))
app.jinja_env.filters['bootstrap_is_hidden_field'] = is_hidden_field_filter
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
config = {}
logger = logging.getLogger(__name__)
authenticator = Authenticator()
first_cfg_received = gevent.event.Event()
# keys used for adding new drones to the system
drone_keys = []
@app.before_first_request
def initialize():
gevent.spawn(config_subscriber)
# wait until we have received the first config publish
first_cfg_received.wait()
def config_subscriber():
global config
ctx = zmq.Context()
subscriber_socket = ctx.socket(zmq.SUB)
subscriber_socket.connect('ipc://configPublisher')
def __init__(self, actor_config, directory="./", idle_trigger=False, idle_time=10):
Actor.__init__(self, actor_config)
self.reading = event.Event()
self.reading.set()
self.pool.createQueue("outbox")
def __init__(self, store, node):
self.store = store
self.node = node
# retrieval task queue
self.queue = gevent.queue.Queue(16)
# recovery signal
self._recovery = None
self.event = gevent.event.Event()
self.last_known_header = None
def __init__(self, fabricclass, fabricconfig, mgmtbusconfig):
self.chassis_id = os.getpid()
self.fts = {}
self.poweroff = gevent.event.AsyncResult()
self.fabric_class = fabricclass
self.fabric_config = fabricconfig
self.fabric = minemeld.fabric.factory(
self.fabric_class,
self,
self.fabric_config
)
self.mgmtbus = minemeld.mgmtbus.slave_hub_factory(
mgmtbusconfig['slave'],
mgmtbusconfig['transport']['class'],
mgmtbusconfig['transport']['config']
)
self.mgmtbus.add_failure_listener(self.mgmtbus_failed)
self.mgmtbus.request_chassis_rpc_channel(self)
def _add_table(self, name, priority, create_if_missing=True):
self.current_tables_lock.acquire()
if len(self.current_tables) < self.max_tables:
try:
result = self._open_table(
name,
create_if_missing=create_if_missing
)
finally:
self.current_tables_lock.release()
return result
self.current_tables_lock.release()
future_table = gevent.event.AsyncResult()
self.add_queue.put((
priority,
(future_table, name, create_if_missing)
))
self._process_queue()
return future_table.get()
sync_start_block: BlockNumber,
required_confirmations: BlockTimeout,
poll_interval: float,
matrix_servers: Optional[List[str]] = None,
):
super().__init__()
self.web3 = web3
self.registry_address = contracts[CONTRACT_TOKEN_NETWORK_REGISTRY].address
self.user_deposit_contract = contracts[CONTRACT_USER_DEPOSIT]
self.service_token_address = self.user_deposit_contract.functions.token().call()
self.chain_id = ChainID(web3.eth.chainId)
self.address = private_key_to_address(private_key)
self.required_confirmations = required_confirmations
self._poll_interval = poll_interval
self._is_running = gevent.event.Event()
log.info("PFS payment address", address=self.address)
self.database = PFSDatabase(
filename=db_filename,
pfs_address=self.address,
sync_start_block=sync_start_block,
token_network_registry_address=to_canonical_address(self.registry_address),
chain_id=self.chain_id,
user_deposit_contract_address=to_canonical_address(self.user_deposit_contract.address),
allow_create=True,
)
self.blockchain_state = BlockchainState(
latest_committed_block=self.database.get_latest_committed_block(),
token_network_registry_address=to_canonical_address(self.registry_address),
if len(g) == 0:
continue
p = multiprocessing.Process(
target=_run_chassis,
args=(
config.fabric,
config.mgmtbus,
g
)
)
processes.append(p)
p.start()
processes_lock = gevent.lock.BoundedSemaphore()
signal_received = gevent.event.Event()
gevent.signal(signal.SIGINT, _sigint_handler)
gevent.signal(signal.SIGTERM, _sigterm_handler)
try:
mbusmaster = minemeld.mgmtbus.master_factory(
config=config.mgmtbus['master'],
comm_class=config.mgmtbus['transport']['class'],
comm_config=config.mgmtbus['transport']['config'],
nodes=config.nodes.keys(),
num_chassis=len(processes)
)
mbusmaster.start()
mbusmaster.wait_for_chassis(timeout=10)
# here nodes are all CONNECTED, fabric and mgmtbus up, with mgmtbus
# dispatching and fabric not dispatching
def _broadcast(self, brtype, stream_name, input=None, muxer='ts', pre_access=''):
if self._shuttingDown.isSet():
return
# Start/stop broadcast with VLC
# Logger
if brtype == True:
broadcast = 'startBroadcast'
else:
broadcast = 'stopBroadcast'
logger = logging.getLogger("VlcClient_" + broadcast)
# Clear AsyncResult
self._result = gevent.event.AsyncResult()
# Get lock
self._resultlock.acquire()
# Write message to VLC socket
if brtype == True:
self._write(VlcMessage.request.startBroadcast(
stream_name, input, self._out_port, muxer, pre_access))
else:
self._write(VlcMessage.request.stopBroadcast(stream_name))
try:
gevent.sleep()
result = self._result.get(timeout=self._resulttimeout)
if result == False:
logger.error(broadcast + " error")
raise VlcException(broadcast + " error")
except gevent.Timeout:
# Create emitter and bind to gateway payloads
self.packets.on((RECV, OPCode.DISPATCH), self.handle_dispatch)
self.packets.on((RECV, OPCode.HEARTBEAT), self.handle_heartbeat)
self.packets.on((RECV, OPCode.HEARTBEAT_ACK), self.handle_heartbeat_acknowledge)
self.packets.on((RECV, OPCode.RECONNECT), self.handle_reconnect)
self.packets.on((RECV, OPCode.INVALID_SESSION), self.handle_invalid_session)
self.packets.on((RECV, OPCode.HELLO), self.handle_hello)
# Bind to ready payload
self.events.on('Ready', self.on_ready)
self.events.on('Resumed', self.on_resumed)
# Websocket connection
self.ws = None
self.ws_event = gevent.event.Event()
self._zlib = None
self._buffer = None
# State
self.seq = 0
self.session_id = None
self.reconnects = 0
self.shutting_down = False
self.replaying = False
self.replayed_events = 0
# Cached gateway URL
self._cached_gateway_url = None
# Heartbeat
self._heartbeat_task = None