def load_encapsulating_entry(_id, client_user_agent = None, cds = None, deleted = False):
"""
Loads a matching MpEntry for the given MpEntry instance based ID or VFS URL.
:param _id: MpEntry instance based ID or VFS URL
:param client_user_agent: Client user agent
:param cds: UPnP CDS
:param deleted: True to include deleted resources
:return: (object) Resource object; None on error
:since: v0.2.00
"""
if (_id is None): raise TypeException("MpEntry ID or VFS URL given is invalid")
_return = None
if ("://" in _id
and (_id.startswith("mp-entry:") or _id.startswith("mp-entry-"))
): _return = MpEntry.load_cds_id(_id, client_user_agent, cds, deleted)
else:
vfs_object = Implementation.load_vfs_url(_id, True)
if (vfs_object.is_directory()): entry_class_name = "dNG.data.upnp.resources.MpEntry"
else:
mimetype = vfs_object.get_mimetype()
mimetype_definition = MimeType.get_instance().get(mimetype = mimetype)
mimeclass = (mimetype.split("/", 1)[0] if (mimetype_definition is None) else mimetype_definition['class'])
camel_case_mimeclass = "".join([ word.capitalize() for word in re.split("\\W", mimeclass) ])
entry_class_name = "dNG.data.upnp.resources.MpEntry{0}".format(camel_case_mimeclass)
if (not NamedLoader.is_defined(entry_class_name)): entry_class_name = "dNG.data.upnp.resources.MpEntry"
#
_return = NamedLoader.get_instance(entry_class_name, False)
if (_return is not None and (not _return.init_cds_id(_id, client_user_agent, deleted))): _return = None
#
return _return
def execute_resource(self):
"""
Action for "resource"
:since: v0.2.00
"""
rid = InputFilter.filter_control_chars(self.request.get_dsd("urid", ""))
client_settings = self.get_client_settings()
self.response.init(True, compress = client_settings.get("upnp_http_compression_supported", True))
self._ensure_access_granted()
if (client_settings.get("upnp_stream_filter_resource_id_hook_call", False)):
rid_filtered = Hook.call("dNG.pas.upnp.Stream.filterResourceID",
rid = rid,
request = self.request,
response = self.response,
client_settings = client_settings
)
if (rid_filtered is not None): rid = rid_filtered
#
resource = Resource.load_cds_id(rid, client_settings)
if (resource is None): raise TranslatableError("pas_http_core_404", 404)
if ((not resource.is_supported("stream_vfs_url"))
and (not resource.is_supported("vfs_url"))
): raise TranslatableError("pas_http_core_400", 400)
if (self.response.is_supported("headers")):
Stream._add_dlna_headers(self.request, self.response, resource)
self.response.set_header("Content-Type", resource.get_mimetype())
#
vfs_url = (resource.get_stream_vfs_url()
if (resource.is_supported("stream_vfs_url"))
else resource.get_vfs_url()
)
if (client_settings.get("upnp_stream_filter_url_hook_call", False)):
vfs_url_filtered = Hook.call("dNG.pas.upnp.Stream.filterUrl",
resource = resource,
vfs_url = vfs_url,
request = self.request,
response = self.response,
client_settings = client_settings
)
if (vfs_url_filtered is not None): vfs_url = vfs_url_filtered
#
vfs_url_elements = urlsplit(vfs_url)
streamer_class = (""
if (vfs_url_elements.scheme == "") else
"".join([ word.capitalize() for word in vfs_url_elements.scheme.split("-") ])
)
streamer = None
if (streamer_class == "" or (not NamedLoader.is_defined("dNG.data.streamer.{0}".format(streamer_class)))):
vfs_object = Implementation.load_vfs_url(vfs_url, True)
if (not vfs_object.is_valid()): raise TranslatableError("pas_http_core_400", 400)
streamer = FileLike()
streamer.set_file(vfs_object)
streamer.set_size(resource.get_size())
else:
streamer = NamedLoader.get_instance("dNG.data.streamer.{0}".format(streamer_class))
if (not streamer.open_url(vfs_url)): raise TranslatableError("pas_http_core_400", 400)
#
if (client_settings.get("upnp_stream_handle_event_hook_call", False)):
Hook.call("dNG.pas.upnp.Stream.onHandle",
resource = resource,
streamer = streamer,
request = self.request,
response = self.response,
client_settings = client_settings
)
#
Streaming.handle(self.request, streamer, self.response)
