def __init__(self, wnck_window, group):
self.group_r = weakref.ref(group)
self.globals = Globals()
self.opacify_obj = Opacify()
connect(self.globals, "show-only-current-monitor-changed",
self.__on_show_only_current_monitor_changed)
self.screen = wnck.screen_get_default()
self.wnck = wnck_window
self.deopacify_sid = None
self.opacify_sid = None
self.select_sid = None
self.xid = self.wnck.get_xid()
self.is_active_window = False
self.on_current_desktop = self.is_on_current_desktop()
self.monitor = self.get_monitor()
self.state_changed_event = self.wnck.connect("state-changed",
self.__on_window_state_changed)
self.icon_changed_event = self.wnck.connect("icon-changed",
self.__on_window_icon_changed)
self.name_changed_event = self.wnck.connect("name-changed",
self.__on_window_name_changed)
self.geometry_changed_event = self.wnck.connect("geometry-changed",
self.__on_geometry_changed)
self.item = WindowItem(self, group)
self.needs_attention = self.wnck.needs_attention()
self.item.show()
self.__on_show_only_current_monitor_changed()
def main():
connection = common.connect()
region = common.prompt_region(connection)
connection = common.connect(region)
zone = common.prompt_zone(connection)
security_group = common.prompt_security_group(connection)
prefix = "{}-{}-".format(security_group, zone.split("-")[-1])
name = _prompt_name(connection, prefix)
instance_type = _prompt_instance_type()
key_path = common.prompt_key_path()
key_name = os.path.basename(key_path).split(".")[0]
arguments = _LaunchArguments(instance_type=instance_type,
key_name=key_name,
name=name,
security_group=security_group,
zone=zone)
env.host_string = _launch(connection, arguments, region)
env.key_filename = key_path
env.user = _USERNAME
common.wait_until_remote_reachable()
sudo("hostname {}".format(name))
_update_system_files(name)
_install()
_update_installed_files()
reboot()
if instance_type.ephemeral_disk_count > 1:
_create_ephemeral_raid(instance_type.ephemeral_disk_count)
if _GIT_REPO:
_clone()
def main():
connection = common.connect()
prefix = raw_input(
"Do you want the section of {} to have a prefix? (default '')".format(
_HOSTS_PATH))
if prefix:
prefix = prefix + " "
region = common.prompt_region(connection)
type_ = common.prompt_choice("Type", ["private", "public"], "public")
begin_marker = "# {}{} begin".format(prefix, region.name)
end_marker = "# {}{} end".format(prefix, region.name)
with open(_HOSTS_PATH) as hosts_file:
content = hosts_file.read()
content = re.sub("\s*{}.*{}".format(begin_marker, end_marker), "", content,
flags=re.DOTALL)
connection = common.connect(region)
mapping = sorted(_get_mapping(connection, type_ == "public"))
content += _generate_mapping_content(begin_marker, end_marker, mapping)
with tempfile.NamedTemporaryFile(delete=False) as temporary_file:
temporary_file.write(content)
subprocess.check_call([
"sudo",
"cp",
temporary_file.name,
_HOSTS_PATH
])
def __init__(self, group, class_group=None,
desktop_entry=None, identifier=None):
self.dockbar_r = weakref.ref(group.dockbar_r())
self.theme = Theme()
self.globals = Globals()
connect(self.globals, "color-changed", self.reset_surfaces)
self.desktop_entry = desktop_entry
self.identifier = identifier
self.class_group = class_group
# Setting size to something other than zero to
# avoid crashes if surface_update() is runned
# before the size is set.
self.size = 15
self.icon = None
self.surfaces = {}
self.average_color = None
self.max_win_nr = self.theme.get_windows_cnt()
self.types_in_theme = 0
for type in self.theme.get_types():
if not type in self.TYPE_DICT:
continue
self.types_in_theme = self.types_in_theme | self.TYPE_DICT[type]
def parse_arguments(arguments):
"""Parse command-line arguments."""
option_parser = OptionParser()
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, arguments)."""
option_parser = OptionParser()
option_parser.add_option("-y", "--year", default=date.today().year)
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, runners).
May raise a ConnectionError"""
option_parser = OptionParser("%prog RUNNER_ID [RUNNER_IDS...]")
option_parser.add_option("-t", "--sort-times", action="store_true", default=False)
options, runner_ids = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse the command-line arguments. Returns the tuple (options,
arguments)."""
option_parser = OptionParser()
option_parser.add_option("--show-venues", action="store_true",
default=False, help="Show the venue where each "
"race was held.")
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options,
arguments)."""
option_parser = OptionParser()
option_parser.add_option("-g", "--gender", action="callback",
callback=gender_callback, type="str")
option_parser.add_option("--school")
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, arguments)."""
option_parser = OptionParser()
option_parser.add_option("-p", "--pretty", action="store_true",
default=False, help="Print database ID and "
"official name. If not set, the program prints "
"out a list of all nicknames as well.")
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, race_id)."""
option_parser = OptionParser()
option_parser.set_usage("%prog [options] RACE_ID")
option_parser.add_option("-y", "--year", default=date.today().year,
help="Year in which the race occurred.",
type="int")
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
race = Races.get(int(arguments[0]))
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, (school,)).
May raise a ConnectionError."""
option_parser = OptionParser("%prog SCHOOL")
option_parser.add_option("-g", "--sort-by-gender", action="store_true",
default=False)
option_parser.add_option("-y", "--year", default=date.today().year,
type="int")
options, arguments = option_parser.parse_args(arguments[1:])
try:
connect(options.server)
except ConnectionError, error:
option_parser.error(error)
def __init__(self, window, group):
CairoButton.__init__(self)
self.set_no_show_all(True)
self.window_r = weakref.ref(window)
self.group_r = weakref.ref(group)
self.globals = Globals()
self.opacify_sid = None
self.deopacify_sid = None
self.press_sid = None
self.pressed = False
self.close_button = CairoCloseButton()
self.close_button.set_no_show_all(True)
if self.globals.settings["show_close_button"]:
self.close_button.show()
self.label = gtk.Label()
self.label.set_ellipsize(pango.ELLIPSIZE_END)
self.label.set_alignment(0, 0.5)
self.__update_label()
self.area.set_needs_attention(window.wnck.needs_attention())
hbox = gtk.HBox()
icon = window.wnck.get_mini_icon()
self.icon_image = gtk.image_new_from_pixbuf(icon)
hbox.pack_start(self.icon_image, False)
hbox.pack_start(self.label, True, True, padding = 4)
alignment = gtk.Alignment(1, 0.5, 0, 0)
alignment.add(self.close_button)
hbox.pack_start(alignment, False, False)
vbox = gtk.VBox()
vbox.pack_start(hbox, False)
self.preview_box = gtk.Alignment(0.5, 0.5, 0, 0)
self.preview_box.set_padding(4, 2, 0, 0)
self.preview = gtk.Image()
self.preview_box.add(self.preview)
self.preview.show()
vbox.pack_start(self.preview_box, True, True)
self.add(vbox)
self.preview_box.set_no_show_all(True)
vbox.show_all()
self.show_all()
self.update_show_state()
self.drag_dest_set(0, [], 0)
self.drag_entered = False
self.close_button.connect("button-press-event", self.disable_click)
self.close_button.connect("clicked", self.__on_close_button_clicked)
self.close_button.connect("leave-notify-event",
self.__on_close_button_leave)
connect(self.globals, "show-close-button-changed",
self.__on_show_close_button_changed)
connect(self.globals, "color-changed", self.__update_label)
connect(self.globals, "preview-size-changed", self.update_preview)
connect(self.globals, "window-title-width-changed",
self.__update_label)
def walldistdbread(logger, connfile, table, begin, end, crits, users, hosts,
title, plan, norm):
'''
Connect to DB, run query and store x values into a list which is returned.
Specific to getting data for plotting a histogram of the waiting
distribution, i.e. dbread() isn't really suitable for doing it (not
least because we don't have time on the x axis, we have walltimes).
'''
# Connect
c = common.connect(logger, os.path.expanduser(connfile))
cursor = c.cursor()
# Queues or groups
critcond, crits = mkcritcond(crits)
# Submit hosts
hostcond, hosts = mkcond(hosts, 'fromHost')
# Users
usercond, users = mkcond(users, 'userName')
# Normalisation factor
if norm == None:
factor = ''
else:
factor = ' * hostFactor * %s' % norm
# Query
# Difference is already in days by virtue of Oracle
sel = "SELECT (eventTime - startTime) * 24 %s" % factor
tab = "FROM %s" % table
# Time condition is compulsory and there are default values anyway
timecond = "WHERE eventTime BETWEEN :begin AND :end"
span = [datetime.date.fromtimestamp(begin),
datetime.date.fromtimestamp(end)]
# Statement
stmt = '%s %s %s AND %s AND %s %s' % \
(sel, tab, timecond, STTCOND, CPUCOND, critcond + hostcond + usercond)
params = span + [EPOCH] + crits + hosts + users
print "Querying..."
t = time.time()
if plan:
mkplan(cursor, stmt)
cursor.execute(stmt, params)
# Run query and store values
f = open(title.translate(TRANS) + '.data', 'w')
xs = []
for x, in cursor:
print >>f, '%f' % x
xs.append(x)
print "Queried in %f s" % (time.time() - t)
f.close()
return xs
def SenderClient(nick):
sock = connect()
sendCmd(sock, "LOGIN %s\r\n" % nick)
sendCmd(sock, "JOIN #foo\r\n")
sendCmd(sock, "MSG #foo Hello!\r\n")
sendCmd(sock, "PART #foo\r\n")
sendCmd(sock, "LOGOUT\r\n")
sock.close()
def main():
if com.is_db_exists() :
print('이미 파일이 있음')
return
com.DB = com.connect()
com.make_table()
def NormalOp(i):
print "Go! %d"%i
sock = connect()
sendCmd(sock, "LOGIN foo%d\r\n" % i)
sendCmd(sock, "JOIN #foo\r\n")
sendCmd(sock, "MSG #foo hello\r\n")
sendCmd(sock, "MSG foo%d sup\r\n" % i)
sendCmd(sock, "PART #foo\r\n")
sendCmd(sock, "LOGOUT\r\n")
disconnect(sock)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, (given_name,
surname, school, gender)). May raise a ConnectionError."""
option_parser = OptionParser()
option_parser.set_usage("%prog [options] GIVEN_NAME SURNAME SCHOOL GENDER")
option_parser.add_option("--competition-year", default=date.today().year,
type="int")
option_parser.add_option("-n", "--nicknames")
option_parser.add_option("-y", "--year", help="Graduation year", type="int")
options, arguments = option_parser.parse_args(arguments[1:])
index = count(0)
try:
connect(options.server)
given_name = arguments[index.next()]
surname = arguments[index.next()]
school_id = Schools.get(arguments[index.next()])
gender = parse_gender(arguments[index.next()])
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"Parse command line arguments. Returns the tuple (options, (gender,))."
option_parser = race_display_options(GenderedOptionParser())
option_parser.add_option("-c", "--conference", help="Include schools from "
"only the specified conference.")
option_parser.add_option("-d", "--dist-limit", help="Minimum race "
"distance.", type="int")
option_parser.add_option("-f", "--filter", help="Include or exclude the "
"specified schools.")
option_parser.add_option("-p", "--previous-years", default=0, type="int")
option_parser.add_option("-y", "--year", default=date.today().year,
type="int")
options, arguments = option_parser.parse_args(arguments[1:])
index = count()
try:
connect(options.server)
gender = arguments[next(index)]
except IndexError:
option_parser.error("")
except ConnectionError, error:
option_parser.error(error)
def parse_arguments(arguments):
"""Parse command line arguments. Returns the tuple (options, (name,
date, venue, city, state))."""
option_parser = OptionParser()
option_parser.set_usage("%prog [options] RACE_NAME DATE VENUE")
option_parser.add_option("-c", "--comments", help="Comments on the race, "
"such as conditions, intensity of competition, "
"etc.")
option_parser.add_option("-e", "--elevation", type="int")
option_parser.add_option("-m", "--mens-distance", help="The length of "
"the men's race.", type="int")
option_parser.add_option("-w", "--womens-distance", help="The length of "
"the women's race.", type="int")
options, arguments = option_parser.parse_args(arguments[1:])
index = count()
try:
connect(options.server)
race_name = arguments[next(index)]
date = Date.from_string(arguments[next(index)])
venue = arguments[next(index)]
venue = Venues.get(venue)
except ConnectionError, error:
option_parser.error(error)
def main():
socket = connect()
if not common.__dict__.has_key(sys.argv[1]):
raise Exception("Invalid request type")
req_type = common.__dict__[sys.argv[1]]
args = []
for pair in sys.argv[2:]:
pair_parts = pair.split(':', 1)
if len(pair_parts) == 1 or pair_parts[0] == 's':
args.append(pair_parts[-1])
elif pair_parts[0] == 'i':
args.append(int(pair_parts[1]))
send(socket, req_type, *args)
resp = recv_all(socket)
print resp
print "PAYLOAD SIZE: %d" % (len(resp['payload']),)
def connect_facebook(keyword):
photos = []
is_end_of_page = False
page = 1
while is_end_of_page == False:
url = generate_url(keyword, str(i), field)
json = connect(url)
for p in json['photos']['photo']:
photos.append(p)
pages = json['photos']['pages']
if pages > page and page < DEFAULT_MAX_PAGE_NUM:
page = page + 1
else:
is_end_of_page = True
print 'total size : ' + str(len(photos))
return photos
def main():
'''
Set up pylsf to read event records and set up pyinotify to notice them
as they come. Nothing expected, nothing returned.
'''
# Read arguments
p = optparse.OptionParser()
help = "user/passwd@dsn-formatted database connection file absolute path"
p.add_option("-c", "--connfile", help=help)
help = "LSF accounting log file absolute path"
p.add_option("-a", "--acctfile", help=help)
help = "PID file absolute path (defaults to %s)" % PIDFILE
p.add_option("-p", "--pidfile", help=help, default=PIDFILE)
help = "log file absolute path (defaults to %s)" % LOGFILE
p.add_option("-l", "--logfile", help=help, default=LOGFILE)
help = "how many minutes between log heart beats (defaults to %d)" % \
common.HBDELTA
p.add_option("-b", "--heartbeatdelta", type='int',
help=help, default=common.HBDELTA)
help = "Don't touch the DB"
p.add_option("-d", "--dryrun", action='store_true', help=help)
options, args = p.parse_args()
# Set up logging
#fmt = '%(asctime)s %(levelname)s %(message)s'
#logging.basicConfig(level=logging.INFO, format=fmt,
# filename='/tmp/acct.log')
#h = logging.handlers.SysLogHandler(address='/dev/log')
h = logging.FileHandler(options.logfile)
#fmt = "%(name)s: %(levelname)s %(message)s"
fmt = "%(asctime)s %(name)s: %(levelname)s %(message)s"
h.setFormatter(logging.Formatter(fmt, common.LOGDATEFMT))
logger = logging.getLogger(common.LOGGER)
logger.addHandler(h)
logger.setLevel(logging.INFO)
# Try to connect before daemonising to exit with a useful code
try:
if not options.dryrun:
logger.info("Trying DB connection...")
connection = common.connect(logger, options.connfile)
connection.close()
except common.AcctDBError, e:
logger.error(e)
return 1
def main():
ec2_connection = common.connect()
region = common.prompt_region(ec2_connection)
elb_connection = common.connect_elb_region(region.name)
elb = common.prompt_elb(elb_connection, _DEFAULT_ELB_NAME)
if not elb:
print("No ELBs exist for region {}".format(region.name))
return
choice = common.prompt_choice("Choice", _ELB_ACTIONS, _DEFAULT_ELB_ACTION)
while (choice != "Exit"):
elb_info = _get_elb_info(ec2_connection, elb)
_handle_user_choice(choice, elb, elb_info.zones,
elb_info.registered_instances,
elb_info.unregistered_instances)
choice = common.prompt_choice("Choice", _ELB_ACTIONS, _DEFAULT_ELB_ACTION)
return
def ListenerClient(nick):
global status
sock = connect()
sendCmd(sock, "LOGIN %s\r\n" % nick)
sock.recv(1024)
sendCmd(sock, "JOIN #foo\r\n")
data = ""
while 1:
data = sock.recv(1024)
if not data: break
if data == "OK\r\n":
continue
if "GOTROOMMSG" in data:
break
print "[%s] %s" % (nick, data.strip())
sendCmd(sock, "PART #foo\r\n")
sendCmd(sock, "LOGOUT\r\n")
sock.close()
def main():
# Read arguments
p = optparse.OptionParser()
help = "user/passwd@dsn-formatted database connection file path"
p.add_option("-c", "--connfile", help=help)
help = "table name"
p.add_option("-t", "--table", help=help)
help="don't do anything, only SQL-print what would be done"
p.add_option("-d", "--dryrun", action='store_true', help=help)
help = "log file absolute path (defaults to %s)" % LOGFILE
p.add_option("-l", "--logfile", help=help, default=LOGFILE)
help = "how many months to plan ahead (defaults to %d)" % AHEAD
p.add_option("-p", "--plan", help=help, type='int', default=AHEAD)
options, args = p.parse_args()
if None in (options.connfile, options.table):
p.print_help()
return 1
# Set up logging
h = logging.FileHandler(options.logfile)
fmt = "%(asctime)s %(name)s: %(levelname)s %(message)s"
h.setFormatter(logging.Formatter(fmt, common.LOGDATEFMT))
logger = logging.getLogger(common.LOGGER)
logger.addHandler(h)
logger.setLevel(logging.INFO)
# DB
connection = common.connect(logger, options.connfile)
cursor = connection.cursor()
# Create partitions
last = lastpartition(cursor, options.table)
stmts, months = createpartitions(options.table.upper(), last, options.plan)
for stmt, month in izip(stmts, months):
logger.info("Adding partition for %s to %s" % (month, options.table))
logger.info(stmt)
if not options.dryrun:
cursor.execute(stmt)
logger.info("Done")
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
common.connect()
tags = os.environ.get('RD_CONFIG_TAGS')
mappingList = os.environ.get('RD_CONFIG_MAPPING')
defaults = os.environ.get('RD_CONFIG_ATTRIBUTES')
running = False
if os.environ.get('RD_CONFIG_RUNNING') == 'true':
running = True
boEmoticon = False
if os.environ.get('RD_CONFIG_EMOTICON') == 'true':
boEmoticon = True
field_selector = None
if os.environ.get('RD_CONFIG_FIELD_SELECTOR'):
field_selector = os.environ.get('RD_CONFIG_FIELD_SELECTOR')
label_selector = None
if os.environ.get('RD_CONFIG_LABEL_SELECTOR'):
label_selector = os.environ.get('RD_CONFIG_LABEL_SELECTOR')
node_set = []
v1 = client.CoreV1Api()
log.debug(label_selector)
log.debug(field_selector)
if field_selector and label_selector:
ret = v1.list_pod_for_all_namespaces(
watch=False,
field_selector=field_selector,
label_selector=label_selector,
)
if field_selector and label_selector is None:
ret = v1.list_pod_for_all_namespaces(
watch=False,
field_selector=field_selector,
)
if label_selector and field_selector is None:
ret = v1.list_pod_for_all_namespaces(
watch=False,
label_selector=label_selector,
)
if label_selector is None and field_selector is None:
ret = v1.list_pod_for_all_namespaces(watch=False, )
for i in ret.items:
for container in i.spec.containers:
log.debug("%s\t%s\t%s\t%s" %
(i.status.pod_ip, i.metadata.namespace, i.metadata.name,
container.name))
node_data = nodeCollectData(i, container, defaults, tags,
mappingList, boEmoticon)
if running is False:
if (node_data["terminated"] is False):
node_set.append(node_data)
if running is True:
if node_data["status"].lower() == "running":
node_set.append(node_data)
print(json.dumps(node_set, indent=4, sort_keys=True))
def connect_flickr(keyword, field):
url = generate_url(keyword, str(1), field)
return connect(url)
def run(self):
print "Starting " + self.name
common.vectorClock[:1] = [[str(common.port), str(0)]]
common.findNeighbors()
common.connect()
common.updateList()
count = 0
while self.run_client:
#if count % 2:
common.askingToWrite()
#else:
#common.askingToRead()
if common.read == False and common.write == False:
continue
#print "Esperando..."
while True:
if common.waiting() == True:
print "\nAcessou a memoria compartilhada!"
localtime = time.localtime()
print time.strftime("%Y/%m/%d %H:%M:%S", localtime)
print common.vectorClock
break
common.toDoSomething()
count = count + 1
#daqui pra baixo eh tratamento de quebra de hashes
#for s in server.connected_servers:
#try:
#import pdb; pdb.set_trace()
# if s.ping():
# p = s.getPort()
# if p not in self.broken_hashes_server and p != self.port:
# vector = s.getHashes()
# print "\nQuebrando hashes..."
# v = self.breakHashes(vector)
# if v is not None:
# h = []
# for i in v:
# h.append(md5(i).hexdigest())
# if s.sendPasswords(v, h, server.vectorClock) == 1:
# self.broken_hashes_server.append(s.getPort())
# print "...Hashes quebradas!"
# print "Lista de pares cujas hashes jah foram quebradas:"
# print self.broken_hashes_server
# print "Lista de senhas:"
# print v
# print "Lista de hashes:"
# print h
# else:
# continue
#except:
# continue
print "Exiting" + self.name
score = 0.0
matched = 0
for n in nearest:
items = n[2]
if items.has_key(item):
matched += 1
score += float(items[item])
# average
if matched > 0:
score = score / matched
return score
if __name__ == '__main__':
common.connect()
client = common.client
login = common.login
#loadMLFile(sys.argv[1])
#loadMoviesFile(sys.argv[1])
# find 10 nearest neighbors (similar viewers)
#nearest = kNearestNeighbors('ml', 'user_1', 10)
# predict rating for a given movie
#predictedScore = recommendedScore(nearest, '')
#!/usr/bin/python
import unittest
import socket
import sys
from common import connect, disconnect, sendCmd
print "infinite stream..."
try:
pass
sock = connect()
while 1:
sock.send("x")
sock.close()
except:
print "got exception!"
print sys.exc_info()
print "login w/2KB username..."
try:
sock = connect()
cmd = "LOGIN "
for i in range(1, 2048):
cmd += "x"
cmd += "\r\n"
sendCmd(sock, cmd)
data = sock.recv(1024)
print "data = %s" % data
sendCmd(sock, "JOIN #foo")
def main():
# parse options
(options, args) = parse_options()
if os.isatty(sys.stdin.fileno()):
raise RuntimeError('Need configuration in stdin.')
config = common.read_config(sys.stdin)
conn = common.connect(config.s3)
bucket = None
try:
# setup
real_stdout = sys.stdout
sys.stdout = sys.stderr
# verify all required config items are present
if 'roundtrip' not in config:
raise RuntimeError('roundtrip section not found in config')
for item in ['readers', 'writers', 'duration', 'files', 'bucket']:
if item not in config.roundtrip:
raise RuntimeError(
"Missing roundtrip config item: {item}".format(item=item))
for item in ['num', 'size', 'stddev']:
if item not in config.roundtrip.files:
raise RuntimeError(
"Missing roundtrip config item: files.{item}".format(
item=item))
seeds = dict(config.roundtrip.get('random_seed', {}))
seeds.setdefault('main', random.randrange(2**32))
rand = random.Random(seeds['main'])
for name in ['names', 'contents', 'writer', 'reader']:
seeds.setdefault(name, rand.randrange(2**32))
print 'Using random seeds: {seeds}'.format(seeds=seeds)
# setup bucket and other objects
bucket_name = common.choose_bucket_prefix(config.roundtrip.bucket,
max_len=30)
bucket = conn.create_bucket(bucket_name)
print "Created bucket: {name}".format(name=bucket.name)
objnames = realistic.names(
mean=15,
stddev=4,
seed=seeds['names'],
)
objnames = itertools.islice(objnames, config.roundtrip.files.num)
objnames = list(objnames)
files = realistic.files(
mean=1024 * config.roundtrip.files.size,
stddev=1024 * config.roundtrip.files.stddev,
seed=seeds['contents'],
)
q = gevent.queue.Queue()
logger_g = gevent.spawn_link_exception(yaml.safe_dump_all,
q,
stream=real_stdout)
print "Writing {num} objects with {w} workers...".format(
num=config.roundtrip.files.num,
w=config.roundtrip.writers,
)
pool = gevent.pool.Pool(size=config.roundtrip.writers)
start = time.time()
for objname in objnames:
fp = next(files)
pool.spawn_link_exception(
writer,
bucket=bucket,
objname=objname,
fp=fp,
queue=q,
)
pool.join()
stop = time.time()
elapsed = stop - start
q.put(
dict(
type='write_done',
duration=int(round(elapsed * NANOSECOND)),
))
print "Reading {num} objects with {w} workers...".format(
num=config.roundtrip.files.num,
w=config.roundtrip.readers,
)
# avoid accessing them in the same order as the writing
rand.shuffle(objnames)
pool = gevent.pool.Pool(size=config.roundtrip.readers)
start = time.time()
for objname in objnames:
pool.spawn_link_exception(
reader,
bucket=bucket,
objname=objname,
queue=q,
)
pool.join()
stop = time.time()
elapsed = stop - start
q.put(
dict(
type='read_done',
duration=int(round(elapsed * NANOSECOND)),
))
q.put(StopIteration)
logger_g.get()
finally:
# cleanup
if options.cleanup:
if bucket is not None:
common.nuke_bucket(bucket)
def main():
common.connect()
api = core_v1_api.CoreV1Api()
namespace = os.environ.get('RD_CONFIG_NAMESPACE')
name = os.environ.get('RD_CONFIG_NAME')
container = os.environ.get('RD_CONFIG_CONTAINER_NAME')
log.debug("--------------------------")
log.debug("Pod Name: %s", name)
log.debug("Namespace: %s", namespace)
log.debug("Container: %s", container)
log.debug("--------------------------")
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["container_name"] = os.environ.get('RD_CONFIG_CONTAINER_NAME')
data["image"] = os.environ.get('RD_CONFIG_IMAGE')
data["ports"] = os.environ.get('RD_CONFIG_PORTS')
data["replicas"] = os.environ.get('RD_CONFIG_REPLICAS')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
data["labels"] = os.environ.get('RD_CONFIG_LABELS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS'):
data["environments"] = os.environ.get('RD_CONFIG_ENVIRONMENTS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS'):
evs = os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS')
data["environments_secrets"] = evs
if os.environ.get('RD_CONFIG_LIVENESS_PROBE'):
data["liveness_probe"] = os.environ.get('RD_CONFIG_LIVENESS_PROBE')
if os.environ.get('RD_CONFIG_READINESS_PROBE'):
data["readiness_probe"] = os.environ.get('RD_CONFIG_READINESS_PROBE')
if os.environ.get('RD_CONFIG_VOLUME_MOUNTS'):
data["volume_mounts"] = os.environ.get('RD_CONFIG_VOLUME_MOUNTS')
if os.environ.get('RD_CONFIG_VOLUMES'):
data["volumes"] = os.environ.get('RD_CONFIG_VOLUMES')
if os.environ.get('RD_CONFIG_CONTAINER_COMMAND'):
cc = os.environ.get('RD_CONFIG_CONTAINER_COMMAND')
data["container_command"] = cc
if os.environ.get('RD_CONFIG_CONTAINER_ARGS'):
data["container_args"] = os.environ.get('RD_CONFIG_CONTAINER_ARGS')
if os.environ.get('RD_CONFIG_RESOURCES_REQUESTS'):
rr = os.environ.get('RD_CONFIG_RESOURCES_REQUESTS')
data["resources_requests"] = rr
if os.environ.get('RD_CONFIG_WAITREADY'):
data["waitready"] = os.environ.get('RD_CONFIG_WAITREADY')
if os.environ.get('RD_CONFIG_IMAGEPULLSECRETS'):
data["image_pull_secrets"] = os.environ.get('RD_CONFIG_IMAGEPULLSECRETS')
pod = create_pod(data)
resp = None
try:
resp = api.create_namespaced_pod(namespace=namespace,
body=pod,
pretty="True")
print("Pod Created successfully")
except ApiException:
log.exception("Exception creating pod:")
exit(1)
if not resp:
print("Pod %s does not exist" % name)
exit(1)
def __init__(self, astergui, parent=None):
"""
Create view.
Arguments:
astergui (AsterGui): *AsterGui* instance.
parent (Optional[QWidget]): Parent widget. Defaults to
*None*.
"""
super(DataFiles, self).__init__(parent)
self.astergui = astergui
self.setObjectName("DataFilesBase")
self.ops = {}
# Files tree
self.view = FilesView(self)
self.view.setObjectName('DataFilesView')
connect(self.view.clicked, self.updateButtonsState)
connect(self.view.doubleClicked, self._doubleClicked)
# Toolbar
self.toolbar = Q.QToolBar(self)
self.toolbar.setToolButtonStyle(Q.Qt.ToolButtonIconOnly)
self.toolbar.setObjectName("DataFilesToolbar")
# - add file
action = Q.QAction(translate("AsterStudy", "&Add File"), self)
action.setToolTip(translate("AsterStudy", "Add file"))
action.setStatusTip(
translate("AsterStudy", "Add a data file to the stage"))
action.setIcon(load_icon("as_pic_new_file.png"))
connect(action.triggered, self.add)
self.ops[DataFiles.Add] = action
# - edit file
action = Q.QAction(translate("AsterStudy", "&Edit File"), self)
action.setToolTip(translate("AsterStudy", "Edit file"))
action.setStatusTip(
translate("AsterStudy", "Edit properties of selected data file"))
action.setIcon(load_icon("as_pic_edit_file.png"))
connect(action.triggered, self.edit)
self.ops[DataFiles.Edit] = action
# - view file
action = Q.QAction(translate("AsterStudy", "&View File"), self)
action.setToolTip(translate("AsterStudy", "View file"))
action.setStatusTip(
translate("AsterStudy", "View properties of selected data file"))
action.setIcon(load_icon("as_pic_view_file.png"))
connect(action.triggered, self.edit)
self.ops[DataFiles.View] = action
# - remove file
action = Q.QAction(translate("AsterStudy", "&Remove File"), self)
action.setToolTip(translate("AsterStudy", "Remove file"))
action.setStatusTip(
translate("AsterStudy", "Remove selected data file "
"from the stage"))
action.setIcon(load_icon("as_pic_remove_file.png"))
connect(action.triggered, self.remove)
self.ops[DataFiles.Remove] = action
# - go to
action = Q.QAction(translate("AsterStudy", "&Go To"), self)
action.setToolTip(translate("AsterStudy", "Go to"))
action.setStatusTip(
translate("AsterStudy", "Go to the selected command"))
action.setIcon(load_icon("as_pic_goto.png"))
connect(action.triggered, self.goto)
self.ops[DataFiles.GoTo] = action
# - fill in toolbar
self.toolbar.addAction(self.ops[DataFiles.Add])
self.toolbar.addAction(self.ops[DataFiles.Edit])
self.toolbar.addAction(self.ops[DataFiles.View])
self.toolbar.addAction(self.ops[DataFiles.Remove])
self.toolbar.addAction(self.ops[DataFiles.GoTo])
# Layout widgets
vbox_layout = Q.QVBoxLayout(self)
vbox_layout.setContentsMargins(5, 5, 5, 5)
vbox_layout.addWidget(self.view)
vbox_layout.addWidget(self.toolbar)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "Deployment":
k8s_beta = client.ExtensionsV1beta1Api()
resp = k8s_beta.delete_namespaced_deployment(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
print("Deployment deleted. status='%s'" % str(resp.status))
if data["type"] == "Service":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_service(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
print("Service deleted. status='%s'" % str(resp.status))
if data["type"] == "Ingress":
k8s_beta = client.ExtensionsV1beta1Api()
body = client.V1DeleteOptions()
resp = k8s_beta.delete_namespaced_ingress(
name=data["name"],
namespace=data["namespace"],
body=body,
pretty="true")
print("Ingress deleted. status='%s'" % str(resp.status))
if data["type"] == "Job":
api_instance = client.BatchV1Api()
resp = api_instance.delete_namespaced_job(
namespace=data["namespace"], name=data["name"], pretty="true")
print("Job deleted. status='%s'" % str(resp.status))
if data["type"] == "StorageClass":
api_instance = client.StorageV1Api()
resp = api_instance.delete_storage_class(
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
print("Storage Class deleted. status='%s'" % str(resp))
if data["type"] == "PersistentVolumeClaim":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_persistent_volume_claim(
namespace=data["namespace"],
body=client.V1DeleteOptions(),
name=data["name"],
pretty="true")
print("PVC deleted. status='%s'" % str(resp.status))
if data["type"] == "Secret":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_secret(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
print("Secret deleted. status='%s'" % str(resp.status))
if data["type"] == "PersistentVolume":
api_instance = client.CoreV1Api()
resp = api_instance.delete_persistent_volume(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
print("PV deleted. status='%s'" % str(resp.status))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
def main():
parser = OptionParser(usage='%prog [options]')
parser.add_option(
'-n',
'--dry-run',
action='store_true',
default=False,
help='show what would be inserted without actually doing it')
options, args = parser.parse_args()
# temporary table to receive new runs
db = connect()
db.autocommit = False
#cursor = db.cursor()
#cursor.execute('SELECT run_id FROM run_suppress UNION SELECT run_id FROM run')
#known = frozenset(row[0] for row in results(cursor))
#print 'known:', len(known)
#del cursor
#return 13
db.cursor().execute("""
CREATE TEMPORARY TABLE upload_run (
run_id VARCHAR(24) PRIMARY KEY NOT NULL,
application_name VARCHAR(50) NOT NULL,
application_version VARCHAR(50) NOT NULL,
application_release VARCHAR(50) NOT NULL,
build_distribution VARCHAR(50) NOT NULL,
version VARCHAR(255) NOT NULL,
sparsity INTEGER NOT NULL CHECK (sparsity > 0),
exit_signal SMALLINT NOT NULL CHECK (exit_signal >= 0),
exit_status SMALLINT NOT NULL CHECK (exit_status >= 0),
CHECK (exit_status = 0 OR exit_signal = 0),
date TIMESTAMP NOT NULL,
server_name VARCHAR(50) NOT NULL
)
""")
if args:
subdirs = args
else:
subdirs = sys.stdin
subdirs = imap(str.rstrip, subdirs)
# upload new runs into temporary table
subdirs = imap(dirname, subdirs)
runs = uploadRuns(db, subdirs)
# remove anything we already knew about
print 'discard already-known runs'
cursor = db.cursor()
cursor.execute("""
DELETE FROM upload_run
USING run
WHERE upload_run.run_id = run.run_id
""")
print '\t%d discarded' % cursor.rowcount
del cursor
# merge new runs into main table
db.cursor().execute("""
INSERT INTO run SELECT
run_id,
build_id,
version,
sparsity,
exit_signal,
exit_status,
date,
server_name
FROM upload_run
NATURAL LEFT JOIN build
""")
# finish up with database
if options.dry_run:
db.rollback()
else:
db.commit()
db.close()
# archive new runs
for run in runs:
archive = archives[run.server_name]
year, month = run.date.split('-')[0:2]
destdir = '%s/%s/%s' % (archive, year, month)
destination = '%s/%s' % (destdir, run.run_id)
print 'archive: %s -> %s' % (run.subdir, destdir)
if not options.dry_run:
if not exists(destdir):
makedirs(destdir)
rename(run.subdir, destination)
def __init__(self, node, astergui, parent=None): # pragma pylint: disable=too-many-locals
"""
Create editor panel.
Arguments:
node (Stage, Unit): Object to manage.
astergui (AsterGui): *AsterGui* instance.
parent (Optional[QWidget]): Parent widget. Defaults to
*None*.
"""
#----------------------------------------------------------------------
super(UnitPanel, self).__init__(parent=parent,
name="",
astergui=astergui)
#----------------------------------------------------------------------
self.node = node
self.prev_unit = None
self.unit = None
#----------------------------------------------------------------------
# set title
title = translate("UnitPanel", "Edit data file") \
if self.mode == UnitPanel.EditMode \
else translate("UnitPanel", "Add data file")
self._controllername = title
self.setWindowTitle(title)
# set icon
pixmap = load_pixmap("as_pic_edit_file.png") \
if self.mode == UnitPanel.EditMode \
else load_pixmap("as_pic_new_file.png")
self.setPixmap(pixmap)
#----------------------------------------------------------------------
# top-level layout
v_layout = Q.QVBoxLayout(self)
v_layout.setContentsMargins(0, 0, 0, 0)
#----------------------------------------------------------------------
# top level widget to easily manage read-only mode
self.frame = Q.QWidget(self)
v_layout.addWidget(self.frame)
#----------------------------------------------------------------------
# main layout
glayout = Q.QGridLayout(self.frame)
glayout.setContentsMargins(0, 0, 0, 0)
#----------------------------------------------------------------------
# 'Mode' controls
label = Q.QLabel(translate("DataFiles", "Mode"), self.frame)
glayout.addWidget(label, 0, 0)
self.attr_combo = Q.QComboBox(self.frame)
self.attr_combo.setObjectName("Mode")
attr_list = [FileAttr.In, FileAttr.Out, FileAttr.InOut]
for attr in attr_list:
self.attr_combo.addItem(FileAttr.value2str(attr), attr)
self.attr_combo.setCurrentIndex(-1)
glayout.addWidget(self.attr_combo, 0, 1)
#----------------------------------------------------------------------
label = Q.QLabel(translate("DataFiles", "Filename"), self.frame)
glayout.addWidget(label, 1, 0)
self.file_combo = Q.QComboBox(self.frame)
self.file_combo.setObjectName("Filename")
glayout.addWidget(self.file_combo, 1, 1, 1, 2)
self.file_btn = Q.QToolButton(self.frame)
self.file_btn.setText("...")
self.file_btn.setObjectName("Filename")
glayout.addWidget(self.file_btn, 1, 3)
#----------------------------------------------------------------------
# 'Unit' controls
label = Q.QLabel(translate("DataFiles", "Unit"), self.frame)
glayout.addWidget(label, 2, 0)
self.unit_edit = Q.QLineEdit(self.frame)
self.unit_edit.setObjectName("Unit")
self.unit_edit.setValidator(Q.QIntValidator(2, 99, self.unit_edit))
glayout.addWidget(self.unit_edit, 2, 1)
#----------------------------------------------------------------------
# 'Exists' controls
label = Q.QLabel(translate("DataFiles", "Exists"), self.frame)
glayout.addWidget(label, 3, 0)
self.exists_check = Q.QCheckBox(self.frame)
self.exists_check.setObjectName("Exists")
self.exists_check.setEnabled(False)
glayout.addWidget(self.exists_check, 3, 1)
#----------------------------------------------------------------------
# 'Embedded' controls
label = Q.QLabel(translate("DataFiles", "Embedded"), self.frame)
glayout.addWidget(label, 4, 0)
self.embedded_check = Q.QCheckBox(self.frame)
self.embedded_check.setObjectName("Embedded")
glayout.addWidget(self.embedded_check, 4, 1)
#----------------------------------------------------------------------
# tune layout
glayout.setColumnStretch(1, 2)
glayout.setColumnStretch(2, 2)
glayout.setRowStretch(glayout.rowCount(), 10)
#----------------------------------------------------------------------
# initialize unit model
file_model = UnitModel(self.stage)
self.file_combo.setModel(file_model)
self.file_combo.setCurrentIndex(-1)
#----------------------------------------------------------------------
# initialize controls from data model object
if self.mode == UnitPanel.EditMode:
self.setEditData(node)
#----------------------------------------------------------------------
# connections
connect(self.file_combo.currentIndexChanged, self.updateControls)
connect(self.file_combo.currentIndexChanged, self.updateButtonStatus)
connect(self.file_btn.clicked, self.browseFile)
connect(self.unit_edit.textChanged, self.updateButtonStatus)
connect(self.attr_combo.currentIndexChanged, self.updateButtonStatus)
connect(self.embedded_check.toggled, self.embeddedChanged)
connect(file_model.rowsAboutToBeInserted, self.beforeUpdate)
connect(file_model.rowsInserted, self.afterUpdate)
connect(file_model.rowsAboutToBeRemoved, self.beforeUpdate)
connect(file_model.rowsRemoved, self.afterUpdate)
#----------------------------------------------------------------------
# update status
self.updateControls()
def main():
# parse options
(options, args) = parse_options()
if os.isatty(sys.stdin.fileno()):
raise RuntimeError('Need configuration in stdin.')
config = common.read_config(sys.stdin)
conn = common.connect(config.s3)
bucket = None
try:
# setup
real_stdout = sys.stdout
sys.stdout = sys.stderr
# verify all required config items are present
if 'readwrite' not in config:
raise RuntimeError('readwrite section not found in config')
for item in ['readers', 'writers', 'duration', 'files', 'bucket']:
if item not in config.readwrite:
raise RuntimeError(
"Missing readwrite config item: {item}".format(item=item))
for item in ['num', 'size', 'stddev']:
if item not in config.readwrite.files:
raise RuntimeError(
"Missing readwrite config item: files.{item}".format(
item=item))
seeds = dict(config.readwrite.get('random_seed', {}))
seeds.setdefault('main', random.randrange(2**32))
rand = random.Random(seeds['main'])
for name in ['names', 'contents', 'writer', 'reader']:
seeds.setdefault(name, rand.randrange(2**32))
print 'Using random seeds: {seeds}'.format(seeds=seeds)
# setup bucket and other objects
bucket_name = common.choose_bucket_prefix(config.readwrite.bucket,
max_len=30)
bucket = conn.create_bucket(bucket_name)
print "Created bucket: {name}".format(name=bucket.name)
# check flag for deterministic file name creation
if not config.readwrite.get('deterministic_file_names'):
print 'Creating random file names'
file_names = realistic.names(
mean=15,
stddev=4,
seed=seeds['names'],
)
file_names = itertools.islice(file_names,
config.readwrite.files.num)
file_names = list(file_names)
else:
print 'Creating file names that are deterministic'
file_names = []
for x in xrange(config.readwrite.files.num):
file_names.append('test_file_{num}'.format(num=x))
files = realistic.files2(
mean=1024 * config.readwrite.files.size,
stddev=1024 * config.readwrite.files.stddev,
seed=seeds['contents'],
)
q = gevent.queue.Queue()
# warmup - get initial set of files uploaded if there are any writers specified
if config.readwrite.writers > 0:
print "Uploading initial set of {num} files".format(
num=config.readwrite.files.num)
warmup_pool = gevent.pool.Pool(size=100)
for file_name in file_names:
fp = next(files)
warmup_pool.spawn_link_exception(
write_file,
bucket=bucket,
file_name=file_name,
fp=fp,
)
warmup_pool.join()
# main work
print "Starting main worker loop."
print "Using file size: {size} +- {stddev}".format(
size=config.readwrite.files.size,
stddev=config.readwrite.files.stddev)
print "Spawning {w} writers and {r} readers...".format(
w=config.readwrite.writers, r=config.readwrite.readers)
group = gevent.pool.Group()
rand_writer = random.Random(seeds['writer'])
# Don't create random files if deterministic_files_names is set and true
if not config.readwrite.get('deterministic_file_names'):
for x in xrange(config.readwrite.writers):
this_rand = random.Random(rand_writer.randrange(2**32))
group.spawn_link_exception(
writer,
bucket=bucket,
worker_id=x,
file_names=file_names,
files=files,
queue=q,
rand=this_rand,
)
# Since the loop generating readers already uses config.readwrite.readers
# and the file names are already generated (randomly or deterministically),
# this loop needs no additional qualifiers. If zero readers are specified,
# it will behave as expected (no data is read)
rand_reader = random.Random(seeds['reader'])
for x in xrange(config.readwrite.readers):
this_rand = random.Random(rand_reader.randrange(2**32))
group.spawn_link_exception(
reader,
bucket=bucket,
worker_id=x,
file_names=file_names,
queue=q,
rand=this_rand,
)
def stop():
group.kill(block=True)
q.put(StopIteration)
gevent.spawn_later(config.readwrite.duration, stop)
# wait for all the tests to finish
group.join()
print 'post-join, queue size {size}'.format(size=q.qsize())
if q.qsize() > 0:
for temp_dict in q:
if 'error' in temp_dict:
raise Exception('exception:\n\t{msg}\n\t{trace}'.format(
msg=temp_dict['error']['msg'],
trace=temp_dict['error']['traceback']))
else:
yaml.safe_dump(temp_dict, stream=real_stdout)
finally:
# cleanup
if options.cleanup:
if bucket is not None:
common.nuke_bucket(bucket)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["container_name"] = os.environ.get('RD_CONFIG_CONTAINER_NAME')
data["image"] = os.environ.get('RD_CONFIG_IMAGE')
data["ports"] = os.environ.get('RD_CONFIG_PORTS')
data["replicas"] = os.environ.get('RD_CONFIG_REPLICAS')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
data["labels"] = os.environ.get('RD_CONFIG_LABELS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS'):
data["environments"] = os.environ.get('RD_CONFIG_ENVIRONMENTS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS'):
evs = os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS')
data["environments_secrets"] = evs
if os.environ.get('RD_CONFIG_LIVENESS_PROBE'):
data["liveness_probe"] = os.environ.get('RD_CONFIG_LIVENESS_PROBE')
if os.environ.get('RD_CONFIG_READINESS_PROBE'):
data["readiness_probe"] = os.environ.get('RD_CONFIG_READINESS_PROBE')
if os.environ.get('RD_CONFIG_VOLUME_MOUNTS'):
data["volume_mounts"] = os.environ.get('RD_CONFIG_VOLUME_MOUNTS')
if os.environ.get('RD_CONFIG_VOLUMES'):
data["volumes"] = os.environ.get('RD_CONFIG_VOLUMES')
if os.environ.get('RD_CONFIG_CONTAINER_COMMAND'):
cc = os.environ.get('RD_CONFIG_CONTAINER_COMMAND')
data["container_command"] = cc
if os.environ.get('RD_CONFIG_CONTAINER_ARGS'):
data["container_args"] = os.environ.get('RD_CONFIG_CONTAINER_ARGS')
if os.environ.get('RD_CONFIG_RESOURCES_REQUESTS'):
rr = os.environ.get('RD_CONFIG_RESOURCES_REQUESTS')
data["resources_requests"] = rr
if os.environ.get('RD_CONFIG_ANNOTATIONS'):
data["annotations"] = os.environ.get('RD_CONFIG_ANNOTATIONS')
if os.environ.get('RD_CONFIG_IMAGEPULLSECRETS'):
data["image_pull_secrets"] = os.environ.get(
'RD_CONFIG_IMAGEPULLSECRETS')
log.debug("Creating job from data:")
log.debug(data)
common.connect()
apiV1 = client.AppsV1Api()
deployment = create_deployment_object(data)
create_deployment(apiV1, deployment, data)
# -*- coding: utf-8 -*-
from hbase.ttypes import TPut, TColumnValue, TGet, TDelete, TColumn
from common import connect
with connect() as client:
table = 'tsdata'
# put multiple
tputs = [
TPut('sys.cpu.user:20180421:192.168.1.1', [
TColumnValue('cf', '1015', '0.28'),
TColumnValue('cf', '1016', '0.35'),
TColumnValue('cf', '1017', '0.25'),
]),
TPut('sys.cpu.user:20180421:192.168.1.2', [
TColumnValue('cf', '1015', '0.45'),
TColumnValue('cf', '1016', '0.32'),
TColumnValue('cf', '1017', '0.58'),
]),
]
client.putMultiple(table, tputs)
# get multiple
tgets = [
TGet('sys.cpu.user:20180421:192.168.1.1', [TColumn('cf', '1015')]),
TGet('sys.cpu.user:20180421:192.168.1.2', [TColumn('cf', '1015')])
]
for tresult in client.getMultiple(table, tgets):
print(tresult)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["yaml"] = os.environ.get('RD_CONFIG_YAML')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "Deployment":
dep = yaml.load(data["yaml"])
k8s_beta = client.ExtensionsV1beta1Api()
resp = k8s_beta.create_namespaced_deployment(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Service":
api_instance = client.CoreV1Api()
dep = yaml.load(data["yaml"])
resp = api_instance.create_namespaced_service(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Ingress":
dep = yaml.load(data["yaml"])
k8s_beta = client.ExtensionsV1beta1Api()
resp = k8s_beta.create_namespaced_ingress(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Job":
api_instance = client.BatchV1Api()
dep = yaml.load(data["yaml"])
resp = api_instance.create_namespaced_job(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "StorageClass":
dep = yaml.load(data["yaml"])
api_instance = client.StorageV1Api()
resp = api_instance.create_storage_class(body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "PersistentVolumeClaim":
dep = yaml.load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_namespaced_persistent_volume_claim(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Secret":
dep = yaml.load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_namespaced_secret(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "PersistentVolume":
dep = yaml.load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_persistent_volume(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
def _main():
# Get some time interval options.
parser = argparse.ArgumentParser(description="Import time entries from Toggl to Shotgun")
add_common_arguments(parser)
parser.add_argument(
"--start", "-s",
action="store",
required=False,
default=None,
help="First day to import data for in the YYYY-MM-DD format. Defaults to 5 days ago at midnight."
)
parser.add_argument(
"--end", "-e",
action="store",
required=False,
default=None,
help="Last day to import data for in the YYYY-MM-DD format. Defaults to current time."
)
# Read the options from the command line.
args = parser.parse_args()
if args.start is not None:
start = _user_str_to_utc_timezone(args.start)
else:
# Go back as far as 5 days ago to import data.
today_at_midnight = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
start = today_at_midnight - datetime.timedelta(days=7) + UTC_OFFSET
if args.end is not None:
end = _user_str_to_utc_timezone(args.end)
else:
# Otherwise now is pretty much the further something can be logged.
end = datetime.datetime.utcnow()
# Log into Shotgun and toggl.
(sg, sg_self), (toggl, wid) = connect(args.headless)
# Get Toggl project information
toggl_projects = get_projects_from_toggl(toggl)
# Create a map that goes from Toggl project id to a Shotgun ticket id.
toggl_projects_to_sg = {project_id: ticket_id for ticket_id, (_, project_id) in toggl_projects}
# Get the entries that the user requested.
time_entries = toggl.TimeEntries.get(
start_date=_to_toggl_date_format(start),
end_date=_to_toggl_date_format(end)
)
previous_day = None
# Group tasks by day, project and task name so we can compute and save a duration for a given task
# on a given project on a give day.
for (day, pid, task_name), time_entries in _sort_time_entries(_massage_time_entries(time_entries)):
# Task names are optional. If any, set to a empty string.
task_name = task_name or ""
# if the project is not tracked in Shotgun, skip it!
ticket_id = toggl_projects_to_sg.get(pid)
if ticket_id is None:
continue
# If we're on a new day, print its header.
if previous_day != day:
print day
previous_day = day
# Sum all the durations, except the one in progress if it is present (durtion < 9())
total_task_duration = int(sum((entry["duration"] for entry in time_entries if entry["duration"] >= 0)) / 60.0)
# Show some progress.
print " Ticket %s, Task %s %s" % (
ticket_id,
task_name.ljust(40),
_to_hours_minutes(total_task_duration)
)
ticket_link = {"type": "Ticket", "id": ticket_id}
# Find if we have an entry for this time log.
timelog_entity = sg.find_one(
"TimeLog",
[
["entity", "is", ticket_link],
["description", "is", task_name],
["date", "is", day]
]
)
# Create or update the entry in Shotgun.
if timelog_entity:
sg.update(
"TimeLog",
timelog_entity["id"],
{"duration": total_task_duration}
)
else:
sg.create("TimeLog", {
"entity": ticket_link,
"description": task_name,
"duration": max(total_task_duration, 1),
"project": {"type": "Project", "id": 12},
"date": day
})
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["container_name"] = os.environ.get('RD_CONFIG_CONTAINER_NAME')
data["image"] = os.environ.get('RD_CONFIG_IMAGE')
if os.environ.get('RD_CONFIG_PORTS'):
data["ports"] = os.environ.get('RD_CONFIG_PORTS')
data["replicas"] = os.environ.get('RD_CONFIG_REPLICAS')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
if os.environ.get('RD_CONFIG_LABELS'):
data["labels"] = os.environ.get('RD_CONFIG_LABELS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS'):
data["environments"] = os.environ.get('RD_CONFIG_ENVIRONMENTS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS'):
evs = os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS')
data["environments_secrets"] = evs
if os.environ.get('RD_CONFIG_LIVENESS_PROBE'):
data["liveness_probe"] = os.environ.get('RD_CONFIG_LIVENESS_PROBE')
if os.environ.get('RD_CONFIG_READINESS_PROBE'):
data["readiness_probe"] = os.environ.get('RD_CONFIG_READINESS_PROBE')
if os.environ.get('RD_CONFIG_CONTAINER_COMMAND'):
cc = os.environ.get('RD_CONFIG_CONTAINER_COMMAND')
data["container_command"] = cc
if os.environ.get('RD_CONFIG_CONTAINER_ARGS'):
data["container_args"] = os.environ.get('RD_CONFIG_CONTAINER_ARGS')
if os.environ.get('RD_CONFIG_RESOURCES_REQUESTS'):
rr = os.environ.get('RD_CONFIG_RESOURCES_REQUESTS')
data["resources_requests"] = rr
log.debug("Updating Deployment data:")
log.debug(data)
common.connect()
try:
extensions_v1beta1 = client.ExtensionsV1beta1Api()
deployment = create_deployment_object(data)
log.debug("deployment object: ")
log.debug(deployment)
update_deployment(extensions_v1beta1, deployment, data)
except ApiException as e:
log.error("Exception updating deployment: %s\n" % e)
sys.exit(1)
def wait():
try:
name = environ.get("RD_CONFIG_NAME")
namespace = environ.get("RD_CONFIG_NAMESPACE")
container = environ.get("RD_CONFIG_CONTAINER")
retries = int(environ.get("RD_CONFIG_RETRIES"))
sleep = float(environ.get("RD_CONFIG_SLEEP"))
show_log = environ.get("RD_CONFIG_SHOW_LOG") == "true"
# Poll for completion if retries
retries_count = 0
completed = False
while True:
common.connect()
batch_v1 = client.BatchV1Api()
core_v1 = client.CoreV1Api()
api_response = batch_v1.read_namespaced_job_status(
name,
namespace,
pretty="True"
)
log.debug(api_response)
#for condition in api_response.status.conditions:
# log.info(condition.type)
retries_count = retries_count + 1
if retries_count > retries:
log.error("Number of retries exceeded")
completed = True
if api_response.status.conditions:
for condition in api_response.status.conditions:
if condition.type == "Failed":
completed = True
if api_response.status.completion_time:
completed = True
if show_log:
log.debug("Searching for pod associated with job")
schedule_start_time = time.time()
schedule_timeout = 600
while True:
try:
pod_list = core_v1.list_namespaced_pod(
namespace,
label_selector="job-name==" + name
)
first_item = pod_list.items[0]
pod_name = first_item.metadata.name
break
except IndexError as IndexEx:
log.warning("Still Waiting for Pod to be Scheduled")
time.sleep(60)
if schedule_timeout and time.time() - schedule_start_time > schedule_timeout: # pragma: no cover
raise TimeoutError
log.info("Fetching logs from pod: {0}".format(pod_name))
# time.sleep(15)
log.info("========================== job log start ==========================")
start_time = time.time()
timeout = 300
log.debug(container)
while True:
try:
if container:
core_v1.read_namespaced_pod_log(name=pod_name,
namespace=namespace, container=container)
else:
core_v1.read_namespaced_pod_log(name=pod_name,
namespace=namespace)
break
except ApiException as ex:
log.warning("Pod is not ready, status: {}".format(ex.status))
if ex.status == 200:
break
else:
log.info("waiting for log")
time.sleep(15)
if timeout and time.time() - start_time > timeout: # pragma: no cover
raise TimeoutError
w = watch.Watch()
for line in w.stream(core_v1.read_namespaced_pod_log,
name=pod_name,
container=container,
namespace=namespace):
print(line)
log.info("=========================== job log end ===========================")
if completed:
break
log.info("Waiting for job completion")
show_log = False
time.sleep(sleep)
if api_response.status.succeeded:
log.info("Job succeeded")
sys.exit(0)
else:
log.info("Job failed")
sys.exit(1)
except ApiException as e:
log.error("Exception waiting for job: %s\n" % e)
sys.exit(1)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
common.connect()
data = {}
data["api_version"] = os.environ.get('RD_CONFIG_API_VERSION')
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
data["container_name"] = os.environ.get('RD_CONFIG_CONTAINER_NAME')
data["container_image"] = os.environ.get('RD_CONFIG_CONTAINER_IMAGE')
data["image_pull_policy"] = os.environ.get('RD_CONFIG_IMAGE_PULL_POLICY')
if os.environ.get('RD_CONFIG_PARALLELISM'):
data["parallelism"] = os.environ.get('RD_CONFIG_PARALLELISM')
if os.environ.get('RD_CONFIG_LABELS'):
data["labels"] = os.environ.get('RD_CONFIG_LABELS')
if os.environ.get('RD_CONFIG_ANNOTATIONS'):
data["annotations"] = os.environ.get('RD_CONFIG_ANNOTATIONS')
if os.environ.get('RD_CONFIG_SELECTORS'):
data["selectors"] = os.environ.get('RD_CONFIG_SELECTORS')
if os.environ.get('RD_CONFIG_CONTAINER_COMMAND'):
cmd = os.environ.get('RD_CONFIG_CONTAINER_COMMAND')
data["container_command"] = cmd
if os.environ.get('RD_CONFIG_CONTAINER_ARGS'):
data["container_args"] = os.environ.get('RD_CONFIG_CONTAINER_ARGS')
if os.environ.get('RD_CONFIG_RESOURCES_REQUESTS'):
req = os.environ.get('RD_CONFIG_RESOURCES_REQUESTS')
data["resources_requests"] = req
if os.environ.get('RD_CONFIG_VOLUME_MOUNTS'):
data["volume_mounts"] = os.environ.get('RD_CONFIG_VOLUME_MOUNTS')
if os.environ.get('RD_CONFIG_VOLUMES'):
data["volumes"] = os.environ.get('RD_CONFIG_VOLUMES')
if os.environ.get('RD_CONFIG_JOB_RESTART_POLICY'):
rpolicy = os.environ.get('RD_CONFIG_JOB_RESTART_POLICY')
data["job_restart_policy"] = rpolicy
if os.environ.get('RD_CONFIG_COMPLETIONS'):
data["completions"] = os.environ.get('RD_CONFIG_COMPLETIONS')
if os.environ.get('RD_CONFIG_ACTIVE_DEADLINE_SECONDS'):
active_ds = os.environ.get('RD_CONFIG_ACTIVE_DEADLINE_SECONDS')
data["active_deadline_seconds"] = active_ds
if os.environ.get('RD_CONFIG_BACKOFF_LIMIT'):
backoff_limit = os.environ.get('RD_CONFIG_BACKOFF_LIMIT')
data["backoff_limit"] = backoff_limit
if os.environ.get('RD_CONFIG_ENVIRONMENTS'):
data["environments"] = os.environ.get('RD_CONFIG_ENVIRONMENTS')
if os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS'):
esecret = os.environ.get('RD_CONFIG_ENVIRONMENTS_SECRETS')
data["environments_secrets"] = esecret
log.debug("Creating job")
log.debug(data)
job = create_job_object(data)
log.debug("new job: ")
log.debug(job)
try:
k8s_client = client.BatchV1Api()
api_response = k8s_client.create_namespaced_job(
body=job, namespace=data["namespace"])
print(common.parseJson(api_response.status))
except ApiException as e:
log.error("Exception creating job: %s\n" % e)
sys.exit(1)
def main():
# parse options
(options, args) = parse_options()
if os.isatty(sys.stdin.fileno()):
raise RuntimeError('Need configuration in stdin.')
config = common.read_config(sys.stdin)
conn = common.connect(config.s3)
bucket = None
try:
# setup
real_stdout = sys.stdout
sys.stdout = sys.stderr
# verify all required config items are present
if 'readwrite' not in config:
raise RuntimeError('readwrite section not found in config')
for item in ['readers', 'writers', 'duration', 'files', 'bucket']:
if item not in config.readwrite:
raise RuntimeError("Missing readwrite config item: {item}".format(item=item))
for item in ['num', 'size', 'stddev']:
if item not in config.readwrite.files:
raise RuntimeError("Missing readwrite config item: files.{item}".format(item=item))
seeds = dict(config.readwrite.get('random_seed', {}))
seeds.setdefault('main', random.randrange(2**32))
rand = random.Random(seeds['main'])
for name in ['names', 'contents', 'writer', 'reader']:
seeds.setdefault(name, rand.randrange(2**32))
print 'Using random seeds: {seeds}'.format(seeds=seeds)
# setup bucket and other objects
bucket_name = common.choose_bucket_prefix(config.readwrite.bucket, max_len=30)
bucket = conn.create_bucket(bucket_name)
print "Created bucket: {name}".format(name=bucket.name)
# check flag for deterministic file name creation
if not config.readwrite.get('deterministic_file_names'):
print 'Creating random file names'
file_names = realistic.names(
mean=15,
stddev=4,
seed=seeds['names'],
)
file_names = itertools.islice(file_names, config.readwrite.files.num)
file_names = list(file_names)
else:
print 'Creating file names that are deterministic'
file_names = []
for x in xrange(config.readwrite.files.num):
file_names.append('test_file_{num}'.format(num=x))
files = realistic.files2(
mean=1024 * config.readwrite.files.size,
stddev=1024 * config.readwrite.files.stddev,
seed=seeds['contents'],
)
q = gevent.queue.Queue()
# warmup - get initial set of files uploaded if there are any writers specified
if config.readwrite.writers > 0:
print "Uploading initial set of {num} files".format(num=config.readwrite.files.num)
warmup_pool = gevent.pool.Pool(size=100)
for file_name in file_names:
fp = next(files)
warmup_pool.spawn_link_exception(
write_file,
bucket=bucket,
file_name=file_name,
fp=fp,
)
warmup_pool.join()
# main work
print "Starting main worker loop."
print "Using file size: {size} +- {stddev}".format(size=config.readwrite.files.size, stddev=config.readwrite.files.stddev)
print "Spawning {w} writers and {r} readers...".format(w=config.readwrite.writers, r=config.readwrite.readers)
group = gevent.pool.Group()
rand_writer = random.Random(seeds['writer'])
# Don't create random files if deterministic_files_names is set and true
if not config.readwrite.get('deterministic_file_names'):
for x in xrange(config.readwrite.writers):
this_rand = random.Random(rand_writer.randrange(2**32))
group.spawn_link_exception(
writer,
bucket=bucket,
worker_id=x,
file_names=file_names,
files=files,
queue=q,
rand=this_rand,
)
# Since the loop generating readers already uses config.readwrite.readers
# and the file names are already generated (randomly or deterministically),
# this loop needs no additional qualifiers. If zero readers are specified,
# it will behave as expected (no data is read)
rand_reader = random.Random(seeds['reader'])
for x in xrange(config.readwrite.readers):
this_rand = random.Random(rand_reader.randrange(2**32))
group.spawn_link_exception(
reader,
bucket=bucket,
worker_id=x,
file_names=file_names,
queue=q,
rand=this_rand,
)
def stop():
group.kill(block=True)
q.put(StopIteration)
gevent.spawn_later(config.readwrite.duration, stop)
# wait for all the tests to finish
group.join()
print 'post-join, queue size {size}'.format(size=q.qsize())
if q.qsize() > 0:
for temp_dict in q:
if 'error' in temp_dict:
raise Exception('exception:\n\t{msg}\n\t{trace}'.format(
msg=temp_dict['error']['msg'],
trace=temp_dict['error']['traceback'])
)
else:
yaml.safe_dump(temp_dict, stream=real_stdout)
finally:
# cleanup
if options.cleanup:
if bucket is not None:
common.nuke_bucket(bucket)
def main():
common.connect()
api = core_v1_api.CoreV1Api()
namespace = os.environ.get('RD_CONFIG_NAMESPACE')
name = os.environ.get('RD_CONFIG_NAME')
log.debug("--------------------------")
log.debug("Pod Name: %s" % name)
log.debug("Namespace: %s " % namespace)
log.debug("--------------------------")
delete_on_fail = False
if os.environ.get('RD_CONFIG_DELETEONFAIL') == 'true':
delete_on_fail = True
resp = None
try:
resp = api.read_namespaced_pod(name=name, namespace=namespace)
except ApiException as e:
if e.status != 404:
log.error("Unknown error: %s" % e)
exit(1)
if not resp:
log.error("Pod %s does not exits." % name)
exit(1)
core_v1 = client.CoreV1Api()
response = core_v1.read_namespaced_pod_status(name=name,
namespace=namespace,
pretty="True")
if response.spec.containers:
container = response.spec.containers[0].name
else:
log.error("Container not found")
exit(1)
script = os.environ.get('RD_CONFIG_SCRIPT')
invocation = "/bin/bash"
if 'RD_CONFIG_INVOCATION' in os.environ:
invocation = os.environ.get('RD_CONFIG_INVOCATION')
destination_path = "/tmp"
if 'RD_NODE_FILE_COPY_DESTINATION_DIR' in os.environ:
destination_path = os.environ.get('RD_NODE_FILE_COPY_DESTINATION_DIR')
temp = tempfile.NamedTemporaryFile()
destination_file_name = os.path.basename(temp.name)
full_path = destination_path + "/" + destination_file_name
try:
temp.write(script)
temp.seek(0)
log.debug("coping script from %s to %s" % (temp.name, full_path))
common.copy_file(name=name,
namespace=namespace,
container=container,
source_file=temp.name,
destination_path=destination_path,
destination_file_name=destination_file_name)
finally:
temp.close()
permissions_command = ["chmod", "+x", full_path]
log.debug("setting permissions %s" % permissions_command)
resp = common.run_command(name=name,
namespace=namespace,
container=container,
command=permissions_command)
if resp.peek_stdout():
print(resp.read_stdout())
if resp.peek_stderr():
print(resp.read_stderr())
sys.exit(1)
# calling exec and wait for response.
exec_command = invocation.split(" ")
exec_command.append(full_path)
if 'RD_CONFIG_ARGUMENTS' in os.environ:
arguments = os.environ.get('RD_CONFIG_ARGUMENTS')
exec_command.append(arguments)
log.debug("running script %s" % exec_command)
resp, error = common.run_interactive_command(name=name,
namespace=namespace,
container=container,
command=exec_command)
if error:
log.error("error running script")
if delete_on_fail:
log.info("removing POD on fail")
data = {}
data["name"] = name
data["namespace"] = namespace
common.delete_pod(api, data)
log.info("POD deleted")
sys.exit(1)
rm_command = ["rm", full_path]
log.debug("removing file %s" % rm_command)
resp = common.run_command(name=name,
namespace=namespace,
container=container,
command=rm_command)
if resp.peek_stdout():
log.debug(resp.read_stdout())
if resp.peek_stderr():
log.debug(resp.read_stderr())
sys.exit(1)
def __init__(self, astergui):
"""
Create dialog.
Arguments:
astergui (AsterGui): Parent AsterGui instance.
"""
# pragma pylint: disable=too-many-statements
Dialog.__init__(self, astergui.mainWindow())
self.setObjectName("Preferences")
self.astergui = astergui
self.widgets = {}
self.changes = []
self.setWindowTitle(translate("PrefDlg", "Preferences"))
items = []
values = []
icons = []
def _add_item(_text, _value=None, _icon=None, _clear=False):
if _clear:
items[:] = []
values[:] = []
icons[:] = []
items.append(_text)
if _value is not None:
values.append(_value)
if _icon is not None:
icons.append(_icon)
# 'General' tab
title = translate("PrefDlg", "General")
tab = self.addTab(title)
tab.setObjectName("Preferences_General")
# Language
title = translate("PrefDlg", "Language")
_add_item("English", "en", "as_lang_en.png", _clear=True)
_add_item("Français", "fr", "as_lang_fr.png")
self._addSelectorItem(tab, title, "language", items, icons, values)
self.widgets["language"].need_restart = True
# Add spacing
self._addSpacing(tab, 10)
# code_aster version
title = translate("PrefDlg", "Version of code_aster")
_add_item(translate("PrefDlg", "Use default"), "default", _clear=True)
_add_item(translate("PrefDlg", "Ask"), "ask")
self._addSelectorItem(tab, title, "code_aster_version", items, icons,
values)
# Add spacing
self._addSpacing(tab, 10)
# Toolbar buttons style
title = translate("PrefDlg", "Toolbar button style")
_add_item(translate("PrefDlg", "Only display icon"),
"icon_only",
_clear=True)
_add_item(translate("PrefDlg", "Only display text"), "text_only")
_add_item(translate("PrefDlg", "Text appears beside icon"),
"text_beside_icon")
_add_item(translate("PrefDlg", "Text appears under icon"),
"text_under_icon")
_add_item(translate("PrefDlg", "Follow style"), "follow_style")
self._addSelectorItem(tab, title, "toolbar_button_style", items, icons,
values)
# Workspace tabs position
title = translate("PrefDlg", "Workspace tab pages position")
_add_item(translate("PrefDlg", "North"), "north", _clear=True)
_add_item(translate("PrefDlg", "South"), "south")
_add_item(translate("PrefDlg", "West"), "west")
_add_item(translate("PrefDlg", "East"), "east")
self._addSelectorItem(tab, title, "workspace_tab_position", items,
icons, values)
# Add spacing
self._addSpacing(tab, 10)
# Strict import mode
title = translate("PrefDlg", "Strict import mode")
self._addSwitchItem(tab, title, "strict_import_mode")
title = translate("PrefDlg",
"Limit of number of lines for graphical mode")
self._addIntegerItem(tab, title, "nblines_limit", 1, 100000)
# Add spacing
self._addSpacing(tab, 10)
# Switch on/off Undo/Redo feature
title = translate("PrefDlg", "Disable Undo/Redo feature")
self._addSwitchItem(tab, title, "disable_undo_redo")
self._addSpacing(tab, 10)
# Use CodeAster native naming
# (switch off business-oriented translation)
title = translate("PrefDlg", "Use business-oriented translations")
self._addSwitchItem(tab, title, "use_business_translations")
if behavior().forced_native_names:
force = behavior().force_native_names
self.widgets["use_business_translations"].setChecked(not force)
self.widgets["use_business_translations"].setDisabled(True)
self.widgets["use_business_translations"].ignore = True
self._addSpacing(tab, 10)
# Documentation url
title = translate("PrefDlg", "Documentation website")
self._addStringItem(tab, title, "doc_base_url")
# Add stretch
self._addSpacing(tab, 0, True)
# --- end of 'General' tab
# 'Interface' tab
title = translate("PrefDlg", "Interface")
tab = self.addTab(title)
tab.setObjectName("Preferences_Interface")
# *** Data Settings
# Show catalogue name in Data Settings panel
title = translate("PrefDlg",
"Show catalogue name in Data Settings panel")
self._addSwitchItem(tab, title, "show_catalogue_name")
# Show comments in Data Settings panel
title = translate("PrefDlg", "Show comments in Data Settings panel")
self._addSwitchItem(tab, title, "show_comments")
# Enable auto-hide feature for search tool in Data Settings panel
title = translate("PrefDlg", "Auto-hide search panel")
self._addSwitchItem(tab, title, "auto_hide_search")
# Add spacing
self._addSpacing(tab, 10)
# *** Data Files
# Sort stages in Data Files panel
title = translate("PrefDlg", "Sort stages in Data Files panel")
self._addSwitchItem(tab, title, "sort_stages")
# Show related concepts in Data Files panel
title = translate("PrefDlg",
"Show related concepts in Data Files panel")
self._addSwitchItem(tab, title, "show_related_concepts")
# Join similar files in Data Files panel
title = translate("PrefDlg",
"Join similar data files in Data Files panel")
self._addSwitchItem(tab, title, "join_similar_files")
# Add spacing
self._addSpacing(tab, 10)
# *** Operations
# Auto-edit command
title = translate("PrefDlg", "Automatically activate command edition")
self._addSwitchItem(tab, title, "auto_edit")
# Add spacing
self._addSpacing(tab, 10)
# *** Windows
# Show read-only banner
title = translate("PrefDlg", "Show read-only banner")
self._addSwitchItem(tab, title, "show_readonly_banner")
# Add spacing
self._addSpacing(tab, 10)
# *** Parameter panel
# Content label mode
title = translate("PrefDlg", "Parameter content display mode")
_add_item(translate("PrefDlg", "None"), "none", _clear=True)
_add_item(translate("PrefDlg", "Parameters"), "parameters")
_add_item(translate("PrefDlg", "Keywords"), "keywords")
_add_item(translate("PrefDlg", "Values"), "values")
self._addSelectorItem(tab, title, "content_mode", items, icons, values)
# Show tooltip for 'into' items
title = translate("PrefDlg", "Show identifier for selector items")
self._addSwitchItem(tab, title, "show_selector_value")
# Sort selector items in Parameters panel
title = translate("PrefDlg", "Sort selector items")
self._addSwitchItem(tab, title, "sort_selector_values")
# Show catalogue name for command selector items
title = translate("PrefDlg",
"Show catalogue name in command selector items")
self._addSwitchItem(tab, title, "show_catalogue_name_in_selectors")
# External list
title = translate("PrefDlg", "Edit list-like keywords in sub-panel")
self._addSwitchItem(tab, title, "external_list")
# Add spacing
self._addSpacing(tab, 10)
# *** Other features
# Allow delete case used by other case(s)
title = translate("PrefDlg",
"Allow deleting cases used by other case(s)")
self._addSwitchItem(tab, title, "allow_delete_cases")
# Add stretch
self._addSpacing(tab, 0, True)
# --- end of 'Interface' tab
# 'Editor' tab
title = translate("PrefDlg", "Editor")
tab = self.addTab(title)
tab.setObjectName("Preferences_Editor")
# - External editor
title = translate("PrefDlg", "External editor")
self._addFileItem(tab, title, "external_editor", self._browseEditor)
# Add spacing
self._addSpacing(tab, 10)
# Use external editor for text stage
title = translate("PrefDlg",
"Use external editor for text stage edition")
self._addSwitchItem(tab, title, "use_external_editor_stage")
# Use external editor for data files edition
title = translate("PrefDlg",
"Use external editor for data files edition")
self._addSwitchItem(tab, title, "use_external_editor_data_file")
# Use external editor for message files viewing
title = translate("PrefDlg",
"Use external editor for message files viewing")
self._addSwitchItem(tab, title, "use_external_editor_msg_file")
# Add spacing
self._addSpacing(tab, 10)
# Warn for file's size limit
title = translate("PrefDlg", "Warn when viewing file larger than")
self._addIntegerItem(tab, title, "file_size_limit", 1, 100000, " KB")
try:
import PyEditorPy
if hasattr(PyEditorPy, "PyEditor_Widget"):
# Add spacing
self._addSpacing(tab, 10)
# Python editor group
title = translate("PrefDlg", "Python editor")
grp = self._addGroupBox(tab, title, obj_name="python_editor")
# - Font
title = translate("PrefDlg", "Font")
self._addFontItem(grp, title, "PyEditor/font")
# - Enable current line highlight
title = translate("PrefDlg", "Enable current line highlight")
self._addSwitchItem(grp, title,
"PyEditor/highlightcurrentline")
# - Enable text wrapping
title = translate("PrefDlg", "Enable text wrapping")
self._addSwitchItem(grp, title, "PyEditor/textwrapping")
# - Center cursor on scroll
title = translate("PrefDlg", "Center cursor on scroll")
self._addSwitchItem(grp, title,
"PyEditor/centercursoronscroll")
# - Display line numbers area
title = translate("PrefDlg", "Display line numbers area")
self._addSwitchItem(grp, title, "PyEditor/linenumberarea")
# Add spacing
self._addSpacing(grp, 10)
# - Completion mode
title = translate("PrefDlg", "Completion mode")
_add_item(translate("PrefDlg", "None"), "none", _clear=True)
_add_item(translate("PrefDlg", "Auto"), "auto")
_add_item(translate("PrefDlg", "Manual"), "manual")
_add_item(translate("PrefDlg", "Always"), "always")
self._addSelectorItem(grp, title, "PyEditor/completionpolicy",
items, icons, values)
# Add spacing
self._addSpacing(grp, 10)
# - Display tab delimiters
title = translate("PrefDlg", "Display tab delimiters")
self._addSwitchItem(grp, title, "PyEditor/tabspacevisible")
# - Tab size
title = "\t" + translate("PrefDlg", "Tab size")
self._addIntegerItem(grp, title, "PyEditor/tabsize", 1, 99)
# Add spacing
self._addSpacing(grp, 10)
# - Display vertical edge
title = translate("PrefDlg", "Display vertical edge")
self._addSwitchItem(grp, title, "PyEditor/verticaledge")
connect(self.widgets["PyEditor/verticaledge"].stateChanged,
self._updateState)
# - Number of columns
title = "\t" + translate("PrefDlg", "Number of columns")
self._addIntegerItem(grp, title, "PyEditor/numbercolumns", 1,
200)
except ImportError:
pass
# Add stretch
self._addSpacing(tab, 0, True)
# --- end of 'Editor' tab
# 'Confirmations' tab
title = translate("PrefDlg", "Confirmations")
tab = self.addTab(title)
tab.setObjectName("Preferences_Confirmations")
# - Delete object
title = translate("PrefDlg", "Delete object")
self._addSwitchItem(tab, title, "msgbox_delete")
# - Undefined files
title = translate("PrefDlg", "Undefined files")
self._addSwitchItem(tab, title, "msgbox_undefined_files")
# - Break operation
title = translate("PrefDlg", "Break current operation")
self._addSwitchItem(tab, title, "msgbox_break")
# - Delete case used by other case(s)
title = translate("PrefDlg", "Delete case used by other case(s)")
self._addSwitchItem(tab, title, "msgbox_delete_case")
# - Delete child stages
title = translate("PrefDlg", "Delete child stages")
self._addSwitchItem(tab, title, "msgbox_delete_stages")
# - Convert invalid graphical stage
title = translate("PrefDlg", "Convert invalid graphical stage")
self._addSwitchItem(tab, title, "msgbox_convert_invalid_graphic_stage")
# - Close the parameter panel
title = translate("PrefDlg",
"Close parameter panel with modifications")
self._addSwitchItem(tab, title, "msgbox_parampanel_close")
# - Abort the parameter panel
title = translate("PrefDlg", "Abort command edition")
self._addSwitchItem(tab, title, "msgbox_parampanel_abort")
# Add stretch
self._addSpacing(tab, 0, True)
# --- end of 'Confirmations' tab
# 'Catalogs' tab
title = translate("PrefDlg", "Catalogs")
tab = self.addTab(title)
tab.setObjectName("Preferences_Catalogs")
# User's catalogs
title = translate("PrefDlg", "User's catalogs")
grp = self._addGroupBox(tab, title, obj_name="user_catalogs")
self._addDirItem(grp, "user_catalogs")
# --- end of 'Catalogs' tab
title = translate("PrefDlg", "Defaults")
def_btn = self.addButton(title)
def_btn.setObjectName("Dialog_defaults")
connect(def_btn.clicked, self._fromResources)
self.okButton().setObjectName("Dialog_ok")
self.cancelButton().setObjectName("Dialog_cancel")
self._fromResources(False)
self.tabWidget().setCurrentIndex(PrefDlg.last_tab)
def parse_weather(lat, lon):
url = generate_url(lat, lon)
place = connect(url)
woeid = place['query']['results']['Result']['woeid']
return connect(get_weather_url(woeid))
#!/usr/bin/python
import unittest
import socket
import sys
from common import connect, disconnect, sendCmd
print "infinite stream..."
try:
pass
sock = connect()
while 1:
sock.send("x")
sock.close()
except:
print "got exception!"
print sys.exc_info()
print "login w/2KB username..."
try:
sock = connect()
cmd = "LOGIN "
for i in range(1, 2048):
cmd += "x"
cmd += "\r\n"
sendCmd(sock, cmd)
data = sock.recv(1024)
print "data = %s" % data
sendCmd(sock, "JOIN #foo")
data = sock.recv(1024)
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["yaml"] = os.environ.get('RD_CONFIG_YAML')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "Deployment":
dep = yaml.safe_load(data["yaml"])
api_instance = client.AppsV1Api()
resp = api_instance.create_namespaced_deployment(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "ConfigMap":
api_instance = client.CoreV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.create_namespaced_config_map(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "StatefulSet":
dep = yaml.safe_load(data["yaml"])
k8s_beta = client.AppsV1Api()
resp = k8s_beta.create_namespaced_stateful_set(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Service":
api_instance = client.CoreV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.create_namespaced_service(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Ingress":
dep = yaml.safe_load(data["yaml"])
k8s_beta = client.ExtensionsV1beta1Api()
resp = k8s_beta.create_namespaced_ingress(
body=dep, namespace=data["namespace"], pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Job":
api_instance = client.BatchV1Api()
dep = yaml.safe_load(data["yaml"])
resp = api_instance.create_namespaced_job(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "StorageClass":
dep = yaml.safe_load(data["yaml"])
api_instance = client.StorageV1Api()
resp = api_instance.create_storage_class(body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "PersistentVolumeClaim":
dep = yaml.safe_load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_namespaced_persistent_volume_claim(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "Secret":
dep = yaml.safe_load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_namespaced_secret(
namespace=data["namespace"], body=dep, pretty="true")
print(common.parseJson(resp.metadata))
if data["type"] == "PersistentVolume":
dep = yaml.safe_load(data["yaml"])
api_instance = client.CoreV1Api()
resp = api_instance.create_persistent_volume(body=dep,
pretty="true")
print(common.parseJson(resp.status))
if data["type"] == "BuildConfig":
dep = yaml.safe_load(data["yaml"])
k8s_client = config.new_client_from_config()
openshift_client = DynamicClient(k8s_client)
v1_bc = openshift_client.resources.get(
api_version='build.openshift.io/v1', kind='BuildConfig')
resp = v1_bc.create(body=dep, namespace=data["namespace"])
print(common.parseJson(resp.metadata))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
def main():
common.connect()
api = core_v1_api.CoreV1Api()
name = os.environ.get('RD_NODE_DEFAULT_NAME')
namespace = os.environ.get('RD_NODE_DEFAULT_NAMESPACE')
container = os.environ.get('RD_NODE_DEFAULT_CONTAINER_NAME')
log.debug("--------------------------")
log.debug("Pod Name: %s" % name)
log.debug("Namespace: %s " % namespace)
log.debug("Container: %s " % container)
log.debug("--------------------------")
resp = None
try:
resp = api.read_namespaced_pod(name=name, namespace=namespace)
except ApiException as e:
if e.status != 404:
print("Unknown error: %s" % e)
exit(1)
if not resp:
print("Pod %s does not exits." % name)
exit(1)
source_file = os.environ.get('RD_FILE_COPY_FILE')
destination_file = os.environ.get('RD_FILE_COPY_DESTINATION')
#force print destination to avoid error with node-executor
print destination_file
log.debug("Copying file from %s to %s" % (source_file, destination_file))
destination_path = os.path.dirname(destination_file)
destination_file_name = os.path.basename(destination_file)
# Copying file client -> pod
exec_command = ['tar', 'xvf', '-', '-C', '/']
resp = stream(api.connect_get_namespaced_pod_exec,
name,
'default',
command=exec_command,
container=container,
stderr=True,
stdin=True,
stdout=True,
tty=False,
_preload_content=False)
with TemporaryFile() as tar_buffer:
with tarfile.open(fileobj=tar_buffer, mode='w') as tar:
tar.add(name=source_file,
arcname=destination_path + "/" + destination_file_name)
tar_buffer.seek(0)
commands = []
commands.append(tar_buffer.read())
while resp.is_open():
resp.update(timeout=1)
if resp.peek_stdout():
print("STDOUT: %s" % resp.read_stdout())
if resp.peek_stderr():
print("STDERR: %s" % resp.read_stderr())
if commands:
c = commands.pop(0)
# print("Running command... %s\n" % c)
resp.write_stdin(c)
else:
break
resp.close()
def main():
if os.environ.get('RD_CONFIG_DEBUG') == 'true':
log.setLevel(logging.DEBUG)
log.debug("Log level configured for DEBUG")
data = {}
data["name"] = os.environ.get('RD_CONFIG_NAME')
data["type"] = os.environ.get('RD_CONFIG_TYPE')
data["namespace"] = os.environ.get('RD_CONFIG_NAMESPACE')
common.connect()
try:
if data["type"] == "Deployment":
apps_v1 = client.AppsV1Api()
resp = apps_v1.delete_namespaced_deployment(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "ConfigMap":
apps_v1 = client.CoreV1Api()
resp = apps_v1.delete_namespaced_config_map(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "StatefulSet":
apps_v1 = client.AppsV1Api()
resp = apps_v1.delete_namespaced_stateful_set(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "Service":
apps_v1 = client.CoreV1Api()
resp = apps_v1.delete_namespaced_service(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(propagation_policy='Foreground',
grace_period_seconds=5),
pretty="true")
if data["type"] == "Ingress":
apps_v1 = client.ExtensionsV1beta1Api()
body = client.V1DeleteOptions()
resp = apps_v1.delete_namespaced_ingress(
name=data["name"],
namespace=data["namespace"],
body=body,
pretty="true")
if data["type"] == "Job":
api_instance = client.BatchV1Api()
resp = api_instance.delete_namespaced_job(
name=data["name"],
namespace=data["namespace"],
body=client.V1DeleteOptions(api_version='v1',
kind="DeleteOptions",
propagation_policy="Background"),
pretty="true")
if data["type"] == "StorageClass":
api_instance = client.StorageV1Api()
resp = api_instance.delete_storage_class(
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
if data["type"] == "PersistentVolumeClaim":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_persistent_volume_claim(
namespace=data["namespace"],
body=client.V1DeleteOptions(),
name=data["name"],
pretty="true")
if data["type"] == "Secret":
api_instance = client.CoreV1Api()
resp = api_instance.delete_namespaced_secret(
namespace=data["namespace"],
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
if data["type"] == "PersistentVolume":
api_instance = client.CoreV1Api()
resp = api_instance.delete_persistent_volume(
name=data["name"],
body=client.V1DeleteOptions(),
pretty="true")
print(common.parseJson(resp))
except ApiException as e:
log.error("Exception error creating: %s\n" % e)
sys.exit(1)
