Muster Dispatcher Python API

import MDispatcherAPI
err, jobs = MDispatcherAPI.jobGetList()
if (err.getErrorCode() != 0):
    print("Function failed: " + err.getDescription())
for job in jobs:
    print("Job status: " + str(job.getStatus()) + " name: " + job.getName()) 

import MDispatcherAPI
err, job = MDispatcherAPI.jobGet(2)
if (err.getErrorCode() == 0):
    print("Job name: " + job.getName())
else
    print("Error: " + err.getDescription())

import MDispatcherAPI
err = MDispatcherAPI.jobReparent(2,3)
if (err.getErrorCode() != 0): print("Error: " + err.getDescription())

import MDispatcherAPI
import MClientAPI
 
# Creates a new MJob object
job = MClientAPI.MJob()
# Sets the base attributes
job.setName("A new job")
job.setTemplateID(1) # Targets Maya sw rendering
job.setPacketSize(1) # Sets the packet size to 1
job.setParentId(-1)
job.setDependMode(MClientAPI.MJob.kJobDependSuccess)
job.setJobType(MClientAPI.MJob.kJobTypeJob)
job.setPriority(1)
job.setPacketType(MTemplateAPI.kTemplateMultiframe)
job.setMaximumNodes(4)
 
''' Template specific attributes '''
job.attributeSetString("job_file","\\\\Myserver\\myshare\\myproject\\scenes\\test.mb",1,1)
job.attributeSetString("job_project","\\\\Myserver\\myshare\\myproject",1,1)
job.attributeSetString("output_folder","\\\\Myserver\\myshare\\myproject\\images",1,1)
job.attributeSetFloat("start_frame",1.0)
job.attributeSetFloat("by_frame",1.0)
job.attributeSetFloat("end_frame",10.0)
job.attributeSetInt("step_by",1)
job.attributeSetInt("number_by",1)
job.attributeSetInt("MAYADIGITS",1)
 
err = MDispatcherAPI.jobSubmit(job,"admin")
if (err.getErrorCode() != 0): print("Error: " + err.getDescription())
else: print("Job submitted with ID: " + str(job.getJobId()) )

import MDispatcherAPI
import MClientAPI
 
# Gets an existing job
err, job = MDispatcherAPI.jobGet(10)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
 
# Changes the job filename
job.attributeSetString("job_file","/new/path")
 
# Edit and reinit the job
err = MDispatcherAPI.jobEdit(job)
if (err.getErrorCode() != 0): print("Error: " + err.getDescription())

import MDispatcherAPI
err = MDispatcherAPI.jobAddFolder(4,"admin","new folder")
if (err.getErrorCode() != 0): print("Error: " + err.getDescription())

import MDispatcherAPI
err = MDispatcherAPI.jobReinit(2)
if (err.getErrorCode() != 0): print("Error: " + err.getDescription())

import MDispatcherAPI
err = MDispatcherAPI.jobDelete(6)
if (err.getErrorCode() != 0): print("Error: " + err.getDescription())

import MDispatcherAPI
# Change the status of a chunk
err = MDispatcherAPI. chunkSetStatus(2,1,MClientAPI.MChunk.kChunkStatusCompleted)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
# Tells the Dispatcher to recalculate the job status and launch post job actions if the job completed
err = MDispatcherAPI.jobUpdateStatus(2)

import MDispatcherAPI
# Get a job from its ID
err,job = MDispatcherAPI.jobGet(2)
if (err.getErrorCode() != 0):
    sys.exit(err.getDescription())
 
# Change a job parameter directly
job.setName("I've renamed my job!")
 
# Change a job attribute, be sure when working with paths to pass the substitution flag to 1
job.attributeSetString("job_file","path/to/my/new/file",1,1) 
 
# Tells to Console that the inner job attributes have changed, otherwise it will be changed on the Dispatcher but Consoles won't be aware of it, also flushes the changes to the db
err = MDispatcherAPI.jobUpdate(2)

