def main():
# TODO: parse configuration file to retreive
# sender's and receiver's ip addresses
config_dict = parse_config()
if not config_dict:
print 'no config params'
return
sender_name = config_dict['IP'] + '_sender'
recv_name = config_dict['IP'] + '_receiver'
print 'sender name: ' + sender_name
print 'receiver name: ' + recv_name
s_obj = Sender()
r_obj = Receiver()
s_obj.ip_address = config_dict['IP']
r_obj.ip_address = config_dict['IP']
s_obj.multicast_address = config_dict['multicast']
r_obj.multicast_address = config_dict['multicast']
Pyro4.Daemon.serveSimple(
{
s_obj: sender_name,
r_obj: recv_name
},
ns=False,
port=45000,
host=config_dict["IP"]
)
def __init__(self):
# This are the global variables
self.functions_dict = {
"phone/mediacenter/play": self.play,
"phone/mediacenter/stop": self.stop,
"phone/mediacenter/increase_volume": self.increase_volume,
"phone/mediacenter/decrease_volume": self.decrease_volume,
"phone/mediacenter/pause": self.pause,
"phone/mediacenter/loadfile": self.load_file,
"phone/mediacenter/position/get": self.get_position
}
self.sender = Sender()
self.client = mqtt.Client()
self.client.connect("localhost", 1883, 60)
self.client.on_connect = self.on_connect
self.client.on_message = self.on_message
self.client.on_disconnect = self.on_disconnect
self.player = mediaplayer(1, 'MainThread')
self.player.exitEvent = self.exit_event
self.player.pauseEvent = self.pause_event
self.player.playEvent = self.play_event
self.player.positionEvent = self.position_event
self.player.seekEvent = self.relative_event
self.player.stopEvent = self.stop_event
self.player.start()
self.status = dict()
self.count = 0
def __init__(self, config=None):
"""Initialise the Connector and starts to listen to incoming messages.
:param config: Configuration to use (default config if None).
"""
self.log = logging.getLogger(self.__class__.__name__)
if config is None:
config = ConnConfig()
self.log.info("Falling back to default configuration.")
# errors up to here are allowed to terminate the program
mappings = self._read_mappings(config.mappings)
self.mapper = Mapper(mappings)
self.log.debug("Mappings read.")
self.sender = Sender(config.send.address, config.send.port,
config.broker.endpoint_prefix +
config.connector_id,
config.broker.topic,
config.connector_id)
self.log.info("Sender created.")
self.receiver = Receiver(self.RECEIVER_NAME,
config.listen.address, config.listen.port)
self.log.info("Receiver created.")
self.receiver.listen("/", self.handle_receive)
def postIpDel(request):
form = IpForm(request.REQUEST, request.FILES)
if not form.is_valid():
return json_response({"status": FORM_ERR, "result": 'Ошибка формы'})
login = form.cleaned_data['user_login']
del_ips = json.loads(form.cleaned_data['ip_list'])
kwargs = {'action': 'del_ip', 'user': login, 'ip_list': '{ip_list:' + json.dumps(del_ips) + '}'}
from models import WebApiSetting
web_api_settings = WebApiSetting.objects.all();
if len(web_api_settings)>0:
sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url)
status, reason, resp = sd.sendData(kwargs)
if status == ERROR400:
return json_response({"status":LOGIN_ERR, "result": "Неверное указано имя пользователя"})
elif status != SUCCESS:
logging.error("videoclient.configuration.web_api_users.wiews.postIpDel(connection failed) :" + 'Ошибка соединения при получении списка ip адресов пользователя')
return json_response({"status":ERROR, "result": "Повторите запрос позже"})
else:
logging.error("videoclient.configuration.web_api_users.wiews.postIpDel(connection failed) :" + 'Отсутствуют настройки для WEB API')
return json_response({"status":ERROR, "result": "Повторите запрос позже"})
return json_response({"status": OK, "result": "IP-адреса удалены (" + str(len(del_ips)) + ')'})
def __init__(self, addr, client_id):
self.sender = Sender(addr)
self.model = utility.getNewModel()
self.client_id = client_id
self.datasets = 0
self.weights = self.model.get_weights()
self.sent = True
def run(self):
self.is_running = True
if self.is_listening:
if self.is_verbose:
print "\033[34m[*]\033[0m starting the listener ...."
''' START Listener '''
self.listener = Listener(open_sock=self.sock,
isVerbose=self.is_verbose)
self.listener.daemon = True
self.listener.start()
if self.is_verbose:
print "\033[34m[*]\033[0m starting the sender ...."
''' START Sender'''
self.sender = Sender(sock=self.sock,
messages=self.messages,
peers=self.peer,
isVerbose=self.is_verbose,
msg_freq=self.msgs_freq,
wait_time=self.wait_time,
gtp_port=self.gtp_port)
self.sender_daemon = True
self.sender.start()
self.sender.join()
time.sleep(5)
self.stop()
def run_mirror(coord, transmission_protocol, identifier, sender_ipc_focus,
receiver_ipc_focus, receiver_ipc_light, senders_ipc_mirrors,
receivers_ipc_mirrors):
mirror = Mirror(identifier=identifier, coord=coord)
mirror.sender_focus_ = Sender(sender_ipc_focus,
transmission_protocol,
verbose=False)
mirror.receiver_focus_ = Receiver(receiver_ipc_focus,
transmission_protocol,
verbose=False)
mirror.receiver_light_src_ = Receiver(receiver_ipc_light,
transmission_protocol,
verbose=False)
for i, ipc in senders_ipc_mirrors.items():
mirror.senders_mirrors_[i] = Sender(ipc,
transmission_protocol,
verbose=False)
for i, ipc in receivers_ipc_mirrors.items():
mirror.receivers_mirrors_[i] = Receiver(ipc,
transmission_protocol,
verbose=False)
if identifier == 0:
mirror.run(is_first_to_adjust=True)
else:
mirror.run()
def main():
CONNECTION_STRING = os.getenv('EdgeHubConnectionString')
CA_CERTIFICATE = os.getenv('EdgeModuleCACertificateFile', False)
sender = Sender(CONNECTION_STRING, CA_CERTIFICATE)
print("connected to "+CONNECTION_STRING)
global r
r = sr.Recognizer()
with sr.Microphone() as source:
while True:
# obtain audio from the microphone
print("Say something!")
audio = r.listen(source)
# recognize speech using Sphinx
try:
if sender:
msg_properties = {
'detection_index': str(detection_index)
}
json_formatted = json.dumps({"text":r.recognize_sphinx(audio)})
sender.send_event_to_output(json_formatted, msg_properties, detection_index)
print("Sphinx thinks you said " + r.recognize_sphinx(audio))
except sr.UnknownValueError:
print("Sphinx could not understand audio")
except sr.RequestError as e:
print("Sphinx error; {0}".format(e))
def test1(key, sent):
# Initialize Sender and Receiver with key
S = Sender(key)
R = Receiver(key)
print '### SEND ###'
print sent
print '############'
# Loops if there is an error with the transfer
while True:
# Builds & encrypts packets to send
C = S.send(sent)
print '### ENCRYPTED PACKETS ###'
for c in C:
print repr(c)
print '#########################'
# Decrypts & rebuilds packets in correct order
err, received = R.receive(C)
if (err == None):
break
else:
print 'Uh Oh'
sys.exit(1)
print '### RECEIVE ###'
print received
print '###############'
test = sent == received
print 'sent = received? ' + str(test)
print '###############\n'
return test
def OnActionStart(self, event):
handler = rt.RichTextHTMLHandler()
handler.SetFlags(rt.RICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64)
handler.SetFontSizeMapping([7,9,11,12,14,22,100])
import cStringIO
stream = cStringIO.StringIO()
if not handler.SaveStream(self.richTextPanel.rtc.GetBuffer(), stream):
return
htmldata = stream.getvalue()
text = content.mime_message(htmldata, "hello hello this is a test", "this is a test", "*****@*****.**",
"*****@*****.**").as_string()
with open('email-example.eml', 'w') as f:
f.write(text)
#start send
listctrl = self.list_ctrl
_count = listctrl.GetItemCount()
_host = config.read_config(config.HOST)
_port = config.read_config(config.PORT)
_user = config.read_config(config.ACCOUNT_NAME)
_password = config.read_config(config.PASSWORD)
_from = config.read_config(config.FROM)
sender = Sender(_host, _port)
sender.login(_user, _password)
for i in range(_count):
sender.send(_from, listctrl.GetItem(i, 1).GetText(), text)
def __init__(self, args):
self.sender = Sender(args.port, train=True)
self.algorithm = args.algorithm
curr_file_path = os.path.dirname(os.path.abspath(__file__))
saved_models_path = os.path.join(curr_file_path, 'saved_models')
make_sure_path_exists(saved_models_path)
dagger_path = os.path.join(saved_models_path, 'dagger')
reinforce_path = os.path.join(saved_models_path, 'reinforce')
if self.algorithm == 'dagger':
self.learner = Dagger(state_dim=self.sender.state_dim,
action_cnt=self.sender.action_cnt,
train=True,
save_vars=dagger_path,
restore_vars=None,
debug=True)
elif self.algorithm == 'reinforce':
self.learner = Reinforce(state_dim=self.sender.state_dim,
action_cnt=self.sender.action_cnt,
train=True,
save_vars=reinforce_path,
restore_vars=None,
debug=True)
self.sender.set_sample_action(self.learner.sample_action)
self.max_batches = 2000
self.episodes_per_batch = 1
def main():
receiver = Receiver()
sender = Sender()
thread.start_new_thread(receiver.listen, ())
time.sleep(1)
sender.send()
def reset(self):
"""Must be called before running rollout()."""
self.cleanup()
self.port = get_open_udp_port()
#start sender as an instance of Sender class
sys.stderr.write('Starting sender...\n')
self.sender = Sender(self.port, train=True)
self.sender.set_sample_action(self.sample_action)
self.sender.set_update_Qnet(self.update_Qnet)
# start receiver in a subprocess
sys.stderr.write('Starting receiver...\n')
receiver_src = path.join(project_root.DIR, 'env',
'run_receiver.py') # path of run_receiver.py
recv_cmd = 'python %s $MAHIMAHI_BASE %s' % (receiver_src, self.port)
cmd = "%s -- sh -c '%s'" % (self.mahimahi_cmd, recv_cmd)
sys.stderr.write('$ %s\n' % cmd)
#Popen: Execute a child program in a new process.
#preexec_fn is set to a callable object, this object will be called in the child process just before the child is executed. (Unix only)
#os.setsid: To keep the child process running while the parent process exit.
self.receiver = Popen(cmd, preexec_fn=os.setsid, shell=True)
# sender completes the handshake sent from receiver
self.sender.handshake()
state = [
self.sender.delay_ewma, self.sender.send_rate_ewma,
self.sender.delivery_rate_ewma, self.sender.cwnd
]
return state
def __init__(self, config, log):
Sender.__init__(self, config, log)
self.access_key = config.get('Messenger', 'gcm_access_key')
self.base_deeplink_url = config.get('Messenger', 'base_deeplink_url')
self.gcm = GCM(self.access_key)
self.canonical_ids = []
self.unregistered_devices = []
def __init__(self, config, log):
Sender.__init__(self, config, log)
self.access_key = config.get('Messenger', 'gcm_access_key')
self.base_deeplink_url = config.get('Messenger', 'base_deeplink_url')
self.gcm = GCM2(self.access_key)
self.canonical_ids = []
self.unregistered_devices = []
def postTableStatistics(request):
form = StatisticForm(request.REQUEST, request.FILES)
if not form.is_valid():
return json_response({"status": FORM_ERR, "result": 'Повторите запрос позже'})
data = dict()
login = form.cleaned_data['user_login']
s_date = form.cleaned_data['start_date']
e_date = form.cleaned_data['end_date']
query = form.cleaned_data['query']
sorto = form.cleaned_data["sorto"]
data['sorto'] = sorto
data['up'] = form.cleaned_data['up']
kwargs = {'user': login, 'query': query, 'start_date': s_date, 'end_date': e_date}
from models import WebApiSetting
web_api_settings = WebApiSetting.objects.all();
if len(web_api_settings)==0:
logging.error("videoclient.configuration.web_api_users.wiews.postIpDel(connection failed) :" + 'Отсутствуют настройки для WEB API')
return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'})
sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].stat_url)
status, reason, resp = sd.sendData(kwargs)
del sd
if status == ERROR400:
return json_response({"status": LOGIN_ERR, "result": 'Неизвестный пользователь'})
if status != SUCCESS:
return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'})
ipstat = json.loads(resp)
#вычисляем суммы столбцов и строк таблицы
total = {}
column_list = ['detect', 'detect_and_identification', 'fanstudio']
for column_name in column_list:
total[column_name] = 0
total['total'] = 0
for host in ipstat:
host['total'] = 0
for column_name in column_list:
total[column_name] += host[column_name]
total['total'] += host[column_name]
host['total'] += host[column_name]
#сортируем
sort_fields = ["ip", 'detect', 'detect_and_identification', 'fanstudio', 'total']
if sorto > 0 and sorto <= len(sort_fields):
sort = [[sort_fields[sorto - 1]]]
ipstat = GlobalSortUser(ipstat, sort, 1, up=form.cleaned_data["up"])
data['table'] = ipstat
data['total'] = total
from django.template import loader
if ipstat:
result = loader.render_to_string('stat_table.html', data)
else:
result = False
return json_response({'result': result, 'status': OK})
def __init__(self, config, log):
Sender.__init__(self, config, log)
self.sandbox = config.getboolean('Messenger', 'apns_sandbox')
self.certificate_path = config.get('Messenger', 'apns_certificate_path')
self.topic = config.get('Messenger', 'apns_topic')
self.apn = APNsClient(self.certificate_path, use_sandbox=self.sandbox, log=log)
self.canonical_ids = []
self.unregistered_devices = []
def create_frames(self):
sender_page = Sender(self.container, self, self.user_name)
self.frames.update({"sender_page": sender_page})
sender_page.grid(row=0, column=0, sticky="nsew")
home_page = Home(self.container, self, self.user_name)
self.frames["home_page"] = home_page
home_page.grid(row=0, column=0, sticky="nsew")
def testSendDataWithNullData(getFixtures):
try:
pubsub = "foo"
sender = Sender(getFixtures.topic)
sender.sendData(None, 1)
except Exception as ex:
assert (type(ex) is ValueError)
def __init__(self, config, log):
Sender.__init__(self, config, log)
self.base_deeplink_url = config.get('Messenger', 'base_deeplink_url')
app = generate_fcm_app(
config.get('Messenger', 'google_application_credentials'))
self.FCM = FCM(app)
self.canonical_ids = []
self.unregistered_devices = []
def main():
args = get_args()
sender = Sender(type=args.type,
dst_ip=args.dst_ip,
dst_port=args.dport,
src_port=args.sport,
length=args.plen or 1)
sender.send_data()
def __init__(self, Twitter_UserID, CqHost, GroupID, CqToken):
self.sender = Sender(CqHost, GroupID, CqToken)
self.sender.start()
self.t = TweetApi(Twitter_UserID)
while True:
for i in self.t.updateTweet():
self.sender.send(i)
sleep(Config.CheckSec)
def __init__(self):
super().__init__()
self.__sender = Sender(Sender.DEFAULT_IP, Sender.DEFAULT_PORT)
self.setupUi(self)
self.__socket_created = False
self.__sender.log_message_signal.connect(self.write_in_log)
self.__sender.file_sent_signal.connect(self.enable_components)
def verify(self, plain_text):
sender = Sender(self)
receiver = Receiver(self)
self.generate_keys(sender, receiver)
cypher_text = self.encode(plain_text, sender.get_key())
decoded_text = self.decode(cypher_text, receiver.get_key())
if plain_text == decoded_text:
return True
return False
def bootstrap_connection(self):
"""
Initializes the receiver and sender threads
"""
self.receiver = Receiver(self.conn_socket, self.receiver_q, self.config.debug_token)
self.receiver.start()
self.sender = Sender(self.conn_socket, self.sender_q, self.config.debug_token)
self.sender.start()
self.config.state = State.UNSECURED_CONN
def update_data():
result = []
sender = None
for origin_class in cachcat_crawler.__all__:
page = 1
print(origin_class)
while page <= 1:
d = getattr(cachcat_crawler, origin_class)(page=page)
result += d.new_items
page += 1
object_data = {
'Notices': {
'data': sorted(result, key=lambda x: x['posted_at']),
'id_key': 'id'
},
}
for name, info in object_data.items():
data_objects = []
LEANCLOUD_OBJECT_DATA = load_json(os.path.join('leancloud_data', name))
data_dict = {}
for item in info['data']:
if data_changed(
LEANCLOUD_OBJECT_DATA.get(
object_id_key(name, item.get(info['id_key'])), {}),
item):
if info['id_key'] not in item:
continue
data_objects.append(
leancloud_object(name, item, info['id_key']))
data_dict[item.get(info['id_key'])] = item
print(name + " Total Count:" + str(len(info['data'])))
print(name + " Changed Count:" + str(len(data_objects)))
i = 0
batch_size = 50
while True:
if len(data_objects[i:i + batch_size]) > 0:
leancloud.Object.save_all(data_objects[i:i + batch_size])
i += batch_size
else:
break
for data_object in data_objects:
OBJECT_ID_MAP[object_id_key(name, data_object.get(
info['id_key']))] = data_object.id
LEANCLOUD_OBJECT_DATA[object_id_key(
name,
data_object.get(info['id_key']))] = data_dict[data_object.get(
info['id_key'])]
write_json('local_config/object_id_map.json', OBJECT_ID_MAP)
write_json(os.path.join('leancloud_data', name), LEANCLOUD_OBJECT_DATA)
for data_object in data_objects:
if sender is None:
sender = Sender()
sender.send(data_dict[data_object.get(info['id_key'])],
data_object.id)
class CoapClass(ProtocolClient):
def __init__(self):
self.port = 5683
self.reg = Registry()
self.send = Sender()
#self.coapSensors = self.reg.getCoapSensors()
def dataProcessing(self, receivedData):
if (receivedData["registred"] != True):
print(receivedData['regInfos'])
dbIds = self.reg.registerResourceIC(receivedData['localId'],
receivedData['regInfos'])
dbIds = True
if (dbIds != False):
print(' ')
print('call reg')
dbIds = self.reg.consultRegister(receivedData['localId'])
if (dbIds != False):
dbIds = self.reg.registerResourceIC(
receivedData['localId'], receivedData['regInfos'])
#print(self.coapSensors)
else:
print('erro no cadastro')
else:
print('Sensor without status identified')
#if is a sensor without state
dbIds = self.reg.registerResourceIC(receivedData['localId'],
receivedData['regInfos'])
if (dbIds != False):
#send data to IC
self.send.sendDataIC(dbIds, receivedData['data'])
def startListening(self):
print("\033[33mSTART LISTENING COAP INITIALIZED\033[m")
server = CoAPServer("0.0.0.0", 5683)
try:
server.listen(10)
except KeyboardInterrupt:
print("Server Shutdown")
server.close()
print("Exiting...")
def requestSensorData(self):
print("\033[35mREQUEST SENSOR DATA INITIALIZED\033[m")
path = 'data'
#for sensor in self.coapSensors:
client = HelperClient(server=(self.coapSensors["sensor"]["address"],
5683))
self.response = client.get(path)
self.data = json.loads(self.response.payload)
print(self.data)
#dbIds = self.reg.consultRegister(self.data['localId'])
#self.send.sendDataIC(dbIds,self.data)
print('Sended')
def __init__(self):
self.names = utils.get_names()
self.actions = {j:i for i,j in self.names.items()}
# special case for stopping the car when a stop or red light signal is detected
self.actions[-1] = 'stop'
# parts
self.sender = Sender()
self.decisor = Decisor()
self.capture = Capture()
def submit(d):
header = Header(d["method"], d["path"], d["httpversion"])
for i in d['headers']:
header.add_header(i['header_name'], i['header_value'])
header.build_from_text()
print(header.payload)
s = Sender()
r = Response()
resp = r.input_text(s.send(d["protocol"], d["hostname"], header.payload))
return resp
def __init__(self, packet_sender):
print 'Init Connection'
self.ee = EventEmitter()
self._sender = Sender(packet_sender)
self._receiver = Receiver(packet_sender)
@self._receiver.ee.on('data')
def on_data(data):
self.ee.emit('data', data)
def main():
setting.init()
host = input("Your IP or hostname: ")
port = int(input("Your port: "))
receiver = Receiver(host, port)
partner_host = input("Partner's IP or hostname: ")
partner_port = int(input("Partner's port: "))
sender = Sender(partner_host, partner_port)
threads = [receiver.start(), sender.start()]
def run_node(transmission_protocol, identifier, sender_ipc_topology, receiver_ipc_topology, senders_ipc_neighbor,
receivers_ipc_neighbor):
node = Node(identifier=identifier)
node.sender_des_node_ = Sender(sender_ipc_topology, transmission_protocol, verbose=False)
node.receiver_des_node_ = Receiver(receiver_ipc_topology, transmission_protocol, verbose=False)
for i, ipc in senders_ipc_neighbor.items():
node.senders_neighbors_[i] = Sender(ipc, transmission_protocol, verbose=False)
for i, ipc in receivers_ipc_neighbor.items():
node.receivers_neighbors_[i] = Receiver(ipc, transmission_protocol, verbose=False)
node.run()
def update_status():
if "To" in request.form and "MessageStatus" in request.form:
LOGGER.info(
f"STATUS UPDATE {request.form['To']}: {request.values['MessageStatus']}"
)
try:
sender = Sender(request.form["To"])
sender.update(request.values["MessageStatus"])
except Exception as e:
LOGGER.error(e)
return str(MessagingResponse())
def stream_sdata(self, datasize, cl_port):
if self.state != 2:
logging.error('stream_sdata: unexpected cur_state=%s', self.state)
return
#
to_addr = (self.cl_ip, cl_port)
sender = Sender(dst_addr = to_addr,
proto = self.proto,
datasize = datasize,
tx_type = self.tx_type,
file_url = self.file_url )
sender.init_send()
def main():
users = Users()
receiver = Receiver()
sender = Sender()
while True:
receiver.read_emails(users)
for user in users.users_map.values():
if user.modified:
sender.send_news(user.email, list(user.topics_set))
user.modified = False
print ('Sleeping')
sleep(10)
print ('Waking up')
def monitor_tilt():
sender = Sender()
while True:
beacons = distinct(blescan.parse_events(sock, 10))
for beacon in beacons:
if beacon['uuid'] in TILTS.keys():
sender.add_data({
'color': TILTS[beacon['uuid']],
'timestamp': datetime.datetime.now().isoformat(),
'temp': to_celsius(beacon['major']),
'gravity': beacon['minor']
})
time.sleep(10)
def __init__(self, source_addr, dest_addr):
self.source_addr = source_addr
self.dest_addr = dest_addr
self.q = Queue()
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.bind(source_addr)
self.connections = {}
self.users = self.get_users()
self.r = Receiver(self.sock, self.q, self.connections)
self.s = Sender(self.sock, self.q)
self.r.start()
self.s.start()
def getTableIp(request):
form = UserForm(request.REQUEST, request.FILES)
data = dict()
ips = []
if form.is_valid():
login = form.cleaned_data["user_login"]
sorto = form.cleaned_data["sorto"]
up = form.cleaned_data["up"]
data.update(form.cleaned_data)
kwargs = {'action': 'get_ip', 'user': login}
from models import WebApiSetting
web_api_settings = WebApiSetting.objects.all();
if len(web_api_settings)>0:
sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url)
status, reason, resp_str = sd.sendData(kwargs)
if status == ERROR400:
data["error"] = LOGIN_ERR
elif status != SUCCESS:
data["error"] = ERROR
else:
resp = json.loads(resp_str)
if 'ip_list' in resp:
ips = resp['ip_list']
else:
logging.error("videoclient.configuration.web_api_users.wiews.getTableIp(connection failed) :" + 'Отсутствуют настройки для WEB API')
data["error"] = ERROR
else:
data["user_login"] = ''
data["error"] = FORM_ERR
if 'error' in data:
return json_response({'status': data["error"], 'result': ''})
#сортируем
sort_fields = ["ip"]
sorto = form.cleaned_data["sorto"]
if sorto > 0 and sorto <= len(sort_fields):
ips = sorted(ips, reverse=(up == 0))
data["ip_list"] = ips
from django.template import loader
result = loader.render_to_string('ip_table.html', data, context_instance=RequestContext(request))
return json_response({'status': OK, 'result': result})
def __send_broadcast_frame(self, frame):
"""
Method that send broadcast frame if possible or push the frame to the queue of all Workers.
This is necessary because we are not able to identify ACK frames because of the missing sequence number on WiWo
frames.
"""
if self.__are_workers_available_for_broadcast_frame():
self.__set_workers_to_wait_response(frame)
Sender.send(frame, self.__iface_name)
else:
time.sleep(1) # TODO: Fix this code, it's not clear.
if self.__are_workers_available_for_broadcast_frame():
self.__set_workers_to_wait_response(frame)
Sender.send(frame, self.__iface_name)
def main():
sender = Sender('localhost')
sender.connect()
sender.create_queue('inbox')
sender.send_message('inbox', 'hello')
sender.disconnect()
receiver = Receiver('localhost')
receiver.connect()
receiver.receive('inbox')
receiver.disconnect()
def _send(self, frame, iface_name):
self.__communication_status = Worker.COMMUNICATION_WAITING
self.__last_frame_sent = frame
frame = Sender.send(frame, iface_name)
log_line = "- [SENT]: %s" % repr(frame)
self.__frame_log.append(log_line)
return frame
def sender_query(self, mac=None, sort='last_seen', time_window=None, advanced=None, count=None):
"""Query the database for a sender by it's MAC address.
If mac is None - return a list of all senders.
sort can start with `-' to change sort direction
time_window - recently seen (X seconds) senders only
"""
# Parse sorting order
direction = 1
if sort.startswith('-'):
direction = -1
sort = sort[1:]
# Build query
where = {}
if mac is not None:
where['mac'] = mac.lower()
if time_window:
now = time()
where['aggregate.last_seen'] = {
'$gt': now - time_window
}
if advanced is not None:
where.update(advanced)
senders = self.knowledge.find(where).sort(sort, direction)
if count is not None:
senders = senders[:count]
return Sender.create_from_db(senders)
def __init__(self, config, log):
"""
APNs Push Sender uses MODIFIED (watch out if you want to update it) PyAPNs module: https://github.com/djacobs/PyAPNs
APNs documentation: https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW4
"""
Sender.__init__(self, config, log)
self.sent_queue = {}
self.batch_size = int(config.get('Messenger', 'apns_batch_size'))
self.sandbox = config.get('Messenger', 'apns_sandbox') == 'true'
self.certificate_path = config.get('Messenger', 'apns_certificate_path')
set_logger(log)
self.apns = APNs(use_sandbox=self.sandbox, cert_file=self.certificate_path, enhanced=True,
write_retries=self.connection_error_retries)
self.apns.gateway_server.register_response_listener(self.process_malformed_notification)
self.apns.gateway_server.register_error_listener(self.process_failed_notification)
def main():
global indexer, uploader, sender, receiver, downloader
setup_signals()
logging.info("Asink client started at %s" %
(time.strftime("%a, %d %b %Y %X GMT", time.gmtime())))
#create all threads which will be used to process events
indexer = Indexer()
uploader = Uploader()
sender = Sender()
receiver = Receiver()
downloader = Downloader()
#create and set up queues which are used to pass events between threads
uploader_queue = Queue()
indexer.uploader_queue = uploader_queue
uploader.queue = uploader_queue
#set on watcher when initialized
sender_queue = Queue()
uploader.sender_queue = sender_queue
sender.queue = sender_queue
downloader_queue = Queue()
receiver.downloader_queue = downloader_queue
downloader.queue = downloader_queue
#setup storage provider
storage = setup_storage()
uploader.storage = storage.clone()
downloader.storage = storage
#start all threads
watcher.start_watching(uploader_queue)
indexer.start()
uploader.start()
sender.start()
receiver.start()
downloader.start()
#sleep until signaled, which will call sig_handler
while True:
time.sleep(86400) #= 24 hours just for fun
def send(self, url): for output in self.output.keys(): classes = Sender.__subclasses__() for cls in classes: if cls.is_registrar_for(output): params = self.output.get(output) params['subject'] = self.subject params['status'] = self.status params['dryrun'] = self.dryrun params['verbose'] = self.verbose sender = cls(**params) sender.send(url)
class Connection:
def __init__(self, packet_sender):
print 'Init Connection'
self.ee = EventEmitter()
self._sender = Sender(packet_sender)
self._receiver = Receiver(packet_sender)
@self._receiver.ee.on('data')
def on_data(data):
self.ee.emit('data', data)
def send(self, data):
self._sender.send(data)
def receive(self, packet):
if packet.getIsAcknowledgement():
self._sender.verifyAcknowledgement(packet.getSequenceNumber())
else:
self._receiver.receive(packet)
def __init__(self, tsid, ssid):
Sender.__init__(self, tsid, ssid)
self.mid = ""
self.timer = Timer()
self.uid2player = {}
self.presenter = None
self.cache_billboard = {}
self.cc = CacheCenter(tsid, ssid)
self.mode = Question
self.idle_state = IdleState(self)
self.ready_state = ReadyState(self)
self.timing_state = TimingState(self)
self.timeup_state = TimeupState(self)
self.statistics_state = StatisticsState(self)
self.answer_state = AnswerState(self)
self.announce_state = AnnounceState(self)
self.award_state = AwardState(self)
self.ending_state = EndingState(self)
self.state = self.idle_state
self.SetState(self.idle_state)
self.loopGetBillboard()
def getUsersList():
from models import WebApiSetting
web_api_settings = WebApiSetting.objects.all();
if len(web_api_settings)>0:
sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url)
kwargs = {'action': 'get_users'}
status, reason, resp_str = sd.sendData(kwargs)
#print '>>',resp_str
#resp_str = '{"users":[{"login": "******", "daemon_restrictions":{"detect":{"rpsec":10,"rpmin":10},"detect_and_identification":{"rpsec":10,"rpmin":10},"fanstudio":{"rpsec":10,"rpmin":10}},"ip_list":["192.168.0.166","192.168.0.152"]},{"login": "******", "daemon_restrictions":{"detect":{"rpsec":10,"rpmin":10},"detect_and_identification":{"rpsec":10,"rpmin":10},"fanstudio":{"rpsec":10,"rpmin":10}},"ip_list":["192.168.0.166","192.168.0.152","192.168.0.6","192.168.1.1","192.168.0.55","192.168.0.2","192.16.0.166","19.16.0.1","192.168.0.3","192.168.0.152","192.168.1.166","192.168.1.2"]}]}'
if status != SUCCESS:
resp = {}
else:
resp = json.loads(resp_str)
if 'users' in resp:
users = resp["users"]
else:
users = []
else:
users = []
return users
def postDataStatistics(request):
form = StatisticForm(request.REQUEST, request.FILES)
data = dict()
if not form.is_valid():
return json_response({"status": FORM_ERR, "result": 'Повторите запрос позже'})
login = form.cleaned_data["user_login"]
s_date = form.cleaned_data['start_date']
e_date = form.cleaned_data['end_date']
query = form.cleaned_data['query']
data["user_login"] = login
kwargs = {'user': login, 'query': query, 'start_date': s_date, 'end_date': e_date}
from models import WebApiSetting
web_api_settings = WebApiSetting.objects.all();
if len(web_api_settings)==0:
logging.error("videoclient.configuration.web_api_users.wiews.postDataStatistics(connection failed) :" + 'Отсутствуют настройки для WEB API')
return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'})
sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].stat_url)
status, reason, resp = sd.sendData(kwargs)
del sd
if status == ERROR400:
return json_response({"status": LOGIN_ERR, "result": 'Неизвестный пользователь'})
if status != SUCCESS:
return json_response({"status": ERROR, "result": 'Стастистика временно недоступна. Повторите запрос позже.'})
stat = json.loads(resp)
#если данных для отображения на графике нет, то выводим сообщение
if not filter(lambda x: len(filter(lambda x:x[1] > 0, x['data'])) > 0, stat):
return json_response({"status": NO_DATA, "result": 'Отсутствуют данные за указанный период'})
e = {}
e['resp'] = resp
return json_response({'result': e, 'status': OK})
def postChangeKeyAccess(request):
form = UserForm(request.REQUEST, request.FILES)
if not form.is_valid():
return json_response({"status": FORM_ERR, "result": 'Ошибка формы'})
login = form.cleaned_data["user_login"]
new_key = passgen(16)
kwargs = {'action': 'change_password', 'login': login, 'new_password': new_key}
from models import WebApiSetting
web_api_settings = WebApiSetting.objects.all();
if len(web_api_settings)==0:
logging.error("videoclient.configuration.web_api_users.wiews.postChangeKeyAccess(connection failed) :" + 'Отсутствуют настройки для WEB API')
return json_response({"status": ERROR, "result": 'Повторите запрос позже'})
sd = Sender(web_api_settings[0].host,web_api_settings[0].port, web_api_settings[0].users_url)
status, reason, resp = sd.sendData(kwargs)
if status == ERROR400:
return json_response({"status":LOGIN_ERR, "result": "Неверное указано имя пользователя"})
elif status != SUCCESS:
logging.error("videoclient.configuration.web_api_users.wiews.changeKeyAccess(connection failed) :" + 'Ошибка соединения при получении списка ip адресов пользователя')
return json_response({"status":ERROR, "result": "Повторите запрос позже"})
return json_response({'status': OK, 'result': str(new_key)})
def changeNotifyTypeByBalance(db):
"""
Принудительно изменяет тип оповещений с sms на емаил при балансе ниже нуля
О каждом изменении оповещает пользователя на смс и мыло
"""
from sender import Sender
accounts = db.getAccountsForChangeNotify()
logging.info("found %d account for change notify type" % len(accounts))
sender = Sender(db)
for account in accounts:
logging.info("process account %s" % account)
acc = db.getAccount(account['id'])
if acc is None:
logging.error('аккаунт не найден')
continue
#сменили тип нотификейшенов
res = db.setAccountNotify(acc['id'], 'email')
logging.debug("change type result %s" % res)
message = "%s: balance < 0, notify type change to email" % acc['login']
res1 = sender.sendNotify(acc, message, 'Notify type change by balance', 'sms')
res2 = sender.sendNotify(acc, message, 'Notify type change by balance', 'email')
logging.debug('result sms - %s; email - %s' % (res1, res2))
if res1 is not True or res2 is not True:
logging.error(res1)
logging.error(res2)
continue
logging.info('success notification of change notify type')
return len(accounts)
def do_work(self, url):
if not isValidScheme(url):
logger.warning("not vaild_scheme")
return None
try:
response = yield self.fetch(url)
except tornado.httpclient.HTTPError as e:
# import traceback
# traceback.print_exc()
# TODO
# Some bug here. Too many file open.
# with open('httperror.txt', "a") as f:
# f.write("Url: %s HTTPError: %s \n"% (url,e.code))
logger.error("Url: %s HTTPError: %s " % (url, e.code))
except:
import traceback
traceback.print_exc()
logger.error("Unknow error with url: %s" % url)
else:
url_gen = self.parse(response)
self.fetch_finished.append(url)
sender = Sender()
for u in url_gen:
sender.add_url(u)
logging.info("fetched %s" % url)
self.fetching -= 1
def init( self, host, port, peers, dirName ):
logging.info( 'Initializing new peer ' + self.getPeerKey( host, port ) )
self.filesDir = dirName
self.host = host
self.port = port
self.peers = peers
self.peerKey = self.getPeerKey( host, port )
self.activePeers = {}
self.waitingQueries = []
self.joined = False
self.status = Status( self.peerKey )
self.status.registerPeer( self.peerKey, {} )
self.sender = Sender( self )
self.rQueue = Queue()
self.shutdownFlag = False
self.start()
def __init__(self):
QMainWindow.__init__(self)
# make variables
self.voltage = 0
self.current = 0
# load gui.ui
self.ui = loadUi('../gui/gui.ui')
self.ui.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
self.ui.destroyed.connect(self.shutdown)
# show window
self.ui.show()
# make new log object
self.log = Log(self.ui)
# make new sender object
self.sender = Sender(self.ui, self.log)
# set events
self.set_events()
# initial reset
self.sender.reset()
# new listener
self.listener = Listener()
# new_data_received signal
self.listener.data_received.connect(self.new_data_received)
# start listener
self.listener.start()
# new interpreter
self.interpreter = Interpreter(self.log, self.ui)
# add tree
self.add_tree()
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.addCarriers()
self.thread = Sender()
self.connect(self.ui.actionAbout, QtCore.SIGNAL('triggered()'), self.showAbout)
self.connect(self.ui.actionQuit, QtCore.SIGNAL('triggered()'), exit)
self.connect(self.ui.button, QtCore.SIGNAL('clicked()'), self.toggle)
self.connect(self.thread, QtCore.SIGNAL("finished()"), self.done)
self.connect(self.thread, QtCore.SIGNAL("terminated()"), self.done)
self.connect(self.thread, QtCore.SIGNAL("plusOne()"), self.plusOne)
self.connect(self.thread, QtCore.SIGNAL("sendingError()"), self.stop)
self.ui.server.setText('127.0.0.1:25') #set default
self.ui.message.setPlainText('SPAM!')
self.ui.statusBar().showMessage('Ready') #broken
def main():
create_queue()
sender = Sender()
receiver = Receiver()
sender.start()
receiver.start()
def run(self):
while True:
try:
self.rep_ip = self._replication_interface()
self.uuid = self._my_uuid()
break
except:
msg = ('Failed to get replication interface or uuid. '
'Aborting.')
return logger.error(msg)
ctx = zmq.Context()
# fs diffs are sent via this publisher.
rep_pub = ctx.socket(zmq.PUB)
rep_pub.bind('tcp://%s:%d' % (self.rep_ip, self.data_port))
# synchronization messages are received in this pull socket
meta_pull = ctx.socket(zmq.PULL)
meta_pull.RCVTIMEO = 100
meta_pull.bind('tcp://%s:%d' % (self.rep_ip, self.meta_port))
total_sleep = 0
while True:
if (os.getppid() != self.ppid):
logger.error('Parent exited. Aborting.')
break
while(not self.pubq.empty()):
msg = self.pubq.get()
rep_pub.send(msg)
# check for any recv's coming
num_msgs = 0
while (num_msgs < 1000):
try:
self.recv_meta = meta_pull.recv_json()
num_msgs = num_msgs + 1
snap_id = self.recv_meta['id']
if (self.recv_meta['msg'] == 'begin'):
rw = Receiver(self.recv_meta)
self.receivers[snap_id] = rw
rw.start()
elif (snap_id not in self.senders):
logger.error('Unknown snap_id(%s) received. Ignoring'
% snap_id)
else:
self.senders[snap_id].q.put(self.recv_meta)
except zmq.error.Again:
break
self._prune_workers((self.receivers, self.senders))
if (int(time.time()) - self.prune_time > 3600):
self.prune_time = int(time.time())
for rs in ReplicaShare.objects.all():
prune_receive_trail(rs.id, logger)
for r in Replica.objects.all():
prune_replica_trail(r.id, logger)
if (total_sleep >= 60 and len(self.senders) < 50):
try:
for r in get_replicas(logger):
rt = get_replica_trail(r.id, logger)
now = datetime.utcnow().replace(second=0,
microsecond=0,
tzinfo=utc)
sw = None
snap_name = 'replication'
rt2 = ReplicaTrail.objects.filter().order_by('-id')
if (len(rt2) != 0):
snap_name = ('%s_%d' % (snap_name, rt2[0].id + 1))
else:
snap_name = ('%s_1' % snap_name)
snap_id = ('%s_%s_%s_%s' %
(self.uuid, r.pool, r.share, snap_name))
if (len(rt) == 0):
logger.debug('new sender for snap: %s' % snap_id)
sw = Sender(r, self.rep_ip, self.pubq, Queue(),
snap_name, self.meta_port,
self.data_port, r.meta_port, self.uuid,
snap_id)
elif (rt[0].status == 'succeeded'):
if (((now - rt[0].end_ts).total_seconds() >
(r.frequency * 60))):
logger.debug('incremental sender for snap: %s'
% snap_id)
sw = Sender(r, self.rep_ip, self.pubq, Queue(),
snap_name, self.meta_port,
self.data_port, r.meta_port,
self.uuid, snap_id, rt[0])
else:
continue
elif (rt[0].status == 'pending'):
prev_snap_id = ('%s_%s_%s_%s' % (self.uuid,
r.pool, r.share, rt[0].snap_name))
if (prev_snap_id in self.senders):
logger.debug('send process ongoing for snap: '
'%s' % snap_id)
continue
logger.debug('%s not found in senders. Previous '
'sender must have Aborted. Marking '
'it as failed' % prev_snap_id)
msg = ('Sender process Aborted. See logs for '
'more information')
data = {'status': 'failed',
'end_ts': now.strftime(settings.SNAP_TS_FORMAT),
'error': msg,
'send_failed': now, }
update_replica_status(rt[0].id, data, logger)
continue
elif (rt[0].status == 'failed'):
snap_name = rt[0].snap_name
# if num_failed attempts > 10, disable the replica
num_tries = 0
for rto in rt:
if (rto.status != 'failed' or
num_tries >= self.MAX_ATTEMPTS or
rto.end_ts < r.ts):
break
num_tries = num_tries + 1
if (num_tries >= self.MAX_ATTEMPTS):
logger.info('Maximum attempts(%d) reached '
'for snap: %s. Disabling the '
'replica.' %
(self.MAX_ATTEMPTS, snap_id))
disable_replica(r.id, logger)
continue
logger.info('previous backup failed for snap: '
'%s. Starting a new one. Attempt '
'%d/%d.' % (snap_id, num_tries,
self.MAX_ATTEMPTS))
prev_rt = None
for rto in rt:
if (rto.status == 'succeeded'):
prev_rt = rto
break
sw = Sender(r, self.rep_ip, self.pubq, Queue(),
snap_name, self.meta_port,
self.data_port, r.meta_port,
self.uuid, snap_id, prev_rt)
else:
logger.error('unknown replica trail status: %s. '
'ignoring snap: %s' %
(rt[0].status, snap_id))
continue
self.senders[snap_id] = sw
sw.daemon = True
sw.start()
total_sleep = 0
except DatabaseError, e:
e_msg = ('Error getting the list of enabled replica '
'tasks. Moving on')
logger.error(e_msg)
logger.exception(e)
time.sleep(1)
total_sleep = total_sleep + 1
