def __init__(self):
self._categories = []
self._config_parser = ConfigParser.RawConfigParser()
self.input_seq_filepaths = []
import string
import sys
import base64
import ConfigParser
STR_RED = "\033[01;31m{0}\033[00m"
STR_GREEN = "\033[1;36m{0}\033[00m"
# Script configuration
# dry-run: set it to False to actually write into the OpenLDAP
#DRY_RUN = True
DRY_RUN = False
# Lecture des paramètres AD et LDAP
config = ConfigParser.RawConfigParser()
config.read('.ldap.conf')
try:
# Active Directory
IN_LDAP_URI = config.get('IN_LDAP', 'IN_LDAP_URI')
IN_LDAP_BINDDN = config.get('IN_LDAP', 'IN_LDAP_BINDDN')
IN_LDAP_PASSWD = config.get('IN_LDAP', 'IN_LDAP_PASSWD')
# OpenLDAP
OUT_LDAP_URI = config.get('OUT_LDAP', 'OUT_LDAP_URI')
OUT_LDAP_BINDDN = config.get('OUT_LDAP', 'OUT_LDAP_BINDDN')
OUT_LDAP_PASSWD = config.get('OUT_LDAP', 'OUT_LDAP_PASSWD')
except ConfigParser.Error, err:
print 'Oops, une erreur dans votre fichier de conf (%s)' % err
def _build_config_wrapper(self, data, filename):
fileconfig = configparser.RawConfigParser()
self._parse_config(data, filename, fileconfig, set())
return ConfigWrapper(self.printer, fileconfig, {}, 'printer')
def load_master(master, force_format="default"):
try:
tree = ET.parse(master)
root = tree.getroot()
except IOError:
root = ET.fromstring(master)
xmlpipes, xmloptions = list(root)
options = ConfigParser.RawConfigParser()
exporter = None
couples = {}
for xmloption in xmloptions:
section = xmloption.tag
options.add_section(section)
attribs = {}
for key, val in xmloption.attrib.items():
key = key.replace(u"-", u"_")
try:
attribs[key] = sem.misc.str2bool(val)
except ValueError:
attribs[key] = val
for key, val in attribs.items():
options.set(section, key, val)
if xmloption.tag == "export":
couples = dict(options.items("export"))
export_format = couples["format"]
if force_format is not None and force_format != "default":
sem_tagger_logger.info("using forced format: %s" %
force_format)
export_format = force_format
exporter = sem.exporters.get_exporter(export_format)(**couples)
if get_option(options, "log", "log_file") is not None:
sem_tagger_logger.addHandler(
file_handler(get_option(options, "log", "log_file")))
sem_tagger_logger.setLevel(get_option(options, "log", "level", "WARNING"))
classes = {}
pipes = []
for xmlpipe in xmlpipes:
if xmlpipe.tag == "export": continue
Class = classes.get(xmlpipe.tag, None)
if Class is None:
Class = get_module(xmlpipe.tag)
classes[xmlpipe.tag] = Class
arguments = {}
for key, value in xmlpipe.attrib.items():
if value.startswith(u"~/"):
value = os.path.expanduser(value)
elif sem.misc.is_relative_path(value):
value = os.path.abspath(
os.path.join(os.path.dirname(master), value))
arguments[key.replace(u"-", u"_")] = value
for section in options.sections():
if section == "export": continue
for key, value in options.items(section):
if key not in arguments:
arguments[key] = value
else:
sem_tagger_logger.warn(
'Not adding already existing option: %s' % (key))
sem_tagger_logger.info("loading %s" % xmlpipe.tag)
pipes.append(Class(**arguments))
pipeline = sem.modules.pipeline.Pipeline(pipes)
return pipeline, options, exporter, couples
def __init__(self, root):
self.images = []
self.axes = []
self.filename = ''
self.sequenz = Daten()
self.serialState = ''
self.decstart = 0
self.decend = 1500
#GUI
self.config = ConfigParser.RawConfigParser()
self.configfile = 'LogikAnalyse.cfg'
self.defaultDir = "Daten"
try:
self.loadConfig()
except:
print 'Kein Configfile gefunden, nehme Anfangswerte'
#initial defaults
self.pulseMin = 300
self.samples = 1500
self.comPortSelect = 'COM9'
self.messTyp = 'pulse'
self.root = root
self.root.title('Logik Analyse')
self.root.protocol("WM_DELETE_WINDOW", self.exit_)
self.fig = matplotlib.figure.Figure()
self.axes = self.fig.add_subplot(1, 1, 1)
figframe = Tk.Frame(root)
figframe.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas = FigureCanvasTkAgg(self.fig, master=figframe)
toolbar = NavigationToolbar2TkAgg(canvas, figframe)
toolbar.pack(side=Tk.TOP, fill=Tk.BOTH) # expand=1)
self.modify_toolbar()
self.scaleY()
self.add_menu()
configframe = Tk.Frame(root)
configframe.pack(side=Tk.BOTTOM, fill=Tk.BOTH, expand=1)
self.samplesSpinboxVal = Tk.StringVar()
self.samplesSpinboxVal.set(str(self.samples))
self.samplesSpinboxLabel = Tk.Label(configframe,
text='Samples').pack(side=Tk.LEFT,
anchor=Tk.E)
self.samplesSpinbox = Tk.Spinbox(configframe,
from_=500,
to=5000,
increment=500,
width=5,
textvariable=self.samplesSpinboxVal)
self.samplesSpinbox.pack(side=Tk.LEFT)
self.pulseMinSpinboxVal = Tk.StringVar()
self.pulseMinSpinboxVal.set(str(self.pulseMin))
self.pulseMinSpinboxLabel = Tk.Label(
configframe, text='pulseMin').pack(side=Tk.LEFT, anchor=Tk.E)
self.pulseMinSpinbox = Tk.Spinbox(configframe,
from_=100,
to=500,
increment=50,
width=5,
textvariable=self.pulseMinSpinboxVal)
self.pulseMinSpinbox.pack(side=Tk.LEFT)
self.comPortSpinboxVal = Tk.StringVar()
self.comPortSpinboxVal.set(str(self.comPortSelect))
#print self.comPortSpinboxVal.get()
self.comPorts = tuple(serial_ports())
self.comPortSpinboxLabel = Tk.Label(configframe,
text='Port').pack(side=Tk.LEFT,
anchor=Tk.E)
self.comPortSpinbox = Tk.Spinbox(configframe,
command=self.switchconnectSer(),
values=self.comPorts,
textvariable=self.comPortSpinboxVal,
width=14)
self.comPortSpinbox.pack(side=Tk.LEFT)
self.messTypRadioVal = Tk.StringVar()
self.messTypRadioVal.set(self.messTyp)
self.messTypDtRadio = Tk.Radiobutton(configframe,
text='dt',
padx=0,
variable=self.messTypRadioVal,
value='dt')
self.messTypDtRadio.pack(side=Tk.LEFT, anchor=Tk.W)
self.messTypPulseRadio = Tk.Radiobutton(configframe,
text='Pulse',
padx=0,
variable=self.messTypRadioVal,
value='pulse')
self.messTypPulseRadio.pack(side=Tk.LEFT, anchor=Tk.W)
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.root.bind('<Control-y>', lambda e: self.scaleY())
self.root.bind('<Control-m>', lambda e: self.aufnahme())
# implement the default mpl key bindings
def on_key_event(event):
#if (event.key=='y'):
# self.scaleY()
key_press_handler(event, canvas, toolbar)
self.tmp_cid1 = canvas.mpl_connect('key_press_event', on_key_event)
def on_button_event(event):
self.scaleY()
self.tmp_cid2 = canvas.mpl_connect('button_release_event',
on_button_event)
import json
import sys
if sys.version_info[0] < 3:
import ConfigParser as configparser
from urllib2 import Request, urlopen, URLError, HTTPError
else:
import configparser
from urllib.request import Request, urlopen
from urllib.error import URLError, HTTPError
red = lambda s: '\033[31m%s\033[39m' % s
green = lambda s: '\033[32m%s\033[39m' % s
underline = lambda s: '\033[4m%s\033[24m' % s
config = configparser.RawConfigParser()
config.read('.pl_upload.cfg')
base_url = config.get('PrairieLearn', 'base_url')
auth_uid = config.get('Authentication', 'auth_uid')
auth_name = config.get('Authentication', 'auth_name')
auth_date = config.get('Authentication', 'auth_date')
auth_signature = config.get('Authentication', 'auth_signature')
user_uid = config.get('Question', 'user_uid')
qid = config.get('Question', 'qid')
qiid = config.get('Question', 'qiid')
tiid = config.get('Question', 'tiid')
upload_file = config.get('Question', 'upload_file')
def updateStatusIniFile():
config = ConfigParser.RawConfigParser()
config.add_section(STATUS_DATES_SECTION)
config.set(STATUS_DATES_SECTION, START_DATE, eventDatetime)
with open(STATUS_INI, 'wb') as configfile:
config.write(configfile)
def makeService(config):
ini = ConfigParser.RawConfigParser()
ini.read(config['config'])
configPath = FilePath(config['config']).parent()
rproxyConf = dict(ini.items("rproxy"))
hostsConf = dict(ini.items("hosts"))
hosts = {}
for k, v in hostsConf.items():
k = k.lower()
hostname, part = k.rsplit("_", 1)
if hostname not in hosts:
hosts[hostname] = {}
hosts[hostname][part] = v
if not hosts:
raise ValueError("No hosts configured.")
for i in hosts:
if "port" not in hosts[i]:
raise ValueError("All hosts need a port.")
if "host" not in hosts[i]:
print("%s does not have a host, making localhost" % (i, ))
hosts[i]["host"] = "localhost"
if "wwwtoo" not in hosts[i]:
print("%s does not have an wwwtoo setting, making True" % (i, ))
hosts[i]["wwwtoo"] = "True"
if "proxysecure" not in hosts[i]:
print("%s does not have an proxysecure setting, making False" %
(i, ))
hosts[i]["proxysecure"] = False
hosts[i]["wwwtoo"] = True if hosts[i]["wwwtoo"] == "True" else False
hosts[i]["proxysecure"] = True if hosts[i][
"proxysecure"] == "True" else False
hosts[i]["sendhsts"] = True if hosts[i].get(
"sendhsts") == "True" else False
from twisted.internet import reactor
pool = HTTPConnectionPool(reactor)
resource = EncodingResourceWrapper(
RProxyResource(hosts, rproxyConf.get("clacks"), pool, reactor, {},
False), [server.GzipEncoderFactory()])
responder = HTTP01Responder()
site = server.Site(EnsureHTTPS(resource, responder.resource), )
multiService = service.MultiService()
certificates = rproxyConf.get("certificates", None)
if certificates:
try:
configPath.child(certificates).makedirs()
except:
pass
certificates = configPath.child(certificates).path
for i in rproxyConf.get("https_ports").split(","):
print("Starting HTTPS on port " + i)
multiService.addService(
strports.service('txsni:' + certificates + ':tcp:' + i, site))
for host in hosts.keys():
with open(FilePath(certificates).child(host + ".pem").path, 'w'):
# Open it so that txacme can find it
pass
if hosts[host]["wwwtoo"]:
with open(
FilePath(certificates).child("www." + host +
".pem").path, 'w'):
# Open it so that txacme can find it
pass
for i in rproxyConf.get("http_ports", "").split(","):
print("Starting HTTP on port " + i)
multiService.addService(strports.service('tcp:' + i, site))
issuingService = AcmeIssuingService(
cert_store=DirectoryStore(FilePath(certificates)),
client_creator=(lambda: Client.from_url(
reactor=reactor,
url=LETSENCRYPT_DIRECTORY,
key=load_or_create_client_key(FilePath(certificates)),
alg=RS256,
)),
clock=reactor,
responders=[responder],
)
issuingService.setServiceParent(multiService)
return multiService
def read_config(options):
"""
Read config file and if provided overwrite default values
If no config file exist, create one with default values
"""
global work_dir
work_dir = ''
if getattr(sys, 'frozen', False):
work_dir = os.path.dirname(sys.executable)
elif __file__:
work_dir = os.path.dirname(__file__)
_configfile = os.path.join(work_dir, options.config)
if os.path.exists(options.config):
_configfile = options.config
if options.verbose:
print "Config file: {0}".format(_configfile)
if os.path.exists(_configfile):
try:
config = ConfigParser.SafeConfigParser()
config.read(_configfile)
if config.has_option('TRAKT','CLIENT_ID') and len(config.get('TRAKT','CLIENT_ID')) != 0:
_trakt['client_id'] = config.get('TRAKT','CLIENT_ID')
else:
print 'Error, you must specify a trakt.tv CLIENT_ID'
sys.exit(1)
if config.has_option('TRAKT','CLIENT_SECRET') and len(config.get('TRAKT','CLIENT_SECRET')) != 0:
_trakt['client_secret'] = config.get('TRAKT','CLIENT_SECRET')
else:
print 'Error, you must specify a trakt.tv CLIENT_SECRET'
sys.exit(1)
if config.has_option('TRAKT','OAUTH_TOKEN') and len(config.get('TRAKT','OAUTH_TOKEN')) != 0:
_trakt['oauth_token'] = config.get('TRAKT','OAUTH_TOKEN')
else:
print 'Warning, authentification is required'
if config.has_option('TRAKT','BASEURL'):
_trakt['baseurl'] = config.get('TRAKT','BASEURL')
if config.has_option('SETTINGS','PROXY'):
_proxy['proxy'] = config.getboolean('SETTINGS','PROXY')
if _proxy['proxy'] and config.has_option('SETTINGS','PROXY_HOST') and config.has_option('SETTINGS','PROXY_PORT'):
_proxy['host'] = config.get('SETTINGS','PROXY_HOST')
_proxy['port'] = config.get('SETTINGS','PROXY_PORT')
_proxyDict['http'] = _proxy['host']+':'+_proxy['port']
_proxyDict['https'] = _proxy['host']+':'+_proxy['port']
except:
print "Error reading configuration file {0}".format(_configfile)
sys.exit(1)
else:
try:
print '%s file was not found!' % _configfile
config = ConfigParser.RawConfigParser()
config.add_section('TRAKT')
config.set('TRAKT', 'CLIENT_ID', '')
config.set('TRAKT', 'CLIENT_SECRET', '')
config.set('TRAKT', 'OAUTH_TOKEN', '')
config.set('TRAKT', 'BASEURL', 'https://api.trakt.tv')
config.add_section('SETTINGS')
config.set('SETTINGS', 'PROXY', False)
config.set('SETTINGS', 'PROXY_HOST', 'https://127.0.0.1')
config.set('SETTINGS', 'PROXY_PORT', '3128')
with open(_configfile, 'wb') as configfile:
config.write(configfile)
print "Default settings wrote to file {0}".format(_configfile)
except:
print "Error writing configuration file {0}".format(_configfile)
sys.exit(1)
def store_data(self, bucket, item_name, headers, data):
key_name = os.path.join(bucket.name, item_name)
dirname = os.path.join(self.root, key_name)
filename = os.path.join(dirname, CONTENT_FILE)
metafile = os.path.join(dirname, METADATA_FILE)
metadata = {}
config = ConfigParser.RawConfigParser()
files_parsed = config.read(metafile)
if files_parsed:
metadata['size'] = config.getint('metadata', 'size')
metadata['md5'] = config.get('metadata', 'md5')
metadata['filename'] = config.get('metadata', 'filename')
metadata['content_type'] = config.get('metadata', 'content_type')
metadata['creation_date'] = config.get('metadata', 'creation_date')
m = md5.new()
lower_headers = {}
for key in headers:
lower_headers[key.lower()] = headers[key]
headers = lower_headers
if 'content-type' not in headers:
headers['content-type'] = 'application/octet-stream'
size = int(headers['content-length'])
m.update(data)
if not os.path.exists(dirname):
os.makedirs(dirname)
with open(filename, 'wb') as f:
f.write(data)
if metadata:
metadata['md5'] = m.hexdigest()
metadata['modified_date'] = datetime.now().strftime(
'%Y-%m-%dT%H:%M:%S.000Z')
metadata['content_type'] = headers['content-type']
metadata['size'] = size
else:
metadata = {
'content_type': headers['content-type'],
'creation_date':
datetime.now().strftime('%Y-%m-%dT%H:%M:%S.000Z'),
'md5': m.hexdigest(),
'filename': filename,
'size': size,
}
config.add_section('metadata')
config.set('metadata', 'size', metadata['size'])
config.set('metadata', 'md5', metadata['md5'])
config.set('metadata', 'filename', metadata['filename'])
config.set('metadata', 'content_type', metadata['content_type'])
config.set('metadata', 'creation_date', metadata['creation_date'])
if 'modified_date' in metadata:
config.set('metadata', 'modified_date', metadata['modified_date'])
with open(metafile, 'wb') as configfile:
config.write(configfile)
s3_item = S3Item(key, **metadata)
s3_item.io = open(filename, 'rb')
return s3_item
def ipcores(env, aXilSimLibsPath, aToScript, aToStdout):
'''
Generate the vivado libraries and cores required to simulate the current design.
'''
lSessionId = 'ipcores'
lIpCoresModelsimIni = 'modelsim.ipcores.ini'
# -------------------------------------------------------------------------
if not which('vivado'):
# if 'XILINX_VIVADO' not in os.environ:
raise click.ClickException(
'Vivado is not available. Have you sourced the environment script?')
# -------------------------------------------------------------------------
lDryRun = aToScript or aToStdout
# Use compiler executable to detect Modelsim's flavour
lSimVariant = autodetect()
# For questa and modelsim the simulator name is the variant name in lowercase
lSimulator = lSimVariant.lower()
echo(style(lSimVariant, fg='blue')+" detected")
lDepFileParser = env.depParser
# Guess the current vivado version from environment
lVivadoVersion = basename(os.environ['XILINX_VIVADO'])
secho('Using Vivado version: '+lVivadoVersion, fg='green')
# -------------------------------------------------------------------------
# Store the target path in the env, for it to be retrieved by Vivado
# i.e. .xilinx_sim_libs/2017.4
lSimlibPath = expandvars(join(aXilSimLibsPath, lVivadoVersion))
echo ("Using Xilinx simulation library path: " + style(lSimlibPath, fg='blue'))
if not exists(lSimlibPath):
secho("Warning: Simulation Xilinx libraries not found. Likely this is a problem.\nPlease execute {} sim setup-simlibs to generate them.".format(getClickRootName()), fg='yellow')
confirm("Do you want to continue anyway?", abort=True)
# -------------------------------------------------------------------------
# -------------------------------------------------------------------------
# Extract the list of cores
lIPCores = [
split(name)[1] for name, ext in
( splitext(src.FilePath) for src in lDepFileParser.commands["src"] )
if ext in [".xci", ".edn"]
]
if not lIPCores:
secho ("WARNING: No ipcore files detected in this project", fg='yellow')
return
else:
echo ('List of ipcores in project')
for lIPCore in lIPCores:
echo('- ' + style(lIPCore, fg='blue'))
# -------------------------------------------------------------------------
# For questa and modelsim the simulator name is the variant name in lowercase
lIPCoreSimMaker = IPCoresSimMaker(lSimlibPath, lSimVariant, lSimulator, kIPExportDir)
secho("Generating ipcore simulation code", fg='blue')
try:
with (
# Pipe commands to Vivado console
VivadoOpen(lSessionId) if not lDryRun
else SmartOpen(
# Dump to script
aToScript if not aToStdout
# Dump to terminal
else None
)
) as lVivadoConsole:
lIPCoreSimMaker.write(
lVivadoConsole,
lDepFileParser.vars,
lDepFileParser.components,
lDepFileParser.commands,
lDepFileParser.libs,
lDepFileParser.maps
)
except VivadoConsoleError as lExc:
echoVivadoConsoleError(lExc)
raise click.Abort()
except RuntimeError as lExc:
secho("Error caught while generating Vivado TCL commands:\n" +
"\n".join(lExc), fg='red'
)
raise click.Abort()
# Copy the generated modelsim ini file locally, with a new name
shutil.copy(join(lSimlibPath, 'modelsim.ini'), join(os.getcwd(), lIpCoresModelsimIni))
secho("Imported modelsim.ini from {} to {}".format(lSimlibPath, lIpCoresModelsimIni), fg='blue')
# Prepare the area where to compile the simulation
lIPSimDir = join(kIPExportDir,lSimulator)
# Create the target directory for the code simulation
mkdir(join(lIPSimDir, '{0}_lib'.format(lSimulator), 'work'))
# and copy the simlibrary config file into it
shutil.copy(join(lSimlibPath, 'modelsim.ini'), lIPSimDir)
# Compile
secho("Compiling ipcore simulation", fg='blue')
with ModelSimBatch(echo=aToStdout, dryrun=lDryRun, cwd=lIPSimDir) as lSim:
lSim('do compile.do')
# ----------------------------------------------------------
# Collect the list of libraries generated by ipcores to add them to
# modelsim.ini
lVivadoYear = [int(v) for v in lVivadoVersion.split('.')]
if lVivadoYear[0] >= 2017:
# Vivado 2017 requires an additional folder on the simulation path
lCoreSimDir = abspath(join(
kIPExportDir,
lSimulator,
'{0}_lib'.format(lSimulator),
'msim'
))
else:
# Vivado 2016<
lCoreSimDir = abspath(join(
kIPExportDir,
lSimulator,
'msim'
))
if not exists( lCoreSimDir ):
raise click.ClickException("Simlib directory not found")
lSimLibs = next(os.walk(lCoreSimDir))[1]
echo ('Detected simulation libraries: '+ style(', '.join(lSimLibs), fg='blue'))
# add newly generated libraries to modelsim.ini
echo ('Adding generated simulation libraries to modelsim.ini')
import ConfigParser
lModelsimIni = ConfigParser.RawConfigParser()
lModelsimIni.read('modelsim.ipcores.ini')
for lSimLib in lSimLibs:
echo (' - ' + lSimLib)
lModelsimIni.set('Library', lSimLib, join(lCoreSimDir, lSimLib))
lLibSearchPaths = lModelsimIni.get('vsim', 'librarysearchpath').split() if lModelsimIni.has_option('vsim', 'librarysearchpath') else []
lLibSearchPaths += lSimLibs
lNoDups = []
for lSimLib in lLibSearchPaths:
if lSimLib in lNoDups:
continue
lNoDups.append(lSimLib)
lModelsimIni.set('vsim', 'librarysearchpath', ' '.join(lNoDups))
# Make a backup copy of modelsim.ini (generated by ipcores)
with SmartOpen('modelsim.ini') as newIni:
lModelsimIni.write(newIni.target)
def setup(self):
self.queues = queues.declare_queues(self)
################# CONFIGURATION
# AMQP is required
if not self.amqp_host:
raise ValueError("amqp_host not set in the .ini")
if not self.cassandra_seeds:
raise ValueError("cassandra_seeds not set in the .ini")
# heavy load mode is read only mode with a different infobar
if self.heavy_load_mode:
self.read_only_mode = True
origin_prefix = self.domain_prefix + "." if self.domain_prefix else ""
self.origin = "http://" + origin_prefix + self.domain
self.secure_domains = set([urlparse(self.payment_domain).netloc])
self.trusted_domains = set([self.domain])
self.trusted_domains.update(self.authorized_cnames)
if self.https_endpoint:
https_url = urlparse(self.https_endpoint)
self.secure_domains.add(https_url.netloc)
self.trusted_domains.add(https_url.hostname)
if getattr(self, 'oauth_domain', None):
self.secure_domains.add(self.oauth_domain)
# load the unique hashed names of files under static
static_files = os.path.join(self.paths.get('static_files'), 'static')
names_file_path = os.path.join(static_files, 'names.json')
if os.path.exists(names_file_path):
with open(names_file_path) as handle:
self.static_names = json.load(handle)
else:
self.static_names = {}
# make python warnings go through the logging system
logging.captureWarnings(capture=True)
log = logging.getLogger('reddit')
# when we're a script (paster run) just set up super simple logging
if self.running_as_script:
log.setLevel(logging.INFO)
log.addHandler(logging.StreamHandler())
# if in debug mode, override the logging level to DEBUG
if self.debug:
log.setLevel(logging.DEBUG)
# attempt to figure out which pool we're in and add that to the
# LogRecords.
try:
with open("/etc/ec2_asg", "r") as f:
pool = f.read().strip()
# clean up the pool name since we're putting stuff after "-"
pool = pool.partition("-")[0]
except IOError:
pool = "reddit-app"
self.log = logging.LoggerAdapter(log, {"pool": pool})
# make cssutils use the real logging system
csslog = logging.getLogger("cssutils")
cssutils.log.setLog(csslog)
# load the country list
countries_file_path = os.path.join(static_files, "countries.json")
try:
with open(countries_file_path) as handle:
self.countries = json.load(handle)
self.log.debug("Using countries.json.")
except IOError:
self.log.warning("Couldn't find countries.json. Using pycountry.")
self.countries = get_countries_and_codes()
if not self.media_domain:
self.media_domain = self.domain
if self.media_domain == self.domain:
print("Warning: g.media_domain == g.domain. " +
"This may give untrusted content access to user cookies")
for arg in sys.argv:
tokens = arg.split("=")
if len(tokens) == 2:
k, v = tokens
self.log.debug("Overriding g.%s to %s" % (k, v))
setattr(self, k, v)
self.reddit_host = socket.gethostname()
self.reddit_pid = os.getpid()
if hasattr(signal, 'SIGUSR1'):
# not all platforms have user signals
signal.signal(signal.SIGUSR1, thread_dump)
self.startup_timer.intermediate("configuration")
################# ZOOKEEPER
# for now, zookeeper will be an optional part of the stack.
# if it's not configured, we will grab the expected config from the
# [live_config] section of the ini file
zk_hosts = self.config.get("zookeeper_connection_string")
if zk_hosts:
from r2.lib.zookeeper import (connect_to_zookeeper, LiveConfig,
LiveList)
zk_username = self.config["zookeeper_username"]
zk_password = self.config["zookeeper_password"]
self.zookeeper = connect_to_zookeeper(zk_hosts,
(zk_username, zk_password))
self.live_config = LiveConfig(self.zookeeper, LIVE_CONFIG_NODE)
self.throttles = LiveList(self.zookeeper,
"/throttles",
map_fn=ipaddress.ip_network,
reduce_fn=ipaddress.collapse_addresses)
else:
self.zookeeper = None
parser = ConfigParser.RawConfigParser()
parser.read([self.config["__file__"]])
self.live_config = extract_live_config(parser, self.plugins)
self.throttles = tuple() # immutable since it's not real
self.startup_timer.intermediate("zookeeper")
################# MEMCACHE
num_mc_clients = self.num_mc_clients
# the main memcache pool. used for most everything.
self.memcache = CMemcache(
self.memcaches,
min_compress_len=50 * 1024,
num_clients=num_mc_clients,
)
# a pool just used for @memoize results
memoizecaches = CMemcache(
self.memoizecaches,
min_compress_len=50 * 1024,
num_clients=num_mc_clients,
)
# a smaller pool of caches used only for distributed locks.
# TODO: move this to ZooKeeper
self.lock_cache = CMemcache(self.lockcaches,
num_clients=num_mc_clients)
self.make_lock = make_lock_factory(self.lock_cache, self.stats)
# memcaches used in front of the permacache CF in cassandra.
# XXX: this is a legacy thing; permacache was made when C* didn't have
# a row cache.
if self.permacache_memcaches:
permacache_memcaches = CMemcache(self.permacache_memcaches,
min_compress_len=50 * 1024,
num_clients=num_mc_clients)
else:
permacache_memcaches = None
# the stalecache is a memcached local to the current app server used
# for data that's frequently fetched but doesn't need to be fresh.
if self.stalecaches:
stalecaches = CMemcache(self.stalecaches,
num_clients=num_mc_clients)
else:
stalecaches = None
# rendercache holds rendered partial templates.
rendercaches = CMemcache(
self.rendercaches,
noreply=True,
no_block=True,
num_clients=num_mc_clients,
min_compress_len=1400,
)
# pagecaches hold fully rendered pages
pagecaches = CMemcache(
self.pagecaches,
noreply=True,
no_block=True,
num_clients=num_mc_clients,
min_compress_len=1400,
)
self.startup_timer.intermediate("memcache")
################# CASSANDRA
keyspace = "reddit"
self.cassandra_pools = {
"main":
StatsCollectingConnectionPool(keyspace,
stats=self.stats,
logging_name="main",
server_list=self.cassandra_seeds,
pool_size=self.cassandra_pool_size,
timeout=4,
max_retries=3,
prefill=False),
}
permacache_cf = CassandraCache(
'permacache',
self.cassandra_pools[self.cassandra_default_pool],
read_consistency_level=self.cassandra_rcl,
write_consistency_level=self.cassandra_wcl)
self.startup_timer.intermediate("cassandra")
################# POSTGRES
event.listens_for(engine.Engine, 'before_cursor_execute')(
self.stats.pg_before_cursor_execute)
event.listens_for(engine.Engine, 'after_cursor_execute')(
self.stats.pg_after_cursor_execute)
self.dbm = self.load_db_params()
self.startup_timer.intermediate("postgres")
################# CHAINS
# initialize caches. Any cache-chains built here must be added
# to cache_chains (closed around by reset_caches) so that they
# can properly reset their local components
cache_chains = {}
localcache_cls = (SelfEmptyingCache
if self.running_as_script else LocalCache)
if stalecaches:
self.cache = StaleCacheChain(
localcache_cls(),
stalecaches,
self.memcache,
)
else:
self.cache = MemcacheChain((localcache_cls(), self.memcache))
cache_chains.update(cache=self.cache)
if stalecaches:
self.memoizecache = StaleCacheChain(
localcache_cls(),
stalecaches,
memoizecaches,
)
else:
self.memoizecache = MemcacheChain(
(localcache_cls(), memoizecaches))
cache_chains.update(memoizecache=self.memoizecache)
self.rendercache = MemcacheChain((
localcache_cls(),
rendercaches,
))
cache_chains.update(rendercache=self.rendercache)
self.pagecache = MemcacheChain((
localcache_cls(),
pagecaches,
))
cache_chains.update(pagecache=self.pagecache)
# the thing_cache is used in tdb_cassandra.
self.thing_cache = CacheChain((localcache_cls(), ))
cache_chains.update(thing_cache=self.thing_cache)
self.permacache = CassandraCacheChain(
localcache_cls(),
permacache_cf,
memcache=permacache_memcaches,
lock_factory=self.make_lock,
)
cache_chains.update(permacache=self.permacache)
# hardcache is used for various things that tend to expire
# TODO: replace hardcache w/ cassandra stuff
self.hardcache = HardcacheChain(
(localcache_cls(), self.memcache, HardCache(self)),
cache_negative_results=True,
)
cache_chains.update(hardcache=self.hardcache)
# I know this sucks, but we need non-request-threads to be
# able to reset the caches, so we need them be able to close
# around 'cache_chains' without being able to call getattr on
# 'g'
def reset_caches():
for name, chain in cache_chains.iteritems():
chain.reset()
chain.stats = CacheStats(self.stats, name)
self.cache_chains = cache_chains
self.reset_caches = reset_caches
self.reset_caches()
self.startup_timer.intermediate("cache_chains")
# try to set the source control revision numbers
self.versions = {}
r2_root = os.path.dirname(os.path.dirname(self.paths["root"]))
r2_gitdir = os.path.join(r2_root, ".git")
self.short_version = self.record_repo_version("r2", r2_gitdir)
if I18N_PATH:
i18n_git_path = os.path.join(os.path.dirname(I18N_PATH), ".git")
self.record_repo_version("i18n", i18n_git_path)
self.startup_timer.intermediate("revisions")
def play_cast(self):
if self.debug is True:
print('def play_cast(self):')
localip = self.ip
try:
print(colors.options('The IP of ') +
colors.success(self.cast_to) + colors.options(' is:') +
' ' + self.cast.host)
except TypeError:
print(colors.options('The IP of ') +
colors.success(self.cast_to.player_name) +
colors.options(' is:') + ' ' + self.cast_to.ip_address)
except AttributeError:
for _ in self.sonos_list:
if self.cast_to in _.player_name:
self.cast_to = _
print(colors.options('The IP of ') +
colors.success(self.cast_to.player_name) +
colors.options(' is:') + ' ' + self.cast_to.ip_address)
if self.host is None:
print(colors.options('Your local IP is:') + ' ' + localip)
else:
print(colors.options('Your manually entered local IP is:') +
' ' + localip)
try:
media_controller = self.cast.media_controller
if self.tray is True:
config = ConfigParser.RawConfigParser()
# Class from mkchromecast.config
from mkchromecast.config import config_manager
configurations = config_manager()
configf = configurations.configf
if os.path.exists(configf) and self.tray is True:
print(self.tray)
print(colors.warning('Configuration file exists'))
print(colors.warning('Using defaults set there'))
config.read(configf)
self.backend = ConfigSectionMap('settings')['backend']
if self.sourceurl is not None:
if args.video is True:
import mkchromecast.video
mtype = mkchromecast.video.mtype
else:
import mkchromecast.audio
mtype = mkchromecast.audio.mtype
print(' ')
print(colors.options('Casting from stream URL:') + ' ' +
self.sourceurl)
print(colors.options('Using media type:') + ' ' +
mtype)
media_controller.play_media(
self.sourceurl,
mtype,
title=self.title
)
elif (self.backend == 'ffmpeg' or self.backend == 'node' or
self.backend == 'avconv' or self.backend == 'parec' or
self.backend == 'gstreamer' and self.sourceurl is None):
if args.video is True:
import mkchromecast.video
mtype = mkchromecast.video.mtype
else:
import mkchromecast.audio
mtype = mkchromecast.audio.mtype
print(' ')
print(colors.options('The media type string used is:') +
' ' + mtype)
media_controller.play_media(
'http://' + localip + ':' + self.port + '/stream',
mtype,
title=self.title
)
print(' ')
print(colors.important('Cast media controller status'))
print(' ')
print(self.cast.status)
print(' ')
if self.hijack is True:
self.r = Thread(target=self.hijack_cc)
# This has to be set to True so that we catch
# KeyboardInterrupt.
self.r.daemon = True
self.r.start()
except AttributeError:
self.sonos = self.cast_to
self.sonos.play_uri('x-rincon-mp3radio://' + localip +
':' + self.port + '/stream',
title=self.title)
if self.tray is True:
self.cast = self.sonos
def main():
config = ConfigParser.RawConfigParser()
config.read('mt500.conf')
MT500(config)
def main(argv):
"""
Main function
"""
try:
opts, args = getopt.getopt(argv, "c:hv", ["config", "help", "version"])
except getopt.GetoptError:
syntax()
exit(2)
config_file = ""
config_url = _CONF_FILE
for opt, arg in opts:
if opt in ("-c", "--config"):
if arg.startswith("http://") or \
arg.startswith("https://") or \
arg.startswith("ftp://"):
config_url = arg
else:
config_file = arg
elif opt in ("-h", "--help"):
syntax()
exit()
elif opt in ('-v', "--version"):
version()
exit()
# Are your root ?
if (not isroot()):
showexec(_("Script should be run as root"), "tpastroot", exitonerror=1)
# Is it Precise Pangolin ?
_UBUNTU_VERSION = platform.linux_distribution()[2]
if (_UBUNTU_VERSION != _FOR_UBUNTU):
showexec(_("Script only for Ubuntu %s") % _FOR_UBUNTU,
"badubuntuversion",
exitonerror=1)
# Read the configuration file
if (config_file == ""):
config_file = "/tmp/%s.cfg" % __appname__
showexec(
_("Download the configuration file"), "rm -f " + config_file +
" ; " + _WGET + " -O " + config_file + " " + config_url)
config = ConfigParser.RawConfigParser()
config.read(config_file)
# Parse and exec pre-actions
for action_name, action_cmd in config.items("preactions"):
showexec(
_("Execute preaction ") + action_name.lstrip("action_"),
action_cmd)
# Update repos
showexec(_("Update repositories"), _APT_UPDATE)
# Upgrade system
showexec(_("System upgrade (~20 mins, please be patient...)"),
_APT_UPGRADE)
# Parse and install packages
for pkg_type, pkg_list in config.items("packages"):
if (pkg_type.startswith("remove_")):
showexec(
_("Remove packages ") + pkg_type.lstrip("remove_"),
_APT_REMOVE + " " + pkg_list)
else:
showexec(
_("Install packages ") + pkg_type,
_APT_INSTALL + " " + pkg_list)
'''
I needed to comment out all the dotfiles peices because of issues with os.system. You can
look at the issues section to see why it is an issue. os.system is outdated and should be
replaced with subprocess. I will work on that, until then this script now works.
'''
# # Install packages related to repositories
# #~ print pkg_list_others
# for pkg in pkg_list_others.keys():
# showexec (_("Install packages ")+pkg, _APT_INSTALL+" "+pkg_list_others[pkg])
# # Allow user to read DVD (CSS)
# showexec (_("DVDs CSS encryption reader"), "sh /usr/share/doc/libdvdread4/install-css.sh")
# Download and install dotfiles: vimrc, prompt...
# if (config.has_section("dotfiles")):
# Create the bashrc.d subfolder
#showexec (_("Create the ~/.bashrc.d subfolder"), "mkdir -p $HOME/.bashrc.d")
#if (config.has_option("dotfiles", "bashrc")):
# showexec (_("Download bash main configuration file"), _WGET+" -O $HOME/.bashrc "+config.get("dotfiles", "bashrc"))
#if (config.has_option("dotfiles", "bashrc_prompt")):
# showexec (_("Download bash prompt configuration file"), _WGET+" -O $HOME/.bashrc.d/bashrc_prompt "+config.get("dotfiles", "bashrc_prompt"))
#if (config.has_option("dotfiles", "bashrc_aliases")):
# showexec (_("Download bash aliases configuration file"), _WGET+" -O $HOME/.bashrc.d/bashrc_aliases "+config.get("dotfiles", "bashrc_aliases"))
#showexec (_("Install the bash configuration file"), "chown -R $me:$me $HOME/.bashrc*")
# Vim
#if (config.has_option("dotfiles", "vimrc")):
# showexec (_("Donwload the Vim configuration file"), _WGET+" -O $HOME/.vimrc "+config.get("dotfiles", "vimrc"))
# showexec (_("Install the Vim configuration file"), "chown -R $me:$me $HOME/.vimrc")
# Htop
#if (config.has_option("dotfiles", "htoprc")):
# showexec (_("Download the Htop configuration file"), _WGET+" -O $HOME/.htoprc "+config.get("dotfiles", "htoprc"))
# showexec (_("Install the Htop configuration file"), "chown -R $me:$me $HOME/.htoprc")
# Xresources
#if (config.has_option("dotfiles", "xres")):
# showexec(_("Downloading the Xresources file"), _WGET+"-O $HOME/.Xresources "+config.get("dotfiles", "xres"))
# showexec(_("Installing the Xresources file"), "chown -R me:me $HOME/.Xresources")
# xinitrc
#if (config.has_option("dotfiles", "xinit")):
# showexec(_("Downloading the xinitrc file"), _WGET+"-O $HOME/.xinitrc "+config.get("dotfiles", "xres"))
# showexec(_("Installing the xinitrc file"), "chown -R me:me $HOME/.xinitrc"
# Parse and exec post-actions
for action_name, action_cmd in config.items("postactions"):
showexec(
_("Execute postaction ") + action_name.lstrip("action_"),
action_cmd)
# End of the script
print("---")
print(_("End of the script."))
print(_(" - Cfg file: ") + config_file)
print(_(" - Log file: ") + _LOG_FILE)
print("")
print(_("Please restart your session to complete."))
print("---")
def get_idx_server(hashval):
configParser = ConfigParser.RawConfigParser()
configFilePath = r'/home/ubuntu/config.cfg'
configParser.read(configFilePath)
port = int(configParser.get('ports', str(hashval)))
return (port)
def load_config(cfgfile=_default_config_file):
conf = _defaults.copy()
# read configuration from waptserver.ini
_config = ConfigParser.RawConfigParser()
if os.path.exists(cfgfile):
_config.read(cfgfile)
else:
# XXX this is a kludge
if os.getenv('USERNAME') == 'buildbot':
return conf
raise Exception(
"FATAL : couldn't open configuration file : {}.".format(cfgfile))
if not _config.has_section('options'):
raise Exception(
"FATAL, configuration file {} has no section [options]. Please check the waptserver documentation."
.format(cfgfile))
if _config.has_option('options', 'client_tasks_timeout'):
conf['client_tasks_timeout'] = int(
_config.get('options', 'client_tasks_timeout'))
if _config.has_option('options', 'clients_connect_timeout'):
conf['clients_connect_timeout'] = int(
_config.get('options', 'clients_connect_timeout'))
if _config.has_option('options', 'clients_read_timeout'):
conf['clients_read_timeout'] = int(
_config.get('options', 'clients_read_timeout'))
if _config.has_option('options', 'loglevel'):
conf['loglevel'] = _config.get('options', 'loglevel')
if _config.has_option('options', 'mongodb_ip'):
conf['mongodb_ip'] = _config.get('options', 'mongodb_ip')
if _config.has_option('options', 'mongodb_port'):
conf['mongodb_port'] = _config.getint('options', 'mongodb_port')
if _config.has_option('options', 'secret_key'):
config['secret_key'] = _config.get('options', 'secret_key')
if _config.has_option('options', 'server_uuid'):
conf['server_uuid'] = _config.get('options', 'server_uuid')
if _config.has_option('options', 'wapt_folder'):
conf['wapt_folder'] = _config.get('options', 'wapt_folder').rstrip('/')
if _config.has_option('options', 'wapt_huey_db'):
conf['wapt_huey_db'] = _config.get('options', 'wapt_huey_db')
if _config.has_option('options', 'wapt_password'):
conf['wapt_password'] = _config.get('options', 'wapt_password')
if _config.has_option('options', 'wapt_user'):
conf['wapt_user'] = _config.get('options', 'wapt_user')
if _config.has_option('options', 'waptserver_port'):
conf['waptserver_port'] = _config.get('options', 'waptserver_port')
if _config.has_option('options', 'waptservice_port'):
conf['waptservice_port'] = _config.get('options', 'waptservice_port')
# XXX must be processed after conf['wapt_folder']
if _config.has_option('options', 'waptwua_folder'):
conf['waptwua_folder'] = _config.get('options',
'waptwua_folder').rstrip('/')
if not conf['waptwua_folder']:
conf['waptwua_folder'] = conf['wapt_folder'] + 'wua'
if _config.has_option('options', 'db_url'):
conf['db_url'] = _config.get('options', 'db_url')
return conf
def get_peer_port(peer):
configParser = ConfigParser.RawConfigParser()
configFilePath = r'/home/ubuntu/config.cfg'
configParser.read(configFilePath)
port = int(configParser.get('ports', peer))
return (port)
TVHEADEND = 'TVH'
SHELL = 'SHELL'
HTTP = 'HTTP'
TV_GRAB = 'TV_GRAB'
KODI = 'KODI'
SETTINGS = {
'userdata': kodi_home,
'proxy_type': SHELL,
'interactive': None,
'repo_url': 'https://k.slyguy.xyz/.repo',
'debug': 0,
}
config = ConfigParser.RawConfigParser(defaults=SETTINGS)
config.read(os.path.join(kodi_home, 'config.ini'))
for key in SETTINGS:
SETTINGS[key] = os.environ.get(key, config.get('DEFAULT', key))
addons_dir = os.path.join(SETTINGS['userdata'], 'addons')
addons_data = os.path.join(SETTINGS['userdata'], 'addon_data')
tmp_dir = os.path.join(SETTINGS['userdata'], 'tmp')
if SETTINGS['interactive'] == None:
SETTINGS['interactive'] = SETTINGS['proxy_type'] == SHELL
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
def setup():
cfg = ConfigParser.RawConfigParser()
try:
path = os.environ['S3TEST_CONF']
except KeyError:
raise RuntimeError(
'To run tests, point environment ' +
'variable S3TEST_CONF to a config file.', )
with file(path) as f:
cfg.readfp(f)
global prefix
global targets
try:
template = cfg.get('fixtures', 'bucket prefix')
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
template = 'test-{random}-'
prefix = choose_bucket_prefix(template=template)
s3.clear()
config.clear()
for section in cfg.sections():
try:
(type_, name) = section.split(None, 1)
except ValueError:
continue
if type_ != 'region':
continue
regions.add(name, TargetConfig(cfg, section))
for section in cfg.sections():
try:
(type_, name) = section.split(None, 1)
except ValueError:
continue
if type_ != 's3':
continue
if len(regions.get()) == 0:
regions.add("default", TargetConfig(cfg, section))
config[name] = bunch.Bunch()
for var in [
'user_id',
'display_name',
'email',
]:
try:
config[name][var] = cfg.get(section, var)
except ConfigParser.NoOptionError:
pass
targets[name] = RegionsConn()
for (k, conf) in regions.iteritems():
conn = boto.s3.connection.S3Connection(
aws_access_key_id=cfg.get(section, 'access_key'),
aws_secret_access_key=cfg.get(section, 'secret_key'),
is_secure=conf.is_secure,
port=conf.port,
host=conf.host,
# TODO test vhost calling format
calling_format=conf.calling_format,
)
targets[name].add(k, TargetConnection(conf, conn))
s3[name] = targets[name].default.connection
# WARNING! we actively delete all buckets we see with the prefix
# we've chosen! Choose your prefix with care, and don't reuse
# credentials!
# We also assume nobody else is going to use buckets with that
# prefix. This is racy but given enough randomness, should not
# really fail.
nuke_prefixed_buckets(prefix=prefix)
class Iblox(object):
"""manage infoblox entries"""
config = ConfigParser.RawConfigParser()
def __init__(self, network, record, alias):
self.network = network
self.record = record
self.alias = alias
self.config.readfp(open(IBLOX_CONF))
self.opts = {
'host': self.config.get('iblox', 'iblox_server'),
'username': self.config.get('iblox', 'iblox_username'),
'password': self.config.get('iblox', 'iblox_password')
}
self.conn = connector.Connector(self.opts)
def query_alias(self):
""" query for CNAME record: return None if it does not exist or
if self.alias matches the existing one """
try:
alias_rec = self.conn.get_object('record:cname', {'name': self.alias})[0]
except TypeError:
return None
else:
if self.record == str(alias_rec['canonical']):
return 'already_there'
else:
return alias_rec
def destroy(self):
""" clean up CNAME entry """
try:
self.conn.delete_object(self.conn.get_object(
'record:cname', {'name': self.alias})[0]['_ref'])
except TypeError:
print "cound not find CNAME {}".format(self.alias)
else:
print "destroyed CNAME {}".format(self.alias)
def destroy_conditional(self):
""" clean up host entries """
alias_entry = self.query_alias()
if alias_entry and alias_entry != 'already_there':
self.conn.delete_object(alias_entry['_ref'])
print "destroyed CNAME record {}".format(self.alias)
return 'did something'
elif alias_entry == 'already_there':
return 'already_there'
else:
return None
def rebuild(self):
""" - destroy alias record (if it is not matching)
- create a new alias record if there isn't one already
"""
try_destroy = self.destroy_conditional()
if try_destroy == 'already_there':
print "A CNAME {} associated to {} is already there".format(
self.alias, self.record)
else:
try:
objects.CNAMERecord.create(self.conn, view=self.network,
name=self.alias, canonical=self.record)
except Exception as err:
print "couldn't create CNAME {} to Record {}: {}".format(
self.alias, self.record, err)
os.sys.exit(1)
else:
print "created CNAME record {} associated to {}".format(
self.alias, self.record)
print '-'*74
def main_merge(stats_list, stats_file, verbose):
process_parameter_file = 'processParameters.txt'
# Output file
config_out = ConfigParser.RawConfigParser()
config_out.optionxform = str # don't convert to lowercase
config_out.add_section('global')
for i, maskstats in enumerate(stats_list):
if verbose:
print "Reading", maskstats
config = ConfigParser.RawConfigParser()
config.read(maskstats)
keys = [
'Excluded Wells', 'Empty Wells', 'Pinned Wells', 'Ignored Wells',
'Bead Wells', 'Dud Beads', 'Reference Beads', 'Live Beads',
'Test Fragment Beads', 'Library Beads',
'TF Filtered Beads (read too short)',
'TF Filtered Beads (fail keypass)',
'TF Filtered Beads (too many positive flows)',
'TF Filtered Beads (poor signal fit)', 'TF Validated Beads',
'Lib Filtered Beads (read too short)',
'Lib Filtered Beads (fail keypass)',
'Lib Filtered Beads (too many positive flows)',
'Lib Filtered Beads (poor signal fit)', 'Lib Validated Beads'
]
if i == 0:
head, tail = os.path.split(maskstats)
config_pp = ConfigParser.RawConfigParser()
config_pp.read(os.path.join(head, process_parameter_file))
chip = config_pp.get('global', 'Chip')
size = chip.split(',')
config_out.set('global', 'Start Row', '0')
config_out.set('global', 'Start Column', '0')
config_out.set('global', 'Width', int(size[0]))
config_out.set('global', 'Height', int(size[1]))
config_out.set('global', 'Total Wells',
int(size[0]) * int(size[1]))
config_out.set('global', 'Percent Template-Positive Library Beads',
'0') # TODO
for key in keys:
config_out.set('global', key, '0')
for key in keys:
try:
value_in = config.get('global', key)
value_out = config_out.get('global', key)
config_out.set('global', key, int(value_in) + int(value_out))
except:
print "ERROR: StatsMerge: key %s doesn't exist" % key
sum_wells = 0
sum_wells += config_out.getint('global', 'Empty Wells')
sum_wells += config_out.getint('global', 'Pinned Wells')
sum_wells += config_out.getint('global', 'Ignored Wells')
sum_wells += config_out.getint('global', 'Bead Wells')
sum_wells += config_out.getint('global', 'Excluded Wells')
if config_out.get('global', 'Total Wells') != sum_wells:
print "ERROR: StatsMerge: Total Wells: %s (sum) != %s (expected)" % (
sum_wells, config_out.get('global', 'Total Wells'))
with open(stats_file, 'wb') as configfile:
if verbose:
print "Writing", stats_file
config_out.write(configfile)
config_file_directory = config_file.get('r_settings',
'config_file_directory')
except ConfigParser.Error, e:
traceback.print_exc(e)
else:
fl_sites = florida_sample_sites(True)
fl_sites.load_sites(file_name=sites_location_file,
boundary_file=boundaries_location_file)
for site in fl_sites:
if site.name == options.site_name:
site_data_wb = load_workbook(filename=options.site_xl_file)
site_config_filename = os.path.join(
station_model_dir, '%s.ini' % (site.name))
try:
site_config_file = ConfigParser.RawConfigParser()
site_config_file.read(site_config_filename)
except Exception, e:
traceback.print_exc(e)
else:
models = OrderedDict()
sheet_names = site_data_wb.get_sheet_names()
for ws_name in sheet_names:
work_sheet = site_data_wb[ws_name]
print "Processing sheet: %s" % (ws_name)
wb_data = read_sheet_data(work_sheet, site.name,
config_file_directory)
models[ws_name] = wb_data
write_ini_file(site, models, config_file)
return
def main():
parser = optparse.OptionParser()
parser.add_option("--ConfigFile",
dest="config_file",
help="INI Configuration file.")
parser.add_option("--LoggingConfig",
dest="logging_conf",
help="Logging Configuration file.")
(options, args) = parser.parse_args()
logging.config.fileConfig(options.logging_conf)
logger = logging.getLogger(__name__)
logger.info("Log file opened.")
db_config_file = ConfigParser.RawConfigParser()
db_config_file.read(options.config_file)
db_user = db_config_file.get('database', 'user')
db_pwd = db_config_file.get('database', 'password')
db_host = db_config_file.get('database', 'host')
db_name = db_config_file.get('database', 'name')
db_connectionstring = db_config_file.get('database', 'connectionstring')
db_obj = xeniaAlchemy()
if (db_obj.connectDB(db_connectionstring, db_user, db_pwd, db_host,
db_name, False) == True):
logger.info("Succesfully connect to DB: %s at %s" % (db_name, db_host))
default_prune = datetime.now() - timedelta(weeks=8)
prune_start_time = time.time()
# Get list of platforms to prune.
platform_recs = db_obj.session.query(platform) \
.order_by(platform.organization_id).all()
platform_count = 0
connectionString = "%s://%s:%s@%s/%s" % (db_connectionstring, db_user,
db_pwd, db_host, db_name)
db_engine = create_engine(connectionString, echo=False)
connection = db_engine.raw_connection()
connection.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
cursor = connection.cursor()
try:
delete_start_time = time.time()
delete_where = "m_date < '%s'" % (
default_prune.strftime('%Y-%m-%dT%H:%M:%S'))
cursor.execute("DELETE FROM multi_obs WHERE %s" % (delete_where))
except Exception as e:
logger.exception(e)
else:
logger.info("Pruned records WHERE %s in %f seconds" %
(delete_where, time.time() - delete_start_time))
'''
for platform_rec in platform_recs:
delete_start_time = time.time()
db_obj.session.query(multi_obs) \
.filter(multi_obs.m_date < default_prune.strftime('%Y-%m-%dT%H:%M:%S')) \
.filter(multi_obs.platform_handle == platform_rec.platform_handle)\
.delete()
logger.info("Platform: %s pruned records older than: %s in %f seconds" % (
platform_rec.platform_handle, default_prune, time.time() - delete_start_time))
platform_count += 1
'''
cursor.close()
connection.close()
db_obj.disconnect()
try:
# Now create raw connection to database to do vacuum.
connectionString = "%s://%s:%s@%s/%s" % (
db_connectionstring, db_user, db_pwd, db_host, db_name)
logger.info("Preparing to vacuum and reindex")
db_engine = create_engine(connectionString, echo=False)
connection = db_engine.raw_connection()
connection.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
except (exc.OperationalError, Exception) as e:
logger.exception(e)
else:
cursor = connection.cursor()
vacuum_start_time = time.time()
#cursor.execute("VACUUM ANALYSE multi_obs")
cursor.execute("VACUUM FULL multi_obs")
logger.info("VACUUMed multi_obs in %f seconds" %
(time.time() - vacuum_start_time))
reindex_start_time = time.time()
cursor.execute("REINDEX TABLE multi_obs")
logger.info("Reindexed multi_obs in %f seconds" %
(time.time() - reindex_start_time))
cursor.close()
connection.close()
db_engine.dispose()
else:
logger.error("Unable to connect to DB: %s at %s. Terminating script." %
(db_name, db_host))
return
import sys
import serial
import time
import ConfigParser
import io
import os
import json
from influxdb import InfluxDBClient
from influxdb.client import InfluxDBClientError
with open("config.ini") as f:
sample_config = f.read()
config = ConfigParser.RawConfigParser(allow_no_value=True)
config.readfp(io.BytesIO(sample_config))
################
# Variables
################
influx_server = config.get('INFLUXDB',
'influxdb_server') # Ifluxdb server adre$
influx_port = int(config.get('INFLUXDB', 'influxdb_port')) # Influxdb port
influx_db = config.get('INFLUXDB', 'influxdb_databasename') # influxdb name
influx_user = config.get('INFLUXDB',
'influxdb_user') # influxdb gebruikersnaam
influx_passwd = config.get('INFLUXDB', 'influxdb_password') # influxdb login
################
#Error display #
################
def show_error():
def __init__(self, cf):
self.config = config = ConfigParser.RawConfigParser()
config.readfp(cf)
[Icons] show: yes use_gtk_theme: yes theme: Mint-X size: 24 application: application-x-executable bookmark: user-bookmarks folder: gtk-directory file: gtk-file internal_drive: gtk-harddisk optical_drive: gtk-cdrom removable_drive: gnome-dev-removable mount: gtk-execute unmount: media-eject """ ######################################################## # # # -------------------- Config Run -------------------- # # # ######################################################## # Parse uxdgmenu default config __parser = ConfigParser.RawConfigParser() __parser.readfp(StringIO.StringIO(DEFAULT_CONFIG)) # Create working dirs & config files if needed check() # Parse config files __parser.read([SYSTEM_CONFIG_FILE, USER_CONFIG_FILE])
def _get_config_from_file(self):
# Parse Liota configuration file
config = ConfigParser.RawConfigParser()
config.optionxform = str
fullPath = LiotaConfigPath().get_liota_fullpath()
if fullPath != '':
try:
if config.read(fullPath) != []:
try:
# retrieve device info file storage directory
self.dev_file_path = config.get(
'IOTCC_PATH', 'dev_file_path')
# retrieve organization info file storage directory
self.org_file_path = config.get(
'IOTCC_PATH', 'iotcc_path')
except ConfigParser.ParsingError as err:
log.error('Could not parse log config file' + err)
exit(-4)
if not os.path.exists(self.dev_file_path):
try:
os.makedirs(self.dev_file_path)
except OSError as exc: # Python >2.5
if exc.errno == errno.EEXIST and os.path.isdir(
self.dev_file_path):
pass
else:
log.error(
'Could not create device file storage directory'
)
exit(-4)
if not os.path.exists(self.org_file_path):
log.error('No organization info file (iotcc.json)')
try:
# retrieve discovery cmd pip
self.cmd_messenger_pipe = os.path.abspath(
config.get('DISC_CFG', 'disc_cmd_msg_pipe'))
# retrieve package path (later use config file to register device)
self.package_path = os.path.abspath(
config.get('PKG_CFG', 'pkg_path'))
# retrieve endpoint list
tmp_list = config.items('DISC_ENDPOINT_LIST')
for key, value in tmp_list[:]:
if value is None or value == "None":
continue
if key.find('disc_msg_pipe') != -1:
self.discovery_messenger_pipe = os.path.abspath(
value)
if self.discovery_messenger_pipe is not None:
self.endpoint_list[
key] = self.discovery_messenger_pipe
elif key.find('socket') != -1:
self.endpoint_list[key] = value
elif key.find('mqtt') != -1:
# retrieve mqtt configurations
mqtt_cfg_dict = dict(
config.items('DISC_MQTT_CFG'))
# make broker_ip:port:topic included inside mqtt_cfg_dict
mqtt_cfg_dict["broker_ip_port_topic"] = value
self.endpoint_list[key] = mqtt_cfg_dict
elif key.find('coap') != -1:
self.endpoint_list[key] = value
else:
log.error(key + ' is currently not supported!')
for key in self.endpoint_list.iterkeys():
log.debug("endpoint_list:(%s : %s)\n" %
(key, self.endpoint_list[key]))
global DEVICE_TYPE_SAFE_REGEX
# retrieve device type to unique key mapping list
tmp_list = config.items(
'DEVICE_TYPE_TO_UNIQUEKEY_MAPPING')
for key, value in tmp_list[:]:
if not re.match(DEVICE_TYPE_SAFE_REGEX, key):
log.warning(
"device type {0} contains unacceptable character"
.format(key))
continue
if value is None or value == "None":
continue
self.type_key_map[key] = value
for key in self.type_key_map.iterkeys():
log.debug("type_key_map:(%s : %s)\n" %
(key, self.type_key_map[key]))
# retrieve device type to DCC mapping list
tmp_list = config.items('DEVICE_TYPE_TO_DCC_MAPPING')
for key, value in tmp_list[:]:
if not re.match(DEVICE_TYPE_SAFE_REGEX, key):
log.warning(
"device type {0} contains unacceptable character"
.format(key))
continue
if value is None or value == "None":
continue
tmp_list2 = []
tmp_list2 = [x.strip() for x in value.split(',')]
self.type_dcc_map[key] = tmp_list2
self.type_tuple_key_dcc_pkg[key] = (
self.type_key_map[key], tmp_list2)
for key in self.type_dcc_map.iterkeys():
log.debug("type_dcc_map:(%s : %s)\n" %
(key, self.type_dcc_map[key]))
for key in self.type_tuple_key_dcc_pkg.iterkeys():
log.debug("type_tuple_key_dcc_pkg:(%s : %s)\n" %
(key, self.type_tuple_key_dcc_pkg[key]))
except ConfigParser.ParsingError:
log.error('Could not parse log config file')
exit(-4)
else:
raise IOError('Could not open configuration file: ' +
fullPath)
except IOError:
raise IOError('Could not open configuration file: ' + fullPath)
else:
# missing config file
log.error('liota.conf file missing')
assert (isinstance(self.cmd_messenger_pipe, basestring))
def run():
"""
Run the wind multiplier calculations.
This will attempt to run the calculation in parallel by tiling the
domain, but also provides a sane fallback mechanism to execute
in serial.
"""
# add subfolders into path
cmd_folder = os.path.realpath(
os.path.abspath(
os.path.split(inspect.getfile(inspect.currentframe()))[0]))
if cmd_folder not in sys.path:
sys.path.insert(0, cmd_folder)
cmd_subfolder1 = pjoin(cmd_folder, "terrain")
if cmd_subfolder1 not in sys.path:
sys.path.insert(0, cmd_subfolder1)
cmd_subfolder2 = pjoin(cmd_folder, "shielding")
if cmd_subfolder2 not in sys.path:
sys.path.insert(0, cmd_subfolder2)
cmd_subfolder3 = pjoin(cmd_folder, "topographic")
if cmd_subfolder3 not in sys.path:
sys.path.insert(0, cmd_subfolder3)
cmd_subfolder4 = pjoin(cmd_folder, "utilities")
if cmd_subfolder4 not in sys.path:
sys.path.insert(0, cmd_subfolder4)
config = ConfigParser.RawConfigParser()
config.read(pjoin(cmd_folder, 'multiplier_conf.cfg'))
root = config.get('inputValues', 'root')
upwind_length = float(config.get('inputValues', 'upwind_length'))
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'multipliers.log')
loglevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
if verbose:
verbose = True
else:
verbose = False
attempt_parallel()
if pp.size() > 1 and pp.rank() > 0:
logfile += '_' + str(pp.rank())
verbose = False
else:
pass
fl_start_log(logfile, loglevel, verbose)
# set input maps and output folder
terrain_map = pjoin(pjoin(root, 'input'), "lc_terrain_class.img")
dem = pjoin(pjoin(root, 'input'), "dems1_whole.img")
do_output_directory_creation(root)
global output_folder
output_folder = pjoin(root, 'output')
log.info("get the tiles based on the DEM")
tg = TileGrid(upwind_length, dem)
tiles = get_tiles(tg)
log.info('the number of tiles is {0}'.format(str(len(tiles))))
pp.barrier()
multiplier = Multipliers(terrain_map, dem)
multiplier.parallelise_on_tiles(tiles)
pp.barrier()
log.info("Successfully completed wind multipliers calculation")
def parse_gh():
config = ConfigParser.RawConfigParser(allow_no_value=True)
config.read('.deploy.ini')
if not config.getboolean('Github', 'enable'):
return None
prerelease = config.getboolean('Github', 'prerelease')
if not prerelease:
conditional_prerelease = config.getboolean('Github',
'conditional_prerelease')
if conditional_prerelease and ("alpha" in os.environ["TRAVIS_TAG"]
or "beta" in os.environ["TRAVIS_TAG"]):
prerelease = True
draft = config.getboolean('Github', 'draft')
if not draft:
conditional_draft = config.getboolean('Github', 'conditional_draft')
if conditional_draft and ("alpha" in os.environ["TRAVIS_TAG"]
or "beta" in os.environ["TRAVIS_TAG"]):
draft = True
title = config.get('Github', 'title')
description = config.get('Github', 'description')
branch = config.get('Github', 'branch')
packagename = config.get('Github', 'packagename')
include_version = config.getboolean('Github', 'include_version')
deploy_gh = {
"provider": "releases",
"api_key": os.environ["GH_TOKEN"],
"target_commitish": os.environ["TRAVIS_COMMIT"],
"draft": draft,
"prerelease": prerelease,
"skip_cleanup": "true",
"on": {}
}
if title:
deploy_gh["name"] = title
else:
deploy_gh["name"] = os.environ["TRAVIS_TAG"]
if description:
deploy_gh["description"] = description
if branch:
deploy_gh["on"]["branch"] = branch
else:
deploy_gh["on"]["all_branches"] = "true"
if packagename:
if include_version:
deploy_gh["file"] = "./Deploy/%s_%s.zip" % (
packagename, os.environ["TRAVIS_TAG"])
else:
deploy_gh["file"] = "./Deploy/%s.zip" % packagename
else:
if include_version:
deploy_gh["file"] = "./Deploy/%s_%s.zip" % (
os.environ["TRAVIS_REPO_SLUG"].split("/")[1],
os.environ["TRAVIS_TAG"])
else:
deploy_gh["file"] = "./Deploy/%s.zip" % os.environ[
"TRAVIS_REPO_SLUG"].split("/")[1] #this is the repo name
return deploy_gh
