def iterate_assets( cache, settings, asset_folders, tools, platform ): # loop through each asset path and glob # run the tool associated with each file logging.info("Running tools on assets...") total_files = 0 modified_files = 0 for asset in asset_folders: try: search_path = os.path.join( asset.abs_src_folder, asset.glob ) #logging.info("Processing: \"%s\"" % search_path) if tools.has_key(asset.tool): tool = tools[asset.tool] else: raise UnknownToolException( "Unknown tool \"%s\"" % asset.tool ) path_created = False for root, subs, files in os.walk(asset.abs_src_folder, topdown=True): # filter files based on glob files[:] = fnmatch.filter(files, asset.glob) if not path_created: # make all asset destination folders make_dirs(asset.abs_dst_folder) path_created = True # filter subdirectories based on the glob matched_subs = fnmatch.filter(subs, asset.glob) # do not recurse into subdirectories subs[:] = [] if matched_subs: # One or more subdirectories matched the glob. # For now, copy each match over to the destination folder. # This is to specifically handle the case where directories are entire # folders (.dSYM, .app). These specific dirs should be # exceptions where the entire folder is simply copied. for folder in matched_subs: copy_tree(source_file_root, dst_file_root) for file in files: src_file_path = os.path.join(root, file) total_files += 1 if not cache.update(src_file_path): continue modified_files += 1 execute_commands( tools, tool, settings.paths, asset, src_file_path, platform ) except UnknownToolException as e: logging.warn(e.message) continue logging.info("Complete.") logging.info("Modified / Total - %i/%i" % (modified_files, total_files))
def process_events(self): queued_items = self.queue[:] self.queue = [] for target_path in queued_items: for asset in asset_folders: match = re.search(asset.get_abs_regex(), target_path) if match: # determine if this is a directory path # a file in a subdirectory source_to_target_path = os.path.relpath(target_path, self.settings.paths.source_root) asset_target_relative = os.path.relpath(source_to_target_path, asset.src_folder) subdir = os.path.sep in asset_target_relative is_directory = os.path.isdir(target_path) or subdir if is_directory: # We don't want to perform tree copies for modified files # inside of a subfolder; only do that on the root subfolder. if not subdir: source_path = target_path destination_path = os.path.join(settings.paths.destination_root, asset.dst_folder, asset_target_relative) copy_tree(source_path, destination_path) break try: # try to update the cache if not self.cache.update(target_path): break if self.tools.has_key(asset.tool): tool = tools[asset.tool] else: raise UnknownToolException( "Unknown tool \"%s\"" % asset.tool ) outputs = execute_commands( self.tools, tool, self.settings.paths, asset, target_path, self.platform ) # get the relative asset path from the source_root # to the asset being modified. relative_path = os.path.relpath(outputs[0], settings.paths.destination_root) if self.send_reload_requests: request_packet = { "type": "file_modified", "resource": relative_path } post = 80 host, uri = self.server_url.split("/") if ":" in host: host, port = host.split(":") port = int(port) try: connection = httplib.HTTPConnection(host, port) connection.request("PUT", ("/" + uri), json.dumps(request_packet)) response = connection.getresponse() if response.status != 204 and response.status != 200: logging.warn("Request failed: (%i) %s" % (response.status, response.reason)) except socket.error as exception: pass except: raise break except: raise