def reassign():
        # NOTE(akscram): Initialization of fuelclient.
        fuel_config = flask.current_app.config["CLOUDS"]["fuel"]["endpoint"]
        os.environ["SERVER_ADDRESS"] = fuel_config["host"]
        os.environ["LISTEN_PORT"] = str(fuel_config["port"])
        os.environ["KEYSTONE_USER"] = fuel_config["username"]
        os.environ["KEYSTONE_PASS"] = fuel_config["password"]

        src_config = hooks.source.config()
        dst_config = hooks.destination.config()
        config = {
            "source": src_config["environment"],
            "destination": dst_config["environment"],
        }

        try:
            src = hooks.source.connect()
            dst = hooks.destination.connect()
            ctx = context.Context(config, src, dst)

            flow = node_tasks.reassign_node(ctx, host_id)
            LOG.debug("Reassigning flow: %s", flow)
            result = flows.run_flow(flow, ctx.store)
            LOG.debug("Result of migration: %s", result)
        except Exception:
            msg = ("Error is occured during reassigning host {}"
                   .format(host_id))
            LOG.exception(msg)
            events.emit("error", {
                "message": msg,
            }, namespace="/events")

 def created_event(self, flavor):
     LOG.info("Flavor created: %s", flavor.id)
     events.emit(
         "create",
         {"id": flavor.id, "type": "flavor", "cloud": self.cloud.name, "data": flavor.to_dict()},
         namespace="/events",
     )

 def unassign_start_event(self, node):
     events.emit("update", {
         "id": extract_hostname(node.data),
         "cloud": self.cloud.name,
         "type": "host",
         "action": "reassignment",
     }, namespace="/events")

 def delete_event(self, keypair_info):
     LOG.info("Deleted keypair: %s", keypair_info["name"])
     events.emit(
         "delete",
         {"id": keypair_info["name"], "type": "keypair", "cloud": self.cloud.name, "data": None},
         namespace="/events",
     )

 def create_event(self, keypair):
     LOG.info("Created keypair: %s", keypair.name)
     events.emit(
         "create",
         {"id": keypair.name, "type": "keypair", "cloud": self.cloud.name, "data": keypair.to_dict()},
         namespace="/events",
     )

 def created_event(self, secgroup_info):
     events.emit("create", {
         "id": secgroup_info["id"],
         "type": "secgroup",
         "cloud": self.cloud.name,
         "data": secgroup_info,
     }, namespace="/events")

 def upload_to_glance_event(self, image_info):
     LOG.info("Created: %s", image_info)
     events.emit("create", {
         "id": image_info["id"],
         "cloud": self.cloud.name,
         "type": "image",
         "data": dict(image_info)
     }, namespace="/events")

 def upload_to_glance_event(self, image_info):
     LOG.info("Created: %s", image_info)
     events.emit("volume snapshot create", {
         "cloud": self.cloud.name,
         "id": image_info["id"],
         "name": image_info["name"],
         "status": "active",
     }, namespace="/events")

 def created_event(self, floating_ip):
     events.emit("create", {
         "id": floating_ip.address,
         "type": "floating_ip",
         "cloud": self.cloud.name,
         "data": dict(floating_ip.to_dict(),
                      name=floating_ip.address),
     }, namespace="/events")

 def update_event(self, service):
     events.emit("update", {
         "id": service["host"],
         "cloud": self.cloud.name,
         "type": "host",
         "progress": None,
         "action": None,
     }, namespace="/events")

 def resume_event(self, server):
     LOG.info("Server resumed: %s", server["id"])
     events.emit("update", {
         "id": server["id"],
         "cloud": self.cloud.name,
         "type": "server",
         "data": server,
     }, namespace="/events")

 def execute(self, server_id):
     LOG.info("Migration of server %r started", server_id)
     events.emit("update", {
         "id": server_id,
         "cloud": self.cloud.name,
         "type": "server",
         "action": "migration",
     }, namespace="/events")

 def created_event(self, tenant):
     LOG.info("Tenant created: %s", tenant.id)
     events.emit("create", {
         "id": tenant.id,
         "type": "tenant",
         "cloud": self.cloud.name,
         "data": tenant.to_dict(),
     }, namespace="/events")

 def created_event(self, snapshot):
     events.emit("create", {
         "id": snapshot["id"],
         "type": "image",
         "cloud": self.cloud.name,
         "action": "uploading",
         "data": dict(snapshot),
     }, namespace="/events")

 def created_event(self, user):
     LOG.info("Created user: %s", user)
     events.emit("create", {
         "id": user.id,
         "type": "user",
         "cloud": self.cloud.name,
         "data": user.to_dict(),
     }, namespace="/events")

 def execute(self, volume, target_host):
     LOG.info("Evacuating volume %s to host %s...", volume.id, target_host)
     self.cloud.cinder.volumes.migrate_volume(volume, target_host, False)
     volume = utils.wait_for(volume.id, self.cloud.cinder.volumes.get,
                             get_volume_host, target_host)
     events.emit("update", event_from(self.cloud, volume),
                 namespace="/events")
     LOG.info("Evacuated volume %s to host %s", volume.id, target_host)

 def assigned_event(self, address, server_id):
     events.emit("update", {
         "id": address,
         "type": "floating_ip",
         "cloud": self.cloud.name,
         "data": {
             "server_id": server_id,
         }
     }, namespace="/events")

 def created_event(self, image):
     LOG.info("Image created: %s", image["id"])
     events.emit("create", {
         "id": image["id"],
         "type": "image",
         "cloud": self.dst_cloud.name,
         "action": "uploading",
         "data": dict(image),
     }, namespace="/events")

 def detach_event(self, volume_id):
     LOG.info("Volume updated: %s", volume_id)
     events.emit("update", {
         "id": volume_id,
         "cloud": self.cloud.name,
         "type": "volume",
         "action": "detach",
         "data": dict(server_ids=[]),
     }, namespace="/events")

 def uploaded_event(self, image):
     LOG.info("Image uploaded: %s", image["id"])
     events.emit("update", {
         "id": image["id"],
         "type": "image",
         "cloud": self.dst_cloud.name,
         "progress": None,
         "action": None,
         "data": dict(image),
     }, namespace="/events")