Source Code for Module ioids.dbconnector

  1  """ 
  2  Connect against database backend. 
  3   
  4  Inter-Organisational Intrusion Detection System (IOIDS) 
  5   
  6  Yes, we could put something very sophisticated here in order to allow integration with 
  7  a variety of datbases; however, for reasons of simplicity I decided to just put the code  
  8  for connecting against the XML RPC database here. 
  9   
 10  @author: Michael Pilgermann 
 11  @contact: mailto:mpilgerm@glam.ac.uk 
 12  @license: GPL (General Public License) 
 13  """ 
 14   
 15  from soapsytools.dbconnector import * 
 16  import soapsytools.dbconnector 
 17   
 18  # constant for database type 
 19  DB_CONNECTION_TYPE_XML_RPC = 'xmlrpc' 
 20   
 21  # "singleton" 
 22  _dbConnector = None 
 23 -def getDBConnector(): 
 24      """ 
 25      Singleton implementation. 
 26      """ 
 27      global _dbConnector 
 28      if not _dbConnector: 
 29          _dbConnector = IoidsDBConnector() 
 30      return _dbConnector 
 31   
 32 -class IoidsDBConnector(soapsytools.dbconnector.DBConnector): 
 33      """ 
 34      Standard DB connector - work on XML RPC database. 
 35      """ 
 36   
 37 -    def __init__(self): 
 38          """ 
 39          Sets the parameters for the later db connections. 
 40           
 41          Most of the settings are taken from the global config file. 
 42          """ 
 43          from config import DATABASE_CONNECTION_TYPE, SOAP_SERVER_URL 
 44          from errorhandling import IoidsException 
 45               
 46          if DATABASE_CONNECTION_TYPE !=DB_CONNECTION_TYPE_XML_RPC: 
 47              raise IoidsException('The database type defined in the config file is not supported by IOIDS') 
 48               
 49          soapsytools.dbconnector.DBConnector.__init__(self, SOAP_SERVER_URL) 
 50                   
 51 -    def getIoidsEvents(self, conditions = []): 
 52          """ 
 53          Collects available ioids events from the database. 
 54           
 55          The result is returned in a format mixed by lists and dictionaries. 
 56          """ 
 57          from messagewrapper import getXMLDBWrapper 
 58          xml = getXMLDBWrapper().wrapSelect('ioids_event', 'all', conditions) 
 59          result = self._performRequest(xml) 
 60          no, resolved = getXMLDBWrapper().parseSelectReply(result) 
 61          return resolved 
 62           
 63 -    def getIoidsEventsFromEventID(self, minIoidsEventId): 
 64          """ 
 65          Returns all ioids events with ioids event id greater then the given one. 
 66          """ 
 67          return self.getIoidsEvents([['ioids_event_id', OPERATOR_GREATER_THEN_OR_EQUAL, str(minIoidsEventId)]]) 
 68           
 69           
 70  ##    def insertIoidsEvent(self, eventDict, relations = []): 
 71 -    def insertIoidsEvent(self, ioidsEventEntryList): 
 72          """ 
 73          Insert a new IOIDS event. 
 74           
 75          @return: The primary key of the new event 
 76          @rtype: C{String} 
 77          """ 
 78          from messagewrapper import getXMLDBWrapper 
 79  ##        xml = getXMLDBWrapper().wrapInsert('ioids_event', eventDict, relations) 
 80          xml = getXMLDBWrapper().wrapInsert(ioidsEventEntryList[0], ioidsEventEntryList[1], ioidsEventEntryList[2]) 
 81           
 82  ##        print xml 
 83          result = self._performRequest(xml) 
 84  ##        print result 
 85          decode = getXMLDBWrapper().parseInsertReply(result) 
 86  ##        print "Result - primary key: %s " %(decode[0][2]) 
 87          return decode[0][2][1:len(decode[0][2])-1] 
 88           
 89 -    def insertFullIoidsEventWithRelation(self, fullIoidsEvent): 
 90          """ 
 91          Insert a new ioids event with its relation to further events. 
 92   
 93          @return: The primary key of the new relation entry 
 94          @rtype: C{String} 
 95          """ 
 96          from messagewrapper import getXMLDBWrapper 
 97          xml = getXMLDBWrapper().wrapInsert(fullIoidsEvent[0], fullIoidsEvent[1], fullIoidsEvent[2]) 
 98          result = self._performRequest(xml) 
 99           
