class SpeakerThread(threading.Thread):
config = inject.attr(Config)
def __init__(self, wordsQueue):
super(SpeakerThread, self).__init__()
self.wordsQueue = wordsQueue
self._stop = threading.Event()
def finish(self):
print 'terminando thread'
self._stop.set()
def run(self):
name = self.config.configs['espeak_name']
rate = int(self.config.configs['espeak_rate'])
espeak.set_voice(name)
espeak.set_parameter(espeak.Parameter.Rate, rate)
while not self._stop.isSet():
try:
phrase = self.wordsQueue.get(True, 0.05)
espeak.synth(phrase.encode('utf8'))
except Queue.Empty:
continue
class IDHAndlers(HTTPMethodView):
mongo = inject.attr(Mongo)
async def get(self, request, doc_id):
doc = await self.mongo.get_doc(doc_id=doc_id)
if doc:
return HTTPResponse(body=self.mongo.docs_to_json(doc),
content_type="application/json")
else:
raise sanic.exceptions.NotFound(
message='Cannot find document with'
' id:{0}'.format(doc_id))
async def post(self, request, doc_id):
new_doc = request.json
update_result = await self.mongo.insert_or_update(doc=new_doc,
doc_id=doc_id)
if update_result["result"] == "updated":
return text('Successfully updated document with id:{0}'.
format(update_result['updated_id']))
else:
raise sanic.exceptions.ServerError(
message='Failed to update document')
async def delete(self, request, doc_id):
delete_result = await self.mongo.delete_doc(doc_id=doc_id)
if delete_result:
return text(body='Successfully deleted document with id:{0}'.format(doc_id))
else:
raise sanic.exceptions.NotFound(message='Cannot find document with'
' id:{0}'.format(doc_id))
class TestHostStompEngine(unittest.TestCase):
engine = inject.attr('stompEngine')
def setUp(self):
self.stompProtocol = StompProtocolFactory().buildProtocol(
('127.0.0.1', 0))
self.fakeTransport = proto_helpers.StringTransport()
def tearDown(self):
self.fakeTransport.clear()
def test_connection(self):
self.stompProtocol.makeConnection(self.fakeTransport)
#ignore the connection request sent. We aren't testing that here
self.fakeTransport.clear()
#pretend we've received successful ack of our connection request.
#check that the host engine subscribes to the topics upon connection
connectedMsg = """CONNECTED
session:ID:snorky.local-49191-1185461799654-3:18"""
self.stompProtocol.dataReceived(connectedMsg)
msg1 = stomper.subscribe(destinations.CONN_DESTINATION)
msg2 = stomper.subscribe(destinations.CMD_RES_DESTINATION)
self.assertTrue(msg1 in self.fakeTransport.value())
self.assertTrue(msg2 in self.fakeTransport.value())
class TestUserEndpoint:
repository = inject.attr(UserRepository)
def setup(self):
self.mongo_client.db.users.drop()
def test_delete(self, client):
"""
Delete user
"""
user_id = uuid.uuid4()
user = User(id=UserId(user_id),
name=UserName(f"User"))
self.repository.save(user)
response = client.delete(f"/user/{user_id}")
assert response.status_code == HTTPStatus.NO_CONTENT
def test_post(self, client):
"""
Create a new video posting("/users")
"""
user_payload = {
"id": str(uuid.uuid4()),
"name": "Test user"
}
response = client.post("/users", json=user_payload)
assert response.status_code == HTTPStatus.NO_CONTENT
class Connection:
registry = inject.attr(Registry)
def __init__(self):
self.name = '{}.{}'.format(self.__class__.__module__,
self.__class__.__name__)
self.host = self.registry.get(self.name, 'host')
self.database = self.registry.get(self.name, 'database')
self.user = self.registry.get(self.name, 'user')
self.password = self.registry.get(self.name, 'password')
self.pool = psycopg2.pool.ThreadedConnectionPool(
10,
20,
host=self.host,
database=self.database,
user=self.user,
password=self.password,
cursor_factory=DictCursor)
def get(self):
return self.pool.getconn()
def put(self, conn):
self.pool.putconn(conn)
class UserService:
user_repository = inject.attr(UserRepository)
def create_user(self):
from flask import current_app
user1 = self.user_repository.create(email=current_app.config['FLASKY_ADMIN'], username='******', password='******',
confirmed=True)
user2 = self.user_repository.create(email='*****@*****.**', username='******', password='******', confirmed=True)
self.user_repository.add(user1)
self.user_repository.add(user2)
def generate_fake(self, count=100):
import forgery_py
for i in range(count):
u = self.user_repository.create(
email=forgery_py.internet.email_address(),
username=forgery_py.internet.user_name(True),
password=forgery_py.lorem_ipsum.word(),
confirmed=True,
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True)
)
self.user_repository.add(u)
def add_self_follows(self):
for user in self.user_repository.all():
if not user.is_following(user):
user.follow(user)
self.user_repository.add(user)
class Dispatcher:
rec = inject.attr(records.UserRec)
def dispatch(self, user_id):
user: entities.User = self.rec.get(user_id)
return getattr(Context, user.context, None)
class InviteMember(GenericAPIView):
bh = inject.attr(BaseHandler)
serializer_class = InviteMemberSerializer
permission_classes = [IsAuthenticated, IsLeadTeam]
def post(self, request, id):
from django.db import transaction
user_id = request.POST.get('user_id')
id_team = request.data['team_id']
if id == id_team:
user = User.objects.get(pk=user_id)
team = Team.objects.get(pk=id_team)
with transaction.atomic():
invite_member = UserTeam.objects.create(
team=team,
user=user,
roll='MEMBER',
status='PENDING',
)
serializer = InviteMemberSerializer(team)
context = {'message': 'Invite member successfull!'}
return Response(
context,
status=status.HTTP_201_CREATED,
)
else:
context = {"message": "Forbiden"}
return Response(context, status=status.HTTP_403_FORBIDDEN)
class ListUserInvite(GenericAPIView):
bh = inject.attr(BaseHandler)
serializer_class = InviteSerializer
permission_classes = [IsAuthenticated, IsLeadTeam]
def get(self, request, id):
id_team = request.data['team_id']
if id == id_team:
users_list = User.objects.filter(
~Q(userteam__team_id=id_team),
is_superuser=False).order_by('date_joined')
result_limit = request.GET.get('result_limit', RESULT_LIMIT)
page = request.GET.get('page', PAGE_DEFAULT)
paginator = Paginator(users_list, result_limit)
try:
users = paginator.page(page)
except PageNotAnInteger:
users = paginator.page(PAGE_DEFAULT)
except EmptyPage:
users = paginator.page(paginator.num_pages)
serializer = InviteSerializer(users, many=True)
content = {
'id_team': id_team,
'result_count': users_list.count(),
'page': int(page),
'next_page_flg': users.has_next(),
'result': serializer.data,
}
return Response(content)
else:
context = {"message": "Forbiden"}
return Response(context, status=status.HTTP_403_FORBIDDEN)
class UserUseCase:
repo: IUserRepo = inject.attr(IUserRepo)
def create_user(self, name: Name) -> UserCreatedResult:
user = User.create(name)
self.repo.save_user(user)
return UserCreatedResult(
id=user.id.value,
name=user.name
)
def list_users(self, request: BulkRequest) -> UserListResult:
return UserListResult(users=self.repo.list_users(request))
def change_name(self, user_id: UserID, new_name: Name) -> ChangeNameResult:
user = self.repo.get_user(user_id)
if not user:
raise RuntimeError('User not found')
old_name = user.name
user.name = new_name
if not self.repo.save_user(user):
raise RuntimeError('Save user failed')
return ChangeNameResult(
new_name=new_name,
old_name=old_name
)
class InvitationUpdate(UpdateModelMixin, GenericAPIView):
bh = inject.attr(BaseHandler)
serializer_class = InvitationUpdateSerializer
permission_classes = [
IsAuthenticated,
IsNormalUser,
]
lookup_field = 'pk'
queryset = UserTeam.objects.all()
def update(self, request, *args, **kwargs):
instance = self.get_object()
serializer = self.get_serializer(instance, data=kwargs, partial=True)
response = self.bh.validate(serializer)
if response is not None:
return response
serializer.save()
context = {"message": "Update invitation successfully"}
return Response(
context,
status=status.HTTP_200_OK,
)
def patch(self, request, *args, **kwargs):
kwargs['status'] = 'ACCEPTED'
return self.update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
kwargs['status'] = 'REJECTED'
return self.update(request, *args, **kwargs)
class BookingCancel(UpdateModelMixin, GenericAPIView):
bh = inject.attr(BaseHandler)
serializer_class = BookingCancelSerializer
permission_classes = [
IsAuthenticated,
]
lookup_field = 'pk'
queryset = StadiumRegister.objects.all()
def update(self, request, *args, **kwargs):
instance = self.get_object()
serializer = self.get_serializer(instance, data=kwargs, partial=True)
response = self.bh.validate(serializer)
if response is not None:
return response
serializer.save()
context = {"message": "Cancel this booking successfully"}
return Response(
context,
status=status.HTTP_200_OK,
)
def put(self, request, *args, **kwargs):
kwargs['status'] = 'CANCEL'
return self.update(request, *args, **kwargs)
class BlockInspector(object):
rpc_client = inject.attr(ParityEthJsonRpc)
current_block = 0
def __init__(self):
self.current_block = self.rpc_client.eth_blockNumber()
def get_prev_block(self) -> Transaction:
return self.__get_another_block(-1)
def __get_another_block(self, step: int):
logger = logging.getLogger()
# logger.error(e, exc_info=True, extra={"txid": transaction['hash']})
while True:
print(self.current_block)
block = self.rpc_client.eth_getBlockByNumber(self.current_block)
if block is None:
time.sleep(5)
logger.info("Sleeping on ",
extra={"number": self.current_block})
continue
self.current_block = hex_to_dec(block['number']) + step
logger.info("Fetched new block",
extra={"number": self.current_block - 1})
return block
def get_next_block(self) -> Transaction:
return self.__get_another_block(1)
class TestUsersEndpoint:
repository = inject.attr(UserRepository)
def setup(self):
self.mongo_client.db.users.drop()
def test_get(self, client):
"""
return all the users getting("/users")
"""
for i in range(0, random.randint(1, 10)):
user = User(id=UserId(uuid.uuid4()),
name=UserName(f"User {i}"))
self.repository.save(user)
response = client.get("/users")
assert response.status_code == HTTPStatus.OK
assert response.headers['Content-Type'] == 'application/json'
assert json.loads(response.data) == [UserEncoder.encode(u) for u in self.repository.all()]
def test_post(self, client):
"""
Create a new video posting("/users")
"""
user_payload = {
"id": str(uuid.uuid4()),
"name": "Test user"
}
response = client.post("/users", json=user_payload)
assert response.status_code == HTTPStatus.NO_CONTENT
class AccountLimitedRepository(BaseRepository):
account = inject.attr(Account)
def filter(self, *args, **kwargs):
filter_kwargs = {'account': self.account}
kwargs.update(filter_kwargs)
return super(AccountLimitedRepository, self).filter(*args, **kwargs)
class TestCommandRegistry(unittest.TestCase):
stompProtocol = inject.attr('stompProtocol')
def setUp(self):
self.cmdRegistry = Host.CommandRegistry()
self.names = ("testVM1", "testVM2")
self.ids = ("DE:AD:BE:EF:00:01", "DE:AD:BE:EF:00:02")
self.descriptors = map(lambda i: EntityDescriptor(i), self.ids)
for d in self.descriptors:
self.cmdRegistry.vmRegistry.addVM(d)
self.fakeTransport = proto_helpers.StringTransport()
def tearDown(self):
self.fakeTransport.clear()
def test_processCmdResult(self):
#depends on the implementation of VMWords
self.cmdRegistry.sendCmdRequest(self.names[0], 'fooCmd')
rxdFrame = stomper.unpack_frame(self.cmdRegistry.msgSender.data)
cmdId = rxdFrame['headers']['cmd-id']
self.assertIn(cmdId, self.cmdRegistry._cmdReqsSent)
reqSent = self.cmdRegistry._cmdReqsSent[cmdId]
self.cmdRegistry.processCmdResult(rxdFrame)
self.assertIn(cmdId, self._cmdReqsRcvd)
self.assertEquals(reqSent, self._cmdReqsRcvd[cmdId])
self.assertEquals(reqSent, self._cmdReqsRetired[cmdId])
class SessionService:
session = None
session_factory = inject.attr(SessionFactory)
def new_game(self, game_type):
self.session = self.session_factory.create(game_type)
return self.session.game.type
def add_user(self, name):
self.session.add_user(name)
return name
def add_users(self, names):
self.session.add_users(names)
return names
def remove_user(self, name):
self.session.remove_user(name)
return name
def remove_users(self, names):
self.session.remove_users(names)
return names
def get_players(self):
if self.session is None:
raise SessionNotStartedException
return self.session.get_players()
def draw(self):
return self.session.draw()
class SimpleEventsListComponent(BaseMainWindowSection):
"""Events list component"""
name = 'Simple Events List'
plugin_proxy: plugins.PluginProxy = inject.attr(plugins.PluginProxy)
def __init__(self):
super(SimpleEventsListComponent, self).__init__()
self.setLayout(QtWidgets.QVBoxLayout())
self.list_widget = QtWidgets.QListWidget()
self.list_widget.setMinimumSize(QtCore.QSize(0, 100))
self.list_widget.setMaximumSize(QtCore.QSize(16777215, 150))
self.list_widget.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.list_widget.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAsNeeded)
self.list_widget.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.list_widget.setAutoScroll(False)
self.list_widget.setEditTriggers(
QtWidgets.QAbstractItemView.NoEditTriggers)
self.list_widget.setProperty("showDropIndicator", False)
self.list_widget.setDefaultDropAction(QtCore.Qt.IgnoreAction)
self.list_widget.setSelectionMode(
QtWidgets.QAbstractItemView.NoSelection)
self.layout().addWidget(self.list_widget)
def on_journal_event(self, event: journal.Event):
"""Add journal event name to list widget"""
self.list_widget.insertItem(0, event.name)
count = self.list_widget.count()
if count > 10:
diff = count - 10
for i in range(1, diff + 1):
self.list_widget.takeItem(count - i)
class FindStudent:
students = inject.attr(Students)
events = inject.attr(Events)
profiles = inject.attr(Profiles)
config = inject.attr(Config)
def handleAction(self, server, message):
if (message['action'] != 'findStudent'):
return False
if 'student' not in message:
response = {
'id': message['id'],
'error': 'no existe la info del estudiante'
}
server.sendMessage(response)
return True
if 'id' not in message['student']:
response = {
'id': message['id'],
'error': 'no existe la info del estudiante'
}
server.sendMessage(response)
return True
""" chequeo que exista la sesion, etc """
sid = message['session']
self.profiles.checkAccess(sid, ['ADMIN', 'USER'])
con = psycopg2.connect(
host=self.config.configs['database_host'],
dbname=self.config.configs['database_database'],
user=self.config.configs['database_user'],
password=self.config.configs['database_password'])
try:
st = message['student']
student = self.students.findStudent(con, st['id'])
response = {'id': message['id'], 'student': student, 'ok': ''}
server.sendMessage(response)
return True
finally:
con.close()
class CreateStudent:
students = inject.attr(Students)
events = inject.attr(Events)
profiles = inject.attr(Profiles)
config = inject.attr(Config)
def handleAction(self, server, message):
if (message['action'] != 'createStudent'):
return False
if 'student' not in message:
response = {
'id': message['id'],
'error': 'no existe la info del estudiante'
}
server.sendMessage(response)
return True
""" chequeo que exista la sesion, etc """
sid = message['session']
self.profiles.checkAccess(sid, ['ADMIN'])
con = psycopg2.connect(
host=self.config.configs['database_host'],
dbname=self.config.configs['database_database'],
user=self.config.configs['database_user'],
password=self.config.configs['database_password'])
try:
student = message['student']
self.students.createStudent(con, student)
con.commit()
response = {'id': message['id'], 'ok': ''}
server.sendMessage(response)
event = {'type': 'UserUpdatedEvent', 'data': student['id']}
self.events.broadcast(server, event)
return True
except psycopg2.DatabaseError as e:
con.rollback()
raise e
finally:
con.close()
class Handler(threading.Thread):
alive = True
router = inject.attr('Router')
logger = inject.attr('Logger')
def __init__(self, socket):
super().__init__()
self.transport = Transport(socket)
self.client = self.__build_client(self.transport)
threading.local().client = self.client
def run(self):
threading.Thread(name=self.name, target=self.__ping).start()
while self.alive:
try:
packet = self.transport.recv_packet()
if packet:
self.router.route(self.client, packet)
except SocketDisconnect:
self.stop()
except Exception:
self.logger.exception("Exception!", exc_info=True)
def stop(self):
self.logger.debug("Stopping client thread..")
self.alive = False
threading.local().client = None
try:
self.transport.close()
except OSError:
pass
def __build_client(self, transport):
return Client(transport)
def __ping(self):
def ping(self):
try:
self.logger.debug("Ping client")
ping = PingClient()
ping.ServerTime = int(time.time())
self.transport.send_packet(ping)
except SocketDisconnect:
self.stop()
util.periodically(lambda: ping(self), lambda: self.alive,
int(os.getenv("CLIENT_CHECK_TIMEOUT", 5)))
class Transport:
closed = False
null_enumerator = b'\0'
buffer = b''
chunk_size = 1024
logger = inject.attr('Logger')
def __init__(self, socket):
self.socket = socket
self.logger.debug("Connected!")
def send_packet(self, packet):
any = Any()
Any.Pack(any, packet)
return self.__send(any.SerializeToString())
def recv_packet(self):
if self.closed:
raise SocketDisconnect()
while not self.closed:
try:
if self.null_enumerator in self.buffer:
packets = self.buffer.split(self.null_enumerator)
self.buffer = self.null_enumerator.join(packets[1:])
packet = packets[0]
self.logger.debug("Received packet: " + str(packet))
return self.__parse_packet(packet)
else:
recv = self.socket.recv(self.chunk_size)
if recv == "":
self.close()
self.buffer += recv
except:
self.close()
def __send(self, data):
try:
self.socket.sendall(data + self.null_enumerator)
except:
self.close()
def __parse_packet(self, packet):
any = Any()
any.ParseFromString(packet)
cl = util.import_procotol_class(any.type_url.split("/")[1])
unpacked_message = cl()
any.Unpack(unpacked_message)
return unpacked_message
def close(self):
if self.closed:
return
self.closed = True
try:
self.socket.shutdown(socket.SHUT_RDWR)
self.socket.close()
finally:
self.logger.debug("Disconnected!")
raise SocketDisconnect()
class StadiumHandler(GenericAPIView):
bh = inject.attr(BaseHandler)
serializer_class = ListStadiumSerializer
def get(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.query_params)
response = self.bh.validate(serializer)
if response is not None:
return response
request_data = {
k: (lambda x: int(x))(v)
for k, v in request.query_params.items()
if v is not None and v != ''
}
timestamp_time_from = datetime.fromtimestamp(request_data['time_from'])
time_from_dt = timestamp_time_from.strftime('%Y-%m-%d %H:%M:%S+00')
timestamp_time_to = datetime.fromtimestamp(request_data['time_to'])
time_to_dt = timestamp_time_to.strftime('%Y-%m-%d %H:%M:%S+00')
stadium_registed_list = StadiumRegister.objects.filter(
(Q(time_from__lt=time_from_dt) & Q(time_to__gt=time_from_dt)
| Q(time_from__lt=time_to_dt) & Q(time_to__gt=time_to_dt))
& ~Q(status='Cancel')).values_list('stadium_id').all()
stadium_available = Stadium.objects.exclude(
id__in=stadium_registed_list).order_by('id')
if ('min_price' in request_data) & ('max_price' in request_data):
stadium_available = stadium_available.filter(
price__range=(request_data['min_price'],
request_data['max_price']))
response_stadium_list = []
for stadium_list in stadium_available:
stadium = ListStadiumResponse(
stadium_list.id,
stadium_list.name,
stadium_list.lat,
stadium_list.lng,
stadium_list.phone_number,
stadium_list.email,
stadium_list.price,
stadium_list.bank_num,
)
response_stadium_list.append(stadium)
result_limit = request.GET.get('result_limit', RESULT_LIMIT_DEFAULT)
page = request.GET.get('page', PAGE_DEFAULT)
paginator = Paginator(stadium_available, result_limit)
try:
stadiums = paginator.page(page)
except PageNotAnInteger:
stadiums = paginator.page(PAGE_DEFAULT)
except EmptyPage:
stadiums = paginator.page(paginator.num_pages)
serializer = StadiumSerializer(stadiums, many=True)
response_data = {
"result_count": stadium_available.count(),
"page": int(page),
"next_page_flg": stadiums.has_next(),
"stadium": serializer.data,
}
return Response(response_data)
class PostService:
user_repository = inject.attr(UserRepository)
post_repository = inject.attr(PostRepository)
def generate_fake(self, count=100):
from random import randint
import forgery_py
user_count = len(self.user_repository.all())
for i in range(count):
id = random.randint(0, user_count - 1)
u = self.user_repository.get(id=id)
p = self.post_repository.create(
body=forgery_py.lorem_ipsum.sentences(randint(1, 3)),
timestamp=forgery_py.date.date(True),
author=u)
self.post_repository.add(p)
class Transport:
car_plates = inject.attr(CarPlates)
auction_provider = inject.attr(AuctionUrlProviderBase)
def find_vin_by_number(self):
pass
def get_auction_url_by_vin(self, vin):
return self.auction_provider.get_auction_url(vin)
def get_auction_url_by_number(self, number):
pass
def handle(self, bot, update):
vin_or_number = update.message.text[7:]
try:
data = self.car_plates.get_data(vin_or_number)
except NotValidNumberOrVin:
with open("media/pulp_fiction.jpg", "rb") as fh:
bot.send_photo(update.message.chat_id,
fh,
caption="Чекни вин или номер",
reply_to_message_id=update.message.message_id)
return
except CarPlatesApiError:
bot.send_message(update.message.chat_id,
"Походу такой тачки нет",
reply_to_message_id=update.message.message_id,
parse_mode=telegram.ParseMode.MARKDOWN)
return
auction_url = ""
if data.auction and data.vin:
auction_url = self.get_auction_url_by_vin(data.vin)
message = (f"{update.message.from_user.name}\n"
f"Вот что найдено:\n"
f"Гос. номер: {data.number}\n"
f"VIN: {data.vin if data.vin else 'Не найден'}\n"
f"Аукцион: {auction_url}")
if data.vin is None:
message = (
f"Поиск VIN'а по Гос номеру WIP.\n"
f"Вин можно найти через @OpenDataUABot или на https://policy-web.mtsbu.ua"
)
bot.send_message(update.message.chat_id,
message,
parse_mode=telegram.ParseMode.MARKDOWN)
class UserService:
repo: IUserRepository = inject.attr(IUserRepository)
def __init__(self, id: str):
self._id = id
def get_user(self) -> Optional[User]:
return self.repo.find_by_id(self._id)
class User(object):
cache = inject.attr(Cache)
def __init__(self, name):
self.name = name
def greet(self):
return '%s, %s' % (self.cache.load_greeting(), self.name)
class GetAssistanceStatus:
profiles = inject.attr(Profiles)
config = inject.attr(Config)
assistance = inject.attr(Assistance)
date = inject.attr(Date)
def handleAction(self, server, message):
if (message['action'] != 'getAssistanceStatus'):
return False
if ('request' not in message) or ('user_id' not in message['request']):
response = {
'id': message['id'],
'error': 'Insuficientes parámetros'
}
server.sendMessage(response)
return True
sid = message['session']
self.profiles.checkAccess(sid, ['ADMIN-ASSISTANCE', 'USER-ASSISTANCE'])
con = psycopg2.connect(
host=self.config.configs['database_host'],
dbname=self.config.configs['database_database'],
user=self.config.configs['database_user'],
password=self.config.configs['database_password'])
try:
userId = message['request']['user_id']
date = None
if 'date' in message['request']:
date = self.date.parse(message['request']['date'])
status = self.assistance.getAssistanceStatus(con, userId, date)
response = {'id': message['id'], 'ok': '', 'response': status}
server.sendMessage(response)
return True
except psycopg2.DatabaseError as e:
raise e
finally:
con.close()
class StreamsetsBalancer:
pipeline_provider = inject.attr(IPipelineProvider)
logger = inject.attr(ILogger)
def __init__(self):
self.streamsets_pipelines: Dict[
IStreamSets, List[IPipeline]] = get_streamsets_pipelines()
def balance(self):
while not self.is_balanced():
pipeline = self.streamsets_pipelines[most_loaded_streamsets(
self.streamsets_pipelines)].pop()
to_streamsets = least_loaded_streamsets(self.streamsets_pipelines)
self._move(pipeline, to_streamsets)
self.logger.info(
f'Moved `{pipeline.get_id()}` to `{pipeline.get_streamsets().get_url()}`'
)
def unload_streamsets(self, streamsets: IStreamSets):
for pipeline in self.streamsets_pipelines.pop(streamsets):
to_streamsets = least_loaded_streamsets(self.streamsets_pipelines)
self._move(pipeline, to_streamsets)
def _move(self, pipeline: IPipeline, to_streamsets: IStreamSets):
self.logger.info(
f'Moving `{pipeline.get_id()}` from `{pipeline.get_streamsets().get_url()}` to `{to_streamsets.get_url()}`'
)
should_start = client.get_pipeline_status(pipeline) in [
IPipeline.STATUS_STARTING, IPipeline.STATUS_RUNNING
]
client.delete(pipeline)
pipeline.set_streamsets(to_streamsets)
client.create(pipeline)
self.pipeline_provider.save(pipeline)
if should_start:
client.start(pipeline)
self.streamsets_pipelines[to_streamsets].append(pipeline)
def is_balanced(self) -> bool:
if len(self.streamsets_pipelines.keys()) < 2:
return True
# streamsets are balanced if the difference in num of their pipelines is 0 or 1
lengths = [
len(pipelines) for pipelines in self.streamsets_pipelines.values()
]
return max(lengths) - min(lengths) < 2
class PersistLaboralInsertionCV:
laboralInsertion = inject.attr(LaboralInsertion)
events = inject.attr(Events)
profiles = inject.attr(Profiles)
config = inject.attr(Config)
def handleAction(self, server, message):
if (message['action'] != 'persistLaboralInsertionCV'):
return False
if 'laboralInsertion' not in message:
response = {'id':message['id'], 'error':'no existe la info correspondiente a insercion laboral '}
server.sendMessage(response)
return True
""" chequeo que exista la sesion, etc """
sid = message['session']
self.profiles.checkAccess(sid,['ADMIN','USER'])
try:
con = psycopg2.connect(host=self.config.configs['database_host'], dbname=self.config.configs['database_database'], user=self.config.configs['database_user'], password=self.config.configs['database_password'])
laboralInsertion = message['laboralInsertion']
laboralInsertion["cv"] = base64.b64decode(laboralInsertion["cv"])
self.laboralInsertion.persistLaboralInsertionCV(con,laboralInsertion)
con.commit()
response = {'id':message['id'], 'ok':''}
server.sendMessage(response)
event = {
'type':'UserUpdatedEvent',
'data':laboralInsertion['id']
}
self.events.broadcast(server,event)
return True
except Exception as e:
con.rollback()
logging.exception(e)
raise e
finally:
con.close()
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
self.date = inject.attr(Date)
self.events = inject.attr(Events)
self.mail = inject.attr(Mail)
self.users = inject.attr(Users)
self.offices = inject.attr(Offices)
self.justifications = inject.attr(Justifications)