import MDispatcherAPI
err, chunks = MDispatcherAPI.chunkGetList(10)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
print ("Job has " + str(len(chunks)) + " chunks")

import MDispatcherAPI
err, chunk = MDispatcherAPI.chunkGet(10,1)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
print ("Chunk ID 1 of job 10 has starting frame: " + str(chunk.getStartFrame()) )

import MDispatcherAPI
err = MDispatcherAPI.chunkSetStatus(10,1,MClientAPI.MChunk.kChunkStatusOnHold)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
# After changing a chunk status, always tell the Dispatcher to recalculate the job status
err = MDispatcherAPI.jobUpdateStatus(10)

import MDispatcherAPI
err, list = chunkGetHistory(1,1)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())

import MDispatcherAPI
err, list = chunkGetHistory(1)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())

import MDispatcherAPI
MDispatcherAPI.nodeKillProcess(1) # Kills the rendering on the instance ID 1

import MDispatcherAPI
MDispatcherAPI.nodeKillAndPauseNodesWorkingOnJob(1) # Stops and pause instances rendering on job ID 1

import MDispatcherAPI
MDispatcherAPI.nodePause(1)

import MDispatcherAPI
MDispatcherAPI.nodeResume(1)

import MDispatcherAPI
MDispatcherAPI.nodeForceUpdate(1) # Updates status of the instance ID 1 on the Dispatcher

import MDispatcherAPI
MDispatcherAPI.nodeSetProcessPriority(1,MClientAPI.MNode.kProcessPriorityIdle) # Sets the process priority of instance 1 to idle

import MDispatcherAPI
MDispatcherAPI.nodeSoftRestart(1)

import MDispatcherAPI
MDispatcherAPI.nodePurgeTemplatesExclusion(1,"-1") # Purges the entire templates exclusion list

import MDispatcherAPI
MDispatcherAPI.nodePurgeJobsExclusions(1,"-1") # Purges the entire node jobs exclusion list

import MDispatcherAPI
MDispatcherAPI.nodeSetRealtimeLog(1,0) # Disables the real time log on instance 1

import MDispatcherAPI
MDispatcherAPI.nodeSendSystemEvent(1,MClientAPI.MNode.kSysEventShutdown) # Shutdown the node of instance ID 1

import MDispatcherAPI
MDispatcherAPI.nodeRunPythonCode(1,"print('hello world!')") # Runs a python code on the instance directly

import MDispatcherAPI
MDispatcherAPI.nodeSetNotes(1,"My new notes !") # Changes the notes on a instance

# this code programmatically removes the offline instances from the Dispatcher
import MDispatcherAPI
err, nodes = MDispatcherAPI.nodeGetList()
for node in nodes:
    if (node.getStatus() == MClientAPI.MNode.kInstanceStatusOffline): 
        MDispatcherAPI.nodeRemoveRegistration(node.getNodeId()) # Removes the offline instance

# this code prints all the offline instances
import MDispatcherAPI
err, nodes = MDispatcherAPI.nodeGetList()
for node in nodes:
    if (node.getStatus() == MClientAPI.MNode.kInstanceStatusOffline): 
       print (node.getInstanceName()) 

# This code gets the name of a specific instance ID (1)
import MDispatcherAPI
err, node = MDispatcherAPI.nodeGet(1)
if (err.getErrorCode() != 0):
    print("Instance ID 1 is named: " + node.getInstanceName())
else:
    print("Instance ID 1 does not exist!")

# This code looks up the ID of an instance named Main server
import MDispatcherAPI
err, node = MDispatcherAPI.nodeGetByName("Main server")
if (err.getErrorCode() != 0):
    print("Main server has ID : " + str(node.getNodeId()))
else:
    print("Main server is not connected!")

mport MDispatcherAPI
err, node = MDispatcherAPI.nodeGetByName("Main server")
if (err.getErrorCode() != 0):
    print("Main server has ID : " + str(node.getNodeId()))
    # This sends a message to the node main server, directed to the global template only
    MDispatcherAPI.sendMessageToNode(node.getNodeId(),0,"Hello world!",False)
 
