def connect_client(hostport):
host, port = hostport.split(':')
port = int(port)
print('connecting %s:%d' % (host, port))
client = rpc.Client(host, port, v6=not args.ipv4)
print('client %s:%d ready' % (host, port))
return client
def call_add_notification(self, reminders_dict):
self.logger.info('Ближайшие события: ' + str(reminders_dict))
results = []
if reminders_dict:
info_messages = []
for values in reminders_dict["d"]:
info_mess = {
"s": [{
"n": "Тип",
"t": "Число целое"
}, {
"n": "ИдПользователя",
"t": "Число целое"
}, {
"n": "ИдКлиента",
"t": "Число целое"
}, {
"n": "ИдЧастноеЛицо",
"t": "Число целое"
}, {
"n": "ИдОблака",
"t": "Строка"
}, {
"n": "Примечание",
"t": "Текст"
}, {
"n": "Канал",
"t": "Запись"
}],
# {"n": "Действие", "Строка"}
"d": []
}
new_values = deepcopy(values[4:])
new_values.insert(0, 5)
info_mess["d"].extend(new_values)
info_messages.append(info_mess)
self.logger.info('Список из отсылаемых параметров ИнфСообщение: ' +
str(info_messages))
else:
return results
try:
for info_mess in info_messages:
cl = rpc.Client(self.notification_service)
result = cl.call('ОповещенияПользователей.ДобавитьУведомление',
_site='/notice',
ИнфСообщение=info_mess)
results.append(result)
self.logger.info('Результаты добавления уведомлений: ' +
str(results))
return results
except Exception:
self.logger.error(self._get_tb_info())
return results
def call_save_data(self, xml):
if xml:
try:
cl = rpc.Client(self.service_address, is_https=True)
cl.auth('Демо', 'Демо123')
interval_end = self.current_datetime.timestamp() # Чтобы сериализация в json не ломалась, преобразуем в вещественное число.
result = cl.call('ЭлектроннаяПроходная.СохранитьДанные', Идентификатор=self.clock_house_ip, файл=xml, КонецИнтервала=interval_end)
self.logger.info('Метод СохранитьДанные() вернул {}'.format(result))
except Exception:
self.logger.error(self._get_tb_info())
else:
self.logger.info('Метод СохранитьДанные() не отработал')
def call_nearest_reminders(self):
try:
cl = rpc.Client(self.inside_address, is_https=True)
cl.auth(self.user, self.password)
remiders_dict = cl.call('Напоминания.СписокБлижайшихСобытий',
ДопПоля=None,
Навигация=None,
Сортировка=None,
Фильтр=None)
return remiders_dict
except Exception:
self.logger.error(self._get_tb_info())
return {}
def put(uptoken, key, data, extra=None):
""" put your data to Qiniu
If key is None, the server will generate one.
data may be str or read()able object.
"""
fields = {
}
if not extra:
extra = PutExtra()
if extra.params:
for k in extra.params:
fields[k] = str(extra.params[k])
if extra.check_crc:
fields["crc32"] = str(extra.crc32)
if key is not None:
fields['key'] = key
fields["token"] = uptoken
fname = key
if fname is None:
fname = _random_str(9)
elif fname is '':
fname = 'index.html'
files = [
{'filename': fname, 'data': data, 'mime_type': extra.mime_type},
]
ret, err, code = rpc.Client(conf.UP_HOST).call_with_multipart("/", fields, files)
if err is None or code / 100 == 4 or code == 579 or code / 100 == 6 or code / 100 == 7:
return ret, err
ret, err, code = rpc.Client(conf.UP_HOST2).call_with_multipart("/", fields, files)
return ret, err
def call_delivery_result(self, results, reminders_dict):
if results and all(results):
try:
cl = rpc.Client(self.inside_address, is_https=True)
cl.auth(self.user, self.password)
identifiers = [l[0] for l in reminders_dict["d"]]
self.logger.info('Идентификаторы успешных уведомлений: ' +
str(identifiers))
deliv_res = cl.call('Напоминания.РезультатРассылки',
Список=identifiers)
self.logger.info('метод РезультатРассылки вернул ' +
str(deliv_res))
return deliv_res
except Exception:
self.logger.error(self._get_tb_info())
return None
def call_last_update_time(self):
try:
cl = rpc.Client(self.service_address, is_https=True)
cl.auth('Демо', 'Демо123')
dt = cl.call('ЭлектроннаяПроходная.ВремяПоследнегоОбновления', Идентификатор=self.clock_house_ip)
except Exception:
self.logger.error(self._get_tb_info())
dt = None
if dt is None: # Сделаем заглушку даты вчерашним днём.
dt = self.current_datetime - timedelta(days=1)
self.logger.info('метод ВремяПоследнегоОбновления вернул None')
return dt
self.logger.info('Значение времени последнего обновления - {}'.format(dt))
dt = datetime.strptime(dt+'00', "%Y-%m-%d %H:%M:%S%z") # Формат из метода ВремяПоследнегоОбновления()
return dt
def get_response_from_wi(self):
client = rpc.Client('wi.sbis.ru')
try:
response = client.call('Вопрос.СписокВопросов',
ДопПоля=[],
Навигация=None,
Сортировка=None,
Фильтр={
'd': [True],
's': [{
't': 'Логическое',
'n': 'ТолькоНеРешенные'
}]
})
return response
except Exception:
self.logger.error(traceback.print_exc())
response = {}
return response
def put(uptoken, key, data, extra):
action = ["/rs-put"]
action.append(urlsafe_b64encode("%s:%s" % (extra.bucket, key)))
if extra.mime_type is not None:
action.append("mimeType/%s" % urlsafe_b64encode(extra.mime_type))
if extra.custom_meta is not None:
action.append("meta/%s" % urlsafe_b64encode(extra.custom_meta))
fields = [
("action", '/'.join(action)),
("auth", uptoken),
]
if extra.callback_params is not None:
fields.append(("params", extra.callback_params))
files = [("file", key, data)]
return rpc.Client(config.UP_HOST).call_with_multipart(
"/upload", fields, files)
import rpc
import time
from context import lab_logging
lab_logging.setup()
cl = rpc.Client()
cl.run()
base_list = rpc.DBList({'foo'})
result_list = cl.append('bar', base_list)
print("Result: {}".format(result_list.value))
cl.stop()
import time
import rpc
import sys
import combined_index
import search_server
hostnames = sys.argv[1:]
print("Load local index")
ci = combined_index.CombinedIndexDeep1B()
print("connect to clients")
clients = []
for host in hostnames:
client = rpc.Client(host, 12012, v6=False)
clients.append(client)
# check if all servers respond
print("sizes seen by servers:", [cl.get_ntotal() for cl in clients])
# aggregate all clients into a one that uses them all for speed
# note that it also requires a local index ci
sindex = search_server.SplitPerListIndex(ci, clients)
sindex.verbose = True
# set reasonable parameters
ci.set_parallel_mode(1)
ci.set_prefetch_nthread(0)
ci.set_omp_num_threads(64)
# -*- coding: utf-8 -*-
import rpc
import sys
if __name__ == '__main__':
sys.argv.pop(0)
service = rpc.Client(worker=sys.argv.pop(0))
uptime = service.uptime(timeout=10, async=True)
print service.hello()
print uptime.get()
if isa:
port += 2
class A(object):
def a(self):
return "a"
a1 = A()
a2 = A()
rs = rpc.Server(host, port)
rs.add_service("ra1", a1)
rs.add_service("ra2", a2)
rc = rpc.Client(host, reg_port)
rc.req("reg", "add", rs.info())
if isb:
port += 3
class B(object):
def b(self):
return "b"
b1 = B()
b2 = B()
rs = rpc.Server(host, port)
rs.add_service("rb1", b1)
rs.add_service("rb2", b2)
