def __init__(self, edrserver, edrinara):
self.server = edrserver
self.inara = edrinara
self._player = EDCmdr()
self.heartbeat_timestamp = None
edr_config = edrconfig.EDRConfig()
self._edr_heartbeat = edr_config.edr_heartbeat()
try:
with open(self.EDR_CMDRS_CACHE, 'rb') as handle:
self.cmdrs_cache = pickle.load(handle)
except:
self.cmdrs_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.cmdrs_max_age())
try:
with open(self.EDR_INARA_CACHE, 'rb') as handle:
self.inara_cache = pickle.load(handle)
except:
self.inara_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.inara_max_age())
try:
with open(self.EDR_SQDRDEX_CACHE, 'rb') as handle:
self.sqdrdex_cache = pickle.load(handle)
except:
self.sqdrdex_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.sqdrdex_max_age())
def __init__(self):
edr_config = edrconfig.EDRConfig()
set_language(config.get("language"))
self.edr_version = edr_config.edr_version()
EDRLOG.log(u"Version {}".format(self.edr_version), "INFO")
self.system_novelty_threshold = edr_config.system_novelty_threshold()
self.place_novelty_threshold = edr_config.place_novelty_threshold()
self.ship_novelty_threshold = edr_config.ship_novelty_threshold()
self.cognitive_novelty_threshold = edr_config.cognitive_novelty_threshold(
)
self.intel_even_if_clean = edr_config.intel_even_if_clean()
self.edr_needs_u_novelty_threshold = edr_config.edr_needs_u_novelty_threshold(
)
self.previous_ad = None
self.blips_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.blips_max_age())
self.cognitive_blips_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.blips_max_age())
self.traffic_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.traffic_max_age())
self.scans_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.scans_max_age())
self.cognitive_scans_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.blips_max_age())
self._email = tk.StringVar(value=config.get("EDREmail"))
self._password = tk.StringVar(value=config.get("EDRPassword"))
# Translators: this is shown on the EDMC's status line
self._status = tk.StringVar(value=_(u"not authenticated."))
self.status_ui = None
visual = 1 if config.get("EDRVisualFeedback") == "True" else 0
self._visual_feedback = tk.IntVar(value=visual)
audio = 1 if config.get("EDRAudioFeedback") == "True" else 0
self._audio_feedback = tk.IntVar(value=audio)
self.player = edentities.EDCmdr()
self.server = edrserver.EDRServer()
self.edrsystems = edrsystems.EDRSystems(self.server)
self.edrcmdrs = edrcmdrs.EDRCmdrs(self.server)
self.edroutlaws = edroutlaws.EDROutlaws(self.server)
self.edrlegal = edrlegalrecords.EDRLegalRecords(self.server)
self.mandatory_update = False
self.crimes_reporting = True
self.motd = []
self.tips = randomtips.RandomTips()
self.help_content = helpcontent.HelpContent()
def __init__(self, server, opponent_kind, client_callback):
self.server = server
self.kind = opponent_kind
self.powerplay = None
self.realtime_callback = client_callback
self.realtime = None
config = edrconfig.EDRConfig()
try:
with open(self.EDR_OPPONENTS_SIGHTINGS_CACHES[opponent_kind],
'rb') as handle:
self.sightings = pickle.load(handle)
except:
self.sightings = lrucache.LRUCache(
config.lru_max_size(), config.opponents_max_age(self.kind))
try:
with open(self.EDR_OPPONENTS_RECENTS_CACHES[opponent_kind],
'rb') as handle:
self.recents = pickle.load(handle)
except:
self.recents = deque(
maxlen=config.opponents_max_recents(self.kind))
self.timespan = config.opponents_recent_threshold(self.kind)
self.reports_check_interval = config.reports_check_interval()
def procesar(path, tam, warm, test): print "Leyendo el archivos de queries y procesando" cache = lrucache.LRUCache(tam) #Declaro el cache LRU con un tamaño dado try: archivo = open (path, "r") except e: print "Error de lectura: " + e query = archivo.readline() #leo la primer linea if warm != 0: #Si el calentamiento es mayor a 0, hay calentamiento cW = 1 #contador de calentamiento while (query != '') and (cW < int(warm)): #Mientras no sea linea vacia o Mientras no haya terminado el calentamiento cache.accessPage(query.strip(), False) #Cacheo pero no hago el recuento de hit, porque es calentamiento cW += 1 #Sumo el contador de calentamiento query = archivo.readline() #leo otra linea cQ = 1 #Contador de queries leidas while (query != '') and (cQ <= test): cache.accessPage(query.strip(), True) #Cacheo y hago el recuento de hit cQ += 1 #Contador de queries query = archivo.readline() #leo otra linea print "Proceso terminado" archivo.close() hit = cache.getTotalHit() return hit
def __init__(self, MapServ_inst, configpath):
TilesRepository.__init__(self, MapServ_inst, configpath)
self.set_repository_path(configpath)
self.tile_cache = lrucache.LRUCache(1000)
self.mapServ_inst = MapServ_inst
self.lock = Lock()
self.missingPixbuf = mapPixbuf.missing()
def __init__(self):
self._overlay = edmcoverlay.Overlay()
self.cfg = {}
self.general_config()
self.must_clear = False
for kind in self.MESSAGE_KINDS:
self.message_config(kind)
self.msg_ids = lrucache.LRUCache(1000, 60 * 15)
def __init__(self, MapServ_inst, configpath):
TilesRepository.__init__(self, MapServ_inst, configpath)
self.tile_cache = lrucache.LRUCache(1000)
self.mapServ_inst = MapServ_inst
self.configpath = configpath
self.lock = Lock()
self.missingPixbuf = mapPixbuf.missing()
self.sqlite3func = SQLite3Funcs( self.configpath, SQLITE3_REPOSITORY_FILE )
def pledged_to(self, power, time_pledged):
if self.kind is not EDROpponents.ENEMIES:
return
if not power or self.powerplay is not power:
config = edrconfig.EDRConfig()
self.recents = deque(
maxlen=config.opponents_max_recents(self.kind))
self.sightings = lrucache.LRUCache(
config.lru_max_size(), config.opponents_max_age(self.kind))
self.powerplay = power
def __init__(self, server):
self.server = server
self.inara = edrinara.EDRInara()
edr_config = edrconfig.EDRConfig()
try:
with open(self.EDR_CMDRS_CACHE, 'rb') as handle:
self.cmdrs_cache = pickle.load(handle)
except:
self.cmdrs_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.cmdrs_max_age())
try:
with open(self.EDR_INARA_CACHE, 'rb') as handle:
self.inara_cache = pickle.load(handle)
except:
self.inara_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.inara_max_age())
def __init__(self, server):
edr_config = edrconfig.EDRConfig()
try:
with open(self.EDR_SYSTEMS_CACHE, 'rb') as handle:
self.systems_cache = pickle.load(handle)
except:
self.systems_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.systems_max_age())
try:
with open(self.EDR_NOTAMS_CACHE, 'rb') as handle:
self.notams_cache = pickle.load(handle)
except:
self.notams_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.notams_max_age())
try:
with open(self.EDR_SITREPS_CACHE, 'rb') as handle:
self.sitreps_cache = pickle.load(handle)
except:
self.sitreps_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.sitreps_max_age())
try:
with open(self.EDR_CRIMES_CACHE, 'rb') as handle:
self.crimes_cache = pickle.load(handle)
except:
self.crimes_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.crimes_max_age())
try:
with open(self.EDR_TRAFFIC_CACHE, 'rb') as handle:
self.traffic_cache = pickle.load(handle)
except:
self.traffic_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.traffic_max_age())
self.reports_check_interval = edr_config.reports_check_interval()
self.notams_check_interval = edr_config.notams_check_interval()
self.timespan = edr_config.sitreps_timespan()
self.server = server
def CreateConnection(self, request: chat.User, context):
users = [request.name, request.othername]
self.requestFromUser[request.othername] = chat.User(name=request.name)
users.sort()
new_key = users[0] + "-" + users[1]
for online_user in self.registeredUsers:
if (online_user.name == request.othername):
if new_key not in self.messages:
self.messages[new_key] = lrucache.LRUCache(max_num_messages)
return chat.Connection(successful=True)
return chat.Connection(successful=False)
def __init__(self, server):
self.server = server
self.timespan = None
self.records_last_updated = None
self.records_check_interval = None
config = edrconfig.EDRConfig()
try:
with open(self.EDR_LEGAL_RECORDS_CACHE, 'rb') as handle:
self.records = pickle.load(handle)
except:
self.records = lrucache.LRUCache(config.lru_max_size(),
config.legal_records_max_age())
self.timespan = config.legal_records_recent_threshold()
self.reports_check_interval = config.legal_records_check_interval()
def message_config(self, kind):
conf = igmconfig.IGMConfig()
self.cfg[kind] = {
"h": {
"x": conf.x(kind, "header"),
"y": conf.y(kind, "header"),
"ttl": conf.ttl(kind, "header"),
"rgb": conf.rgb(kind, "header"),
"size": conf.size(kind, "header"),
"len": conf.len(kind, "header"),
"align": conf.align(kind, "header")
},
"b": {
"x":
conf.x(kind, "body"),
"y":
conf.y(kind, "body"),
"ttl":
conf.ttl(kind, "body"),
"rgb":
conf.rgb(kind, "body"),
"size":
conf.size(kind, "body"),
"len":
conf.len(kind, "body"),
"align":
conf.align(kind, "body"),
"rows":
conf.body_rows(kind),
"cache":
lrucache.LRUCache(conf.body_rows(kind), conf.ttl(kind,
"body")),
"last_row":
0
}
}
if not conf.panel(kind):
return
self.cfg[kind]["panel"] = {
"x": conf.x(kind, "panel"),
"y": conf.y(kind, "panel"),
"x2": conf.x2(kind, "panel"),
"y2": conf.y2(kind, "panel"),
"ttl": conf.ttl(kind, "panel"),
"rgb": conf.rgb(kind, "panel"),
"fill": conf.fill(kind, "panel")
}
def __init__(self, server):
self.server = server
config = edrconfig.EDRConfig()
try:
with open(self.EDR_OUTLAWS_SIGHTINGS_CACHE, 'rb') as handle:
self.sightings = pickle.load(handle)
except:
self.sightings = lrucache.LRUCache(config.lru_max_size(), config.outlaws_max_age())
try:
with open(self.EDR_OUTLAWS_RECENTS_CACHE, 'rb') as handle:
self.recents = pickle.load(handle)
except:
self.recents = deque(maxlen=config.outlaws_max_recents())
self.timespan = config.outlaws_recent_threshold()
self.reports_check_interval = config.reports_check_interval()
class CacheWrapper: # this is kind of a weakref proxy, but hashable
# TODO put that refs in the context
refs = lrucache.LRUCache(5000)
# duh, it works ! TODO: .saveme() on cache eviction
# but there is no memory reduction as the GC does not collect that shit.
# i would guess too many fields, map, context...
def __init__(self, context, addr):
self._addr = addr
self._fname = makeFilenameFromAddr(context, addr)
if not os.access(self._fname, os.F_OK):
raise ValueError()
self._context = context
self.obj = None
def __getattr__(self, *args):
if self.obj is None or self.obj() is None: #
self._load()
return getattr(self.obj(), *args)
def unload(self):
if self._addr in CacheWrapper.refs:
del CacheWrapper.refs[self._addr]
self.obj = None
def _load(self):
if self.obj is not None: #
if self.obj() is not None: #
return self.obj()
try:
p = pickle.load(file(self._fname, 'r'))
except EOFError, e:
log.error('Could not load %s - removing it ' % (self._fname))
os.remove(self._fname)
raise e
if not isinstance(p, AnonymousStructInstance):
raise EOFError('not a AnonymousStructInstance in cache. %s' %
(p.__class__))
p.setContext(self._context)
p._dirty = False
CacheWrapper.refs[self._addr] = p
self.obj = weakref.ref(p)
return
class CacheWrapper:
"""
this is kind of a weakref proxy, but hashable
"""
# TODO put that refs in the context
refs = lrucache.LRUCache(5000)
# duh, it works ! TODO: .saveme() on cache eviction
# but there is no memory reduction as the GC does not collect that shit.
# i would guess too many fields, map, context...
def __init__(self, _context, address):
self.address = address
self._fname = make_filename_from_addr(_context, address)
if not os.access(self._fname, os.F_OK):
raise ValueError("%s does not exists" % self._fname)
self._memory_handler = _context.memory_handler
self.obj = None
def __getattr__(self, *args):
if self.obj is None or self.obj() is None: #
self._load()
return getattr(self.obj(), *args)
def unload(self):
if self.address in CacheWrapper.refs:
del CacheWrapper.refs[self.address]
self.obj = None
def _load(self):
if self.obj is not None: #
if self.obj() is not None: #
return self.obj()
try:
p = pickle.load(file(self._fname, 'r'))
except EOFError as e:
log.error('Could not load %s - removing it %s', self._fname, e)
os.remove(self._fname)
raise e # bad file removed
if not isinstance(p, AnonymousRecord):
raise EOFError("not a AnonymousRecord in cache. %s", p.__class__)
if isinstance(p, CacheWrapper):
raise TypeError("Why is a cache wrapper pickled?")
p.set_memory_handler(self._memory_handler)
p._dirty = False
CacheWrapper.refs[self.address] = p
self.obj = weakref.ref(p)
return
def save(self):
if self.obj() is None:
return
self.obj().save()
def __setstate__(self, d):
log.error('setstate %s' % d)
raise TypeError
def __getstate__(self):
log.error('getstate %s' % self.__dict__)
raise TypeError
def __hash__(self):
return hash(self.address)
def __cmp__(self, other):
return cmp(self.address, other.address)
def __str__(self):
return 'struct_%x' % self.address
def __init__(self, server):
self.reasonable_sc_distance = 1500
self.reasonable_hs_radius = 50
edr_config = edrconfig.EDRConfig()
try:
with open(self.EDR_SYSTEMS_CACHE, 'rb') as handle:
self.systems_cache = pickle.load(handle)
except:
self.systems_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.systems_max_age())
try:
with open(self.EDR_NOTAMS_CACHE, 'rb') as handle:
self.notams_cache = pickle.load(handle)
except:
self.notams_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.notams_max_age())
try:
with open(self.EDR_SITREPS_CACHE, 'rb') as handle:
self.sitreps_cache = pickle.load(handle)
except:
self.sitreps_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.sitreps_max_age())
try:
with open(self.EDR_CRIMES_CACHE, 'rb') as handle:
self.crimes_cache = pickle.load(handle)
except:
self.crimes_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.crimes_max_age())
try:
with open(self.EDR_TRAFFIC_CACHE, 'rb') as handle:
self.traffic_cache = pickle.load(handle)
except:
self.traffic_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.traffic_max_age())
try:
with open(self.EDSM_SYSTEMS_CACHE, 'rb') as handle:
self.edsm_systems_cache = pickle.load(handle)
except:
self.edsm_systems_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.edsm_systems_max_age())
try:
with open(self.EDSM_STATIONS_CACHE, 'rb') as handle:
self.edsm_stations_cache = pickle.load(handle)
except:
self.edsm_stations_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.edsm_stations_max_age())
try:
with open(self.EDSM_FACTIONS_CACHE, 'rb') as handle:
self.edsm_factions_cache = pickle.load(handle)
except:
self.edsm_factions_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.edsm_factions_max_age())
try:
with open(self.EDSM_SYSTEMS_WITHIN_RADIUS_CACHE, 'rb') as handle:
self.edsm_systems_within_radius_cache = pickle.load(handle)
except:
self.edsm_systems_within_radius_cache = lrucache.LRUCache(
edr_config.edsm_within_radius_max_size(),
edr_config.edsm_systems_max_age())
self.reports_check_interval = edr_config.reports_check_interval()
self.notams_check_interval = edr_config.notams_check_interval()
self.timespan = edr_config.sitreps_timespan()
self.timespan_notams = edr_config.notams_timespan()
self.server = server
self.edsm_server = edsmserver.EDSMServer()
import subprocess, shutil, os, re, sys, ConfigParser, time, lrucache, math
import config
from debug import debug_write, fn_attr
info_cache = lrucache.LRUCache(1000)
videotest = os.path.join(os.path.dirname(__file__), 'videotest.mpg')
BAD_MPEG_FPS = ['15.00']
def ffmpeg_path():
return config.get('Server', 'ffmpeg')
# XXX BIG HACK
# subprocess is broken for me on windows so super hack
def patchSubprocess():
o = subprocess.Popen._make_inheritable
def _make_inheritable(self, handle):
if not handle: return subprocess.GetCurrentProcess()
return o(self, handle)
subprocess.Popen._make_inheritable = _make_inheritable
mswindows = (sys.platform == "win32")
if mswindows:
patchSubprocess()
def output_video(inFile, outFile, tsn=''):
if tivo_compatable(inFile, tsn):
debug_write(__name__, fn_attr(), [inFile, ' is tivo compatible'])
f = file(inFile, 'rb')
shutil.copyfileobj(f, outFile)
def __init__(self):
self.cache = lrucache.LRUCache(4096)
def __init__(self):
# can be reset with method `resize`
self._cache = lrucache.LRUCache(self._DEFAULT_CACHE_SIZE)
# never expire
self.max_age = None
self.enable()