# Alternatively broadcast a message to all nodes
MDispatcherAPI.sendMessageToNode(0,0,"Hello world!",True)
 
# If you want to send a message to a specific template in addition to the global template, you can set the template ID:
MDispatcherAPI.sendMessageToNode(0,1,"Hello world!",True) # This sends the message to the template ID 1, specific code can be written only inside that template

# this code prints all the connected clients
import MDispatcherAPI
err, clients = MDispatcherAPI.clientGetList()
for client in clients:
    print(client.getUsername())
    print(client.getClientId())
    print(client.getHostIP())

import MDispatcherAPI
err, client = MDispatcherAPI.clientGet(1)
if client != None:
    print (client.getUsername))

import MDispatcherAPI
err, client = MDispatcherAPI.clientGetByUsername("admin")
for client in clients:
    print(client.getClientId())
    print(client.getHostIP())

# Disconnects all the connections for the admin user
import MDispatcherAPI
err, client = MDispatcherAPI.clientGetByUsername("admin")
for client in clients:
    MDispatcherAPI.clientForceDisconnection(client.getClientId())

import MDispatcherAPI
err, clients = MDispatcherAPI.clientGetByUsername("john")
for client in clients:
    # This sends a message to the console connections authenticated with john
    MDispatcherAPI.sendMessageToConsole(client.getClientId(),0,"Hello world!",False)
 
# Alternatively broadcast a message to all consoles
MDispatcherAPI.sendMessageToConsole(0,0,"Hello world!",True)
 
# If you want to send a message to a specific template in addition to the global template, you can set the template ID:
MDispatcherAPI.sendMessageToConsole(0,1,"Hello world!",True) # This sends the message to the template ID 1, specific code can be written only inside that template

# this code prints all the connected notificators clients
import MDispatcherAPI
err, clients = MDispatcherAPI.clientNGetList()
for client in clients:
    print(client.getUsername())
    print(client.getClientId())
    print(client.getHostIP())

import MDispatcherAPI
err, client = MDispatcherAPI.clientNGet(1)
if client != None:
    print (client.getUsername))

import MDispatcherAPI
err, client = MDispatcherAPI.clientNGetByUsername("admin")
for client in clients:
    print(client.getClientId())
    print(client.getHostIP())

# Disconnects all the notificator connections for the admin user
import MDispatcherAPI
err, client = MDispatcherAPI.clientNGetByUsername("admin")
for client in clients:
    MDispatcherAPI.clientNForceDisconnection(client.getClientId())

import MDispatcherAPI
err, clients = MDispatcherAPI.clientNGetByUsername("john")
for client in clients:
    # This sends a message to the notificator connections authenticated with john
    MDispatcherAPI.sendMessageToNotificator(client.getClientId(),0,"Hello world!",False)
 
# Alternatively broadcast a message to all consoles
MDispatcherAPI.sendMessageToNotificator(0,0,"Hello world!",True)
 
# If you want to send a message to a specific template in addition to the global template, you can set the template ID:
MDispatcherAPI.sendMessageToNotificator(0,1,"Hello world!",True) # This sends the message to the template ID 1, specific code can be written only inside that template

err, startSample , endSample, numSamples = MDispatcherAPI.dbGetStatisticsBounds()

err, startSample , endSample, numSamples = MDispatcherAPI.dbGetHistoryBounds()

MDispatcherAPI.dbClearStatisticsBounds(1421691712,1421691900)

MDispatcherAPI.dbClearHistoryBounds(1421691712,1421691900)

err= MDispatcherAPI.dbImportQueueSQL(sql)

# Creates an empty string reference object
sql = MClientAPI.MStringRef()
err = MDispatcherAPI.dbExportQueueSQL(sql)
print (sql.getString())

# Creates an empty string reference object
err = dbFlush()

# Creates an empty string reference object
err = dbHistoryFlush()

# Creates an empty string reference object
err = dbBackupFlush()

