from oslo_config import cfg
import oslo_messaging
import sys
import json
import time

from keystoneclient.v2_0 import client as k_client
from glanceclient import Client
from cinderclient import client




class CreateImageHandler(object):
    filter_rule = oslo_messaging.notify.filter.NotificationFilter(
        publisher_id='^image.*', event_type='^image\.create')

    def info(self, ctxt, publisher_id, event_type, payload, metadata):
        print "!!! IMAGE CREATE CATCHED WITH FILTER !!!"
        print "payload: %s" % payload
        bd_mapping = payload['properties'].get('block_device_mapping')
        if bd_mapping:
            bd_mapping_json = json.loads(bd_mapping)
            cinder = client.Client('2', OS_USERNAME, OS_PASSWORD,
                                   OS_TENANT_NAME, OS_AUTH_URL)
            new_bd_mapping = []
            update_info = False
            for elem in bd_mapping_json:
                snap_id = elem.get('snapshot_id')
                if snap_id:
                    catch_image_id = payload.get('id')
                    print "snapshot_id: %s" % snap_id
                    snap_size = cinder.volume_snapshots.get(snap_id).size
                    print "snapshot_size: %s" % snap_size
                    time.sleep(60)
                    volume = cinder.volumes.create(size=snap_size,
                                                   snapshot_id=snap_id)
                    print "VOLUME CREATED"
                    while cinder.get(volume.id).status != 'available':
                        print cinder.get(volume.id).status
                        time.sleep(1)
                    print "volume: %s" % volume.id
                    image = cinder.volumes.upload_to_image(volume=volume.id,
                                                           image_name="test_name",
                                                           force=False,
                                                           container_format="bare",
                                                           disk_format="raw")
                    print "IMAGE_CREATED"
                    new_elem = elem
                    print new_elem
                    new_elem.update({'snapshot_id': None,
                                     'image_id': image.id,
                                     'source_type': 'image'})
                    new_bd_mapping.append(new_elem)
                    print new_elem
                    update_info = True
                    cinder.volumes.delete(volume.id)
                    print "VOLUME DELETED"
                    cinder.volume_snapshots.delete(snap_id)
                    print "SNAPSHOT DELETED"
            if update_info:
                new_info = json.JSONEncoder().encode(new_bd_mapping)
                keystone = k_client.Client(username=OS_USERNAME,
                                           password=OS_PASSWORD,
                                           tenant_name=OS_TENANT_NAME,
                                           auth_url=OS_AUTH_URL)
                token = keystone.auth_token
                glance = Client('1', endpoint='',
                                token=token)
                glance.images.update(catch_image_id,
                                     properties=dict(block_device_mapping=new_info))


class DeleteImageHandler(object):
    filter_rule = oslo_messaging.notify.filter.NotificationFilter(
        publisher_id='^image.*', event_type='^image\.delete')

    def info(self, ctxt, publisher_id, event_type, payload, metadata):
        print "!!! IMAGE DELETE CATCHED WITH FILTER !!!"
        print "publisher_id: %s" % publisher_id
        print "payload: %s" % payload
        bd_mapping = payload['properties'].get('block_device_mapping')
        if bd_mapping:
            bd_mapping_json = json.loads(bd_mapping)
            for elem in bd_mapping_json:
                snapshot_id = elem.get('snapshot_id')
                print snapshot_id
                if snapshot_id:
                    cinder = client.Client('2', OS_USERNAME, OS_PASSWORD,
                                           OS_TENANT_NAME, OS_AUTH_URL)
                    cinder.volume_snapshots.delete(snapshot_id)
                    print "SNAPSHOT DELETED"
                volume_id = elem.get('volume_id')
                if volume_id:
                    cinder = client.Client('2', OS_USERNAME, OS_PASSWORD,
                                           OS_TENANT_NAME, OS_AUTH_URL)
                    cinder.volumes.delete(volume_id)
                    print "VOLUME DELETED"
                image_id = elem.get('image_id')
                if image_id:
                    keystone = k_client.Client(username=OS_USERNAME,
                                               password=OS_PASSWORD,
                                               tenant_name=OS_TENANT_NAME,
                                               auth_url=OS_AUTH_URL)
                    token = keystone.auth_token
                    glance = Client('1', endpoint='',
                                    token=token)
                    glance.images.delete(image_id)
                    print "IMAGE_DELETE"

conn = [cfg.StrOpt('connection')]
db = cfg.OptGroup(name='database')
CONF = cfg.CONF
cfg.CONF(sys.argv[1:])
CONF.register_group(db)
CONF.register_opts(conn, db)
print CONF['database'].connection
print dict(CONF)
transport = oslo_messaging.get_transport(cfg.CONF)
targets = [
    oslo_messaging.Target(topic='notifications'),
]
endpoints = [
    DeleteImageHandler(),
    CreateImageHandler(),
]
server = oslo_messaging.get_notification_listener(transport, targets,
                                                  endpoints)
server.start()
server.wait()