def publish_to_xml(context):
    """Generates XML for object and saves it to the file. If object contains
    attachments - XML is saved in zip archive with all attached files. 
    """


    context = zope.security.proxy.removeSecurityProxy(context)
    obj_type = IWorkflow(context).name
    
    #locking
    lock_name = "%s-%s" %(obj_type, stringKey(context))
    with LockStore.get_lock(lock_name):
        #root key (used to cache files to zip)
        root_key = make_key()

        #create a fake interaction to ensure items requiring a participation
        #are serialized 
        #!+SERIALIZATION(mb, Jan-2013) review this approach
        try:
            zope.security.management.getInteraction()
        except zope.security.interfaces.NoInteraction:
            principal = zope.security.testing.Principal('user', 'manager', ())
            zope.security.management.newInteraction(create_participation(principal))
        include = []
        # data dict to be published
        data = {}

        if interfaces.IFeatureVersion.providedBy(context):
            include.append("versions")
        if interfaces.IFeatureAudit.providedBy(context):
            include.append("event")
        
        exclude = ["data", "event", "attachments"]
        
        data.update(
            obj2dict(context, 1, 
                parent=None,
                include=include,
                exclude=exclude,
                root_key=root_key
            )
        )
        tags = IStateController(context).get_state().tags
        if tags:
            data["tags"] = tags
        permissions = get_object_state_rpm(context).permissions
        data["permissions"] = get_permissions_dict(permissions)
        
        # setup path to save serialized data 
        path = os.path.join(setupStorageDirectory(), obj_type)
        if not os.path.exists(path):
            os.makedirs(path)
        
        # xml file path
        file_path = os.path.join(path, stringKey(context)) 
        
        #files to zip
        files = []
        
        if interfaces.IFeatureAttachment.providedBy(context):
            attachments = getattr(context, "attachments", None)
            if attachments:
                data["attachments"] = []
                for attachment in attachments:
                    # serializing attachment
                    attachment_dict = obj2dict(attachment, 1,
                        parent=context,
                        exclude=["data", "event", "versions"])
                    # saving attachment to tmp
                    attached_file = tmp(delete=False)
                    attached_file.write(attachment.data)
                    attached_file.flush()
                    attached_file.close()
                    files.append(attached_file.name)
                    attachment_dict["saved_file"] = os.path.basename(
                        attached_file.name
                    )
                    data["attachments"].append(attachment_dict)

        #add explicit origin chamber for this object (used to partition data in
        #if more than one parliament exists)
        data["origin_parliament"] = get_origin_parliament(context)
        
        #add any additional files to file list
        files = files + PersistFiles.get_files(root_key)
        # zipping xml, attached files plus any binary fields
        # also remove the temporary files
        if files:
            #generate temporary xml file
            temp_xml = tmp(delete=False)
            temp_xml.write(serialize(data, name=obj_type))
            temp_xml.close()
            #write attachments/binary fields to zip
            with  ZipFile("%s.zip" % (file_path), "w") as zip_file:
                for f in files:
                    zip_file.write(f, os.path.basename(f))
                # write the xml
                zip_file.write(temp_xml.name, "%s.xml" % os.path.basename(file_path))
            files.append(temp_xml.name)

        else:
            # save serialized xml to file
            with open("%s.xml" % (file_path), "w") as xml_file:
                xml_file.write(serialize(data, name=obj_type))
                xml_file.close()

        # publish to rabbitmq outputs queue
        connection = bungeni.core.notifications.get_mq_connection()
        if not connection:
            return
        channel = connection.channel()
        publish_file_path = "%s.%s" %(file_path, ("zip" if files else "xml"))
        channel.basic_publish(
            exchange=SERIALIZE_OUTPUT_EXCHANGE,
            routing_key=SERIALIZE_OUTPUT_ROUTING_KEY,
            body=simplejson.dumps({"type": "file", "location": publish_file_path }),
            properties=pika.BasicProperties(content_type="text/plain",
                delivery_mode=2
            )
        )
        
        #clean up - remove any files if zip was/was not created
        if files:
            files.append("%s.%s" %(file_path, "xml"))
        else:
            files.append("%s.%s" %(file_path, "zip"))
        remove_files(files)

        #clear the cache
        PersistFiles.clear_files(root_key)
