def parse_user_option(option, option_str, value, parser):
"""Callback to parser -u/--user option
Translate uuid <-> email and add 'user_id' and 'user_email' to command
options.
"""
astakos = astakosclient.AstakosClient(settings.CYCLADES_SERVICE_TOKEN,
settings.ASTAKOS_AUTH_URL,
retry=2)
try:
if "@" in value:
email = value
uuid = astakos.service_get_uuid(email)
else:
uuid = value
email = astakos.service_get_username(uuid)
except astakosclient.errors.NoUUID:
raise OptionValueError("User with email %r does not exist" % email)
except astakosclient.errors.NoUserName:
raise OptionValueError("User with uuid %r does not exist" % uuid)
except astakosclient.errors.AstakosClientException as e:
raise OptionValueError("Failed to get user info:\n%r" % e)
setattr(parser.values, 'user_id', uuid)
setattr(parser.values, 'user_email', email)
def logout(request):
"""Logout view."""
admin_log(request)
auth_token = request.user['access']['token']['id']
ac = astakosclient.AstakosClient(auth_token, settings.ASTAKOS_AUTH_URL,
retry=2, use_pool=True, logger=logger)
logout_url = ac.ui_url + '/logout'
return HttpResponseRedirect(logout_url)
def test_usernames2uuids(self, orig_astakos, validate, resolve, get_uuids):
import astakosclient
self.client._uuids['t1'] = 'uuid 0'
self.client._astakos['uuid 0'] = astakosclient.AstakosClient(
self.url, self.token)
self.client._usernames2uuids['uuid 0'] = dict(name0='uuid 0')
exp = dict()
for i in range(3):
exp['name%s' % i] = 'uuid %s' % i
self.assertEqual(
exp, self.client.usernames2uuids(['name1', 'name2'], 'dont care'))
resolve.assert_called_once_with('dont care')
validate.assert_called_once_with('t1')
get_uuids.assert_called_once_with(['name1', 'name2'])
def search_by_ip(request, search_query):
"""Search IP history for all uses of an IP address."""
auth_token = request.user['access']['token']['id']
astakos_client = astakosclient.AstakosClient(auth_token,
settings.ASTAKOS_AUTH_URL,
retry=2,
use_pool=True,
logger=logger)
ips = IPAddressLog.objects.filter(address=search_query)\
.order_by("allocated_at")
for ip in ips:
# Annotate IPs with the VM, Network and account attributes
ip.vm = VirtualMachine.objects.get(id=ip.server_id)
ip.network = Network.objects.get(id=ip.network_id)
userid = ip.vm.userid
try:
ip.account = astakos_client.get_username(userid)
except:
ip.account = userid
logger.info("Failed to resolve '%s' into account" % userid)
user_context = {
'ip_exists': bool(ips),
'is_ip': True,
'ips': ips,
'search_query': search_query,
'token': auth_token,
'HELPDESK_MEDIA_URL': HELPDESK_MEDIA_URL,
'UI_MEDIA_URL': UI_MEDIA_URL
}
return direct_to_template(request,
"helpdesk/ip.html",
extra_context=user_context)
def account(request, search_query):
"""
Account details view.
"""
logging.info("Helpdesk search by %s: %s", request.user_uniq, search_query)
show_deleted = bool(int(request.GET.get('deleted', SHOW_DELETED_VMS)))
account_exists = True
# flag to indicate successfull astakos calls
account_resolved = False
vms = []
networks = []
is_ip = IP_SEARCH_REGEX.match(search_query)
is_uuid = UUID_SEARCH_REGEX.match(search_query)
is_vm = VM_SEARCH_REGEX.match(search_query)
account_name = search_query
auth_token = request.user.get('auth_token')
if is_ip:
try:
nic = NetworkInterface.objects.get(ipv4=search_query)
search_query = nic.machine.userid
is_uuid = True
except NetworkInterface.DoesNotExist:
account_exists = False
account = None
if is_vm:
vmid = is_vm.groupdict().get('vmid')
try:
vm = VirtualMachine.objects.get(pk=int(vmid))
search_query = vm.userid
is_uuid = True
except VirtualMachine.DoesNotExist:
account_exists = False
account = None
search_query = vmid
astakos_client = astakosclient.AstakosClient(settings.ASTAKOS_BASE_URL,
retry=2, use_pool=True,
logger=logger)
account = None
if is_uuid:
account = search_query
try:
account_name = astakos_client.get_username(auth_token, account)
except:
logger.info("Failed to resolve '%s' into account" % account)
if account_exists and not is_uuid:
account_name = search_query
try:
account = astakos_client.get_uuid(auth_token, account_name)
except:
logger.info("Failed to resolve '%s' into account" % account_name)
if not account:
account_exists = False
else:
account_resolved = True
filter_extra = {}
if not show_deleted:
filter_extra['deleted'] = False
# all user vms
vms = VirtualMachine.objects.filter(userid=account,
**filter_extra).order_by('deleted')
# return all user private and public networks
public_networks = Network.objects.filter(public=True,
nics__machine__userid=account,
**filter_extra
).order_by('state').distinct()
private_networks = Network.objects.filter(userid=account,
**filter_extra).order_by('state')
networks = list(public_networks) + list(private_networks)
if vms.count() == 0 and private_networks.count() == 0 and not \
account_resolved:
account_exists = False
user_context = {
'account_exists': account_exists,
'is_ip': is_ip,
'is_vm': is_vm,
'is_uuid': is_uuid,
'account': account,
'search_query': search_query,
'vms': vms,
'show_deleted': show_deleted,
'account_name': account_name,
'token': request.user['auth_token'],
'networks': networks,
'HELPDESK_MEDIA_URL': HELPDESK_MEDIA_URL,
'UI_MEDIA_URL': UI_MEDIA_URL
}
return direct_to_template(request, "helpdesk/account.html",
extra_context=user_context)
