def test_get_instance_nw_info(self):
self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
self.mox.StubOutWithMock(db, 'instance_type_get')
db.fixed_ip_get_by_instance(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(fixed_ips)
db.virtual_interface_get_by_instance(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(vifs)
db.instance_type_get(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(flavor)
self.mox.ReplayAll()
nw_info = self.network.get_instance_nw_info(None, 0, 0, None)
self.assertTrue(nw_info)
for i, nw in enumerate(nw_info):
i8 = i + 8
check = {'bridge': 'fa%s' % i,
'cidr': '192.168.%s.0/24' % i,
'cidr_v6': '2001:db%s::/64' % i8,
'id': i,
'multi_host': False,
'injected': 'DONTCARE',
'bridge_interface': 'fake_fa%s' % i,
'vlan': None}
self.assertDictMatch(nw[0], check)
check = {'broadcast': '192.168.%s.255' % i,
'dhcp_server': '192.168.%s.1' % i,
'dns': 'DONTCARE',
'gateway': '192.168.%s.1' % i,
'gateway6': '2001:db%s::1' % i8,
'ip6s': 'DONTCARE',
'ips': 'DONTCARE',
'label': 'test%s' % i,
'mac': 'DE:AD:BE:EF:00:0%s' % i,
'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' %
i),
'rxtx_cap': 'DONTCARE',
'should_create_vlan': False,
'should_create_bridge': False}
self.assertDictMatch(nw[1], check)
check = [{'enabled': 'DONTCARE',
'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i),
'netmask': '64'}]
self.assertDictListMatch(nw[1]['ip6s'], check)
check = [{'enabled': '1',
'ip': '192.168.%s.100' % i,
'netmask': '255.255.255.0'}]
self.assertDictListMatch(nw[1]['ips'], check)
def test_get_instance_nw_info(self):
self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
self.mox.StubOutWithMock(db, 'instance_type_get')
db.fixed_ip_get_by_instance(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(fixed_ips)
db.virtual_interface_get_by_instance(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(vifs)
db.instance_type_get(mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(flavor)
self.mox.ReplayAll()
nw_info = self.network.get_instance_nw_info(None, 0, 0, None)
self.assertTrue(nw_info)
for i, nw in enumerate(nw_info):
i8 = i + 8
check = {'bridge': 'fa%s' % i,
'cidr': '192.168.%s.0/24' % i,
'cidr_v6': '2001:db%s::/64' % i8,
'id': i,
'multi_host': False,
'injected': 'DONTCARE',
'bridge_interface': 'fake_fa%s' % i,
'vlan': None}
self.assertDictMatch(nw[0], check)
check = {'broadcast': '192.168.%s.255' % i,
'dhcp_server': '192.168.%s.1' % i,
'dns': 'DONTCARE',
'gateway': '192.168.%s.1' % i,
'gateway6': '2001:db%s::1' % i8,
'ip6s': 'DONTCARE',
'ips': 'DONTCARE',
'label': 'test%s' % i,
'mac': 'DE:AD:BE:EF:00:0%s' % i,
'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' %
i),
'rxtx_cap': 'DONTCARE',
'should_create_vlan': False,
'should_create_bridge': False}
self.assertDictMatch(nw[1], check)
check = [{'enabled': 'DONTCARE',
'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i),
'netmask': '64'}]
self.assertDictListMatch(nw[1]['ip6s'], check)
check = [{'enabled': '1',
'ip': '192.168.%s.100' % i,
'netmask': '255.255.255.0'}]
self.assertDictListMatch(nw[1]['ips'], check)
def delete(self, req, filesystem_id, id):
"""Detach an instance from a filesystem."""
fs_name = filesystem_id
instance_uuid = id
context = req.environ['nova.context']
instance = db.instance_get_by_uuid(context, instance_uuid)
if not instance:
msg = (_("Unable to find instance %s.") % instance_uuid)
raise webob.exc.HTTPNotFound(msg)
instance_id = instance.id
try:
ips = db.fixed_ip_get_by_instance(context, instance_id)
except exception.FixedIpNotFound:
msg = (_("Unable to get IP address for instance_id %s.") %
instance_id)
raise webob.exc.HTTPNotFound(msg)
for ip in ips:
LOG.debug(_("unattaching ip %(ip)s from filesystem %(fs)s.") %
{'ip': ip, 'fs': fs_name})
try:
self.fs_driver.unattach(fs_name, ip['address'])
except exception.NotAuthorized:
msg = _("Filesystem detachment not permitted.")
raise webob.exc.HTTPForbidden(msg)
return webob.Response(status_int=202)
def update(self, req, filesystem_id, id, body):
"""Attach an instance to a filesystem."""
fs_name = filesystem_id
instance_uuid = id
if body:
LOG.warning(_("Unexpected body: %s") % body)
raise webob.exc.HTTPUnprocessableEntity()
context = req.environ['nova.context']
instance = db.instance_get_by_uuid(context, instance_uuid)
if not instance:
msg = (_("Unable to find instance %s.") % instance_uuid)
raise webob.exc.HTTPNotFound(msg)
instance_id = instance.id
try:
fixed_ips = db.fixed_ip_get_by_instance(context, instance_id)
except exception.FixedIpNotFound:
msg = (_("Unable to get IP address for instance_id %s.") %
instance_id)
raise webob.exc.HTTPNotFound(msg)
for ip in fixed_ips:
LOG.debug(_("attaching ip %(ip)s to filesystem %(fs)s.") %
{'ip': ip['address'], 'fs': fs_name})
try:
self.fs_driver.attach(fs_name, ip['address'])
except exception.NotAuthorized:
msg = _("Filesystem attachment not permitted.")
raise webob.exc.HTTPForbidden(msg)
return _translate_instance_view(instance_uuid)
def get_network_info(instance):
# TODO(tr3buchet): this function needs to go away! network info
# MUST be passed down from compute
# TODO(adiantum) If we will keep this function
# we should cache network_info
admin_context = context.get_admin_context()
try:
fixed_ips = db.fixed_ip_get_by_instance(admin_context, instance['id'])
except exception.FixedIpNotFoundForInstance:
fixed_ips = []
vifs = db.virtual_interface_get_by_instance(admin_context, instance['id'])
flavor = db.instance_type_get(admin_context,
instance['instance_type_id'])
network_info = []
for vif in vifs:
network = vif['network']
# determine which of the instance's IPs belong to this network
network_ips = [fixed_ip['address'] for fixed_ip in fixed_ips if
fixed_ip['network_id'] == network['id']]
def ip_dict(ip):
return {
'ip': ip,
'netmask': network['netmask'],
'enabled': '1'}
def ip6_dict():
prefix = network['cidr_v6']
mac = vif['address']
project_id = instance['project_id']
return {
'ip': ipv6.to_global(prefix, mac, project_id),
'netmask': network['netmask_v6'],
'enabled': '1'}
mapping = {
'label': network['label'],
'gateway': network['gateway'],
'broadcast': network['broadcast'],
'dhcp_server': network['gateway'],
'mac': vif['address'],
'rxtx_cap': flavor['rxtx_cap'],
'dns': [],
'ips': [ip_dict(ip) for ip in network_ips]}
if network['dns1']:
mapping['dns'].append(network['dns1'])
if network['dns2']:
mapping['dns'].append(network['dns2'])
if FLAGS.use_ipv6:
mapping['ip6s'] = [ip6_dict()]
mapping['gateway6'] = network['gateway_v6']
network_info.append((network, mapping))
return network_info
def get_network_info(instance):
# TODO(tr3buchet): this function needs to go away! network info
# MUST be passed down from compute
# TODO(adiantum) If we will keep this function
# we should cache network_info
admin_context = context.get_admin_context()
try:
fixed_ips = db.fixed_ip_get_by_instance(admin_context, instance['id'])
except exception.FixedIpNotFoundForInstance:
fixed_ips = []
vifs = db.virtual_interface_get_by_instance(admin_context, instance['id'])
flavor = db.instance_type_get(admin_context, instance['instance_type_id'])
network_info = []
for vif in vifs:
network = vif['network']
# determine which of the instance's IPs belong to this network
network_ips = [
fixed_ip['address'] for fixed_ip in fixed_ips
if fixed_ip['network_id'] == network['id']
]
def ip_dict(ip):
return {'ip': ip, 'netmask': network['netmask'], 'enabled': '1'}
def ip6_dict():
prefix = network['cidr_v6']
mac = vif['address']
project_id = instance['project_id']
return {
'ip': ipv6.to_global(prefix, mac, project_id),
'netmask': network['netmask_v6'],
'enabled': '1'
}
mapping = {
'label': network['label'],
'gateway': network['gateway'],
'broadcast': network['broadcast'],
'dhcp_server': network['gateway'],
'mac': vif['address'],
'rxtx_cap': flavor['rxtx_cap'],
'dns': [],
'ips': [ip_dict(ip) for ip in network_ips]
}
if network['dns1']:
mapping['dns'].append(network['dns1'])
if network['dns2']:
mapping['dns'].append(network['dns2'])
if FLAGS.use_ipv6:
mapping['ip6s'] = [ip6_dict()]
mapping['gateway6'] = network['gateway_v6']
network_info.append((network, mapping))
return network_info
def list_vms(host=None):
"""
make a list of vms and expand out their fixed_ip and floating ips sensibly
"""
flags.parse_args([])
my_instances = []
if host is None:
instances = db.instance_get_all(context.get_admin_context())
else:
instances = db.instance_get_all_by_host(
context.get_admin_context(), host)
for instance in instances:
my_inst = {}
my_inst = dict(instance).copy()
for (k,v) in my_inst.items():
try:
json.encoder(v)
except TypeError, e:
v = str(v)
my_inst[k] = v
ec2_id = db.get_ec2_instance_id_by_uuid(context.get_admin_context(), instance.uuid)
ec2_id = 'i-' + hex(int(ec2_id)).replace('0x', '').zfill(8)
my_inst['ec2_id'] = ec2_id
try:
fixed_ips = db.fixed_ip_get_by_instance(context.get_admin_context(), instance.uuid)
except:
pass
my_inst['fixed_ips'] = [ ip.address for ip in fixed_ips ]
my_inst['floating_ips'] = []
for ip in fixed_ips:
my_inst['floating_ips'].extend([ f_ip.address for f_ip in db.floating_ip_get_by_fixed_address(context.get_admin_context(), ip.address)])
my_instances.append(my_inst)
def get_by_instance_uuid(cls, context, instance_uuid):
expected_attrs = ['network', 'virtual_interface', 'floating_ips']
db_fixedips = db.fixed_ip_get_by_instance(context, instance_uuid)
return obj_base.obj_make_list(context,
cls(context),
objects.FixedIP,
db_fixedips,
expected_attrs=expected_attrs)
def test_get_instance_nw_info(self):
self.mox.StubOutWithMock(db, "fixed_ip_get_by_instance")
self.mox.StubOutWithMock(db, "virtual_interface_get_by_instance")
self.mox.StubOutWithMock(db, "instance_type_get_by_id")
db.fixed_ip_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(fixed_ips)
db.virtual_interface_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(vifs)
db.instance_type_get_by_id(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(flavor)
self.mox.ReplayAll()
nw_info = self.network.get_instance_nw_info(None, 0, 0)
self.assertTrue(nw_info)
for i, nw in enumerate(nw_info):
i8 = i + 8
check = {
"bridge": "fa%s" % i,
"cidr": "192.168.%s.0/24" % i,
"cidr_v6": "2001:db%s::/64" % i8,
"id": i,
"injected": "DONTCARE",
}
self.assertDictMatch(nw[0], check)
check = {
"broadcast": "192.168.%s.255" % i,
"dns": "DONTCARE",
"gateway": "192.168.%s.1" % i,
"gateway6": "2001:db%s::1" % i8,
"ip6s": "DONTCARE",
"ips": "DONTCARE",
"label": "test%s" % i,
"mac": "DE:AD:BE:EF:00:0%s" % i,
"rxtx_cap": "DONTCARE",
}
self.assertDictMatch(nw[1], check)
check = [{"enabled": "DONTCARE", "ip": "2001:db%s::dcad:beff:feef:%s" % (i8, i), "netmask": "64"}]
self.assertDictListMatch(nw[1]["ip6s"], check)
check = [{"enabled": "1", "ip": "192.168.%s.100" % i, "netmask": "255.255.255.0"}]
self.assertDictListMatch(nw[1]["ips"], check)
def update(self, req, id, body):
"""Add new filesystem."""
name = id
try:
entry = body['fs_entry']
size = entry['size']
scope = entry['scope']
except (TypeError, KeyError):
raise webob.exc.HTTPUnprocessableEntity()
if scope not in ['project', 'instance', 'global']:
LOG.error(_("scope must be one of project, instance, or global"))
raise webob.exc.HTTPUnprocessableEntity()
context = req.environ['nova.context']
project = context.project_id
try:
if self.has_db_support:
sharedfs_db.filesystem_add(context, name, scope, project)
self.fs_driver.create_fs(name, project, size)
except exception.NotAuthorized:
msg = _("Filesystem creation requires admin permissions.")
raise webob.exc.HTTPForbidden(msg)
if self.has_db_support:
# Attach global or project-wide shares immediately.
instance_list = []
if scope == 'global':
instance_list = db.instance_get_all(context)
elif scope == 'project':
instance_list = db.instance_get_all_by_project(context,
project)
for instance in instance_list:
try:
fixed_ips = db.fixed_ip_get_by_instance(context,
instance.id)
for ip in fixed_ips:
LOG.debug(_("attaching %(ip)s to filesystem %(fs)s.")
% {'ip': ip['address'], 'fs': name})
try:
self.fs_driver.attach(name, ip['address'])
except exception.NotAuthorized:
LOG.warning(_("Insufficient permissions to attach"
" %(instance)s to filesystem %(fs)s.") %
{'instance': instance.name, 'fs': name})
except exception.FixedIpNotFound:
LOG.warning(_("Unable to get IP address for %s.")
% instance.id)
return _translate_fs_entry_view({'name': name,
'size': size,
'scope': scope,
'project': project})
def refresh_instance_security_rules(self, instance):
LOG.debug(_('refresh iptables filter for instance %s') %
instance['id'])
self.do_refresh_instance_rules(instance)
self.iptables.apply()
if FLAGS.del_sec_rule_conntracks:
ctxt = context.get_admin_context()
fixed_ip = db.fixed_ip_get_by_instance(ctxt, instance['uuid'])
fip = fixed_ip[0]['address']
linux_net.del_conntrack_entries(fip)
def unattach(self, ctxt, instance_uuid, fs_name):
LOG.debug(_("unattaching %(instance)s from filesystem %(fs)s.") %
{'instance': instance_uuid, 'fs': fs_name})
instance = db.instance_get_by_uuid(ctxt, instance_uuid)
instance_id = instance.id
fixed_ips = db.fixed_ip_get_by_instance(ctxt, instance_id)
for ip in fixed_ips:
LOG.debug(_("auto unattaching %(ip)s from filesystem %(fs)s.") %
{'ip': ip['address'], 'fs': fs_name})
self.fs_driver.unattach(fs_name, ip['address'])
def delete(self, req, id):
"""Delete the filesystem identified by id."""
name = id
if self.has_db_support:
# Unattach global or project-wide shares immediately.
context = req.environ['nova.context']
fs_entry = sharedfs_db.filesystem_get(context, name)
if not fs_entry:
msg = _("Filesystem %s not found.") % name
raise webob.exc.HTTPNotFound(msg)
scope = fs_entry.scope
project = fs_entry.project_id
instance_list = []
if scope == 'global':
instance_list = db.instance_get_all(context)
elif scope == 'project':
instance_list = db.instance_get_all_by_project(context,
project)
for instance in instance_list:
try:
fixed_ips = db.fixed_ip_get_by_instance(context,
instance.id)
for ip in fixed_ips:
LOG.debug(_("unattaching %(ip)s from fs %(fs)s.") %
{'ip': ip['address'], 'fs': name})
try:
self.fs_driver.unattach(name, ip['address'])
except exception.NotAuthorized:
LOG.warning(_("Insufficient permission to unattach"
" %(instance)s from filesystem %(fs)s.") %
{'instance': instance.name,
'fs': name})
except exception.FixedIpNotFound:
LOG.warning(_("Unable to get IP address for %s.")
% instance.id)
sharedfs_db.filesystem_delete(context, name)
try:
self.fs_driver.delete_fs(name, project)
except exception.NotAuthorized:
msg = _("Filesystem deletion requires admin permissions.")
raise webob.exc.HTTPForbidden(msg)
except exception.NotFound:
msg = _("Filesystem %s does not exist.") % name
raise webob.exc.HTTPNotFound(msg)
return webob.Response(status_int=202)
def do_refresh_security_group_rules(self, security_group):
ctxt = context.get_admin_context()
res = []
for instance in self.instances.values():
self.remove_filters_for_instance(instance)
self.add_filters_for_instance(instance)
try:
fixed_ip = db.fixed_ip_get_by_instance(ctxt, instance['uuid'])
fip = fixed_ip[0]['address']
res.append(fip)
except Exception:
pass
return res
def list_vms(host=None):
"""
make a list of vms and expand out their fixed_ip and floating ips sensibly
"""
flags.parse_args([])
my_instances = []
if host is None:
instances = db.instance_get_all(context.get_admin_context())
else:
instances = db.instance_get_all_by_host(context.get_admin_context(),
host)
for instance in instances:
my_inst = {}
my_inst = dict(instance).copy()
for (k, v) in my_inst.items():
try:
json.encoder(v)
except TypeError, e:
v = str(v)
my_inst[k] = v
ec2_id = db.get_ec2_instance_id_by_uuid(context.get_admin_context(),
instance.uuid)
ec2_id = 'i-' + hex(int(ec2_id)).replace('0x', '').zfill(8)
my_inst['ec2_id'] = ec2_id
try:
fixed_ips = db.fixed_ip_get_by_instance(
context.get_admin_context(), instance.uuid)
except:
pass
my_inst['fixed_ips'] = [ip.address for ip in fixed_ips]
my_inst['floating_ips'] = []
for ip in fixed_ips:
my_inst['floating_ips'].extend([
f_ip.address for f_ip in db.floating_ip_get_by_fixed_address(
context.get_admin_context(), ip.address)
])
my_instances.append(my_inst)
def get_by_instance_uuid(cls, context, instance_uuid):
expected_attrs = ['network', 'virtual_interface', 'floating_ips']
db_fixedips = db.fixed_ip_get_by_instance(context, instance_uuid)
return obj_base.obj_make_list(context, cls(context),
objects.FixedIP, db_fixedips,
expected_attrs=expected_attrs)
def notify(self, message):
ctxt = context.get_admin_context()
event_type = message.get('event_type')
if event_type in FLAGS.wiki_eventtype_blacklist:
return
if event_type not in FLAGS.wiki_eventtype_whitelist:
LOG.debug("Ignoring message type %s" % event_type)
return
payload = message['payload']
instance_name = payload['display_name']
uuid = payload['instance_id']
if FLAGS.wiki_instance_dns_domain:
fqdn = "%s.%s" % (instance_name, FLAGS.wiki_instance_dns_domain)
else:
fqdn = instance_name
template_param_dict = {}
for field in self.RawTemplateFields:
template_param_dict[field] = payload[field]
tenant_id = payload['tenant_id']
if (FLAGS.wiki_use_keystone and
self._keystone_login(tenant_id, ctxt)):
tenant_obj = self.tenant_manager[tenant_id].get(tenant_id)
user_obj = self.user_manager[tenant_id].get(payload['user_id'])
tenant_name = tenant_obj.name
user_name = user_obj.name
template_param_dict['tenant'] = tenant_name
template_param_dict['username'] = user_name
inst = db.instance_get_by_uuid(ctxt, uuid)
old_school_id = inst.id
ec2_id = 'i-%08x' % old_school_id
template_param_dict['cpu_count'] = inst.vcpus
template_param_dict['disk_gb_current'] = inst.ephemeral_gb
template_param_dict['host'] = inst.host
template_param_dict['reservation_id'] = inst.reservation_id
template_param_dict['availability_zone'] = inst.availability_zone
template_param_dict['original_host'] = inst.launched_on
template_param_dict['fqdn'] = fqdn
template_param_dict['ec2_id'] = ec2_id
template_param_dict['project_name'] = inst.project_id
template_param_dict['region'] = FLAGS.wiki_instance_region
try:
fixed_ips = db.fixed_ip_get_by_instance(ctxt, old_school_id)
except exception.FixedIpNotFoundForInstance:
fixed_ips = []
ips = []
floating_ips = []
for fixed_ip in fixed_ips:
ips.append(fixed_ip.address)
for floating_ip in db.floating_ip_get_by_fixed_ip_id(ctxt, fixed_ip.id):
floating_ips.append(floating_ip.address)
template_param_dict['private_ip'] = ','.join(ips)
template_param_dict['public_ip'] = ','.join(floating_ips)
sec_groups = db.security_group_get_by_instance(ctxt, old_school_id)
grps = [grp.name for grp in sec_groups]
template_param_dict['security_group'] = ','.join(grps)
fields_string = ""
for key in template_param_dict:
fields_string += "\n|%s=%s" % (key, template_param_dict[key])
if event_type == 'compute.instance.delete.start':
page_string = "\n%s\nThis instance has been deleted.\n%s\n" % (begin_comment,
end_comment)
else:
page_string = "\n%s\n{{InstanceStatus%s}}\n%s\n" % (begin_comment,
fields_string,
end_comment)
self._wiki_login()
pagename = "%s%s" % (FLAGS.wiki_page_prefix, ec2_id)
LOG.debug("wikistatus: Writing instance info"
" to page http://%s/wiki/%s" %
(FLAGS.wiki_host, pagename))
page = self.site.Pages[pagename]
try:
pText = page.edit()
start_replace_index = pText.find(begin_comment)
if start_replace_index == -1:
# Just stick it at the end.
newText = "%s%s" % (page_string, pText)
else:
# Replace content between comment tags.
end_replace_index = pText.find(end_comment, start_replace_index)
if end_replace_index == -1:
end_replace_index = start_replace_index + len(begin_comment)
else:
end_replace_index += len(end_comment)
newText = "%s%s%s" % (pText[:start_replace_index],
page_string,
pText[end_replace_index:])
page.save(newText, "Auto update of instance info.")
except (mwclient.errors.InsufficientPermission,
mwclient.errors.LoginError):
LOG.debug("Failed to update wiki page..."
" trying to re-login next time.")
self._wiki_logged_in = False
def index(self, req):
"""Return all flavors in brief."""
#flavors = self._get_flavors(req)
#return self._view_builder.index(req, flavors)
project_id=str(req.environ['HTTP_X_TENANT_ID'])
context = req.environ['nova.context']
context = context.elevated()
networks = db.network_get_all(context)
nets=[dict(network.iteritems()) for network in networks]
virtual_interfaces = db.virtual_interface_get_all(context)
vifs=[dict(vif.iteritems()) for vif in virtual_interfaces]
#make a dict of relationships between Network_IDs and Instance_IDs {1:[1,2],...}
net_vm_dict = {}
for vif in vifs:
net_id=int(vif['network_id'])
vm_id=int(vif['instance_id'])
if net_id in net_vm_dict:
net_vm_dict[net_id].append(vm_id)
else:
net_vm_dict[net_id] = [vm_id]
print net_vm_dict
#Go through the dict , filter by this project and get detailed infos
#instance_get(context, instance_id)
net_list = []
for netID in net_vm_dict:
networks= db.network_get(context, netID)
net = dict(networks.iteritems())
print str(net['project_id'])
if net['project_id']==None or net['project_id']==project_id:
print "my precious~~"
net_info = {}
net_info['id']=str(net['uuid'])
net_info['name']=str(net['label'])
net_info['cidr']=str(net['cidr'])
net_info['vm']=[]
net_list.append(net_info)
for vmID in net_vm_dict[netID]:
vms = db.instance_get(context, vmID)
vm = dict(vms.iteritems())
if vm['project_id']==project_id:
print "My VM"
vm_info = {}
#Get vm infos for each VM
vm_info['name']=str(vm['hostname'])
vm_info['id']=str(vm['uuid'])
vm_info['vm_state']=str(vm['vm_state'])
#Get fixed_ips for each VM
fixed_ips = db.fixed_ip_get_by_instance(context, vmID)
fixed_ip_info = []
for ip in fixed_ips:
fixed_ip_info.append(str(dict(ip.iteritems())['address']))
vm_info['fixed_ips'] = fixed_ip_info
#Get Floating_ips for each VM
floating_ip_info = []
for fixed_ip in fixed_ip_info:
try:
floating_ips = db.floating_ip_get_by_address(context, fixed_ip)
except exception.FloatingIpNotFoundForAddress:
print "floating not found"
continue
if floating_ips != None:
for floating_ip in floating_ips:
floating_ip_info.append(str(dict(ip.floating_ip.iteritems()['address'])))
vm_info['floating_ips']=floating_ip_info
net_info['vm'].append(vm_info)
ret_net_list={}
ret_net_list['networks']=net_list
print ret_net_list
return ret_net_list
def notify(self, ctxt, message):
event_type = message.get('event_type')
if event_type in FLAGS.wiki_eventtype_blacklist:
return
if event_type not in FLAGS.wiki_eventtype_whitelist:
LOG.debug("Ignoring message type %s" % event_type)
return
payload = message['payload']
instance = payload['instance_id']
instance_name = payload['display_name']
pagename = "%s%s" % (FLAGS.wiki_page_prefix, instance_name)
LOG.debug("wikistatus: Writing instance info"
" to page http://%s/wiki/%s" %
(self.host, pagename))
if event_type == 'compute.instance.delete.end':
page_string = _("This instance has been deleted.")
else:
template_param_dict = {}
for field in self.RawTemplateFields:
template_param_dict[field] = payload[field]
tenant_id = payload['tenant_id']
if (FLAGS.wiki_use_keystone and
self._keystone_login(tenant_id, ctxt)):
tenant_obj = self.tenant_manager[tenant_id].get(tenant_id)
user_obj = self.user_manager[tenant_id].get(payload['user_id'])
tenant_name = tenant_obj.name
user_name = user_obj.name
template_param_dict['tenant'] = tenant_name
template_param_dict['username'] = user_name
inst = db.instance_get_by_uuid(ctxt, payload['instance_id'])
simple_id = inst.id
template_param_dict['cpu_count'] = inst.vcpus
template_param_dict['disk_gb_current'] = inst.ephemeral_gb
template_param_dict['host'] = inst.host
template_param_dict['reservation_id'] = inst.reservation_id
template_param_dict['availability_zone'] = inst.availability_zone
template_param_dict['original_host'] = inst.launched_on
template_param_dict['public_ip'] = inst.access_ip_v4
try:
fixed_ips = db.fixed_ip_get_by_instance(ctxt, payload['instance_id'])
except exception.FixedIpNotFoundForInstance:
fixed_ips = []
ips = [ip.address for ip in fixed_ips]
template_param_dict['private_ip'] = ','.join(ips)
sec_groups = db.security_group_get_by_instance(ctxt, simple_id)
grps = [grp.name for grp in sec_groups]
template_param_dict['security_group'] = ','.join(grps)
image = self._image_service.show(ctxt, inst.image_ref)
image_name = image.get('name', inst.image_ref)
template_param_dict['image_name'] = image_name
fields_string = ""
for key in template_param_dict:
fields_string += "\n|%s=%s" % (key, template_param_dict[key])
page_string = "{{InstanceStatus%s}}" % fields_string
self._wiki_login()
page = self.site.Pages[pagename]
try:
page.edit()
page.save(page_string, "Auto update of instance info.")
except (mwclient.errors.InsufficientPermission,
mwclient.errors.LoginError):
LOG.debug("Failed to update wiki page..."
" trying to re-login next time.")
self._wiki_logged_in = False
def get_by_instance_uuid(cls, context, instance_uuid):
db_fixedips = db.fixed_ip_get_by_instance(context, instance_uuid)
return obj_base.obj_make_list(context, cls(context),
objects.FixedIP, db_fixedips)
def notify(self, message):
ctxt = context.get_admin_context()
event_type = message.get('event_type')
if event_type in FLAGS.wiki_eventtype_blacklist:
return
if event_type not in FLAGS.wiki_eventtype_whitelist:
LOG.debug("Ignoring message type %s" % event_type)
return
payload = message['payload']
instance_name = payload['display_name']
uuid = payload['instance_id']
if FLAGS.wiki_instance_dns_domain:
fqdn = "%s.%s" % (instance_name, FLAGS.wiki_instance_dns_domain)
else:
fqdn = instance_name
template_param_dict = {}
for field in self.RawTemplateFields:
template_param_dict[field] = payload[field]
tenant_id = payload['tenant_id']
if (FLAGS.wiki_use_keystone and self._keystone_login(tenant_id, ctxt)):
tenant_obj = self.tenant_manager[tenant_id].get(tenant_id)
user_obj = self.user_manager[tenant_id].get(payload['user_id'])
tenant_name = tenant_obj.name
user_name = user_obj.name
template_param_dict['tenant'] = tenant_name
template_param_dict['username'] = user_name
inst = db.instance_get_by_uuid(ctxt, uuid)
old_school_id = inst.id
ec2_id = 'i-%08x' % old_school_id
template_param_dict['cpu_count'] = inst.vcpus
template_param_dict['disk_gb_current'] = inst.ephemeral_gb
template_param_dict['host'] = inst.host
template_param_dict['reservation_id'] = inst.reservation_id
template_param_dict['availability_zone'] = inst.availability_zone
template_param_dict['original_host'] = inst.launched_on
template_param_dict['fqdn'] = fqdn
template_param_dict['ec2_id'] = ec2_id
template_param_dict['project_name'] = inst.project_id
template_param_dict['region'] = FLAGS.wiki_instance_region
try:
fixed_ips = db.fixed_ip_get_by_instance(ctxt, old_school_id)
except exception.FixedIpNotFoundForInstance:
fixed_ips = []
ips = []
floating_ips = []
for fixed_ip in fixed_ips:
ips.append(fixed_ip.address)
for floating_ip in db.floating_ip_get_by_fixed_ip_id(
ctxt, fixed_ip.id):
floating_ips.append(floating_ip.address)
template_param_dict['private_ip'] = ','.join(ips)
template_param_dict['public_ip'] = ','.join(floating_ips)
sec_groups = db.security_group_get_by_instance(ctxt, old_school_id)
grps = [grp.name for grp in sec_groups]
template_param_dict['security_group'] = ','.join(grps)
fields_string = ""
for key in template_param_dict:
fields_string += "\n|%s=%s" % (key, template_param_dict[key])
if event_type == 'compute.instance.delete.start':
page_string = "\n%s\nThis instance has been deleted.\n%s\n" % (
begin_comment, end_comment)
else:
page_string = "\n%s\n{{InstanceStatus%s}}\n%s\n" % (
begin_comment, fields_string, end_comment)
self._wiki_login()
pagename = "%s%s" % (FLAGS.wiki_page_prefix, ec2_id)
LOG.debug("wikistatus: Writing instance info"
" to page http://%s/wiki/%s" % (FLAGS.wiki_host, pagename))
page = self.site.Pages[pagename]
try:
pText = page.edit()
start_replace_index = pText.find(begin_comment)
if start_replace_index == -1:
# Just stick it at the end.
newText = "%s%s" % (page_string, pText)
else:
# Replace content between comment tags.
end_replace_index = pText.find(end_comment,
start_replace_index)
if end_replace_index == -1:
end_replace_index = start_replace_index + len(
begin_comment)
else:
end_replace_index += len(end_comment)
newText = "%s%s%s" % (pText[:start_replace_index], page_string,
pText[end_replace_index:])
page.save(newText, "Auto update of instance info.")
except (mwclient.errors.InsufficientPermission,
mwclient.errors.LoginError):
LOG.debug("Failed to update wiki page..."
" trying to re-login next time.")
self._wiki_logged_in = False
