Updates needed to work with the upgraded BURP backend of Renderfarm.fi

1 files changed, 108 insertions, 101 deletions

diff --git a/render_renderfarmfi.py b/render_renderfarmfi.py
index e7a9afdb..a50d6b00 100644
--- a/render_renderfarmfi.py
+++ b/render_renderfarmfi.py
@@ -16,11 +16,13 @@
 #
 # ##### END GPL LICENSE BLOCK #####
 
+DEV = False
+
 bl_info = {
     "name": "Renderfarm.fi",
     "author": "Nathan Letwory <nathan@letworyinteractive.com>, Jesse Kaukonen <jesse.kaukonen@gmail.com>",
-    "version": (12,),
-    "blender": (2, 6, 0),
+    "version": (13,),
+    "blender": (2, 6, 1),
     "api": 41934,
     "location": "Render > Engine > Renderfarm.fi",
     "description": "Send .blend as session to http://www.renderfarm.fi to render",
@@ -86,6 +88,15 @@ bpy.childParticleWarning = False
 bpy.simulationWarning = False
 bpy.ready = False
 
+if DEV:
+    rffi_xmlrpc_secure = r'http://192.168.0.109/burp/xmlrpc'
+    rffi_xmlrpc = r'http://192.168.0.109/burp/xmlrpc'
+    rffi_xmlrpc_upload = '192.168.0.109'
+else:
+    rffi_xmlrpc_secure = r'https://xmlrpc.renderfarm.fi/burp/xmlrpc'
+    rffi_xmlrpc = r'http://xmlrpc.renderfarm.fi/burp/xmlrpc'
+    rffi_xmlrpc_upload = 'xmlrpc.renderfarm.fi'
+
 def renderEngine(render_engine):
     bpy.utils.register_class(render_engine)
     return render_engine
@@ -221,9 +232,9 @@ def isFilterNode(node):
     t = type(node)
     return t==bpy.types.CompositorNodeBlur or t==bpy.types.CompositorNodeDBlur
 
-def changeSettings(context):
+def changeSettings():
     
-    sce = context.scene
+    sce = bpy.context.scene
     rd = sce.render
     ore = sce.ore_render
     
@@ -249,12 +260,12 @@ def changeSettings(context):
     else:
         bpy.simulationWarning = False
 
-def prepareScene(context):
-    sce = context.scene
+def prepareScene():
+    sce = bpy.context.scene
     rd = sce.render
     ore = sce.ore_render
     
-    changeSettings(context)
+    changeSettings()
     
     print("Packing external textures...")
     # Pack all external textures
@@ -304,8 +315,8 @@ class OpSwitchRenderfarm(bpy.types.Operator):
     bl_idname = "ore.switch_to_renderfarm_render"
     
     def execute(self, context):
-        changeSettings(context)
-        context.scene.render.engine = 'RENDERFARMFI_RENDER'
+        changeSettings()
+        bpy.context.scene.render.engine = 'RENDERFARMFI_RENDER'
         return {'FINISHED'}
 
 class OpSwitchBlenderRender(bpy.types.Operator):
@@ -313,7 +324,7 @@ class OpSwitchBlenderRender(bpy.types.Operator):
     bl_idname = "ore.switch_to_blender_render"
     
     def execute(self, context):
-        context.scene.render.engine = 'BLENDER_RENDER'
+        bpy.context.scene.render.engine = 'BLENDER_RENDER'
         return {'FINISHED'}  
 
 # Copies start & end frame + others from render settings to ore settings
@@ -322,7 +333,7 @@ class OpCopySettings(bpy.types.Operator):
     bl_idname = "ore.copy_settings"
     
     def execute(self, context):
-        sce = context.scene
+        sce = bpy.context.scene
         rd = sce.render
         ore = sce.ore_render
         ore.resox = rd.resolution_x
@@ -339,13 +350,12 @@ class OpCopySettings(bpy.types.Operator):
     
     def draw(self, context):
         layout = self.layout
-        sce = context.scene
-        rd = sce.render
+        rd = context.scene.render
         row = layout.row()
         row.operator("ore.switch_to_renderfarm_render", text="Renderfarm.fi", icon='WORLD')
         row.operator("ore.switch_to_blender_render", text="Blender Render", icon='BLENDER')
         row = layout.row()
-        if (sce.render.engine == 'BLENDER_RENDER'):
+        if (bpy.context.scene.render.engine == 'BLENDER_RENDER'):
             row.operator("render.render", text="Image", icon='RENDER_STILL')
             row.operator("render.render", text="Animation", icon='RENDER_ANIMATION').animation = True
             layout.prop(rd, "display_mode", text="Display")
@@ -367,13 +377,12 @@ class EngineSelectPanel(bpy.types.Panel):
     
     def draw(self, context):
         layout = self.layout
-        sce = context.scene
-        rd = sce.render
+        rd = context.scene.render
         row = layout.row()
         row.operator("ore.switch_to_renderfarm_render", text="Renderfarm.fi", icon='WORLD')
         row.operator("ore.switch_to_blender_render", text="Blender Render", icon='BLENDER')
         row = layout.row()
-        if (rd.engine == 'RENDERFARMFI_RENDER'):
+        if (bpy.context.scene.render.engine == 'RENDERFARMFI_RENDER'):
             if bpy.found_newer_version == True:
                 layout.operator('ore.open_download_location')
             else:
@@ -390,7 +399,7 @@ class RENDERFARM_MT_Session(bpy.types.Menu):
         layout = self.layout
         ore = context.scene.ore_render
         
-        if ore.loginInserted == True:
+        if (ore.loginInserted == True):
             layout.operator('ore.completed_sessions')
             layout.operator('ore.accept_sessions')
             layout.operator('ore.active_sessions')
@@ -618,9 +627,10 @@ def encode_multipart_data(data, files):
     
     return body, headers
 
-def send_post(url, data, files):
-    connection = http.client.HTTPConnection('xmlrpc.renderfarm.fi')
-    connection.request('POST', '/file', *encode_multipart_data(data, files))
+def send_post(data, files):
+    connection = http.client.HTTPConnection(rffi_xmlrpc_upload)
+    print("posting to ", rffi_xmlrpc_upload)
+    connection.request('POST', '/burp/storage', *encode_multipart_data(data, files)) # was /file
     response = connection.getresponse()
     res = response.read()
     return res
@@ -636,7 +646,7 @@ def md5_for_file(filepath):
         md5hash.update(data)
     return md5hash.hexdigest()
 
-def upload_file(key, userid, sessionid, server, path):
+def upload_file(key, userid, sessionid, path):
     assert isabs(path)
     assert isfile(path)
     data = {
@@ -648,14 +658,14 @@ def upload_file(key, userid, sessionid, server, path):
     files = {
         'blenderfile': path
     }
-    r = send_post(server, data, files)
-    #print 'Uploaded %r' % (path)
+    r = send_post(data, files)
     
     return r
 
 def run_upload(key, userid, sessionid, path):
-    #print('Upload', path)
-    r = upload_file(key, userid, sessionid, r'http://xmlrpc.renderfarm.fi/file', path)
+    print('Upload', path)
+    r = upload_file(key, userid, sessionid, path)
+    print("uploaded, now preparing for loads")
     o = xmlrpc.client.loads(r)
     print("Done!")
     return o[0][0]
@@ -668,16 +678,19 @@ def ore_upload(op, context):
         op.report(set(['ERROR']), 'Your user or scene information is not complete')
         bpy.infoError = True
         bpy.errorStartTime = time.time()
-        sce.render.engine = 'RENDERFARMFI_RENDER'
+        bpy.context.scene.render.engine = 'RENDERFARMFI_RENDER'
         return {'CANCELLED'}
     try:
-        authproxy = xmlrpc.client.ServerProxy(r'https://xmlrpc.renderfarm.fi/auth')
+        print("ore_upload start")
+        authproxy = xmlrpc.client.ServerProxy(rffi_xmlrpc_secure)
         res = authproxy.auth.getSessionKey(ore.username, ore.hash)
         key = res['key']
         userid = res['userId']
-        proxy = xmlrpc.client.ServerProxy(r'http://xmlrpc.renderfarm.fi/session')
+        print("ore_upload authenticated")
+        proxy = xmlrpc.client.ServerProxy(rffi_xmlrpc) #r'http://xmlrpc.renderfarm.fi/session')
         proxy._ServerProxy__transport.user_agent = 'Renderfarm.fi Uploader/%s' % (bpy.CURRENT_VERSION)
         res = proxy.session.createSession(userid, key)
+        print("session created", res)
         sessionid = res['sessionId']
         key = res['key']
         res = run_upload(key, userid, sessionid, bpy.data.filepath)
@@ -700,16 +713,16 @@ def ore_upload(op, context):
         res = proxy.session.submit(userid, res['key'], sessionid)
         op.report(set(['INFO']), 'Submission sent to Renderfarm.fi')
     except xmlrpc.client.Error as v:
-        sce.render.engine = 'RENDERFARMFI_RENDER'
+        bpy.context.scene.render.engine = 'RENDERFARMFI_RENDER'
         print('ERROR:', v)
         op.report(set(['ERROR']), 'An error occurred while sending submission to Renderfarm.fi')
     except Exception as e:
-        sce.render.engine = 'RENDERFARMFI_RENDER'
+        bpy.context.scene.render.engine = 'RENDERFARMFI_RENDER'
         print('Unhandled error:', e)
         op.report(set(['ERROR']), 'An error occurred while sending submission to Renderfarm.fi')
     
-    sce.render.engine = 'RENDERFARMFI_RENDER'
-    doRefresh(context)
+    bpy.context.scene.render.engine = 'RENDERFARMFI_RENDER'
+    doRefresh(op)
     return {'FINISHED'}
 
 def setStatus(property, status):
@@ -752,53 +765,74 @@ class OreSession:
     
     def percentageComplete(self):
         totFrames = self.endframe - self.startframe
+        done = 0
         if totFrames != 0:
             done = math.floor((self.frames / totFrames)*100)
-        else:
-            done = math.floor((self.frames / (totFrames+0.01))*100)
         
         if done > 100:
             done = 100
         return done
 
-def xmlSessionsToOreSessions(sessions, queue):
-    #bpy.ore_sessions = []
+def xmlSessionsToOreSessions(sessions, stage=None): #, queue):
     output = []
-    sessionFilter = []
-    sessionFilter = sessions[queue]
-    for sid in sessionFilter:
-        s = sessionFilter[sid]['title']
-        t = sessionFilter[sid]['timestamps']
-        sinfo = OreSession(sid, s) 
-        if queue in ('completed', 'active'):
-            sinfo.frames = sessionFilter[sid]['framesRendered']
-        sinfo.startframe = sessionFilter[sid]['startFrame']
-        sinfo.endframe = sessionFilter[sid]['endFrame']
-        #bpy.ore_sessions.append(sinfo)
+    for session in sessions:
+        s = session['title']
+        print("\n\n\n")
+        print(session)
+        print("\n\n\n")
+        if stage:
+            s = s + ' (' + stage + ')'
+        #t = session['timestamps']
+        sinfo = OreSession(session['sessionId'], s) 
+        if stage in ('Completed', 'Active'):
+            sinfo.frames = session['framesRendered']
+        sinfo.startframe = session['startFrame']
+        sinfo.endframe = session['endFrame']
         output.append(sinfo)
     return output
 
-def doRefresh(context):
-    sce = context.scene
+def doRefresh(op, rethrow=False):
+    sce = bpy.context.scene
     ore = sce.ore_render
     try:
-        userproxy = xmlrpc.client.ServerProxy(r'https://xmlrpc.renderfarm.fi/user')
-        sessions = userproxy.user.getAllSessions(ore.username, ore.hash, 'completed')
+    
+        proxy = xmlrpc.client.ServerProxy(rffi_xmlrpc_secure)
+        res = proxy.auth.getSessionKey(ore.username, ore.hash)
+        userid = res['userID']
+        proxy = xmlrpc.client.ServerProxy(rffi_xmlrpc)
+
         bpy.ore_sessions = []
-        bpy.ore_sessions = xmlSessionsToOreSessions(sessions, 'completed')
+
+        sessions = proxy.session.getSessions(userid, 'accept', 0, 100, 'full')
+        bpy.ore_sessions = xmlSessionsToOreSessions(sessions, stage='Pending')
+        bpy.ore_pending_sessions = bpy.ore_sessions
+
+        sessions = proxy.session.getSessions(userid, 'completed', 0, 100, 'full')
+        bpy.ore_sessions = xmlSessionsToOreSessions(sessions, stage='Completed')
         bpy.ore_completed_sessions = bpy.ore_sessions
-        bpy.ore_cancelled_sessions = xmlSessionsToOreSessions(sessions, 'canceled')
-        sessions = userproxy.user.getAllSessions(ore.username, ore.hash, 'accept')
-        bpy.ore_pending_sessions = xmlSessionsToOreSessions(sessions, 'accept')
-        sessions = userproxy.user.getAllSessions(ore.username, ore.hash, 'active')
-        bpy.ore_active_sessions = xmlSessionsToOreSessions(sessions, 'active')
+
+        sessions = proxy.session.getSessions(userid, 'cancelled', 0, 100, 'full')
+        bpy.ore_sessions = xmlSessionsToOreSessions(sessions, stage='Cancelled')
+        bpy.ore_cancelled_sessions = bpy.ore_sessions
+
+        sessions = proxy.session.getSessions(userid, 'render', 0, 100, 'full')
+        bpy.ore_sessions = xmlSessionsToOreSessions(sessions, stage='Rendering')
+        bpy.ore_active_sessions = bpy.ore_sessions
         
         updateCompleteSessionList(ore)
         
         return 0
     except xmlrpc.client.Error as v:
-        self.report({'WARNING'}, "Error at refresh")
+        op.report({'WARNING'}, "Error at refresh : " + str(v.faultCode) + " " + v.faultString)
+        print(v)
+        if rethrow:
+            raise v
+        return 1
+    except Exception as v:
+        op.report({'WARNING'}, "Non XMLRPC Error at refresh: " + str(v))
         print(v)
+        if rethrow:
+            raise v
         return 1
 
 class ORE_RefreshOp(bpy.types.Operator):
@@ -806,7 +840,7 @@ class ORE_RefreshOp(bpy.types.Operator):
     bl_label = 'Refresh'
     
     def execute(self, context):
-        result = doRefresh(context)
+        result = doRefresh(self)
         if (result == 0):
             return {'FINISHED'}
         else:
@@ -836,8 +870,8 @@ def updateCompleteSessionList(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_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)
@@ -858,15 +892,19 @@ class ORE_CancelSession(bpy.types.Operator):
     def execute(self, context):
         sce = context.scene
         ore = sce.ore_render
-        userproxy = xmlrpc.client.ServerProxy(r'https://xmlrpc.renderfarm.fi/user')
+        proxy = xmlrpc.client.ServerProxy(rffi_xmlrpc_secure)
         if len(bpy.ore_complete_session_queue)>0:
             s = bpy.ore_complete_session_queue[ore.selected_session]
             try:
-                userproxy.user.cancelSession(ore.username, ore.hash, int(s.id))
-                doRefresh(context)
-                self.report(set(['INFO']), 'Session ' + s.title + ' with id ' + s.id + ' cancelled')
-            except:
-                self.report(set(['ERROR']), 'Could not cancel session ' + s.title + ' with id ' + s.id)
+                res = proxy.auth.getSessionKey(ore.username, ore.hash)
+                key = res['key']
+                userid = res['userId']
+                res = proxy.session.cancelSession(userid, key, s.id)
+                doRefresh(self)
+                self.report(set(['INFO']), 'Session ' + s.title + ' with id ' + str(s.id) + ' cancelled')
+            except xmlrpc.client.Error as v:
+                self.report(set(['ERROR']), 'Could not cancel session ' + s.title + ' with id ' + str(s.id))
+                print(v)
                 bpy.cancelError = True
                 bpy.errorStartTime = time.time()
         
@@ -961,27 +999,7 @@ class ORE_LoginOp(bpy.types.Operator):
                 ore.loginInserted = False
         
         try:
-            userproxy = xmlrpc.client.ServerProxy(r'https://xmlrpc.renderfarm.fi/user')
-            sessions = userproxy.user.getAllSessions(ore.username, ore.hash, 'completed')
-            bpy.ore_sessions = xmlSessionsToOreSessions(sessions, 'completed')
-            bpy.ore_completed_sessions = bpy.ore_sessions
-            bpy.ore_cancelled_sessions = xmlSessionsToOreSessions(sessions, 'canceled')
-            sessions = userproxy.user.getAllSessions(ore.username, ore.hash, 'accept')
-            bpy.ore_pending_sessions = xmlSessionsToOreSessions(sessions, 'accept')
-            sessions = userproxy.user.getAllSessions(ore.username, ore.hash, 'active')
-            bpy.ore_active_sessions = xmlSessionsToOreSessions(sessions, 'active')
-            
-            bpy.ore_active_session_queue = bpy.ore_completed_sessions
-            updateSessionList(ore.completed_sessions, ore)
-            
-            bpy.ore_active_session_queue = bpy.ore_pending_sessions
-            updateSessionList(ore.pending_sessions, ore)
-            
-            bpy.ore_active_session_queue = bpy.ore_active_sessions
-            updateSessionList(ore.active_sessions, ore)
-            
-            bpy.ore_active_session_queue = bpy.ore_cancelled_sessions
-            updateSessionList(ore.rejected_sessions, ore)
+            doRefresh(self, True)
             
             ore.passwordCorrect = True
             ore.loginInserted = True
@@ -996,17 +1014,6 @@ class ORE_LoginOp(bpy.types.Operator):
             print(v)
             return {'CANCELLED'}
         
-        all_sessions = []
-        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)
-        
         return {'FINISHED'}
 
 class ORE_ResetOp(bpy.types.Operator):
@@ -1052,7 +1059,7 @@ class ORE_UploaderOp(bpy.types.Operator):
     def execute(self, context):
         
         bpy.uploadInProgress = True
-        prepareScene(context)
+        prepareScene()
         
         returnValue = ore_upload(self, context)
         bpy.uploadInProgress = False