def setUp(self):
def _fake_fetch_actor(actor_url):
return {'preferredUsername': '******', 'summary': 'cianlr is here'}
os.environ["HOST_NAME"] = "cianisharrypotter.secret"
self.logger = logging.getLogger(__name__)
self.util = UsersUtil(self.logger, None)
self.util._activ_util.fetch_actor = _fake_fetch_actor
def main():
args = get_args()
logger = get_logger('actors_service', args.v)
logger.info('Creating server')
with get_service_channel(logger, "DB_SERVICE_HOST", 1798) as db_chan, \
get_service_channel(logger, "FOLLOWS_SERVICE_HOST", 1641) as follows_chan:
db_stub = database_pb2_grpc.DatabaseStub(db_chan)
follows_stub = follows_pb2_grpc.FollowsStub(follows_chan)
users_util = UsersUtil(logger, db_stub)
activities_util = ActivitiesUtil(logger, db_stub)
host_name = get_host_name(logger)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
servicer = Servicer(logger, users_util, activities_util, db_stub,
host_name, follows_stub)
actors_pb2_grpc.add_ActorsServicer_to_server(servicer, server)
server.add_insecure_port('0.0.0.0:1973')
logger.info("Starting actors service on port 1973")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
args = get_args()
logger = get_logger("article_service", args.v)
db_channel = get_service_channel(logger, "DB_SERVICE_HOST", 1798)
db_stub = database_pb2_grpc.DatabaseStub(db_channel)
create_channel = get_service_channel(logger, "CREATE_SERVICE_HOST", 1922)
create_stub = create_pb2_grpc.CreateStub(create_channel)
search_channel = get_service_channel(logger, "SEARCH_SERVICE_HOST", 1886)
search_stub = search_pb2_grpc.SearchStub(search_channel)
logger.info("Creating article server")
mdc_channel = get_service_channel(logger, "MDC_SERVICE_HOST", 1937)
mdc_stub = mdc_pb2_grpc.ConverterStub(mdc_channel)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
users_util = UsersUtil(logger, db_stub)
recommender_util = RecommendersUtil(logger, db_stub)
post_recommendation_stub = recommender_util.get_post_recommendation_stub()
article_pb2_grpc.add_ArticleServicer_to_server(
ArticleServicer(create_stub, db_stub, mdc_stub, search_stub, logger,
users_util, post_recommendation_stub), server)
server.add_insecure_port('0.0.0.0:1601')
logger.info("Starting article server on port 1601")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
db_channel.close()
create_channel.close()
pass
def __init__(self, logger, db, default=None, env_var=None, recommenders=None):
self._logger = logger
self._db_stub = db
self._users_util = UsersUtil(logger, db)
self.DEFAULT_RECOMMENDER = default
self.ENV_VAR = env_var
self.RECOMMENDERS = recommenders
def setUp(self):
self.db = MockDB()
self.activ_util = ActivitiesUtil(Mock(), self.db)
self.activ_util.build_actor = lambda han, host: f'{host}/ap/@{han}'
self.activ_util.build_inbox_url = lambda han, host: f'{host}/ap/@{han}/inbox'
self.users_util = UsersUtil(Mock(), self.db)
self.servicer = SendLikeServicer(Mock(), self.db, self.users_util,
self.activ_util, "localhost")
self.data = None
self.url = None
self.activ_util.send_activity = self.save_request
def setUp(self):
self.req = upb.LikeUndoDetails(
article_id=3,
liker_handle="cian",
)
self.db = MockDB()
self.activ_util = ActivitiesUtil(Mock(), self.db)
self.users_util = UsersUtil(Mock(), self.db)
self.hostname = "skinny_123"
self.servicer = SendLikeUndoServicer(
Mock(), self.db, self.activ_util, self.users_util, self.hostname)
self.data = None
self.url = None
self.activ_util.send_activity = self.save_request
self.activ_util._get_activitypub_actor_url = lambda host, handle: (host + '/' + handle)
self.activ_util.build_inbox_url = lambda handle, host: (host + '/' + handle + '/inbox')
def main():
logger = get_logger("undo_service")
db_stub = get_db_stub(logger)
activ_util = ActivitiesUtil(logger, db_stub)
users_util = UsersUtil(logger, db_stub)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
undo_pb2_grpc.add_S2SUndoServicer_to_server(
S2SUndoServicer(logger, db_stub, activ_util, users_util), server)
server.add_insecure_port("0.0.0.0:1608")
logger.info("Starting Undo service on port 1608")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
args = get_args()
logger = get_logger("s2s_follow_service", args.v)
users_util = UsersUtil(logger, None)
with get_future_channel(logger, "DB_SERVICE_HOST", 1798) as db_chan, \
get_future_channel(logger, "FOLLOWS_SERVICE_HOST", 1641) as logger_chan:
db_stub = database_pb2_grpc.DatabaseStub(db_chan)
activ_util = ActivitiesUtil(logger, db_stub)
follows_service = follows_pb2_grpc.FollowsStub(logger_chan)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
s2s_follow_pb2_grpc.add_S2SFollowServicer_to_server(
FollowServicer(logger, users_util, activ_util, follows_service,
db_stub), server)
server.add_insecure_port('0.0.0.0:1922')
logger.info("Starting s2s follow server on port 1922")
server.start()
while True:
time.sleep(60 * 60 * 24) # One day
class UsersUtilTest(unittest.TestCase):
def setUp(self):
def _fake_fetch_actor(actor_url):
return {'preferredUsername': '******', 'summary': 'cianlr is here'}
os.environ["HOST_NAME"] = "cianisharrypotter.secret"
self.logger = logging.getLogger(__name__)
self.util = UsersUtil(self.logger, None)
self.util._activ_util.fetch_actor = _fake_fetch_actor
def test_parse_local_username(self):
a, b = self.util.parse_username('admin')
self.assertEqual(a, 'admin')
self.assertIsNone(b)
def test_parse_foreign_username(self):
a, b = self.util.parse_username('*****@*****.**')
self.assertEqual(a, 'cianlr')
self.assertEqual(b, 'neopets.com')
def test_parse_prefixed_local_username(self):
a, b = self.util.parse_username('@admin')
self.assertEqual(a, 'admin')
self.assertIsNone(b)
def test_parse_prefixed_foreign_username(self):
a, b = self.util.parse_username('@[email protected]')
self.assertEqual(a, 'cianlr')
self.assertEqual(b, 'neopets.com')
def test_parse_actor(self):
a, b = self.util.parse_actor('https://neopets.com/@cianlr')
self.assertEqual(a, 'https://neopets.com')
self.assertEqual(b, 'cianlr')
def test_parse_bad_username(self):
with self.assertLogs(self.logger, level='WARNING'):
a, b = self.util.parse_username('a@b@c')
self.assertIsNone(a)
self.assertIsNone(b)
def test_get_or_create_user_from_db_too_many_attempts(self):
resp = self.util.get_or_create_user_from_db(None,
None,
attempt_number=100)
self.assertIsNone(resp)
def main():
logger = get_logger("announce_service")
db_stub = get_db_stub(logger)
article_stub = get_article_stub(logger)
user_util = UsersUtil(logger, db_stub)
activ_util = ActivitiesUtil(logger, db_stub)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
announce_pb2_grpc.add_AnnounceServicer_to_server(
AnnounceServicer(logger, db_stub, user_util, activ_util, article_stub),
server
)
server.add_insecure_port("0.0.0.0:1919")
logger.info("Starting Announce service on port 1919")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
args = get_args()
logger = get_logger("update_service", args.v)
db_stub = get_db_stub(logger)
md_stub = get_md_stub(logger)
activ_util = ActivitiesUtil(logger, db_stub)
users_util = UsersUtil(logger, db_stub)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
update_pb2_grpc.add_S2SUpdateServicer_to_server(
S2SUpdateServicer(logger, db_stub, md_stub, activ_util, users_util),
server)
server.add_insecure_port("0.0.0.0:2029")
logger.info("Starting Update service on port 2029")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
logger = get_logger("likes_service")
db_stub = get_db_stub(logger)
user_util = UsersUtil(logger, db_stub)
activ_util = ActivitiesUtil(logger, db_stub)
recommender_util = RecommendersUtil(logger, db_stub)
post_recommendation_stub = recommender_util.get_post_recommendation_stub()
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
like_pb2_grpc.add_S2SLikeServicer_to_server(
S2SLikeServicer(logger, db_stub, user_util, activ_util,
post_recommendation_stub), server)
server.add_insecure_port("0.0.0.0:1848")
logger.info("Starting Like service on port 1848")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
args = get_args()
logger = get_logger('follows_service', args.v)
logger.info('Creating server')
db_env = 'DB_SERVICE_HOST'
follow_env = 'FOLLOW_ACTIVITY_SERVICE_HOST'
approver_env = 'APPROVER_SERVICE_HOST'
rss_env = 'RSS_SERVICE_HOST'
with get_service_channel(logger, db_env, 1798) as db_chan, \
get_service_channel(logger, follow_env, 1922) as follow_chan, \
get_service_channel(logger, approver_env, 2077) as approver_chan, \
get_service_channel(logger, rss_env, 1973) as rss_chan:
db_stub = database_pb2_grpc.DatabaseStub(db_chan)
rss_stub = rss_pb2_grpc.RSSStub(rss_chan)
follow_stub = s2s_follow_pb2_grpc.S2SFollowStub(follow_chan)
approver_stub = approver_pb2_grpc.ApproverStub(approver_chan)
users_util = UsersUtil(logger, db_stub)
util = Util(logger, db_stub, approver_stub, users_util)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
recommender_util = RecommendersUtil(logger, db_stub)
follow_recommender_stub = recommender_util.get_follow_recommender_stub(
)
follows_servicer = FollowsServicer(logger, util, users_util, db_stub,
follow_stub, approver_stub,
rss_stub, follow_recommender_stub)
follows_pb2_grpc.add_FollowsServicer_to_server(follows_servicer,
server)
server.add_insecure_port('0.0.0.0:1641')
logger.info("Starting follows service on port 1641")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
logger = get_logger("create_service")
logger.info("Creating db connection")
with get_service_channel(logger, "DB_SERVICE_HOST", 1798) as db_chan:
db_stub = database_pb2_grpc.DatabaseStub(db_chan)
users_util = UsersUtil(logger, db_stub)
activ_util = ActivitiesUtil(logger, db_stub)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
approver_pb2_grpc.add_ApproverServicer_to_server(
ApproverServicer(logger, db_stub, activ_util, users_util),
server,
)
server.add_insecure_port('0.0.0.0:2077')
logger.info("Starting approver service on port 2077")
server.start()
while True:
time.sleep(60 * 60 * 24) # One day
def main():
logger = get_logger('recommend_follows_service')
logger.info('Creating server')
with get_service_channel(logger, "DB_SERVICE_HOST", 1798) as db_chan:
db_stub = database_pb2_grpc.DatabaseStub(db_chan)
users_util = UsersUtil(logger, db_stub)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
servicer = FollowRecommendationsServicer(logger, users_util, db_stub)
recommend_follows_pb2_grpc.add_FollowRecommendationsServicer_to_server(
servicer, server)
server.add_insecure_port('0.0.0.0:1973')
logger.info("Starting recommend_follows service on port 1973")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
pass
def main():
logger = get_logger("create_service")
db_channel = get_service_channel(logger, "DB_SERVICE_HOST", 1798)
db_stub = database_pb2_grpc.DatabaseStub(db_channel)
article_channel = get_future_channel(logger, "ARTICLE_SERVICE_HOST", 1601)
article_stub = article_pb2_grpc.ArticleStub(article_channel)
logger.info("Creating create server")
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
users_util = UsersUtil(logger, db_stub)
activ_util = ActivitiesUtil(logger, db_stub)
create_pb2_grpc.add_CreateServicer_to_server(
CreateServicer(db_stub, article_stub, logger, users_util, activ_util),
server
)
server.add_insecure_port('0.0.0.0:1922')
logger.info("Starting create server on port 1922")
server.start()
try:
while True:
time.sleep(60 * 60 * 24) # One day
except KeyboardInterrupt:
db_channel.close()
pass