def publish_to_xml(context):
    """Generates XML for object and saves it to the file. If object contains
    attachments - XML is saved in zip archive with all attached files. 
    """

    #create a fake interaction to ensure items requiring a participation
    #are serialized 
    #!+SERIALIZATION(mb, Jan-2013) review this approach
    try:
        zope.security.management.getInteraction()
    except zope.security.interfaces.NoInteraction:
        principal = zope.security.testing.Principal('user', 'manager', ())
        zope.security.management.newInteraction(create_participation(principal))

    include = []
    # list of files to zip
    files = []
    # data dict to be published
    data = {}
    
    context = zope.security.proxy.removeSecurityProxy(context)
    
    if interfaces.IFeatureVersion.providedBy(context):
        include.append("versions")
    if interfaces.IFeatureAudit.providedBy(context):
        include.append("event")
    
    exclude = ["data", "event", "attachments", "changes"]
    
    # include binary fields and include them in the zip of files for this object
    for column in class_mapper(context.__class__).columns:
        if column.type.__class__ == Binary:
            exclude.append(column.key)
            content = getattr(context, column.key, None)
            if content:
                bfile = tmp(delete=False)
                bfile.write(content)
                files.append(bfile.name)
                data[column.key] = dict(
                    saved_file=os.path.basename(bfile.name)
                )
                bfile.close()
    data.update(
        obj2dict(context, 1, 
            parent=None,
            include=include,
            exclude=exclude
        )
    )
    obj_type = IWorkflow(context).name    
    tags = IStateController(context).get_state().tags
    if tags:
        data["tags"] = tags
    permissions = get_object_state_rpm(context).permissions
    data["permissions"] = get_permissions_dict(permissions)
    data["changes"] = []
    for change in getattr(context, "changes", []):
        change_dict = obj2dict(change, 0, parent=context)
        change_permissions = get_head_object_state_rpm(change).permissions
        change_dict["permissions"] = get_permissions_dict(change_permissions)
        data["changes"].append(change_dict)
    
    # setup path to save serialized data 
    path = os.path.join(setupStorageDirectory(), obj_type)
    if not os.path.exists(path):
        os.makedirs(path)
    
    # xml file path
    file_path = os.path.join(path, stringKey(context)) 
    
    if interfaces.IFeatureAttachment.providedBy(context):
        attachments = getattr(context, "attachments", None)
        if attachments:
            data["attachments"] = []
            for attachment in attachments:
                # serializing attachment
                attachment_dict = obj2dict(attachment, 1,
                    parent=context,
                    exclude=["data", "event", "versions"])
                permissions = get_object_state_rpm(attachment).permissions
                attachment_dict["permissions"] = \
                    get_permissions_dict(permissions)
                # saving attachment to tmp
                attached_file = tmp(delete=False)
                attached_file.write(attachment.data)
                attached_file.flush()
                attached_file.close()
                files.append(attached_file.name)
                attachment_dict["saved_file"] = os.path.basename(
                    attached_file.name
                )
                data["attachments"].append(attachment_dict)

    
    # zipping xml, attached files plus any binary fields
    # also remove the temporary files
    if files:
        #generate temporary xml file
        temp_xml = tmp(delete=False)
        temp_xml.write(serialize(data, name=obj_type))
        temp_xml.close()
        #write attachments/binary fields to zip
        zip_file = ZipFile("%s.zip" % (file_path), "w")
        for f in files:
            zip_file.write(f, os.path.basename(f))
            os.remove(f)
        #write the xml
        zip_file.write(temp_xml.name, "%s.xml" % os.path.basename(file_path))
        zip_file.close()
        #placed remove after zip_file.close !+ZIP_FILE_CRC_FAILURE
        os.remove(temp_xml.name) 

    else:
        # save serialized xml to file
        with open("%s.xml" % (file_path), "w") as xml_file:
            xml_file.write(serialize(data, name=obj_type))
            xml_file.close()

    #publish to rabbitmq outputs queue
    connection = get_mq_connection()
    if not connection:
        return
    channel = connection.channel()
    publish_file_path = "%s.%s" %(file_path, ("zip" if files else "xml"))
    channel.basic_publish(
        exchange=SERIALIZE_OUTPUT_EXCHANGE,
        routing_key=SERIALIZE_OUTPUT_ROUTING_KEY,
        body=simplejson.dumps({"type": "file", "location": publish_file_path }),
        properties=pika.BasicProperties(content_type="text/plain",
            delivery_mode=2
        )
    )
    
    #clean up - remove any files if zip was created
    if files:
        prev_xml_file = "%s.%s" %(file_path, "xml")
        if os.path.exists(prev_xml_file):
            os.remove(prev_xml_file)
