def test_get_command(self):
"""tests if the get_command method works"""
command_string = "get filedata"
# get an existing command
self.assertEqual(get_command(get_filedata), command_string)
# get an illegal command
self.assertEqual(get_command(invalid_function), None)
def __handle_request(self, caller):
"""This is called whenever data is received from one of the client."""
try:
data = caller.receive()
logging.debug("Parsing this data: '" + data + "'")
result = self.parser.parse(data)
logging.debug("Result of parsing: '" + result.command_name + "(" + ",".join(result.command_arguments) + ")'")
cmd = commands.get_command(result.command_name, self, caller, result.command_arguments)
cmd.execute()
except commands.ArgumentsValidationError as e:
#Command arguments did not validate.
print(e)
print("asdasdasdasd")
cmd = commands.get_command("Whisper", self, self.server_client, [caller.name, str(e)])
cmd.execute()
except commands.ExecutionFailedError as e:
#Tell the client that the command could not be executed properly.
cmd = commands.get_command("Whisper", self, self.server_client, [caller.name, "Command execution failed"])
cmd.execute()
logging.exception(e)
except clients.SocketError as e:
#Client probably just disconnected.
logging.debug("SocketError while handling request.")
logging.exception(e)
self.disconnect_client(caller)
except clients.ClientIsNotFinishedSendingError as e:
#Client has not finished sending it's data.
pass
except NameError as e:
# The command is not recognized.
cmd = commands.get_command("Whisper", self, self.server_client, [caller.name, "Unrecognized command"])
cmd.execute()
def test_get_command(self):
"""tests if the get_command method works"""
command_string = "get filedata"
# get an existing command
self.assertEqual(get_command(get_filedata),
command_string)
# get an illegal command
self.assertEqual(get_command(invalid_function), None)
def check_for_followed_by_args(cmd, command_args, project_template):
if not cmd.followed_by_template and not cmd.followed_by_command:
return command_args # nothing to check
command = None
if cmd.followed_by_template and cmd.followed_by_command:
# If no arguments, there is something obviously wrong
if len(command_args) == 0:
if project_template:
templatetools.usage_error(_("No command provided to %s command.") % cmd.name, cmd=cmd, template=project_template)
else:
templatetools.usage_error(_("No template or command provided to %s command.") % cmd.name, cmd=cmd)
# At least one argument. What is it? First check if it's a command if we already have a template
if project_template:
command = commands.get_command(command_args[0], project_template)
if command:
command_args.insert(0, project_template) # use default template
elif not command and not check_template_exists(command_args[0]):
# Wasn't a command or a template name, but we are in the context of a template
templatetools.usage_error(_("No %s command found in %s template.") % (command_args[0], project_template), cmd=cmd, template=project_template)
if not command:
# must be a template name then (or nonsense)
if not check_template_exists(command_args[0]):
command = commands.get_command(command_args[0]) # did user provid a valid builtin command?
if command:
command_args.insert(0, 'builtins')
elif len(command_args) == 1:
templatetools.usage_error(_("%s is neither a template nor a standard command.") % (command_args[0]), cmd=cmd)
else:
templatetools.usage_error(_("Template %s does not exist.") % (command_args[0]), cmd=cmd, show_templates_for=None)
project_template = command_args[0]
# OK, we have a template!
if len(command_args) < 2:
templatetools.usage_error(_("No command provided to %s command.") % cmd.name, cmd=cmd, template=project_template)
command = commands.get_command(command_args[1], project_template)
if not command:
templatetools.usage_error(_("No %s command found in %s template.") % (command_args[1], project_template), cmd=cmd, template=project_template)
elif cmd.followed_by_template:
if len(command_args) > 0:
if check_template_exists(command_args[0]):
project_template = command_args[0]
if not project_template:
templatetools.usage_error(_("No template provided to %s command.") % cmd.name, cmd=cmd)
elif cmd.followed_by_command:
if len(command_args) > 0:
command = commands.get_command(command_args[0], project_template)
if not command:
templatetools.usage_error(_("No %s command found.") % command_args[0], cmd=cmd, template=project_template)
if not command:
templatetools.usage_error(_("No command provided to %s command.") % cmd.name, cmd=cmd, template=project_template)
return command_args
def onMessage(self, msg):
if msg["type"] == 'chat' and hasattr(msg, "body"):
cmd_list = str(msg.body).split(" ")
cmd = cmd_list[0]
args = cmd_list[1:]
kwargs = {}
if "=" in cmd:
args = []
kwargs = utils.str_to_dict(" ".join(cmd_list[1:]))
commands.get_command(cmd)(self, msg, *args, **kwargs)
def run(self, cmd):
from inspect import getdoc
if not cmd:
for cmd in get_commands():
print(getdoc(get_command(cmd)).split('\n')[0])
return
if not get_command(cmd):
print('No such command. Try "help" for a list of all commands.')
else:
print(getdoc(get_command(cmd)))
def run(self, cmd):
from inspect import getdoc
if not cmd:
for cmd in get_commands():
print(getdoc(get_command(cmd)).split('\n')[0])
return
if not get_command(cmd):
print('No such command. Try "help" for a list of all commands.')
else:
print(getdoc(get_command(cmd)))
def __handle_new_connection(self):
"""This is called whenever a new connection is initiated"""
sock, address = self.server_client.socket.accept()
client = clients.Client(ip=address[0], name=address[0], protocol=self.encoders, socket=sock, server=self)
self.clients.append(client)
cmd = commands.get_command("Broadcast", self, self.server_client, ["{0} has joined the chat!".format(client.name), [client.name]])
cmd.execute()
def quickly(project_template, project_dir, command_args, shell_completion=False):
"""Create a new quickly template from an existing one"""
# We have nothing for this
if shell_completion:
return("")
project_template = command_args[0]
if len(command_args) < 2:
cmd = commands_module.get_command('quickly', project_template)
templatetools.usage_error(_("No destination template name provided."), cmd=cmd, template=project_template)
destination_path = os.path.expanduser("~/quickly-templates/")
# create ~/quickly-templates/ if needed
if not os.path.exists(destination_path):
os.makedirs(destination_path)
template_destination_path = destination_path + command_args[1]
if os.path.exists(template_destination_path):
print _("%s already exists." % template_destination_path)
return 1
if not os.path.exists(template_destination_path):
print _("Copy %s to create new %s template") % (project_template, template_destination_path)
try:
template_source_path = tools.get_template_directory(project_template)
except tools.template_path_not_found, e:
print(e)
return 1
def stop(self):
"""Warns the connected client that the server is going down then close all connection"""
logging.info("Server stopped")
cmd = commands.get_command("Broadcast", self, self.server_client,
["I AM GOING DOWN."])
cmd.execute()
self.kill()
def parse_commands(machine):
global ERROR_FREE_CODE
while not machine.instruction_queue.empty():
command = machine.instruction_queue.get()
command_directive, params = get_command_directive(command)
command_directive = command_directive.strip()
command_return_message = commands.get_command()[command_directive](
params, machine)
if command_return_message.startswith("Error"):
print(command_return_message)
ERROR_FREE_CODE = False
break
if command_return_message == '==> Emergency stop':
machine.message_queue.put(command_return_message)
break
if command_return_message == '==> Unconditional stop':
machine.message_queue.put(command_return_message)
break
machine.message_queue.put(command_return_message)
def main(argv):
loglevel = logging.ERROR
load_commands()
# handle input switches and parameters using `getopt.getopt` function
# there should be handled following switches:
# -h and --help - display help message prepared in _usage function above
# -v and --verbose - display additional debug ouput, set log level as logging.DEBUG
#
# There should be accepted only one input parameter, namely <command name>
#
# Missing input parameters should cause displaying help message.
# Wrong command name in the first parameter, should cause displaying error message.
# !!!Your code here!!!
logger = _configlog(loglevel)
logger.debug('START')
try:
cmdclass = commands.get_command(command)
# execute command provided by user as first parameter
# `cmdclass` it should be class, which implements given command
# this class should be instantiated with appropriate arguments
# and `execute` method of this instance should be called
#
# !!!Your code here!!!
except Exception, ex:
logger.error('Command error: %s' % ex)
def main(argv):
loglevel = logging.ERROR
load_commands()
# handle input switches and parameters using `getopt.getopt` function
# there should be handled following switches:
# -h and --help - display help message prepared in _usage function above
# -v and --verbose - display additional debug ouput, set log level as logging.DEBUG
#
# There should be accepted only one input parameter, namely <command name>
#
# Missing input parameters should cause displaying help message.
# Wrong command name in the first parameter, should cause displaying error message.
# !!!Your code here!!!
logger = _configlog(loglevel)
logger.debug('START')
try:
cmdclass = commands.get_command(command)
# execute command provided by user as first parameter
# `cmdclass` it should be class, which implements given command
# this class should be instantiated with appropriate arguments
# and `execute` method of this instance should be called
#
# !!!Your code here!!!
except Exception, ex:
logger.error('Command error: %s' % ex)
def disconnect_client(self, client):
"""
Disconnect a client and announce it to the world.
"""
self.clients.remove(client)
client.socket.close()
cmd = commands.get_command("Broadcast", self, self.server_client, ["{0} has left the chat!".format(client.name), [client.name]])
cmd.execute()
def main():
if len(argv) == 1:
with open('description.txt') as f:
print f.read()
else:
command = argv[1]
command = get_command(argv[1:])
command.execute()
def disconnect_client(self, client):
"""
Disconnect a client and announce it to the world.
"""
self.clients.remove(client)
client.socket.close()
cmd = commands.get_command(
"Broadcast", self, self.server_client,
["{0} has left the chat!".format(client.name), [client.name]])
cmd.execute()
def main(cmd_name, *args):
cmd = commands.get_command(cmd_name)
if cmd is None:
logger.error('Unknown command %s', cmd)
return 1
zk = get_client('localhost')
result = cmd(zk, *args)
if result is not None:
print(result)
def loop(self):
ok = True
while ok is True:
epidb = self._context.epidb
line = raw_input(str(epidb.echo(self._context.user_key)) + " > ")
cmd = line.strip()
if len(cmd) == 0:
continue
command = get_command(cmd)
if command is None:
continue
command(self._context)
def __handle_new_connection(self):
"""This is called whenever a new connection is initiated"""
sock, address = self.server_client.socket.accept()
client = clients.Client(ip=address[0],
name=address[0],
protocol=self.encoders,
socket=sock,
server=self)
self.clients.append(client)
cmd = commands.get_command(
"Broadcast", self, self.server_client,
["{0} has joined the chat!".format(client.name), [client.name]])
cmd.execute()
def __handle_request(self, caller):
"""This is called whenever data is received from one of the client."""
try:
data = caller.receive()
logging.debug("Parsing this data: '" + data + "'")
result = self.parser.parse(data)
logging.debug("Result of parsing: '" + result.command_name + "(" +
",".join(result.command_arguments) + ")'")
cmd = commands.get_command(result.command_name, self, caller,
result.command_arguments)
cmd.execute()
except commands.ArgumentsValidationError as e:
#Command arguments did not validate.
print(e)
print("asdasdasdasd")
cmd = commands.get_command("Whisper", self, self.server_client,
[caller.name, str(e)])
cmd.execute()
except commands.ExecutionFailedError as e:
#Tell the client that the command could not be executed properly.
cmd = commands.get_command(
"Whisper", self, self.server_client,
[caller.name, "Command execution failed"])
cmd.execute()
logging.exception(e)
except clients.SocketError as e:
#Client probably just disconnected.
logging.debug("SocketError while handling request.")
logging.exception(e)
self.disconnect_client(caller)
except clients.ClientIsNotFinishedSendingError as e:
#Client has not finished sending it's data.
pass
except NameError as e:
# The command is not recognized.
cmd = commands.get_command("Whisper", self, self.server_client,
[caller.name, "Unrecognized command"])
cmd.execute()
def main(argv):
loglevel = logging.ERROR
load_commands()
comm_name = "comm"
# handle input switches and parameters using `getopt.getopt` function
# there should be handled following switches:
# -h and --help - display help message prepared in _usage function above
# -v and --verbose - display additional debug ouput, set log level as logging.DEBUG
#
# There should be accepted only one input parameter, namely <command name>
#
# Missing input parameters should cause displaying help message.
# Wrong command name in the first parameter, should cause displaying error message.
#print len(sys.argv[1:])
try:
opts, args = getopt.getopt(sys.argv[1:], 'ho:v')
except getopt.GetoptError as err:
_usage(1)
sys.exit()
if len(sys.argv[1:]) == 0 or len(args) == 0:
_usage(1)
sys.exit()
for opt, arg in opts:
if opt in ('-h', '--help'):
_usage(1)
sys.exit()
elif opt in ('-v', '--verbose'):
comm_name = args[0]
else:
_usage(1)
sys.exit()
# !!!Your code here!!!
logger = _configlog(loglevel)
logger.debug('START')
try:
cmdclass = commands.get_command(comm_name)
# execute command provided by user as first parameter
# `cmdclass` it should be class, which implements given command
# this class should be instantiated with appropriate arguments
# and `execute` method of this instance should be called
# !!!Your code here!!!
some = cmdclass()
#logger.info('Command: %s' % some.cmd_description)
some.execute()
except ValueError as ex:
logger.error('Command error: %s' % ex)
logger.debug('%r' % 'DONE')
def pipe_commands(args, channel):
pipelist = args["args"].copy()
pipelist.insert(0,args["command"])
l = isplit(pipelist,"|")
out = None
for i in l:
cmd = i[0].strip(".")
a = i[1:]
if out:
a.append(out)
args["command"] = cmd
args["args"] = a
print(a)
c = get_command(args["command"])
print(type(c), c)
out = "".join(c(args))
sendmsg(channel, out)
def help(project_template, project_dir, command_args, shell_completion=False):
"""Get help from commands"""
# We have nothing for this
if shell_completion:
return("")
# main quickly script has already made sure input is sane
project_template = command_args[0]
command_name = command_args[1]
command = commands_module.get_command(command_name, project_template)
# Also print usage if we can
if command.usage():
print # blank line before getting to help
return command.help(project_dir, command_args)
def pipe_commands(args, channel):
pipelist = args["args"].copy()
pipelist.insert(0,args["command"])
l = isplit(pipelist,"|")
out = None
for i in l:
cmd = i[0].strip(".")
a = i[1:]
if out:
a.append(out)
args["command"] = cmd
args["args"] = a
print(a)
c = get_command(args["command"])
print(type(c), c)
if not cmd == "rate" or not cmd == "r8":
out = "".join(c(args))
sendmsg(channel, out)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('db', help='db connection string')
args = parser.parse_args()
connect(args.db)
history = InMemoryHistory()
while(True):
command_name = ui.prompt_options('>', command_list(), strict=True, history=history)
try:
command = get_command(command_name)
except:
ui.print('Invalid command')
continue
session = Session()
try:
command(session)
except KeyboardInterrupt:
session.rollback()
ui.print('Command cancelled')
def pre_create(command_template, project_template, project_dir, command_args):
"""Create the project directory before create command call"""
if len(command_args) < 1:
cmd = commands_module.get_command('create', project_template)
templatetools.usage_error(_("No project name specified."), cmd=cmd, template=project_template)
path_and_project = command_args[0].split('/')
project_name = path_and_project[-1]
# if a path is not present, create it
if len(path_and_project) > 1:
path = str(os.path.sep).join(path_and_project[0:-1])
if not os.path.exists(path):
os.makedirs(path)
os.chdir(path)
# check that project name follow quickly rules and reformat it.
try:
project_name = templatetools.quickly_name(project_name)
except templatetools.bad_project_name, e:
print(e)
return(4)
def check_for_followed_by_args(cmd, command_args):
if not cmd.followed_by_command:
return command_args # nothing to check
command = None
if cmd.followed_by_command:
# If no arguments, there is something obviously wrong
if len(command_args) == 0:
usage_error(_("No command provided to %s command.") % cmd.name, cmd=cmd)
command = commands.get_command(command_args[0]) # did user provid a valid builtin command?
if command:
command_args.insert(0, 'builtins')
elif len(command_args) == 1:
usage_error(_("%s is not a standard command.") % (command_args[0]), cmd=cmd)
if len(command_args) > 1:
if not command:
usage_error(_("No %s command found.") % command_args[0], cmd=cmd)
if not command:
usage_error(_("No command provided to %s command.") % cmd.name, cmd=cmd)
return command_args
def check_for_followed_by_args(cmd, command_args, project_template):
if not cmd.followed_by_template and not cmd.followed_by_command:
return command_args # nothing to check
command = None
if cmd.followed_by_template and cmd.followed_by_command:
# If no arguments, there is something obviously wrong
if len(command_args) == 0:
if project_template:
templatetools.usage_error(
_("No command provided to %s command.") % cmd.name,
cmd=cmd,
template=project_template)
else:
templatetools.usage_error(
_("No template or command provided to %s command.") %
cmd.name,
cmd=cmd)
# At least one argument. What is it? First check if it's a command if we already have a template
if project_template:
command = commands.get_command(command_args[0], project_template)
if command:
command_args.insert(0,
project_template) # use default template
elif not command and not check_template_exists(command_args[0]):
# Wasn't a command or a template name, but we are in the context of a template
templatetools.usage_error(
_("No %s command found in %s template.") %
(command_args[0], project_template),
cmd=cmd,
template=project_template)
if not command:
# must be a template name then (or nonsense)
if not check_template_exists(command_args[0]):
command = commands.get_command(
command_args[0]
) # did user provid a valid builtin command?
if command:
command_args.insert(0, 'builtins')
elif len(command_args) == 1:
templatetools.usage_error(
_("%s is neither a template nor a standard command.") %
(command_args[0]),
cmd=cmd)
else:
templatetools.usage_error(
_("Template %s does not exist.") % (command_args[0]),
cmd=cmd,
show_templates_for=None)
project_template = command_args[0]
# OK, we have a template!
if len(command_args) < 2:
templatetools.usage_error(
_("No command provided to %s command.") % cmd.name,
cmd=cmd,
template=project_template)
command = commands.get_command(command_args[1], project_template)
if not command:
templatetools.usage_error(
_("No %s command found in %s template.") %
(command_args[1], project_template),
cmd=cmd,
template=project_template)
elif cmd.followed_by_template:
if len(command_args) > 0:
if check_template_exists(command_args[0]):
project_template = command_args[0]
if not project_template:
templatetools.usage_error(
_("No template provided to %s command.") % cmd.name, cmd=cmd)
elif cmd.followed_by_command:
if len(command_args) > 0:
command = commands.get_command(command_args[0], project_template)
if not command:
templatetools.usage_error(_("No %s command found.") %
command_args[0],
cmd=cmd,
template=project_template)
if not command:
templatetools.usage_error(_("No command provided to %s command.") %
cmd.name,
cmd=cmd,
template=project_template)
return command_args
def whisp_client(self, message, client):
cmd = commands.get_command("Whisper", self, self.server_client,
[client.name, message])
cmd.execute()
valid_data = process_data(data)
except Exception as e:
continue
if not valid_data:
continue
print(data)
for ircmsg in process_data(data):
if "PING :" in ircmsg:
ircsock.send(bytes("PONG :ping\n", 'UTF-8'))
elif "/QUOTE PONG" in ircmsg:
confirm = "PONG " + ircmsg.split()[-1:][0] + "\r\n"
ircsock.send(bytes(confirm, 'UTF-8'))
for channel in channel_list:
joinchan(channel)
time.sleep(.5)
elif any(channel in ircmsg for channel in channel_list):
try:
args = parsemsg(str(ircmsg))
channel = args['channel']
if "|" in args["args"]:
pipe_commands(args, channel)
else:
cmd = get_command(args["command"])
try:
sendmsg(channel, cmd(args))
except Exception as e:
print(e)
sendmsg(channel, (str(e)))
except Exception as e:
pass
def stop(self):
"""Warns the connected client that the server is going down then close all connection"""
logging.info("Server stopped")
cmd = commands.get_command("Broadcast", self, self.server_client, ["I AM GOING DOWN."])
cmd.execute()
self.kill()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
time.sleep(.5)
s.connect((server, port))
time.sleep(.5)
ircsock = ssl.wrap_socket(s)
time.sleep(.5)
ircsock.send(bytes("USER %s %s %s :some stuff\n" % (botnick, botnick, botnick), 'UTF-8'))
time.sleep(.5)
ircsock.send(bytes("NICK %s\n" % botnick, 'UTF-8'))
time.sleep(.5)
joinchan(channel)
while True:
data = ircsock.recv(1024)
for ircmsg in process_data(data):
if "PING :" in ircmsg:
ircsock.send(bytes("PONG :ping\n", 'UTF-8'))
elif channel in ircmsg:
args = parsemsg(str(ircmsg))
if "|" in args["args"]:
pipe_commands(args, channel)
else:
cmd = get_command(args["command"])
try:
sendmsg(channel, cmd(args))
except Exception as e:
print(e)
sendmsg(channel, (str(e)))
else:
continue
def whisp_client(self, message, client):
cmd = commands.get_command("Whisper",self, self.server_client, [client.name, message])
cmd.execute()
CMD_DICT_ARGS = {'group': group_bookmarks, 'add': add_bookmarks, 'delete':del_bookmarks}
CMD_DICT = {'open':open_bookmarks, 'list': list_bookmarks}
def run_command(cmd, cmd_string):
"""Run the command entered by the user.
Args:
cmd (str): This is the command, e.g. group
cmd_string (str): The parameters of the command
Returns:
None
"""
cmd = cmd.lower()
if cmd in CMD_DICT_ARGS:
func = CMD_DICT_ARGS[cmd]
func(cmd_string)
elif cmd in CMD_DICT:
func = CMD_DICT[cmd]
func()
else:
print_usage()
if __name__ == '__main__':
if not sys.argv[1:]:
print_usage()
exit()
else:
(cmd, cmd_string) = get_command(sys.argv)
run_command(cmd, cmd_string)
