SocketServer_Server.py

Go to the documentation of this file.

#!/usr/bin/python

## @package serverportfolio.SocketServer_Server
# @brief Server of the application, wait for requests: provide data, force update, etc.
#
# Last Changed $Id: SocketServer_Server.py 9 2015-04-02 23:27:25Z michael $

#
# Can be run alone ( just for test ), 
#       will parse last value from internet, but not running autoparser, and quit after 3 seconds.
#   or loaded and run by Server_Portfolio.py ( main use ) 

# 6th version, adding LastCSVUpdate and UpdateCSV
# 5th version, new option RELOAD, reload dictstocks.txt, check if open or not, actualize queueing system
# 4th version, can answer to multiple stock like GET CAC40 DJ S&P500
#    only a call for multiple answer, better for php exec
#
# 3thd version of a TCP server
# can respond to GET CAC40 and get data
# can force      FORCE CAC40 to run parser and get new data
#
# with module SocketServer
# Possibility to make one thread, answering to request. One unique is certainly enought ??
# Data is in memory in a DictStock_Parser
# Add more specific class for 2nde version, in order to include it after
#
# found on internet !!! solution for closing server
# If the value of s is set once, and not reinitialized 
# you could make it a class variable as opposed to an instance variable 
# of TestServer, and then have the handler retrieve it via a class method 
# of TestServer in the handler's constructor.

import SocketServer, threading
import logging
import time
import sys

from serverportfolio.GlobalDicts import HOST, PORT, DEBUG_MODE
# dependence could be deleted, only print_dict
from serverportfolio.DictionaryStocks import DictionaryStocks 
from serverportfolio.UpdateStocks import UpdateStocks

# only Yahoo needed ? general parser better ?
#import YahooAPI

## @class MyThreaded_TCPServer_Parser
# @brief The thread Server.
#
# want this server threaded, but not the Handler (SocketServer.ThreadingMixIn)
class MyThreaded_TCPServer_Parser(SocketServer.TCPServer):
    
    _server_running = False
    
    # for efficiency, but NO SECURE ???
    allow_reuse_address = True
    # If we use Threaded Handler, define in class ThreadingMixIn:
    # seems enought if not threading ??
    # daemon_threads = True

    ## @brief Constructor.
    # Constructor, pass the queue to handler, MyHandler_Parser, and add a message
    def __init__(self, server_address, RequestHandlerClass, thq=None, message=''):
        # constructor of the parent, need address and handler 
        SocketServer.TCPServer.__init__(self, server_address, RequestHandlerClass)

        ## @brief Save a link to the queue for interacting (ex:force update)
        # available from the handler as self.server._thq
        self._thq = thq
        
        # get child logger from SP, not a thread
        self.logger = logging.getLogger('SP.TCPServer')
         
        # just a message Welcome to print
        self.message = message
        print "\n"+self.message+"\n"
        
        # keep all for test of logging
        self.logger.info('info %s',self.message)
        #self.logger.error('error %s',self.message)
        
    ## @brief Called by constructor to activate the server.
    # May be overridden.
    #
    # why ? useful ?? 
    def server_activate(self):
        
        ## important line ? not by default ?
        self.socket.listen(self.request_queue_size)
        MyThreaded_TCPServer_Parser._server_running=True
        #self.logger.info("TCP server activated")
        #print "self.request_queue_size ", self.request_queue_size #5 default ??
        #print dir()