Beispiel #3
0
def publish_to_xml(context):
    """Generates XML for object and saves it to the file. If object contains
    attachments - XML is saved in zip archive with all attached files. 
    """

    context = zope.security.proxy.removeSecurityProxy(context)
    obj_type = IWorkflow(context).name

    #locking
    lock_name = "%s-%s" % (obj_type, stringKey(context))
    with LockStore.get_lock(lock_name):
        #root key (used to cache files to zip)
        root_key = make_key()

        #create a fake interaction to ensure items requiring a participation
        #are serialized
        #!+SERIALIZATION(mb, Jan-2013) review this approach
        try:
            zope.security.management.getInteraction()
        except zope.security.interfaces.NoInteraction:
            principal = zope.security.testing.Principal('user', 'manager', ())
            zope.security.management.newInteraction(
                create_participation(principal))
        include = []
        # data dict to be published
        data = {}

        if interfaces.IFeatureVersion.providedBy(context):
            include.append("versions")
        if interfaces.IFeatureAudit.providedBy(context):
            include.append("event")

        exclude = ["data", "event", "attachments"]

        data.update(
            obj2dict(context,
                     1,
                     parent=None,
                     include=include,
                     exclude=exclude,
                     root_key=root_key))
        tags = IStateController(context).get_state().tags
        if tags:
            data["tags"] = tags
        permissions = get_object_state_rpm(context).permissions
        data["permissions"] = get_permissions_dict(permissions)

        # setup path to save serialized data
        path = os.path.join(setupStorageDirectory(), obj_type)
        if not os.path.exists(path):
            os.makedirs(path)

        # xml file path
        file_path = os.path.join(path, stringKey(context))

        #files to zip
        files = []

        if interfaces.IFeatureAttachment.providedBy(context):
            attachments = getattr(context, "attachments", None)
            if attachments:
                data["attachments"] = []
                for attachment in attachments:
                    # serializing attachment
                    attachment_dict = obj2dict(
                        attachment,
                        1,
                        parent=context,
                        exclude=["data", "event", "versions"])
                    # saving attachment to tmp
                    attached_file = tmp(delete=False)
                    attached_file.write(attachment.data)
                    attached_file.flush()
                    attached_file.close()
                    files.append(attached_file.name)
                    attachment_dict["saved_file"] = os.path.basename(
                        attached_file.name)
                    data["attachments"].append(attachment_dict)

        #add explicit origin chamber for this object (used to partition data in
        #if more than one parliament exists)
        data["origin_parliament"] = get_origin_parliament(context)

        #add any additional files to file list
        files = files + PersistFiles.get_files(root_key)
        # zipping xml, attached files plus any binary fields
        # also remove the temporary files
        if files:
            #generate temporary xml file
            temp_xml = tmp(delete=False)
            temp_xml.write(serialize(data, name=obj_type))
            temp_xml.close()
            #write attachments/binary fields to zip
            with ZipFile("%s.zip" % (file_path), "w") as zip_file:
                for f in files:
                    zip_file.write(f, os.path.basename(f))
                # write the xml
                zip_file.write(temp_xml.name,
                               "%s.xml" % os.path.basename(file_path))
            files.append(temp_xml.name)

        else:
            # save serialized xml to file
            with open("%s.xml" % (file_path), "w") as xml_file:
                xml_file.write(serialize(data, name=obj_type))
                xml_file.close()

        # publish to rabbitmq outputs queue
        connection = bungeni.core.notifications.get_mq_connection()
        if not connection:
            return
        channel = connection.channel()
        publish_file_path = "%s.%s" % (file_path, ("zip" if files else "xml"))
        channel.basic_publish(exchange=SERIALIZE_OUTPUT_EXCHANGE,
                              routing_key=SERIALIZE_OUTPUT_ROUTING_KEY,
                              body=simplejson.dumps({
                                  "type":
                                  "file",
                                  "location":
                                  publish_file_path
                              }),
                              properties=pika.BasicProperties(
                                  content_type="text/plain", delivery_mode=2))

        #clean up - remove any files if zip was/was not created
        if files:
            files.append("%s.%s" % (file_path, "xml"))
        else:
            files.append("%s.%s" % (file_path, "zip"))
        remove_files(files)

        #clear the cache
        PersistFiles.clear_files(root_key)
