cartocss_helper 1.2.1 → 4.0.0

data/lib/cartocss_helper/git.rb

@@ -1,38 +1,28 @@
 require_relative 'configuration.rb'
+require_relative 'util/systemhelper.rb'
+
+include SystemHelper
 
 module CartoCSSHelper
   module Git
-    def checkout(branch, debug=false)
-      silence = '> /dev/null 2>&1'
-      if debug
-        silence = ''
-      end
-      Dir.chdir(Configuration.get_path_to_tilemill_project_folder) {
+    def checkout(branch, debug = false)
+      Dir.chdir(Configuration.get_path_to_cartocss_project_folder) do
         require 'open3'
-        command = "git checkout #{branch} #{silence}"
-        Open3.popen3(command) {|_, stdout, stderr, wait_thr |
-          error = stderr.read.chomp
-          if error != '' or wait_thr.value.success? != true
-            raise 'failed checkout to ' + branch + ' due to ' + error
-          end
-          return
-        }
-        raise 'impossible happened'
-      }
+        command = "git checkout #{branch}"
+        begin
+          execute_command(command, debug, ignore_stderr_presence: true) # or maybe just do not run if it is currently in the wanted branch?
+        rescue FailedCommandException => e
+          raise "failed checkout to #{branch} due to #{e}"
+        end
+      end
     end
 
     def get_commit_hash
-      Dir.chdir(Configuration.get_path_to_tilemill_project_folder) {
-        Open3.popen3('git log -n 1 --pretty=format:"%H"') {|_, stdout, stderr, wait_thr|
-          commit = stdout.read.chomp
-          error = stderr.read.chomp
-          if error != '' or wait_thr.value.success? != true
-            raise error
-          end
-          return commit
-        }
-      }
+      Dir.chdir(Configuration.get_path_to_cartocss_project_folder) do
+        command = 'git log -n 1 --pretty=format:"%H"'
+        return execute_command(command)
+      end
       raise 'impossible happened'
     end
   end
-end
+end

data/lib/cartocss_helper/heuristic.rb

@@ -7,60 +7,59 @@ module CartoCSSHelper
       tags = get_tags_from_mss
       tags.merge(get_tags_from_yaml)
       tags.merge(get_tags_from_osm2pqsql)
-      #unrecovable = Set.new [['area', 'yes'], ['area', 'no']] #TODO - how this should be handled?
-      #tags.merge(unrecovable)
+      # unrecovable = Set.new [['area', 'yes'], ['area', 'no']] #TODO - how this should be handled?
+      # tags.merge(unrecovable)
       return tags.to_a.sort
     end
 
     def get_tags_from_mss
       tags = Set.new
-      filenames = Dir[Configuration.get_path_to_tilemill_project_folder+'*.mss']
-      filenames.each { |filename|
-        tags.merge(get_tags_from_mss_file filename)
-      }
+      filenames = Dir[Configuration.get_path_to_cartocss_project_folder + '*.mss']
+      filenames.each do |filename|
+        tags.merge(get_tags_from_mss_file(filename))
+      end
       return tags
     end
 
     def get_tags_from_yaml
       tags = Set.new
-      filenames = Dir[Configuration.get_path_to_tilemill_project_folder+'*.yaml']
-      filenames.each { |filename|
-        tags.merge(get_tags_from_yaml_file filename)
-      }
-      return  tags
+      filenames = Dir[Configuration.get_path_to_cartocss_project_folder + '*.yaml']
+      filenames.each do |filename|
+        tags.merge(get_tags_from_yaml_file(filename))
+      end
+      return tags
     end
 
     def get_tags_from_osm2pqsql
       tags = Set.new
-      filenames = Dir[Configuration.get_path_to_tilemill_project_folder+'*.style']
-      filenames.each { |filename|
-        tags.merge(get_tags_from_osm2pqsql_file filename)
-      }
-      return  tags
+      filenames = Dir[Configuration.get_path_to_cartocss_project_folder + '*.style']
+      filenames.each do |filename|
+        tags.merge(get_tags_from_osm2pqsql_file(filename))
+      end
+      return tags
     end
 
     def get_tags_from_mss_file(style_filename)
       possible_key_values = get_tags_from_osm2pqsql
       tags = Set.new
-      #puts style_filename
+      # puts style_filename
       style_file = open(style_filename)
       style = style_file.read
       matched = style.scan(/\[feature = '(man_made|[^_]+)_([^']+)'\]/)
