def testShellScript(self): fp = open("test.sh", "w") fp.write("#!/bin/sh\n") fp.write("echo zoom zoom zoom") fp.close() ol = outline.Outline(name="shell_script_test_v1", current=True) ol.add_layer(ShellScript("script", script="test.sh")) cuerun.launch(ol, test=True)
def main(input_path, fps, crf, chunk, output_path): """ Sends a job to opencue that will compress an image sequence to an H.264 file using multiple render nodes in parallel :input_path: str - path to the first frame of the image sequence :fps: float - framerate of the desired encoded file :crf: int - quality of the desired encoded file """ input_path = os.path.abspath(input_path) shot_name = os.path.basename(input_path) job_name = "dpx_to_mov" show_name = "testing" user = getpass.getuser() outline = Outline(job_name, shot=shot_name, show=show_name, user=user) # Create the MakeMov Layer layer_name = "seq_to_mov" threads = 1.0 threadable = False frame_start, frame_end = get_imgseq_framerange(input_path) range_len = int(frame_end) - int(frame_start) frame_range = frame_start + "-" + frame_end input_path_ffmpeg = translate_imgseq_ffmpeg(input_path) output_chunk_path_template = create_chunk_path_template(input_path) seqtomov_layer = SeqToMov(layer_name, chunk=chunk, threads=threads, range=frame_range, threadable=threadable, crf=crf, fps=fps) seqtomov_layer.add_input("main", input_path_ffmpeg) seqtomov_layer.add_output("main", output_chunk_path_template) outline.add_layer(seqtomov_layer) # Create the ConcatMov Layer layer_name = "concat_mov" concatmov_layer = ConcatMov(layer_name, chunk=1, threads=threads, range=1, threadable=threadable) chunk_paths = get_chunk_paths(output_chunk_path_template, chunk, frame_start, frame_end) for chunk_path in enumerate(chunk_paths): concatmov_layer.add_input("", chunk_path) concatmov_layer.add_output("main", output_path) concatmov_layer.depend_all(seqtomov_layer) outline.add_layer(concatmov_layer) # Submit job cuerun.launch(outline, use_pycuerun=False)
def launch_outline(self, outline, **override): """ Launches the specified outline script with the options parsed from the command line. """ from outline import cuerun, config, event if self.__options.debug: bin_dir = os.path.dirname(os.path.abspath(__file__)) logger.debug("Overriding cuerun bin directory to %s" % bin_dir) # Overide the location of the bin dir to the one where # this script is located if we're in debug mode. config.set("outline", "bin_dir", bin_dir) self.__evh.emit( event.LaunchEvent(event.BEFORE_LAUNCH, self, outline=outline)) try: args = self.options_to_dict(self.__options) args.update(override) result = cuerun.launch(outline, **args) self.__evh.emit( event.LaunchEvent(event.AFTER_LAUNCH, self, job=result, outline=outline)) return result except Exception, e: sys.stderr.write("outline failure, %s" % e) traceback.print_exc(file=sys.stderr) sys.exit(1)
def submitJob(jobData): """Submit the job using the PyOutline API.""" outline = Outline(jobData['name'], shot=jobData['shot'], show=jobData['show'], user=jobData['username']) lastLayer = None for layerData in jobData['layers']: if layerData.layerType == JobTypes.JobTypes.MAYA: layer = buildMayaLayer(layerData, lastLayer) elif layerData.layerType == JobTypes.JobTypes.SHELL: layer = buildShellLayer(layerData, lastLayer) elif layerData.layerType == JobTypes.JobTypes.NUKE: layer = buildNukeLayer(layerData, lastLayer) elif layerData.layerType == JobTypes.JobTypes.BLENDER: layer = buildBlenderLayer(layerData, lastLayer) else: raise ValueError('unrecognized layer type %s' % layerData.layerType) outline.add_layer(layer) lastLayer = layer if 'facility' in jobData: outline.set_facility(jobData['facility']) return cuerun.launch(outline, use_pycuerun=False)
def _doDispatch(self, rootBatch): # Construct an object to track everything we need # to generate the job. I have a suspicion that at # some point we'll want a Dispatcher::Job base class # which _doDispatch() must return, in which case this # might just be member data for a subclass of one of those. dispatchData = {} dispatchData["scriptNode"] = rootBatch.preTasks()[0].node().scriptNode( ) dispatchData["scriptFile"] = Gaffer.Context.current( )["dispatcher:scriptFileName"] dispatchData["batchesToLayers"] = {} # Create an OpenCue outline and set its basic properties. context = Gaffer.Context.current() outline = Outline( context.substitute(self["jobName"].getValue()) or "untitled", show=context.substitute(self["showName"].getValue()) or "show", shot=context.substitute(self["shotName"].getValue()) or "shot", user=context.substitute(self["userName"].getValue()) or "user", ) # Populate the job with tasks from the batch tree # that was prepared by our base class. for upstreamBatch in rootBatch.preTasks(): self.__buildOutlineWalk(outline, upstreamBatch, dispatchData) # Signal anyone who might want to make just-in-time # modifications to the job. self.preSpoolSignal()(self, outline) # Finally, we can spool the job. cuerun.launch(outline, use_pycuerun=False)
def submitJob(jobData): """Submit the job using the PyOutline API.""" outline = Outline(jobData['name'], shot=jobData['shot'], show=jobData['show'], user=jobData['username']) for layerData in jobData['layers']: if layerData.layerType == JobTypes.JobTypes.MAYA: layer = buildMayaLayer(layerData) elif layerData.layerType == JobTypes.JobTypes.SHELL: layer = buildShellLayer(layerData) elif layerData.layerType == JobTypes.JobTypes.NUKE: layer = buildNukeLayer(layerData) outline.add_layer(layer) return cuerun.launch(outline, use_pycuerun=False)
def testShellSequence(self): """Test a simple sequence of shell commands""" commands = ["/bin/ls"] * 10 ol = outline.Outline(name="shell_sequence_test_v1", current=True) ol.add_layer(ShellSequence("bah", commands=commands, cores=10, memory="512m")) job = cuerun.launch(ol, pause=True) self.assertEquals(10, job.stats.waitingFrames) self.assertEquals(10, job.stats.pendingFrames) cue.test(job) job = opencue.getJob(job) self.assertEquals(0, job.stats.waitingFrames) self.assertEquals(10, job.stats.succeededFrames)
from outline import Outline, cuerun # Create an outline for the job job_name = "debug_job" shot_name = "debug_shot" show_name = "testing" user = getpass.getuser() outline = Outline(job_name, shot=shot_name, show=show_name, user=user) # Create the debug Layer layer_name = "debug_layer" chunk_size = 1 threads = 1.0 threadable = False frame_range = "1" debug_layer = DebugLayer(layer_name, input="input_path", output="output_path", chunk=chunk_size, threads=threads, range=frame_range, threadable=threadable, crf=25) outline.add_layer(debug_layer) # Submit job cuerun.launch(outline, use_pycuerun=False)
# SUBMIT ############################################################ outline = Outline(jobData['name'], shot=jobData['shot'], show=jobData['show'], user=jobData['username']) layers = [] for layerData in jobData['layers']: layer = Shell(layerData.name, command=layerData.cmd.split(), chunk='1', threads=float(layerData.cores), range=str(layerData.layerRange), threadable=True) layer.set_service(layerData.services[0]) layers.append(layer) layer_count = 0 for layer in layers: if layer_count > 0: layer.depend_all(layers[layer_count - 1]) layer_count += 1 outline.add_layer(layer) jobs = cuerun.launch(outline, use_pycuerun=False, pause=True) for job in jobs: print(job.name()) job.setPriority(10) job.setMaxCores(1500) job.setMaxRetries(3)
#!/bin/env python2.5 # Copyright (c) 2018 Sony Pictures Imageworks Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from outline import Outline, cuerun from outline.modules.tutorial import HelloModule ol = Outline("my_job") ol.add_layer(HelloModule("my_layer")) cuerun.launch(ol, range="1-10", pause=True)
def testShellToString(self): """Test a string shell command.""" ol = outline.Outline(name="string_test_v1") ol.add_layer(Shell("string_test", command="/bin/ls -l ./")) cuerun.launch(ol, range="1", test=True)
def testShell(self): """Test a simple shell command.""" ol = outline.Outline(name="shell_test_v1") ol.add_layer(Shell("bah", command=["/bin/ls"])) cuerun.launch(ol, range="1", test=True)