def run_server(): # parse arguments import optparse parser = optparse.OptionParser(usage='usage: %prog [options]') parser.add_option('-c', '--conf', dest='conf', default='yastatsd.cfg', help='Path to configuration file') (opt, args) = parser.parse_args() # read config file import ConfigParser conf = ConfigParser.ConfigParser() conf.readfp(open(opt.conf)) # setup logger if conf.has_option('files', 'logging'): import os os.environ['TZ'] = 'Etc/UTC' time.tzset() import logging.config logging.config.fileConfig(open(conf.get('files', 'logging'))) logging.Formatter.converter = time.localtime # start server server = Server( carbon_host=conf.get('carbon', 'host'), carbon_port=conf.getint('carbon', 'port'), send_interval=conf.getint('carbon', 'interval'), pct_threshold=conf.getint('metrics', 'percentile'), prefix=conf.get('metrics', 'prefix') ) server.serve(conf.get('listen', 'host'), conf.getint('listen', 'port'))
def teardown(self): if self.old_tz: os.environ['TZ'] = self.old_tz else: del os.environ['TZ'] if 'tzset' in dir(time): time.tzset()
def format_date(timestamp): FORY = '%Y-%m-%d @ %H:%M' FORM = '%m-%d @ %H:%M' FORH = '%H:%M' os.environ["TZ"] = config.default_timezone time.tzset() r_time = time.strftime(FORM, time.localtime(timestamp)) h_time = time.strftime(FORH, time.localtime(timestamp)) now = int(time.time()) t = now - timestamp if t < 60: format_str = '刚刚' elif t < 60 * 60: min = t / 60 format_str = '%d 分钟前' % min elif t < 60 * 60 * 24: h = t / (60 * 60) format_str = '%d 小时前 %s' % (h, h_time) elif t < 60 * 60 * 24 * 3: d = t / (60 * 60 * 24) if d == 1: format_str = '昨天 ' + r_time else: format_str = '前天 ' + r_time else: format_str = time.strftime(FORY, time.localtime(timestamp)) return format_str
def get_messages(): os.environ['TZ'] = 'Asia/Shanghai' time.tzset() db = MySQLdb.connect("localhost","root","dhdj513758","iems5722") chatroom_id = request.args.get("chatroom_id",0,type = int) page = request.args.get("page",0,type = int) query = "SELECT * FROM messages WHERE chatroom_id = %s" params = (chatroom_id,) cursor = db.cursor() cursor.execute(query,params) messages =cursor.fetchall() string_t = [] if messages is None: db.close() return jsonify(message="<error message>",status="ERROR") else: for row in messages: roww = {} roww["message"]=row[4] roww["user_id"]=row[2] roww["name"]=row[3] roww["timestamp"]=str(row[5]) string_t.append(roww) messages_num = cursor.execute(query,params) total_pages = messages_num / 5 + 1 string_u = string_t[::-1] string = string_u[page * 5 - 5:page * 5] data = { "current_page":page, "messages":string, "total_pages":total_pages, } db.close() return jsonify(data=data,status="OK")
def apply_django_settings(siteconfig, settings_map=None): """ Applies all settings from the site configuration to the Django settings object. """ if settings_map is None: settings_map = get_django_settings_map() for key, setting_data in settings_map.iteritems(): if key in siteconfig.settings: value = siteconfig.get(key) if isinstance(setting_data, dict): setting_key = setting_data['key'] if ('deserialize_func' in setting_data and callable(setting_data['deserialize_func'])): value = setting_data['deserialize_func'](value) else: setting_key = setting_data setattr(settings, setting_key, value) if hasattr(time, 'tzset'): os.environ['TZ'] = settings.TIME_ZONE time.tzset()
def setup_new_conf(self): conf = self.new_conf self.new_conf = None self.cur_conf = conf # Got our name from the globals if 'receiver_name' in conf['global']: name = conf['global']['receiver_name'] else: name = 'Unnamed receiver' self.name = name self.log.load_obj(self, name) print "[%s] Sending us configuration %s" % (self.name, conf) if not self.have_modules: self.modules = mods = conf['global']['modules'] self.have_modules = True logger.log("[%s] We received modules %s " % (self.name, mods)) # Set our giving timezone from arbiter use_timezone = conf['global']['use_timezone'] if use_timezone != 'NOTSET': logger.log("[%s] Setting our timezone to" % (self.name, use_timezone)) os.environ['TZ'] = use_timezone time.tzset()
def get_month(): timestamp = int(time.time()) FORY = '%m' os.environ["TZ"] = config.default_timezone time.tzset() format_str = time.strftime(FORY, time.localtime(timestamp)) return format_str
def update_connections_time_zone(**kwargs): if kwargs['setting'] == 'TIME_ZONE': # Reset process time zone if hasattr(time, 'tzset'): if kwargs['value']: os.environ['TZ'] = kwargs['value'] else: os.environ.pop('TZ', None) time.tzset() # Reset local time zone cache timezone._localtime = None # Reset the database connections' time zone if kwargs['setting'] == 'USE_TZ' and settings.TIME_ZONE != 'UTC': USE_TZ, TIME_ZONE = kwargs['value'], settings.TIME_ZONE elif kwargs['setting'] == 'TIME_ZONE' and not settings.USE_TZ: USE_TZ, TIME_ZONE = settings.USE_TZ, kwargs['value'] else: # no need to change the database connnections' time zones return tz = 'UTC' if USE_TZ else TIME_ZONE for conn in connections.all(): conn.settings_dict['TIME_ZONE'] = tz tz_sql = conn.ops.set_time_zone_sql() if tz_sql: conn.cursor().execute(tz_sql, [tz])
def setUpMyTime(): # Set the time to a fixed, known value # Sun Aug 14 12:00:00 CEST 2005 # yoh: we need to adjust TZ to match the one used by Cyril so all the timestamps match os.environ['TZ'] = 'Europe/Zurich' time.tzset() MyTime.setTime(1124013600)
def update_connections_time_zone(**kwargs): if kwargs["setting"] == "TIME_ZONE": # Reset process time zone if hasattr(time, "tzset"): if kwargs["value"]: os.environ["TZ"] = kwargs["value"] else: os.environ.pop("TZ", None) time.tzset() # Reset local time zone cache timezone.get_default_timezone.cache_clear() # Reset the database connections' time zone if kwargs["setting"] == "USE_TZ" and settings.TIME_ZONE != "UTC": USE_TZ, TIME_ZONE = kwargs["value"], settings.TIME_ZONE elif kwargs["setting"] == "TIME_ZONE" and not settings.USE_TZ: USE_TZ, TIME_ZONE = settings.USE_TZ, kwargs["value"] else: # no need to change the database connnections' time zones return tz = "UTC" if USE_TZ else TIME_ZONE for conn in connections.all(): conn.settings_dict["TIME_ZONE"] = tz tz_sql = conn.ops.set_time_zone_sql() if tz_sql: conn.cursor().execute(tz_sql, [tz])
def read(self, configs, reload=False): # sys.stderr.write("url.read\n") self.cache = None self.metadata = {} config = None try: config = ConfigParser.ConfigParser() fp = urllib2.urlopen(self.resource) headers = dict(fp.info()) config.readfp(fp) fp.close() self.layers = {} self._loadSections(config, configs, reload, cache=self.cache) ##### set last_mtime ##### os.environ["TZ"] = "UTC" time.tzset() # FIXME fixed format is probably wrong mytime = time.strptime(headers["last-modified"], "%a, %d %b %Y %H:%M:%S %Z") self.last_mtime = time.mktime(mytime) except Exception, E: self.metadata["exception"] = E self.metadata["traceback"] = "".join(traceback.format_tb(sys.exc_traceback))
def test_TimeRE_recreation_timezone(self): # The TimeRE instance should be recreated upon changing the timezone. oldtzname = time.tzname tm = _strptime._strptime_time(time.tzname[0], '%Z') self.assertEqual(tm.tm_isdst, 0) tm = _strptime._strptime_time(time.tzname[1], '%Z') self.assertEqual(tm.tm_isdst, 1) # Get id of current cache object. first_time_re = _strptime._TimeRE_cache # Change the timezone and force a recreation of the cache. os.environ['TZ'] = 'EST+05EDT,M3.2.0,M11.1.0' time.tzset() tm = _strptime._strptime_time(time.tzname[0], '%Z') self.assertEqual(tm.tm_isdst, 0) tm = _strptime._strptime_time(time.tzname[1], '%Z') self.assertEqual(tm.tm_isdst, 1) # Get the new cache object's id. second_time_re = _strptime._TimeRE_cache # They should not be equal. self.assertIsNot(first_time_re, second_time_re) # Make sure old names no longer accepted. with self.assertRaises(ValueError): _strptime._strptime_time(oldtzname[0], '%Z') with self.assertRaises(ValueError): _strptime._strptime_time(oldtzname[1], '%Z')
def testApprovedTZFromEnvironmentWithFloating(self): def _restoreTZEnv(result, oldTZ): if oldTZ is None: del os.environ['TZ'] else: os.environ['TZ'] = oldTZ time.tzset() eventcalendar.tz.LOCAL = tz.LocalTimezone() return result new_end_naive = self.half_an_hour_ago.replace(tzinfo=None) oldTZ = os.environ.get('TZ', None) os.environ['TZ'] = 'US/Pacific' time.tzset() eventcalendar.tz.LOCAL = tz.LocalTimezone() data = self.ical_from_specs('', self.half_an_hour_ago, '', new_end_naive) self.bouncer = self.bouncer_from_ical(data) keycard = keycards.KeycardGeneric() d = defer.maybeDeferred(self.bouncer.authenticate, keycard) d.addCallback(self._approved_callback) d.addBoth(_restoreTZEnv, oldTZ) return d
def __init__(self): # Will only work on UNIX if (hasattr(time, 'tzset')): os.environ['TZ'] = 'Europe/London' time.tzset() # DB connection string try: with open('plugins/LogsToDB/config.json') as data: config = json.load(data) conn_string = "host='%s' dbname='%s' user='******' password='******'" % (config['db']['host'], config['db']['dbname'], config['db']['user'], config['db']['password']) except IOError as e: print(os.getcwd()) sys.exit("Error! No config file supplied, please create a config.json file in the root") # Print connection string print("Connecting to database\n -> %s" % (conn_string)) # get a connection conn = psycopg2.connect(conn_string) # conn.curser will return a cursor object, you can use this to perform queries self.cursor = conn.cursor() self.conn = conn print("connected!\n")
def setup(bot): time.tzset() ctime = time.time() bot.memory['kd_queue']=[] try: bot.memory['kd_evnctr']=int(bot.config.kdown.ev_ctr) except: bot.memory['kd_evnctr']=0 print(bot.config.kdown.events) events=unpack_events(bot, bot.config.kdown.events) bot.memory['kd_events']=events print(bot.memory['kd_events']) print() print(bot.memory['kd_queue']) try: subscrl=bot.config.kdown.get_list('subscribers') bot.memory['kd_subscribers']=set() for sub in subscrl: bot.memory['kd_subscribers'].add(sub) print(subscrl,bot.memory['kd_subscribers']) except Exception as e: bot.memory['kd_subscribers']=set() bot.memory.setdefault('ctmutex', threading.BoundedSemaphore(1)) #CheckTime Mutex lstr = lambda o: str(o).lower() admins=set(map(lstr, bot.config.core.get_list('admins'))) admins.update(set(map(lstr, bot.config.kdown.get_list('admins')))) admins.add(bot.config.core.owner) bot.memory['kd_admins'] = admins
def cleanup(): # os.environ.pop is broken! Don't use it! Ever! Or die! try: del os.environ['TZ'] except KeyError: pass time.tzset()
def main(): logging.warning( 'devappserver2.py is currently experimental but will eventually replace ' 'dev_appserver.py in the App Engine Python SDK. For more information and ' 'to report bugs, please see: ' 'http://code.google.com/p/appengine-devappserver2-experiment/') _install_signal_handler() # The timezone must be set in the devappserver2 process rather than just in # the runtime so printed log timestamps are consistent and the taskqueue stub # expects the timezone to be UTC. The runtime inherits the environment. os.environ['TZ'] = 'UTC' if hasattr(time, 'tzset'): # time.tzet() should be called on Unix, but doesn't exist on Windows. time.tzset() options = parse_command_arguments(sys.argv[1:]) dev_server = DevelopmentServer() try: dev_server.start(options) while True: time.sleep(1) except KeyboardInterrupt: pass finally: dev_server.stop()
def set_current_tz(self, tzval): if tzval is UnsetTz and 'TZ' in os.environ: del os.environ['TZ'] else: os.environ['TZ'] = tzval time.tzset()
def _restore_tz(self, tzbackup): if tzbackup is None: if 'TZ' in os.environ: del os.environ['TZ'] else: os.environ['TZ'] = tzbackup time.tzset()
def __init__(self, init_data, raw_feed=None, has_icon=None, icon=None, feedhandler=None, feedtype='usual'): GObject.GObject.__init__(self) tzset() self.url = init_data["url"] self.name = init_data["feed_name"] self.automatic_update = init_data["update_switch"] self.notifications = init_data["notify_switch"] self.update_interval = init_data["update_spin"] self.delete_interval = init_data["delete_spin"] self.new_entries = [] self.has_icon = has_icon self.icon = icon self.feedtype = feedtype self.is_clicked = False self.count_new_entries = 0 self.raw_feed = raw_feed if raw_feed is None: self._download_data() self.update_id = None self.add_updater(self.update_interval)
def test_timezones(): pofile = po.pofile() # The following will only work on Unix because of tzset() and %z if 'tzset' in time.__dict__: os.environ['TZ'] = 'Asia/Kabul' time.tzset() assert time.timezone == -16200 # Typically "+0430" assert poheader.tzstring() == time.strftime("%z") os.environ['TZ'] = 'Asia/Seoul' time.tzset() assert time.timezone == -32400 # Typically "+0900" assert poheader.tzstring() == time.strftime("%z") os.environ['TZ'] = 'Africa/Johannesburg' time.tzset() assert time.timezone == -7200 # Typically "+0200" assert poheader.tzstring() == time.strftime("%z") os.environ['TZ'] = 'Africa/Windhoek' time.tzset() assert time.timezone == -3600 # Typically "+0100" # For some reason python's %z doesn't know about Windhoek DST #assert poheader.tzstring() == time.strftime("%z") os.environ['TZ'] = 'UTC' time.tzset() assert time.timezone == 0 # Typically "+0000" assert poheader.tzstring() == time.strftime("%z")
def getTodayDate(self): import os, time os.environ['TZ'] = "Europe/London" time.tzset() localtime = time.localtime() timeString = time.strftime('%Y%m%d') return(timeString)
def __init__(self): with open('config.json', 'r') as f: self.config = json.load(f) self.conn = Redis(self.config['redis']['host']) os.environ['TZ'] = 'EST' time.tzset()
def reload_django_settings(): mod = util.import_module(os.environ['DJANGO_SETTINGS_MODULE']) # reload module reload(mod) # reload settings. # USe code from django.settings.Settings module. # Settings that should be converted into tuples if they're mistakenly entered # as strings. tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS") for setting in dir(mod): if setting == setting.upper(): setting_value = getattr(mod, setting) if setting in tuple_settings and type(setting_value) == str: setting_value = (setting_value,) # In case the user forgot the comma. setattr(settings, setting, setting_value) # Expand entries in INSTALLED_APPS like "django.contrib.*" to a list # of all those apps. new_installed_apps = [] for app in settings.INSTALLED_APPS: if app.endswith('.*'): app_mod = util.import_module(app[:-2]) appdir = os.path.dirname(app_mod.__file__) app_subdirs = os.listdir(appdir) name_pattern = re.compile(r'[a-zA-Z]\w*') for d in sorted(app_subdirs): if (name_pattern.match(d) and os.path.isdir(os.path.join(appdir, d))): new_installed_apps.append('%s.%s' % (app[:-2], d)) else: new_installed_apps.append(app) setattr(settings, "INSTALLED_APPS", new_installed_apps) if hasattr(time, 'tzset') and settings.TIME_ZONE: # When we can, attempt to validate the timezone. If we can't find # this file, no check happens and it's harmless. zoneinfo_root = '/usr/share/zoneinfo' if (os.path.exists(zoneinfo_root) and not os.path.exists(os.path.join(zoneinfo_root, *(settings.TIME_ZONE.split('/'))))): raise ValueError("Incorrect timezone setting: %s" % settings.TIME_ZONE) # Move the time zone info into os.environ. See ticket #2315 for why # we don't do this unconditionally (breaks Windows). os.environ['TZ'] = settings.TIME_ZONE time.tzset() # Settings are configured, so we can set up the logger if required if getattr(settings, 'LOGGING_CONFIG', False): # First find the logging configuration function ... logging_config_path, logging_config_func_name = settings.LOGGING_CONFIG.rsplit('.', 1) logging_config_module = util.import_module(logging_config_path) logging_config_func = getattr(logging_config_module, logging_config_func_name) # ... then invoke it with the logging settings logging_config_func(settings.LOGGING)
def setUp(self): # Ensure we're in UTC. os.environ['TZ'] = 'UTC' time.tzset() # Start with a fresh api proxy. apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap() # Use a fresh stub datastore. self.__datastore_stub = datastore_file_stub.DatastoreFileStub( APP_ID, '/dev/null', '/dev/null') apiproxy_stub_map.apiproxy.RegisterStub( 'datastore_v3', self.__datastore_stub) os.environ['APPLICATION_ID'] = APP_ID # Use a fresh stub UserService. apiproxy_stub_map.apiproxy.RegisterStub( 'user', user_service_stub.UserServiceStub()) os.environ['AUTH_DOMAIN'] = AUTH_DOMAIN os.environ['USER_EMAIL'] = LOGGED_IN_USER # Use a fresh urlfetch stub. apiproxy_stub_map.apiproxy.RegisterStub( 'urlfetch', urlfetch_stub.URLFetchServiceStub()) # Use a fresh mail stub. apiproxy_stub_map.apiproxy.RegisterStub( 'mail', mail_stub.MailServiceStub())
def updateTime(self, event = None): """When this is called, update all the text boxes with the correct time""" boxWidth = 80 #used to force the window to be the correct width for [tz, title, format, wxtextbox] in self.config: os.environ['TZ'] = tz #set the TZ to that given in the config time.tzset() #set the time zone in the time module dateStr = time.strftime(format) + " " + title boxWidth = max(boxWidth, len(dateStr)*self.pixlesPerCharX) wxtextbox.SetValue(dateStr) if self.paintFormat == self.__PAINT_DIURNAL__ and \ int(time.strftime("%H")) >= 7 and int(time.strftime("%H")) <= 19: #rudimentary check for daylight wxtextbox.SetBackgroundColour(wx.Colour(self.bgA[0], self.bgA[1], self.bgA[2])) if self.paintFormat == self.__PAINT_DIURNAL__ and \ int(time.strftime("%H")) < 7 or int(time.strftime("%H")) > 19: #checking for daylight wxtextbox.SetBackgroundColour(wx.Colour(self.bgB[0], self.bgB[1], self.bgB[2])) for i in range(len(self.config)): #set smallest size and colorize self.config[i][3].SetMinSize([boxWidth, 27]) #set smallest size if (i % 2) == 0 and self.paintFormat == self.__PAINT_ALTERNATING__: self.config[i][3].SetBackgroundColour(wx.Colour(self.bgA[0], self.bgA[1], self.bgA[2])) if (i % 2) == 1 and self.paintFormat == self.__PAINT_ALTERNATING__: self.config[i][3].SetBackgroundColour(wx.Colour(self.bgB[0], self.bgB[1], self.bgB[2])) self.SetMinSize([boxWidth, -1]) self.SetMaxSize([boxWidth, 27*len(self.config)]) try: event.Skip except: pass
def __init__(self): Cmd.__init__(self) os.environ["TZ"] = "UTC" time.tzset() # Try parsing just the arguments that make sense if we're # going to be running an interactive command loop. If that # parses everything, we're interactive, otherwise, it's either # a non-interactive command or a parse error, so we let the full # parser sort that out for us. args, argv = self.top_argparser.parse_known_args() self.interactive = not argv if not self.interactive: args = self.full_argparser.parse_args() self.cfg_file = args.config self.handle = args.identity if args.profile: import cProfile prof = cProfile.Profile() try: prof.runcall(self.main, args) finally: prof.dump_stats(args.profile) print "Dumped profile data to %s" % args.profile else: self.main(args)
def get_year(): timestamp = int(time.time()) FORY = '%Y' os.environ["TZ"] = config.default_timezone time.tzset() str = time.strftime(FORY, time.localtime(timestamp)) return str
def activateTimezone(self, tz, tzarea): if path.exists("/usr/lib/enigma2/python/Plugins/Extensions/AutoTimer/plugin.pyo") and config.plugins.autotimer.autopoll.value: print "[Timezones] trying to stop main AutoTimer poller" self.autopoller.stop() self.ATupdate = True if tzarea == Timezones.gen_label: fulltz = tz else: fulltz = "%s/%s" % (tzarea, tz) tzneed = "%s/%s" % (Timezones.tzbase, fulltz) if not path.isfile(tzneed): print "[Timezones] Attempt to set timezone", fulltz, "ignored. UTC used" fulltz = "UTC" tzneed = "%s/%s" % (Timezones.tzbase, fulltz) print "[Timezones] setting timezone to", fulltz environ['TZ'] = fulltz try: unlink("/etc/localtime") except OSError: pass try: symlink(tzneed, "/etc/localtime") except OSError: pass try: time.tzset() except: from enigma import e_tzset e_tzset() if path.exists("/usr/lib/enigma2/python/Plugins/Extensions/AutoTimer/plugin.pyo") and config.plugins.autotimer.autopoll.value: self.startATupdate()
def update_connections_time_zone(**kwargs): if kwargs['setting'] == 'TIME_ZONE': # Reset process time zone if hasattr(time, 'tzset'): if kwargs['value']: os.environ['TZ'] = kwargs['value'] else: os.environ.pop('TZ', None) time.tzset() # Reset local time zone cache timezone.get_default_timezone.cache_clear() # Reset the database connections' time zone if kwargs['setting'] in {'TIME_ZONE', 'USE_TZ'}: for conn in connections.all(): try: del conn.timezone except AttributeError: pass try: del conn.timezone_name except AttributeError: pass conn.ensure_timezone()
def test_tzset(self): if not hasattr(time, "tzset"): return # Can't test this; don't want the test suite to fail from os import environ # Epoch time of midnight Dec 25th 2002. Never DST in northern # hemisphere. xmas2002 = 1040774400.0 # These formats are correct for 2002, and possibly future years # This format is the 'standard' as documented at: # http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap08.html # They are also documented in the tzset(3) man page on most Unix # systems. eastern = 'EST+05EDT,M4.1.0,M10.5.0' victoria = 'AEST-10AEDT-11,M10.5.0,M3.5.0' utc = 'UTC+0' org_TZ = environ.get('TZ', None) try: # Make sure we can switch to UTC time and results are correct # Note that unknown timezones default to UTC. # Note that altzone is undefined in UTC, as there is no DST environ['TZ'] = eastern time.tzset() environ['TZ'] = utc time.tzset() self.failUnlessEqual(time.gmtime(xmas2002), time.localtime(xmas2002)) self.failUnlessEqual(time.daylight, 0) self.failUnlessEqual(time.timezone, 0) self.failUnlessEqual(time.localtime(xmas2002).tm_isdst, 0) # Make sure we can switch to US/Eastern environ['TZ'] = eastern time.tzset() self.failIfEqual(time.gmtime(xmas2002), time.localtime(xmas2002)) self.failUnlessEqual(time.tzname, ('EST', 'EDT')) self.failUnlessEqual(len(time.tzname), 2) self.failUnlessEqual(time.daylight, 1) self.failUnlessEqual(time.timezone, 18000) self.failUnlessEqual(time.altzone, 14400) self.failUnlessEqual(time.localtime(xmas2002).tm_isdst, 0) self.failUnlessEqual(len(time.tzname), 2) # Now go to the southern hemisphere. environ['TZ'] = victoria time.tzset() self.failIfEqual(time.gmtime(xmas2002), time.localtime(xmas2002)) self.failUnless(time.tzname[0] == 'AEST', str(time.tzname[0])) self.failUnless(time.tzname[1] == 'AEDT', str(time.tzname[1])) self.failUnlessEqual(len(time.tzname), 2) self.failUnlessEqual(time.daylight, 1) self.failUnlessEqual(time.timezone, -36000) self.failUnlessEqual(time.altzone, -39600) self.failUnlessEqual(time.localtime(xmas2002).tm_isdst, 1) finally: # Repair TZ environment variable in case any other tests # rely on it. if org_TZ is not None: environ['TZ'] = org_TZ elif environ.has_key('TZ'): del environ['TZ'] time.tzset()
import shutil import tempfile import time import py7zr import py7zr.archiveinfo import py7zr.cli import py7zr.compression import pytest from . import check_output, decode_all testdata_path = os.path.join(os.path.dirname(__file__), 'data') os.environ['TZ'] = 'UTC' if os.name == 'posix': time.tzset() os.umask(0o022) @pytest.mark.basic def test_basic_initinfo(): archive = py7zr.SevenZipFile( open(os.path.join(testdata_path, 'test_1.7z'), 'rb')) assert archive is not None @pytest.mark.basic def test_basic_list_1(): archive = py7zr.SevenZipFile( open(os.path.join(testdata_path, 'test_1.7z'), 'rb')) output = io.StringIO()
def getString(self): time.tzset() timeString = time.strftime(self.timeFormat) output = [Icons.get('clock1')] output.append(timeString) return " ".join(output)
async def _reload_timeservices(self, **kwargs): await self._service("ix-localtime", "start", quiet=True, **kwargs) await self._service("ix-ntpd", "start", quiet=True, **kwargs) await self._service("ntpd", "restart", **kwargs) os.environ['TZ'] = await self.middleware.call('datastore.query', 'system.settings', [], {'order_by': ['-id'], 'get': True})['stg_timezone'] time.tzset()
def main(*args): """ Process command line arguments and invoke bot. If args is an empty list, sys.argv is used. @param args: command line arguments @type args: str """ filename = None pagename = None namespace = None salt = '' force = False calc = None templates = [] local_args = pywikibot.handle_args(args) for arg in local_args: option, _, value = arg.partition(':') if not option.startswith('-'): templates.append(arg) continue option = option[1:] if option in ('file', 'filename'): filename = value elif option == 'locale': # Required for english month names locale.setlocale(locale.LC_TIME, value.encode('utf8')) elif option == 'timezone': os.environ['TZ'] = value.timezone # Or use the preset value if hasattr(time, 'tzset'): time.tzset() elif option == 'calc': calc = value elif option == 'salt': salt = value elif option == 'force': force = True elif option == 'page': pagename = value elif option == 'namespace': namespace = value site = pywikibot.Site() if calc: if not salt: pywikibot.bot.suggest_help(missing_parameters=['-salt']) return False page = pywikibot.Page(site, calc) if page.exists(): calc = page.title() else: pywikibot.output( 'NOTE: the specified page "{0}" does not (yet) exist.'.format( calc)) pywikibot.output('key = {}'.format(calc_md5_hexdigest(calc, salt))) return if not templates: pywikibot.bot.suggest_help( additional_text='No template was specified.') return False for template_name in templates: pagelist = [] tmpl = pywikibot.Page(site, template_name, ns=10) if not filename and not pagename: if namespace is not None: ns = [str(namespace)] else: ns = [] pywikibot.output('Fetching template transclusions...') for pg in tmpl.getReferences(only_template_inclusion=True, follow_redirects=False, namespaces=ns): pagelist.append(pg) if filename: for pg in open(filename, 'r').readlines(): pagelist.append(pywikibot.Page(site, pg, ns=10)) if pagename: pagelist.append(pywikibot.Page(site, pagename, ns=3)) pagelist = sorted(pagelist) for pg in iter(pagelist): pywikibot.output('Processing {}'.format(pg)) # Catching exceptions, so that errors in one page do not bail out # the entire process try: archiver = PageArchiver(pg, tmpl, salt, force) archiver.run() except ArchiveBotSiteConfigError as e: # no stack trace for errors originated by pages on-site pywikibot.error( 'Missing or malformed template in page {}: {}'.format( pg, e)) except Exception: pywikibot.error( 'Error occurred while processing page {}'.format(pg)) pywikibot.exception(tb=True)
def makeService(options): """ Makes a new swftp-sftp service. The only option is the config file location. See CONFIG_DEFAULTS for list of configuration options. """ from twisted.cred.portal import Portal from swftp.realm import SwftpRealm from swftp.auth import SwiftBasedAuthDB from swftp.utils import (log_runtime_info, GLOBAL_METRICS, parse_key_value_config) c = get_config(options['config_file'], options) smtp_service = service.MultiService() # ensure timezone is GMT os.environ['TZ'] = 'GMT' time.tzset() print('Starting SwFTP-smtp %s' % VERSION) authdb = SwiftBasedAuthDB( c.get('smtp', 'auth_url'), global_max_concurrency=c.getint('smtp', 'num_persistent_connections'), max_concurrency=c.getint('smtp', 'num_connections_per_session'), timeout=c.getint('smtp', 'connection_timeout'), extra_headers=parse_key_value_config(c.get('smtp', 'extra_headers')), verbose=c.getboolean('smtp', 'verbose'), rewrite_scheme=c.get('smtp', 'rewrite_storage_scheme'), rewrite_netloc=c.get('smtp', 'rewrite_storage_netloc'), ) rabbitmq_hosts = c.get('rabbitmq', 'rabbitmq_hosts') rabbitmq_cluster = RabbitClusterClient([RabbitReplica(host, port) \ for host, port in [(h,int(p)) for h,p in [r.split(':') \ for r in rabbitmq_hosts.split(',')]]], \ c.get('rabbitmq', 'username'), \ c.get('rabbitmq', 'password')) \ if rabbitmq_hosts else None queue_name = c.get('smtp', 'queue_name') swift_username = c.get('smtp', 'swift_username') swift_password = c.get('smtp', 'swift_password') def swift_connect(): d = authdb.requestAvatarId( UsernamePassword(swift_username, swift_password)) def cb(connection): return connection def errback(failure): log.err("Swift connection failed: %s" % failure.type) raise SMTPServerError(451, "Internal server error") d.addCallbacks(cb, errback) return d @defer.inlineCallbacks def prepare_path(): swift_conn = yield swift_connect() swift_filesystem = SwiftFileSystem(swift_conn) try: yield swift_filesystem.get_container_listing('smtp', '/') except swift.NotFound: yield swift_filesystem.makeDirectory('/smtp/') defer.returnValue(None) prepare_path() smtp_factory = SwftpSMTPFactory(swift_connect, rabbitmq_cluster,\ queue_name) signal.signal(signal.SIGUSR1, log_runtime_info) signal.signal(signal.SIGUSR2, log_runtime_info) internet.TCPServer(c.getint('smtp', 'port'), smtp_factory, interface=c.get('smtp', 'host')).setServiceParent(smtp_service) return smtp_service
def initTimeZone(): os.environ['TZ'] = 'America/New_York' time.tzset()
def handle_api_tz_get(self, http_context): time.tzset() return { 'tz': self.manager.get_tz(), 'offset': self.manager.get_offset(), }
def test_tzset(self): from os import environ # Epoch time of midnight Dec 25th 2002. Never DST in northern # hemisphere. xmas2002 = 1040774400.0 # These formats are correct for 2002, and possibly future years # This format is the 'standard' as documented at: # http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap08.html # They are also documented in the tzset(3) man page on most Unix # systems. eastern = 'EST+05EDT,M4.1.0,M10.5.0' victoria = 'AEST-10AEDT-11,M10.5.0,M3.5.0' utc = 'UTC+0' org_TZ = environ.get('TZ', None) try: # Make sure we can switch to UTC time and results are correct # Note that unknown timezones default to UTC. # Note that altzone is undefined in UTC, as there is no DST environ['TZ'] = eastern time.tzset() environ['TZ'] = utc time.tzset() self.assertEqual(time.gmtime(xmas2002), time.localtime(xmas2002)) self.assertEqual(time.daylight, 0) self.assertEqual(time.timezone, 0) self.assertEqual(time.localtime(xmas2002).tm_isdst, 0) # Make sure we can switch to US/Eastern environ['TZ'] = eastern time.tzset() self.assertNotEqual(time.gmtime(xmas2002), time.localtime(xmas2002)) self.assertEqual(time.tzname, ('EST', 'EDT')) self.assertEqual(len(time.tzname), 2) self.assertEqual(time.daylight, 1) self.assertEqual(time.timezone, 18000) self.assertEqual(time.altzone, 14400) self.assertEqual(time.localtime(xmas2002).tm_isdst, 0) self.assertEqual(len(time.tzname), 2) # Now go to the southern hemisphere. environ['TZ'] = victoria time.tzset() self.assertNotEqual(time.gmtime(xmas2002), time.localtime(xmas2002)) # Issue #11886: Australian Eastern Standard Time (UTC+10) is called # "EST" (as Eastern Standard Time, UTC-5) instead of "AEST" # (non-DST timezone), and "EDT" instead of "AEDT" (DST timezone), # on some operating systems (e.g. FreeBSD), which is wrong. See for # example this bug: # http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=93810 self.assertIn(time.tzname[0], ('AEST' 'EST'), time.tzname[0]) self.assertTrue(time.tzname[1] in ('AEDT', 'EDT'), str(time.tzname[1])) self.assertEqual(len(time.tzname), 2) self.assertEqual(time.daylight, 1) self.assertEqual(time.timezone, -36000) self.assertEqual(time.altzone, -39600) self.assertEqual(time.localtime(xmas2002).tm_isdst, 1) finally: # Repair TZ environment variable in case any other tests # rely on it. if org_TZ is not None: environ['TZ'] = org_TZ elif 'TZ' in environ: del environ['TZ'] time.tzset()
def reload_django_settings(self, settings_modname): from django.conf import settings from django.utils import importlib mod = importlib.import_module(settings_modname) # reload module reload(mod) # reload settings. # USe code from django.settings.Settings module. # Settings that should be converted into tuples if they're mistakenly entered # as strings. tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS") for setting in dir(mod): if setting == setting.upper(): setting_value = getattr(mod, setting) if setting in tuple_settings and type(setting_value) == str: setting_value = (setting_value, ) # In case the user forgot the comma. setattr(settings, setting, setting_value) # Expand entries in INSTALLED_APPS like "django.contrib.*" to a list # of all those apps. new_installed_apps = [] for app in settings.INSTALLED_APPS: if app.endswith('.*'): app_mod = importlib.import_module(app[:-2]) appdir = os.path.dirname(app_mod.__file__) app_subdirs = os.listdir(appdir) app_subdirs.sort() name_pattern = re.compile(r'[a-zA-Z]\w*') for d in app_subdirs: if name_pattern.match(d) and os.path.isdir( os.path.join(appdir, d)): new_installed_apps.append('%s.%s' % (app[:-2], d)) else: new_installed_apps.append(app) setattr(settings, "INSTALLED_APPS", new_installed_apps) if hasattr(time, 'tzset') and settings.TIME_ZONE: # When we can, attempt to validate the timezone. If we can't find # this file, no check happens and it's harmless. zoneinfo_root = '/usr/share/zoneinfo' if (os.path.exists(zoneinfo_root) and not os.path.exists( os.path.join(zoneinfo_root, *(settings.TIME_ZONE.split('/'))))): raise ValueError("Incorrect timezone setting: %s" % settings.TIME_ZONE) # Move the time zone info into os.environ. See ticket #2315 for why # we don't do this unconditionally (breaks Windows). os.environ['TZ'] = settings.TIME_ZONE time.tzset() # Settings are configured, so we can set up the logger if required if getattr(settings, 'LOGGING_CONFIG', False): # First find the logging configuration function ... logging_config_path, logging_config_func_name = settings.LOGGING_CONFIG.rsplit( '.', 1) logging_config_module = importlib.import_module( logging_config_path) logging_config_func = getattr(logging_config_module, logging_config_func_name) # ... then invoke it with the logging settings logging_config_func(settings.LOGGING)
while True: sys.stdout.write("-----\n") sys.stdout.flush() # TODO 1: write check_file_change & add settings. #self.check_file_change() #sleep(settings.LOOP_INTERVAL) # This will restart on very short downtime, but if it's longer, # the MM will crash entirely as it is unable to connect to the WS on boot. if not self.check_connection(): print('No connection detected! Restarting...') logging.error( "Realtime data connection unexpectedly closed, restarting." ) self.restart() # TODO 2: sanity_check, print_status self.run() #self.sanity_check() # Ensures health of mm - several cut-out points here #self.print_status() # Print skew, delta, etc #self.place_orders() # Creates desired orders and converges to existing orders if __name__ == "__main__": current_hour = datetime.datetime.now().hour os.environ['TZ'] = 'Asia/Saigon' time.tzset() # only available in Unix Market_maker('ETHUSD').run()
def setUp(self): os.environ['TZ'] = 'GMT' time.tzset()
def format_date2(timestamp): FORY = '%Y-%m-%d @ %H:%M' os.environ["TZ"] = config.default_timezone time.tzset() format_str = time.strftime(FORY, time.localtime(timestamp)) return format_str
def tearDownClass(cls): del os.environ["TZ"] if cls.tz_prev is not None: os.environ["TZ"] = cls.tz_prev time.tzset() super(ArrowTests, cls).tearDownClass()
def tearDownClass(cls): del os.environ["TZ"] if cls.tz_prev is not None: os.environ["TZ"] = cls.tz_prev time.tzset() ReusedSQLTestCase.tearDownClass()
def settimezone(timezone): os.environ['TZ'] = timezone time.tzset() return ""
# -*- coding: utf-8 -*- import telebot import io, re, os, time from telebot import types from SQLighter import SQLighter import botan, requests, json, logging os.environ['TZ'] = 'Europe/Moscow' time.tzset() # Настройка времени на сервере # Настройка соединения с Telegram и Botan BOTAN_TOKEN = '' API_TOKEN = '' # Создание клавиатуры по-умолчанию key_default = types.ReplyKeyboardMarkup(resize_keyboard=True) key_default.row(types.KeyboardButton('Добавить страницу ВК 📠')) key_default.row(types.KeyboardButton('Настройки моих страниц 🚀')) key_default.row(types.KeyboardButton('О боте VK Poster 🤖')) key_hide = types.ReplyKeyboardHide(selective=False) key_force = types.ForceReply(selective=False) # Настройка логгера, сохраняющего все входящие сообщения logging.getLogger('requests').setLevel(logging.CRITICAL) logging.basicConfig(format='[%(asctime)s]%(message)s', level=logging.INFO, filename='app.log', datefmt='%d.%m.%Y %H:%M:%S') logger = telebot.logger
def get_day(timestamp): FORY = '%d' os.environ["TZ"] = config.default_timezone time.tzset() str = time.strftime(FORY, time.localtime(timestamp)) return str
def main(args=None): args = parser.parse_args(args) if args.hardening: if platform.system() == 'Windows': # pragma: no cover raise NotImplementedError('require --no-hardening under Windows') if args.setuid is None or isinstance(args.setuid, str): parser.error(f'unknown --setuid user: {args.setuid}') if (args.chroot is None or isinstance(args.chroot, str) or not args.chroot.is_dir()): parser.error(f'not a present --chroot directory: {args.chroot}') logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO, format='%(asctime)s %(message)s', datefmt='%b %d %H:%M:%S') logging.info('start asciimation server on %s port %s', args.host, args.port) @register_signal_handler(signal.SIGINT, signal.SIGTERM) def handle_with_exit(signum, _): sys.exit(f'received signal.{signal.Signals(signum).name}') next(iterframes()) # pre-load FRAMES logging.debug('socket.create_server(%r)', (args.host, args.port)) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind((args.host, args.port)) logging.debug('%r', s) if args.hardening: with pathlib.Path('/etc/timezone').open(encoding='utf-8') as f: tz = f.readline().strip() logging.debug('TZ=%r; time.tzset()', tz) os.environ['TZ'] = tz time.tzset() logging.debug('os.chroot(%r)', args.chroot) os.chroot(args.chroot) logging.debug('os.setuid(%r)', uid) os.setgid(args.setuid.pw_gid) os.setgroups([]) os.setuid(args.setuid.pw_uid) logging.debug('asyncio.run(serve_forever(sock=%r))', s) try: asyncio.run(serve_forever(sock=s, fps=args.fps)) except socket.error: # pragma: no cover logging.exception('socket.error') return 'socket error' except SystemExit as e: logging.info('%r exiting', e) finally: try: s.shutdown(socket.SHUT_WR) except (socket.error, OSError): pass s.close() logging.info('asciimation server stopped') return None
def setup(self): self.old_tz = os.environ.get('TZ') os.environ['TZ'] = 'UTC' # time.tzset() is not implemented on some platforms (notably, Windows). if hasattr(time, 'tzset'): time.tzset()
def get_timestamp(): os.environ['TZ'] = 'Singapore' time.tzset() timestamp = time.strftime("%Y%m%d-%H.%M.%S") return timestamp
def main(): """Main() for gatherer. """ global LOGGER global PUB opts = arg_parse() CONFIG.read(opts.config) print("Setting timezone to UTC") os.environ["TZ"] = "UTC" time.tzset() handlers = [] if opts.log: handlers.append( logging.handlers.TimedRotatingFileHandler(opts.log, "midnight", backupCount=7)) handlers.append(logging.StreamHandler()) if opts.verbose: loglevel = logging.DEBUG else: loglevel = logging.INFO for handler in handlers: handler.setFormatter( logging.Formatter( "[%(levelname)s: %(asctime)s :" " %(name)s] %(message)s", '%Y-%m-%d %H:%M:%S')) handler.setLevel(loglevel) logging.getLogger('').setLevel(loglevel) logging.getLogger('').addHandler(handler) logging.getLogger("posttroll").setLevel(logging.INFO) LOGGER = logging.getLogger("gatherer") if opts.config_item: for section in opts.config_item: if section not in CONFIG.sections(): LOGGER.warning( "No config item called %s found in config file.", section) for section in CONFIG.sections(): if section not in opts.config_item: CONFIG.remove_section(section) if len(CONFIG.sections()) == 0: LOGGER.error("No valid config item provided") return nameservers = [] for section in CONFIG.sections(): try: nameserver = CONFIG.get(section, "nameserver") except NoOptionError: nameserver = "localhost" if nameserver not in nameservers: nameservers.append(nameserver) decoder = get_metadata PUB = publisher.NoisyPublisher("gatherer", nameservers=nameservers) granule_triggers = setup(decoder) PUB.start() for granule_trigger in granule_triggers: granule_trigger.start() try: while True: time.sleep(1) for granule_trigger in granule_triggers: if not granule_trigger.is_alive(): raise RuntimeError except KeyboardInterrupt: LOGGER.info("Shutting down...") except RuntimeError: LOGGER.critical('Something went wrong!') except OSError: LOGGER.critical('Something went wrong!') finally: LOGGER.warning('Ending publication the gathering of granules...') for granule_trigger in granule_triggers: granule_trigger.stop() PUB.stop()
# Load Twilio secrets from twilio_secrets.json twilio_secrets = None with open('twilio_secrets.json') as twilio_secrets_file: twilio_secrets = load(twilio_secrets_file) # Load config from config.json config = None with open('config.json') as config_file: config = load(config_file) # Set timezone os.environ['TZ'] = config['timezone'] tzset() # Set transparent pixel information data # We do this with a base64 string to avoid being dependent on a 1x1 png base64_pixel = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkqAcAAIUAgUW0RjgAAAAASUVORK5CYII=" pixel_data = b64decode(base64_pixel) # Set up Twilio client = Client(twilio_secrets['account_sid'], twilio_secrets['auth_token']) # Read GeoIP2 database geoip2_reader = geoip2.database.Reader('geolite2/GeoLite2-City.mmdb') def ip_location_summary(ip_addr): try:
def set_timezone(tz_name: str = 'Asia/Calcutta'): os.environ['TZ'] = tz_name time.tzset() print(f"Time-zone: {time.tzname}")
def __init__(self, arguments): ''' initialize local variables ''' if 'TZ' not in environ: os.environ['TZ'] = 'America/Los_Angeles' time.tzset() if 'FrameworkPath' not in environ: self.FrameworkPath = path.join(environ['HOME'], 'Projects', 'AutoBDD') else: self.FrameworkPath = environ['FrameworkPath'] self.reportonly = arguments.REPORTONLY self.rumtime_stamp = arguments.TIMESTAMP if arguments.TIMESTAMP else time.strftime( "%Y%m%d_%H%M%S%Z", time.gmtime()) self.parallel = arguments.PARALLEL self.screenshot = arguments.SCREENSHOT self.movie = arguments.MOVIE self.runlevel = arguments.RUNLEVEL self.platform = arguments.PLATFORM self.browser = arguments.BROWSER self.debugmode = arguments.DEBUGMODE self.projectbase = arguments.PROJECTBASE self.project = arguments.PROJECT self.reportbase = arguments.REPORTBASE if arguments.REPORTBASE else path.join( self.FrameworkPath, 'test-reports') self.reportpath = arguments.REPORTPATH if arguments.REPORTPATH else '_'.join( (self.project, self.rumtime_stamp)) self.modulelist = arguments.MODULELIST if arguments.TAGLIST is not None: self.args = '_'.join((arguments.MODULELIST + arguments.TAGLIST)) self.tags = ' --tags ' + ','.join(arguments.TAGLIST) else: self.args = '_'.join(arguments.MODULELIST) self.tags = '' self.tagarray = arguments.TAGLIST self.display = ':99' self.display_size = '1920x1200' # self.test_projects_path = path.join(self.FrameworkPath, # 'test-projects') self.project_full_path = path.join(self.FrameworkPath, self.projectbase, self.project) # Each runable module should have a chimp.js self.chimp_profile = path.join('chimp.js') # Create report directory if not path.exists(path.join(self.FrameworkPath, self.reportbase)): os.makedirs(path.join(self.FrameworkPath, self.reportbase)) self.report_dir = path.join(self.reportbase, self.reportpath) try: os.makedirs(self.report_dir) except OSError as e: if e.errno != errno.EEXIST: raise print('\n*** Report Directory: ***\n {}'.format(self.report_dir)) self.rerun = None if arguments.RERUN is not None: self.rerun = path.join( path.abspath(path.join(self.report_dir, '..')), arguments.RERUN) assert path.exists(self.rerun), '{} is not exits'.format( self.rerun) self.runlevel = 'Scenario' # remove /tmp/*.lock file for item in os.listdir('/tmp/'): if item.endswith(".lock"): os.remove('/tmp/' + item) self.marray = {} self.sarray = {} self.features_count = 0 self.scenarios_count = 0 self.runarray = [] self.host = [] self.thread_count = 0 self.end_time = time.strftime("%Y%m%d_%H%M%S%Z", time.gmtime()) self.get_available_host()
def __init__(self, arguments): ''' initialize local variables ''' if 'TZ' not in environ: os.environ['TZ'] = 'UTC' time.tzset() if 'FrameworkPath' not in environ: self.FrameworkPath = path.join(environ['HOME'], 'Projects', 'AutoBDD') else: self.FrameworkPath = environ['FrameworkPath'] os.chdir(self.FrameworkPath) self.reportonly = arguments.REPORTONLY self.runtime_stamp = arguments.TIMESTAMP if arguments.TIMESTAMP else time.strftime("%Y%m%d_%H%M%S%Z", time.gmtime()) self.parallel = arguments.PARALLEL self.screenshot = arguments.SCREENSHOT self.screenremark = arguments.SCREENREMARK self.movie = arguments.MOVIE self.platform = arguments.PLATFORM self.browser = arguments.BROWSER self.debugmode = arguments.DEBUGMODE self.projectbase = arguments.PROJECTBASE if arguments.PROJECTBASE else 'test-projects' self.project = arguments.PROJECT self.projecttype = arguments.PROJECTTYPE self.reportbase = arguments.REPORTBASE if arguments.REPORTBASE else path.join( self.FrameworkPath, self.projectbase, self.project, 'bdd_reports') self.reportpath = arguments.REPORTPATH if arguments.REPORTPATH else '_'.join( (self.project, self.runtime_stamp)) self.modulelist = arguments.MODULELIST self.argstring = arguments.ARGSTRING self.display_size = '1920x1200' self.project_full_path = path.join(self.FrameworkPath, self.projectbase, self.project) self.report_full_path = path.join(self.reportbase, self.reportpath) self.isMaven = self.isMavenProject (arguments.PROJECTTYPE) # Each runable module should have a chimp.js self.chimp_profile = path.join('chimp.js') # Create report directory if not path.exists(path.join(self.FrameworkPath, self.reportbase)): os.makedirs(path.join(self.FrameworkPath, self.reportbase)) self.report_dir_base = path.join(self.reportbase, self.reportpath) try: os.makedirs(self.report_dir_base) except OSError as e: if e.errno != errno.EEXIST: raise print('\n*** Report Directory: ***\n {}'.format(self.report_dir_base)) # remove /tmp/*.lock file for item in os.listdir('/tmp/'): if item.endswith(".lock"): os.remove('/tmp/' + item) self.host = [] self.available_pool_number = 0 self.end_time = time.strftime("%Y%m%d_%H%M%S%Z", time.gmtime()) self.get_available_host() pprint(vars(self))
def lambda_handler(event, context): os.environ['TZ'] = 'America/New_York' time.tzset() return dispatch(event)
def main(): # pragma: no cover parser = argparse.ArgumentParser() parser.add_argument( '--broker', dest='broker', default=DEFAULT_BROKER, help="URL to the Celery broker. Defaults to {}".format(DEFAULT_BROKER)) parser.add_argument( '--transport-options', dest='transport_options', help=("JSON object with additional options passed to the underlying " "transport.")) parser.add_argument( '--addr', dest='addr', default=DEFAULT_ADDR, help="Address the HTTPD should listen on. Defaults to {}".format( DEFAULT_ADDR)) parser.add_argument( '--enable-events', action='store_true', help="Periodically enable Celery events") parser.add_argument( '--tz', dest='tz', help="Timezone used by the celery app.") parser.add_argument( '--verbose', action='store_true', default=False, help="Enable verbose logging") parser.add_argument( '--max_tasks_in_memory', dest='max_tasks_in_memory', default=DEFAULT_MAX_TASKS_IN_MEMORY, type=int, help="Tasks cache size. Defaults to {}".format( DEFAULT_MAX_TASKS_IN_MEMORY)) parser.add_argument( '--version', action='version', version='.'.join([str(x) for x in __VERSION__])) opts = parser.parse_args() if opts.verbose: logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT) else: logging.basicConfig(level=logging.INFO, format=LOG_FORMAT) signal.signal(signal.SIGINT, shutdown) signal.signal(signal.SIGTERM, shutdown) if opts.tz: os.environ['TZ'] = opts.tz time.tzset() app = celery.Celery(broker=opts.broker) if opts.transport_options: try: transport_options = json.loads(opts.transport_options) except ValueError: print("Error parsing broker transport options from JSON '{}'" .format(opts.transport_options), file=sys.stderr) sys.exit(1) else: app.conf.broker_transport_options = transport_options setup_metrics(app) t = MonitorThread(app=app, max_tasks_in_memory=opts.max_tasks_in_memory) t.daemon = True t.start() w = WorkerMonitoringThread(app=app) w.daemon = True w.start() e = None if opts.enable_events: e = EnableEventsThread(app=app) e.daemon = True e.start() start_httpd(opts.addr) t.join() w.join() if e is not None: e.join()
def lambda_handler(event, context): # TODO implement os.environ['TZ'] = 'America/New_York' time.tzset() logger.debug('event.bot.name={}'.format(event['bot']['name'])) return dispatch(event)
def __init__(self, settings_module): # update this dict from global settings (but only for ALL_CAPS settings) for setting in dir(global_settings): if setting == setting.upper(): setattr(self, setting, getattr(global_settings, setting)) # store the settings module in case someone later cares self.SETTINGS_MODULE = settings_module try: mod = importlib.import_module(self.SETTINGS_MODULE) except ImportError as e: raise ImportError( "Could not import settings '%s' (Is it on sys.path?): %s" % (self.SETTINGS_MODULE, e)) # Settings that should be converted into tuples if they're mistakenly entered # as strings. tuple_settings = ("INSTALLED_APPS", "TEMPLATE_DIRS") for setting in dir(mod): if setting == setting.upper(): setting_value = getattr(mod, setting) if setting in tuple_settings and \ isinstance(setting_value, basestring): warnings.warn( "The %s setting must be a tuple. Please fix your " "settings, as auto-correction is now deprecated." % setting, PendingDeprecationWarning) setting_value = (setting_value, ) # In case the user forgot the comma. setattr(self, setting, setting_value) if not self.SECRET_KEY: raise ImproperlyConfigured( "The SECRET_KEY setting must not be empty.") if hasattr(time, 'tzset') and self.TIME_ZONE: # When we can, attempt to validate the timezone. If we can't find # this file, no check happens and it's harmless. zoneinfo_root = '/usr/share/zoneinfo' if (os.path.exists(zoneinfo_root) and not os.path.exists( os.path.join(zoneinfo_root, *(self.TIME_ZONE.split('/'))))): raise ValueError("Incorrect timezone setting: %s" % self.TIME_ZONE) # Move the time zone info into os.environ. See ticket #2315 for why # we don't do this unconditionally (breaks Windows). os.environ['TZ'] = self.TIME_ZONE time.tzset() # Settings are configured, so we can set up the logger if required if self.LOGGING_CONFIG: # First find the logging configuration function ... logging_config_path, logging_config_func_name = self.LOGGING_CONFIG.rsplit( '.', 1) logging_config_module = importlib.import_module( logging_config_path) logging_config_func = getattr(logging_config_module, logging_config_func_name) # Backwards-compatibility shim for #16288 fix compat_patch_logging_config(self.LOGGING) # ... then invoke it with the logging settings logging_config_func(self.LOGGING)