def test_execute(self):
"""
Test the execute method.
"""
#test invalid configuration
connector = ElfinderConnector({})
self.assertEqual(
ElfinderErrorMessages.ERROR_CONF
in connector.execute('open')['error'], True)
connector = ElfinderConnector(
ls.ELFINDER_CONNECTOR_OPTION_SETS['default'])
#test invalid command
self.assertEqual(
ElfinderErrorMessages.ERROR_UNKNOWN_CMD
in connector.execute('dummy')['error'], True)
#test missing arguments
self.assertEqual(
ElfinderErrorMessages.ERROR_INV_PARAMS
in connector.execute('ls')['error'], True)
#test it is actually doing something
self.assertEqual(
'error' in connector.execute('open', mimes=['image'], init=True),
False)
#test debug keyword
self.assertEqual('debug' in connector.execute('open', init=True),
False)
self.assertEqual(
'debug' in connector.execute('open', init=True, debug=True), True)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
if kwargs['optionset'] == 'sftp':
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][0]['storageKwArgs'] = {
'host': '127.0.0.1',
'params': settings.SFTP_CONF,
'root_path': settings.MEDIA_ROOT+'/playbook',
'interactive': False
}
self.elfinder = ElfinderConnector(optinon_sets, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
cmd = self.get_command(request.POST)
if cmd not in ['upload']:
self.render_to_response(
{
'error': self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE
)
}
)
return self.output(cmd, request.POST)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
if kwargs['optionset'] == 'sftp':
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][0]['storageKwArgs'] = {
'host': '127.0.0.1',
'params': {
'port': 22,
'username': '******',
'password': '******',
'timeout': 30
},
'root_path': '/',
'interactive': False
}
self.elfinder = ElfinderConnector(optinon_sets, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({
'error':
self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)
})
return self.output(cmd, request.POST)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
u_id = str(uuid.uuid4())
if kwargs['optionset'] == 'sftp':
kwargs['u_id'] = u_id
server_object = get_object_or_404(ServerInfor,hostname=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(server_object.name,server_object.ip)
key_label = "%s::%s" % (server_object.ip, server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {'host':server_object.ip,
'params':{'port':server_object.credential.port,
'username':server_object.credential.username,
'password':server_object.credential.password,
'timeout':30},
'root_path':'/','interactive':False,
'key_label': key_label}
else:
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {'host':server_object.ip,
'params':{'port':server_object.credential.port,
'username':server_object.credential.username,
'key_filename':server_object.credential.key,
'timeout':30},
'root_path':'/','interactive':False,
'key_label': key_label}
self.elfinder = ElfinderConnector(optinon_sets, u_id, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), u_id, request.session)
return self.output(self.get_command(request.GET), request.GET)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
request.session)
return self.output(self.get_command(request.GET), request.GET)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
u_id = str(uuid.uuid4())
if kwargs['optionset'] == 'sftp':
kwargs['u_id'] = u_id
server_object = get_object_or_404(ServerInfor,
hostname=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(
server_object.name, server_object.ip)
key_label = "%s::%s" % (server_object.ip,
server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'password': server_object.credential.password,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
else:
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'key_filename': server_object.credential.key,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
u_id, request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({
'error':
self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)
})
return self.output(cmd, request.POST)
def test_open_startpath(self):
"""
Test startpath option
"""
self.opts['roots'][0]['startPath'] = 'files'
connector = ElfinderConnector(self.opts)
#************ init without tree ***********
ret = connector.execute('open', target='dummy', init='1')
#check files and cwd
self.assertEqual(len(ret['files']), 2)
self.assertNotEqual(ret['files'][0]['hash'], ret['files'][1]['hash'])
self.assertEqual(ret['files'][0]['name'], '2bytes.txt')
self.assertEqual(ret['files'][1]['name'], 'directory')
self.assertEqual(ret['cwd']['dirs'], 1)
self.assertEqual(ret['cwd']['name'], 'files')
self.assertEqual(ret['cwd']['read'], 1)
self.assertEqual(ret['cwd']['write'], 1)
self.assertEqual(ret['cwd']['locked'], 0)
self.assertEqual(ret['cwd']['hidden'], 0)
self.assertEqual(ret['cwd']['size'], 'unknown')
self.assertEqual(ret['cwd']['mime'], 'directory')
self.assertNotIn('volumeid', ret['cwd'])
self.assertIsInstance(ret['cwd']['ts'], float)
self.assertGreater(len(ret['cwd']['phash']), 0)
self.assertGreater(len(ret['cwd']['hash']), 0)
#other response attributes
self.assertNotIn('error', ret)
self.assertIn('netDrivers', ret)
self.assertEqual(ret['uplMaxSize'], 128 * 1048576)
self.assertEqual(ret['api'], '2.1')
self.assertEqual(ret['options']['pathUrl'],
'%sfiles' % settings.MEDIA_URL)
self.assertEqual(ret['options']['tmbUrl'],
'%s.tmb/' % settings.MEDIA_URL)
self.assertIn('create', ret['options']['archivers'])
self.assertIn('extract', ret['options']['archivers'])
self.assertEqual(ret['options']['disabled'], [])
self.assertEqual(ret['options']['copyOverwrite'], 1)
self.assertEqual(ret['options']['separator'], os.sep)
self.assertEqual(ret['options']['path'],
'%s%sfiles' % (connector._default._root_name, os.sep))
#********* init with tree ***********
ret_tree = connector.execute('open',
target='dummy',
init='1',
tree='1')
self.check_root_tree(ret_tree, 5, connector._default._root_name)
#cleanup startpath
self.opts['startpath'] = ''
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
if kwargs['optionset'] == 'sftp':
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][0]['storageKwArgs'] = {'host':'127.0.0.1','params':settings.SFTP_CONF,'root_path':settings.MEDIA_ROOT+'/playbook','interactive':False}
self.elfinder = ElfinderConnector(optinon_sets, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
return self.output(self.get_command(request.GET), request.GET)
def test_open_startpath(self):
"""
Test startpath option
"""
self.opts['roots'][0]['startPath'] = 'files'
connector = ElfinderConnector(self.opts)
#************ init without tree ***********
ret = connector.execute('open', target='dummy', init='1')
#check files and cwd
self.assertEqual(len(ret['files']), 2)
self.assertNotEqual(ret['files'][0]['hash'], ret['files'][1]['hash'])
self.assertEqual(ret['files'][0]['name'], '2bytes.txt')
self.assertEqual(ret['files'][1]['name'], 'directory')
self.assertEqual(ret['cwd']['dirs'], 1)
self.assertEqual(ret['cwd']['name'], 'files')
self.assertEqual(ret['cwd']['read'], 1)
self.assertEqual(ret['cwd']['write'], 1)
self.assertEqual(ret['cwd']['locked'], 0)
self.assertEqual(ret['cwd']['hidden'], 0)
self.assertEqual(ret['cwd']['size'], 'unknown')
self.assertEqual(ret['cwd']['mime'], 'directory')
self.assertNotIn('volumeid', ret['cwd'])
self.assertIsInstance(ret['cwd']['ts'], float)
self.assertGreater(len(ret['cwd']['phash']), 0)
self.assertGreater(len(ret['cwd']['hash']), 0)
#other response attributes
self.assertNotIn('error', ret)
self.assertIn('netDrivers', ret)
self.assertEqual(ret['uplMaxSize'], 128 * 1048576)
self.assertEqual(ret['api'], '2.0')
self.assertEqual(ret['options']['pathUrl'], '%sfiles' % settings.MEDIA_URL)
self.assertEqual(ret['options']['tmbUrl'], '%s.tmb/' % settings.MEDIA_URL)
self.assertIn('create', ret['options']['archivers'])
self.assertIn('extract', ret['options']['archivers'])
self.assertEqual(ret['options']['disabled'], [])
self.assertEqual(ret['options']['copyOverwrite'], 1)
self.assertEqual(ret['options']['separator'], os.sep)
self.assertEqual(ret['options']['path'], '%s%sfiles' % (connector._default._root_name, os.sep))
#********* init with tree ***********
ret_tree = connector.execute('open', target='dummy', init='1', tree='1')
self.check_root_tree(ret_tree, 5, connector._default._root_name)
#cleanup startpath
self.opts['startpath'] = ''
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
if kwargs['optionset'] == 'sftp':
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][0]['storageKwArgs'] = {'host':'127.0.0.1','params':settings.SFTP_CONF,'root_path':settings.MEDIA_ROOT+'/playbook','interactive':False}
self.elfinder = ElfinderConnector(optinon_sets, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({'error' : self.elfinder.error(ElfinderErrorMessages.ERROR_UPLOAD, ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)})
return self.output(cmd, request.POST)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
if kwargs['optionset'] == 'sftp':
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][0]['storageKwArgs'] = {
'host': '127.0.0.1',
'params': settings.SFTP_CONF,
'root_path': settings.MEDIA_ROOT+'/playbook',
'interactive': False
}
self.elfinder = ElfinderConnector(optinon_sets, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
return self.output(self.get_command(request.GET), request.GET)
def test_open_path(self):
connector = ElfinderConnector(self.opts)
#************ init without tree ***********
ret = connector.execute('open',
target=connector._default.encode(
connector._default._join_path(
settings.MEDIA_ROOT,
connector._default._join_path(
'files', 'directory'))),
init='1')
#check files and cwd
self.assertEqual(len(ret['files']), 1)
self.assertEqual(ret['files'][0]['name'], 'yawd-logo.png')
self.assertNotIn('dirs', ret['cwd'])
self.assertEqual(ret['cwd']['name'], 'directory')
self.assertEqual(ret['cwd']['read'], 1)
self.assertEqual(ret['cwd']['write'], 1)
self.assertEqual(ret['cwd']['locked'], 0)
self.assertEqual(ret['cwd']['hidden'], 0)
self.assertEqual(ret['cwd']['size'], 'unknown')
self.assertEqual(ret['cwd']['mime'], 'directory')
self.assertNotIn('volumeid', ret['cwd'])
self.assertIsInstance(ret['cwd']['ts'], float)
self.assertGreater(len(ret['cwd']['phash']), 0)
self.assertGreater(len(ret['cwd']['hash']), 0)
#other response attributes
self.assertNotIn('error', ret)
self.assertIn('netDrivers', ret)
self.assertEqual(ret['uplMaxSize'], 128 * 1048576)
self.assertEqual(ret['api'], '2.1')
self.assertEqual(ret['options']['pathUrl'],
'%sfiles/directory' % settings.MEDIA_URL)
self.assertEqual(ret['options']['tmbUrl'],
'%s.tmb/' % settings.MEDIA_URL)
self.assertIn('create', ret['options']['archivers'])
self.assertIn('extract', ret['options']['archivers'])
self.assertEqual(ret['options']['disabled'], [])
self.assertEqual(ret['options']['copyOverwrite'], 1)
self.assertEqual(ret['options']['separator'], os.sep)
self.assertEqual(
ret['options']['path'], '%s%sfiles%sdirectory' %
(connector._default._root_name, os.sep, os.sep))
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({
'error':
self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)
})
return self.output(cmd, request.POST)
def test_init(self):
"""
Test the ElfinderConnector __init__ method
"""
#fault-tolerant initialization
connector = ElfinderConnector({})
self.assertEqual(connector.loaded(), False)
connector = ElfinderConnector({})
self.assertEqual(connector.loaded(), False)
#initialize with 'default' optionset
connector = ElfinderConnector(
ls.ELFINDER_CONNECTOR_OPTION_SETS['default'])
self.assertEqual(connector.loaded(), True)
def test_open_specs(self):
"""
Test the command compiles to the API specification
"""
connector = ElfinderConnector(self.opts)
#command accepts the specification arguments
argslist = connector.commandArgsList('open')
self.assertIn('target', argslist)
self.assertIn('init', argslist)
self.assertIn('tree', argslist)
self.assertIn('mimes', argslist)
#test invalid keyword arguments
self.assertEqual(ElfinderErrorMessages.ERROR_INV_PARAMS in connector.execute('open')['error'], True)
#test invalid target
self.assertEqual(ElfinderErrorMessages.ERROR_OPEN in connector.execute('open', target='dummy')['error'], True)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({'error' : self.elfinder.error(ElfinderErrorMessages.ERROR_UPLOAD, ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)})
return self.output(cmd, request.POST)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
if kwargs['optionset'] == 'sftp':
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][0]['storageKwArgs'] = {
'host': '127.0.0.1',
'params': {
'port': 22,
'username': '******',
'password': '******',
'timeout': 30
},
'root_path': '/',
'interactive': False
}
self.elfinder = ElfinderConnector(optinon_sets, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
request.session)
return self.output(self.get_command(request.GET), request.GET)
def test_open_path(self):
connector = ElfinderConnector(self.opts)
#************ init without tree ***********
ret = connector.execute('open', target=connector._default.encode(
connector._default._join_path(settings.MEDIA_ROOT,
connector._default._join_path('files', 'directory'))),
init='1')
#check files and cwd
self.assertEqual(len(ret['files']), 1)
self.assertEqual(ret['files'][0]['name'], 'yawd-logo.png')
self.assertNotIn('dirs', ret['cwd'])
self.assertEqual(ret['cwd']['name'], 'directory')
self.assertEqual(ret['cwd']['read'], 1)
self.assertEqual(ret['cwd']['write'], 1)
self.assertEqual(ret['cwd']['locked'], 0)
self.assertEqual(ret['cwd']['hidden'], 0)
self.assertEqual(ret['cwd']['size'], 'unknown')
self.assertEqual(ret['cwd']['mime'], 'directory')
self.assertNotIn('volumeid', ret['cwd'])
self.assertIsInstance(ret['cwd']['ts'], float)
self.assertGreater(len(ret['cwd']['phash']), 0)
self.assertGreater(len(ret['cwd']['hash']), 0)
#other response attributes
self.assertNotIn('error', ret)
self.assertIn('netDrivers', ret)
self.assertEqual(ret['uplMaxSize'], 128 * 1048576)
self.assertEqual(ret['api'], '2.0')
self.assertEqual(ret['options']['pathUrl'], '%sfiles/directory' % settings.MEDIA_URL)
self.assertEqual(ret['options']['tmbUrl'], '%s.tmb/' % settings.MEDIA_URL)
self.assertIn('create', ret['options']['archivers'])
self.assertIn('extract', ret['options']['archivers'])
self.assertEqual(ret['options']['disabled'], [])
self.assertEqual(ret['options']['copyOverwrite'], 1)
self.assertEqual(ret['options']['separator'], os.sep)
self.assertEqual(ret['options']['path'], '%s%sfiles%sdirectory' % (connector._default._root_name, os.sep, os.sep))
def test_open_specs(self):
"""
Test the command compiles to the API specification
"""
connector = ElfinderConnector(self.opts)
#command accepts the specification arguments
argslist = connector.commandArgsList('open')
self.assertIn('target', argslist)
self.assertIn('init', argslist)
self.assertIn('tree', argslist)
self.assertIn('mimes', argslist)
#test invalid keyword arguments
self.assertEqual(
ElfinderErrorMessages.ERROR_INV_PARAMS
in connector.execute('open')['error'], True)
#test invalid target
self.assertEqual(
ElfinderErrorMessages.ERROR_OPEN
in connector.execute('open', target='dummy')['error'], True)
def test_execute(self):
"""
Test the execute method.
"""
#test invalid configuration
connector = ElfinderConnector({})
self.assertEqual(ElfinderErrorMessages.ERROR_CONF in connector.execute('open')['error'], True)
connector = ElfinderConnector(ls.ELFINDER_CONNECTOR_OPTION_SETS['default'])
#test invalid command
self.assertEqual(ElfinderErrorMessages.ERROR_UNKNOWN_CMD in connector.execute('dummy')['error'], True)
#test missing arguments
self.assertEqual(ElfinderErrorMessages.ERROR_INV_PARAMS in connector.execute('ls')['error'], True)
#test it is actually doing something
self.assertEqual('error' in connector.execute('open', mimes=['image'], init=True), False)
#test debug keyword
self.assertEqual('debug' in connector.execute('open', init=True), False)
self.assertEqual('debug' in connector.execute('open', init=True, debug=True), True)
def test_init(self):
"""
Test the ElfinderConnector __init__ method
"""
#fault-tolerant initialization
connector = ElfinderConnector({})
self.assertEqual(connector.loaded(), False)
connector = ElfinderConnector({})
self.assertEqual(connector.loaded(), False)
#initialize with 'default' optionset
connector = ElfinderConnector(ls.ELFINDER_CONNECTOR_OPTION_SETS['default'])
self.assertEqual(connector.loaded(), True)
class ElfinderConnectorView(View):
"""
Default elfinder backend view
"""
def render_to_response(self, context, **kwargs):
"""
It returns a json-encoded response, unless it was otherwise requested
by the command operation
"""
if not settings.DEBUG and not self.request.is_ajax():
raise Http404
kwargs = {}
additional_headers = {}
#create response headers
if 'header' in context:
for key in context['header']:
if key == 'Content-Type':
kwargs['content_type'] = context['header'][key]
elif key.lower() == 'status':
kwargs['status'] = context['header'][key]
else:
additional_headers[key] = context['header'][key]
del context['header']
#return json if not header
if not 'content_type' in kwargs:
kwargs['content_type'] = 'application/json'
if 'pointer' in context: #return file
context['pointer'].seek(0)
kwargs['content'] = context['pointer'].read()
context['volume'].close(context['pointer'], context['info']['hash'])
elif 'raw' in context and context['raw'] and 'error' in context and context['error']: #raw error, return only the error list
kwargs['content'] = context['error']
elif kwargs['content_type'] == 'application/json': #return json
kwargs['content'] = json.dumps(context)
else: #return context as is!
kwargs['content'] = context
response = HttpResponse(**kwargs)
for key, value in additional_headers.items():
response[key] = value
return response
def output(self, cmd, src):
"""
Collect command arguments, operate and return self.render_to_response()
"""
args = {}
for name in self.elfinder.commandArgsList(cmd):
if name == 'request':
args['request'] = self.request
elif name == 'FILES':
args['FILES'] = self.request.FILES
elif name == 'targets':
args[name] = src.getlist('targets[]')
else:
arg = name
if name.endswith('_'):
name = name[:-1]
if name in src:
try:
args[arg] = src.get(name).strip()
except:
args[arg] = src.get(name)
args['debug'] = src['debug'] if 'debug' in src else False
return self.render_to_response(self.elfinder.execute(cmd, **args))
def get_command(self, src):
"""
Get requested command
"""
try:
return src['cmd']
except KeyError:
return 'open'
def get_optionset(self, **kwargs):
set_ = ls.ELFINDER_CONNECTOR_OPTION_SETS[kwargs['optionset']].copy()
if kwargs['start_path'] != 'default':
for root in set_['roots']:
root['startPath'] = kwargs['start_path']
return set_
@method_decorator(staff_member_required)
@method_decorator(csrf_exempt)
def dispatch(self, *args, **kwargs):
if not kwargs['optionset'] in ls.ELFINDER_CONNECTOR_OPTION_SETS:
raise Http404
return super(ElfinderConnectorView, self).dispatch(*args, **kwargs)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
return self.output(self.get_command(request.GET), request.GET)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({'error' : self.elfinder.error(ElfinderErrorMessages.ERROR_UPLOAD, ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)})
return self.output(cmd, request.POST)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), request.session)
return self.output(self.get_command(request.GET), request.GET)
def test_open_default(self):
"""
Test the default optionset
"""
connector = ElfinderConnector(self.opts)
#************ init without tree ***********
ret = connector.execute('open', target='dummy', init='1')
#check files and cwd
self.assertEqual(len(ret['files']), 2)
self.assertNotEqual(ret['files'][0]['hash'], ret['files'][1]['hash'])
self.assertEqual(ret['files'][0]['name'], 'files')
self.assertEqual(ret['files'][1]['name'], 'test')
self.assertEqual(ret['cwd']['dirs'], 1)
self.assertEqual(ret['cwd']['name'], connector._default._root_name)
self.assertEqual(ret['cwd']['read'], 1)
self.assertEqual(ret['cwd']['write'], 1)
self.assertEqual(ret['cwd']['locked'], 1)
self.assertEqual(ret['cwd']['hidden'], 0)
self.assertEqual(ret['cwd']['size'], 'unknown')
self.assertEqual(ret['cwd']['mime'], 'directory')
self.assertEqual(ret['cwd']['volumeid'], 'llff_')
self.assertIsInstance(ret['cwd']['ts'], float)
self.assertNotIn('phash', ret['cwd'])
self.assertGreater(len(ret['cwd']['hash']), 0)
#other response attributes
self.assertNotIn('error', ret)
self.assertIn('netDrivers', ret)
self.assertEqual(ret['uplMaxSize'], 128 * 1048576)
self.assertEqual(ret['api'], '2.0')
self.assertEqual(ret['options']['pathUrl'], settings.MEDIA_URL)
self.assertEqual(ret['options']['tmbUrl'], '%s.tmb/' % settings.MEDIA_URL)
self.assertIn('create', ret['options']['archivers'])
self.assertIn('extract', ret['options']['archivers'])
self.assertEqual(ret['options']['disabled'], [])
self.assertEqual(ret['options']['copyOverwrite'], 1)
self.assertEqual(ret['options']['separator'], os.sep)
self.assertEqual(ret['options']['path'], connector._default._root_name)
#********* init with tree ***********
ret_tree = connector.execute('open', target='dummy', init='1', tree='1')
self.check_root_tree(ret_tree, 3, connector._default._root_name)
ret['files'][:0] = [ret['cwd']]
self.assertEqual(ret, ret_tree)
#******** init with tree and debug *******
ret_tree_debug = connector.execute('open', target='dummy', init='1', tree='1', debug='1')
self.assertEqual(ret_tree_debug['debug']['connector'], 'yawd-elfinder')
self.assertEqual(ret_tree_debug['debug']['mountErrors'], [])
self.assertEqual(ret_tree_debug['debug']['upload'], '')
self.assertEqual(ret_tree_debug['debug']['volumes'], [{'id': 'llff_', 'name': 'localfilesystem'}])
self.assertIsInstance(ret_tree_debug['debug']['time'], float)
del ret_tree_debug['debug']
self.assertEqual(ret_tree, ret_tree_debug)
def test_open_default(self):
"""
Test the default optionset
"""
connector = ElfinderConnector(self.opts)
#************ init without tree ***********
ret = connector.execute('open', target='dummy', init='1')
#check files and cwd
self.assertEqual(len(ret['files']), 2)
self.assertNotEqual(ret['files'][0]['hash'], ret['files'][1]['hash'])
self.assertEqual(ret['files'][0]['name'], 'files')
self.assertEqual(ret['files'][1]['name'], 'test')
self.assertEqual(ret['cwd']['dirs'], 1)
self.assertEqual(ret['cwd']['name'], connector._default._root_name)
self.assertEqual(ret['cwd']['read'], 1)
self.assertEqual(ret['cwd']['write'], 1)
self.assertEqual(ret['cwd']['locked'], 1)
self.assertEqual(ret['cwd']['hidden'], 0)
self.assertEqual(ret['cwd']['size'], 'unknown')
self.assertEqual(ret['cwd']['mime'], 'directory')
self.assertEqual(ret['cwd']['volumeid'], 'llff_')
self.assertIsInstance(ret['cwd']['ts'], float)
self.assertNotIn('phash', ret['cwd'])
self.assertGreater(len(ret['cwd']['hash']), 0)
#other response attributes
self.assertNotIn('error', ret)
self.assertIn('netDrivers', ret)
self.assertEqual(ret['uplMaxSize'], 128 * 1048576)
self.assertEqual(ret['api'], '2.1')
self.assertEqual(ret['options']['pathUrl'], settings.MEDIA_URL)
self.assertEqual(ret['options']['tmbUrl'],
'%s.tmb/' % settings.MEDIA_URL)
self.assertIn('create', ret['options']['archivers'])
self.assertIn('extract', ret['options']['archivers'])
self.assertEqual(ret['options']['disabled'], [])
self.assertEqual(ret['options']['copyOverwrite'], 1)
self.assertEqual(ret['options']['separator'], os.sep)
self.assertEqual(ret['options']['path'], connector._default._root_name)
#********* init with tree ***********
ret_tree = connector.execute('open',
target='dummy',
init='1',
tree='1')
self.check_root_tree(ret_tree, 3, connector._default._root_name)
ret['files'][:0] = [ret['cwd']]
self.assertEqual(ret, ret_tree)
#******** init with tree and debug *******
ret_tree_debug = connector.execute('open',
target='dummy',
init='1',
tree='1',
debug='1')
self.assertEqual(ret_tree_debug['debug']['connector'], 'yawd-elfinder')
self.assertEqual(ret_tree_debug['debug']['mountErrors'], [])
self.assertEqual(ret_tree_debug['debug']['upload'], '')
self.assertEqual(ret_tree_debug['debug']['volumes'],
[{
'id': 'llff_',
'name': 'localfilesystem'
}])
self.assertIsInstance(ret_tree_debug['debug']['time'], float)
del ret_tree_debug['debug']
self.assertEqual(ret_tree, ret_tree_debug)
class ElfinderConnectorView(LoginRequiredMixin, PermissionRequiredMixin, View):
"""
Default elfinder backend view
"""
permission_required = 'common.can_filemanage_serverinfo'
raise_exception = True
def render_to_response(self, context, **kwargs):
"""
It returns a json-encoded response, unless it was otherwise requested
by the command operation
"""
kwargs = {}
additional_headers = {}
# create response headers
if 'header' in context:
for key in context['header']:
if key == 'Content-Type':
kwargs['content_type'] = context['header'][key]
elif key.lower() == 'status':
kwargs['status'] = context['header'][key]
else:
additional_headers[key] = context['header'][key]
del context['header']
# return json if not header
if not 'content_type' in kwargs:
kwargs['content_type'] = 'application/json'
if 'pointer' in context: # return file
if context['volume']._options.has_key('storage') and isinstance(
context['volume']._options['storage'], SFTPStorage):
# stream sftp file download
def file_iterator(file_name, chunk_size=32768):
while True:
c = file_name.read(chunk_size)
if c:
yield c
else:
context['volume'].close(context['pointer'],
context['info']['hash'])
# fix sftp open transfer not close session bug
if context['volume']._options.has_key(
'storage') and isinstance(
context['volume']._options['storage'],
SFTPStorage):
context['volume']._options[
'storage'].sftp.close()
break
the_file_name = additional_headers["Content-Location"]
response = StreamingHttpResponse(
file_iterator(context['pointer']))
response['Content-Type'] = 'application/octet-stream'
response[
'Content-Disposition'] = 'attachment;filename="{0}"'.format(
the_file_name)
return response
else:
context['pointer'].seek(0)
kwargs['content'] = context['pointer'].read()
context['volume'].close(context['pointer'],
context['info']['hash'])
# raw error, return only the error list
elif 'raw' in context and context[
'raw'] and 'error' in context and context['error']:
kwargs['content'] = context['error']
elif kwargs['content_type'] == 'application/json': # return json
kwargs['content'] = json.dumps(context)
else: # return context as is!
kwargs['content'] = context
response = HttpResponse(**kwargs)
for key, value in additional_headers.items():
response[key] = value
return response
@staticmethod
def handler_chunk(src, args):
"""
handler chunk parameter
"""
if "chunk" in src:
args['chunk_name'] = re.findall(r'(.*?).\d+_\d+.part$',
src['chunk'])[0]
first_chunk_flag = re.findall(r'.*?.(\d+)_\d+.part$',
src['chunk'])[0]
if int(first_chunk_flag) == 0:
args['is_first_chunk'] = True
else:
args['is_first_chunk'] = False
else:
args['chunk_name'] = False
args['is_first_chunk'] = False
def output(self, cmd, src):
"""
Collect command arguments, operate and return self.render_to_response()
"""
args = {}
cmd_args = self.elfinder.commandArgsList(cmd)
for name in cmd_args:
if name == 'request':
args['request'] = self.request
elif name == 'FILES':
args['FILES'] = self.request.FILES
elif name == 'targets':
args[name] = src.getlist('targets[]')
else:
arg = name
if name.endswith('_'):
name = name[:-1]
if name in src:
try:
args[arg] = src.get(name).strip()
except:
args[arg] = src.get(name)
if cmd == 'mkdir':
args['name'] = src.getlist(
'dirs[]') if 'dirs[]' in src else src.getlist('name')
elif cmd == "upload":
if 'upload_path[]' in src:
dir_path = src.getlist('upload_path[]')
if len(list(
set(dir_path))) == 1 and dir_path[0] == args['target']:
args['upload_path'] = False
self.handler_chunk(src, args)
else:
args['upload_path'] = dir_path
self.handler_chunk(src, args)
else:
args['upload_path'] = False
self.handler_chunk(src, args)
elif cmd == "size":
args['targets'] = src.getlist('targets[0]')
args['debug'] = src['debug'] if 'debug' in src else False
return self.render_to_response(self.elfinder.execute(cmd, **args))
def get_command(self, src):
"""
Get requested command
"""
try:
return src['cmd']
except KeyError:
return 'open'
def get_optionset(self, **kwargs):
set_ = ls.ELFINDER_CONNECTOR_OPTION_SETS[kwargs['optionset']]
if kwargs['start_path'] != 'default':
for root in set_['roots']:
root['startPath'] = kwargs['start_path']
temp_dict = copy.deepcopy(set_)
u_id_dict = {
'debug': temp_dict['debug'],
'roots': {
kwargs['u_id']: temp_dict['roots']
}
}
return u_id_dict
@method_decorator(csrf_exempt)
def dispatch(self, *args, **kwargs):
if not kwargs['optionset'] in ls.ELFINDER_CONNECTOR_OPTION_SETS:
raise Http404
return super(ElfinderConnectorView, self).dispatch(*args, **kwargs)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
u_id = str(uuid.uuid4())
kwargs['u_id'] = u_id
if kwargs['optionset'] == 'sftp':
server_object = get_object_or_404(ServerInfor,
id=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(
server_object.name, server_object.ip)
key_label = "%s::%s" % (server_object.ip,
server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'password': server_object.credential.password,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
else:
private_key = StringIO.StringIO(server_object.credential.key)
key = server_object.credential.key
if 'RSA' in key:
private_key = paramiko.RSAKey.from_private_key(private_key)
elif 'DSA' in key:
private_key = paramiko.DSSKey.from_private_key(private_key)
elif 'EC' in key:
private_key = paramiko.ECDSAKey.from_private_key(
private_key)
elif 'OPENSSH' in key:
private_key = paramiko.Ed25519Key.from_private_key(
private_key)
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'pkey': private_key,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
else:
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}_tmp_dir'.format(
request.user.username)
optinon_sets['roots'][u_id][0]['path'] = os.path.join(
settings.MEDIA_ROOT, request.user.username, 'Download')
optinon_sets['roots'][u_id][0]['URL'] = '{0}{1}/{2}/'.format(
settings.MEDIA_URL, request.user.username, 'Download')
mkdir_p(os.path.join(settings.MEDIA_ROOT, request.user.username))
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
return self.output(self.get_command(request.GET), request.GET)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
u_id = str(uuid.uuid4())
kwargs['u_id'] = u_id
if kwargs['optionset'] == 'sftp':
server_object = get_object_or_404(ServerInfor,
id=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(
server_object.name, server_object.ip)
key_label = "%s::%s" % (server_object.ip,
server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'password': server_object.credential.password,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
else:
private_key = StringIO.StringIO(server_object.credential.key)
key = server_object.credential.key
if 'RSA' in key:
private_key = paramiko.RSAKey.from_private_key(private_key)
elif 'DSA' in key:
private_key = paramiko.DSSKey.from_private_key(private_key)
elif 'EC' in key:
private_key = paramiko.ECDSAKey.from_private_key(
private_key)
elif 'OPENSSH' in key:
private_key = paramiko.Ed25519Key.from_private_key(
private_key)
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'pkey': private_key,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
else:
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}_tmp_dir'.format(
request.user.username)
optinon_sets['roots'][u_id][0]['path'] = os.path.join(
settings.MEDIA_ROOT, request.user.username, 'Download')
optinon_sets['roots'][u_id][0]['URL'] = '{0}{1}/{2}/'.format(
settings.MEDIA_URL, request.user.username, 'Download')
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({
'error':
self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)
})
return self.output(cmd, request.POST)
def set_elfinder(self, hostid, optinon_sets):
if hostid not in self.elfinder_sftps:
self.elfinder_sftps[hostid] = ElfinderConnector(optinon_sets)
cache.set('elfinder_%s' % hostid, 1, timeout=self.sftp_timeout)
return self.elfinder_sftps[hostid]
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
u_id = str(uuid.uuid4())
kwargs['u_id'] = u_id
if kwargs['optionset'] == 'sftp':
server_object = get_object_or_404(ServerInfor,
id=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(
server_object.name, server_object.ip)
key_label = "%s::%s" % (server_object.ip,
server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'password': server_object.credential.password,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
else:
private_key = StringIO(server_object.credential.key)
key = server_object.credential.key
if 'RSA' in key:
private_key = paramiko.RSAKey.from_private_key(private_key)
elif 'DSA' in key:
private_key = paramiko.DSSKey.from_private_key(private_key)
elif 'EC' in key:
private_key = paramiko.ECDSAKey.from_private_key(
private_key)
elif 'OPENSSH' in key:
private_key = paramiko.Ed25519Key.from_private_key(
private_key)
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'pkey': private_key,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
else:
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}_tmp_dir'.format(
request.user.username)
optinon_sets['roots'][u_id][0]['path'] = os.path.join(
settings.MEDIA_ROOT, request.user.username, 'Download')
optinon_sets['roots'][u_id][0]['URL'] = '{0}{1}/{2}/'.format(
settings.MEDIA_URL, request.user.username, 'Download')
mkdir_p(os.path.join(settings.MEDIA_ROOT, request.user.username))
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
return self.output(self.get_command(request.GET), request.GET)
class ElfinderConnectorView(View):
"""
Default elfinder backend view
"""
def render_to_response(self, context, **kwargs):
"""
It returns a json-encoded response, unless it was otherwise requested
by the command operation
"""
if not settings.DEBUG and not self.request.is_ajax():
raise Http404
kwargs = {}
additional_headers = {}
#create response headers
if 'header' in context:
for key in context['header']:
if key == 'Content-Type':
kwargs['content_type'] = context['header'][key]
elif key.lower() == 'status':
kwargs['status'] = context['header'][key]
else:
additional_headers[key] = context['header'][key]
del context['header']
#return json if not header
if not 'content_type' in kwargs:
kwargs['content_type'] = 'application/json'
if 'pointer' in context: #return file
context['pointer'].seek(0)
kwargs['content'] = context['pointer'].read()
context['volume'].close(context['pointer'],
context['info']['hash'])
elif 'raw' in context and context[
'raw'] and 'error' in context and context[
'error']: #raw error, return only the error list
kwargs['content'] = context['error']
elif kwargs['content_type'] == 'application/json': #return json
kwargs['content'] = json.dumps(context)
else: #return context as is!
kwargs['content'] = context
response = HttpResponse(**kwargs)
for key, value in additional_headers.items():
response[key] = value
return response
def output(self, cmd, src):
"""
Collect command arguments, operate and return self.render_to_response()
"""
args = {}
for name in self.elfinder.commandArgsList(cmd):
if name == 'request':
args['request'] = self.request
elif name == 'FILES':
args['FILES'] = self.request.FILES
elif name == 'targets':
args[name] = src.getlist('targets[]')
else:
arg = name
if name.endswith('_'):
name = name[:-1]
if name in src:
try:
args[arg] = src.get(name).strip()
except:
args[arg] = src.get(name)
args['debug'] = src['debug'] if 'debug' in src else False
return self.render_to_response(self.elfinder.execute(cmd, **args))
def get_command(self, src):
"""
Get requested command
"""
try:
return src['cmd']
except KeyError:
return 'open'
def get_optionset(self, **kwargs):
set_ = ls.ELFINDER_CONNECTOR_OPTION_SETS[kwargs['optionset']]
if kwargs['start_path'] != 'default':
for root in set_['roots']:
root['startPath'] = kwargs['start_path']
return set_
@method_decorator(staff_member_required)
@method_decorator(csrf_exempt)
def dispatch(self, *args, **kwargs):
if not kwargs['optionset'] in ls.ELFINDER_CONNECTOR_OPTION_SETS:
raise Http404
return super(ElfinderConnectorView, self).dispatch(*args, **kwargs)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
request.session)
return self.output(self.get_command(request.GET), request.GET)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs),
request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({
'error':
self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)
})
return self.output(cmd, request.POST)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
u_id = str(uuid.uuid4())
kwargs['u_id'] = u_id
if kwargs['optionset'] == 'sftp':
server_object = get_object_or_404(ServerInfor,
id=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(
server_object.name, server_object.ip)
key_label = "%s::%s" % (server_object.ip,
server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'password': server_object.credential.password,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
else:
private_key = StringIO.StringIO(server_object.credential.key)
key = server_object.credential.key
if 'RSA' in key:
private_key = paramiko.RSAKey.from_private_key(private_key)
elif 'DSA' in key:
private_key = paramiko.DSSKey.from_private_key(private_key)
elif 'EC' in key:
private_key = paramiko.ECDSAKey.from_private_key(
private_key)
elif 'OPENSSH' in key:
private_key = paramiko.Ed25519Key.from_private_key(
private_key)
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {
'host': server_object.ip,
'params': {
'port': server_object.credential.port,
'username': server_object.credential.username,
'pkey': private_key,
'timeout': 30
},
'root_path': '/',
'interactive': False,
'key_label': key_label
}
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
else:
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}_tmp_dir'.format(
request.user.username)
optinon_sets['roots'][u_id][0]['path'] = os.path.join(
settings.MEDIA_ROOT, request.user.username, 'Download')
optinon_sets['roots'][u_id][0]['URL'] = '{0}{1}/{2}/'.format(
settings.MEDIA_URL, request.user.username, 'Download')
self.elfinder = ElfinderConnector(optinon_sets, u_id,
request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({
'error':
self.elfinder.error(
ElfinderErrorMessages.ERROR_UPLOAD,
ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)
})
return self.output(cmd, request.POST)
class ElfinderConnectorView(View):
"""
Default elfinder backend view
"""
def render_to_response(self, context, **kwargs):
"""
It returns a json-encoded response, unless it was otherwise requested
by the command operation
"""
kwargs = {}
additional_headers = {}
#create response headers
if 'header' in context:
for key in context['header']:
if key == 'Content-Type':
kwargs['content_type'] = context['header'][key]
elif key.lower() == 'status':
kwargs['status'] = context['header'][key]
else:
additional_headers[key] = context['header'][key]
del context['header']
#return json if not header
if not 'content_type' in kwargs:
kwargs['content_type'] = 'application/json'
if 'pointer' in context: #return file
context['pointer'].seek(0)
kwargs['content'] = context['pointer'].read()
context['volume'].close(context['pointer'], context['info']['hash'])
elif 'raw' in context and context['raw'] and 'error' in context and context['error']: #raw error, return only the error list
kwargs['content'] = context['error']
elif kwargs['content_type'] == 'application/json': #return json
kwargs['content'] = json.dumps(context)
else: #return context as is!
kwargs['content'] = context
response = HttpResponse(**kwargs)
for key, value in additional_headers.items():
response[key] = value
return response
@staticmethod
def handler_chunk(src, args):
"""
handler chunk parameter
"""
if "chunk" in src:
args['chunk_name'] = re.findall(r'(.*?).\d+_\d+.part$', src['chunk'])[0]
first_chunk_flag = re.findall(r'.*?.(\d+)_\d+.part$', src['chunk'])[0]
if int(first_chunk_flag) == 0:
args['is_first_chunk'] = True
else:
args['is_first_chunk'] = False
else:
args['chunk_name'] = False
args['is_first_chunk'] = False
def output(self, cmd, src):
"""
Collect command arguments, operate and return self.render_to_response()
"""
args = {}
cmd_args = self.elfinder.commandArgsList(cmd)
for name in cmd_args:
if name == 'request':
args['request'] = self.request
elif name == 'FILES':
args['FILES'] = self.request.FILES
elif name == 'targets':
args[name] = src.getlist('targets[]')
else:
arg = name
if name.endswith('_'):
name = name[:-1]
if name in src:
try:
args[arg] = src.get(name).strip()
except:
args[arg] = src.get(name)
if cmd == 'mkdir':
args['name'] = src.getlist('dirs[]') if 'dirs[]' in src else src.getlist('name')
elif cmd == "upload":
if 'upload_path[]' in src:
dir_path = src.getlist('upload_path[]')
if len(list(set(dir_path))) == 1 and dir_path[0] == args['target']:
args['upload_path'] = False
self.handler_chunk(src, args)
else:
args['upload_path'] = dir_path
self.handler_chunk(src, args)
else:
args['upload_path'] = False
self.handler_chunk(src, args)
elif cmd == "size":
args['targets'] = src.getlist('targets[0]')
args['debug'] = src['debug'] if 'debug' in src else False
return self.render_to_response(self.elfinder.execute(cmd, **args))
def get_command(self, src):
"""
Get requested command
"""
try:
return src['cmd']
except KeyError:
return 'open'
def get_optionset(self, **kwargs):
set_ = ls.ELFINDER_CONNECTOR_OPTION_SETS[kwargs['optionset']]
if kwargs['start_path'] != 'default':
for root in set_['roots']:
root['startPath'] = kwargs['start_path']
temp_dict = copy.deepcopy(set_)
u_id_dict = {'debug': temp_dict['debug'], 'roots': {kwargs['u_id']: temp_dict['roots']}}
return u_id_dict
@method_decorator(csrf_exempt)
def dispatch(self, *args, **kwargs):
if not kwargs['optionset'] in ls.ELFINDER_CONNECTOR_OPTION_SETS:
raise Http404
return super(ElfinderConnectorView, self).dispatch(*args, **kwargs)
def get(self, request, *args, **kwargs):
"""
used in get method calls
"""
u_id = str(uuid.uuid4())
if kwargs['optionset'] == 'sftp':
kwargs['u_id'] = u_id
server_object = get_object_or_404(ServerInfor,hostname=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(server_object.name,server_object.ip)
key_label = "%s::%s" % (server_object.ip, server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {'host':server_object.ip,
'params':{'port':server_object.credential.port,
'username':server_object.credential.username,
'password':server_object.credential.password,
'timeout':30},
'root_path':'/','interactive':False,
'key_label': key_label}
else:
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {'host':server_object.ip,
'params':{'port':server_object.credential.port,
'username':server_object.credential.username,
'key_filename':server_object.credential.key,
'timeout':30},
'root_path':'/','interactive':False,
'key_label': key_label}
self.elfinder = ElfinderConnector(optinon_sets, u_id, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), u_id, request.session)
return self.output(self.get_command(request.GET), request.GET)
def post(self, request, *args, **kwargs):
"""
called in post method calls.
It only allows for the 'upload' command
"""
u_id = str(uuid.uuid4())
if kwargs['optionset'] == 'sftp':
kwargs['u_id'] = u_id
server_object = get_object_or_404(ServerInfor,hostname=kwargs['start_path'])
optinon_sets = self.get_optionset(**kwargs)
optinon_sets['roots'][u_id][0]['alias'] = '{0}-{1}'.format(server_object.name,server_object.ip)
key_label = "%s::%s" % (server_object.ip, server_object.credential.username)
if server_object.credential.method == 'password':
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {'host':server_object.ip,
'params':{'port':server_object.credential.port,
'username':server_object.credential.username,
'password':server_object.credential.password,
'timeout':30},
'root_path':'/','interactive':False,
'key_label': key_label}
else:
optinon_sets['roots'][u_id][0]['storageKwArgs'] = {'host':server_object.ip,
'params':{'port':server_object.credential.port,
'username':server_object.credential.username,
'key_filename':server_object.credential.key,
'timeout':30},
'root_path':'/','interactive':False,
'key_label': key_label}
self.elfinder = ElfinderConnector(optinon_sets, u_id, request.session)
else:
self.elfinder = ElfinderConnector(self.get_optionset(**kwargs), u_id, request.session)
cmd = self.get_command(request.POST)
if not cmd in ['upload']:
self.render_to_response({'error' : self.elfinder.error(ElfinderErrorMessages.ERROR_UPLOAD, ElfinderErrorMessages.ERROR_UPLOAD_TOTAL_SIZE)})
return self.output(cmd, request.POST)
