def validate_arguments(p_action, p_db, p_type, pd_cfgDict, p_debug):
''' Validate the input arguments '''
isValid = True
errMsg = ""
if p_action is None or p_db is None:
errMsg = "arg=none"
isValid = False
if isValid == True and p_action not in pd_cfgDict['oraUserAction'][
'valid_action_list']:
errMsg += ",action = invalid"
isValid = False
if isValid == True and p_db not in pd_cfgDict['oraUserAction'][
'valid_db_list']:
errMsg += ",environment = invalid"
isValid = False
if isValid == True and p_type not in pd_cfgDict['oraUserAction'][
'valid_type_list']:
errMsg += ",type = invalid"
isValid = False
if isValid == False:
print "ERROR: validate_arguments 1, error message {0}!".format(errMsg)
exit(1)
else:
pd_cfgDict['oraUserAction']['action'] = p_action
pd_cfgDict['oraUserAction']['db'] = p_db
pd_cfgDict['oraUserAction']['type'] = p_type
m.message(
"INFO : validate_arguments 2, are {0} and {1}!".format(
pd_cfgDict['oraUserAction']['action'],
pd_cfgDict['oraUserAction']['db']), p_debug)
return pd_cfgDict
def register_selected_shortcut(name, old_clipboard):
"""Retrieve the text/filename from the clipboard and register it as a new command."""
clipboard = QtGui.QApplication.clipboard()
clipboard.dataChanged.disconnect()
clipboard_timer.stop()
urls = clipboard.mimeData().urls()
text = clipboard.text()
if list(old_clipboard.formats()): # Check if the old clipboard MIME object contains any data
CommandHandler.main_gui.call(clipboard.setMimeData, [old_clipboard]) # Restore the old clipboard contents
if text: # The clipboard contains text
shortcut = unicode(text)
elif urls: # The clipboard contains a file
shortcut = unicode(urls[0].toString())[8:].replace("/", "\\")
else:
message("Unable to register the selection as a shortcut", "Error")
return
shortcuts_dict = load_shortcuts() # Load shortcuts from the config file
if name.decode("utf-8") not in shortcuts_dict:
keyword = "registered"
else:
keyword = "updated"
CommandHandler.remove(name) # Delete the existing command
register_shortcut(name, shortcut) # Register the new command
shortcuts_dict.update({name.decode("utf-8"): shortcut}) # Update with new shortcut
save_shortcuts(shortcuts_dict) # Write back to the file
message("Shortcut %s: [i]%s[/i]\nTarget: [i]%s[/i]" % (keyword, name.decode("utf-8"), shortcut), "Success")
def previous_level():
# advance to the previous level
message("You go up a floor.", tcod.light_violet)
settings.save_level_state()
settings.dungeon_level -= 1
settings.load_level_state()
initialize_fov()
def prepare_next_question(self):
if self.strategy == 'maxent':
facet = max(self.entropy_dict, key=self.entropy_dict.get)
data = dict()
data['facet'] = facet
new_message = message(cfg.AGENT, cfg.USER, cfg.ASK_FACET, data)
self.asked_feature.append(facet)
return new_message
elif self.strategy == 'maxsim':
# ask following max similarity between attributes
for f in self.asked_feature:
if self.sim_dict is not None and f in self.sim_dict:
self.sim_dict[f] = -1
if len(self.known_feature) == 0 or self.sim_dict is None:
facet = max(self.entropy_dict, key=self.entropy_dict.get)
else:
facet = max(self.sim_dict, key=self.sim_dict.get)
data = dict()
data['facet'] = facet
new_message = message(cfg.AGENT, cfg.USER, cfg.ASK_FACET, data)
self.asked_feature.append(facet)
return new_message
else:
pool = [
item for item in cfg.FACET_POOL
if item not in self.asked_feature
]
facet = np.random.choice(np.array(pool), 1)[0]
data = dict()
if facet in [item.name for item in cfg.cat_tree.children]:
data['facet'] = facet
else:
data['facet'] = facet
new_message = message(cfg.AGENT, cfg.USER, cfg.ASK_FACET, data)
return new_message
def response(self, input_message):
assert input_message.sender == cfg.AGENT
assert input_message.receiver == cfg.USER
# _______ update candidate _______
if 'candidate' in input_message.data:
self.recent_candidate_list = input_message.data['candidate']
new_message = None
if input_message.message_type == cfg.EPISODE_START or input_message.message_type == cfg.ASK_FACET:
facet = input_message.data['facet']
new_message = self.inform_facet(facet)
if input_message.message_type == cfg.MAKE_REC:
if self.busi_id in input_message.data['rec_list']:
data = dict()
data['ranking'] = input_message.data['rec_list'].index(
self.busi_id) + 1
data['total'] = len(input_message.data['rec_list'])
new_message = message(cfg.USER, cfg.AGENT, cfg.ACCEPT_REC,
data)
else:
data = dict()
data['rejected_item_list'] = input_message.data['rec_list']
new_message = message(cfg.USER, cfg.AGENT, cfg.REJECT_REC,
data)
return new_message
def add_data(m, connection):
key = int(input("key:"))
content = input("data:")
nid = sucs(m, connection, key)
data = (key, content)
connection.put(
message(None, -1, ("forward", message(nid, nid, ("adddata", data)))))
def onCommand(message_in):
if message_in.command == 'xkcd':
if message_in.body != '':
try:
if int(message_in.body) < 0:
return message.message(body="ID `{}` is not a valid ID".
format(message_in.body))
except:
return message.message(
body='Input of `{}` is not a valid number'.format(
message_in.body))
data = json.loads(
caching.getJson("https://xkcd.com/{}/info.0.json".format(
message_in.body.strip()),
caller='xkcd',
customName='{}.json'.format(
message_in.body.strip())))
else:
data = json.loads(
caching.getJson("https://xkcd.com/info.0.json",
caller='xkcd',
save=False))
caching.downloadToCache(data['img'],
'{}.png'.format(data['num']),
caller='xkcd')
return message.message(body='**{}/{}/{} - {}**\n_{}_'.format(
data['month'], data['day'], data['year'], data['safe_title'],
data['alt']),
file='cache/xkcd_{}.png'.format(data['num']))
def rand_start(n):
myManager.register('get_connection')
myManager.register('get_inbox')
myManager.register('get_guest_queue')
m = myManager(address=('localhost', 50000), authkey=b'abc')
m.connect()
gq = m.get_guest_queue()
connection = m.get_connection()
id=None
mysucs=None
while(True):
rint=randint(0,n)
connection.put(message(GUEST,SERVER,("sucs",rint)))
resp=gq.get()
if resp.data[1]==False:
id=rint
mysucs=rint
break
if resp.data[1]!=rint:
id=rint
mysucs=resp.data[1]
break
connection.put(message(GUEST,SERVER,("preds",id)))
resp=gq.get()
#pr=Process(target=start,args=(m.get_inbox(id),connection,id,mysucs,resp.data[1],n,))
#pr.start()
#return pr
start(m.get_inbox(id),connection,id,mysucs,resp.data[1],n)
def send_clients(msg, group_name, client_name, content_type, file_name=""):
#print("sending to group members:"+group_name)
msg_length = str(len(msg))
msg_length = pad(msg_length)
for client in group_info[group_name]["participants"]:
if not client == client_name:
print(client)
cipher = encryption.encrypt_des3(msg_length,
client_info[client][1])
msg1 = message("SERV",
"GRP_MSG",
"TEXT",
cipher,
file_name,
client_name=client_name,
group_name=group_name)
msg1 = pickle.dumps(msg1)
cipher = encryption.encrypt_des3(msg, client_info[client][1])
msg2 = message("SERV",
"GRP_MSG",
content_type,
cipher,
file_name,
client_name=client_name,
group_name=group_name)
msg2 = pickle.dumps(msg2)
start_new_thread(send_to_client,
(msg1, msg2, int(client_info[client][0])))
def onCommand(message_in):
"""Do some math."""
formula = message_in.body
formula = formula.replace('*', 'x')
if formula == None:
msg = 'Usage: `{}calc [formula]`'.format('!')
return message.message(body=msg)
try:
nsp = NumericStringParser()
answer = nsp.eval(formula)
except Exception as e:
print("CALC PLUGIN EXCEPTION\r\n{}".format(e))
msg = 'I couldn\'t parse "{}" :(\n\n'.format(formula)
msg += 'I understand the following syntax:\n```\n'
msg += "expop :: '^'\n"
msg += "multop :: 'x' | '/'\n"
msg += "addop :: '+' | '-'\n"
msg += "integer :: ['+' | '-'] '0'..'9'+\n"
msg += "atom :: PI | E | real | fn '(' expr ')' | '(' expr ')'\n"
msg += "factor :: atom [ expop factor ]*\n"
msg += "term :: factor [ multop factor ]*\n"
msg += "expr :: term [ addop term ]*```"
# msg = Nullify.clean(msg)
return message.message(body=msg)
msg = '`{}` = `{}`'.format(formula, answer)
# Say message
return message.message(body=msg)
def check_level_up():
level_up_xp = settings.LEVEL_UP_BASE + settings.player.level * \
settings.LEVEL_UP_FACTOR
if settings.player.fighter.xp >= level_up_xp:
settings.player.level += 1
settings.player.fighter.xp -= level_up_xp
message('Your battle skills grow stronger. You reached level ' +
str(settings.player.level) + '.', color.yellow)
choice = None
while choice is None:
choice = menu('Level up! Choose a stat to raise:\n',
['Constitution (+20 HP, from ' +
str(settings.player.fighter.max_hp) + ')',
'Strength (+1 attack, from ' +
str(settings.player.fighter.power) + ')',
'Agility (+1 defense, from ' +
str(settings.player.fighter.defense) + ')'],
settings.LEVEL_SCREEN_WIDTH)
if choice == 0:
settings.player.fighter.max_hp += 20
settings.player.fighter.hp += 20
elif choice == 1:
settings.player.fighter.power += 1
elif choice == 2:
settings.player.fighter.defense += 1
def get_data(m, connection, key):
nid = sucs(m, connection, key)
q = m.get_guest_queue()
connection.put(
message(GUEST, SERVER, ("forward", message(GUEST, nid,
("getdata", key)))))
resp = q.get()
return resp.data[1]
def player_death(player):
# the game ended
message("You died!", tcod.lighter_red)
settings.game_state = 'dead'
# transform the player into a corpse
settings.player.char = '%'
settings.player.color = tcod.dark_red
def equip(self):
old_equipment = get_equipped_in_slot(self.slot)
if old_equipment is not None:
old_equipment.dequip()
self.is_equipped = True
message.message('Equipped ' + self.owner.name + ' on ' +
self.slot + '.', color.light_green)
def create_shortcut(name=None):
if name is None: # Register subcommands
return []
elif name == "":
message("Press tab to enter a name for the shortcut first", "Error")
else:
# Call from the main thread because the function uses Qt objects
CommandHandler.main_gui.call(get_shortcut, [name])
def drop(self, user):
# add to the map and remove from the player's inventory
settings.objects.append(self.owner)
user.combatant.inventory.remove(self.owner)
self.owner.x = settings.player.x
self.owner.y = settings.player.y
message("You dropped a " + self.owner.name + ".", tcod.yellow)
if self.owner.equipment:
self.owner.equipment.dequip()
def drop(self):
if self.owner.equipment:
self.owner.equipment.dequip()
settings.objects.append(self.owner)
settings.inventory.remove(self.owner)
self.owner.x = settings.player.x
self.owner.y = settings.player.y
message.message('You dropped a ' + self.owner.name + '.', color.yellow)
def take_turn(self):
if self.num_turns > 0:
message.message('The ' + self.owner.name +
'\'s timer is at ' + str(self.num_turns),
color.red)
self.num_turns -= 1
else:
self.result(self)
self.owner.ai = None
def send_sock(req):
client = req.content.decode("utf-8")
if (client not in client_info):
resp = message("SERV", "ERR", "TEXT",
bytes(client + " not found", 'utf-8'))
else:
resp = message("SERV", "SOCK_RES", "TEXT",
bytes(client_info[client][0], 'utf-8'))
return resp
def cast_confuse(user=None, target=None, max_range=settings.CONFUSE_RANGE):
monster = user.combatant.get_target(max_range)
if monster == 'cancelled':
return 'cancelled'
old_ai = monster.ai
monster.ai = ai.ConfusedMonster(old_ai)
monster.ai.owner = monster
message(monster.name + ' looks confused!', tcod.green)
end_player_turn()
def select_target(max_range):
message("Select a target. Right click or Escape to cancel",
tcod.light_cyan)
settings.highlight_state = 'target'
monster = choose_target(max_range)
if monster is None:
settings.highlight_state = 'play'
return 'cancelled'
return monster
def cast_hold_in_place(user=None, target=None, max_range=settings.HOLD_RANGE):
monster = user.combatant.get_target(max_range)
if monster == 'cancelled':
return 'cancelled'
old_ai = monster.ai
monster.ai = ai.HeldMonster(old_ai)
monster.ai.owner = monster
message(monster.name + ' looks unable to move!', tcod.green)
end_player_turn()
def sign_up(req):
if (req.client_name in client_info):
resp = message("SERV", "ERR", "TEXT",
bytes("username already exists", 'utf-8'))
else:
client_info[req.client_name] = req.content.decode('utf-8').split(",")
resp = message("SERV", "SIGN_UP", "TEXT",
bytes("SIGN UP SUCCESFULL", 'utf-8'))
print(client_info)
return resp
def use(self):
if self.owner.equipment:
self.owner.equipment.toggle_equip()
return
if self.use_function is None:
message.message('The ' + self.owner.name + ' cannot be used.')
else:
if self.use_function() != 'cancelled':
settings.inventory.remove(self.owner)
def take_turn(self):
if self.num_turns > 0:
monster = self.owner
if tcod.map_is_in_fov(settings.fov_map, monster.x, monster.y):
if monster.distance_to(settings.player) < 2:
monster.combatant.attack(settings.player)
self.num_turns -= 1
else:
self.owner.ai = self.old_ai
message("The " + self.owner.name + " is no longer held!", tcod.red)
def send_client(msg, receiving_client, file_name="", content_type="TEXT"):
cipher = encryption.encrypt_des3(msg, str(key_info[receiving_client]))
msg1 = message("CLI", "NORMAL_MSG", content_type, cipher, file_name, "",
user_name)
msg1 = pickle.dumps(msg1)
cipher = encryption.encrypt_des3(pad(str(len(msg1))),
str(key_info[receiving_client]))
msg2 = message("CLI", "NORMAL_MSG", "TEXT", cipher, "", "", user_name)
msg2 = pickle.dumps(msg2)
send_to_client(msg2, msg1, peer_info[receiving_client], "NORMAL_MSG")
def inform_facet(self, facet):
data = dict()
data['facet'] = facet
if facet not in cfg.item_dict[str(self.busi_id)]['categories']:
data['value'] = None
return message(cfg.USER, cfg.AGENT, cfg.INFORM_FACET, data)
else:
data['value'] = [facet]
return message(cfg.USER, cfg.AGENT, cfg.INFORM_FACET, data)
def take_turn(self):
if self.num_turns > 0:
# move in a random direction
self.owner.move(tcod.random_get_int(0, -1, 1),
tcod.random_get_int(0, -1, 1))
self.num_turns -= 1
else:
self.owner.ai = self.old_ai
message("The " + self.owner.name + " is no longer confused!",
tcod.red)
def explosive_death(monster):
message('The ' + monster.name + ' is dead. You gain ' +
str(monster.fighter.xp) + ' experiance points.',
color.orange)
monster.char = '*'
monster.color = color.orange
monster.blocks = False
monster.fighter = None
monster.ai = AI.CountDown(spells.cast_self_destruct)
monster.ai.owner = monster
monster.name = 'explosive remains of ' + monster.name
def start(inbox,connection,id,sucs,preds,n):
node=ChordNode(id,connection,inbox,n)
connection.put(message(id,SERVER,("add",id)))
node.send_to_node(message(id,sucs,("setpreds",id)))
node.send_to_node(message(id, sucs, ("reqdata",None)))
node.send_to_node(message(id, preds, ("setsucs", id)))
node.sucs=sucs
node.pred=preds
#node.fillFt()
node.run()
def sign_in(req):
if (req.client_name not in client_info):
resp = message("SERV", "ERR", "TEXT",
bytes("username not found", 'utf-8'))
elif not req.content.decode("utf-8") == client_info[req.client_name][1]:
resp = message("SERV", "ERR", "TEXT",
bytes("incorrect credentials", 'utf-8'))
else:
resp = message("SERV", "SIGN_IN", "TEXT",
bytes("Succesfully signed in", 'utf-8'))
return resp
def check_level_up():
# see if the player's exp enables them to level up
level_up_exp = settings.LEVEL_UP_BASE + settings.player.combatant.level * settings.LEVEL_UP_FACTOR
if settings.player.combatant.xp >= level_up_exp:
settings.player.combatant.level_up()
settings.player.combatant.level += 1
# player gained a level, so gets new abilities
settings.player.combatant.xp -= level_up_exp
message(
"You gained a level. You are now level: " +
str(settings.player.combatant.level), tcod.yellow)
def basic_death(monster):
message(
"The " + monster.name + " is dead. You gain " + str(monster.fighter.xp) + " experiance points.", color.orange
)
monster.char = "%"
monster.color = color.dark_red
monster.blocks = False
monster.fighter = None
monster.ai = None
monster.name = "remains of " + monster.name
monster.send_to_back()
def next_level():
# advance to the next level
message('You go down a floor.', tcod.light_violet)
settings.save_level_state()
settings.dungeon_level += 1
try:
settings.load_level_state()
except:
print_debug("map not found. making new map")
make_map()
settings.save_level_state()
initialize_fov()
def monster_death(monster):
# transform the monster into a corpse. it doesn't block, can't be attacked and can't move
message(
monster.name.capitalize() + ' is dead. You gained ' +
str(monster.combatant.xp) + 'exp!', tcod.light_green)
monster.char = '%'
monster.color = tcod.dark_red
monster.blocks = False
monster.combatant = None
monster.ai = None
monster.name = 'remains of ' + monster.name
monster.send_to_back()
def smash(player, target, max_range):
distance = 1
damage = 20
direction = prompt_user_for_direction()
if direction == (0, 0) or type(direction) is not tuple:
return 'fail'
targets = fire_beam_in_direction((settings.player.x, settings.player.y),
direction, distance)
for obj in targets:
message(obj.name.capitalize() + " takes " + str(damage) + " damage.")
obj.combatant.take_damage(damage)
end_player_turn()
def onCommand(message_in):
if message_in.command == 'eat':
author = displayname.name(message_in.author)
member = message_in.body.strip()
# Check if we're eating nothing
if member == "":
nothingList = ['you sit quietly and eat *nothing*...',
'you\'re *sure* there was something to eat, so you just chew on nothingness...',
'there comes a time when you need to realize that you\'re just chewing nothing for the sake of chewing. That time is now.']
randnum = random.randint(0, len(nothingList) - 1)
return message.message('*{}*, {}'.format(author, nothingList[randnum]))
# Check if we're eating a member
memberCheck = displayname.memberForName(member, message_in.server)
if memberCheck:
# We're eating a member - let's do a bot-check
if memberCheck.id == message_in.server.me.id:
# It's me!
memberList = ['you try to eat *me* - but unfortunately, I saw it coming - your jaw hangs open as I deftly sidestep.',
'your mouth hangs open for a brief second before you realize that *I\'m* eating *you*.',
'I\'m a bot. You can\'t eat me.',
'your jaw clamps down on... wait... on nothing, because I\'m *digital!*.',
'what kind of bot would I be if I let you eat me?']
elif memberCheck.id == message_in.author.id:
# We're eating... ourselves?
memberList = ['you clamp down on your own forearm - not surprisingly, it hurts.',
'you place a finger into your mouth, but *just can\'t* force yourself to bite down.',
'you happily munch away, but can now only wave with your left hand.',
'wait - you\'re not a sandwich!',
'you might not be the smartest...']
else:
memName = displayname.name(memberCheck)
memberList = ['you unhinge your jaw and consume *{}* in one bite.'.format(memName),
'you try to eat *{}*, but you just can\'t quite do it - you spit them out, the taste of failure hanging in your mouth...'.format(memName),
'you take a quick bite out of *{}*. They probably didn\'t even notice.'.format(memName),
'you sink your teeth into *{}\'s* shoulder - they turn to face you, eyes wide as you try your best to scurry away and hide.'.format(memName),
'your jaw clamps down on *{}* - a satisfying *crunch* emanates as you finish your newest meal.'.format(memName)]
randnum = random.randint(0, len(memberList) - 1)
return message.message('*{}*, {}'.format(author, memberList[randnum]))
# Assume we're eating something else
itemList = ['you take a big chunk out of *{}*. *Delicious.*'.format(member),
'your teeth sink into *{}* - it tastes satisfying.'.format(member),
'you rip hungrily into *{}*, tearing it to bits!'.format(member),
'you just can\'t bring yourself to eat *{}* - so you just hold it for awhile...'.format(member),
'you attempt to bite into *{}*, but you\'re clumsier than you remember - and fail...'.format(member),]
randnum = random.randint(0, len(itemList) - 1)
return message.message('*{}*, {}'.format(author, itemList[randnum]))
def cast_lightning():
# find closest enemy within a maximum range and damage it
monster = settings.closest_monster(settings.LIGHTNING_RANGE)
if monster is None:
message("No enemy is close enough to strike", tcod.white)
return 'cancelled'
# zap it
message(
"A lightning bolt strikes the " + monster.name +
" with a loud thunder! The damage is " +
str(settings.LIGHTNING_DAMAGE) + " hit points.", tcod.light_blue)
monster.combatant.take_damage(settings.LIGHTNING_DAMAGE)
def take_turn(self):
if self.num_turns > 0:
self.owner.move(libtcod.random_get_int(0, -1, 1),
libtcod.random_get_int(0, -1, 1))
self.num_turns -= 1
elif self.num_turns == -1:
self.owner.move(libtcod.random_get_int(0, -1, 1),
libtcod.random_get_int(0, -1, 1))
else:
self.owner.ai = self.old_ai
message.message('The ' + self.owner.name +
' is no longer confused.', libtcod.red)
def pick_up(self, user):
# add to the player's inventory and remove from the map
if len(user.combatant.inventory) >= 26 and user == settings.player:
message("Your inventory is full!", tcod.red)
else:
user.combatant.inventory.append(self.owner)
settings.objects.remove(self.owner)
message("You picked up a " + self.owner.name + ".", tcod.green)
equipment = self.owner.equipment
if equipment and settings.get_equipped_in_slot(
equipment.slot) is None:
equipment.equip()
def pick_up(self):
if len(settings.inventory) >= 26:
message.message('Your inventory is full, you cannot pick up ' +
self.owner.name + '.', color.red)
else:
settings.inventory.append(self.owner)
settings.objects.remove(self.owner)
message.message('You picked up a ' + self.owner.name + '.',
color.green)
equipment = self.owner.equipment
if equipment and get_equipped_in_slot(equipment.slot) is None:
equipment.equip()
def dataReceived(self, data):
m = deserialize(data)
if m["message"]["command"] == "verack":
"""Complete the handshake if we received both version and verack"""
self.timeouts["verack"].cancel()
del self.timeouts["verack"]
if "version" not in self.timeouts:
self.on_handshake_complete()
elif m["message"]["command"] == "version":
"""Send the verack back"""
# TODO: make sure this node uses NODE_NETWORK (and maybe NODE_BLOOM in the future)
self.timeouts["version"].cancel()
del self.timeouts["version"]
self.transport.write(serialize(message(verack(), self.params)))
if "verack" not in self.timeouts:
self.on_handshake_complete()
elif m["message"]["command"] == "inv":
"""Run through our callbacks to see if we are waiting on any of these inventory items"""
inventory = deserialize(m["message"]["payload"], "inv")
for item in inventory["inv"]:
if item[1] in self.callbacks:
self.callbacks[item[1]](item[1])
del self.callbacks[item[1]]
elif item[0] == "TX":
self.send_message(message(get_data(item[0], item[1]), self.params))
print "Peer %s:%s announced new %s %s" % (self.transport.getPeer().host, self.transport.getPeer().port, item[0], item[1])
elif m["message"]["command"] == "getdata":
"""Serve the data from inventory if we have it"""
data_request = deserialize(m["message"]["payload"], "getdata")
for item in data_request["getdata"]:
if item[1] in self.inventory and item[0] == "TX":
transaction = tx(self.inventory[item[1]])
self.send_message(message(transaction, self.params))
elif m["message"]["command"] == "tx":
"""Parse to check the script_pubkey data element against our subscriptions"""
t = deserialize(m["message"]["payload"], "tx")
for out in t['tx']['outs']:
script = bitcoin.deserialize_script(out['script'])
data_element = script[2] if len(script) == 5 else script[1]
if data_element in self.callbacks:
self.callbacks[data_element](t)
else:
print "Received message %s from %s:%s" % (m["message"]["command"], self.transport.getPeer().host, self.transport.getPeer().port)
def send_accept(self, prop, ins, cid, value,
rmsg_type, rmsg_prop, rmsg_ins, rmsg_cid):
"""
Helper function, send accept message to server, check
returned message
- prop: proposal number to be sent
- ins: instance number to be sent
- cid: client id to be sent
- value: value to be sent
- rmsg_type: expected returned message type
- rmsg_prop: expected returned message proposal number
- rmsg_ins: expected returned message instane number
- rmsg_cid: expected returned message client id
"""
msg = message.message(MESSAGE_TYPE.ACCEPT, prop, ins,
value, self.dummy_server_id, cid)
self.message_socket.send(pickle.dumps(msg))
rmsgs = self.acceptor_connection.recv(1000)
rmsg = pickle.loads(rmsgs)
assert isinstance(rmsg, message.message)
assert rmsg.msg_type == rmsg_type
assert rmsg.proposal == rmsg_prop
assert rmsg.instance == rmsg_ins
assert rmsg.client_id == rmsg_cid
return rmsg
def test_reject_accept(self):
"""
Test case where prepare goes through but another proposal
fires a high proposal before accept comes through
"""
print "\n\n[Info] ##########[SINGLE PREPARE ACCEPT TEST]##########\n"
# send a prepare message, proposal = 6, instance = 0
self.send_prepare(6, 0, MESSAGE_TYPE.PREPARE_ACK, 6, 0)
# send another prepare message, proposal = 8; instance = 0
self.send_prepare(8, 0, MESSAGE_TYPE.PREPARE_ACK, 8, 0)
# send an accept message which should get rejected
proposal, instance, client_id = 6, 0, 9
msg = message.message(MESSAGE_TYPE.ACCEPT, proposal, instance,
None, self.dummy_server_id, client_id)
self.message_socket.send(pickle.dumps(msg))
self.acceptor_connection.settimeout(1.0)
try:
pickle.loads(self.acceptor_connection.recv(1000))
assert(False)
except Exception, e:
print e
pass
def connectionMade(self):
"""
Send the version message and start the handshake
"""
self.timeouts["verack"] = reactor.callLater(5, self.response_timeout, "verack")
self.timeouts["version"] = reactor.callLater(5, self.response_timeout, "version")
self.transport.write(serialize(message(version(user_agent=self.user_agent), self.params)))
def test_multiple_instance_prepare(self):
"""
Test multiple instances
"""
print "\n\n[Info] ##########[MULTIPLE INSTANCE PREAPRE TEST]########\n"
# send an initial instance number, proposal = 0, instance = 0
self.send_prepare(0, 0, MESSAGE_TYPE.PREPARE_ACK, 0, 0)
# send a higher number proposal, proposal = 5, instance = 0
self.send_prepare(5, 0, MESSAGE_TYPE.PREPARE_ACK, 5, 0)
# send a different instance, proposal = 1, instance = 2
self.send_prepare(1, 2, MESSAGE_TYPE.PREPARE_ACK, 1, 2)
# send original instance with lower proposal number
proposal, instance = 3, 0
msg = message.message(MESSAGE_TYPE.PREPARE, proposal, instance,
None, self.dummy_server_id)
self.message_socket.send(pickle.dumps(msg))
self.acceptor_connection.settimeout(1.0)
try:
pickle.loads(self.acceptor_connection.recv(1000))
assert(False)
except Exception, e:
print e
pass
def test_multiple_proposal_prepare(self):
"""
Issues multiple proposals for the same instance and tests
if correct responses are received
"""
print "\n\n[Info] ##########[MULTIPLE PROPOSAL TEST]##########\n"
# send and receive a valid proposal, proposal = 1, instance = 0
self.send_prepare(1, 0, MESSAGE_TYPE.PREPARE_ACK, 1, 0)
print "[Info] First prepare request successful..."
# send and receive another valid proposal, proposal = 3, instance = 0
self.send_prepare(3, 0, MESSAGE_TYPE.PREPARE_ACK, 3, 0)
print "[Info] Second prepare request successful..."
# send an not receive a lower numbered proposal
proposal, instance = 2, 0
msg = message.message(MESSAGE_TYPE.PREPARE,
proposal, instance, None, self.dummy_server_id)
self.message_socket.send(pickle.dumps(msg))
try:
self.acceptor_connection.settimeout(1.0)
self.acceptor_connection.recv(1000)
assert False # time out should happen
except Exception, e:
print e
pass
def on_handshake_complete(self):
print "Connected to peer %s:%s" % (self.transport.getPeer().host, self.transport.getPeer().port)
self.state = State.CONNECTED
self.send_message(message(filer_load(str(self.bloom_filter.vData).encode("hex"),
self.bloom_filter.nHashFuncs,
self.bloom_filter.nTweak,
self.bloom_filter.nFlags), self.params))
def __init__(self, conn, newDc_no):
msg = message("sync", newDc_no)
send = pickle.dumps(msg,0)
s = socket.socket()
s.connect(conn)
s.send(send)
s.close()
def send_prepare(self, prop, ins, rmsg_type, rmsg_prop, rmsg_ins):
"""
Helper function, send prepare message to server, check
returned message
- prop: proposal number to be sent
- ins: instance number to be sent
- rmsg_type: expected returned message type
- rmsg_prop: expected returned message proposal number
- rmsg_ins: expected returned message instane number
"""
msg = message.message(
MESSAGE_TYPE.PREPARE, prop, ins, None, self.dummy_server_id)
self.message_socket.send(pickle.dumps(msg))
print "[Info] Sent a proposal to acceptor..."
rmsgs = self.acceptor_connection.recv(1000)
rmsg = pickle.loads(rmsgs)
assert isinstance(rmsg, message.message)
print "[Info] Received a response from server..."
assert rmsg.msg_type == rmsg_type
if rmsg.proposal != rmsg_prop:
print (rmsg.proposal, rmsg_prop)
assert rmsg.proposal == rmsg_prop
assert rmsg.instance == rmsg_ins
return rmsg
def tearDown(self):
# directly inject an exit message to each of the queues
exit_msg = message.message(message.MESSAGE_TYPE.EXIT,
None, None, None, 'localhost', 9000, None)
for s in self.servers:
s.acceptor_queue.put(exit_msg)
s.proposer_queue.put(exit_msg)
# join the acceptor and proposer processes for each server
for s in self.servers:
s.listening_process.terminate()
s.listening_process.join(5)
s.acceptor_process.join(5)
s.proposer_process.join(5)
assert(not s.proposer_process.is_alive())
# perform a validation over the files
for s in self.servers:
assert(validate_lock_file("server" + str(s.server_id) + ".txt"))
# check that the correct distributino of lcoks appeared in the log files
client_files = self.client_files
server_files = []
for s in self.servers:
server_files.append("server" + str(s.server_id) + ".txt")
assert(len(server_files) == len(self.servers))
if (self.client_files != None):
validate_client_file(client_files, server_files)
def __init__(self, msg):
self._msg = msg
self._statuses = msg.__getattr__('statuses')
self._len = len(self._statuses)
self._msg_list = []
i = 0
while i < self._len:
self._msg_list.append(message(self._statuses[i]))
i = i + 1
def SaveConfig(self, event=None):
msg = message.message()
url = self.UrlVar.get()
path = self.PathVar.get()
times = int(self.TimesVar.get())
msg.showmsg(u'消息',u'开始运行并隐藏窗口,如需关闭监控请杀python进程!')
self.hide()
m = function.Monitor.monitor(path,url)
m.execute(10000,times)
def __init__(self, msg): self._msg = msg self._jsonprocessor = JsonProcessor() self._statuses = self._jsonprocessor.Parse_get_text_from_json(self._msg, 'statuses') self._len = len(self._statuses) self._msg_list = [] i = 0 while i < self._len: self._msg_list.append(message(self._statuses[i])) i = i + 1
def next_level():
message('You take a moment to rest, and recover your strength',
color.light_violet)
settings.player.fighter.heal(settings.player.fighter.max_hp / 2)
settings.dungeon_level += 1
message('After a rare moment of peace, you descend deeper into ' +
'the heart of the dungeon...', color.red)
(cx, cy) = Rect(0, 0, settings.MAP_WIDTH, settings.MAP_HEIGHT).center
if settings.stairs.x < cx:
cx = 0
else:
cx = 1
if settings.stairs.y < cy:
cy = 0
else:
cy = 2
make_map(cx + cy)
initialize_fov()
def clock2(self):
if self.message is None:
function = self.produce()
if function is None:
return
self.message = message.message(self.position,self.address(), function , "", cycle=cycle)
if not self.channel.request.is_full():
self.channel.request.write(self.message)
self.message = None
def send_command(self, cmd, client_id):
msg = message.message(MESSAGE_TYPE.CLIENT,
None, None, cmd, client_id, client_id=client_id)
assert msg.client_id is not None
try:
self.CONNECTION_SOCKET.send(pickle.dumps(msg))
except Exception, e:
# the server node failed so abort
print "client - warn {}".format(e)
pass
def update(self):
if self.con==0:self.__init__()
m=message.message()
dic=['国内新闻','科技趣闻','环球视野','军事汇总','娱乐八卦','音乐资讯','科技要闻','天气','农历日历','NBA篮球','教务处']
if 1:
#try:
for i in range(1,12):
print i
s=m.getmsg(i)
#self.cur.execute("insert into message (ans,name) values('%s','%s')"%(s,dic[i-1]))
self.cur.execute("update message set ans='%s' where name=='%s'"%(s,dic[i-1]))
return 1
def new_game():
fighter_component = Fighter(hp=30, defense=2, power=5,
xp=0, death_function=player_death)
settings.player = Object(0, 0, '@', 'player', color.white, blocks=True,
fighter=fighter_component)
settings.player.level = 1
settings.dungeon_level = 1
make_map()
handle_keys.initialize_fov()
settings.game_state = 'playing'
settings.inventory = []
settings.game_msgs = []
message('Welcome stranger. Prepare to perish in the ' +
'Tombs of the Ancient Kings.', color.red)
equipment_component = Equipment(slot='right hand', power_bonus=2)
obj = Object(0, 0, '-', 'dagger', color.sky,
equipment=equipment_component)
settings.inventory.append(obj)
equipment_component.equip()
obj.always_visible = True
def run(cls, text):
python_architecture = struct.calcsize("P") * 8 # Python installation: 32- or 64-bit
# If 32-bit Python is used, the System32 folder is normally redirected. This causes some applications to be impossible
# to run. The following disables this redirection.
if python_architecture == 32:
old_value = ctypes.c_long()
ctypes.windll.kernel32.Wow64DisableWow64FsRedirection(old_value)
if cls.active_command:
print "Command:", cls.active_command, ">", text
thread.start_new_thread(cls.command_list[cls.active_command]['callback'], (text,))
cls.reset_mode()
return True
print "Command:", text
try:
command = cls.command_list[text]
except KeyError:
pass
else:
thread.start_new_thread(command['callback'], tuple(command['args']))
return True
try:
shell.Run('"' + text.decode("utf-8").encode("cp1252") + '"')
except com_error:
if re.search(r"\.\w+", text) is not None: # Might be a URL. Append 'http://' and try again.
try:
shell.Run('"http://' + text.decode("utf-8").encode("cp1252") + '"')
except com_error:
message("Cannot execute: [i]%s[/i]" % text.decode("utf-8"), "Invalid command")
else:
message("Cannot execute: [i]%s[/i]" % text.decode("utf-8"), "Invalid command")
return False
else:
return True
