Esempio n. 1
0
def smush(path, generation, domain):
    logging.info('Smushing '+str(domain)+' '+str(path))
    import httplib, urllib

    params = urllib.urlencode([
        ('img', 'http://'+domain+'/'+path),
    ])

    conn = httplib.HTTPConnection('www.smushit.com')
    conn.request('GET', '/ysmush.it/ws.php?'+params)
    response = conn.getresponse()
    data = response.read()
    logging.info('data: '+str(data))
    conn.close

    result=loads(data)
    dest=result['dest']

    response = urlfetch.fetch(dest, follow_redirects=True)
    if response.status_code!=200:
        logging.error('Error smushing')
        return

    resource = Resource.find(path=path, generation=generation, domain=domain)
    if not resource:
        logging.error('Nothing to smush')
        return

    resource.content=response.content
    resource.save()
Esempio n. 2
0
def minify_js(path, generation, domain):
    logging.info('Minifying '+str(domain)+' '+str(path))
    import httplib, urllib

    resource = Resource.find(path=path, generation=generation, domain=domain)
    if not resource:
        logging.error('Nothing to minify')
        return

    params = urllib.urlencode([
        ('js_code',resource.content),
        ('compilation_level', 'SIMPLE_OPTIMIZATIONS'),
        ('output_format', 'text'),
        ('output_info', 'compiled_code'),
    ])

    headers = { "Content-type": "application/x-www-form-urlencoded" }
    conn = httplib.HTTPConnection('closure-compiler.appspot.com')
    conn.request('POST', '/compile', params, headers)
    response = conn.getresponse()
    data = response.read()
    conn.close
    if data[:9]!='Error(22)' and len(data)>2:
      resource.content=data
    resource.save()
Esempio n. 3
0
 def get_resource(self, path):
     domain = os.environ['SERVER_NAME']
     resource = Resource.find(path=path,
                              generation=self.settings.version,
                              domain=domain)
     if resource is None:
         content = self.fetch_resource_content(path)
         created_on = self.fetch_file_timestamp(path)
         resource = Resource(path=path,
                             content=content,
                             generation=self.settings.version)
         if created_on is not None:
             resource.created_on = created_on
         try:
             length = len(resource.content)
         except:
             length = 0
         if length > 0:
             log_event("Caching resource <code>%s</code> (%d bytes)" %
                       (path, length))
         logging.debug("VFS: caching resource %s (%d bytes) for %s", path,
                       length, domain)
         resource.domain = domain
         if content != None:
             resource.save()
     try:
         length = len(resource.content)
     except:
         length = 0
     logging.debug("VFS: serving resource %s (%d bytes) for %s", path,
                   length, domain)
     return resource
Esempio n. 4
0
 def get_resource(self, path):
     # check if file is fresh in cache
     resource = Resource.find(path=path)
     if resource is not None:
         stamp = self.fetch_file_timestamp(path)
         if stamp is not None and resource.created_on != stamp:
             logging.debug("VFS: file %s has been modified since last time => purged from cache", path)
             resource.delete()
     return super(LocalVFS, self).get_resource(path)
Esempio n. 5
0
 def get_resource(self, path):
     # check if file is fresh in cache
     resource = Resource.find(path=path, domain=os.environ['SERVER_NAME'])
     if resource is not None:
         stamp = self.fetch_file_timestamp(path)
         if stamp is not None and resource.created_on != stamp:
             logging.debug(
                 "VFS: file %s has been modified since last time => purged from cache",
                 path)
             resource.delete()
     return super(LocalVFS, self).get_resource(path)
Esempio n. 6
0
 def get_resource(self, path):
     domain = os.environ['SERVER_NAME']
     resource = Resource.find(path=path, generation=self.settings.version, domain=domain)
     if resource is None:
         content = self.fetch_resource_content(path)
         created_on = self.fetch_file_timestamp(path)
         resource = Resource(path=path, content=content, generation=self.settings.version)
         if created_on is not None:
             resource.created_on = created_on
         try:
             length = len(resource.content)
         except:
             length = 0
         if length>0:
             log_event("Caching resource <code>%s</code> (%d bytes)" % (path, length))
         logging.debug("VFS: caching resource %s (%d bytes) for %s", path, length, domain)
         resource.domain = domain
         if content!=None:
           resource.save()
     try:
         length = len(resource.content)
     except:
         length = 0
     logging.debug("VFS: serving resource %s (%d bytes) for %s", path, length, domain)
     return resource