Beispiel #4
0
def publish_to_xml(context):
    """Generates XML for object and saves it to the file. If object contains
    attachments - XML is saved in zip archive with all attached files. 
    """
    context = zope.security.proxy.removeSecurityProxy(context)
    obj_type = IWorkflow(context).name
    #locking
    random_name_sfx = generate_random_filename()
    context_file_name = "%s-%s" % (stringKey(context), random_name_sfx)
    #lock_name = "%s-%s" %(obj_type, context_file_name)
    #!+LOCKING(AH, 25-01-2014) disabling file locking
    #! locking was reqiured when the serializer used ta constant file name
    #! for an object. Now serialized file names are unique, and non repeated
    #with LockStore.get_lock(lock_name):
    #    
    #root key (used to cache files to zip)
    root_key = make_key()
    # create a fake interaction to ensure items requiring a participation
    # are serialized 
    #!+SERIALIZATION(mb, Jan-2013) review this approach
    try:
        zope.security.management.getInteraction()
    except zope.security.interfaces.NoInteraction:
        principal = zope.security.testing.Principal("user", "manager", ())
        zope.security.management.newInteraction(create_participation(principal))
    include = []
    # data dict to be published
    data = {}
    if IFeatureVersion.providedBy(context):
        include.append("versions")
    if IFeatureEvent.providedBy(context):
        include.append("event")
    
    exclude = ["data", "event", "attachments"]
    updated_dict = obj2dict(context, 1, 
	    parent=None,
	    include=include,
	    exclude=exclude,
	    root_key=root_key
        )
    data.update(
        updated_dict
    )

    tags = IStateController(context).get_state().tags
    if tags:
        data["tags"] = tags
    permissions = get_object_state_rpm(context).permissions
    data["permissions"] = get_permissions_dict(permissions)

    # setup path to save serialized data
    path = os.path.join(setupStorageDirectory(), obj_type)
    log.info("Setting up path to write to : %s", path)
    if not os.path.exists(path):
        #
        # !+THREADSAFE(AH, 2014-09-24) making makedirs threadsafe, 
        # sometimes between checking for existence and execution 
        # of makedirs() the folder has already been created by 
        # another thread
        try:
            os.makedirs(path)
        except OSError as exc:
            if exc.errno == errno.EEXIST and os.path.isdir(path):
                log.info("Error Folder : %s already exists, ignoring exception ", path)
            else:
                raise

    # xml file path
    file_path = os.path.join(path, context_file_name) 
    # files to zip
    files = []

    if IFeatureAttachment.providedBy(context):
        attachments = getattr(context, "attachments", None)
        if attachments:
	    data["attachments"] = []
	    for attachment in attachments:
	        # serializing attachment
	        attachment_dict = obj2dict(attachment, 1,
	            parent=context,
	            exclude=["data", "event", "versions"])
	        # saving attachment to tmp
	        attached_file = tmp(delete=False)
	        attached_file.write(attachment.data)
	        attached_file.flush()
	        attached_file.close()
	        files.append(attached_file.name)
	        attachment_dict["saved_file"] = os.path.basename(
	            attached_file.name
	        )
	        data["attachments"].append(attachment_dict)

    # add explicit origin chamber for this object (used to partition data
    # in if more than one chamber exists)
    
    if obj_type == "Legislature":
        data["origin_chamber"] = None
    else:
        data["origin_chamber"] = get_origin_chamber(context)

    # add any additional files to file list
    files = files + PersistFiles.get_files(root_key)
    # zipping xml, attached files plus any binary fields
    # also remove the temporary files
    if files:
        # generate temporary xml file
        temp_xml = tmp(delete=False)
        temp_xml.write(serialize(data, name=obj_type))
        temp_xml.close()
        # write attachments/binary fields to zip
        with  ZipFile("%s.zip" % (file_path), "w") as zip_file:
	    for f in files:
	        zip_file.write(f, os.path.basename(f))
	    # write the xml
	    zip_file.write(temp_xml.name, "%s.xml" % os.path.basename(file_path))
        files.append(temp_xml.name)
    else:
        # save serialized xml to file
        with open("%s.xml" % (file_path), "w") as xml_file:
	    xml_file.write(serialize(data, name=obj_type))
	    xml_file.close()
    # publish to rabbitmq outputs queue
    connection = bungeni.core.notifications.get_mq_connection()
    if not connection:
        return
    channel = connection.channel()
    #channel.confirm_delivery()
    publish_file_path = "%s.%s" %(file_path, ("zip" if files else "xml"))
    #channel_delivery = 
    channel.basic_publish(
        exchange=SERIALIZE_OUTPUT_EXCHANGE,
        routing_key=SERIALIZE_OUTPUT_ROUTING_KEY,
        body=simplejson.dumps({"type": "file", "location": publish_file_path }),
        properties=pika.BasicProperties(content_type="text/plain",
            delivery_mode=2
        )
    )
    #if channel_delivery:
    #    log.info("Message published to exchange %s with key %s for %s" % 
    #        (SERIALIZE_OUTPUT_EXCHANGE, SERIALIZE_OUTPUT_ROUTING_KEY, publish_file_path))
    #else:
    #    log.error("Message publication failed for %r", publish_file_path)
        

    #clean up - remove any files if zip was/was not created
    if files:
        files.append("%s.%s" %(file_path, "xml"))
    else:
        files.append("%s.%s" %(file_path, "zip"))
    remove_files(files)

    # clear the cache
    PersistFiles.clear_files(root_key)
