async def test_only_send_duplicates(time, debug_worker: DebugWorker,
config: Config, global_info: GlobalInfo,
server, error_store: ErrorStore):
config.override(Setting.SEND_ERROR_REPORTS, True)
config.override(Setting.DRIVE_HOST_NAME, "localhost")
global_info.failed(Exception("boom1"))
firstExceptionTime = time.now()
await debug_worker.doWork()
report = error_store.last_error
assert report['report']["error"] == getLogger("test").formatException(
Exception("boom1"))
assert report['report']["time"] == firstExceptionTime.isoformat()
# Same exception shouldn't cause us to send the error report again
time.advance(days=1)
global_info.failed(Exception("boom1"))
await debug_worker.doWork()
report = error_store.last_error
assert report['report']["error"] == getLogger("test").formatException(
Exception("boom1"))
assert report['report']["time"] == firstExceptionTime.isoformat()
# Btu a new one will send a new report
global_info.failed(Exception("boom2"))
await debug_worker.doWork()
report = error_store.last_error
assert report['report']["error"] == getLogger("test").formatException(
Exception("boom2"))
assert report['report']["time"] == time.now().isoformat()
async def test_send_error_report(time, debug_worker: DebugWorker,
config: Config, global_info: GlobalInfo,
server, error_store: ErrorStore):
config.override(Setting.SEND_ERROR_REPORTS, True)
config.override(Setting.DRIVE_HOST_NAME, "localhost")
global_info.sync()
global_info.success()
global_info.sync()
global_info.success()
global_info.sync()
global_info.failed(Exception())
await debug_worker.doWork()
report = error_store.last_error
assert report['report']['sync_success_count'] == 2
assert report['report']['sync_count'] == 3
assert report['report']['failure_count'] == 1
assert report['report']['sync_last_start'] == time.now().isoformat()
assert report['report']['failure_time'] == time.now().isoformat()
assert report['report']['error'] == getLogger("test").formatException(
Exception())
from injector import Module, provider, singleton, multiprovider
from typing import List
from backup.config import Config, Startable, Setting
from backup.drive import DriveSource
from backup.ha import HaSource, HaUpdater, AddonStopper
from backup.model import BackupDestination, BackupSource, Scyncer
from backup.util import Resolver
from backup.model import Coordinator
from backup.worker import Trigger, Watcher
from backup.ui import UiServer, Restarter
from backup.logger import getLogger
from backup.debug import DebugServer
from .debugworker import DebugWorker
from .tracing_session import TracingSession
logger = getLogger(__name__)
class BaseModule(Module):
'''
A module shared between tests and main
'''
def __init__(self, override_dns=True):
self._override_dns = override_dns
@multiprovider
@singleton
def getTriggers(self, coord: Coordinator, ha: HaSource, drive: DriveSource,
watcher: Watcher, server: UiServer) -> List[Trigger]:
return [coord, ha, drive, watcher, server]
import json
import os
from backup.config import Config, Setting
from backup.worker import Worker
from backup.exceptions import SupervisorFileSystemError
from .harequests import HaRequests
from injector import inject, singleton
from backup.time import Time
from backup.logger import getLogger
from datetime import timedelta
from asyncio import Lock
LOGGER = getLogger(__name__)
CHECK_DURATION = timedelta(seconds=60)
ATTR_STATE = "state"
ATTR_WATCHDOG = "watchdog"
ATTR_NAME = "name"
STATE_STOPPED = "stopped"
STATE_STARTED = "started"
@singleton
class AddonStopper(Worker):
@inject
def __init__(self, config: Config, requests: HaRequests, time: Time):
super().__init__("StartandStopTimer", self.check, time, 10)
self.requests = requests
self.config = config
self.time = time
self.must_start = set()
import os
import json
from backup.logger import getLogger, StandardLogger
from injector import inject, singleton
from google.cloud import logging
from google.auth.exceptions import DefaultCredentialsError
basic_logger = getLogger(__name__)
@singleton
class CloudLogger(StandardLogger):
@inject
def __init__(self):
super().__init__(__name__)
self.google_logger = None
if os.environ.get('GOOGLE_APPLICATION_CREDENTIALS') is not None:
try:
google_logger_client = logging.Client()
self.googler_logger = google_logger_client.logger("refresh_server")
except DefaultCredentialsError:
basic_logger.error("Unable to start Google Logger, no default credentials")
def log_struct(self, data):
if self.google_logger is not None:
self.google_logger.log_struct(data)
else:
basic_logger.info(json.dumps(data))