## @class MyHandler_Parser
# @brief Make a proper handler class to respond to the message.
#
# Respond to the client to:
#   - empty  : send back RUNNING or NOT RUNNING
#   - GET CAC40 [DJ EURUS ..] : read data in dictstocks, get fast
#   - FORCE CAC40  [DJ .] : force new parsing, longer
#         (works but order of execution inverse ??)
#   - UPDATE_CSV : download missing csv data from yahoo, save to the disk
#   - LAST_CSV_UPDATE : give date ( timestamp ) of the last update
#   - RELOAD : reread dictstocks, needed when a new stock has been added
#   - BYE  : to stop the server, need to look at shutdown() since v2.6
#
#   general, need to optimize, it works but may not so good
#
# The RequestHandler class for our server.\n
#    It is instantiated once per connection to the server\n
#    override the handle() to get correct return\n
class MyHandler_Parser(SocketServer.BaseRequestHandler):
    
    # not printed ?? to check
    # ok printed before handle
    # need access to DictionaryStocks, in init ? or setup ?
    # here working, but called at every request. Can create the object in the handle method
    def setup(self):
        
        # log
        self.logger = logging.getLogger('SP.TCPServerHandler')
        self.logger.debug("MyHandler_Parser in settup")
        
        # originally used, becomes duplicate with update_stocks
        #self.dict_stocks = DictionaryStocks()
        
    # can be created only after the action is known, anyway setup called everytime ??
    
        # certainly different action to perform, fix the parser ?
        # need to create the object, maybe singleton better for a single GET
        #self.update_stock = UpdateStocks()
        # or option no parser associated, when needed set_parser delete old one and create a new one...
        # self.update_stock = UpdateStocks( None )
        
    def handle(self):
        
        # log
        self.logger = logging.getLogger('SP.TCPServerHandler')
        
        #if DEBUG_MODE:
        self.logger.debug("Entry Handler_Parser thq: %s", self.server._thq)
        
        # self.request is the TCP socket connected to the client
        self.data = self.request.recv(1024).strip()
        #print " self.data %s" % self.data
        #self.logger.debug('%s',self.data)
        #print "%s wrote " % self.client_address[0]
        
        # need a list of self.data
        tab_data = self.data.rsplit(' ')
        self.logger.debug("tab_data: %s",tab_data)
        # name to change GET InstValue ListStock (ALL or empty),
        
        method = None
        action = None
        list_stock = None
        
        size = len(tab_data)
        #print "size ", size
        
        if size > 0:
            method = tab_data[0]
        if size > 1:
            action = tab_data[1]
        if size > 2:
            list_stock = tab_data[2:]
        
        self.logger.debug("method %s", method)
        self.logger.debug("action %s", action)
        self.logger.debug("list_stock %s", list_stock)
        
        str_line=''
        
        # Check for action, GET returns the data in memory
        if method == "GET":
            
            # option no parser associated, when needed set_parser delete old one and create a new one...
            # could use DictionaryStock here ...
            self.update_stock = UpdateStocks( action )
            str_line = self.update_stock.get_string_data( list_stock, opt_parse = False )
            str_line=str_line[:-1]
            self.request.send(str_line)
            
        # force the parsing of new data
        elif method == "FORCE":
            
            # option no parser associated, when needed set_parser delete old one and create a new one...
            self.update_stock = UpdateStocks( action )
            str_line=self.update_stock.get_string_data( list_stock, opt_parse = True )
            str_line=str_line[:-1]
            self.request.send(str_line)
            #if DEBUG_MODE :
            #self.logger.debug("SocketSerClient option FORCE")
            #print self.dict_stocks.dictstocks
            
            # if a list of stocks send directly, how to deal with lock ? how to retrieve the answer ?
            # wait for all locks !
            # Normal with autoparser running
            
#  Do not remember what is it, what was the point ? how to retrieve the data, maybe for some long run ?
#  Ok, insert a new Stock in the queue, then updated normally, can get the value by GET
# like an option ADD_TO_QUEUE/ADD_STOCK

#  for run parser certainly ? Yes after creation of a Stock          
            if self.server._thq:
#                 #f DEBUG_MODE :
#                 self.logger.debug("thq insert to the queue ")
                for stock in list_stock:
                # force insertion to the queue, 
#                     # will be locked until answer received
#                     # caller should check for the lock, could be here
                    status = self.server._thq.InsertToQueue( stock, "InstValue")
                    if status:
                        self.logger.info("Inserted to queue %s" % stock)
                    else:
                        self.logger.error("Cannot insert to queue %s" % stock)
                    
            # if standalone, without autoparser, so need to update sequentially
            # should not happen at the end
            #else:
            
            #if DEBUG_MODE :
            #self.logger.debug("thq False in MyHandler_Parser")
            #print "tab_data[1:] ",tab_data[1:]
                     
            # still needed one by one, to modify in Update
            #for stock in tab_data[1:]:
            #    self.dict_stocks.Update( stock )
            #str_line=self.update_stock.get_string_data('InstValue', tab_data[1:])
            
            # todo check this locking system...
            # need to loop for waiting for all stocks...
            # locked by InsertToQueue
            # while self.AllStocksLock( tab_data[1:] ):
            #    pass
            # print "lock is False"
            
            # print new value  
            # str_line = self.dict_stocks.make_print_stocks(tab_data[1:])
            
         
        # add option ADD_STOCKS, REMOVE_STOCKS, RELOAD convenient with web and SQL   
        elif self.data == 'RELOAD':
            #if DEBUG_MODE :
            print 'reload dictstocks'
            
            # need to change, and save filename !!
            # obviously problematic with threads ??
            
            # should be a function relaod in DictionaryStocks
            # with possible a real lock ?? 
            list_new=self.dict_stocks.ReadStocks('dictstocks.txt')
            if DEBUG_MODE :
                print 'list new :', list_new
            self.dict_stocks.make_print_stocks( None, True )
            
            # update list of the queue, if existing
            if self.server.thq:
                for stock in list_new:
                    if self.dict_stocks.CheckOpen(stock):
                        self.server.thq.list_active_stock.append(stock)
                    else:
                        self.server.thq.list_inactive_stock.append(stock)

            if list_new:
                str_line='Reloaded '
                for stock in list_new:
                    str_line+= stock
                    self.request.send("Reloaded")
            else:
                self.request.send("Nothing changed in dict_stocks")
                
        elif tab_data[0] == 'LAST_CSV_UPDATE':
            
            if DEBUG_MODE :
                print " len tab_data ", len(tab_data)
                print " tab_data ", tab_data
                
            #check argument, make better with exception
            if ( len(tab_data) >= 2 ):
                stock = tab_data[1]
            else:
                print "Argument is missing"
                self.request.send("Argument is missing")
                #raise
                return 
                
            #print 'LAST_CSV_UPDATE ', stock #tab_data[1]
            # old version
            # stock_to_update = YahooAPI.YahooCSV ( tab_data[1] )
            # new version with derived class
            # need a call function from DictionaryStocks ?? follow same logic
            
            # why stock to update intermediate ? it is a stock simple job ?
            stock_to_update = YahooAPI.Parser_YahooCSV ( self.dict_stocks, stock ) #tab_data[1] )
            time_t = stock_to_update.LastCSV()
                
            self.request.send(str(time_t))
            del stock_to_update
                
            
        elif tab_data[0] == 'UPDATE_CSV':
            if DEBUG_MODE :
                print 'UPDATE_CSV tab_data ',tab_data

            if ( len(tab_data) >= 2 ):
                stock = tab_data[1]
            else:
                print "Argument is missing"
                self.request.send("Argument is missing")
                #raise
                return
            
            # same need function in DictionaryStocks ?
            stock_to_update = YahooAPI.Parser_YahooCSV ( self.dict_stocks, stock )
            # #necessary ?? if stock is running can keep the value in the object
            # need to not be deleted
            time_t=stock_to_update.LastCSV()
            #print " time_t ", time_t
            retour = stock_to_update.UpdateCSV( time_t )
            
            self.request.send( "Updated ret:"+str(retour) )
            # needed or reused ?
            del stock_to_update
            
        # to add INTRO
        
        # to stop the server
        elif method == 'BYE':
            print "will stop..."
            print "Stop thread_handle_queue first"
                        
            MyThreaded_TCPServer_Parser._server_running = False
            print "threading enumerate"
            # print nothing
            threading.enumerate()
            self.request.send("Stopping Server")
            
        # for testing if server running
        else:
            self.request.send("RUNNING")

    ## @brief check if at least one stock of the list is still locked
    def AllStocksLock( self, list_stock ):

        for stock in list_stock:
            # return True if one is still locked
            if self.dict_stocks.dictstocks[stock]['lock'] == True :
                return True
    
        return False
