Useless things I forgot to commit.

Author: stefano-maggiolo

system/async_library/ServiceA.py

@@ -26,7 +26,6 @@
 
 import time
 
-from FileStorage import FileCacher
 from AsyncLibrary import Service, rpc_callback, logger
 from Utils import ServiceCoord
 
@@ -47,24 +46,16 @@ def __init__(self, shard):
         self.ServiceB.append(self.connect_to(
                 ServiceCoord("ServiceB", 1)))
 
-        self.add_timeout(self.ask_for_echo, None, 10,
-                         immediately=True)
-        self.add_timeout(self.ask_for_file, None, 2,
-                         immediately=True)
-
-        self.FS = self.connect_to(
-            ServiceCoord("FileStorage", 0))
-        self.add_timeout(self.test_file_storage, None, 2,
+        self.add_timeout(self.ask_for_echo, None, 4,
                          immediately=True)
-
-        self.FC = FileCacher(self, self.FS)
-        self.digest = None
-        self.add_timeout(self.test_file_cacher, None, 5)
+        self.t = 5
 
     def ask_for_echo(self):
         """Ask all ServiceB for a echo.
 
         """
+        self.t -= 1
+        if self.t <= 0: return
         logger.debug("ServiceA.ask_for_echo")
         for i in xrange(0, 2):
             remote_service = self.ServiceB[i]
@@ -126,87 +117,6 @@ def file_callback(self, data, plus, error=None):
             self.ServiceB[0].binary_write(filename="ccc",
                                           binary_data=bbb.read())
 
-    def test_file_storage(self):
-        """Ask FS for file aaa.
-
-        """
-        logger.debug("ServiceA.test_file_storage")
-        if not self.FS.connected:
-            logger.info("Not putting aaa in FileStorage because not connected!")
-            return True
-        logger.info("Putting aaa into FileStorage.")
-        with open("aaa", "rb") as aaa:
-            data = aaa.read()
-        self.FS.put_file(binary_data=data,
-                         callback=ServiceA.test_file_storage_callback,
-                         plus=(len(data), time.time()))
-        return False
-
-    @rpc_callback
-    def test_file_storage_callback(self, data, plus, error=None):
-        """Callback for test_file_storage. It get the file again.
-
-        """
-        logger.debug("ServiceA.test_file_storage_callback")
-        if error != None:
-            logger.error(error)
-            return
-        seconds = time.time() - plus[1]
-        megabytes = plus[0] / 1024.0 / 1024.0
-        logger.info(("FileStorage stored aaa. Digest: %s\m  %5.3lf MB in " + \
-                     "%5.3lf seconds (%5.3lf MB/s)")
-                    % (data, megabytes, seconds, megabytes / seconds))
-        self.digest = data
-
-        # Now getting back the file
-        logger.info("Getting back aaa from FileStorage.")
-        self.FS.get_file(digest=data,
-                         callback=ServiceA.test_file_storage_callback_2,
-                         plus=time.time())
-
-    @rpc_callback
-    def test_file_storage_callback_2(self, data, plus, error=None):
-        """Callback for test_file_storage. It writes the file to bbb.
-
-        """
-        logger.debug("ServiceA.test_file_storage_callback_2")
-        if error != None:
-            logger.error(error)
-            return
-        seconds = time.time() - plus
-        megabytes = len(data) / 1024.0 / 1024.0
-        logger.info(("Got aaa from FileStorage: %5.3lf MB in %5.3lf " + \
-                     "seconds (%5.3lf MB/s)")
-                    % (megabytes, seconds, megabytes / seconds))
-
-        with open("ddd", "wb") as ddd:
-            ddd.write(data)
-
-    def test_file_cacher(self):
-        """Ask FC for file aaa.
-
-        """
-        logger.debug("ServiceA.test_file_cacher")
-        if self.digest == None:
-            logger.info("Not testing FC because not ready.")
-            return True
-        logger.info("Asking FC to get file aaa and move it to eee.")
-        self.FC.get_file(self.digest, filename="eee",
-                         callback=self.test_file_cacher_callback,
-                         plus="Plus object.")
-        return False
-
-    def test_file_cacher_callback(self, data, plus, error=None):
-        """Getting the file and writing it to fff.
-
-        """
-        logger.debug("ServiceA.test_file_cacher_callback")
-        if error != None:
-            logger.error(error)
-            return
-        with open("fff", "wb") as fff:
-            fff.write(data)
-
 
 if __name__ == "__main__":
     import sys

system/async_library/ServiceB.py

@@ -57,6 +57,7 @@ def echo(self, string):
         """Overwritten RPC method echo.
 
         """
+        time.sleep(7)
         logger.debug("ServiceB.echo")
         logger.info("Echo received.")
         return string

system/async_library/Utils.py

@@ -170,4 +170,43 @@ def decode_binary(string):
         print >> sys.stderr, "Can't decode binary."
         raise ValueError
 
+def get_compilation_command(language, source_filename, executable_filename):
+    """For compiling in 32-bit mode under 64-bit OS: add
+    '-march=i686', '-m32' for gcc/g++. Don't know about
+    Pascal. Anyway, this will require some better support from the
+    evaluation environment (particularly the sandbox, which has to be
+    compiled in a different way depending on whether it will execute
+    32- or 64-bit programs).
+     
+    """
+    if language == "c":
+        command = ["/usr/bin/gcc", "-DEVAL", "-static", "-O2","-lm",
+                   "-o", executable_filename, source_filename]
+    elif language == "cpp":
+        command = ["/usr/bin/g++", "-DEVAL", "-static", "-O2",
+                   "-o", executable_filename, source_filename]
+    elif language == "pas":
+        command = ["/usr/bin/fpc", "-dEVAL", "-XS", "-O2",
+                   "-o%s" % (executable_filename), source_filename]
+    return command
+
+
+def filter_ansi_escape(s):
+    """Remove ansi codes from a string.
+
+    s (string): the input string
+
+    return (string): s without ansi codes.
+
+    """
+    ansi_mode = False
+    res = ''
+    for c in s:
+        if c == u'\x1b':
+            ansi_mode = True
+        if not ansi_mode:
+            res += c
+        if c == u'm':
+            ansi_mode = False
+    return res