import MClientAPI
import MDispatcherAPI
 
err = MDispatcherAPI.backupJob(2,MClientAPI.MJob.kJobsBackupActionOverwriteExistings)

err = MDispatcherAPI.backupJobAndDelete(1,MJob.kJobsBackupActionOverwriteExistings)

err = MDispatcherAPI.backupRestoreJob(1,MJob.kJobsBackupRestoreActionOverwriteExistings,-1)

import MClientAPI
import MDispatcherAPI
 
boundaries = MClientAPI.MBackupQueryBoundaries()
err = MDispatcherAPI.backupGetBoundaries(boundaries)
print (boundaries.getJobsCount())

import MClientAPI
import MDispatcherAPI
 
query = MClientAPI.MBackupQuery()
err , objects = MDispatcherAPI.backupQuery(query)
print("Query objects: " + len(objects))

import MDispatcherAPI
err, status = MDispatcherAPI.systemQueryEngineStatus()
# Restarts the selection logic is disabled
if (status == 0): MDispatcherAPI.systemSwapEngineStatus()

MDispatcherAPI.systemSoftRestart()

MDispatcherAPI.systemResetStatisticsCounters()

MDispatcherAPI.systemStartNodesNetworkScan()

# Get the current configuration
config = MClientAPI.MDispatcherConfiguration()
err = MDispatcherAPI.systemGetConfiguration(config)
# Enable the web server configuration
config.general.setEnableWebServer(1)
# Store the configuration
MDispatcherAPI.systemSetConfiguration(config,1)
MDispatcherAPI.softRestart() # Restarts the Dispatcher

# Get the current configuration
config = MClientAPI.MDispatcherLDAPConfiguration()
err = MDispatcherAPI. systemGetLDAPConfiguration(config)
# Enable the LDAP Bindings
config.setEnableBindings(1)
# Store the configuration
MDispatcherAPI.systemSetLDAPConfiguration(config,1)

# Lists all the logs filenames available
import MDispatcherAPI
err, logs = MDispatcherAPI.systemGetActivityLogsList()
for log in logs: print (log)

# Gets the content of the dispatcher.log
import MDispatcherAPI
err, logContent = MDispatcherAPI.systemGetActivityLog("dispatcher.log")
if (err.getErrorCode() == 0): print(logContent)

# This codes removes all the logs excepts the current dispatcher.log file
import MDispatcherAPI
err, logs = MDispatcherAPI.systemGetActivityLogsList()
for log in logs: if (log != "dispatcher.log"): MDispatcherAPI.systemRemoveActivityLog(log)

import MDispatcherAPI
err, logs = MDispatcherAPI.systemGetActionLogsList()
for log in logs: print (log)

import MDispatcherAPI
err, logContent = MDispatcherAPI.systemGetActionLog("1413045793.9.Untitled.log")
if (err.getErrorCode() == 0): print(logContent)

import MDispatcherAPI
MDispatcherAPI. systemRemoveActionLog("1413045793.9.Untitled.log")

MDispatcherAPI.logClear()

# This will go in the realtime log into Console
MDispatcherAPI.logAddInternalMessage("My personal message!")

# This will go into dispatcher.log, mainly for debug purposes
MDispatcherAPI.logAddMessage("My personal message!")

import MDispatcherAPI
err, users = MDispatcherAPI.userGetList()
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
print ("Normal users:")
for user in users: 
    if (not user.getAccountName().startswith("@directory@")): print (user.getAccountName())
print ("Active directory users:")
for user in users: 
    if (user.getAccountName().startswith("@directory@")): print (user.getAccountName())

import MDispatcherAPI
err, user = MDispatcherAPI.userGet("fakeuser")
if (err.getErrorCode() != 0):
    # User does not exist , create a new one
    user = MClientAPI.MUser()
    user.setAccountName("fakeuser")
    user.setGroups("users")
    user.setAllowedRights(MClientAPI.MUser.kUserRightDefaultGroupRights) # Assign default rights, for specific rights just add the kUserRight constants using a bitwise OR
    err = MDispatcherAPI.userAdd(user)
    if (err.getErrorCode() != 0): sys.exit(err.getDescription())
    print("User fakeuser successfully created!")
