def process_state(self):
try:
# Currently state_update_dvs is not implemented.
host_states = {
'absent': {
'present': self.state_remove_host,
'absent': self.state_exit_unchanged,
},
'present': {
'present': self.state_exit_unchanged,
'absent': self.state_add_host,
}
}
import q
q('pre host_states')
host_states[self.state][self.check_host_state()]()
import q
q('post host_states')
except vmodl.RuntimeFault as runtime_fault:
import q
q(runtime_fault)
self.module.fail_json(msg=runtime_fault.msg)
except vmodl.MethodFault as method_fault:
import q
q(method_fault)
self.module.fail_json(msg=method_fault.msg)
except Exception as e:
import q
q(e)
self.module.fail_json(msg=str(e))
def _handle_encryption(self, en_configs, filters, config_decrypt=None):
filtered_configs_index = []
filtered_configs = []
configs = to_bytes(en_configs, errors='surrogate_or_strict')
conf_lines = configs.split('\n')
r = re.compile(filters)
for index, line in enumerate(conf_lines):
match_ob = r.match(line)
if match_ob:
filtered_configs_index.append(index)
filtered_configs.append(line)
for index in sorted(filtered_configs_index, reverse=True):
del (conf_lines[index])
if config_decrypt:
key = config_decrypt.get("key")
q(key)
if key is None:
raise ValueError(
"Decrypt key is reqiured for rollback config to device")
decryption_key = self._get_key_from_password(key)
clear = self._decrypt_configs(filtered_configs, decryption_key,
filters)
n = len(clear)
for index in sorted(filtered_configs_index, reverse=True):
conf_lines[index] = clear[n - 1]
n = n - 1
filtered_config = '\n'.join(conf_lines)
return filtered_config
def _create_backup(self, dest, backup_path, backup_filename, r_id):
rollback_db_dest = os.path.join(backup_path, ROLLBACK_DB_FILENAME)
if os.path.exists(rollback_db_dest):
with open(rollback_db_dest, 'r') as f:
current_rollback_seq = f.read()
if current_rollback_seq:
current_rollback_seq = to_text(
current_rollback_seq, errors='surrogate_or_strict')
current_rollback_seq = int(current_rollback_seq)
else:
current_rollback_seq = 0
else:
current_rollback_seq = 0
new_rollback_seq = current_rollback_seq + 1
backup_dest = os.path.join(backup_path, backup_filename)
q(r_id, new_rollback_seq, r_id % new_rollback_seq)
rollback_id = r_id % new_rollback_seq
q(rollback_id)
backupdest = '%s.%s' % (backup_dest, rollback_id)
shutil.copy2(dest, backupdest)
# Increment rollback seq number
with open(rollback_db_dest, 'w') as f:
f.write(str(new_rollback_seq))
return backupdest, new_rollback_seq
def test_datetime(self):
self.assertEqual(K(date(2000, 1, 1)),
q("2000.01.01"))
self.assertEqual(K(time(0)), q("00:00t"))
self.assertEqual(K(datetime(2000, 1, 1)),
q("2000.01.01T00:00"))
self.assertEqual(K(timedelta(1)), q("1D"))
def coding_challenge_specific_io(challenge_function):
with open('input') as in_file:
parsed_data = _parse_data(_strip_data(in_file))
completed_data = [challenge_function(data) for data in parsed_data]
q(completed_data)
with open('output', 'w') as out_file:
_write_output(completed_data, out_file)
def set_config(self, existing_acls_facts):
""" Collect the configuration from the args passed to the module,
collect the current configuration (as a dict from facts)
:rtype: A list
:returns: the commands necessary to migrate the current configuration
to the desired configuration
"""
config = self._module.params.get('config')
want = []
onbox_configs = []
for h in existing_acls_facts:
have_configs = add_commands(h)
onbox_configs.append(have_configs)
if config:
for w in config:
want.append(remove_empties(w))
have = existing_acls_facts
resp = self.set_state(want, have)
if self.state == 'deleted':
to_config = resp
else:
to_config = self.compare_configs(onbox_configs, to_list(resp))
q(to_config)
return to_config
def _json_to_xml(self, json_obj, root):
json_obj_type = type(json_obj)
if json_obj_type is list:
for sub_elem in json_obj:
self._json_to_xml(sub_elem, root)
# if json_obj_type is dict:
if (json_obj_type is OrderedDict) or (json_obj_type is dict):
for tag_name in json_obj:
sub_obj = json_obj[tag_name]
if OPENCONFIG_NS_MAP.has_key(tag_name):
container_ele = etree.SubElement(
root, tag_name, nsmap=OPENCONFIG_NS_MAP[tag_name])
else:
container_ele = etree.SubElement(root, tag_name)
if (type(sub_obj) is int) or (type(sub_obj) is str) or \
(type(sub_obj) is unicode):
ns_tag = container_ele.nsmap
for keys in ns_tag:
if keys is not None:
prefix = keys
q(ns_tag)
else:
prefix = None
if prefix is not None:
container_ele.text = prefix + ":" + str(sub_obj)
else:
container_ele.text = str(sub_obj)
else:
self._json_to_xml(sub_obj, container_ele)
def main():
'''
Ansible module to preprocess yaml
'''
module = AnsibleModule(
argument_spec=dict(process=dict(required=False, default='true')),
supports_check_mode=False)
try:
for filename in os.listdir(host_vars_dir):
new_contents = recurse(os.path.join(host_vars_dir, filename))
new_file = ''
for chunk in reversed(new_contents):
new_file += ('\n').join(chunk)
new_file += ('\n')
new_file += ('\n')
result = yaml.load(new_file)
with open(os.path.join('host_vars', filename), 'w') as f:
yaml.dump(result,
f,
default_flow_style=False,
Dumper=ExplicitDumper)
module.exit_json(msg='successful')
except Exception, e:
q(e)
excType = e.__class__.__name__
module.fail_json(msg='failed')
def delete(self, id):
params = dict()
params[self.matchsetid] = id
params['ChangeToken'] = get_change_token(self.client)
q(self.method_suffix)
func = getattr(self.client, 'delete_' + self.method_suffix)
return func(**params)
def _handle_ns_map(self):
try:
ns_map_src = self._task.args.get('ns_map')
except Exception as exc:
display.vvvv('No ns_map is specified')
return dict(failed=False, msg="No ns map is specified")
if ns_map_src == None:
return
working_path = self._get_working_path()
if os.path.isabs(ns_map_src) or urlsplit('ns_map_src').scheme:
ns_map_file = ns_map_src
else:
ns_map_file = self._loader.path_dwim_relative(working_path,
'templates', ns_map_src)
if not ns_map_file:
ns_map_file = self._loader.path_dwim_relative(working_path, ns_map_src)
if not os.path.exists(ns_map_file):
raise ValueError('path specified in ns_map not found')
try:
with open(ns_map_file, 'r') as f:
ns_map_data = yaml.load(f)
q(ns_map_data)
return (ns_map_data)
except IOError:
return dict(failed=True, msg='unable to load ns_map file')
def run(self, tmp=None, task_vars=None):
if task_vars is None:
task_vars = dict()
result = super(ActionModule, self).run(tmp, task_vars)
try:
self._handle_template()
except ValueError as exc:
return dict(failed=True, msg=to_text(exc))
src = self._task.args.get('src')
output_file = self._task.args.get('output')
#Optional Arguments Handling
try:
xpath_map_data = self._handle_xpath_map()
except ValueError as exc:
return dict(failed=True, msg=to_text(exc))
try:
ns_map_data = self._handle_ns_map()
except ValueError as exc:
return dict(failed=True, msg=to_text(exc))
self.facts = {}
play_context = copy.deepcopy(self._play_context)
play_context.network_os = self._get_network_os(task_vars)
load_ns_map_from_module_args(ns_map_data)
q("network_os=%s connection=%s \n" %
(play_context.network_os, play_context.connection))
base_schematrans = SchemaTransformNetconfBase()
config_xml_base = base_schematrans.openconfig_to_netconf(
src, xpath_map_data)
# Load appropriate low level config generator bases on network_os
# and connection type
if play_context.network_os == 'iosxr':
iosxr_schematrans = IosxrSchemaTransformNetconf()
config_xml_final = iosxr_schematrans.openconfig_to_netconf(
config_xml_base, xpath_map_data)
if play_context.network_os == 'junos':
junos_schematrans = JunosSchemaTransformNetconf()
config_xml_final = junos_schematrans.openconfig_to_netconf(
config_xml_base, xpath_map_data)
# If no OS specific transform is there we can return basic netconf
# conversion
config_xml_final = config_xml_base
with open(output_file, 'w') as f:
f.write(config_xml_final)
#self.ds.update(task_vars)
result['ansible_facts'] = self.facts
return result
def get_context_data(self, **kwargs):
params = self.request.GET
query = Q()
for key, value in params.items():
if value and key in vars(Car):
query &= Q(**{key: value})
q(query)
return {"cars": Car.objects.filter(query)}
def cmd(args, debug=False, output=False):
if debug:
q(" ".join(str(a) for a in args))
if output:
return check_output(args).decode("ascii")
else:
run(args)
def remove_rules(self, web_acl_id):
changed = False
result = None
acl = self.get(web_acl_id)
q(acl['Rules'])
for rule in acl['Rules']:
self.remove_rule(rule, acl)
return False, result
def list_web_acls(client, module):
changed = False
try:
web_acl = client.list_web_acls(Limit=10)
q(web_acl['WebACLs'])
return changed, web_acl['WebACLs']
except botocore.exceptions.ClientError as e:
module.fail_json(msg=str(e))
def backtrack_solution(self, problemset):
print('backtrack start ...')
import q
q('backtrack')
answerset = [x for x in problemset]
answer_chunks = sl.chunk_set(problemset)
#answer_chunks = [list(x) for x in answer_chunks]
#answer_chunks_original = [x for x in answer_chunks]
tilecount = len(answer_chunks)
tilesq = int(math.sqrt(len(answer_chunks)))
solved = False
iteration = 0
while not solved:
iteration += 1
#print('iteration: %s' % iteration)
ctuples = sl.get_choice_map(answer_chunks)
#print('unfilled: %s' % len(ctuples))
#print(ctuples)
ct = ctuples[0]
idc = ct[0][0]
idx = ct[0][1]
self.active_tile = \
sl.get_chunk_bit_location(idc, idx, val=None, chunks=None)
self.redraw()
choice = random.choice(ct[2])
answer_chunks[idc][idx] = choice
self.answerset_to_cells(sl.dechunk_set(answer_chunks))
self.redraw()
score = sl.score_bits(answer_chunks)
print('SCORE: %s' % score)
#with open('scores.log', 'a') as f:
# f.write(f'score: {score}\n')
if score == 81:
#time.sleep(10)
solved = True
break
solution = sl.dechunk_set(answer_chunks)
#import epdb; epdb.st()
'''
try:
with open('solution.json', 'w') as f:
f.write(json.dumps(solution, indent=2))
except Exception as e:
pass
'''
print('back track finished')
return solution
def check_host_state(self):
import q
q('find host')
self.host, self.cluster = self.find_host_by_cluster_datacenter()
if self.host is None:
return 'absent'
else:
return 'present'
def log_exception(exctype, value, tb):
if exctype == KeyboardInterrupt:
return
q("=======ERROR=======")
q("Type:", exctype)
q("Value:", value)
q("Traceback:", tb)
q("===================")
def delete_web_acl(client, module):
changed = False
result = None
web_acl = WebAcl(client, module)
web_acl_id = web_acl.exists()
q(web_acl_id)
if web_acl_id:
web_acl.remove_rules(web_acl_id)
(changed, result) = web_acl.delete(web_acl_id)
return changed, result
def filter_list(request):
template = loader.get_template('car_list.html')
cars = Car.objects.all()
import q
q(cars)
q(cars[0])
context = {
"title": "Cars",
"cars": cars,
}
return HttpResponse(template.render(context, request))
def _get_backup_filename(self, path, seq_backup, rollback_id_str):
if not os.path.exists(path):
raise ValueError("path : %s does not exist" % path)
match_backup_name = rollback_id_str % seq_backup
q(match_backup_name)
for files in os.listdir(path):
pos = files.find(match_backup_name)
if pos >= 0:
return files
return None
def create_web_acl(client, module):
changed = False
result = None
web_acl = WebAcl(client, module)
web_acl_id = web_acl.exists()
if web_acl_id:
(changed, result) = web_acl.find_and_update(web_acl_id)
else:
new_web_acl = web_acl.create()
q(new_web_acl)
(changed,
result) = web_acl.find_and_update(new_web_acl['WebACL']['WebACLId'])
return changed, result
def main():
import q
q('start')
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(datacenter_name=dict(required=False, type='str'),
cluster_name=dict(required=False, type='str'),
esxi_hostname=dict(required=True, type='str'),
esxi_username=dict(required=True, type='str'),
esxi_password=dict(required=True, type='str', no_log=True),
state=dict(default='present',
choices=['present', 'absent'],
type='str')))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
import q
q('init vmwarehost')
vmware_host = VMwareHost(module)
import q
q('process state')
vmware_host.process_state()
import q
q('stop')
def find_host_by_cluster_datacenter(self):
self.dc = find_datacenter_by_name(self.content, self.datacenter_name)
import q
q(self.dc)
self.cluster = find_cluster_by_name_datacenter(self.dc,
self.cluster_name)
import q
q(self.cluster)
for host in self.cluster.host:
if host.name == self.esxi_hostname:
return host, self.cluster
return None, self.cluster
def car_list(request):
template = loader.get_template('index.html')
if len(request.GET) > 0:
c = request.GET
cars = Car.objects.filter(
Q(manufacture=c.get('manufacture', ''))
& Q(model_auto=c.get('model_auto', ''))
& Q(year=c.get('year', 0))
& Q(transmission=c.get('transmission', 0))
& Q(color=c.get('color', '')))
import q
q(cars)
q(cars[0])
if len(cars) == 0:
context = {
"title": "Cars",
"message": "Ничего не найдено по запросу",
"cars": [],
}
return HttpResponse(template.render(context, request))
else:
cars = Car.objects.all()
import q
q(cars)
q(cars[0])
context = {
"title": "Cars",
"cars": cars,
}
return HttpResponse(template.render(context, request))
def find_and_update(self, id):
rule_id = self.get(id)['RuleId']
predicates = self.get(id)['Predicates']
q(predicates)
for condition in self.conditions:
func = getattr(self.client, self.list_methods[condition['type']])
list_results = func(Limit=99)
key_list = [
list_results[key] for key in list_results
if key.endswith('Sets')
][0]
this_condition = [
k for k in key_list if k['Name'] == condition['name']
][0]
condition_id = [
this_condition[key] for key in this_condition
if key.endswith('SetId')
][0]
q(condition_id)
if len(predicates) == 0 or self.action == "DELETE":
q("No existing predicates")
q(self.action)
self.update(rule_id, condition_id, condition['type'])
self.changed = True
return self.changed, self.get(id)
def delete_workout(sender, instance, **kwargs):
# update personal distance
profile = instance.belongs_to
profile.distance -= instance.distance
if profile.distance < profile.user_goal_km:
profile.user_goal = False
profile.save()
# delete image from S3
try:
default_storage.delete(instance.photo_evidence.name)
except Exception:
q("Can't delete the file {} in S3".format(
instance.photo_evidence.name))
def create_order(self, side, units):
order = oanda.create_order(config['oanda']['account_number'],
instrument=self.instrument,
units=units,
side=side,
type='market')
# order data
socket.send_string('SMA\n' + str(order))
print('\n', order)
q(order)
# market data
msg = 'SMA | Market data:\n%s' % self.resam.iloc[-1]
socket.send_string(msg)
print('\n', msg)
q(msg)
def create_condition(client, module):
changed = False
result = None
condition = Condition(conditions[module.params.get('type')], client,
module)
if condition.exists():
q("Existing condition found so just doing an update or delete if required"
)
(changed, result) = condition.find_and_update_filter()
return changed, result
else:
q("Condition not found so creating and updating")
condition.create()
(changed, result) = condition.find_and_update_filter()
return changed, "result"
def test_list(self):
self.assertEqual(K([]), q("()"))
self.assertEqual(K([1]), q("enlist 1"))
self.assertEqual(K([1, 2]), q("1 2"))
self.assertEqual(K([1, None]), q("1 0N"))
self.assertEqual(K([1.0]), q("enlist 1f"))
self.assertEqual(K([1.0, 2.0]), q("1 2f"))
self.assertEqual(K([1.0, float('nan')]), q("1 0n"))
self.assertEqual(K(['']), q("enlist`"))
self.assertEqual(K(['a', 'b']), q("`a`b"))
def process(self, request):
import q
q('a')
#try:
#response = requests.request(
#request.method,
#u"{}{}".format(self._pointed_at, request.uri),
#)
#except Exception as error:
#q(error)
q('b')
response = Response(200, "hello")
return Response(
response.code, #status_code,
response.content,
)
def test_conversion(self):
import collections
odict = getattr(collections, 'OrderedDict', None)
if odict is None:
self.skipTest("no OrderedDict in collections")
od = odict([('a', 1.0), ('b', 2.0)])
self.assertEqual(K(od), q('`a`b!1 2f'))
def get_queryset(self):
logger.debug(
f"Request to NewsList from user: {self.request.user.id} with params: {self.request.GET}"
)
logger.info("NewsList.get_queryset called")
try:
news = News.objects.select_related("region").all()
except Exception as exc:
logger.error(str(exc))
raise
if not news:
logger.warning("News list is empty")
import q
q(news)
q(news[0])
return news
def test_roundtrip(self):
import pickle
data = ['1b', '1 2 3', '"abcde"',
'(([a:""]b:0#0);`;0h)']
for d in data:
x = q(d)
s = pickle.dumps(x)
y = pickle.loads(s)
self.assertEqual(x, y)
def __init__(self, juju_state):
table = Table()
table.addHeadings([
Text('Service'),
Text('Hardware'),
Text('Hostname'),
Text('Machine'),
])
for name, service in juju_state['Services'].items():
s = ServiceWidget(name, service)
q(s)
for u in s.Units:
m = MachineWidget(juju_state['Machines'][u.Machine.get_text()[0]])
table.addColumns(u.Name.get_text()[0], [
u.Name,
m.Hardware,
m.DNSName,
u.Machine
])
super().__init__(body=table.render())
def render(self, data, media_type=None, renderer_context=None):
status_code = renderer_context["response"].status_code
import q
q(status_code, data, media_type)
if 200 <= status_code < 400:
jsend = RSuccess(data=data, code=status_code)
elif 400 <= status_code < 500:
detail = data.pop("detail", "failed")
jsend = RFail(data=data, code=status_code, message=detail)
else:
detail = data.pop("detail", "error")
jsend = RError(data=data, code=status_code, message=detail)
return super(JSendRenderer, self).render(jsend, media_type, renderer_context)
def custom_handler(exc, context):
"""
Handle exceptions that are NOT `rest_framework.exceptions.APIException`-based exceptions
"""
# Call REST framework's default exception handler first,
# to get the standard error response.
response = exception_handler(exc, context)
request = context.get('request', None)
view = context.get('view', None)
if not response:
q('CUSTOM EXCEPTION!', exc, request.data)
# Get exception info
exc_type, exc_value, exc_trace = sys.exc_info()
q(exc_type, exc_value, exc_trace)
# Customize exceptions that translate to HTTP-4XX status-codes
if isinstance(exc, core_exceptions.ObjectDoesNotExist):
msg = str(exc) # TODO! Translate this!
data = {'detail': six.text_type(msg)}
status_code = status.HTTP_404_NOT_FOUND
elif isinstance(exc, AssertionError):
if isinstance(exc.message, basestring):
data = {'detail': six.text_type(exc.message)}
else:
data = exc.message
status_code = status.HTTP_400_BAD_REQUEST
else:
q('UNHANDLED CUSTOM EXCEPTION!')
# Unhandled exception; print and then just wrap to make render properly
traceback.print_exception(exc_type, exc_value, exc_trace)
try:
msg = str(exc) # TODO! Translate this!
# http://stackoverflow.com/a/696095/1008905
raise WrappedException, (msg, exc_type, exc_value), exc_trace
except Exception, exc:
response = exception_handler(exc, context)
return response
# Add some additional information to the response-data
if view:
data['view'] = view.__class__.__name__
if context.get('kwargs', None):
data['kwargs'] = context['kwargs']
if request.data:
data['request'] = request.data
if not status_code:
status_code = exc.status_code if exc.status_code else 500
set_rollback()
return Response(data, status=status_code)
def f():
import datetime
now = datetime.datetime.now()
q(now)
return now
def test_bool(self):
self.assertEqual(K(True), q("1b"))
self.assertEqual(K(False), q("0b"))
def test_a2(self):
self.failUnlessEqual(q('+')(1,2), q('3i'))
def test_a1(self):
self.failUnlessEqual(q('::')(1), q('1i'))
def test_a0(self):
self.failUnlessEqual(q('{1}')(), q('1'))
def test_err(self):
try:
q("{'`test}", 0)
except kerr, e:
self.failUnlessEqual(str(e), 'test')
def test_tuple(self):
self.assertEqual(K(()), q("()"))
t = (False, 0, 0.0, '', kp(b''), date(2000,1,1))
self.assertEqual(K(t), q("(0b;0;0f;`;\"\";2000.01.01)"))
msg = base64.urlsafe_b64decode(token)
encode = base64.urlsafe_b64encode(msg)
print 'encoded', encode
signed = base64.encodestring(hmac.new(secret_key, msg, hashlib.sha1).digest()).strip()
creds = {
'credentials':
{
# 'access': access_key + '/' + credential_scope,
'access': access_key,
# 'token': string_to_sign,
'token': token,
'signature': signed
}
}
req = requests.post(
'http://10.96.96.53:35357/v2.0/s3tokens',
headers=headers,
data=json.dumps(creds),
verify=None
)
q(req)
if req >= 200:
print type(req)
print json.dumps(json.loads(req.text), indent=4)
def close(self):
q('close')
window = self.view.window()
window.focus_view(self.view)
window.run_command('close')
self.view = None
def msg_blast(msgType, msg):
q(msgType, msg)
log.msg("Qt says: ", msgType, msg)
def test_a0(self):
self.assertEqual(q('{1}')(), q('1'))
def test_err(self):
try:
q("{'`test}", 0)
except kerr, e:
self.assertEqual(str(e), 'test')
def test_a3(self):
self.assertEqual(q('?')(q('10b'), 1, 2), q('1 2'))
def test_long(self):
self.assertEqual(K(1L), q("1j"))
self.assertRaises(OverflowError, K, 2**100)
def test_none(self):
self.assertEqual(K(None), q("::"))
def test_int(self):
self.assertEqual(K(1), q("1"))
self.assertRaises(OverflowError, K, 2**100)
import unittest
from q import *
q("\\e 0") # disable q's debug on error
class CallTestCase(unittest.TestCase):
def test_a0(self):
self.failUnlessEqual(q('{1}')(), q('1'))
def test_a1(self):
self.failUnlessEqual(q('::')(1), q('1i'))
def test_a2(self):
self.failUnlessEqual(q('+')(1,2), q('3i'))
def test_a3(self):
self.failUnlessEqual(q('?')(q('10b'), 1, 2), q('1 2i'))
def test_err(self):
try:
q("{'`test}", 0)
except kerr, e:
self.failUnlessEqual(str(e), 'test')
q("f:{'`test}")
try:
q("{f[x]}")(42)
except kerr, e:
self.failUnlessEqual(str(e), 'test')
if __name__ == '__main__':
unittest.main()
def test_a3(self):
self.failUnlessEqual(q('?')(q('10b'), 1, 2), q('1 2i'))
def test_a1(self):
self.assertEqual(q('::')(1), q('1'))
def test_str(self):
self.assertEqual(K(''), q("`"))
def test_float(self):
self.assertEqual(K(1.0), q("1f"))
self.assertEqual(K(float('nan')), q("0Nf"))
self.assertEqual(K(float('inf')), q("0w"))
def test_a2(self):
self.assertEqual(q('+')(1,2), q('3'))
