blob: 54b42779019204a4cd81b2c4d576c419150ac5a9 [file] [log] [blame]
import datetime
import fnmatch
import logging
import os
import os.path
import Queue
import sublime
import sublime_plugin
import subprocess
import tempfile
import threading
import time
class CompileCurrentFile(sublime_plugin.TextCommand):
# static thread so that we don't try to run more than once at a time.
thread = None
lock = threading.Lock()
def __init__(self, args):
super(CompileCurrentFile, self).__init__(args)
self.thread_id = threading.current_thread().ident
self.text_to_draw = ""
self.interrupted = False
def description(self):
return ("Compiles the file in the current view using Ninja, so all that "
"this file and it's project depends on will be built first\n"
"Note that this command is a toggle so invoking it while it runs "
"will interrupt it.")
def draw_panel_text(self):
"""Draw in the output.exec panel the text accumulated in self.text_to_draw.
This must be called from the main UI thread (e.g., using set_timeout).
"""
assert self.thread_id == threading.current_thread().ident
logging.debug("draw_panel_text called.")
self.lock.acquire()
text_to_draw = self.text_to_draw
self.text_to_draw = ""
self.lock.release()
if len(text_to_draw):
edit = self.output_panel.begin_edit()
self.output_panel.set_read_only(False)
self.output_panel.insert(edit, self.output_panel.size(), text_to_draw)
self.output_panel.show(self.output_panel.size())
self.output_panel.set_read_only(True)
self.output_panel.end_edit(edit)
self.view.window().run_command("show_panel", {"panel": "output.exec"})
logging.debug("Added text:\n%s.", text_to_draw)
def update_panel_text(self, text_to_draw):
self.lock.acquire()
self.text_to_draw += text_to_draw
self.lock.release()
sublime.set_timeout(self.draw_panel_text, 0)
def execute_command(self, command):
"""Execute the provided command and send ouput to panel.
Because the implementation of subprocess can deadlock on windows, we use
a Queue that we write to from another thread to avoid blocking on IO.
Args:
command: A list containing the command to execute and it's arguments.
Returns:
The exit code of the process running the command or,
1 if we got interrupted.
-1 if we couldn't start the process
-2 if we couldn't poll the running process
"""
logging.debug("Running command: %s", command)
def EnqueueOutput(out, queue):
"""Read all the output from the given handle and insert it into the queue.
Args:
queue: The Queue object to write to.
"""
while True:
# This readline will block until there is either new input or the handle
# is closed. Readline will only return None once the handle is close, so
# even if the output is being produced slowly, this function won't exit
# early.
# The potential dealock here is acceptable because this isn't run on the
# main thread.
data = out.readline()
if not data:
break
queue.put(data, block=True)
out.close()
try:
proc = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True,
stderr=subprocess.STDOUT, stdin=subprocess.PIPE)
except OSError, e:
logging.exception('Execution of %s raised exception: %s.', (command, e))
return -1
# Use a Queue to pass the text from the reading thread to this one.
stdout_queue = Queue.Queue()
stdout_thread = threading.Thread(target=EnqueueOutput,
args=(proc.stdout, stdout_queue))
stdout_thread.daemon = True # Ensure this exits if the parent dies
stdout_thread.start()
# We use the self.interrupted flag to stop this thread.
while not self.interrupted:
try:
exit_code = proc.poll()
except OSError, e:
logging.exception('Polling execution of %s raised exception: %s.',
command, e)
return -2
# Try to read output content from the queue
current_content = ""
for _ in range(2048):
try:
current_content += stdout_queue.get_nowait()
except Queue.Empty:
break
self.update_panel_text(current_content)
current_content = ""
if exit_code is not None:
while stdout_thread.isAlive() or not stdout_queue.empty():
try:
current_content += stdout_queue.get(block=True, timeout=1)
except Queue.Empty:
# Queue could still potentially contain more input later.
pass
time_length = datetime.datetime.now() - self.start_time
self.update_panel_text("%s\nDone!\n(%s seconds)" %
(current_content, time_length.seconds))
return exit_code
# We sleep a little to give the child process a chance to move forward
# before we poll it again.
time.sleep(0.1)
# If we get here, it's because we were interrupted, kill the process.
proc.terminate()
return 1
def run(self, edit, target_build):
"""The method called by Sublime Text to execute our command.
Note that this command is a toggle, so if the thread is are already running,
calling run will interrupt it.
Args:
edit: Sumblime Text specific edit brace.
target_build: Release/Debug/Other... Used for the subfolder of out.
"""
# There can only be one... If we are running, interrupt and return.
if self.thread and self.thread.is_alive():
self.interrupted = True
self.thread.join(5.0)
self.update_panel_text("\n\nInterrupted current command:\n%s\n" % command)
self.thread = None
return
# It's nice to display how long it took to build.
self.start_time = datetime.datetime.now()
# Output our results in the same panel as a regular build.
self.output_panel = self.view.window().get_output_panel("exec")
self.output_panel.set_read_only(True)
self.view.window().run_command("show_panel", {"panel": "output.exec"})
# TODO(mad): Not sure if the project folder is always the first one... ???
project_folder = self.view.window().folders()[0]
self.update_panel_text("Compiling current file %s\n" %
self.view.file_name())
# The file must be somewhere under the project folder...
if (project_folder.lower() !=
self.view.file_name()[:len(project_folder)].lower()):
self.update_panel_text(
"ERROR: File %s is not in current project folder %s\n" %
(self.view.file_name(), project_folder))
else:
# Look for a .ninja file that contains our current file.
logging.debug("Searching for Ninja target")
file_relative_path = self.view.file_name()[len(project_folder) + 1:]
output_dir = "%s\\out\\%s" % (project_folder, target_build)
matches = []
for root, dirnames, filenames in os.walk(output_dir):
for filename in fnmatch.filter(filenames, '*.ninja'):
matches.append(os.path.join(root, filename))
logging.debug("Found %d Ninja targets", len(matches))
# The project file name is needed to construct the full Ninja target path.
project_file = None
for ninja_file in matches:
for line in open(ninja_file):
if file_relative_path in line:
project_file = os.path.basename(ninja_file)
break
if project_file is None:
self.update_panel_text(
"ERROR: File %s is not in any Ninja file under %s" %
(file_relative_path, output_dir))
else:
filename = os.path.splitext(os.path.basename(file_relative_path))[0]
target = "obj\\%s\\%s.%s.obj" % (os.path.dirname(file_relative_path),
os.path.splitext(project_file)[0],
filename)
command = [
"ninja", "-C", "%s\\out\\%s" % (project_folder, target_build),
target]
self.interrupted = False
self.thread = threading.Thread(target=self.execute_command,
kwargs={"command":command})
self.thread.start()
time_length = datetime.datetime.now() - self.start_time
logging.debug("Took %s seconds on UI thread to startup",
time_length.seconds)
self.view.window().focus_view(self.view)