def duringMeasureHook(self, elapsed):
if self._pol_move:
if self._attached_polarizer.status(0)[0] != status.BUSY:
self._pol_move = False
self._start_measurement()
return
# start new measurement when needed
spstatus = self._attached_status_in.read(0)
if spstatus == BUSY:
return
self._nfinished += 1
# after 1 measurement we know approximately how long it takes
if self._nfinished == 1:
self._duration = currenttime() - self._started
# if we have less than an approximate duration to go, stop
if currenttime() > self._started + self._presettime - self._duration:
self.log.info('made %d FTIR measurement(s)', self._nfinished)
self._measuring = False
return
# move to next polarizer position if wanted, else start measuring
if self.polvalues:
polvalue = self.polvalues[self._polindex % len(self.polvalues)]
self._polindex += 1
self.log.debug('moving polarizer to %s', polvalue)
self._pol_move = True
self._attached_polarizer.start(polvalue)
else:
self._start_measurement()
def doIsCompleted(self):
if self._started is None:
return True
if self._dont_stop_flag is True:
return (currenttime() - self._started) >= self._preset['value']
if self._stop is not None:
if currenttime() >= self._stop:
return True
if 'TrueTime' in self._preset:
return self._dev.TrueTime >= self._preset['TrueTime']
elif 'LiveTime' in self._preset:
return self._dev.LiveTime >= self._preset['LiveTime']
elif 'counts' in self._preset:
return self.doRead(0)[2] >= self._preset['counts']
try:
# self.log.warning('poll')
stop = self.poll[0]
return stop < 0
except NicosError:
self._dont_stop_flag = True
# self.log.warning('read poll time failed, waiting for other '
# 'detector(s)...')
return False
return False
async def check_on_restart():
with open('dotabase/ongoing_challenges.txt', 'r') as f:
ongoings = f.readlines()
for ongoing in ongoings:
chal = dict(eval(ongoing))
chalchan = client.get_channel(chal['chnl_id'])
if chal['start_time'] + chal['comp_time'] >= int(currenttime()):
checkchallenge(chal, chalchan)
ongoings.remove(ongoing)
with open('dotabase/ongoing_challenges.txt', 'w') as f:
for el in ongoings:
f.write(el)
elif chal['start_time'] + chal['comp_time'] < int(currenttime()):
reset = 1
task = asyncio.create_task(
waitchallenge(
int(currenttime()) -
(chal['start_time'] + chal['comp_time']), chalchan, reset))
def check(reaction, user):
return user.id == chal['discord_user']
react = await client.wait_for("reaction_add", check=check)
if str(react[0]) == "<a:Emoticon_obs:593495627342676040>":
task.cancel()
def isCompleted(self):
if session.mode == SIMULATION:
return True
if not self.stopflag and self.endtime > currenttime():
# arbitrary choice of max 5s
session.delay(min(5, self.endtime - currenttime()))
return False
if self.duration > 3:
session.endActionScope()
return True
def handle_eta(self, data):
"""Handles the "eta" signal."""
state, eta = data
if state in (SIM_STATES['pending'], SIM_STATES['running']):
self.cur_eta = '<calculation in progress>'
elif state == SIM_STATES['failed']:
self.cur_eta = '<calculation failed>'
elif state == SIM_STATES['success'] and eta > currenttime():
self.cur_eta = formatEndtime(eta - currenttime())
def calculate_new_rate():
all_ids = scrape_all_ids()
new_rates = {}
# Look for a page of the category rates.
for single_id in all_ids:
start_time = currenttime()
driver.get(
f"https://first-website.com/catalog/shops.html?idpat={single_id}")
WebDriverWait(driver, 20).until(
EC.presence_of_element_located((By.TAG_NAME, "tr")))
all_competitors = tuple(driver.find_elements(By.TAG_NAME, "tr")[1:])
# Scrape rates of the category.
child_number = 2
competitors_rates = {}
for competitor in all_competitors:
seller = driver.find_element(
By.CSS_SELECTOR,
f"body > table > tbody > tr:nth-child({child_number}) > td:nth-child(2) > a"
).text
seller_rate = driver.find_element(
By.CSS_SELECTOR,
f"body > table > tbody > tr:nth-child({child_number}) > td:nth-child(4)"
).text
competitors_rates.update(
{seller.lower(): float(f"+{seller_rate}")})
child_number += 1
# Calculate new rate and put it into the overall dictionary.
rates_after_cut = {
key: value
for key, value in competitors_rates.items() if value < MAX_RATE
}
rates_of_main_competitors = {
key: value
for key, value in rates_after_cut.items()
if key in main_competitors
}
new_rate = round(
(max(rates_of_main_competitors.values(), default=0) + 0.01), 2)
new_rates.update({f"rate{single_id}": new_rate})
end_time = currenttime()
# Reduce the CPU load by limiting the speed.
time_difference = end_time - start_time
if time_difference < 2:
wait = 2 - time_difference
sleep(wait)
else:
pass
return new_rates
def doStatus(self, maxage=0):
if self.started:
if self.mode == MASTER and self._attached_input.read(maxage):
self.started = 0
self.triggered = currenttime()
return status.OK, 'triggered'
else:
return status.BUSY, 'waiting'
elif self.triggered:
if self.mode == MASTER and currenttime() > self.triggered + 5:
self.triggered = 0
return status.OK, 'triggered'
return status.OK, ''
def _put_pv_blocking(self, pvparam, value, update_rate=0.1, timeout=60):
if epics.ca.current_context() is None:
epics.ca.use_initial_context()
pv = self._pvs[pvparam]
pv.put(value, use_complete=True)
start = currenttime()
while not pv.put_complete:
if currenttime() - start > timeout:
raise CommunicationError('Timeout in setting %s' % pv.pvname)
session.delay(update_rate)
def preparePoint(self, num, xvalues):
if session.mode == SIMULATION and num > self._simpoints:
session.log.info('skipping %d points...',
self._numpoints - self._simpoints)
duration = session.clock.time - self._sim_start
session.clock.tick(duration * (self._numpoints - self._simpoints))
if self._numpoints < 0 and not self._sweepdevices:
session.log.info('would scan indefinitely, skipping...')
raise StopScan
if num == 1:
self._etime.started = currenttime()
if self._sweeptargets:
try:
self.moveDevices(self._sweepdevices,
self._sweeptargets,
wait=False)
except SkipPoint:
raise StopScan
elif self._delay:
# wait between points, but only from the second point on
session.action('Delay')
session.delay(self._delay)
Scan.preparePoint(self, num, xvalues)
if session.mode == SIMULATION:
self._sim_start = session.clock.time
def _handle_msg(self, time, ttlop, ttl, tsop, key, op, value):
if op not in (OP_TELL, OP_TELLOLD):
return
try:
time = float(time)
except (ValueError, TypeError):
time = currenttime()
try:
value = cache_load(value)
except ValueError:
value = None
if key == 'watchdog/warnings' and self.showwatchdog:
self._process_warnings(value)
return
# self.log.debug('processing %s', [time, ttl, key, op, value])
if key == self._prefix + 'session/master':
self._masteractive = value and op != OP_TELLOLD
if key == self._prefix + 'session/mastersetup':
self._setups = set(value)
# reconfigure displayed blocks
self.reconfigureBoxes()
self.log.info('reconfigured display for setups %s',
', '.join(self._setups))
expired = value is None or op == OP_TELLOLD
# now check if we need to update something
objs = self._keymap.get(key, [])
for obj in objs:
self.signalKeyChange(obj, key, value, time, expired)
def getFollowing(user, chan):
try:
try:
url = ("https://api.twitch.tv/kraken/users/" + user +
"/follows/channels/" + chan)
req = urllib2.Request(url)
req.add_header("Client-ID", tclientid)
resp = urllib2.urlopen(req)
page = json.load(resp)
dateFollowed = page['created_at']
except:
return "0"
#timediff = currenttime()-mktime(strptime(dateFollowed, "%Y-%m-%dT%H:%M:%SZ"))
#delta = timedelta(seconds=timediff-7200)
dif = rd.relativedelta(
datetime.fromtimestamp(currenttime() - 7200),
datetime.fromtimestamp(
mktime(strptime(dateFollowed, "%Y-%m-%dT%H:%M:%SZ"))))
if dif.years != 0:
return "{0} years, {1} months, {2} days, {3} hrs".format(
dif.years, dif.months, dif.days, dif.hours)
if dif.months != 0:
return "{0} months, {1} days, {2} hrs".format(
dif.months, dif.days, dif.hours)
if dif.days != 0:
return "{0} days, {1} hrs, {2} min".format(dif.days, dif.hours,
dif.minutes)
if dif.hours != 0:
return "{0} hours, {1} minutes".format(dif.hours, dif.minutes)
return "{0} minutes, {1} seconds".format(dif.minutes, dif.seconds)
except Exception, e:
print "getFollowing error at Api.py, info:", e
def add_value(self, vtime, value, real=True, use_scale=True):
if not isinstance(value, number_types):
if isinstance(value, string_types):
value = self.string_mapping.setdefault(
value, len(self.string_mapping))
self.info = ', '.join(
'%g=%s' % (v * self.scale + self.offset, k)
for (k, v) in sorted(iteritems(self.string_mapping),
key=lambda x: x[1]))
else:
return
elif use_scale:
value = value * self.scale + self.offset
n, real_n = self.n, self.real_n
arrsize = self.data.shape[0]
self.last_y = value
# do not add value if it comes too fast
if real_n > 0 and self.data[real_n - 1, 0] > vtime - self.interval:
return
self._last_update_time = currenttime()
# double array size if array is full
if n >= arrsize:
# keep array around the size of maxsize
if arrsize >= self.maxsize:
# don't add more points, make existing ones more sparse
data = self.data[:real_n]
new_data = lttb.downsample(data[data[:, 0].argsort()],
n_out=arrsize // 2)
n = self.n = self.real_n = new_data.shape[0]
# can resize in place here
new_data.resize(self.data, (n * 2, 2))
self.data = new_data
else:
# can't resize in place
self.data = np.resize(self.data, (2 * arrsize, 2))
# fill next entry
if not real and real_n < n - 1:
# do not generate endless amounts of synthesized points,
# two are enough (one at the beginning, one at the end of
# the interval without real points)
self.data[n - 1] = vtime, value
else:
self.data[n] = vtime, value
self.n += 1
if real:
self.real_n = self.n
# check sliding window
if self.window:
i = -1
threshold = vtime - self.window
while self.data[i + 1, 0] < threshold and i < n:
if self.data[i + 2, 0] > threshold:
self.data[i + 1, 0] = threshold
break
i += 1
if i >= 0:
self.data[0:n - i] = self.data[i + 1:n + 1].copy()
self.n -= i + 1
self.real_n -= i + 1
self.signal_obj.timeSeriesUpdate.emit(self)
def ask_wc(self, key, ts, time, ttl):
ret = set()
with self._db_lock:
# look for matching keys
for dbkey, entries in iteritems(self._db):
if key not in dbkey:
continue
lastent = entries[-1]
# check for removed keys
if lastent.value is None:
continue
if dbkey.startswith('nocat/'):
dbkey = dbkey[6:]
# check for expired keys
if lastent.ttl:
remaining = lastent.time + lastent.ttl - currenttime()
op = remaining > 0 and OP_TELL or OP_TELLOLD
if ts:
ret.add('%r+%s@%s%s%s\n' % (lastent.time, lastent.ttl,
dbkey, op, lastent.value))
else:
ret.add(dbkey + op + lastent.value + '\n')
elif ts:
ret.add('%r@%s%s%s\n' %
(lastent.time, dbkey, OP_TELL, lastent.value))
else:
ret.add(dbkey + OP_TELL + lastent.value + '\n')
return ret
def __repr__(self):
if self.endtime:
# already started, __repr__ is used for updating status strings.
return str(timedelta(
seconds=round(self.endtime - currenttime())))
else:
return '%g s' % self.duration
def doStart(self):
self._enable_gates()
try:
self._dev.Stop()
self._dev.Clear()
self._dev.Start()
except NicosError:
try:
self._dev.Stop()
self._dev.Init()
self._dev.Clear()
self._dev.Start()
except NicosError:
pass
self._started = currenttime()
self._lastread = currenttime()
def read(self, maxage=0):
rois = self.addfile("")
msg = json.loads(rois)
self._cache.put(self, 'value', msg, currenttime(), self.maxage)
# not put in the cache by Tango
return msg
def lock(self, key, value, time, ttl):
"""Lock handling code, common to both subclasses."""
with self._lock_lock:
entry = self._locks.get(key)
# want to lock?
req, client_id = value[0], value[1:]
if req == OP_LOCK_LOCK:
if entry and entry.value != client_id and \
(not entry.ttl or entry.time + entry.ttl >= currenttime()):
# still locked by different client, deny (tell the client
# the current client_id though)
self.log.debug(
'lock request %s=%s, but still locked by %s',
key, client_id, entry.value)
return [key + OP_LOCK + entry.value + '\n']
else:
# not locked, expired or locked by same client, overwrite
ttl = ttl or 600 # set a maximum time to live
self.log.debug('lock request %s=%s ttl %s, accepted',
key, client_id, ttl)
self._locks[key] = CacheEntry(time, ttl, client_id)
return [key + OP_LOCK + '\n']
# want to unlock?
elif req == OP_LOCK_UNLOCK:
if entry and entry.value != client_id:
# locked by different client, deny
self.log.debug('unlock request %s=%s, but locked by %s',
key, client_id, entry.value)
return [key + OP_LOCK + entry.value + '\n']
else:
# unlocked or locked by same client, allow
self.log.debug('unlock request %s=%s, accepted',
key, client_id)
self._locks.pop(key, None)
return [key + OP_LOCK + '\n']
def _set_next_update(self, message):
if 'update_interval' in message:
self._setROParam('statusinterval',
message['update_interval'] // 1000)
next_update = currenttime() + self.statusinterval
if next_update > self.nextupdate:
self._setROParam('nextupdate', next_update)
def resetTimeout(self, target):
"""Method called to reset the timeout when the device is started to
a new target.
"""
self._timeoutActionCalled = False
timesout = self._getTimeoutTimes(self.read(), target, currenttime())
self._setROParam('_timesout', timesout)
def ask(self, key, ts, time, ttl):
dbkey = key if '/' in key else 'nocat/' + key
with self._db_lock:
if dbkey not in self._db:
return [key + OP_TELLOLD + '\n']
lastent = self._db[dbkey][-1]
# check for already removed keys
if lastent.value is None:
return [key + OP_TELLOLD + '\n']
# check for expired keys
if lastent.ttl:
remaining = lastent.time + lastent.ttl - currenttime()
op = remaining > 0 and OP_TELL or OP_TELLOLD
if ts:
return [
'%r+%s@%s%s%s\n' %
(lastent.time, lastent.ttl, key, op, lastent.value)
]
else:
return [key + op + lastent.value + '\n']
if ts:
return [
'%r@%s%s%s\n' % (lastent.time, key, OP_TELL, lastent.value)
]
else:
return [key + OP_TELL + lastent.value + '\n']
def _history(self):
if self._cache:
self._cache.addCallback(self, 'value', self._cacheCB)
self._subscriptions.append(('value', self._cacheCB))
t = currenttime()
return self._cache.history(self, 'value', t - self.window, t)
return []
def put(self, dev, key, value, time=None, ttl=None, flag=''):
"""Put a value for a given device and subkey.
The value is serialized by this method using `cache_dump()`.
"""
if ttl == 0:
# no need to process immediately-expired values
return
if time is None:
time = currenttime()
ttlstr = ttl and '+%s' % ttl or ''
dbkey = ('%s/%s' % (dev, key)).lower()
with self._dblock:
self._db[dbkey] = (value, time)
dvalue = cache_dump(value)
msg = '%r%s@%s%s%s%s%s\n' % (time, ttlstr, self._prefix, dbkey, flag,
OP_TELL, dvalue)
# self.log.debug('putting %s=%s', dbkey, value)
self._queue.put(msg)
self._propagate((time, dbkey, OP_TELL, dvalue))
if key == 'value' and session.experiment:
session.experiment.data.cacheCallback(dbkey, value, time)
# we have to check rewrites here, since the cache server won't send
# us updates for a rewritten key if we sent the original key
if str(dev).lower() in self._rewrites:
for newprefix in self._rewrites[str(dev).lower()]:
rdbkey = ('%s/%s' % (newprefix, key)).lower()
with self._dblock:
self._db[rdbkey] = (value, time)
self._propagate((time, rdbkey, OP_TELL, dvalue))
if key == 'value' and session.experiment:
session.experiment.data.cacheCallback(rdbkey, value, time)
def __init__(self,
name,
interval,
scale,
offset,
window,
signal_obj,
info=None,
mapping=None):
self.name = name
self.disabled = False
self.signal_obj = signal_obj
self.info = info
self.interval = interval
self.window = window
self.scale = scale
self.offset = offset
# [[x, y], [x, y]] array of data points
self.data = None
# number of actual data points in the array (the array is larger to
# be able to add new data efficiently)
self.n = 0
# number of real datapoints, not considering "synthesized" ones that
# extend the last value when no updates are coming
self.real_n = 0
# the last value to use for synthesized points
self.last_y = None
self.string_mapping = mapping or {}
self._last_update_time = currenttime()
def new_messages_callback(self, messages):
json_messages = {}
for timestamp, msg in messages.items():
try:
if isinstance(msg, str):
# handle "old style" messages
js = json.loads(msg)
if 'next_message_eta_ms' in js:
self._setROParam('statusinterval',
js['next_message_eta_ms'] // 1000)
else:
message = deserialise_x5f2(msg)
js = json.loads(message.status_json)
js['update_interval'] = message.update_interval
self._setROParam('statusinterval',
message.update_interval // 1000)
json_messages[timestamp] = js
next_update = currenttime() + self.statusinterval
if next_update > self.nextupdate:
self._setROParam('nextupdate', next_update)
except Exception as e:
self.log.warning(
'Could not decode message from status topic: %s', e)
if json_messages:
self._status_update_callback(json_messages)
def synthesize_value(self):
if not self.n:
return
delta = currenttime() - self._last_update_time
if delta > self.interval:
self.add_value(self.data[self.n - 1, 0] + delta, self.last_y,
real=False, use_scale=False)
def getHTML(self):
if not self.enabled:
return ''
if not self.data or not self.curves:
return '<span>No data or curves found</span>'
with self.lock:
for i, (d, c) in enumerate(zip(self.data, self.curves)):
try:
# add a point "current value" at "right now" to avoid curves
# not updating if the value doesn't change
now = currenttime()
if d[0][-1] < now - 10:
self.updatevalues(i, now, d[1][-1])
c.x, c.y = self.maybeDownsamplePlotdata(d)
except IndexError:
# no data (yet)
pass
c = self.axes.getCurves()
self.axes.setWindow(c.xmin, c.xmax, c.ymin, c.ymax)
if os.path.isfile(self.tempfile):
os.unlink(self.tempfile)
gr.beginprint(self.tempfile)
gr.setwsviewport(0, self.width * 0.0022, 0, self.height * 0.0022)
try:
self.plot.drawGR()
except Exception as err:
return html.escape('Error generating plot: %s' % err)
finally:
gr.endprint()
gr.clearws()
with open(self.tempfile, 'rb') as fp:
imgbytes = fp.read()
return ('<img src="data:image/svg+xml;base64,%s" '
'style="width: %sex; height: %sex">' %
(b64encode(imgbytes).decode(), self.width, self.height))
def _handle_line(self, line):
# self.log.debug('handling line: %s', line)
match = msg_pattern.match(line)
if not match:
# disconnect on trash lines (for now)
if line:
self.log.warning('garbled line: %r', line)
self.closedown()
return []
# extract and clean up individual values
time, ttlop, ttl, tsop, key, op, value = match.groups()
key = key.lower()
value = value or None # no value -> value gets deleted
try:
time = float(time)
except (TypeError, ValueError):
# some timestamp is required -- note that this assumes clocks not
# to be too far out of sync between server and clients
time = currenttime()
try:
ttl = float(ttl)
except (TypeError, ValueError):
ttl = None
# acceptable syntax: either time1-time2 and time1+ttl; convert to ttl
if ttlop == '-' and ttl:
ttl = ttl - time
# dispatch operations to database object
if op == OP_TELL:
self.db.tell(key, value, time, ttl, self)
elif op == OP_ASK:
if ttl:
return self.db.ask_hist(key, time, time + ttl)
else:
# although passed, time and ttl are ignored here
return self.db.ask(key, tsop, time, ttl)
elif op == OP_WILDCARD:
# time and ttl are currently ignored for wildcard requests
return self.db.ask_wc(key, tsop, time, ttl)
elif op == OP_SUBSCRIBE:
# both time and ttl are ignored for subscription requests,
# but the return format changes when the @ is included
if tsop:
self.ts_updates_on.add(key)
else:
self.updates_on.add(key)
elif op == OP_UNSUBSCRIBE:
if tsop:
self.ts_updates_on.discard(key) # note: discard does not raise
else:
self.updates_on.discard(key)
elif op == OP_TELLOLD:
# the server shouldn't get TELLOLD, ignore it
pass
elif op == OP_LOCK:
return self.db.lock(key, value, time, ttl)
elif op == OP_REWRITE:
self.db.rewrite(key, value)
return []
def message(self, s):
global glo_logging
global glo_log
if glo_logging:
lo=open(glo_log,"a")
lo.write(str(currenttime())+"\n")
lo.write("### "+s+"\n")
lo.close()
def doStart(self):
self._measuring = True
self._polindex = 0
self._pol_move = False
self._nfinished = -1
self._started = currenttime()
self._duration = 0
self._firstfile = self._attached_fileno_in.read(0) + 1
def doReset(self):
speed = sum(self._readspeeds())
if speed > 0.5:
raise NicosError(
self, 'Attention: It is strictly forbidden to '
'reset the chopper system if one or more discs '
'are running!')
self._setROParam('changetime', currenttime())
def _set_seq_status(self, newstatus=status.OK, newstatusstring='unknown'):
"""Set the current sequence status."""
oldstatus = self.status()
self._seq_status = (newstatus, newstatusstring.strip())
self.log.debug(self._seq_status[1])
if self._cache and oldstatus != self._seq_status:
self._cache.put(self, 'status', self._seq_status,
currenttime(), self.maxage)
def getTimeOffset(region="US", path="/enrollment/time.htm"):
"""
Calculates the time difference in seconds as
a floating point number between the local
host and a Blizzard server
"""
from struct import unpack
host = ENROLL_HOSTS.get(region, ENROLL_HOSTS["default"]) # get the host, or fallback to default
response = getServerResponse(None, host, path)
time = int(unpack(">Q", response)[0])
difference = time - int(currenttime() * 1000)
return difference / 1000.0
def run(self):
global glo_stillalive
while (glo_stillalive):
ctime=currenttime()
while (glo_stillalive):
#timer
sleep(1.0)
if currenttime()-ctime>=self.interval:
break
if glo_stillalive:#don't do this if told to quit
#do this the simple and dirty way - convert all the filenames to torrents
# and see if those files are listed in the torrent dir.
filelist=os.listdir(self.filedir)
if self.ignoredirs:
f=0
while f<len(filelist):
if os.path.isdir(os.path.join(self.filedir,filelist[f])):filelist=filelist[:f]+filelist[f+1:]
else:f+=1
tfilelist=[make_torrent_filename(fname) for fname in filelist]
torrlist=os.listdir(self.torrentdir)
mlist=[]
for f in range(len(filelist)):
if not tfilelist[f] in torrlist:
mlist.append(filelist[f])
for i in mlist:
try:
if not make_torrent(self.host,self.port,os.path.join(self.filedir,i),self.torrentdir):
if self.logging:
lo=open(self.log,"a")
lo.write(str(currenttime())+":")
lo.write("TorrentMakerTimer - unknown error making torrent in '"+self.torrentdir+"' from file '"+i+"'.\n")
lo.close()
except Exception, e:
lo=open(self.log,"a")
lo.write(str(currenttime())+":")
lo.write("TorrentMakerTimer - "+str(e)+'\n')
lo.close()
def display(self, data):
global glo_logging
global glo_log
if glo_logging:
lo=open(glo_log,"a")
lo.write(str(currenttime())+"\n")
if not data:
self.message('no torrents')
for x in data:
( name, status, progress, peers, seeds, seedsmsg, dist,
uprate, dnrate, upamt, dnamt, size, t, msg ) = x
lo.write( '"%s": "%s" (%s) - %sP%s%s%.3fD u%0.1fK/s-d%0.1fK/s u%dK-d%dK "%s" \n' % (
name, status, progress, peers, seeds, seedsmsg, dist,
uprate/1000, dnrate/1000, upamt/1024, dnamt/1024, msg) )
lo.close()
return False
def getToken(secret, digits=8, seconds=30, time=None):
"""
Computes the token for a given secret
Returns the token, and the seconds remaining
for that token
"""
from struct import pack, unpack
if time is None:
time = currenttime()
t = int(time)
msg = pack(">Q", int(t / seconds))
r = hmac.new(secret, msg, sha1).digest()
k = r[19]
# Python2 compat
if isinstance(k, str):
k = ord(k)
idx = k & 0x0f
h = unpack(">L", r[idx:idx+4])[0] & 0x7fffffff
return h % (10 ** digits), -(t % seconds - seconds)
def timedigest(): return sha1(str(currenttime()).encode()).digest()
def daemonize(program,log):
"""
Turns the currently running program into a daemon, detaching it from
the console so that it runs in the background.
program:
Filename (not including path) of the program being turned
into a daemon. Used for logging, error reporting, and to
write the pid of the daemon to `/var/run/PROGRAM.pid'.
log:
Filename of the log to be used.
TypeError if a bad parameter is detected.
Terminates the program if the command fails.
Returns pid of the daemon
"""
if not log is None and log=="": log is None
flog = None
if log and os.path.isdir(os.path.split(log)[0]):
flog = open(log,"a")
# log what we're about to do and fork
flog.write(str(currenttime())+"\nDaemonizing:now\n")
flog.flush()
pid = os.fork()
# if fork was successful, exit the parent process so it returns
try:
if pid > 0:
os._exit(0)
except OSError:
if not log is None:
flog.write(str(currenttime())+"\nERROR: fork failed, daemon not started")
flog.flush()
flog.close()
sys.exit(1)
# Print my pid into /var/run/PROGRAM.pid
#unnecessary for testing:
pid = str(os.getpid())
filename = "/var/run/" + program + ".pid"
try:
out_file = open(filename, "w")
out_file.write(pid)
out_file.close()
except IOError:
if not log is None:
flog.write(str(currenttime())+"\nERROR: IOError writing pid "+filename)
flog.flush()
# close any open files
sys.stdin.close()
sys.stdout.close()
sys.stderr.close()
for i in range(1023):
try:
os.close(i)
except OSError:
pass
# redirect stdin to /dev/null
# redirect stdout/err to log files.
sys.stdin = open('/dev/null') # fd 0
#sys.stdout = open(program+'.pyout', 'w') # fd 1
#sys.stderr = open(program+'.pyerr', 'w') # fd 2
sys.stdout = open('/dev/null') # fd 1
sys.stderr = open('/dev/null') # fd 2
# disassociate from parent
os.chdir(os.environ["HOME"]) #must maintain the home directory to keep the logs together
os.setsid()
os.umask(0)
try:
if not log is None:flog.close() # might have been closed by the os.close(#) for loop
except:pass
return pid
try:
if len(sys.argv) < 2:
printHelp(uiname, defaults)
sys.exit(1)
config, args = configfile.parse_configuration_and_args(defaults,
uiname, sys.argv[1:], 0, 1)
if args:
config['torrent_dir'] = args[0]
if not os.path.isdir(config['torrent_dir']):
raise BTFailure("Warning: "+args[0]+" is not a directory")
except BTFailure, e:
#print 'error: ' + str(e) + '\nrun with no args for parameter explanations'
if glo_logging:
lo=open(glo_log,"a")
lo.write(str(currenttime())+"\n")
lo.write('error: ' + str(e) + '\n')
lo.close()
glo_stillalive=False
sys.exit(1)
tmt=TorrentMakerTimer(set[0],set[1],set[2],set[5],set[6],glo_logging,glo_log,get_option("arizonabittorrentignoredirs","True").lower()=="true")
tmt.start()
LaunchMany(config, HeadlessDisplayer(), 'btlaunchmany')
glo_stillalive=False
if exceptions:
#print '\nEXCEPTION:'
#print exceptions[0]
if glo_logging:
lo=open(glo_log,"a")
lo.write(str(currenttime())+"\n")