Beispiel #5
0
def publish_to_xml(context):
    """Generates XML for object and saves it to the file. If object contains
    attachments - XML is saved in zip archive with all attached files. 
    """

    #create a fake interaction to ensure items requiring a participation
    #are serialized
    #!+SERIALIZATION(mb, Jan-2013) review this approach
    try:
        zope.security.management.getInteraction()
    except zope.security.interfaces.NoInteraction:
        principal = zope.security.testing.Principal('user', 'manager', ())
        zope.security.management.newInteraction(
            create_participation(principal))

    include = []
    # list of files to zip
    files = []
    # data dict to be published
    data = {}

    context = zope.security.proxy.removeSecurityProxy(context)

    if interfaces.IFeatureVersion.providedBy(context):
        include.append("versions")
    if interfaces.IFeatureAudit.providedBy(context):
        include.append("event")

    exclude = ["data", "event", "attachments", "changes"]

    # include binary fields and include them in the zip of files for this object
    for column in class_mapper(context.__class__).columns:
        if column.type.__class__ == Binary:
            exclude.append(column.key)
            content = getattr(context, column.key, None)
            if content:
                bfile = tmp(delete=False)
                bfile.write(content)
                files.append(bfile.name)
                data[column.key] = dict(
                    saved_file=os.path.basename(bfile.name))
                bfile.close()
    data.update(
        obj2dict(context, 1, parent=None, include=include, exclude=exclude))
    obj_type = IWorkflow(context).name
    tags = IStateController(context).get_state().tags
    if tags:
        data["tags"] = tags
    permissions = get_object_state_rpm(context).permissions
    data["permissions"] = get_permissions_dict(permissions)
    data["changes"] = []
    for change in getattr(context, "changes", []):
        change_dict = obj2dict(change, 0, parent=context)
        change_permissions = get_head_object_state_rpm(change).permissions
        change_dict["permissions"] = get_permissions_dict(change_permissions)
        data["changes"].append(change_dict)

    # setup path to save serialized data
    path = os.path.join(setupStorageDirectory(), obj_type)
    if not os.path.exists(path):
        os.makedirs(path)

    # xml file path
    file_path = os.path.join(path, stringKey(context))

    if interfaces.IFeatureAttachment.providedBy(context):
        attachments = getattr(context, "attachments", None)
        if attachments:
            data["attachments"] = []
            for attachment in attachments:
                # serializing attachment
                attachment_dict = obj2dict(
                    attachment,
                    1,
                    parent=context,
                    exclude=["data", "event", "versions"])
                permissions = get_object_state_rpm(attachment).permissions
                attachment_dict["permissions"] = \
                    get_permissions_dict(permissions)
                # saving attachment to tmp
                attached_file = tmp(delete=False)
                attached_file.write(attachment.data)
                attached_file.flush()
                attached_file.close()
                files.append(attached_file.name)
                attachment_dict["saved_file"] = os.path.basename(
                    attached_file.name)
                data["attachments"].append(attachment_dict)

    # zipping xml, attached files plus any binary fields
    # also remove the temporary files
    if files:
        #generate temporary xml file
        temp_xml = tmp(delete=False)
        temp_xml.write(serialize(data, name=obj_type))
        temp_xml.close()
        #write attachments/binary fields to zip
        zip_file = ZipFile("%s.zip" % (file_path), "w")
        for f in files:
            zip_file.write(f, os.path.basename(f))
            os.remove(f)
        #write the xml
        zip_file.write(temp_xml.name, "%s.xml" % os.path.basename(file_path))
        zip_file.close()
        #placed remove after zip_file.close !+ZIP_FILE_CRC_FAILURE
        os.remove(temp_xml.name)

    else:
        # save serialized xml to file
        with open("%s.xml" % (file_path), "w") as xml_file:
            xml_file.write(serialize(data, name=obj_type))
            xml_file.close()

    #publish to rabbitmq outputs queue
    connection = get_mq_connection()
    if not connection:
        return
    channel = connection.channel()
    publish_file_path = "%s.%s" % (file_path, ("zip" if files else "xml"))
    channel.basic_publish(exchange=SERIALIZE_OUTPUT_EXCHANGE,
                          routing_key=SERIALIZE_OUTPUT_ROUTING_KEY,
                          body=simplejson.dumps({
                              "type": "file",
                              "location": publish_file_path
                          }),
                          properties=pika.BasicProperties(
                              content_type="text/plain", delivery_mode=2))

    #clean up - remove any files if zip was created
    if files:
        prev_xml_file = "%s.%s" % (file_path, "xml")
        if os.path.exists(prev_xml_file):
            os.remove(prev_xml_file)