render_renderfarmfi.py

            print("dorefresh exception")
            if op: op.report({'WARNING'}, "Non XMLRPC Error at refresh: " + str(v))
            if print_errors: print(v)
            if rethrow:
                raise v
            return 1
    else:
        return 1

class ORE_RefreshOp(bpy.types.Operator):
    bl_idname = 'ore.refresh_session_list'
    bl_label = 'Refresh'
    
    def execute(self, context):
        result = doRefresh(self)
        if (result == 0):
            return {'FINISHED'}
        else:
            return {'CANCELLED'}

def updateSessionList(session_list, ore):
    while(len(session_list) > 0):
        session_list.remove(0)
    
    for s in bpy.ore_active_session_queue:
        session_list.add()
        session = session_list[-1]
        session.name = s.title + ' [' + str(s.percentageComplete()) + '% complete]'

def updateCompleteSessionList(ore):
    all_sessions = []
    
    bpy.ore_active_session_queue = bpy.ore_cancelled_sessions
    updateSessionList(ore.rejected_sessions, ore)
    bpy.ore_active_session_queue = bpy.ore_active_sessions
    updateSessionList(ore.active_sessions, ore)
    bpy.ore_active_session_queue = bpy.ore_pending_sessions
    updateSessionList(ore.pending_sessions, ore)
    bpy.ore_active_session_queue = bpy.ore_completed_sessions
    updateSessionList(ore.completed_sessions, ore)
    
    bpy.ore_complete_session_queue = []
    bpy.ore_complete_session_queue.extend(bpy.ore_pending_sessions)
    bpy.ore_complete_session_queue.extend(bpy.ore_active_sessions)
    bpy.ore_complete_session_queue.extend(bpy.ore_completed_sessions)
    bpy.ore_complete_session_queue.extend(bpy.ore_cancelled_sessions)
    
    bpy.ore_active_session_queue = bpy.ore_complete_session_queue
    updateSessionList(ore.all_sessions, ore)

class ORE_OpenDownloadLocation(bpy.types.Operator):
    bl_idname = 'ore.open_download_location'
    bl_label = 'Download new version for your platform'
    
    def execute(self, context):
        import webbrowser
        webbrowser.open(bpy.download_location)
        return {'FINISHED'}

class ORE_CancelSession(bpy.types.Operator):
    bl_idname = 'ore.cancel_session'
    bl_label = 'Cancel Session'
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        proxy = xmlrpc.client.ServerProxy(rffi_xmlrpc_secure, verbose=DEV)
        if len(bpy.ore_complete_session_queue)>0:
            s = bpy.ore_complete_session_queue[ore.selected_session]
            _read_credentials()
            try:
                res = proxy.auth.getSessionKey(bpy.rffi_user, bpy.rffi_hash)
                key = res['key']
                userid = res['userId']
                res = proxy.session.cancelSession(userid, key, s.id)
                doRefresh(self, True)
                self.report({'INFO'}, 'Session ' + s.title + ' with id ' + str(s.id) + ' cancelled')
            except xmlrpc.client.Error as v:
                self.report({'ERROR'}, 'Could not cancel session ' + s.title + ' with id ' + str(s.id))
                print(v)
                bpy.cancelError = True
                bpy.errorStartTime = time.time()
        
        return {'FINISHED'}

class ORE_GetCompletedSessions(bpy.types.Operator):
    bl_idname = 'ore.completed_sessions'
    bl_label = 'Completed sessions'
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        bpy.queue_selected = 1
        bpy.ore_active_session_queue = bpy.ore_completed_sessions
        updateSessionList(completed_sessions, ore)
        
        return {'FINISHED'}

class ORE_GetCancelledSessions(bpy.types.Operator):
    bl_idname = 'ore.cancelled_sessions'
    bl_label = 'Cancelled sessions'
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        bpy.queue_selected = 4
        bpy.ore_active_session_queue = bpy.ore_cancelled_sessions
        updateSessionList(cancelled_sessions, ore)
        
        return {'FINISHED'}

class ORE_GetActiveSessions(bpy.types.Operator):
    bl_idname = 'ore.active_sessions'
    bl_label = 'Rendering sessions'
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        bpy.queue_selected = 2
        bpy.ore_active_session_queue = bpy.ore_active_sessions
        updateSessionList(active_sessions, ore)
        
        return {'FINISHED'}

class ORE_GetPendingSessions(bpy.types.Operator):
    bl_idname = 'ore.accept_sessions' # using ORE lingo in API. acceptQueue is session waiting for admin approval
    bl_label = 'Pending sessions'
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        bpy.queue_selected = 3
        bpy.ore_active_session_queue = bpy.ore_pending_sessions
        updateSessionList(pending_sessions, ore)
        
        return {'FINISHED'}

