def update():
if 'secret' not in request.json or request.json['secret'] != SECRET:
return abort(403)
values = []
client = None
for rasp in Client.items:
for sensor in rasp.sensors:
name = sensor.name
if name not in request.json: break
if not validator.is_sane(sensor, request.json[name]):
print('Got weird value for sensor %s: %s' % \
(name, request.json[name]))
break
values.append(request.json[name])
else:
if len(values) == len(rasp.sensors):
client = rasp
if not client:
return abort(400)
storage.put(LOCAL_ENV, client, values)
return 'success', 202
def test_elasticache(self):
storage.init(
"ELASTICACHE",
"redis://test2.0vgvbw.ng.0001.usw1.cache.amazonaws.com:6379")
self.assertEqual(storage.elasticache_client.ping(), True)
msg = b"test msg"
storage.put("elasticache-test-key", msg)
self.assertEqual(storage.get("elasticache-test-key"), msg)
def test_query_get_all(self):
uuids = []
uuids.append(storage.put(Person("mouse1", "minnie1", 23, 22.2)).uuid)
uuids.append(storage.put(Person("mouse2", "minnie2", 23, 22.2)).uuid)
uuids.append(storage.put(Person("mouse3", "minnie3", 23, 22.2)).uuid)
uuids.append(storage.put(Person("mouse4", "minnie4", 23, 22.2)).uuid)
persons = storage.get_all(Person, uuids)
self.assertEquals(len(persons), 4)
def test_put(self):
p = Person("philip", "folk", 20)
self.assertIsNone(p.uuid)
p = storage.put(p)
self.assertIsNotNone(p.uuid)
p.name = "petter"
new_p = storage.put(p)
self.assertEqual(new_p.uuid, p.uuid)
def test_delete(self):
storage.insert(Age("mouse", 20))
storage.delete(Age)
saved_objects = storage.find(Age)
self.assertEqual(len(saved_objects), 0)
model = storage.put(Person(name="alabama"))
storage.put(Person(name="orm"))
storage.delete(Person, uuid=model.uuid)
saved_objects = storage.find(Person)
self.assertEqual(len(saved_objects), 1)
def p_put(self):
self.response.headers["Content-Type"] = "text/plain"
user = users.get_current_user()
if user:
if users.is_current_user_admin():
storage.put(self.request.get('title'),
self.request.get('content'),
self.request.get('format'),
self.request.get('key'))
self.redirect("/")
else:
self.error(403)
else:
self.response.headers["Content-Type"] = "text/plain"
self.response.out.write("You don't have permission to post here")
def p_put(self):
self.response.headers["Content-Type"] = "text/plain"
user = users.get_current_user()
if user:
if users.is_current_user_admin():
storage.put(self.request.get('title'),
self.request.get('content'),
self.request.get('format'),
self.request.get('key'))
self.redirect("/")
else:
self.error(403)
else:
self.response.headers["Content-Type"] = "text/plain"
self.response.out.write("You don't have permission to post here")
def main():
# Load configuration
cfg = load_config()
# Configure logger
log_formatter = LogFormatter()
log_handler = logging.StreamHandler()
log_handler.setFormatter(log_formatter)
root_logger = logging.getLogger()
root_logger.addHandler(log_handler)
for name, level in cfg["logging"].items():
logging.getLogger(name).setLevel(level.upper())
# Initialize RPC
logger.info("Initializing RPC channel to %s", cfg["fetcher"]["remote"])
rpc_options = []
for key, value in cfg["fetcher"]["options"].items():
rpc_options.append((key, value))
rpc_channel = grpc.insecure_channel(cfg["fetcher"]["remote"],
options=tuple(rpc_options))
rpc_stub = proto.WxFetcherStub(rpc_channel)
# Initialize Telegram Bot
logger.info("Initializing Telegram bot...")
tg_updater = TelegramUpdater(token=cfg["telegram"]["token"],
use_context=True)
tg_updater.dispatcher.add_handler(wxmpbotStartCommandHandler)
tg_updater.dispatcher.add_handler(wxmpbotTextMessageHandler)
tg_updater.dispatcher.add_handler(wxmpbotInlineQueryHandler)
tg_updater.dispatcher.add_handler(wxmpbotCallbackQueryHandler)
tg_updater.start_polling()
# Get bot info
bot_me = tg_updater.bot.get_me()
logger.info("Serving as @%s (ID: %d)", bot_me.username, bot_me.id)
# Set global storage
put("rpc", "channel", rpc_channel)
put("rpc", "stub", rpc_stub)
put("tg", "updater", tg_updater)
put("tg", "admin", cfg["telegram"]["admin"])
put(
"prefix",
"{}{}".format("https://" if cfg["web"].get("https") else "http://",
cfg["web"]["host"]))
# Set signal handling
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
logger.info("Initialized.")
def test_join(self):
storage.put(Age(name="alabama"))
storage.put(Person(name="alabama", lastname="felipe"))
storage.put(Person(name="alabama", lastname="alabama"))
query = (
Query(Person, alias="p")
.select(["p.*"])
.join(Age, alias="a", on="p.name = a.name")
.where({"p.name": "alabama"})
.order("p.lastname DESC")
)
results = storage.query(query)
self.assertEqual(1, len(results))
self.assertEqual("felipe", results["Person"][0].lastname)
self.assertTrue("Person" in results)
self.assertIsNotNone(results["Person"])
def test_get(self):
person = storage.put(Person(name="alabama"))
person_from_db = storage.get(Person, uuid=person.uuid)
self.assertEqual(person.name, person_from_db.name)
self.assertEqual(person.uuid, person_from_db.uuid)
def test_s3(self):
storage.init("S3", "storage-module-test")
msg = bytes(random.randint(1, 10000))
storage.put("aws-test-key", msg)
self.assertEqual(storage.get("aws-test-key"), msg)
def __save(instance):
"""save an instance"""
put(instance)
def datagramReceived(self, datagram, address):
data = datagram.strip().decode('cp1251')
storage.put(data)