else:
    print("User already exists!")

import MDispatcherAPI
err, user = MDispatcherAPI.userRemove("fakeuser")

import MDispatcherAPI
err, user = MDispatcherAPI.userGet("fakeuser")
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
user.setAllowedRights(MClientAPI.MUser.kUserRightDefaultGroupRights)
# Flush the changes back
MDispatcherAPI.userConfigure(user)

import MDispatcherAPI
err, groups = MDispatcherAPI.groupGetList()
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
print ("Normal groups:")
for group in groups: 
    if (not group.getGroupName().startswith("@directory@")): print (group.getGroupName())
print ("Active directory groups:")
for group in groups: 
    if (group.getGroupName().startswith("@directory@")): print (group.getGroupName())

import MDispatcherAPI
err, group = MDispatcherAPI.groupGet("wranglers")
if (err.getErrorCode() != 0):
    # Group does not exist , create a new one
    group = MClientAPI.MGroup()
    group.setGroupName("wranglers")
    group.setAllowedRights(MClientAPI.MUser.kUserRightDefaultGroupRights) 
    err = MDispatcherAPI.groupAdd(group)
    if (err.getErrorCode() != 0): sys.exit(err.getDescription())
    print("Group wranglers successfully created!")
else:
    print("Group already exists!")

import MDispatcherAPI
err = MDispatcherAPI.groupRemove("wranglers")
if (err.getErrorCode() != 0): sys.exit(err.getDescription())

import MDispatcherAPI
err, group = MDispatcherAPI.groupGet("wranglers")
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
group.setAllowedRights(MClientAPI.MUser.kUserRightDefaultGroupRights)
# Flush the changes back
MDispatcherAPI.groupConfigure(group)

import MDispatcherAPI
err, pools = MDispatcherAPI.poolGetList()
for pool in pools: print(pool.getName())

import MDispatcherAPI
err, pool = MDispatcherAPI.poolGet("blades")
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
pool.addNode("powerblade","192.168.1.10") # Adds a new entry into the pool
err = MDispatcherAPI.poolConfigure(pool)

import MDispatcherAPI
# Remove an existing pool and creates it back
err = MDispatcherAPI.poolRemove("blades")
if (err.getErrorCode() == 0): print("Existing pool blades removed")
else: print("Pool blades does not exist")
pool = MClientAPI.MPool()
pool.setName("blades")
pool.addNode("powerblade","192.168.1.10") # Adds a new entry into the pool
err = MDispatcherAPI.poolAdd(pool) # Adds the pool to Dispatcher
err = MDispatcherAPI.poolNotifyChanges() # Notify consoles about changes in the pools

import MDispatcherAPI
err, repositories = MDispatcherAPI.repositoriesGetList()
for repo in repositories:
    print (repo.getName())

import MDispatcherAPI
err, repo = MDispatcherAPI.repositoriesGet("main")
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
repo.setMacSide("/Volumes/main") # Change the repository path for the Mac platform
err = MDispatcherAPI.repositoriesConfigure(repo) # Flush back the changes

import MDispatcherAPI
repo = MClientAPI.MRepository() # Create a black object
repo.setName("My main repository")
repo.setScope(MClientAPI.MRepository.kScopeGlobal) # Set as global repository
repo.setLocalSide("\\\\server\\renderfarm")
repo.setWindowsSide("\\\\server\\renderfarm")
repo.setMacSide("/Volumes/server/renderfarm")
repo.setLinuxSide("/mnt/server/renderfarm")
err = MDispatcherAPI.repositoriesAdd(repo)
if (err.getErrorCode() != 0): sys.exit(err.getDescription())
MDispatcherAPI.repositoriesNotifyChanges() # Notify the consoles that something changed in the repositories

import MDispatcherAPI
MDispatcherAPI.repositoriesRemove("My main repository")