Ignore:
Files:
11 added
2 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • sage/combinat/combinat.py

    r7409 r8380  
    193193 
    194194from sage.interfaces.all import gap, maxima 
    195 from sage.rings.all import QQ, RR, ZZ 
     195from sage.rings.all import QQ, ZZ 
    196196from sage.rings.arith import binomial 
    197197from sage.misc.sage_eval import sage_eval 

  • sage/dsage/database/monitordb.py

    r7308 r7660  
    130130         
    131131    def update_monitor(self, host_info): 
    132         import pdb; pdb.set_trace() 
    133132        query = """UPDATE monitors 
    134133        SET hostname = ?, ip = ?, workers = ?, sage_version = ?, os = ?, 
    … …  
    251250        self.con.commit() 
    252251         
    253     def get_worker_count(self, connected, busy): 
     252    def get_worker_count(self, connected, busy=False): 
    254253        """ 
    255254        Returns the number of workers. 
    … …  
    276275        return sum(w[0] for w in result) 
    277276 
    278     def get_cpu_speed(self, connected=True, busy=True): 
     277    def get_cpu_speed(self, connected=True, busy=False): 
    279278        """ 
    280279        Returns the aggregate cpu speed in Mhz. 
    … …  
    285284        """ 
    286285         
    287         if connected: 
     286        if connected and busy: 
    288287            query = """SELECT cpu_speed, workers FROM monitors  
    289288            WHERE connected AND busy""" 
     289        elif connected: 
     290            query = """SELECT cpu_speed, workers FROM monitors  
     291            WHERE connected""" 
    290292        else: 
    291293            query = """SELECT cpu_speed, workers FROM monitors""" 

  • sage/dsage/dsage.py

    r6745 r7644  
    106106     
    107107    def start_all(self, port=None, workers=2, log_level=0, poll=1.0, 
    108                   anonymous_workers=False, verbose=True): 
     108                  anonymous_workers=False, job_failure_threshold=3, 
     109                  verbose=True): 
    109110        """ 
    110111        Start the server and worker and returns a connection to the server. 
    … …  
    118119            port = find_open_port() 
    119120        self.server(port=port, log_level=log_level, blocking=False, 
     121                    job_failure_threshold=job_failure_threshold, 
    120122                    verbose=verbose) 
    121123        self.worker(port=port, workers=workers, log_level=log_level, 
    … …  
    167169               stats_file=os.path.join(DSAGE_DIR, 'dsage.xml'), 
    168170               anonymous_logins=False, 
     171               job_failure_threshold=3, 
    169172               verbose=True): 
    170173        r""" 
    … …  
    185188         
    186189        cmd = 'dsage_server.py -d %s -p %s -l %s -f %s ' + \ 
    187                               '-c %s -k %s --statsfile=%s'  
    188         cmd = cmd % (db_file, port, log_level, log_file, cert, privkey, 
    189                      stats_file) 
     190                              '-c %s -k %s --jobfailures %s --statsfile=%s'  
     191        cmd = cmd % (db_file, port, log_level, log_file, cert, privkey,  
     192                     job_failure_threshold, stats_file) 
    190193        if ssl: 
    191194            cmd += ' --ssl' 

  • sage/dsage/misc/constants.py

    r4657 r7650  
    33DELIMITER = '-' * 50 
    44DSAGE_DIR = os.path.join(os.getenv('DOT_SAGE'), 'dsage') 
     5TMP_WORKER_FILES = os.path.join(DSAGE_DIR, 'tmp_worker_files') 
     6 

  • sage/dsage/scripts/dsage_server.py

    r7307 r7660  
    101101                      default=os.path.join(DSAGE_DIR, 'dsage.db'), 
    102102                      help='database file') 
    103     parser.add_option('--job_failures', 
     103    parser.add_option('--jobfailures', 
    104104                      dest='job_failure_threshold', 
    105105                      type='int', 
    … …  
    117117    return options 
    118118 
    119 def write_stats(dsage_server, stats_file): 
    120     check_dsage_dir() 
    121     try: 
    122         fname = os.path.join(DSAGE_DIR, stats_file) 
    123         f = open(fname, 'w') 
    124         f.write(dsage_server.generate_xml_stats()) 
    125         f.close() 
    126     except Exception, msg: 
    127         print Exception 
    128         print 'Error writing stats: %s' % (msg) 
    129         return 
    130  
    131119def create_manhole(): 
    132120    """ 
    … …  
    202190     
    203191    # Create the looping call that will output the XML file for Dashboard 
    204     tsk1 = task.LoopingCall(write_stats, dsage_server, STATS_FILE) 
    205     tsk1.start(2.0, now=False) 
     192    # tsk1 = task.LoopingCall(write_stats, dsage_server, STATS_FILE) 
     193    # tsk1.start(2.0, now=False) 
    206194         
    207195    SERVER_PORT = find_open_port() 
    … …  
    237225    from twisted.web2 import server, http, resource, channel, static 
    238226    from sage.dsage.web.web_server import Toplevel, GetJobDetails 
    239     top_level = Toplevel(dsage_server) 
     227    top_level = Toplevel(dsage_server, SERVER_PORT) 
    240228    # top_level.putChild(GetJobDetails(dsage_server)) 
    241229    site = server.Site(top_level) 

  • sage/dsage/scripts/dsage_setup.py

    r6720 r7657  
    5656    return config 
    5757 
     58def add_default_user(): 
     59    """ 
     60    Adds the default user. 
     61     
     62    """ 
     63     
     64    from twisted.conch.ssh import keys 
     65    import base64 
     66    from getpass import getuser 
     67     
     68    username = getuser() 
     69    pubkey_file = os.path.join(DSAGE_DIR, 'dsage_key.pub') 
     70    clientdb = ClientDatabase() 
     71    pubkey = base64.encodestring( 
     72                    keys.getPublicKeyString(filename=pubkey_file).strip()) 
     73    if clientdb.get_user(username) is None: 
     74        clientdb.add_user(username, pubkey) 
     75        print 'Added user %s.\n' % (username) 
     76    else: 
     77        user, key = clientdb.get_user_and_key(username) 
     78        if key != pubkey: 
     79            clientdb.del_user(username) 
     80            clientdb.add_user(username, pubkey) 
     81            print "User %s's pubkey changed, setting to new one." % (username) 
     82        else: 
     83            print 'User %s already exists.' % (username) 
     84 
    5885def setup_client(testing=False): 
    5986    check_dsage_dir() 
    … …  
    6289        cmd = ["ssh-keygen", "-q", "-trsa", "-P ''", "-f%s" % key_file] 
    6390        return 
    64  
     91     
     92    if not cmd_exists('ssh-keygen'): 
     93        print DELIMITER 
     94        print "Could NOT find ssh-keygen." 
     95        print "Aborting." 
     96        return 
     97         
    6598    print DELIMITER 
    6699    print "Generating public/private key pair for authentication..." 
    … …  
    68101    print "Just hit enter when prompted for a passphrase" 
    69102    print DELIMITER 
     103     
    70104    cmd = ["ssh-keygen", "-q", "-trsa", "-f%s" % key_file]     
    71105    ld = os.environ['LD_LIBRARY_PATH'] 
    … …  
    75109    finally: 
    76110        os.environ['LD_LIBRARY_PATH'] = ld 
     111         
    77112    print "\n" 
    78113    print "Client configuration finished.\n" 
    … …  
    131166    f.write(s) 
    132167    f.close() 
     168     
    133169    # Disable certificate generation -- not used right now anyways 
    134170    privkey_file = os.path.join(DSAGE_DIR, 'cacert.pem') 
    135171    pubkey_file = os.path.join(DSAGE_DIR, 'pubcert.pem') 
     172     
    136173    print DELIMITER 
    137174    print "Generating SSL certificate for server..." 
     175     
    138176    if os.uname()[0] != 'Darwin' and cmd_exists('openssl'): 
    139177        # We use openssl by default if it exists, since it is *vastly* 
    … …  
    157195    subprocess.call(cmd, shell=True) 
    158196    print DELIMITER 
     197     
     198    # Set read only permissions on cert 
    159199    os.chmod(os.path.join(DSAGE_DIR, 'cacert.pem'), 0600) 
    160200     
    161     # conf_file = os.path.join(DSAGE_DIR, 'server.conf') 
    162     # config.write(open(conf_file, 'w')) 
    163              
    164201    # add default user 
    165     from twisted.conch.ssh import keys 
    166     import base64 
    167  
    168     # c = ConfigParser.ConfigParser() 
    169     # c.read(os.path.join(DSAGE_DIR, 'client.conf')) 
    170     from getpass import getuser 
    171     username = getuser() 
    172     pubkey_file = os.path.join(DSAGE_DIR, 'dsage_key.pub') 
    173     clientdb = ClientDatabase() 
    174     pubkey = base64.encodestring( 
    175                     keys.getPublicKeyString(filename=pubkey_file).strip()) 
    176     if clientdb.get_user(username) is None: 
    177         clientdb.add_user(username, pubkey) 
    178         print 'Added user %s.\n' % (username) 
    179     else: 
    180         user, key = clientdb.get_user_and_key(username) 
    181         if key != pubkey: 
    182             clientdb.del_user(username) 
    183             clientdb.add_user(username, pubkey) 
    184             print "User %s's pubkey changed, setting to new one." % (username) 
    185         else: 
    186             print 'User %s already exists.' % (username) 
     202    add_default_user() 
    187203             
    188204    print "Server configuration finished.\n\n" 

  • sage/dsage/scripts/dsage_worker.py

    r7307 r7660  
    4949from sage.dsage.misc.constants import DELIMITER 
    5050from sage.dsage.misc.constants import DSAGE_DIR 
     51from sage.dsage.misc.constants import TMP_WORKER_FILES 
    5152from sage.dsage.misc.misc import random_str 
    5253 
    … …  
    194195         
    195196        cur_dir = os.getcwd() # keep a reference to the current directory 
    196         tmp_dir = os.path.join(DSAGE_DIR, 'tmp_worker_files') 
    197         tmp_job_dir = os.path.join(tmp_dir, job.job_id) 
    198         if not os.path.isdir(tmp_dir): 
    199             os.mkdir(tmp_dir) 
     197        tmp_job_dir = os.path.join(TMP_WORKER_FILES, job.job_id) 
     198        if not os.path.isdir(TMP_WORKER_FILES): 
     199            os.mkdir(TMP_WORKER_FILES) 
    200200        if not os.path.isdir(tmp_job_dir): 
    201201            os.mkdir(tmp_job_dir) 
    … …  
    350350            msg = 'Checking job %s' % self.job.job_id 
    351351            log.msg(LOG_PREFIX % self.id + msg) 
     352        os.chdir(self.tmp_job_dir) 
    352353        try: 
    353             os.chdir(self.tmp_job_dir) 
    354354            # foo, output, new = self.sage._so_far()  
    355355            # This sucks and is a very bad way to tell when a calculation is 
    … …  
    499499        """ 
    500500         
     501        # Set status to free and delete any current jobs we have 
     502        self.free = True 
     503        self.job = None 
     504         
    501505        if hard_reset: 
    502506            log.msg(LOG_PREFIX % self.id + 'Performing hard reset.') 
    503507            self.kill_sage() 
    504             self.start() 
    505508        else: # try for a soft reset 
    506509            INTERRUPT_TRIES = 20 
    … …  
    527530            if not success: 
    528531                self.kill_sage() 
    529                 self.start() 
    530532            else: 
    531533                self.sage.reset() 
    532         self.free = True 
    533         self.job = None 
    534534     
    535535    def start(self): 
    … …  
    733733            return 
    734734     
    735         factory = pb.PBClientFactory()         
    736735        self.factory = PBClientFactory() 
    737736        try: 

  • sage/dsage/server/server.py

    r7296 r7660  
    285285                msg = '%s failed, removing from queue.' % (job_id) 
    286286                log.msg(msg) 
     287         
     288        job.update_time = datetime.datetime.now() 
    287289             
    288290        return self.jobdb.store_job(job.reduce()) 
    … …  
    355357         
    356358        return count 
    357      
    358     def generate_xml_stats(self): 
    359         """ 
    360         This method returns a an XML document to be consumed by the  
    361         Mac OS X Dashboard widget and the web server. 
    362          
    363         """ 
    364          
    365         def create_gauge(doc): 
    366             gauge = doc.createElement('gauge') 
    367             doc.appendChild(gauge) 
    368  
    369             return doc, gauge 
    370  
    371         def add_totalAgentCount(doc, gauge): 
    372             totalAgentCount = doc.createElement('totalAgentCount') 
    373             gauge.appendChild(totalAgentCount) 
    374             working_workers = self.monitordb.get_worker_count(connected=True, 
    375                                                               busy=True) 
    376             free_workers = self.monitordb.get_worker_count(connected=True, 
    377                                                            busy=False) 
    378             disconnected_workers = self.monitordb.get_worker_count( 
    379                                    connected=False, 
    380                                    busy=False) 
    381             total_workers = (working_workers +  
    382                              free_workers +  
    383                              disconnected_workers) 
    384             count = doc.createTextNode(str(total_workers)) 
    385             totalAgentCount.appendChild(count) 
    386  
    387             return doc, totalAgentCount 
    388          
    389         def add_onlineAgentCount(doc, gauge): 
    390             onlineAgentCount = doc.createElement('onlineAgentCount') 
    391             gauge.appendChild(onlineAgentCount) 
    392             free_workers = self.monitordb.get_worker_count(connected=True, 
    393                                                            busy=False) 
    394             busy_workers = self.monitordb.get_worker_count(connected=True, 
    395                                                            busy=True) 
    396             count = doc.createTextNode(str(free_workers + busy_workers)) 
    397             onlineAgentCount.appendChild(count) 
    398              
    399             return doc, onlineAgentCount 
    400              
    401         def add_offlineAgentCount(doc, gauge): 
    402             offlineAgentCount = doc.createElement('offlineAgentCount') 
    403             gauge.appendChild(offlineAgentCount) 
    404             worker_count = self.monitordb.get_worker_count(connected=False, 
    405                                                            busy=False) 
    406             count = doc.createTextNode(str(worker_count)) 
    407             offlineAgentCount.appendChild(count) 
    408              
    409             return doc, offlineAgentCount 
    410              
    411         def add_workingAgentCount(doc, gauge): 
    412             workingAgentCount = doc.createElement('workingAgentCount') 
    413             gauge.appendChild(workingAgentCount) 
    414             worker_count = self.monitordb.get_worker_count(connected=True, 
    415                                                            busy=True) 
    416             count = doc.createTextNode(str(worker_count)) 
    417             workingAgentCount.appendChild(count) 
    418              
    419             return doc, workingAgentCount 
    420          
    421         def add_availableAgentCount(doc, gauge): 
    422             availableAgentCount = doc.createElement('availableAgentCount') 
    423             gauge.appendChild(availableAgentCount) 
    424             worker_count = self.monitordb.get_worker_count(connected=True, 
    425                                                            busy=False) 
    426             count = doc.createTextNode(str(worker_count)) 
    427             availableAgentCount.appendChild(count) 
    428              
    429             return doc, availableAgentCount 
    430          
    431         def add_unavailableAgentCount(doc, gauge): 
    432             unavailableAgentCount = doc.createElement('unavailableAgentCount') 
    433             gauge.appendChild(unavailableAgentCount) 
    434             worker_count = self.monitordb.get_worker_count(connected=True, 
    435                                                            busy=True) 
    436             count = doc.createTextNode(str(worker_count)) 
    437             unavailableAgentCount.appendChild(count) 
    438              
    439             return doc, unavailableAgentCount 
    440              
    441         def add_workingMegaHertz(doc, gauge): 
    442             workingMegaHertz = doc.createElement('workingMegaHertz') 
    443             gauge.appendChild(workingMegaHertz) 
    444             cpu_speed = self.monitordb.get_cpu_speed(connected=True, 
    445                                                      busy=True) 
    446             mhz = doc.createTextNode(str(cpu_speed)) 
    447             workingMegaHertz.appendChild(mhz) 
    448  
    449             return doc, workingMegaHertz 
    450  
    451         def add_availableProcessorCount(doc, gauge): 
    452             pass 
    453              
    454         def add_unavailableProcessorCount(doc, gauge): 
    455             pass 
    456              
    457         def add_onlineProcessorCount(doc, gauge): 
    458             onlineProcessorCount = doc.createElement('onlineProcessorCount') 
    459             gauge.appendChild(onlineProcessorCount) 
    460             cpu_count = self.monitordb.get_cpu_count(connected=True) 
    461             c = doc.createTextNode(str(cpu_count)) 
    462             onlineProcessorCount.appendChild(c) 
    463              
    464             return doc, onlineProcessorCount 
    465          
    466         def add_offlineProcessorCount(doc, gauge): 
    467             offlineProcessorCount = doc.createElement('offlineProcessorCount') 
    468             gauge.appendChild(offlineProcessorCount) 
    469             cpu_count = self.monitordb.get_cpu_count(connected=False) 
    470             c = doc.createTextNode(str(cpu_count)) 
    471             offlineProcessorCount.appendChild(c) 
    472              
    473             return doc, offlineProcessorCount 
    474              
    475         def add_workingProcessorCount(doc, gauge): 
    476             workingProcessorCount = doc.createElement('workingProcessorCount') 
    477             gauge.appendChild(workingProcessorCount) 
    478             worker_count = self.monitordb.get_cpu_count(connected=True) 
    479             pcount = doc.createTextNode(str(worker_count)) 
    480             workingProcessorCount.appendChild(pcount) 
    481  
    482             return doc, workingProcessorCount 
    483          
    484         def add_workingAgentPercentage(doc, gauge): 
    485             workingAgentPercentage = doc.createElement( 
    486                                                     'workingAgentPercentage') 
    487             gauge.appendChild(workingAgentPercentage) 
    488             working_workers = self.monitordb.get_worker_count(connected=True, 
    489                                                               busy=True) 
    490             free_workers = self.monitordb.get_worker_count(connected=True, 
    491                                                            busy=False) 
    492             disconnected_workers = self.monitordb.get_worker_count( 
    493                                    connected=False, 
    494                                    busy=False) 
    495             total_workers = (working_workers +  
    496                              free_workers +  
    497                              disconnected_workers) 
    498              
    499             if total_workers != 0: 
    500                 worker_percentage = (float(working_workers / total_workers) * 
    501                 100) 
    502             else: 
    503                 worker_percentage = 0.0 
    504             percentage = doc.createTextNode(str(worker_percentage)) 
    505             workingAgentPercentage.appendChild(percentage) 
    506              
    507             return doc, workingAgentPercentage 
    508              
    509         def add_date(doc, gauge): 
    510             date = datetime.datetime.now() 
    511  
    512             year = doc.createElement('Year') 
    513             gauge.appendChild(year) 
    514             year.appendChild(doc.createTextNode(str(date.year))) 
    515  
    516             seconds = doc.createElement('Seconds') 
    517             gauge.appendChild(seconds) 
    518             seconds.appendChild(doc.createTextNode(str(date.second))) 
    519  
    520             minutes = doc.createElement('Minutes') 
    521             gauge.appendChild(minutes) 
    522             minutes.appendChild(doc.createTextNode(str(date.minute))) 
    523  
    524             return doc, year, seconds, minutes 
    525          
    526         doc = xml.dom.minidom.Document() 
    527         doc, gauge = create_gauge(doc) 
    528          
    529         add_totalAgentCount(doc, gauge) 
    530         add_onlineAgentCount(doc, gauge) 
    531         add_offlineAgentCount(doc, gauge) 
    532         add_availableAgentCount(doc, gauge) 
    533         add_unavailableAgentCount(doc, gauge) 
    534         add_workingAgentCount(doc, gauge) 
    535         add_workingAgentPercentage(doc, gauge) 
    536  
    537         add_onlineProcessorCount(doc, gauge) 
    538         add_offlineAgentCount(doc, gauge) 
    539         add_availableProcessorCount(doc, gauge) 
    540         add_unavailableProcessorCount(doc, gauge) 
    541         add_workingProcessorCount(doc, gauge) 
    542         add_workingMegaHertz(doc, gauge) 
    543          
    544         add_date(doc, gauge) 
    545         s = cStringIO.StringIO()     
    546         doc.writexml(s, newl='\n') 
    547          
    548         return s.getvalue() 
    549359 
    550360class DSageWorkerServer(DSageServer): 

  • sage/dsage/twisted/pb.py

    r7306 r7641  
    7575                          creds.signature, 
    7676                          mind) 
    77  
    7877            return d 
    7978        elif IAnonymous.providedBy(creds): 

  • sage/dsage/web/static/dsage_web.css

    r7296 r7656  
    3232} 
    3333 
    34 #server_stats { 
    35     padding-left: 60%; 
    36     font-size:10px; 
    37 } 
    38  
    3934#title { 
    4035    font-size:24px; 
    … …  
    4540    padding-bottom:10px; 
    4641    margin:0px; 
     42} 
     43 
     44#navigator { 
     45    font-size:10px; 
     46    text-align: center; 
     47} 
     48 
     49#server_title { 
     50    font-size: 24px; 
     51} 
     52 
     53#help { 
     54    font-size: 12px; 
    4755} 
    4856 
    … …  
    95103/* end css tabs */ 
    96104 
    97 table.jobs_table, table.job_details { 
    98     border: solid #000 1px; 
    99     border-bottom: solid #000 1px; 
    100     border-right: solid #000 1px; 
    101     border-collapse: collapse; 
    102     width: 100%; 
    103     margin-left: auto; 
    104     margin-right: auto; 
    105     padding-left:10px; 
    106     padding-right:10px; 
     105table.tablesorter { 
     106        font-family:arial; 
     107        background-color: #CDCDCD; 
     108        margin:10px 0pt 15px; 
     109        font-size: 8pt; 
     110        width: 100%; 
     111        text-align: left; 
    107112} 
    108 table.jobs_table tr.tr0, table.job_details tr.tr0 { 
    109     font-size:16px; 
    110     background-color: #FFFFFF; 
     113table.tablesorter thead tr th, table.tablesorter tfoot tr th { 
     114        background-color: #e6EEEE; 
     115        border: 1px solid #FFF; 
     116        font-size: 8pt; 
     117        padding: 4px; 
    111118} 
    112 table.jobs_table tr.tr1, table.job_details tr.tr1 { 
    113     font-size:16px; 
    114     background-color: #D8CAA8; 
     119table.tablesorter thead tr .header { 
     120        background-image: url(bg.gif); 
     121        background-repeat: no-repeat; 
     122        background-position: center right; 
     123        cursor: pointer; 
    115124} 
    116 table.jobs_table tr.thead, table.job_details tr.thead { 
    117  
     125table.tablesorter tbody td { 
     126        color: #3D3D3D; 
     127        padding: 4px; 
     128        background-color: #FFF; 
     129        vertical-align: top; 
    118130} 
    119  
    120 #jobs_table { 
    121     border: solid #000 1px; 
    122     border-bottom: solid #000 1px; 
    123     border-right: solid #000 1px; 
    124     border-collapse: collapse; 
    125     width: 100%; 
    126     margin-left: auto; 
    127     margin-right: auto; 
    128     padding-left:10px; 
    129     padding-right:10px; 
     131table.tablesorter tbody tr.odd td { 
     132        background-color:#F0F0F6; 
    130133} 
    131 #jobs_table thead { 
    132     width:100%; 
    133     height:20px; 
    134     font-size:16px; 
    135     background-color: #D8CAA8; 
    136     font-family: 'verdana'; 
     134table.tablesorter thead tr .headerSortUp { 
     135        background-image: url(asc.gif); 
    137136} 
    138 table.jobs_table A:link, table.job_details A:link { 
    139     color: #193441; 
     137table.tablesorter thead tr .headerSortDown { 
     138        background-image: url(desc.gif); 
    140139} 
    141 table.jobs_table A:visited, table.job_details A:link { 
    142     color: #3E606F; 
     140table.tablesorter thead tr .headerSortDown, table.tablesorter thead tr .headerSortUp { 
     141background-color: #8dbdd8; 
    143142} 

  • sage/dsage/web/static/dsage_web.js

    r7304 r7658  
     1var count = 10; // Default count 
     2 
     3function getServerDetails () { 
     4    $('#server_details').load('get_server_details', function() { 
     5                                    $("#server_details").tablesorter(); }); 
     6    showServer(); 
     7} 
     8 
     9function showServer () { 
     10    $('#jobs_table').hide(); 
     11    $('#job_details').hide(); 
     12    $('#help').hide(); 
     13    $('#navigator').hide(); 
     14    $('#server_details').show(); 
     15} 
     16function getJobs (c) { 
     17    count = c; // Set global variable count to the selected count.  
     18     
     19    // Load jobs table with the given number of jobs. 
     20    $('#jobs_table').load('get_jobs', {'count': c}, function() { 
     21            $("#jobs_table").tablesorter(); } ); 
     22             
     23    // Change current selected count to red  
     24    $('#navigator > a').css('color', 'black'); 
     25    $('#' + c).css('color', 'red'); 
     26} 
     27 
     28function showJobs () { 
     29    $('#server_details').hide();     
     30    $('#job_details').hide(); 
     31    $('#help').hide(); 
     32    $('#jobs_table').show(); 
     33    $('#navigator').show(); 
     34} 
     35 
     36function getJobDetails (job_id) { 
     37    $('#job_details').load('get_details', {'job_id': job_id}, function() { 
     38                                        $("#job_details").tablesorter(); } ); 
     39    showJobDetails(); 
     40} 
     41 
     42function showJobDetails () { 
     43    $('#jobs_table').hide(); 
     44    $('#navigator').hide(); 
     45    $('#server_details').hide(); 
     46    $('#help').hide(); 
     47    $('#job_details').show(); 
     48} 
     49 
     50function getHelp () { 
     51    $('#help').load('get_help'); 
     52    showHelp(); 
     53} 
     54 
     55function showHelp () { 
     56    $('#jobs_table').hide(); 
     57    $('#navigator').hide(); 
     58    $('#server_details').hide(); 
     59    $('#job_details').hide(); 
     60    $('#help').show(); 
     61} 
     62 
     63// PageLoad function 
     64// This function is called when: 
     65// 1. after calling $.historyInit(); 
     66// 2. after calling $.historyLoad(); 
     67// 3. after pushing "Go Back" button of a browser 
     68function pageload(hash) { 
     69        // hash doesn't contain the first # character. 
     70        if(hash) { 
     71                // restore ajax loaded state 
     72        if (hash=='jobs') { 
     73            showJobs(); 
     74        } 
     75        else if (hash=='server') { 
     76            getServerDetails(); 
     77        } 
     78        else if (hash=='help') { 
     79            getHelp(); 
     80        } 
     81        }  
     82        else { 
     83                // start page 
     84                showJobs(); 
     85        } 
     86} 
     87 
     88function gethash (that) { 
     89    var hash = that.href; 
     90        hash = hash.replace(/^.*#/, ''); 
     91        // moves to a new page.  
     92        // pageload is called at once.  
     93    $.historyLoad(hash); 
     94        return false; 
     95} 
     96 
    197$(document).ready(function()  
    298    {  
    3         $("#myTable").tablesorter();  
     99        // Initialize history plugin. 
     100                // The callback is called at once by present location.hash.  
     101                $.historyInit(pageload); 
     102                // set onlick event for buttons 
     103                $("a[@rel='history']").click(function() {gethash(this); }); 
     104        getJobs(count); // Run it the first time 
     105         
     106        // Only show jobs if this.href is none or jobs 
     107        if (this.href == '' || this.href == '#jobs') { 
     108            showJobs(); 
     109        } 
     110        // setInterval('getJobs(count)', 5000); // Update it every 5 seconds.   
    4111    }  
    5112); 

  • sage/dsage/web/web_server.py

    r7296 r7660  
    2020import os 
    2121import sqlite3 
     22from cStringIO import StringIO 
     23import socket 
    2224 
    2325from twisted.web2 import http, resource 
    2426from twisted.web2 import static, http_headers, responsecode 
    2527 
     28from sage.dsage.misc.constants import TMP_WORKER_FILES 
     29from sage.dsage.server.stats import XMLStats 
     30 
     31from xml.etree.ElementTree import (ElementTree as ET, 
     32                                   Element, 
     33                                   SubElement, 
     34                                   dump, 
     35                                   XML) 
     36                                    
    2637SAGE_ROOT  = os.environ['SAGE_ROOT'] 
    2738DSAGE_LOCAL = SAGE_ROOT + '/local/dsage' 
    28 CSS_FILE = os.path.join(DSAGE_LOCAL,'web/static/dsage_web.css') 
    29 SORTTABLE = os.path.join(DSAGE_LOCAL,'web/static/sorttable.js') 
    30 JS_FILE = os.path.join(DSAGE_LOCAL,'web/static/dsage_web.js') 
    31 PROTOTYPE = os.path.join(DSAGE_LOCAL,'web/static/prototype.js') 
    32 INDEX = os.path.join(DSAGE_LOCAL,'web/static/index.html') 
    33  
    34 # def create_jobs_table(jdicts): 
    35 #     """ 
    36 #     Returns an HTML table of jobs given a list of job dictionaries. 
    37 #      
    38 #     """ 
    39 #      
    40 #     html = """ 
    41 #     <table class='jobs_table' cellspacing='0' padding='5px' border='solid #000 1px'> 
    42 #     <tr class='thead'> 
    43 #         <td>Job ID</td> 
    44 #         <td>Status</td> 
    45 #         <td>Username</td> 
    46 #         <td>Creation Time</td> 
    47 #         <td>Last Update</td> 
    48 #         <td>Priority</td> 
    49 #     </tr> 
    50 #     """ 
    51 #      
    52 #     for i, jdict in enumerate(jdicts): 
    53 #         html+=""" 
    54 #         <tr class='tr%s' 
    55 #         """ % (i % 2) 
    56 #         html+=""" 
    57 #             <td><a href='get_details?job_id=%s'>%s</a></td> 
    58 #             <td>%s</td> 
    59 #             <td>%s</td> 
    60 #             <td>%s</td> 
    61 #             <td>%s</td> 
    62 #             <td>%s</td> 
    63 #         </tr> 
    64 #         """ % (jdict['job_id'],jdict['job_id'], jdict['status'],  
    65 #                jdict['username'], jdict['creation_time'], 
    66 #                jdict['update_time'], jdict['priority']) 
    67 #  
    68 #     html += '</table>' 
    69 #      
    70 #     return html 
     39INDEX = os.path.join(DSAGE_LOCAL,'web/index.html') 
     40STATIC = os.path.join(DSAGE_LOCAL,'web/static') 
     41 
     42def create_jobs_table(jdicts): 
     43    """ 
     44    Returns an HTML table of jobs given a list of job dictionaries. 
     45     
     46    """ 
     47     
     48    html = """ 
     49    <thead> 
     50    <tr> 
     51        <th>Job ID</th> 
     52        <th>Status</th> 
     53        <th>Username</th> 
     54        <th>Creation Time</th> 
     55        <th>Last Update</th> 
     56        <th>Priority</th> 
     57    </tr> 
     58    </thead> 
     59    <tbody> 
     60    """ 
     61     
     62    for i, jdict in enumerate(jdicts): 
     63        creation_time = jdict['creation_time'].strftime('%F %r') 
     64        try: 
     65            update_time = jdict['update_time'].strftime('%F %r') 
     66        except AttributeError: # This is a fix for older databases.  
     67            update_time = "N/A" 
     68        html+=""" 
     69        <tr class='tr%s' 
     70        """ % (i % 2) 
     71        html+=""" 
     72            <td><a href='#%s' onClick="getJobDetails('%s')">%s</a></td> 
     73            <td>%s</td> 
     74            <td>%s</td> 
     75            <td>%s</td> 
     76            <td>%s</td> 
     77            <td>%s</td> 
     78        </tr> 
     79        """ % (jdict['job_id'], jdict['job_id'], jdict['job_id'], 
     80               jdict['status'],  
     81               jdict['username'], creation_time, 
     82               update_time, jdict['priority']) 
     83    html += """</tbody>""" 
     84     
     85    return html 
    7186     
    7287class Toplevel(resource.Resource): 
    7388    addSlash = True 
    74     # header = """ 
    75     # <html> 
    76     # <header> 
    77     #     <link rel="stylesheet" type="text/css" href="dsage_web.css" /> 
    78     #     <scritp src='prototype.js' type='text/javascript'></script> 
    79     #     <script src='dsage_web.js' type='text/javascript'></script> 
    80     # </header> 
    81     # <body> 
    82     #     <div id='header'> 
    83     #         <div id='title'><h1>DSAGE Job Status</h1></div> 
    84     #     </div> 
    85     # """ 
    86     #  
    87     # footer = """ 
    88     # </body> 
    89     # </html> 
    90     # """ 
    91      
    92     def __init__(self, dsage_server): 
     89     
     90    def __init__(self, dsage_server, server_port): 
    9391        self.dsage_server = dsage_server   
    94         self.child_get_details = GetJobDetails(self.dsage_server) 
    95         self.child_get_jobs = GetJobs(self.dsage_server) 
    96    
     92        self.server_port = server_port 
     93         
     94    def child_static(self, ctx): 
     95        return static.File(STATIC) 
     96     
     97    def child_get_details(self, ctx): 
     98        return GetJobDetails(self.dsage_server) 
     99     
     100    def child_get_jobs(self, ctx): 
     101        return GetJobs(self.dsage_server) 
     102     
     103    def child_get_server_details(self, ctx): 
     104        return GetServerDetails(self.dsage_server) 
     105     
     106    def child_get_help(self, ctx): 
     107        return GetHelp() 
     108     
     109    def child_worker_files(self, ctx): 
     110        return static.File(TMP_WORKER_FILES) 
     111         
    97112    def render(self, ctx): 
    98         jobs = self.dsage_server.jobdb.get_all_jobs() 
    99         # jobs_html = create_jobs_table(jobs) 
    100         f = open(INDEX) 
    101         return http.Response(stream=f.read()) 
    102         # return http.Response(stream=self.header + jobs_html + self.footer)    
    103 setattr(Toplevel, 'child_dsage_web.css', static.File(CSS_FILE)) 
    104 setattr(Toplevel, 'child_dsage_web.js', static.File(JS_FILE)) 
    105 setattr(Toplevel, 'child_prototype.js', static.File(PROTOTYPE)) 
    106 setattr(Toplevel, 'child_sorttable.js', static.File(SORTTABLE)) 
    107 # setattr(Toplevel, 'child_index.html', static.File(INDEX)) 
    108  
     113        index = open(INDEX).read() % (socket.getfqdn(), self.server_port) 
     114        # return static.File(StringIO(index)) 
     115        return http.Response(stream=index) 
     116 
     117class GetHelp(resource.PostableResource): 
     118    """ 
     119    Returns the help page. 
     120     
     121    """ 
     122     
     123    def render(self, request): 
     124        return static.File(os.path.join(STATIC, 'README.html')) 
     125         
    109126class GetJobs(resource.PostableResource): 
    110127    """ 
    … …  
    118135         
    119136    def render(self, request): 
    120         jdicts = self.dsage_server.jobdb.get_all_jobs()[:10] 
    121         html = """ 
    122         <tr class='thead'> 
    123             <td>Job ID</td> 
    124             <td>Status</td> 
    125             <td>Username</td> 
    126             <td>Creation Time</td> 
    127             <td>Last Update</td> 
    128             <td>Priority</td> 
    129         </tr>""" 
    130         # if len(jdicts) != len(self.jdicts): 
    131         #     self.jdicts = jdicts 
    132         for i, jdict in enumerate(jdicts): 
    133             html+=""" 
    134             <tr class='tr%s'> 
    135             """ % (i % 2) 
    136             html+=""" 
    137                 <td><a href='get_details?job_id=%s'>%s</a></td> 
    138                 <td>%s</td> 
    139                 <td>%s</td> 
    140                 <td>%s</td> 
    141                 <td>%s</td> 
    142                 <td>%s</td> 
    143             </tr> 
    144             """ % (jdict['job_id'],jdict['job_id'], jdict['status'],  
    145                    jdict['username'], jdict['creation_time'], 
    146                    jdict['update_time'], jdict['priority']) 
    147  
    148         html += '</table>' 
    149         # else: 
    150         #     pass 
    151         # xml_stream = self.build_xml(jdicts) 
     137        try: 
     138            count = int(request.args['count'][0]) 
     139        except: 
     140            count = 10 
     141        if count == - 1: 
     142            jdicts = self.dsage_server.jobdb.get_all_jobs() 
     143        else: 
     144            jdicts = self.dsage_server.jobdb.get_all_jobs()[:count] 
     145             
     146        html = create_jobs_table(jdicts) 
    152147         
    153148        return http.Response(stream=html) 
    … …  
    165160                                           dump, 
    166161                                           XML) 
    167         from cStringIO import StringIO 
    168162        root = Element('jobs')    
    169163              
    … …  
    187181     
    188182    """ 
    189      
    190     header = """ 
    191     <html> 
    192     <header> 
    193         <link rel="stylesheet" type="text/css" href="dsage_web.css" /> 
    194         <scritp src='prototype.js' type='text/javascript'></script> 
    195     </header> 
    196     <body> 
    197         <div id='header'> 
    198             <div id='title'><h1>Details for %s</h1></div> 
    199         </div> 
    200     """ 
    201      
    202     footer = """ 
    203     </body> 
    204     </html> 
    205     """ 
    206      
     183       
    207184    def __init__(self, dsage_server): 
    208185        self.dsage_server = dsage_server 
    … …  
    212189        try: 
    213190            html = """ 
    214             <table class='job_details'> 
    215             <tr class='thead'> 
    216                 <td>Key</td> 
    217                 <td>Value</td> 
     191            <thead> 
     192            <tr> 
     193                <th>Key</th> 
     194                <th>Value</th> 
    218195            </tr> 
     196            </thead> 
     197            <tbody> 
    219198            """ 
     199             
    220200            jdict = self.dsage_server.jobdb.get_job_by_id(job_id) 
    221201            if not isinstance(jdict, dict): 
    222202                raise TypeError 
    223203            for i, (k, v) in enumerate(jdict.iteritems()): 
    224                 if k == 'code': # We will display the code below the table 
    225                     continue 
     204                # if k == 'code': # We will display the code below the table 
     205                #     continue         
     206                if k == 'result': # result is an .sobj, link to the file 
     207                    v = "<a href='worker_files/%s'>result.sobj (Click to download.)</a>" % (jdict['job_id'] + '/' + 'result.sobj') 
    226208                html += """ 
    227209                <tr class='tr%s'> 
    228                 """ % (i % 2) 
     210                """ % (i % 2)                     
    229211                html += """ 
    230212                <td>%s</td> 
    … …  
    232214                </tr> 
    233215                """ %(k, v) 
    234             html += "</table>" 
     216             
    235217            html += """ 
    236             <div id='title'> 
    237                 Job Code 
    238             </div> 
    239             <div id='job_code'> 
    240             %s 
    241             <div> 
    242             """ % jdict['code'] 
     218            </tbody> 
     219            """ 
    243220        except (sqlite3.InterfaceError, TypeError): 
    244221            html = 'Invalid job id.' 
    245         html = self.header % (job_id) + html + self.footer 
     222         
    246223        return http.Response(stream=html) 
    247224 
    248 class GetServerDetails(resource.Resource): 
    249     """ 
    250     Returns an XML file containing the server resources. 
     225class GetServerDetails(resource.PostableResource): 
     226    """ 
     227    Returns an HTML table containing the server resources. 
    251228     
    252229    """ 
    … …  
    254231    def __init__(self, dsage_server): 
    255232        self.dsage_server = dsage_server 
    256          
    257     def render(self): 
     233        self.xml_stats = XMLStats(self.dsage_server) 
     234         
     235    def gen_html(self): 
     236        """ 
     237        generates html snippet from xml stats 
     238         
     239        """ 
     240 
     241        self.xml_stats.gen_xml() 
     242         
     243        html = """ 
     244        <thead> 
     245        <tr> 
     246        <th>Stat</th> 
     247        <th>Value</th> 
     248        <tbody>""" 
     249 
     250        for i, elem in enumerate(self.xml_stats.root.getchildren()):       
     251                html += """ 
     252                <tr> 
     253                    <td>%s</td> 
     254                    <td>%s</td> 
     255                </tr> 
     256                """ % (' '.join(w.title() for w in elem.tag.split("_")),  
     257                       elem.text) 
     258 
     259        html += """ 
     260        </tbody> 
     261        """ 
     262         
     263        return html 
     264         
     265    def render(self, request): 
    258266        """ 
    259267        Asks the server to generate stats and returns it in an XML file. 
    260268         
    261269        """ 
    262          
    263         return self.dsage_server.generate_xml_stats() 
     270                         
     271        return http.Response(stream=self.gen_html()) 

  • sage/libs/pari/gen.pyx

    r7355 r8380  
    47274727        return n 
    47284728 
     4729    def polsturm_full(self): 
     4730        _sig_on 
     4731        n = sturmpart(self.g, NULL, NULL) 
     4732        _sig_off 
     4733        return n 
     4734 
    47294735    def polsylvestermatrix(self, g): 
    47304736        t0GEN(g) 

  • sage/rings/number_field/all.py

    r6961 r8379  
    1010 
    1111from order import is_NumberFieldOrder, EquationOrder 
     12 
     13from totallyreal import enumerate_totallyreal_fields 
     14from totallyreal_data import hermite_constant 
     15from totallyreal_dsage import totallyreal_dsage 
     16from totallyreal_rel import enumerate_totallyreal_fields_imprim, enumerate_totallyreal_fields_rel 

  • sage/rings/number_field/number_field_element.pyx

    r7355 r8380  
    594594        """ 
    595595        return self.number_field().complex_embeddings(prec)[i](self) 
     596 
     597    def is_totally_positive(self): 
     598        """ 
     599        Returns True if self is positive for all real embeddings of  
     600        its parent number field.  We do nothing at complex places, 
     601        so e.g. any element of a totally complex number field will return 
     602        True. 
     603 
     604        EXAMPLES: 
     605            sage: F.<b> = NumberField(x^3-3*x-1) 
     606            sage: b.is_totally_positive() 
     607            False 
     608            sage: (b^2).is_totally_positive() 
     609            True 
     610        """ 
     611        for v in self.number_field().real_embeddings(): 
     612            if v(self) <= 0: 
     613                return False 
     614        return True     
    596615 
    597616    def is_square(self, root=False): 

  • setup.py

    r7388 r8380  
    773773    Extension('sage.rings.number_field.number_field_base', 
    774774              sources = ['sage/rings/number_field/number_field_base.pyx']), \ 
     775 
     776    Extension('sage.rings.number_field.totallyreal_data', 
     777              ['sage/rings/number_field/totallyreal_data.pyx'], 
     778              libraries = ['gmp']), 
    775779 
    776780    Extension('sage.rings.morphism', 
    … …  
    12051209 
    12061210      data_files = [('dsage/web/static',                        
    1207                      ['sage/dsage/web/static/dsage_web.css', 
    1208                       'sage/dsage/web/static/dsage_web.js', 
    1209                       'sage/dsage/web/static/jquery-latest.js', 
    1210                       'sage/dsage/web/static/jquery.tablesorter.pack.js', 
    1211                       'sage/dsage/web/static/index.html'])], 
     1211                    ['sage/dsage/web/static/dsage_web.css', 
     1212                     'sage/dsage/web/static/dsage_web.js', 
     1213                     'sage/dsage/web/static/jquery-latest.js', 
     1214                     'sage/dsage/web/static/jquery.tablesorter.pack.js', 
     1215                     'sage/dsage/web/static/jquery.history.js', 
     1216                     'sage/dsage/web/static/asc.gif', 
     1217                     'sage/dsage/web/static/desc.gif', 
     1218                     'sage/dsage/web/static/bg.gif', 
     1219                     'sage/dsage/README.html']), 
     1220                    ('dsage/web/', 
     1221                    ['sage/dsage/web/index.html'])], 
    12121222       
    12131223      ext_modules = ext_modules, 
Note: See TracChangeset for help on using the changeset viewer.