-      matched.each { |element|
+      matched.each do |element|
         key = element[0]
         if possible_key_values.include?([key, get_generic_tag_value])
           tags.add([key, element[1]])
         end
-      }
+      end
       matched = style.scan(/(\w+) = '(\w+)'/)
-      matched.each { |element|
+      matched.each do |element|
         key = element[0]
-        if key != 'feature'
-          if possible_key_values.include?([key, get_generic_tag_value])
-            tags.add([key, element[1]])
-          end
+        next unless key != 'feature'
+        if possible_key_values.include?([key, get_generic_tag_value])
+          tags.add([key, element[1]])
         end
-      }
+      end
       return tags
     end
 
@@ -69,32 +68,31 @@ module CartoCSSHelper
       tags = Set.new
       yaml_file = open(yaml_filename)
       yaml = yaml_file.read
-      #(.*\.|)     #WHERE p.highway = 'turning_circle'
-      #("|)        #natural and other SQL keywords
-      #([^"() ]+)  #tag
-      #repeat
+      # (.*\.|)     #WHERE p.highway = 'turning_circle'
+      # ("|)        #natural and other SQL keywords
+      # ([^"() ]+)  #tag
+      # repeat
       # =
-      #'([^'()]+)' #quoted value
+      # '([^'()]+)' #quoted value
       matched = yaml.scan(/(.*\.|)("|)([^"() ]+)("|) = '([^'()]+)'/)
-      matched.each { |element|
+      matched.each do |element|
         key = element[2]
         value = element[4]
         if possible_key_values.include?([key, get_generic_tag_value])
           tags.add([key, value])
         end
-      }
+      end
       matched = yaml.scan(/("|)([^"() ]+)("|) (NOT |)IN \(([^()]*)\)/)
-      matched.each { |element|
+      matched.each do |element|
         tag = element[1]
         key = tag.gsub(/.*\./, '')
         values = element[4]
         values_matched = values.scan(/'([^']+)'/)
-        if possible_key_values.include?([key, get_generic_tag_value])
-          values_matched.each { |value|
-            tags.add([key, value[0]])
-          }
+        next unless possible_key_values.include?([key, get_generic_tag_value])
+        values_matched.each do |value|
+          tags.add([key, value[0]])
         end
-      }
+      end
       return tags
     end
 
@@ -104,13 +102,13 @@ module CartoCSSHelper
 
     def get_tags_from_osm2pqsql_file(style_filename)
       tags = Set.new
-      #puts style_filename
+      # puts style_filename
       style_file = open(style_filename)
       style = style_file.read
       matched = style.scan(/^(node,way|node|way)\s*([^ ]+)\s*text\s*($|linear|polygon|nocache)/)
-      matched.each { |element|
+      matched.each do |element|
         tags.add([element[1], get_generic_tag_value])
-      }
+      end
       return tags
     end
   end

data/lib/cartocss_helper/image_generator.rb

@@ -2,15 +2,18 @@
 require_relative 'configuration.rb'
 require_relative 'heuristic.rb'
 require_relative 'data_file_handling.rb'
-require_relative 'tilemill_handler.rb'
+require_relative 'renderer_handler.rb'
 require 'fileutils'
 include CartoCSSHelper::Configuration
 include CartoCSSHelper::Heuristic
 
 module CartoCSSHelper
+  # Defines and generates images for synthethic comparison
+  # it is mostly glue between renderer and generator of synthethic data files
   class Scene
     attr_reader :tags, :zlevel, :on_water, :type
-    def initialize(tags, zlevel, on_water, type)
+    def initialize(tags, zlevel, on_water, type, show_what_is_generated = false)
+      @show_what_is_generated = show_what_is_generated
       raise 'tags not in hash' unless tags.respond_to?(:has_key?)
       @tags = tags
       @zlevel = zlevel
@@ -20,57 +23,52 @@ module CartoCSSHelper
         @tags['area'] = 'yes'
         @type = 'closed_way'
       end
+      @generated_image_location = nil
     end
 
     def is_output_different(another_scene)
-      if @on_water != another_scene.on_water
-        raise 'on_water mismatch'
-      end
-      #Returns true if the contents of a file A and a file B are identical.
-      return !FileUtils.compare_file(self.get_image_filename, another_scene.get_image_filename)
+      raise 'on_water mismatch' if @on_water != another_scene.on_water
+      return !is_output_identical(another_scene)
+    end
+
+    def is_output_identical(another_scene)
+      raise 'on_water mismatch' if @on_water != another_scene.on_water
+      # Returns true if the contents of a file A and a file B are identical.
+      return FileUtils.compare_file(get_image_filename, another_scene.get_image_filename)
     end
 
     def flush_cache
-      File.delete(self.get_filename)
+      File.delete(get_filename)
+    end
+
+    def on_water_string
+      on_water_string = ''
+      on_water_string = 'on_water' if @on_water
+      return on_water_string
     end
 
-    def get_image_filename(silent=true, debug=false)
+    def get_image_filename(debug = false) # TODO: misleading name - should be location
       lat = 0
       lon = 20
-      on_water_string = ''
-      if @on_water
-        lon = 0
-        on_water_string = 'on_water'
-      end
-      export_filename = self.get_filename
-      if File.exists?(export_filename)
-        return export_filename
+      lon = 0 if @on_water
+      if @generated_image_location != nil
+        return @generated_image_location if File.exist?(@generated_image_location)
       end
-      description = "tags: #{@tags.to_s}, zlevel: #{@zlevel}, type: #{@type} #{on_water_string}"
-      if !silent
-        puts "generating: #{description}"
+      description = "tags: #{@tags}, zlevel: #{@zlevel}, type: #{@type} #{on_water_string}"
+      puts "generating: #{description}" if @show_what_is_generated
+      generate_map(lat, lon, debug)
+      unless File.exist?(@generated_image_location) && @generated_image_location != nil
+        raise "get_image failed - #{description}. File <\n#{@generated_image_location}\n> was expected."
       end
-      generate_map(lat, lon,  debug)
-      if !File.exists?(export_filename)
-        description = "get_image failed - #{description}. File <\n#{export_filename}\n> was expected."
-        if debug
-          raise description
-        else
-          puts description
-          return get_image_filename(false, true)
-        end
-      end
-      return export_filename
+      return @generated_image_location
     end
 
     protected
 
     def get_filename
       water_part = ''
-      if @on_water
-        water_part = '_water'
-      end
-      return Configuration.get_path_to_folder_for_branch_specific_cache+@tags.to_a.sort.to_s+'_'+@zlevel.to_s+water_part+'_'+@type+'.png'
+      water_part = '_water' if @on_water
+      return @tags.to_a.sort.to_s + '_' + @zlevel.to_s + water_part + '_' + @type + '.png'
     end
 
     def generate_map(lat, lon, debug)
@@ -85,9 +83,9 @@ module CartoCSSHelper
     end
 
     def generate_image(lat, lon, debug)
-      export_filename = self.get_filename
-      bbox_size = self.get_bbox_size
-      TilemillHandler.run_tilemill_export_image(lat, lon,  @zlevel, [bbox_size, bbox_size], 200, export_filename, debug)
+      export_filename = get_filename
+      bbox_size = get_bbox_size
+      @generated_image_location = RendererHandler.request_image_from_renderer(lat, lon, @zlevel, [bbox_size, bbox_size], 200, export_filename, debug)
     end
   end
 end

data/lib/cartocss_helper/notes_downloader.rb

@@ -0,0 +1,46 @@
+require_relative 'util/generic_cached_downloader.rb'
+
+module CartoCSSHelper
+  class NotesDownloader
+    def self.run_note_query(lat, lon, range, invalidate_cache: false)
+      timeout = NotesDownloader.get_allowed_timeout_in_seconds
+      downloader = GenericCachedDownloader.new(timeout: timeout, stop_on_timeout: false)
+
+      url = NotesDownloader.format_query_into_url(lat, lon, range)
+      cache_filename = CartoCSSHelper::Configuration.get_path_to_folder_for_notes_api_cache + url.delete("/") + ".cache"
+      return downloader.get_specified_resource(url, cache_filename, invalidate_cache: invalidate_cache)
+    end
+
+    def self.cache_timestamp(lat, lon, range)
+      downloader = GenericCachedDownloader.new
+
+      url = NotesDownloader.format_query_into_url(lat, lon, range)
+      cache_filename = CartoCSSHelper::Configuration.get_path_to_folder_for_notes_api_cache + url.delete("/") + ".cache"
+      return downloader.get_cache_timestamp(cache_filename)
+    end
+
+    def self.get_allowed_timeout_in_seconds
+      return 10 * 60
+    end
+
+    def self.format_query_into_url(lat, lon, range)
+      # documentated at http://wiki.openstreetmap.org/wiki/API_v0.6#Map_Notes_API
+      bbox = osm_api_bbox_string(lat, lon, range)
+      base_url = "http://api.openstreetmap.org/api/0.6/notes"
+      return "#{base_url}?bbox=#{bbox}?closed=0"
+    end
+
+    def self.osm_api_bbox_string(latitude, longitude, size)
+      # bbox=left,bottom,right,top
+      min_latitude = latitude - size / 2
+      max_latitude = latitude + size / 2
+      min_longitude = longitude - size / 2
+      max_longitude = longitude + size / 2
+      return "#{min_longitude},#{min_latitude},#{max_longitude},#{max_latitude}"
+    end
+
+    def self.get_overpass_instance_url
+      return CartoCSSHelper::Configuration.get_overpass_instance_url
+    end
+  end
+end

data/lib/cartocss_helper/overpass_downloader.rb

@@ -0,0 +1,42 @@
+require_relative 'util/generic_downloader.rb'
+require_relative 'util/generic_cached_downloader.rb'
+require 'uri' # for URI.escape
+
+module CartoCSSHelper
+  class OverpassDownloader
+    class OverpassRefusedResponse < IOError; end
+
+    def self.run_overpass_query(query, description, cache_filename)
+      url = OverpassDownloader.format_query_into_url(query)
+      timeout = OverpassDownloader.get_allowed_timeout_in_seconds
+      downloader = GenericCachedDownloader.new(timeout: timeout, stop_on_timeout: false)
+      return downloader.get_specified_resource(url, cache_filename, description: description)
+    rescue RequestTimeout => e
+      puts 'Overpass API refused to process this request. It will be not attempted again, most likely query is too complex. It is also possible that Overpass servers are unavailable'
+      puts
+      puts query
+      puts
+      puts url
+      puts
+      puts e
+      raise OverpassRefusedResponse
+    end
+
+    def self.get_allowed_timeout_in_seconds
+      return 10 * 60
+    end
+
+    def self.format_query_into_url(query)
+      query = query.gsub(/\/\/.*\n/, '') # add proper parsing - it will mutilate // inside quotes etc
+      query = query.gsub('\\', '\\\\')
+      query = query.delete("\n")
+      query = query.delete("\t")
+      base_overpass_url = OverpassDownloader.get_overpass_instance_url
+      return base_overpass_url + '/interpreter?data=' + URI.escape(query)
+    end
+
+    def self.get_overpass_instance_url
+      return CartoCSSHelper::Configuration.get_overpass_instance_url
+    end
+  end
+end

data/lib/cartocss_helper/overpass_query_generator.rb

@@ -0,0 +1,248 @@
+# encoding: UTF-8
+require 'digest/sha1'
+require 'sys/filesystem'
+require_relative 'overpass_downloader.rb'
+require_relative 'util/systemhelper.rb'
+
+module CartoCSSHelper
+  class OverpassQueryGenerator
+    class NoLocationFound < StandardError
+    end
+    # TODO: - split into cache handling and Overpass handling
+    def self.get_query_to_find_data_pair(bb, tags_a, tags_b, type_a, type_b, distance_in_meters: 20)
+      filter_a = OverpassQueryGenerator.turn_list_of_tags_in_overpass_filter(tags_a)
+      filter_b = OverpassQueryGenerator.turn_list_of_tags_in_overpass_filter(tags_b)
+
+      query = "[timeout:#{OverpassDownloader.get_allowed_timeout_in_seconds}][out:csv(::lat,::lon;false)];
+      #{type_a}(#{bb})#{filter_a};
+      node(around:#{distance_in_meters})->.anodes;
+      #{type_b}(#{bb})#{filter_b};
+      node(around:#{distance_in_meters}).anodes;
+      out;"
+
+      return query
+    end
+
+    def self.overpass_bbox_string(latitude, longitude, size)
+      min_latitude = latitude - size / 2
+      max_latitude = latitude + size / 2
+      min_longitude = longitude - size / 2
+      max_longitude = longitude + size / 2
+      return "#{min_latitude},#{min_longitude},#{max_latitude},#{max_longitude}"
+    end
+
+    def self.find_data_pair(tags_a, tags_b, latitude, longitude, type_a, type_b, bb_size: 0.1, distance_in_meters: 20)
+      return nil, nil if bb_size > 0.5
+      bb = overpass_bbox_string(latitude, longitude, bb_size.to_f)
+      query = OverpassQueryGenerator.get_query_to_find_data_pair(bb, tags_a, tags_b, type_a, type_b, distance_in_meters: distance_in_meters)
+      description = "find #{VisualDiff.tag_dict_to_string(tags_a)} nearby #{VisualDiff.tag_dict_to_string(tags_b)} - bb size: #{bb_size}"
+      list = OverpassQueryGenerator.get_overpass_query_results(query, description)
+      if list.length != 0
+        return OverpassQueryGenerator.list_returned_by_overpass_to_a_single_location(list)
+      end
+      return OverpassQueryGenerator.find_data_pair(tags_a, tags_b, latitude, longitude, type_a, type_b, bb_size: bb_size * 2, distance_in_meters: distance_in_meters)
+    end
+
+    def self.get_file_with_downloaded_osm_data_for_location(latitude, longitude, size)
+      query = get_query_to_download_data_around_location(latitude, longitude, size)
+      description = "download data for #{latitude} #{longitude} (#{size})"
+      get_overpass_query_results(query, description)
+
+      filename = get_query_cache_filename(query)
+      return filename
+    end
+
+    def self.download_osm_data_for_location(latitude, longitude, size, accept_cache = true)
+      filename = CartoCSSHelper::Configuration.get_path_to_folder_for_cache + "#{latitude} #{longitude} #{size}.osm"
+      if File.exist?(filename)
+        return filename if accept_cache
+        SystemHelper.delete_file(filename, 'query refusing to accept cache was used')
+      end
+      query = get_query_to_download_data_around_location(latitude, longitude, size)
+      text = get_overpass_query_results(query, "download data for #{latitude} #{longitude} (#{size})")
+      File.new(filename, 'w') do |file|
+        file.write text
+      end
+      return filename
+    end
+
+    def self.get_query_to_download_data_around_location(latitude, longitude, size)
+      bb = overpass_bbox_string(latitude, longitude, size)
+      query = "[timeout:#{OverpassDownloader.get_allowed_timeout_in_seconds}];"
+      query += "\n"
+      query += "(node(#{bb});<;);"
+      query += "\n"
+      query += 'out;'
+      query += "\n"
+      query += '/*'
+      query += "\nbbox size: #{size}"
+      query += "\nhttp://www.openstreetmap.org/#map=17/#{latitude}/#{longitude}"
+      query += "\n"
+      query += '*/'
+      query += "\n"
+      return query
+    end
+
+    def self.get_elements_near_given_location(tags, type, latitude, longitude, range_in_meters)
+      description = "find #{tags} #{type} within #{range_in_meters / 1000}km from #{latitude}, #{longitude}"
+      query = OverpassQueryGenerator.get_query_to_get_location(tags, type, latitude, longitude, range_in_meters)
+      list = OverpassQueryGenerator.get_overpass_query_results(query, description)
+      return list_returned_by_overpass_to_array(list)
+    end
+
+    def self.get_elements_across_world(tags, type)
+      description = "find #{tags} #{type} across the world"
+      query = OverpassQueryGenerator.get_query_to_get_location(tags, type, 0, 0, :infinity)
+      list = OverpassQueryGenerator.get_overpass_query_results(query, description)
+      return list_returned_by_overpass_to_array(list)
+    end
+
+    def self.locate_element_with_given_tags_and_type(tags, type, latitude, longitude, max_range_in_km_for_radius = 1600)
+      # special support for following tag values:  :any_value
+      range = 10 * 1000
+      while range <= max_range_in_km_for_radius * 1000
+        list = OverpassQueryGenerator.get_elements_near_given_location(tags, type, latitude, longitude, range)
+        return list[0] if list.length != 0
+        range += [2 * range, 200_000].min
+      end
+      list = get_elements_across_world(tags, type)
+      if list.length != 0
+        return list[0]
+      else
+        raise NoLocationFound, "failed to find #{tags} #{type} across the world"
+      end
+    end
+
+    def self.list_returned_by_overpass_to_a_single_location(list)
+      list = list_returned_by_overpass_to_array(list)
+      return list[0]
+    end
+
+    def self.list_returned_by_overpass_to_array(list)
+      list = list.split("\n")
+      new_list = list.map do |x|
+        x = x.split("\t")
+        x[0] = x[0].to_f
+        x[1] = x[1].to_f
+        x
+      end
+      return new_list
+    end
+
+    def self.get_query_to_get_location(tags, type, latitude, longitude, range)
+      return get_query_to_get_location_set_format(tags, type, latitude, longitude, range, "[out:csv(::lat,::lon;false)]")
+    end
+
+    def self.get_query_to_get_location_set_format(tags, type, latitude, longitude, range, format)
+      # special support for following tag values:  :any_value
+      locator = "[timeout:#{OverpassDownloader.get_allowed_timeout_in_seconds}]#{format};"
+      locator += "\n"
+      type = 'way' if type == 'closed_way'
+      locator += OverpassQueryGenerator.get_query_element_to_get_location(tags, latitude, longitude, type, range)
+      locator += 'out center;'
+      locator += "\n"
+      locator += '/*'
+      range_string = if range == :infinity
+                       'infinity'
+                     else
+                       "#{range / 1000}km"
+                     end
+      locator += "\nrange: #{range_string}"
+      locator += "\nhttp://www.openstreetmap.org/#map=17/#{latitude}/#{longitude}"
+      locator += "\n"
+      locator += '*/'
+      locator += "\n"
+      return locator
+    end
+
+    def self.turn_list_of_tags_in_overpass_filter(tags)
+      element = ''
+      tags.each do |tag|
+        element += if tag[1] == :any_value
+                     "\t['#{tag[0]}']"
+                   else
+                     "\t['#{tag[0]}'='#{tag[1]}']"
+                   end
+        element += "\n"
+      end
+      return element
+    end
+
+    def self.get_query_element_to_get_location(tags, latitude, longitude, type, range)
+      # special support for following tag values:  :any_value
+      # TODO - escape value with quotation signs in them
+      element = "(#{type}"
+      element += OverpassQueryGenerator.turn_list_of_tags_in_overpass_filter(tags)
+      element += "\n"
+      if range != :infinity
+        element += "\t(around:#{range},#{latitude},#{longitude});"
+        element += "\n"
+      end
+      element += ');'
+      element += "\n"
+      return element
+    end
+
+    def self.get_query_cache_refused_response_filename(query)
+      return get_query_cache_filename(query) + '_response_refused'
+    end
+
+    def self.mark_query_as_refused(query)
+      file = File.new(get_query_cache_refused_response_filename(query), 'w')
+      file.write ''
+      file.close
+    end
+
+    def self.get_query_cache_filename(query)
+      hash = Digest::SHA1.hexdigest query
+      query_cache_filename = CartoCSSHelper::Configuration.get_path_to_folder_for_overpass_cache + hash + '_query.cache'
+      return query_cache_filename
+    end
+
+    def self.get_overpass_query_results(query, description, debug = false)
+      if File.exist?(get_query_cache_refused_response_filename(query))
+        raise OverpassDownloader::OverpassRefusedResponse
+      end
+
+      check_for_free_space
+
+      if debug
+        puts query
+        puts
+      end
+
+      cache_filename = get_query_cache_filename(query)
+      description = 'Running Overpass query (connection initiated on ' + Time.now.to_s + ') ' + description
+      begin
+        return OverpassDownloader.run_overpass_query query, description, cache_filename
+      rescue OverpassDownloader::OverpassRefusedResponse
+        mark_query_as_refused(query)
+        raise OverpassDownloader::OverpassRefusedResponse
+      end
+    end
+
+    def self.check_for_free_space # TODO: it really does not belong here... - do system helpera? aż do końca klasy
+      if SystemHelper.not_enough_free_space
+        attempt_cleanup
+        if SystemHelper.not_enough_free_space
+          raise 'not enough free space on disk with cache folder'
+        end
+      end
+    end
+
+    def self.attempt_cleanup
+      delete_large_overpass_caches 500 if SystemHelper.not_enough_free_space
+      delete_large_overpass_caches 100 if SystemHelper.not_enough_free_space
+      delete_large_overpass_caches 50 if SystemHelper.not_enough_free_space
+    end
+
+    def self.delete_large_overpass_caches(threshold_in_MB)
+      # TODO: - find library that deals with caches like this, bug here may be unfunny
+      Dir.glob(CartoCSSHelper::Configuration.get_path_to_folder_for_overpass_cache + '*') do |file|
+        if File.size(file) > (1024 * 1024 * threshold_in_MB)
+          SystemHelper.delete_file(file, "removing everpass cache entries larger than #{threshold_in_MB} MB to make free space on the disk")
+        end
+      end
+    end
+  end
+end