text: # Licensed under the MIT license
  # http://opensource.org/licenses/mit-license.php
  
  # Copyright 2008, Frank Scholz <coherence@beebits.net>
  
  import os.path
  
  from twisted.internet import reactor, defer
  from twisted.python import failure, util
  
  from coherence.upnp.core import DIDLLite
  from coherence.upnp.core.soap_service import errorCode
  from coherence.upnp.core import utils
  
  import dbus
  
  import dbus.service
  
  import coherence.extern.louie as louie
  
  from coherence.backend import BackendItem, BackendStore
  
  ROOT_CONTAINER_ID = 0
  AUDIO_CONTAINER_ID = 100
  AUDIO_ALL_CONTAINER_ID = 101
  AUDIO_ARTIST_CONTAINER_ID = 102
  AUDIO_ALBUM_CONTAINER_ID = 103
  AUDIO_PLAYLIST_CONTAINER_ID = 104
  AUDIO_GENRE_CONTAINER_ID = 105
  
  VIDEO_CONTAINER_ID = 200
  VIDEO_ALL_CONTAINER_ID = 201
  
  IMAGE_CONTAINER_ID = 300
  IMAGE_ALL_CONTAINER_ID = 301
  
  BUS_NAME = 'org.freedesktop.Tracker'
  OBJECT_PATH = '/org/freedesktop/tracker'
  
  tracks_query = """
  <rdfq:Condition>\
  <rdfq:equals>\
  <rdfq:Property name="Audio:Title" />\
  <rdf:String>*</rdf:String>\
  </rdfq:equals>\
  </rdfq:Condition>\
  """
  
  video_query = """
  <rdfq:Condition>\
  <rdfq:equals>\
  <rdfq:Property name="File:Name" />\
  <rdf:String>*</rdf:String>\
  </rdfq:equals>\
  </rdfq:Condition>\
  """
  
  image_query = """
  <rdfq:Condition>\
  <rdfq:equals>\
  <rdfq:Property name="File:Name" />\
  <rdf:String>*</rdf:String>\
  </rdfq:equals>\
  </rdfq:Condition>\
  """
  
  
  class Container(BackendItem):
  
      logCategory = 'tracker_store'
  
      def __init__(self, id, parent_id, name, store=None, children_callback=None, container_class=DIDLLite.Container):
          self.id = id
          self.parent_id = parent_id
          self.name = name
          self.mimetype = 'directory'
          self.item = container_class(id, parent_id,self.name)
          self.item.childCount = 0
          self.update_id = 0
          if children_callback != None:
              self.children = children_callback
          else:
              self.children = util.OrderedDict()
          self.item.childCount = None #self.get_child_count()
  
          if store!=None:
              self.get_url = lambda: store.urlbase + str(self.id)
  
      def add_child(self, child):
          id = child.id
          if isinstance(child.id, basestring):
              _,id = child.id.split('.')
          self.children[id] = child
          if self.item.childCount != None:
              self.item.childCount += 1
  
      def get_children(self,start=0,end=0):
          self.info("container.get_children %r %r", start, end)
  
          if callable(self.children):
              return self.children(start,end-start)
          else:
              children = self.children.values()
          if end == 0:
              return children[start:]
          else:
              return children[start:end]
  
      def get_child_count(self):
          if self.item.childCount != None:
              return self.item.childCount
  
          if callable(self.children):
              return len(self.children())
          else:
              return len(self.children)
  
      def get_item(self):
          return self.item
  
      def get_name(self):
          return self.name
  
      def get_id(self):
          return self.id
  
  
  class Artist(BackendItem):
  
      logCategory = 'tracker_store'
  
      def __init__(self, store, id, name):
          self.store = store
          self.id = 'artist.%d' % int(id)
          self.name = name
          self.children = {}
          self.sorted_children = None
  
      def add_child(self, child):
          _,id = child.id.split('.')
          self.children[id] = child
  
      def get_children(self,start=0,end=0):
          children = []
          if self.sorted_children != None:
              for key in self.sorted_children:
                  children.append(self.children[key])
          else:
              def childs_sort(x,y):
                  r = cmp(self.children[x].name,self.children[y].name)
                  return r
  
              self.sorted_children = self.children.keys()
              self.sorted_children.sort(cmp=childs_sort)
              for key in self.sorted_children:
                  children.append(self.children[key])
  
          if end == 0:
              return children[start:]
          else:
              return children[start:end]
  
      def get_child_count(self):
          return len(self.children)
  
      def get_item(self, parent_id = AUDIO_ARTIST_CONTAINER_ID):
          item = DIDLLite.MusicArtist(self.id, parent_id, self.name)
          return item
  
      def get_id(self):
          return self.id
  
      def get_name(self):
          return self.name
  
  
  class Album(BackendItem):
  
      logCategory = 'tracker_store'
  
      def __init__(self, store, id, title, artist):
          self.store = store
          self.id = 'album.%d' % int(id)
          self.name = unicode(title)
          self.artist = unicode(artist)
          self.cover = None
          self.children = {}
          self.sorted_children = None
  
      def add_child(self, child):
          _,id = child.id.split('.')
          self.children[id] = child
  
      def get_children(self,start=0,end=0):
          children = []
          if self.sorted_children != None:
              for key in self.sorted_children:
                  children.append(self.children[key])
          else:
              def childs_sort(x,y):
                  r = cmp(self.children[x].track_nr,self.children[y].track_nr)
                  return r
  
              self.sorted_children = self.children.keys()
              self.sorted_children.sort(cmp=childs_sort)
              for key in self.sorted_children:
                  children.append(self.children[key])
  
          if end == 0:
              return children[start:]
          else:
              return children[start:end]
  
      def get_child_count(self):
          return len(self.children)
  
      def get_item(self, parent_id = AUDIO_ALBUM_CONTAINER_ID):
          item = DIDLLite.MusicAlbum(self.id, parent_id, self.name)
          item.childCount = self.get_child_count()
          item.artist = self.artist
          item.albumArtURI = self.cover
          return item
  
      def get_id(self):
          return self.id
  
      def get_name(self):
          return self.name
  
      def get_cover(self):
          return self.cover
  
  
  class Track(BackendItem):
  
      logCategory = 'tracker_store'
  
      def __init__(self,store,
                   id,parent_id,
                   file,title,
                   artist,album,genre,\
                   duration,\
                   track_number,\
                   size,mimetype):
  
          self.store = store
          self.id = 'song.%d' % int(id)
          self.parent_id = parent_id
  
          self.path = unicode(file)
  
          duration = str(duration).strip()
          if len(duration) == 0:
              duration = 0
          seconds = int(duration)
          hours = seconds / 3600
          seconds = seconds - hours * 3600
          minutes = seconds / 60
          seconds = seconds - minutes * 60
          self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds)
  
          self.bitrate = 0
  
          self.title = unicode(title)
          self.artist = unicode(artist)
          self.album = unicode(album)
          self.genre = unicode(genre)
          track_number = str(track_number).strip()
          if len(track_number) == 0:
              track_number = 1
          self.track_nr = int(track_number)
  
          self.cover = None
          self.mimetype = str(mimetype)
          self.size = int(size)
  
          self.url = self.store.urlbase + str(self.id)
  
  
      def get_children(self, start=0, end=0):
          return []
  
      def get_child_count(self):
          return 0
  
      def get_item(self, parent_id=None):
  
          self.debug("Track get_item %r @ %r" %(self.id,self.parent_id))
  
          # create item
          item = DIDLLite.MusicTrack(self.id,self.parent_id)
          item.album = self.album
  
          item.artist = self.artist
          #item.date =
          item.genre = self.genre
          item.originalTrackNumber = self.track_nr
          item.title = self.title
  
          item.albumArtURI = self.cover
  
          # add http resource
          res = DIDLLite.Resource(self.url, 'http-get:*:%s:*' % self.mimetype)
          if self.size > 0:
              res.size = self.size
          if self.duration > 0:
              res.duration = str(self.duration)
          if self.bitrate > 0:
              res.bitrate = str(bitrate)
          item.res.append(res)
  
          return item
  
      def get_id(self):
          return self.id
  
      def get_name(self):
          return self.title
  
      def get_url(self):
          return self.url
  
      def get_path(self):
          return self.path
  
  
  class Video(BackendItem):
  
      logCategory = 'tracker_store'
  
      def __init__(self,store,
                   id,parent_id,
                   file,title,
                   duration,\
                   size,mimetype):
  
          self.store = store
          self.id = 'video.%d' % int(id)
          self.parent_id = parent_id
  
          self.path = unicode(file)
  
          duration = str(duration).strip()
          if len(duration) == 0:
              duration = 0
          seconds = int(duration)
          hours = seconds / 3600
          seconds = seconds - hours * 3600
          minutes = seconds / 60
          seconds = seconds - minutes * 60
          self.duration = ("%d:%02d:%02d") % (hours, minutes, seconds)
  
          self.title = unicode(title)
  
          self.cover = None
          self.mimetype = str(mimetype)
          self.size = int(size)
  
          self.url = self.store.urlbase + str(self.id)
  
  
      def get_children(self, start=0, end=0):
          return []
  
      def get_child_count(self):
          return 0
  
      def get_item(self, parent_id=None):
  
          self.debug("Video get_item %r @ %r" %(self.id,self.parent_id))
  
          # create item
          item = DIDLLite.VideoItem(self.id,self.parent_id)
          #item.date =
          item.title = self.title
  
          item.albumArtURI = self.cover
  
          # add http resource
          res = DIDLLite.Resource(self.url, 'http-get:*:%s:*' % self.mimetype)
          if self.size > 0:
              res.size = self.size
          if self.duration > 0:
              res.duration = str(self.duration)
          item.res.append(res)
  
          return item
  
      def get_id(self):
          return self.id
  
      def get_name(self):
          return self.title
  
      def get_url(self):
          return self.url
  
      def get_path(self):
          return self.path
  
  
  class Image(BackendItem):
  
      logCategory = 'tracker_store'
  
      def __init__(self,store,
                   id,parent_id,
                   file,title,album,
                   date,width,height,\
                   size,mimetype):
  
          self.store = store
          self.id = 'image.%d' % int(id)
          self.parent_id = parent_id
  
          self.path = unicode(file)
  
          self.title = unicode(title)
  
          self.album = unicode(album.strip())
          self.mimetype = str(mimetype)
          self.size = int(size)
  
          self.url = self.store.urlbase + str(self.id)
  
  
      def get_children(self, start=0, end=0):
          return []
  
      def get_child_count(self):
          return 0
  
      def get_item(self, parent_id=None):
  
          self.debug("Image get_item %r @ %r" %(self.id,self.parent_id))
  
          # create item
          item = DIDLLite.ImageItem(self.id,self.parent_id)
          #item.date =
          item.title = self.title
  
          # add http resource
          res = DIDLLite.Resource(self.url, 'http-get:*:%s:*' % self.mimetype)
          if self.size > 0:
              res.size = self.size
          item.res.append(res)
  
          return item
  
      def get_id(self):
          return self.id
  
      def get_name(self):
          return self.title
  
      def get_url(self):
          return self.url
  
      def get_path(self):
          return self.path
  
  
  class TrackerStore(BackendStore):
  
      """ this is a backend to Meta Tracker
          http://www.gnome.org/projects/tracker/index.html
  
  
      """
  
      implements = ['MediaServer']
      logCategory = 'tracker_store'
  
      def __init__(self, server, **kwargs):
  
          if server.coherence.config.get('use_dbus','no') != 'yes':
              raise Exception, 'this backend needs use_dbus enabled in the configuration'
  
          self.config = kwargs
          self.name = kwargs.get('name','Tracker')
  
          self.urlbase = kwargs.get('urlbase','')
          if self.urlbase[len(self.urlbase)-1] != '/':
              self.urlbase += '/'
  
          self.server = server
          self.update_id = 0
          self.token = None
  
          self.songs = 0
          self.albums = 0
          self.artists = 0
          self.playlists = 0
          self.genres = 0
  
          self.videos = 0
          self.images = 0
  
          self.bus = dbus.SessionBus()
          tracker_object = self.bus.get_object(BUS_NAME,OBJECT_PATH)
          self.tracker_interface = dbus.Interface(tracker_object, 'org.freedesktop.Tracker')
          self.search_interface = dbus.Interface(tracker_object, 'org.freedesktop.Tracker.Search')
          self.keywords_interface = dbus.Interface(tracker_object, 'org.freedesktop.Tracker.Keywords')
          self.metadata_interface = dbus.Interface(tracker_object, 'org.freedesktop.Tracker.Metadata')
          self.query_id = -1
  
          self.containers = {}
          self.tracks = {}
          self.containers[ROOT_CONTAINER_ID] = \
                      Container(ROOT_CONTAINER_ID,-1,self.name,store=self)
  
          def queries_finished(r):
              louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)
  
          def queries_failed(r):
              error = ''
              louie.send('Coherence.UPnP.Backend.init_failed', None, backend=self, msg=error)
  
          services = kwargs.get('service','Music,Videos,Images')
          services = map(lambda x: x.strip().lower(),services.split(','))
  
          l = []
          mapping =  {'music':self.get_tracks,
                      'videos':self.get_videos,
                      'images':self.get_images}
          for service in services:
              try:
                  l.append(mapping[service]())
              except KeyError:
                  self.warning('Wrong Tracker service definition - %r' % service)
          if len(l)>0:
              dl = defer.DeferredList(l)
              dl.addCallback(queries_finished)
              dl.addErrback(lambda x: louie.send('Coherence.UPnP.Backend.init_failed', None, backend=self, msg='Connection to Tracker service(s) failed!'))
          else:
              louie.send('Coherence.UPnP.Backend.init_failed', None, backend=self, msg='No Tracker service defined!')
  
      def __repr__(self):
          return "TrackerStore"
  
      def get_by_id(self,id):
          self.info("looking for id %r", id)
          if isinstance(id, basestring):
              id = id.split('@',1)
              id = id[0]
          if isinstance(id, basestring) and id.startswith('artist_all_tracks_'):
              try:
                  return self.containers[id]
              except:
                  return None
          item = None
          try:
              id = int(id)
              item = self.containers[id]
          except (ValueError,KeyError):
              try:
                  type,id = id.split('.')
                  if type == 'song':
                      return self.containers[AUDIO_ALL_CONTAINER_ID].children[id]
                  if type == 'album':
                      return self.containers[AUDIO_ALBUM_CONTAINER_ID].children[id]
                  if type == 'artist':
                      return self.containers[AUDIO_ARTIST_CONTAINER_ID].children[id]
                  if type == 'video':
                      return self.containers[VIDEO_ALL_CONTAINER_ID].children[id]
                  if type == 'image':
                      return self.containers[IMAGE_ALL_CONTAINER_ID].children[id]
              except (ValueError,KeyError):
                  return None
          return item
  
      def get_videos(self):
  
          def handle_error(error):
              return error
  
          def parse_videos_query_result(resultlist):
              videos = []
              for video in resultlist:
                  file,_,title,\
                  duration,\
                  size,mimetype = video
                  title = title.strip()
                  if len(title) == 0:
                      title = os.path.basename(file)
                  if mimetype == 'video/x-theora+ogg':
                      mimetype = u'video/ogg'
                  video_item = Video(self,
                                     self.videos,VIDEO_ALL_CONTAINER_ID,
                                     file,title,\
                                     duration,\
                                     size,mimetype)
                  self.videos += 1
                  videos.append(video_item)
  
              videos.sort(cmp=lambda x,y : cmp(x.get_name().lower(),y.get_name().lower()))
              for video_item in videos:
                  self.containers[VIDEO_ALL_CONTAINER_ID].add_child(video_item)
  
          self.containers[VIDEO_CONTAINER_ID] = \
                      Container(VIDEO_CONTAINER_ID,ROOT_CONTAINER_ID,'Video',store=self)
          self.containers[ROOT_CONTAINER_ID].add_child(self.containers[VIDEO_CONTAINER_ID])
  
          self.containers[VIDEO_ALL_CONTAINER_ID] = \
                  Container( VIDEO_ALL_CONTAINER_ID,VIDEO_CONTAINER_ID,'All Videos',
                            store=self,
                            children_callback=None)
          self.containers[VIDEO_CONTAINER_ID].add_child(self.containers[VIDEO_ALL_CONTAINER_ID])
  
          fields=[u'Video:Title',u'Video:Duration',
                  u'File:Size',u'File:Mime']
  
          d = defer.Deferred()
          d.addCallback(parse_videos_query_result)
          d.addErrback(handle_error)
          self.search_interface.Query(self.query_id,'Videos',fields,'','',video_query,False,0,-1,
                                      reply_handler=lambda x: d.callback(x),error_handler=lambda x: d.errback(x))
          return d
  
      def get_images(self):
  
          def handle_error(error):
              return error
  
          def parse_images_query_result(resultlist):
              images = []
              for image in resultlist:
                  file,_,title,album,\
                  date,width, height, \
                  size,mimetype = image
                  title = title.strip()
                  if len(title) == 0:
                      title = os.path.basename(file)
                  image_item = Image(self,
                                     self.images,IMAGE_ALL_CONTAINER_ID,
                                     file,title,album,\
                                     date,width,height,\
                                     size,mimetype)
                  self.images += 1
                  images.append(image_item)
  
              images.sort(cmp=lambda x,y : cmp(x.get_name().lower(),y.get_name().lower()))
              for image_item in images:
                  self.containers[IMAGE_ALL_CONTAINER_ID].add_child(image_item)
  
          self.containers[IMAGE_CONTAINER_ID] = \
                      Container(IMAGE_CONTAINER_ID,ROOT_CONTAINER_ID,'Images',store=self)
          self.containers[ROOT_CONTAINER_ID].add_child(self.containers[IMAGE_CONTAINER_ID])
  
          self.containers[IMAGE_ALL_CONTAINER_ID] = \
                  Container(IMAGE_ALL_CONTAINER_ID,IMAGE_CONTAINER_ID,'All Images',
                            store=self,
                            children_callback=None)
          self.containers[IMAGE_CONTAINER_ID].add_child(self.containers[IMAGE_ALL_CONTAINER_ID])
  
          fields=[u'Image:Title',u'Image:Album',
                  u'Image:Date',u'Image:Width',u'Image:Height',
                  u'File:Size',u'File:Mime']
  
          d = defer.Deferred()
          d.addCallback(parse_images_query_result)
          d.addErrback(handle_error)
          self.search_interface.Query(self.query_id,'Images',fields,'','',image_query,False,0,-1,
                                      reply_handler=lambda x: d.callback(x),error_handler=lambda x: d.errback(x))
          return d
  
  
      def get_tracks(self):
  
          def handle_error(error):
              return error
  
          def parse_tracks_query_result(resultlist):
              albums = {}
              artists = {}
              tracks = []
              for track in resultlist:
                  file,service,title,artist,album,genre,\
                  duration,album_track_count,\
                  track_number,codec,\
                  size,mimetype = track
                  if mimetype == 'video/x-vorbis+ogg':
                      mimetype = 'audio/ogg'
                  track_item = Track(self,
                                     self.songs,AUDIO_ALL_CONTAINER_ID,
                                     file,title,artist,album,genre,\
                                     duration,\
                                     track_number,\
                                     size,mimetype)
                  self.songs += 1
                  tracks.append(track_item)
  
              tracks.sort(cmp=lambda x,y : cmp(x.get_name(),y.get_name()))
              for track_item in tracks:
                  self.containers[AUDIO_ALL_CONTAINER_ID].add_child(track_item)
  
                  try:
                      album_item = albums[track_item.album]
                      album_item.add_child(track_item)
                  except:
                      album_item = Album(self, self.albums, track_item.album, track_item.artist)
                      albums[unicode(track_item.album)] = album_item
                      self.albums += 1
                      album_item.add_child(track_item)
  
                      try:
                          artist_item = artists[track_item.artist]
                          artist_item.add_child(album_item)
                      except:
                          artist_item = Artist(self, self.artists, track_item.artist)
                          artists[unicode(track_item.artist)] = artist_item
                          self.artists += 1
                          artist_item.add_child(album_item)
  
              sorted_keys = albums.keys()
              sorted_keys.sort()
              for key in sorted_keys:
                  self.containers[AUDIO_ALBUM_CONTAINER_ID].add_child(albums[key])
              sorted_keys = artists.keys()
              sorted_keys.sort()
              for key in sorted_keys:
                  self.containers[AUDIO_ARTIST_CONTAINER_ID].add_child(artists[key])
  
  
          self.containers[AUDIO_CONTAINER_ID] = \
                      Container(AUDIO_CONTAINER_ID,ROOT_CONTAINER_ID,'Audio',store=self)
          self.containers[ROOT_CONTAINER_ID].add_child(self.containers[AUDIO_CONTAINER_ID])
  
          self.containers[AUDIO_ALL_CONTAINER_ID] = \
                  Container( AUDIO_ALL_CONTAINER_ID,AUDIO_CONTAINER_ID,'All Tracks',
                            store=self,
                            children_callback=None)
          self.containers[AUDIO_CONTAINER_ID].add_child(self.containers[AUDIO_ALL_CONTAINER_ID])
  
          self.containers[AUDIO_ALBUM_CONTAINER_ID] = \
                  Container( AUDIO_ALBUM_CONTAINER_ID,AUDIO_CONTAINER_ID,'Albums',
                            store=self,
                            children_callback=None)
          self.containers[AUDIO_CONTAINER_ID].add_child(self.containers[AUDIO_ALBUM_CONTAINER_ID])
  
          self.containers[AUDIO_ARTIST_CONTAINER_ID] = \
                  Container( AUDIO_ARTIST_CONTAINER_ID,AUDIO_CONTAINER_ID,'Artists',
                            store=self,
                            children_callback=None)
          self.containers[AUDIO_CONTAINER_ID].add_child(self.containers[AUDIO_ARTIST_CONTAINER_ID])
  
          self.containers[AUDIO_PLAYLIST_CONTAINER_ID] = \
                  Container( AUDIO_PLAYLIST_CONTAINER_ID,AUDIO_CONTAINER_ID,'Playlists',
                            store=self,
                            children_callback=None,
                            container_class=DIDLLite.PlaylistContainer)
          self.containers[AUDIO_CONTAINER_ID].add_child(self.containers[AUDIO_PLAYLIST_CONTAINER_ID])
  
          self.containers[AUDIO_GENRE_CONTAINER_ID] = \
                  Container( AUDIO_GENRE_CONTAINER_ID,AUDIO_CONTAINER_ID,'Genres',
                            store=self,
                            children_callback=None)
          self.containers[AUDIO_CONTAINER_ID].add_child(self.containers[AUDIO_GENRE_CONTAINER_ID])
  
  
          self.wmc_mapping.update({'4': lambda : self.get_by_id(AUDIO_ALL_CONTAINER_ID),       # all tracks
                                   '5': lambda : self.get_by_id(AUDIO_GENRE_CONTAINER_ID),     # all genres
                                   '6': lambda : self.get_by_id(AUDIO_ARTIST_CONTAINER_ID),    # all artists
                                   '7': lambda : self.get_by_id(AUDIO_ALBUM_CONTAINER_ID),     # all albums
                                   '13': lambda : self.get_by_id(AUDIO_PLAYLIST_CONTAINER_ID), # all playlists
                                  })
  
          fields=[u'Audio:Title',u'Audio:Artist',
                  u'Audio:Album',u'Audio:Genre',
                  u'Audio:Duration',u'Audio:AlbumTrackCount',
                  u'Audio:TrackNo',u'Audio:Codec',
                  u'File:Size', u'File:Mime']
  
          d = defer.Deferred()
          d.addCallback(parse_tracks_query_result)
          d.addErrback(handle_error)
          self.search_interface.Query(self.query_id,'Music',fields,'','',tracks_query,False,0,-1,
                                      reply_handler=lambda x: d.callback(x),error_handler=lambda x: d.errback(x))
          return d
  
  
  
      def upnp_init(self):
          if self.server:
              self.server.connection_manager_server.set_variable(0, 'SourceProtocolInfo',
                              ['http-get:*:audio/mpeg:*',
                               'internal:%s:audio/mpeg:*' % self.server.coherence.hostname,
                               'http-get:*:application/ogg:*',
                               'internal:%s:application/ogg:*' % self.server.coherence.hostname,
                               'http-get:*:audio/ogg:*',
                               'internal:%s:audio/ogg:*' % self.server.coherence.hostname,
                               'http-get:*:video/ogg:*',
                               'internal:%s:video/ogg:*' % self.server.coherence.hostname,
                               'http-get:*:video/mpeg:*',
                               'internal:%s:video/mpeg:*' % self.server.coherence.hostname,
                               'http-get:*:video/x-msvideo:*',
                               'internal:%s:video/x-msvideo:*' % self.server.coherence.hostname,
                               'http-get:*:video/avi:*',
                               'internal:%s:video/avi:*' % self.server.coherence.hostname,
                               'http-get:*:video/mp4:*',
                               'internal:%s:video/mp4:*' % self.server.coherence.hostname,
                               'http-get:*:video/quicktime:*',
                               'internal:%s:video/quicktime:*' % self.server.coherence.hostname,
                               'http-get:*:image/jpg:*',
                               'internal:%s:image/jpg:*' % self.server.coherence.hostname,
                               'http-get:*:image/png:*',
                               'internal:%s:image/png:*' % self.server.coherence.hostname,
                               'http-get:*:image/gif:*',
                               'internal:%s:image/gif:*' % self.server.coherence.hostname,])
  