def create_image(image):
file_info = yield _guess_file_info(image['location'])
params = {
'name': image['name'],
'visibility': 'public',
'disk_format': image.get('disk_format', 'qcow2'),
'container_format': image.get('container_format', 'bare'),
'ecloud_image_type': str(image.get('type', 0)),
'os': image['os'],
'min_disk': image.get('min_disk', 0),
'ecloud_source': str(image.get('source', 0)),
'des': image.get('des', ''),
'disk_bus': image.get('disk_bus', 'virtio'),
'super_user': "",
'super_user_pass': ""
}
try:
session = yield openstack.get_session()
img = yield openstack.connect_request(session=session,
type=openstack.TYPE_IMAGE,
url="/v2/images",
method=openstack.METHOD_POST,
body=params)
img['file'] = file_info
message = {"event": IMAGE_QUEUED_EVENT, "body": img}
publisher.publish_message(message)
img = __map_image_fields(img)
except openstack.OpenStackException, e:
LOG.error("create image '%s' failed: %s" % (image['name'], e.message))
raise ImageOperateFailed()
def update_user_password(user_id, password=None):
password = __random_password() if not password else password
params = {"user": {"id": user_id, "password": password}}
url = "/users/%s/OS-KSADM/password" % user_id
try:
session = yield openstack.get_session()
u = yield openstack.connect_request(session=session,
type=openstack.TYPE_IDENTITY,
url=url,
method=openstack.METHOD_PUT,
body=params,
response_key="user")
if CONF.identify.send_password_mail and "email" in u and u['email']:
rg = yield region.get_current_region()
mparams = {
"name": u['name'],
"password": password,
"url": rg['url'],
'user': u['displayname'] if "displayname" in u else u['name']
}
mail.send_mail_task(to_list=[u['email']],
subject="EASTED ECloud - 您的密码已被重置",
template="reset_user_password.html",
params=mparams)
except openstack.OpenStackException, e:
LOG.error("reset user '%s's password failed: %s" %
(user_id, e.message))
raise UserOperationFailed()
def update_server_meta(vm_id, meta_key, meta_val):
""" update meta from instance
:param vm_id: id of vm
:param meta_key: A metadata key to update from the server
:param meta_val: A metadata val to update from the server
"""
try:
if not vm_id:
raise RequiredParamNotExist(args=['vm_id'])
if not meta_key:
raise RequiredParamNotExist(args=['meta_key'])
url = '/servers/%s/metadata/%s' % (vm_id, meta_key)
body = {'meta': {meta_key: str(meta_val)}}
session = yield os.get_session()
server_meta = yield os.connect_request(session=session,
type=os.TYPE_COMPUTE,
url=url,
method=os.METHOD_PUT,
body=body)
except Exception as e:
LOG.error("update instance meta error: %s" % e)
raise SetServerMetaError()
else:
metadata = {k: eval_val(v) for k, v in server_meta['meta'].items()}
raise gen.Return(metadata)
def create_tenant(name, description=None, enabled=True, **kwargs):
params = {
"tenant": {
"name": name,
"description": description,
"enabled": enabled
}
}
for k, v in six.iteritems(kwargs):
if k not in params['tenant']:
params['tenant'][k] = v
LOG.debug("create tenant params: %s", params)
try:
session = yield openstack.get_session()
t = yield openstack.connect_request(session=session,
type=openstack.TYPE_IDENTITY,
url="/tenants",
method=openstack.METHOD_POST,
body=params,
response_key="tenant")
__TENANT_CACHE.set(t['id'], t)
# add admin user
role_id = openstack.get_role_by_name(CONF.identify.internal_admin_role)
yield tenant_users.add_tenant_user(t['id'], session.user_id, role_id)
# 调用查看安全组openstack api， 创建默认安全组 和默认安全组规则
from easted.security_group import get_security_group_from_neutron
yield get_security_group_from_neutron(t.get("id"))
except openstack.OpenStackException, e:
LOG.error("create tenant '%s' failed: %s" % (name, e.message))
if e.message.code == 409:
raise TenantExists()
raise TenantOperationFailed()
def add_vm_nic(vm, vlan_id, subnet_id, ip, mac=None):
url = "/servers/%s/os-interface" % vm.get("id")
try:
network = [{
"vlan": vlan_id,
"subnet": subnet_id,
"mac": mac,
"ip": ip
}]
fixed_ip = ip
nic = yield check_network(vm.get("name"), network, vm.get("tenant_id"),
vm.get("user_id"), vm.get("host_id"))
if nic:
try:
fixed_ip = nic[0].get('v4-fixed-ip')
body = {
"interfaceAttachment": {
"port_id": nic[0].get("port-id")
}
}
session = yield os.get_session(tenant=vm.get("tenant_id"))
yield os.connect_request(session=session,
type=os.TYPE_COMPUTE,
method=os.METHOD_POST,
url=url,
body=body)
except Exception, e:
LOG.error("add vm nics error: %s" % e)
raise VMNicOperationError()
except Exception, e:
LOG.error("add vm nics error: %s" % e)
raise e
def db_clean(interval=3600):
"""clean all meters records that generated {interval} seconds ago.
:param interval: time in seconds.
:return: None
"""
# TODO: assuming that mongodb server running on ceilometer central host
client = None
try:
LOG.debug("*************************************************")
LOG.debug("*********** Clean MongoDB Start ************")
LOG.debug("*************************************************")
session = yield get_session()
controller_host = session.urls[TYPE_METERING]['internalURL'].split(
':')[1].strip('/')
client = pymongo.MongoClient(host=controller_host, port=27017)
db = client.ceilometer
db.meter.remove({
'timestamp': {
'$lt':
datetime.datetime.utcnow() -
datetime.timedelta(seconds=interval)
}
})
LOG.debug("*************************************************")
LOG.debug("*********** Clean MongoDB End ************")
LOG.debug("*************************************************")
except Exception, e:
LOG.error("Error happened while cleaning mongodb: %s" % e)
def update_tenant(tenant_id,
name=None,
description=None,
enabled=None,
**kwargs):
body = {"tenant": {'id': tenant_id}}
if name is not None:
body['tenant']['name'] = name
if enabled is not None:
body['tenant']['enabled'] = enabled
if description is not None:
body['tenant']['description'] = description
for k, v in six.iteritems(kwargs):
if k not in body['tenant']:
body['tenant'][k] = v
LOG.debug("update tenant params: %s", body)
try:
session = yield openstack.get_session()
t = yield openstack.connect_request(session=session,
type=openstack.TYPE_IDENTITY,
url="/tenants/%s" % tenant_id,
method=openstack.METHOD_POST,
body=body,
response_key="tenant")
__TENANT_CACHE.set(tenant_id, t)
except openstack.OpenStackException, e:
LOG.error("update tenant '%s' failed: %s" % (name, e.message))
raise TenantOperationFailed()
def __create_flavor(cores, memory, disk_capacity):
""" create flavor if has not flavor of setting,
vcpus = cores, ram = memory.
:param cores: the vcpus of flavor
:param memory: the ram of flavor
:param disk_capacity: the disk of flavor
"""
new_flavor = {}
try:
try:
memory = int(memory)
except (TypeError, ValueError):
raise ClassCastException()
try:
cores = int(cores)
except (TypeError, ValueError):
raise ClassCastException()
try:
disk_capacity = int(disk_capacity)
except (TypeError, ValueError):
raise ClassCastException()
if cores and memory and disk_capacity:
flavor_name = "m1.flavor-%s" % random_password(12)
body = __build_body(flavor_name, memory, cores, disk_capacity)
url = "/flavors"
session = yield openstack.get_session()
flavor = yield openstack.connect_request(session=session, type=openstack.TYPE_COMPUTE, url=url, body=body,
method=openstack.METHOD_POST, response_key="flavor")
if flavor:
new_flavor = __package_flavor(flavor)
except Exception, e:
LOG.error("create flavor error: %s" % e)
raise FlavorCreateOrFindError()
def security_group_rule_request(request_url,
tenant_id=None,
response_key=None,
method=os.METHOD_GET,
request_body=None):
""" security group rule async request decorators
:param request_url: the action url of handle volume
:param tenant_id: the id of tenant, default None
:param response_key: the key of response: volume or volumes
:param method: request method: get, post, delete, put
:param request_body: request body: A dict
:return:
"""
try:
session = yield os.get_session(tenant=tenant_id)
result = yield os.connect_request(session=session,
type=os.TYPE_NETWORK,
method=method,
url=request_url,
response_key=response_key,
body=request_body)
except Exception as e:
LOG.error("get security group rule error: %s" % e)
raise e
raise gen.Return(result)
def del_vm_nic(vm, port_id):
url = "/servers/%s/os-interface/%s" % (vm.get("id"), port_id)
try:
session = yield os.get_session(tenant=vm.get("tenant_id"))
yield os.connect_request(session=session,
type=os.TYPE_COMPUTE,
method=os.METHOD_DELETE,
url=url)
except Exception, e:
LOG.error("del vm nics error: %s" % e)
raise VMNicOperationError()
def del_meta(vm_id, keys):
try:
session = yield os.get_session()
for k in keys:
url = "/servers/%s/metadata/%s" % (vm_id, k)
yield os.connect_request(session=session,
type=os.TYPE_COMPUTE,
url=url,
method=os.METHOD_DELETE)
except Exception, e:
LOG.error("reboot vm error: %s" % e)
raise SetServerMetaError()
def delete_user(user_id):
try:
url = "/users/%s" % user_id
session = yield openstack.get_session()
yield openstack.connect_request(session=session,
type=openstack.TYPE_IDENTITY,
url=url,
method=openstack.METHOD_DELETE)
__USER_CACHE.remove(user_id)
except Exception, e:
LOG.error("delete user '%s' raise an error: %s" % (user_id, e))
raise UserOperationFailed()
def delete_image(image_id):
if image_id:
request_url = u'/v2/images/%s' % image_id
try:
session = yield openstack.get_session()
yield openstack.connect_request(session=session,
type=openstack.TYPE_IMAGE,
method=openstack.METHOD_DELETE,
url=request_url)
except openstack.OpenStackException, e:
LOG.error("delete image '%s' failed: %s" % (image_id, e.message))
raise ImageOperateFailed()
def delete_tenant(tenant_id):
try:
session = yield openstack.get_session()
yield openstack.connect_request(session=session,
type=openstack.TYPE_IDENTITY,
url="/tenants/%s" % tenant_id,
method=openstack.METHOD_DELETE)
yield tenant_quotas.delete_quotas(tenant_id)
__TENANT_CACHE.remove(tenant_id)
except openstack.OpenStackException, e:
LOG.error("delete tenant '%s' failed: %s" % (tenant_id, e.message))
raise TenantOperationFailed()
def request_get_networks(network_id):
url = __version + "/networks/%s" % network_id
try:
session = yield openstack.get_session()
result_networks = yield openstack.connect_request(
session=session,
type=openstack.TYPE_NETWORK,
url=url,
method=openstack.METHOD_GET)
except Exception as e:
LOG.error(e)
raise e
raise gen.Return(result_networks)
def list_tenant_users(tenant_id, admin=False):
try:
session = yield openstack.get_session()
ret = yield openstack.connect_request(
session=session,
type=openstack.TYPE_IDENTITY,
url="/tenants/%s/users" % (tenant_id,),
method=openstack.METHOD_GET,
response_key="users"
)
except openstack.OpenStackException, e:
LOG.error("list tenant '%s' users failed: %s", (tenant_id, e.message,))
raise TenantUserOperationFailed()
def vm_set_meta_item(vm_id, k, v):
try:
url = '/servers/%s/metadata/%s' % (vm_id, k)
body = {'meta': {k: v}}
session = yield os.get_session()
yield os.connect_request(session=session,
type=os.TYPE_COMPUTE,
url=url,
method=os.METHOD_PUT,
body=body)
except Exception, e:
LOG.error("reboot vm error: %s" % e)
raise SetServerMetaError()
def list_vm_nics(vm):
url = "/servers/%s/os-interface" % vm.get("id")
result = []
try:
session = yield os.get_session(tenant=vm.get("tenant_id"))
nics = yield os.connect_request(session=session,
type=os.TYPE_COMPUTE,
method=os.METHOD_GET,
url=url,
response_key="interfaceAttachments")
except Exception, e:
LOG.error("list vm nics error: %s" % e)
raise VMNicOperationError()
def f():
try:
url = "/users/%s" % user_id
session = yield openstack.get_session()
user = yield openstack.connect_request(
session=session,
type=openstack.TYPE_IDENTITY,
url=url,
method=openstack.METHOD_GET,
response_key="user")
user['role'] = yield get_user_role(user_id)
except Exception, e:
LOG.error("get user error: %s" % e)
raise UserNotExist(args=[user_id])
def remove_tenant_user(tenant_id, user_id, role_id=None):
try:
session = yield openstack.get_session()
if not role_id:
role_id = openstack.get_role_by_name(CONF.identify.internal_user_role)
yield openstack.connect_request(
session=session,
type=openstack.TYPE_IDENTITY,
url="/tenants/%s/users/%s/roles/OS-KSADM/%s" % (tenant_id, user_id, role_id),
method=openstack.METHOD_DELETE,
)
except openstack.OpenStackException, e:
LOG.error("remove user '%s' from tenant '%s' failed: %s" % (user_id, tenant_id, e.message))
raise TenantUserOperationFailed()
def request_update_network(network_id, body):
url = __version + "/networks"
try:
session = yield openstack.get_session()
result_networks = yield openstack.connect_request(
session=session,
type=openstack.TYPE_NETWORK,
url=url + "/" + network_id,
method=openstack.METHOD_PUT,
body=body)
except Exception as e:
LOG.error(e)
raise e
raise gen.Return(result_networks)
def vnc(vm_id):
try:
url = '/servers/%s/action' % vm_id
body = {"os-getVNCConsole": {"type": "novnc"}}
session = yield openstack.get_session()
console = yield openstack.connect_request(session=session,
type=openstack.TYPE_COMPUTE,
url=url,
method=openstack.METHOD_POST,
body=body)
url = console["console"]["url"]
except Exception, e:
LOG.error("vnc vm error: %s" % e)
raise VNCConsoleError()
def get_flavor_by_id(flavor_id):
""" get flavor by id
:param flavor_id: id of flavor
:return: flavor={}
"""
out_flavor = {}
try:
url = '/flavors/%s' % flavor_id
session = yield openstack.get_session()
flavor = yield openstack.connect_request(session=session, type=openstack.TYPE_COMPUTE, url=url,
method=openstack.METHOD_GET, response_key="flavor")
except Exception, e:
LOG.error("get flavor by id error: %s" % e)
raise FlavorCreateOrFindError()
def request_delete_ports(tenant, port):
url = __version + "/ports/%s" % port
try:
session = yield openstack.get_session(tenant)
result_ports = yield openstack.connect_request(
session=session,
type=openstack.TYPE_NETWORK,
url=url,
method=openstack.METHOD_DELETE,
response_key="port")
LOG.debug("delete ports end teant is %s port is %s", tenant, port)
except Exception as e:
LOG.error(e)
raise e
raise gen.Return(result_ports)
def update_user_enable(user_id, enabled=True):
params = {"user": {"id": user_id, "enabled": enabled}}
url = "/users/%s/OS-KSADM/enabled" % user_id
try:
session = yield openstack.get_session()
u = yield openstack.connect_request(session=session,
type=openstack.TYPE_IDENTITY,
url=url,
method=openstack.METHOD_PUT,
body=params,
response_key="user")
__USER_CACHE.set(u['id'], u)
except openstack.OpenStackException, e:
LOG.error("update user '%s' status failed: %s" % (user_id, e.message))
raise UserOperationFailed()
def __delete_token(token_id):
yield dbpools.execute_commit(
dbpools.get_common(),
"delete from token where token = %s",
(token_id,)
)
try:
session = yield openstack.get_session()
yield openstack.connect_request(
session=session,
type=openstack.TYPE_IDENTITY,
url="/tokens/%s" % token_id,
method=openstack.METHOD_DELETE
)
except Exception, e:
LOG.error("this token has deleted %s" % e)
def download_image(image_id, on_data):
url = u'/v2/images/%s/file' % image_id
try:
session = yield openstack.get_session()
yield openstack.connect_request(
session=session,
type=openstack.TYPE_IMAGE,
method=openstack.METHOD_GET,
url=url,
streaming_callback=on_data,
request_timeout=1800,
max_body_size=MAX_IMAGE_SIZE,
content_type="application/octet-stream")
except openstack.OpenStackException, e:
LOG.error("download image '%s' failed: %s" % (image_id, e.message))
raise ImageOperateFailed()
def request_create_ports(tenant, body):
url = __version + "/ports"
body = {"port": body}
try:
session = yield openstack.get_session(tenant)
result_ports = yield openstack.connect_request(
session=session,
type=openstack.TYPE_NETWORK,
url=url,
body=body,
method=openstack.METHOD_POST,
response_key="port")
except Exception as e:
LOG.error(e)
raise e
raise gen.Return(result_ports)
def add_tenant_user(tenant_id, user_id, role_id=None):
try:
session = yield openstack.get_session()
if not role_id:
role_id = openstack.get_role_by_name(CONF.identify.internal_user_role)
r = yield openstack.connect_request(
session=session,
type=openstack.TYPE_IDENTITY,
url="/tenants/%s/users/%s/roles/OS-KSADM/%s" % (tenant_id, user_id, role_id),
method=openstack.METHOD_PUT,
body='',
response_key='role'
)
except openstack.OpenStackException, e:
LOG.error("add user '%s' to tenant '%s' failed: %s" % (user_id, tenant_id, e.message))
raise TenantUserOperationFailed()
def __boot_vm(t):
try:
tenant = t.get("tenant")
resource_url = t.get("resource_url")
response_key = t.get("response_key")
body = t.get("body")
sys_volume_id = t.get("sys_volume_id")
drive_volume_id = t.get("drive_volume_id")
image = t.get("image")
is_iso = t.get("is_iso")
volume = t.get("volume")
is_windows = t.get("is_windows")
if is_iso:
image_volume = yield check_image_up_down(
image, volume.get('availability_zone'),
volume.get("volume_type"))
image_sys_volume = image_volume.get("sys_volume")
yield _update_iso_volume_available(image_sys_volume)
body["server"]["block_device_mapping_v2"]["vda"] = body["server"][
"block_device_mapping_v2"]["vda"] % image_sys_volume
body["server"]["block_device_mapping_v2"]["vdb"] = body["server"][
"block_device_mapping_v2"]["vdb"] % sys_volume_id
if is_windows:
yield _update_iso_volume_available(drive_volume_id)
body["server"]["block_device_mapping_v2"][
"vdc"] = body["server"]["block_device_mapping_v2"][
"vdc"] % drive_volume_id
else:
body["server"]["block_device_mapping_v2"]["vda"] = body["server"][
"block_device_mapping_v2"]["vda"] % sys_volume_id
body["server"]["block_device_mapping_v2"] = parse_block_device_mapping(
body["server"]["block_device_mapping_v2"])
body["server"]["metadata"].pop("nics")
LOG.debug("create vm body is %s", body)
session = yield openstack.get_session(tenant)
yield openstack.connect_request(session=session,
type=openstack.TYPE_COMPUTE,
url=resource_url,
body=body,
method=openstack.METHOD_POST,
response_key=response_key)
except Exception, e:
LOG.error("boot vm error %s" % e)