Esempio n. 7
0
 def get_resource(self, path):
     domain = os.environ['SERVER_NAME']
     resource = Resource.find(path=path, generation=self.settings.version, domain=domain)
     if resource is None:
         content = self.fetch_resource_content(path)
         created_on = self.fetch_file_timestamp(path)
         resource = Resource(path=path, content=content, generation=self.settings.version)
         if created_on is not None:
             resource.created_on = created_on
         try:
             length = len(resource.content)
         except:
             length = 0
         if length>0:
             log_event("Caching resource <code>%s</code> (%d bytes)" % (path, length))
         logging.debug("VFS: caching resource %s (%d bytes) for %s", path, length, domain)
         resource.domain = domain
         if content!=None:
             basename, extension = os.path.splitext(path)
             optimizations = Optimizations.all().filter("domain =", os.environ['SERVER_NAME']).get()
             logging.info('optimizations: '+str(optimizations))
             if extension=='.js' and optimizations and optimizations.minify_js:
                 logging.info('Deferring to minify')
                 logging.debug(str(path)+' '+str(self.settings.version)+' '+str(domain))
                 deferred.defer(minify_js, path, self.settings.version, domain)
             elif extension=='.css' and optimizations and optimizations.minify_css:
                 from drydrop.lib.slimmer import css_slimmer
                 resource.content=css_slimmer(resource.content)
             elif (extension=='.html' or (extension==None and path[-1]=='/')) and optimizations and optimizations.minify_html:
                 from drydrop.lib.slimmer import html_slimmer
                 resource.content=html_slimmer(resource.content)
             elif (extension=='.png' or extension=='.jpg' or extension=='.jpeg') and optimizations and optimizations.minify_css:
                 logging.info('Deferring to smush')
                 logging.debug(str(path)+' '+str(self.settings.version)+' '+str(domain))
                 deferred.defer(smush, path, self.settings.version, domain)
             resource.save()
     try:
         length = len(resource.content)
     except:
         length = 0
     logging.debug("VFS: serving resource %s (%d bytes) for %s", path, length, domain)
     return resource
Esempio n. 8
0
 def get_all_resources(self):
     return Resource.all().filter("generation =", self.settings.version).fetch(1000)
Esempio n. 9
0
 def flush_resource(self, path):
     # purge all generations
     resources = Resource.all().filter("path =", path).fetch(1000)
     db.delete(resources)
Esempio n. 10
0
 def flush_resources(self, count = 1000):
     deleted = Resource.clear(False, count)
     finished = deleted<count
     return finished, deleted
Esempio n. 11
0
 def get_all_resources(self):
     return Resource.all().filter("generation =",
                                  self.settings.version).filter(
                                      "domain =",
                                      os.environ['SERVER_NAME']).fetch(1000)
Esempio n. 12
0
 def flush_resource(self, path):
     # purge all generations
     resources = Resource.all().filter("path =", path).filter(
         "domain =", os.environ['SERVER_NAME']).fetch(1000)
     db.delete(resources)
Esempio n. 13
0
 def flush_resources(self, count=1000):
     domain = os.environ['SERVER_NAME']
     deleted = Resource.clear(False, count, domain=domain)
     finished = deleted < count
     return finished, deleted
Esempio n. 14
0
 def get_all_resources(self):
     return Resource.all().filter("generation =", self.settings.version).filter("domain =", os.environ['SERVER_NAME']).fetch(1000)
Esempio n. 15
0
 def flush_resource(self, path):
     # purge all generations
     resources = Resource.all().filter("path =", path).filter("domain =", os.environ['SERVER_NAME']).fetch(1000)
     db.delete(resources)
Esempio n. 16
0
 def flush_resources(self, count = 1000):
     domain = os.environ['SERVER_NAME']
     deleted = Resource.clear(False, count, domain=domain)
     finished = deleted<count
     return finished, deleted