# To shutdown, need to set _server_running to false

## @brief Function to initialize and run the server.
# Can be called by the main thread ( normal behaviour )\n
# or as a separate thread like in this main
#
# server run until class variable MyThreaded_TCPServer_Parser._server_running is True.
#
# @param host, port hostname and port of the server
# @param thq queue associated
def run_MyServer( host=HOST, port=PORT, thq=None ):

    address_server = ( host, port )
    
    if DEBUG_MODE :
        print "run_MyServer"
        print "address_server ", address_server
     
    thq_for_server = None
    if thq:
        thq_for_server=thq
        
        print "thq_for_server"  
    else:
        print "thq not given"
        
    print "run TCPServer"
    
    ## create server and associate the handle
    # and not, this thread will wait in while loop
    #server = MyThreaded_TCPServer_Parser((host,port), MyHandler_Parser
    #                     ,'Welcome to the MyServer_Portfolio.\n\r')
    server = MyThreaded_TCPServer_Parser(address_server, MyHandler_Parser
                                 , thq_for_server, 'Welcome to Server_Portfolio.' )

    # by this way control the exit, _server_running accessible by MyHandler (and everywhere in fact)
    while MyThreaded_TCPServer_Parser._server_running:
        server.handle_request()

# #### main to test, not very good 
if __name__ == "__main__":

    print "Version main of SocketServer, autoparser not running"
    
    logging.basicConfig(level=logging.DEBUG)
    logger = logging.getLogger('SP')
    main_logger = logging.getLogger("SP.main")
    
    ## not needed, may be useful for debugging if already one running
    # just need to change here, default from Global
    host = HOST
    port = PORT
    print "host, port ", host,port
    address = ( host, port )

    # Load DictStcoks, alias not used later
    dict_stocks = DictionaryStocks( load_all_stocks=True )

    # No option update all the dictionary
    #dict_stocks.Update()

    ##liststocks=(list_stocks,list_stocks_open)
    start=time.time()
    
    # wait time update done
    #time.sleep(10)
    
    # without thread, main thread will be waiting in server loop
    #run_MyServer(address)
    
    # here run as a thread, to continue printing information
    # by Server_Portfolio not needed, will be the MainThread
    server_thread = threading.Thread(target=run_MyServer, name="t-server",
                                     args=(host,port) )
    # If True, exit the server thread when the main thread terminates
    # Here default (False) 
    server_thread.setDaemon(False)
    print "start server_thread "
    server_thread.start()

    print "Elapsed Time: %s" % (time.time() - start)

    # do not exit, not working
    while (time.time()-start) < 2:
        pass

    print " enumerate ", threading.enumerate()
    print " time passed..."
    print " server running ", MyThreaded_TCPServer_Parser._server_running
    
    print "\nServer loop running in thread:", server_thread.name