class ORE_CheckUpdate(bpy.types.Operator):
    bl_idname = 'ore.check_update'
    bl_label = 'Check for a new version'
    
    def execute(self, context):
        blenderproxy = xmlrpc.client.ServerProxy(r'http://xmlrpc.renderfarm.fi/renderfarmfi/blender', verbose=DEV)
        try:
            self.report({'INFO'}, 'Checking for newer version on Renderfarm.fi')
            dl_url = blenderproxy.blender.getCurrentVersion(bpy.CURRENT_VERSION)
            if len(dl_url['url']) > 0:
                self.report({'INFO'}, 'Found a newer version on Renderfarm.fi ' + dl_url['url'])
                bpy.download_location = dl_url['url']
                bpy.found_newer_version = True
            else:
                bpy.up_to_date = True
            self.report({'INFO'}, 'Done checking for newer version on Renderfarm.fi')
        except xmlrpc.client.Fault as f:
            print('ERROR:', f)
            self.report({'ERROR'}, 'An error occurred while checking for newer version on Renderfarm.fi: ' + f.faultString)
        except xmlrpc.client.ProtocolError as e:
            print('ERROR:', e)
            self.report({'ERROR'}, 'An HTTP error occurred while checking for newer version on Renderfarm.fi: ' + str(e.errcode) + ' ' + e.errmsg)
        
        return {'FINISHED'}

class ORE_LoginOp(bpy.types.Operator):
    bl_idname = 'ore.login'
    bl_label = 'Login'
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render

        ore.password = ore.password.strip()
        ore.username = ore.username.strip()
        
        if ore.password != '' and ore.username != '':
            print("writing new credentials")
            _write_credentials(hashlib.md5(ore.password.encode() + ore.username.encode()).hexdigest(),ore.username)
            _read_credentials()
            ore.password = ''
            ore.username = ''
            bpy.loginInserted = False
            bpy.passwordCorrect = False
        
        try:
            doRefresh(self, True)
            
            bpy.passwordCorrect = True
            bpy.loginInserted = True
            
        except xmlrpc.client.Error as v:
            bpy.ready = False
            bpy.loginInserted = False
            bpy.passwordCorrect = False
            ore.username = bpy.rffi_user
            _write_credentials('', '')
            _read_credentials()
            ore.hash = ''
            ore.password = ''
            self.report({'WARNING'}, "Incorrect login: " + v.faultString)
            print(v)
            return {'CANCELLED'}
        
        return {'FINISHED'}

class ORE_ResetOp(bpy.types.Operator):
    bl_idname = "ore.reset"
    bl_label = "Reset Preparation"
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        ore.prepared = False
        bpy.loginInserted = False
        bpy.prepared = False
        ore.hash = ''
        ore.username = ''
        ore.passowrd = ''
        ore.longdesc = ''
        ore.shortdesc = '-'
        ore.tags = ''
        ore.title = ''
        ore.url = ''
        
        return {'FINISHED'}

class ORE_TestRenderOp(bpy.types.Operator):
    bl_idname = "ore.test_render"
    bl_label = "Run a test render"
    
    def execute(self, context):
        rd = context.scene.render
        rd.engine = 'BLENDER_RENDER'
        rd.threads_mode = 'AUTO'
        rd.threads = 1
        bpy.ops.render.render()
        rd.threads_mode = 'FIXED'
        rd.threads = 1
        rd.engine = 'RENDERFARMFI_RENDER'
        return {'FINISHED'}

class ORE_UploaderOp(bpy.types.Operator):
    bl_idname = "ore.upload"
    bl_label = "Render on Renderfarm.fi"
    
    def execute(self, context):
        
        bpy.uploadInProgress = True
        prepareScene()
        
        returnValue = ore_upload(self, context)
        bpy.uploadInProgress = False
        return returnValue

class ORE_UseBlenderReso(bpy.types.Operator):
    bl_idname = "ore.use_scene_settings"
    bl_label = "Use Scene settings"
    
    def execute(self, context):
        sce = context.scene
        ore = sce.ore_render
        rd = context.scene.render
        
        ore.resox = rd.resolution_x
        ore.resoy = rd.resolution_y
        ore.start = sce.frame_start
        ore.end = sce.frame_end
        ore.fps = rd.fps
        
        return {'FINISHED'}
        
class ORE_UseCyclesRender(bpy.types.Operator):
    bl_idname = "ore.use_cycles_render"
    bl_label = "Cycles"
    
    def execute(self, context):
        context.scene.ore_render.engine = 'cycles'
        return {'FINISHED'}

class ORE_UseBlenderRender(bpy.types.Operator):
    bl_idname = "ore.use_blender_render"
    bl_label = "Blender Internal"
    
    def execute(self, context):
        context.scene.ore_render.engine = 'blender'
        return {'FINISHED'}

class ORE_ChangeUser(bpy.types.Operator):
    bl_idname = "ore.change_user"
    bl_label = "Change user"
    
    def execute(self, context):
        ore = context.scene.ore_render
        _write_credentials('', '')
        _read_credentials()
        ore.password = ''
        ore.hash = ''
        bpy.rffi_user = ''
        bpy.rffi_hash = ''
        bpy.rffi_creds_found = False
        bpy.passwordCorrect = False
        bpy.loginInserted = False
        
        return {'FINISHED'}

class RenderfarmFi(bpy.types.RenderEngine):
    bl_idname = 'RENDERFARMFI_RENDER'
    bl_label = "Renderfarm.fi"

    def render(self, scene):
        print('Do test renders with Blender Render')

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.ore_render = PointerProperty(type=ORESettings, name='ORE Render', description='ORE Render Settings')

def unregister():
    bpy.utils.unregister_module(__name__)

if __name__ == "__main__":
    register()