100          decode = getXMLDBWrapper().parseInsertReply(result) 
101  ##        print "Result - primary key: %s " %(decode[0][2]) 
102          return decode[0][2][1:len(decode[0][2])-1] 
103           
104           
105      ## 
106      ## Functions for getting all the details of events 
107      ##         
108 -    def getIoidsClassification(self, classification_id, full = 1): 
109          from dataengine_tools import getPreXMLDictCreator 
110          myEntry = self._getSomething('ioids_classification', 'classification_id', classification_id) 
111          return getPreXMLDictCreator().createIoidsClassificationEntry(myEntry) 
112   
113 -    def getIoidsClassificationByCode(self, classification_code, full = 1): 
114          from dataengine_tools import getPreXMLDictCreator 
115          myEntry = self._getSomething('ioids_classification', 'classification_code', classification_code) 
116          return getPreXMLDictCreator().createIoidsClassificationEntry(myEntry) 
117       
118 -    def getIoidsPeer(self, peerId, full = 1): 
119          from dataengine_tools import getPreXMLDictCreator 
120          myEntry = self._getSomething('ioids_peer', 'ioids_peer_id', peerId) 
121          return getPreXMLDictCreator().createIoidsPeerEntry(myEntry) 
122   
123 -    def getIoidsSender(self, senderId, full = 1): 
124          from dataengine_tools import getPreXMLDictCreator 
125          myEntry = self._getSomething('ioids_sender', 'ioids_sender_id', senderId) 
126          peer = None 
127          if full: 
128              if myEntry['ioids_peer_id'] != 'None': 
129                  peer = self.getIoidsPeer(myEntry['ioids_peer_id']) 
130          return getPreXMLDictCreator().createIoidsSenderEntry(myEntry, peer) 
131           
132 -    def getIoidsSource(self, sourceId, full = 1): 
133          from dataengine_tools import getPreXMLDictCreator 
134          myEntry = self._getSomething('ioids_source', 'ioids_source_id', sourceId) 
135          peer = None 
136          if full: 
137              if myEntry['ioids_peer_id'] != 'None': 
138                  peer = self.getIoidsPeer(myEntry['ioids_peer_id']) 
139          return getPreXMLDictCreator().createIoidsSourceEntry(myEntry, peer) 
140       
141 -    def getIoidsEvent(self, ioids_event_id, full = 1): 
142          from dataengine_tools import getPreXMLDictCreator 
143          myEntry = self._getSomething('ioids_event', 'ioids_event_id', ioids_event_id) 
144   
145          event = None 
146          sender = None 
147          source = None 
148          classification = None 
149          if full: 
150              if myEntry['event_id'] != 'None': 
151                  event = self.getEvent(myEntry['event_id'],1) 
152              if myEntry['ioids_sender_id'] != 'None': 
153                  sender = self.getIoidsSender(myEntry['ioids_sender_id'],1) 
154              if myEntry['ioids_source_id'] != 'None': 
155                  source = self.getIoidsSource(myEntry['ioids_source_id'],1) 
156              if myEntry['classification_id'] != 'None': 
157                  classification = self.getIoidsClassification(myEntry['classification_id'],1) 
158               
159          return getPreXMLDictCreator().createIoidsEventEntry(myEntry, event, sender, source, classification) 
160       
161 -    def getIoidsRelationType(self, relation_type_id, full = 1): 
162          from dataengine_tools import getPreXMLDictCreator 
163          myEntry = self._getSomething('ioids_relation_type', 'ioids_relation_type_id', relation_type_id) 
164          return getPreXMLDictCreator().createIoidsRelationTypeEntry(myEntry) 
165       
166   
167 -    def getIoidsRelation(self, relationId, full =1): 
168          from dataengine_tools import getPreXMLDictCreator 
169          myEntry = self._getSomething('ioids_relation', 'ioids_relation_id', relationId) 
170           
171          event = None 
172          ioids_event = None 
173          relationType = None 
174          if full: 
175              if myEntry['event_id'] != 'None': 
176                  event = self.getEvent(myEntry['event_id'],1) 
177              if myEntry['ioids_event_id'] != 'None': 
178                  ioids_event = self.getIoidsEvent(myEntry['ioids_event_id'],1) 
179              if myEntry['ioids_relation_type_id'] != 'None': 
180                  relationType = self.getEvent(myEntry['ioids_relation_type_id'],1) 
181               
182          return getPreXMLDictCreator().createIoidsRelationEntry(myEntry, event, ioids_event, relationType) 
183           
184 -    def getRelatedEventsForIoidsEvent(self, ioidsEventId, full = 1): 
185           
186          from messagewrapper import getXMLDBWrapper 
187          xml = getXMLDBWrapper().wrapSelect('ioids_relation', 'event_id', [['ioids_event_id', OPERATOR_EQUAL, str(ioidsEventId)]]) 
188          result = self._performRequest(xml) 
189          #print "\n>\n%s\n<\n" %result 
190          no, resolved = getXMLDBWrapper().parseSelectReply(result) 
191   
192          from dataengine_tools import getPreXMLDictCreator 
193           
194          relations = [] 
195          items = resolved[0]['relations'] 
196          for item in items: 
197              aRelation = getPreXMLDictCreator().restructureEntry(item['attributes'], 'relation') 
198              relations.append(aRelation) 
199           
200          for rel in relations: 
201              oneEvent = self.getEvent(rel[1] ['event_id']) 
202              rel[2].append(oneEvent) 
203              del rel[1]['event_id'] 
204              oneRelType = self.getIoidsRelationType(rel[1]['ioids_relation_type_id']) 
205              rel[2].append(oneRelType) 
206              del rel[1]['ioids_relation_type_id'] 
207          return relations 
208           
209 -    def getExtensionForEvent(self, event): 
210          """ 
211          Retrieves extension information from the database for an event. 
212           
213          @param event: Event in List / Dict format. 
214          @return: Name of the Extension / Extension in List / Dict format (including event). 
215          """ 
216  ##        type = self.getEventType(event[1]['event_type_id']) 
217  ##        typeName = type[1]['event_type_name'] 
218          from messagewrapper import getIoidsMessageWrapper 
219          typeName  =getIoidsMessageWrapper()._getValueInTree(event, ['event_type', 'event_type_name']) 
220           
221          eventid = self.insertEvent(event)       # it's not really an insert - but it's the only way I see to find the prim key 
222          extension = getDBExtensionHandler().getExtensionInformationForEventId(typeName, eventid) 
223           
224  ##        print "Echo - extension - i got: %s: %s" %(typeName, extension) 
225           
226          return typeName, extension 
227           
228 -    def insertExtensionEvent(self, extensionName, data): 
229          return getDBExtensionHandler().insertExtensionEvent(extensionName, data) 
230   
231           
232  # "singleton" 
233  _dbExtensionHandler = None 
234 -def getDBExtensionHandler(): 
235      """ 
236      Singleton implementation. 
237      """ 
238      global _dbExtensionHandler 
239      if not _dbExtensionHandler: 
240          _dbExtensionHandler = DBExtensionHandler() 
241      return _dbExtensionHandler 
242           
243 -class DBExtensionHandler: 
244      """ 
245      Provides access to information from several SoapSy extensions. 
246      """ 
247       
248 -    def __init__(self): 
249          """ 
250          Yet empty constructor. 
251          """ 
252          from config import SOAPSY_EXTENSIONS 
253          self._extensions = SOAPSY_EXTENSIONS 
254           
255 -    def getExtensionInformationForEventId(self, extensionName, eventId): 
256          if not self._extensions.has_key(extensionName): 
257              return None 
258               
259          ext_db = self._extensions[extensionName]['dbconnector'] 
260          return ext_db().getExtensionEvent(eventId) 
261           
262 -    def insertExtensionEvent(self, extensionName, data): 
263          """ 
264          @return: The primary key value of the top level table of the insert action. 
265          """ 
266          if not self._extensions.has_key(extensionName): 
267              raise ValueError('Extension unknown on this node: %s' %(extensionName)) 
268   
269          ext_db = self._extensions[extensionName]['dbconnector'] 
270          return ext_db().insertExtensionEvent(data) 
271