Revision 1292
Added by Jing Tao over 21 years ago
ReplicationHandler.java | ||
---|---|---|
56 | 56 |
{ |
57 | 57 |
int serverCheckCode = 1; |
58 | 58 |
MetaCatUtil util = new MetaCatUtil(); |
59 |
Hashtable serverList = new Hashtable(); |
|
60 |
//Connection conn; |
|
59 |
ReplicationServerList serverList = null; |
|
61 | 60 |
PrintWriter out; |
62 | 61 |
|
63 | 62 |
public ReplicationHandler(PrintWriter o) |
64 | 63 |
{ |
65 | 64 |
this.out = o; |
65 |
serverList = new ReplicationServerList(); |
|
66 | 66 |
} |
67 | 67 |
|
68 | 68 |
public ReplicationHandler(PrintWriter o, int serverCheckCode) |
69 | 69 |
{ |
70 | 70 |
this.out = o; |
71 | 71 |
this.serverCheckCode = serverCheckCode; |
72 |
serverList = new ReplicationServerList(); |
|
72 | 73 |
} |
73 | 74 |
|
74 | 75 |
/** |
... | ... | |
82 | 83 |
//xml_documents with an update_date > last_checked |
83 | 84 |
try |
84 | 85 |
{ |
85 |
//try |
|
86 |
//{ //this connection is prone to error for some reason so we |
|
87 |
//try to connect it three times before quiting. |
|
88 |
//conn = util.openDBConnection(); |
|
89 |
//} |
|
90 |
//catch(SQLException sqle) |
|
91 |
//{ |
|
92 |
/*try |
|
93 |
{ |
|
94 |
conn = util.openDBConnection(); |
|
95 |
} |
|
96 |
catch(SQLException sqlee) |
|
97 |
{ |
|
98 |
try |
|
99 |
{ |
|
100 |
conn = util.openDBConnection(); |
|
101 |
} |
|
102 |
catch(SQLException sqleee) |
|
103 |
{*/ |
|
104 |
//System.out.println("error getting db connection in " + |
|
105 |
//"ReplicationHandler.run: " + |
|
106 |
//sqle.getMessage()); |
|
107 |
//} |
|
108 |
//} |
|
109 |
//} |
|
110 |
serverList = buildServerList(); |
|
111 | 86 |
//if serverList is null, metacat don't need to replication |
112 | 87 |
if (serverList==null||serverList.isEmpty()) |
113 | 88 |
{ |
114 | 89 |
return; |
115 | 90 |
} |
116 |
updateCatalog(serverList);
|
|
117 |
update(serverList);
|
|
91 |
updateCatalog(); |
|
92 |
update(); |
|
118 | 93 |
//conn.close(); |
119 | 94 |
}//try |
120 | 95 |
catch (Exception e) |
121 | 96 |
{ |
122 | 97 |
MetaCatUtil.debugMessage("Error in replicationHandler.run():" |
123 | 98 |
+e.getMessage(), 30); |
99 |
e.printStackTrace(); |
|
124 | 100 |
}//catch |
125 | 101 |
} |
126 | 102 |
|
127 | 103 |
/** |
128 | 104 |
* Method that uses revision taging for replication instead of update_date. |
129 | 105 |
*/ |
130 |
private void update(Hashtable serverList)
|
|
106 |
private void update() |
|
131 | 107 |
{ |
132 | 108 |
/* |
133 | 109 |
Pseudo-algorithm |
... | ... | |
145 | 121 |
|
146 | 122 |
DBConnection dbConn = null; |
147 | 123 |
int serialNumber = -1; |
148 |
/*try |
|
149 |
{ |
|
150 |
conn = util.getConnection(); |
|
151 |
} |
|
152 |
catch (Exception e) |
|
153 |
{ |
|
154 |
util.debugMessage("There is problem to get conncetion: "+e.getMessage()); |
|
155 |
}*/ |
|
156 |
|
|
157 |
Enumeration keys; |
|
158 |
String server; |
|
124 |
|
|
125 |
ReplicationServer replServer = null; // Variable to store the |
|
126 |
// ReplicationServer got from |
|
127 |
// Server list |
|
128 |
String server; // Variable to store server name |
|
159 | 129 |
String update; |
160 | 130 |
ReplMessageHandler message = new ReplMessageHandler(); |
161 | 131 |
Vector responses = new Vector(); |
162 | 132 |
PreparedStatement pstmt = null; |
163 | 133 |
ResultSet rs; |
164 | 134 |
boolean tablehasrows; |
165 |
boolean flag=false; |
|
135 |
boolean flag=false; // If a document need to update
|
|
166 | 136 |
boolean dataFile=false; |
167 | 137 |
String action = new String(); |
168 | 138 |
XMLReader parser; |
... | ... | |
170 | 140 |
|
171 | 141 |
try |
172 | 142 |
{ |
143 |
// Get DBConnection from pool |
|
173 | 144 |
dbConn=DBConnectionPool. |
174 | 145 |
getDBConnection("ReplicationHandler.update"); |
175 | 146 |
serialNumber=dbConn.getCheckOutSerialNumber(); |
176 |
MetaCatUtil.debugMessage("init parser"); |
|
147 |
MetaCatUtil.debugMessage("init parser", 50);
|
|
177 | 148 |
parser = initParser(message); |
178 |
keys = serverList.keys();
|
|
179 |
while(keys.hasMoreElements())
|
|
149 |
//Check for every server in server list
|
|
150 |
for (int i=0; i<serverList.size(); i++)
|
|
180 | 151 |
{ |
181 |
server = (String)(keys.nextElement()); |
|
152 |
// Get ReplicationServer object from server list |
|
153 |
replServer = serverList.serverAt(i); |
|
154 |
// Get server name from ReplicationServer object |
|
155 |
server = replServer.getServerName(); |
|
182 | 156 |
MetacatReplication.replLog("full update started to: " + server); |
157 |
// Send command to that server to get updated docid information |
|
183 | 158 |
u = new URL("https://" + server + "?server=" |
184 | 159 |
+util.getLocalReplicationServerName()+"&action=update"); |
185 |
//System.out.println("Sending Message: " + u.toString()); |
|
186 |
String result = MetacatReplication.getURLContent(u); |
|
187 |
//check if result have error or not |
|
160 |
MetaCatUtil.debugMessage("Sending infomation " +u.toString(), 50); |
|
161 |
// Get information from remote server |
|
162 |
String result = null; |
|
163 |
try |
|
164 |
{ |
|
165 |
result = MetacatReplication.getURLContent(u); |
|
166 |
}//try |
|
167 |
catch (Exception e) |
|
168 |
{ |
|
169 |
|
|
170 |
MetaCatUtil.debugMessage("Error in get docid information from "+ |
|
171 |
server+" :"+e.getMessage(), 30); |
|
172 |
continue; |
|
173 |
}//catch |
|
174 |
MetaCatUtil.debugMessage("docid: "+server+" "+result, 50); |
|
175 |
//check if result have error or not, if has skip it. |
|
188 | 176 |
if (result.indexOf("error")!=-1) |
189 | 177 |
{ |
190 | 178 |
continue; |
... | ... | |
193 | 181 |
} |
194 | 182 |
|
195 | 183 |
//make sure that there is updated file list |
196 |
//If response is null, mecat don't need do anything |
|
184 |
//If response is null, metacat don't need do anything
|
|
197 | 185 |
if (responses==null||responses.isEmpty()) |
198 | 186 |
{ |
199 | 187 |
return; |
200 | 188 |
} |
189 |
|
|
201 | 190 |
|
202 |
//String srvr = util.getOption("servletpath"); |
|
191 |
MetaCatUtil.debugMessage("Responses from remote metacat about updated "+ |
|
192 |
"document information: "+ responses.toString(), 30); |
|
203 | 193 |
|
204 |
//System.out.println("responses (from srvr): " + responses.toString()); |
|
205 |
|
|
206 | 194 |
for(int i=0; i<responses.size(); i++) |
207 | 195 |
{ //check each server for updated files |
208 |
//System.out.println("parsing responses"); |
|
209 | 196 |
parser.parse(new InputSource( |
210 | 197 |
new StringReader( |
211 | 198 |
(String)(responses.elementAt(i))))); |
... | ... | |
215 | 202 |
//d is the list of deleted documents |
216 | 203 |
Vector d = new Vector(message.getDeletesVect()); |
217 | 204 |
//System.out.println("d: " + d.toString()); |
205 |
MetaCatUtil.debugMessage("Update vector size: "+ v.size(), 40); |
|
206 |
MetaCatUtil.debugMessage("Delete vector size: "+ d.size(),40); |
|
218 | 207 |
//check the revs in u to see if there are any newer ones than |
219 | 208 |
//in the local DB. |
220 |
MetaCatUtil.debugMessage("Update vector size: "+ v.size(), 20); |
|
221 |
MetaCatUtil.debugMessage("Delete vector size: "+ d.size(),20); |
|
222 | 209 |
for(int j=0; j<v.size(); j++) |
223 | 210 |
{ |
224 | 211 |
//initial dataFile is false |
... | ... | |
233 | 220 |
dataFile=true; |
234 | 221 |
} |
235 | 222 |
//System.out.println("w: " + w.toString()); |
223 |
// Get docid |
|
236 | 224 |
String docid = (String)w.elementAt(0); |
237 | 225 |
MetaCatUtil.debugMessage("docid: " + docid, 40); |
226 |
// Get revision number |
|
238 | 227 |
int rev = Integer.parseInt((String)w.elementAt(1)); |
239 | 228 |
MetaCatUtil.debugMessage("rev: " + rev, 40); |
240 |
String docServer = (String)w.elementAt(2); |
|
229 |
// Get remote server name (it is may not be doc homeserver because |
|
230 |
// the new hub feature |
|
231 |
String remoteServer = (String)w.elementAt(2); |
|
241 | 232 |
|
242 |
|
|
243 |
pstmt = dbConn.prepareStatement("select rev from xml_documents where "+
|
|
244 |
"docid like '" + docid + "'"); |
|
233 |
// Choose revision number from local host |
|
234 |
pstmt = dbConn.prepareStatement("select rev from xml_documents where "
|
|
235 |
+ "docid like '" + docid + "'");
|
|
245 | 236 |
pstmt.execute(); |
246 | 237 |
rs = pstmt.getResultSet(); |
247 | 238 |
tablehasrows = rs.next(); |
248 | 239 |
if(tablehasrows) |
249 | 240 |
{ //check the revs for an update because this document is in the |
250 |
//local DB, it just might be out of date.
|
|
241 |
//local DB, it might be out of date. |
|
251 | 242 |
int localrev = rs.getInt(1); |
252 | 243 |
if(localrev == rev) |
253 | 244 |
{ |
245 |
// Local meatacat has the same rev to remote host, don't need |
|
246 |
// update and flag set false |
|
254 | 247 |
flag = false; |
255 | 248 |
} |
256 | 249 |
else if(localrev < rev) |
... | ... | |
265 | 258 |
flag = true; |
266 | 259 |
} |
267 | 260 |
|
261 |
// Close result set |
|
262 |
rs.close(); |
|
263 |
// Close preparedstatement |
|
264 |
pstmt.close(); |
|
265 |
|
|
268 | 266 |
// this is non-data file |
269 | 267 |
if(flag && !dataFile) |
270 | 268 |
{ //if the document needs to be updated or inserted, this is executed |
271 |
u = new URL("https://" + docServer + "?server="+
|
|
269 |
u = new URL("https://" + remoteServer + "?server="+
|
|
272 | 270 |
util.getLocalReplicationServerName()+"&action=read&docid="+docid); |
273 | 271 |
//System.out.println("Sending message: " + u.toString()); |
272 |
// Get docid content |
|
274 | 273 |
String newxmldoc = MetacatReplication.getURLContent(u); |
274 |
// If couldn't get skip it |
|
275 | 275 |
if ( newxmldoc.indexOf("error")!= -1) |
276 | 276 |
{ |
277 | 277 |
continue; |
278 | 278 |
} |
279 | 279 |
MetaCatUtil.debugMessage("xml documnet:", 50); |
280 | 280 |
MetaCatUtil.debugMessage(newxmldoc, 50); |
281 |
|
|
282 |
// Try get the docid info from remote server |
|
281 | 283 |
DocInfoHandler dih = new DocInfoHandler(); |
282 | 284 |
XMLReader docinfoParser = initParser(dih); |
283 |
URL docinfoUrl = new URL("https://" + docServer +
|
|
285 |
URL docinfoUrl = new URL("https://" + remoteServer +
|
|
284 | 286 |
"?server="+util.getLocalReplicationServerName()+ |
285 | 287 |
"&action=getdocumentinfo&docid="+docid); |
286 |
//System.out.println("Sending message: " + docinfoUrl.toString()); |
|
288 |
MetaCatUtil.debugMessage("Sending message: " + |
|
289 |
docinfoUrl.toString(), 50); |
|
287 | 290 |
String docInfoStr = MetacatReplication.getURLContent(docinfoUrl); |
288 | 291 |
docinfoParser.parse(new InputSource(new StringReader(docInfoStr))); |
289 | 292 |
Hashtable docinfoHash = dih.getDocInfo(); |
293 |
// Get home server of the docid |
|
290 | 294 |
String docHomeServer = (String)docinfoHash.get("home_server"); |
291 |
//int serverCode = MetacatReplication.getServerCode(docServer); |
|
292 |
//System.out.println("updating doc: " + docid +" action: "+ action); |
|
295 |
|
|
293 | 296 |
//docid should include rev number too |
294 | 297 |
String accnum=docid+util.getOption("accNumSeparator")+ |
295 | 298 |
(String)docinfoHash.get("rev"); |
296 |
//System.out.println("accnum: "+accnum); |
|
297 | 299 |
try |
298 | 300 |
{ |
299 |
|
|
301 |
// Write the document into local host |
|
300 | 302 |
String newDocid = DocumentImpl.writeReplication(dbConn, |
301 | 303 |
new StringReader(newxmldoc), |
302 | 304 |
(String)docinfoHash.get("public_access"), |
... | ... | |
306 | 308 |
(String)docinfoHash.get("user_owner"), |
307 | 309 |
null, /* null for groups[] */ |
308 | 310 |
docHomeServer, |
309 |
false /* validate */); |
|
311 |
false /* validate */, |
|
312 |
remoteServer); |
|
310 | 313 |
//increase usage |
311 | 314 |
dbConn.increaseUsageCount(1); |
312 | 315 |
MetacatReplication.replLog("wrote doc " + docid + " from " + |
313 |
docServer);
|
|
316 |
remoteServer);
|
|
314 | 317 |
/*System.out.println("wrote doc " + docid + " from " + |
315 | 318 |
docServer);*/ |
316 | 319 |
} |
... | ... | |
322 | 325 |
} |
323 | 326 |
}//if for non-data file |
324 | 327 |
|
325 |
// this is for data file and metacat is configured to accetp datafile |
|
326 |
if(flag && dataFile |
|
327 |
&& (util.getOption("replicationacceptdata")).equals("on")) |
|
328 |
// this is for data file |
|
329 |
if(flag && dataFile) |
|
328 | 330 |
{ |
329 | 331 |
//if the document needs to be updated or inserted, this is executed |
330 |
//String newxmldoc = MetacatReplication.getURLContent(u); |
|
332 |
|
|
333 |
// Try get docid info from remote server |
|
331 | 334 |
DocInfoHandler dih = new DocInfoHandler(); |
332 | 335 |
XMLReader docinfoParser = initParser(dih); |
333 |
URL docinfoUrl = new URL("https://" + docServer +
|
|
336 |
URL docinfoUrl = new URL("https://" + remoteServer +
|
|
334 | 337 |
"?server="+util.getLocalReplicationServerName()+ |
335 | 338 |
"&action=getdocumentinfo&docid="+docid); |
336 |
//System.out.println("Sending message: " + docinfoUrl.toString()); |
|
339 |
|
|
337 | 340 |
String docInfoStr = MetacatReplication.getURLContent(docinfoUrl); |
338 | 341 |
docinfoParser.parse(new InputSource(new StringReader(docInfoStr))); |
339 | 342 |
Hashtable docinfoHash = dih.getDocInfo(); |
343 |
// Get doicd owner |
|
340 | 344 |
String user = (String)docinfoHash.get("user_owner"); |
345 |
// Get docid name (such as acl or dataset) |
|
341 | 346 |
String docName = (String)docinfoHash.get("docname"); |
347 |
// Get doc type (eml public id) |
|
342 | 348 |
String docType = (String)docinfoHash.get("doctype"); |
349 |
// Get docid home sever. it might be different to remoteserver |
|
350 |
// becuause of hub feature |
|
343 | 351 |
String docHomeServer = (String)docinfoHash.get("home_server"); |
344 |
|
|
345 |
//int serverCode = MetacatReplication.getServerCode(docServer); |
|
352 |
|
|
346 | 353 |
//System.out.println("updating doc: " + docid +" action: "+ action); |
347 | 354 |
//docid should include rev number too |
348 | 355 |
String accnum=docid+util.getOption("accNumSeparator")+ |
349 | 356 |
(String)docinfoHash.get("rev"); |
350 | 357 |
String datafilePath = util.getOption("datafilepath"); |
351 |
u = new URL("https://" + docServer + "?server="+ |
|
358 |
// Get data file content |
|
359 |
u = new URL("https://" + remoteServer + "?server="+ |
|
352 | 360 |
util.getLocalReplicationServerName()+ |
353 | 361 |
"&action=readdata&docid="+accnum); |
354 |
//System.out.println("accnum: "+accnum); |
|
362 |
|
|
355 | 363 |
try |
356 | 364 |
{ |
357 |
|
|
358 | 365 |
//register data file into xml_documents table and wite data file |
359 | 366 |
//into file system |
360 | 367 |
if (u.openStream() != null) |
361 | 368 |
{ |
362 |
DocumentImpl.writeDataFile(u.openStream(), datafilePath, |
|
363 |
docName,docType, accnum, user,docHomeServer); |
|
369 |
DocumentImpl.writeDataFileInReplication(u.openStream(), |
|
370 |
datafilePath, |
|
371 |
docName,docType, |
|
372 |
accnum, user, |
|
373 |
docHomeServer, |
|
374 |
remoteServer); |
|
364 | 375 |
|
365 |
MetacatReplication.replLog("wrote doc " + docid + " from " + |
|
366 |
docServer);
|
|
367 |
} |
|
376 |
MetacatReplication.replLog("wrote doc " + docid + " from " +
|
|
377 |
remoteServer);
|
|
378 |
}//if
|
|
368 | 379 |
else |
369 | 380 |
{ |
381 |
// If get null, skip it |
|
370 | 382 |
continue; |
371 |
} |
|
372 |
/*System.out.println("wrote doc " + docid + " from " + |
|
373 |
docServer);*/ |
|
374 |
} |
|
383 |
}//else |
|
384 |
|
|
385 |
}//try |
|
375 | 386 |
catch(Exception e) |
376 | 387 |
{ |
377 | 388 |
System.out.println("error writing document in " + |
378 | 389 |
"ReplicationHandler.update: " + docid + |
379 | 390 |
": " + e.getMessage()); |
380 |
} |
|
391 |
}//catch
|
|
381 | 392 |
}//for datafile |
382 | 393 |
}//for update docs |
383 | 394 |
|
... | ... | |
397 | 408 |
MetacatReplication.replLog("doc " + docid + " deleted"); |
398 | 409 |
} |
399 | 410 |
}//for delete docs |
400 |
|
|
401 |
//updated last_checked |
|
402 |
keys = serverList.keys(); |
|
403 |
while(keys.hasMoreElements()) |
|
404 |
{ |
|
405 |
server = (String)(keys.nextElement()); |
|
411 |
}//for |
|
412 |
|
|
413 |
//updated last_checked |
|
414 |
for (int i=0;i<serverList.size(); i++) |
|
415 |
{ |
|
416 |
// Get ReplicationServer object from server list |
|
417 |
replServer = serverList.serverAt(i); |
|
418 |
// Get server name from ReplicationServer object |
|
419 |
server = replServer.getServerName(); |
|
420 |
// Get time from remote server |
|
406 | 421 |
URL dateurl = new URL("https://" + server + "?server="+ |
407 | 422 |
util.getLocalReplicationServerName()+"&action=gettime"); |
408 | 423 |
String datexml = MetacatReplication.getURLContent(dateurl); |
... | ... | |
421 | 436 |
dbConn.increaseUsageCount(1); |
422 | 437 |
pstmt.executeUpdate(); |
423 | 438 |
dbConn.commit(); |
424 |
System.out.println("last_checked updated to " + datestr + " on " + |
|
425 |
server); |
|
426 |
} |
|
427 |
}//wile |
|
439 |
MetaCatUtil.debugMessage("last_checked updated to "+datestr+" on " |
|
440 |
+ server, 45); |
|
441 |
}//if |
|
428 | 442 |
}//for |
429 | 443 |
}//try |
430 | 444 |
catch(Exception e) |
... | ... | |
437 | 451 |
{ |
438 | 452 |
try |
439 | 453 |
{ |
440 |
pstmt.close(); |
|
454 |
|
|
455 |
pstmt.close(); |
|
456 |
|
|
441 | 457 |
}//try |
442 | 458 |
catch(Exception ee) |
443 | 459 |
{ |
... | ... | |
454 | 470 |
/** |
455 | 471 |
* updates xml_catalog with entries from other servers. |
456 | 472 |
*/ |
457 |
private void updateCatalog(Hashtable serverList)
|
|
473 |
private void updateCatalog() |
|
458 | 474 |
{ |
475 |
// DConnection |
|
459 | 476 |
DBConnection dbConn = null; |
477 |
// DBConnection checkout serial number |
|
460 | 478 |
int serialNumber = -1; |
479 |
// ReplicationServer object in server list |
|
480 |
ReplicationServer replServer = null; |
|
461 | 481 |
PreparedStatement pstmt = null; |
462 | 482 |
try |
463 | 483 |
{ |
464 |
/*try |
|
465 |
{ |
|
466 |
conn = util.openDBConnection(); |
|
467 |
} |
|
468 |
catch(SQLException sqle) |
|
469 |
{ |
|
470 |
try |
|
471 |
{ |
|
472 |
conn = util.openDBConnection(); |
|
473 |
} |
|
474 |
catch(SQLException sqlee) |
|
475 |
{ |
|
476 |
try |
|
477 |
{ |
|
478 |
conn = util.openDBConnection(); |
|
479 |
} |
|
480 |
catch(SQLException sqleee) |
|
481 |
{ |
|
482 |
System.out.println("error getting db connection in " + |
|
483 |
"ReplicationHandler.update: " + |
|
484 |
sqleee.getMessage()); |
|
485 |
} |
|
486 |
} |
|
487 |
}*/ |
|
488 |
|
|
484 |
|
|
489 | 485 |
dbConn=DBConnectionPool. |
490 | 486 |
getDBConnection("ReplicationHandler.updateCatalog"); |
491 | 487 |
serialNumber=dbConn.getCheckOutSerialNumber(); |
492 | 488 |
String server; |
493 |
Enumeration keys = serverList.keys(); |
|
494 |
while(keys.hasMoreElements()) |
|
495 |
{ //go through each server |
|
496 |
server = (String)(keys.nextElement()); |
|
489 |
|
|
490 |
// Go through each ReplicationServer object in sererlist |
|
491 |
for (int j=0; j<serverList.size(); j++) |
|
492 |
{ |
|
493 |
// Get ReplicationServer object from server list |
|
494 |
replServer = serverList.serverAt(j); |
|
495 |
// Get server name from the ReplicationServer object |
|
496 |
server = replServer.getServerName(); |
|
497 |
// Try to get catalog |
|
497 | 498 |
URL u = new URL("https://" + server + "?server="+ |
498 | 499 |
util.getLocalReplicationServerName()+"&action=getcatalog"); |
499 |
//System.out.println("sending message " + u.toString());
|
|
500 |
MetaCatUtil.debugMessage("sending message " + u.toString(), 50);
|
|
500 | 501 |
String catxml = MetacatReplication.getURLContent(u); |
501 |
//System.out.println("catxml: " + catxml); |
|
502 |
|
|
503 |
// Make sure there are not error, no empty string |
|
504 |
if (catxml.indexOf("error")!=-1 || catxml==null||catxml.equals("")) |
|
505 |
{ |
|
506 |
continue; |
|
507 |
} |
|
508 |
MetaCatUtil.debugMessage("catxml: " + catxml, 50); |
|
502 | 509 |
CatalogMessageHandler cmh = new CatalogMessageHandler(); |
503 | 510 |
XMLReader catparser = initParser(cmh); |
504 | 511 |
catparser.parse(new InputSource(new StringReader(catxml))); |
505 | 512 |
//parse the returned catalog xml and put it into a vector |
506 | 513 |
Vector remoteCatalog = cmh.getCatalogVect(); |
507 | 514 |
|
515 |
// Makse sure remoteCatalog is not empty |
|
516 |
if (remoteCatalog.isEmpty()) |
|
517 |
{ |
|
518 |
continue; |
|
519 |
} |
|
520 |
|
|
508 | 521 |
String localcatxml = MetacatReplication.getCatalogXML(); |
509 |
//System.out.println("localcatxml: " + localcatxml); |
|
522 |
|
|
523 |
// Make sure local catalog is no empty |
|
524 |
if (localcatxml==null||localcatxml.equals("")) |
|
525 |
{ |
|
526 |
continue; |
|
527 |
} |
|
528 |
|
|
510 | 529 |
cmh = new CatalogMessageHandler(); |
511 | 530 |
catparser = initParser(cmh); |
512 | 531 |
catparser.parse(new InputSource(new StringReader(localcatxml))); |
... | ... | |
520 | 539 |
for(int i=0; i<localCatalog.size(); i++) |
521 | 540 |
{ |
522 | 541 |
Vector v = new Vector((Vector)localCatalog.elementAt(i)); |
523 |
//System.out.println("v1: " + v.toString());
|
|
542 |
MetaCatUtil.debugMessage("v1: " + v.toString(), 50);
|
|
524 | 543 |
publicId.add(new String((String)v.elementAt(3))); |
525 | 544 |
//System.out.println("adding " + (String)v.elementAt(3)); |
526 | 545 |
} |
... | ... | |
532 | 551 |
//System.out.println("i: " + i); |
533 | 552 |
//System.out.println("remoteCatalog.size(): " + remoteCatalog.size()); |
534 | 553 |
//System.out.println("publicID: " + publicId.toString()); |
535 |
//System.out.println("v.elementAt(3): " + (String)v.elementAt(3)); |
|
554 |
MetaCatUtil.debugMessage |
|
555 |
("v.elementAt(3): " + (String)v.elementAt(3), 50); |
|
536 | 556 |
if(!publicId.contains(v.elementAt(3))) |
537 | 557 |
{ //so we don't have this public id in our local table so we need to |
538 | 558 |
//add it. |
... | ... | |
555 | 575 |
} |
556 | 576 |
} |
557 | 577 |
} |
558 |
//conn.close(); |
|
578 |
|
|
559 | 579 |
} |
560 | 580 |
catch(Exception e) |
561 | 581 |
{ |
... | ... | |
565 | 585 |
}//catch |
566 | 586 |
finally |
567 | 587 |
{ |
568 |
try |
|
569 |
{ |
|
570 |
pstmt.close(); |
|
571 |
}//try |
|
572 |
catch (SQLException ee) |
|
573 |
{ |
|
574 |
MetaCatUtil.debugMessage("Error in ReplicationHandler.updateCatalog "+ |
|
575 |
"to close pstmt: "+ee.getMessage(), 30); |
|
576 |
}//catch |
|
577 |
finally |
|
578 |
{ |
|
579 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
580 |
}//finally |
|
588 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
581 | 589 |
}//finall |
582 | 590 |
} |
583 | 591 |
|
... | ... | |
674 | 682 |
}//finally |
675 | 683 |
return false; |
676 | 684 |
} |
677 |
|
|
678 |
/** |
|
679 |
* Checks to see if a document is already in the DB. Returns |
|
680 |
* "UPDATE" if it is, "INSERT" if it isn't |
|
681 |
*/ |
|
682 |
private static String getAction(String docid) |
|
683 |
{ |
|
684 |
DBConnection dbConn = null; |
|
685 |
int serialNumber = -1; |
|
686 |
PreparedStatement pstmt = null; |
|
687 |
try |
|
688 |
{ |
|
689 |
dbConn=DBConnectionPool. |
|
690 |
getDBConnection("ReplicationHandler.getAction"); |
|
691 |
serialNumber=dbConn.getCheckOutSerialNumber(); |
|
692 |
//MetaCatUtil util = new MetaCatUtil(); |
|
693 |
StringBuffer sql = new StringBuffer(); |
|
694 |
sql.append("select docid from xml_documents where docid like '"); |
|
695 |
sql.append(docid).append("'"); |
|
696 |
//Connection conn = util.openDBConnection(); |
|
697 |
pstmt = dbConn.prepareStatement(sql.toString()); |
|
698 |
pstmt.execute(); |
|
699 |
ResultSet rs = pstmt.getResultSet(); |
|
700 | 685 |
|
701 |
if(rs.next()) |
|
702 |
{ |
|
703 |
pstmt.close(); |
|
704 |
//conn.close(); |
|
705 |
return "UPDATE"; |
|
706 |
} |
|
707 |
else |
|
708 |
{ |
|
709 |
pstmt.close(); |
|
710 |
//conn.close(); |
|
711 |
return "INSERT"; |
|
712 |
} |
|
713 |
} |
|
714 |
catch(Exception e) |
|
715 |
{ |
|
716 |
System.out.println("error in replicationHandler.getAction: " + |
|
717 |
e.getMessage()); |
|
718 |
} |
|
719 |
finally |
|
720 |
{ |
|
721 |
try |
|
722 |
{ |
|
723 |
pstmt.close(); |
|
724 |
} |
|
725 |
catch (SQLException sqlE) |
|
726 |
{ |
|
727 |
MetaCatUtil.debugMessage("error in replicationHandler.getAction: " + |
|
728 |
"to close pstmt: "+ sqlE.getMessage(), 30); |
|
729 |
} |
|
730 |
finally |
|
731 |
{ |
|
732 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
733 |
} |
|
734 |
}//finally |
|
735 |
return ""; |
|
736 |
} |
|
737 | 686 |
|
738 | 687 |
/** |
739 |
* Method to query xml_replication and build a hashtable of each server |
|
740 |
* and it's last update time. |
|
741 |
* @param conn a connection to the database |
|
742 |
*/ |
|
743 |
public static Hashtable buildServerList() |
|
744 |
{ |
|
745 |
DBConnection dbConn = null; |
|
746 |
int serialNumber = -1; |
|
747 |
Hashtable sl = new Hashtable(); |
|
748 |
PreparedStatement pstmt = null; |
|
749 |
try |
|
750 |
{ |
|
751 |
dbConn=DBConnectionPool. |
|
752 |
getDBConnection("ReplicationHandler.buildServerList"); |
|
753 |
serialNumber=dbConn.getCheckOutSerialNumber(); |
|
754 |
pstmt = dbConn.prepareStatement("select server, last_checked, replicate "+ |
|
755 |
"from xml_replication"); |
|
756 |
pstmt.execute(); |
|
757 |
ResultSet rs = pstmt.getResultSet(); |
|
758 |
boolean tableHasRows = rs.next(); |
|
759 |
while(tableHasRows) |
|
760 |
{ |
|
761 |
if(rs.getInt(3) == 1) |
|
762 |
{//only put the server in the list if the replicate flag is true |
|
763 |
String server = rs.getString(1); |
|
764 |
String last_checked = rs.getString(2); |
|
765 |
if(!server.equals("localhost")) |
|
766 |
{ |
|
767 |
sl.put(server, last_checked); |
|
768 |
} |
|
769 |
} |
|
770 |
tableHasRows = rs.next(); |
|
771 |
} |
|
772 |
pstmt.close(); |
|
773 |
} |
|
774 |
catch(Exception e) |
|
775 |
{ |
|
776 |
System.out.println("error in replicationHandler.buildServerList(): " + |
|
777 |
e.getMessage()); |
|
778 |
} |
|
779 |
finally |
|
780 |
{ |
|
781 |
try |
|
782 |
{ |
|
783 |
pstmt.close(); |
|
784 |
}//try |
|
785 |
catch (SQLException sqlE) |
|
786 |
{ |
|
787 |
MetaCatUtil.debugMessage("Error in ReplicationHandler.buildServerList: " |
|
788 |
+sqlE.getMessage()); |
|
789 |
}//catch |
|
790 |
finally |
|
791 |
{ |
|
792 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
793 |
}//finally |
|
794 |
}//finally |
|
795 |
|
|
796 |
return sl; |
|
797 |
} |
|
798 |
/** |
|
799 |
* Method to get a host server information for given docid |
|
800 |
* @param conn a connection to the database |
|
801 |
*/ |
|
802 |
public static Hashtable getHomeServer(String docId) |
|
803 |
{ |
|
804 |
Hashtable sl = new Hashtable(); |
|
805 |
DBConnection dbConn = null; |
|
806 |
int serialNumber = -1; |
|
807 |
//MetaCatUtil ut=new MetaCatUtil(); |
|
808 |
docId=MetaCatUtil.getDocIdFromString(docId); |
|
809 |
PreparedStatement pstmt=null; |
|
810 |
int serverLocation; |
|
811 |
try |
|
812 |
{ |
|
813 |
//get conection |
|
814 |
dbConn=DBConnectionPool. |
|
815 |
getDBConnection("ReplicationHandler.getHomeServer"); |
|
816 |
serialNumber=dbConn.getCheckOutSerialNumber(); |
|
817 |
//get a server location from xml_document table |
|
818 |
pstmt=dbConn.prepareStatement("select server_location from xml_documents " |
|
819 |
+"where docid = ?"); |
|
820 |
pstmt.setString(1, docId); |
|
821 |
pstmt.execute(); |
|
822 |
ResultSet serverName = pstmt.getResultSet(); |
|
823 |
//get a server location |
|
824 |
if(serverName.next()) |
|
825 |
{ |
|
826 |
serverLocation=serverName.getInt(1); |
|
827 |
pstmt.close(); |
|
828 |
} |
|
829 |
else |
|
830 |
{ |
|
831 |
pstmt.close(); |
|
832 |
//ut.returnConnection(conn); |
|
833 |
return null; |
|
834 |
} |
|
835 |
pstmt=dbConn.prepareStatement("select server, last_checked, replicate " + |
|
836 |
"from xml_replication where serverid = ?"); |
|
837 |
//increase usage count |
|
838 |
dbConn.increaseUsageCount(1); |
|
839 |
pstmt.setInt(1, serverLocation); |
|
840 |
pstmt.execute(); |
|
841 |
ResultSet rs = pstmt.getResultSet(); |
|
842 |
boolean tableHasRows = rs.next(); |
|
843 |
if (tableHasRows) |
|
844 |
{ |
|
845 |
|
|
846 |
String server = rs.getString(1); |
|
847 |
String last_checked = rs.getString(2); |
|
848 |
if(!server.equals("localhost")) |
|
849 |
{ |
|
850 |
sl.put(server, last_checked); |
|
851 |
} |
|
852 |
|
|
853 |
} |
|
854 |
else |
|
855 |
{ |
|
856 |
pstmt.close(); |
|
857 |
//ut.returnConnection(conn); |
|
858 |
return null; |
|
859 |
} |
|
860 |
pstmt.close(); |
|
861 |
} |
|
862 |
catch(Exception e) |
|
863 |
{ |
|
864 |
System.out.println("error in replicationHandler.getHomeServer(): " + |
|
865 |
e.getMessage()); |
|
866 |
} |
|
867 |
finally |
|
868 |
{ |
|
869 |
try |
|
870 |
{ |
|
871 |
pstmt.close(); |
|
872 |
//ut.returnConnection(conn); |
|
873 |
} |
|
874 |
catch (Exception ee) |
|
875 |
{ |
|
876 |
MetaCatUtil.debugMessage("Eror irn rplicationHandler.getHomeServer() "+ |
|
877 |
"to close pstmt: "+ee.getMessage(), 30); |
|
878 |
} |
|
879 |
finally |
|
880 |
{ |
|
881 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
882 |
} |
|
883 |
|
|
884 |
}//finally |
|
885 |
return sl; |
|
886 |
} |
|
887 |
|
|
888 |
/** |
|
889 |
* Returns a server location given a accnum |
|
890 |
* @param accNum , given accNum for a document |
|
891 |
* |
|
892 |
*/ |
|
893 |
public static int getServerLocation(String accNum) throws Exception |
|
894 |
{ |
|
895 |
DBConnection dbConn = null; |
|
896 |
int serialNumber = -1; |
|
897 |
PreparedStatement pstmt = null; |
|
898 |
int serverCode = 1; |
|
899 |
//MetaCatUtil ut = new MetaCatUtil(); |
|
900 |
String docId=MetaCatUtil.getDocIdFromString(accNum); |
|
901 |
|
|
902 |
try |
|
903 |
{ |
|
904 |
|
|
905 |
//conn = ut.openDBConnection(); |
|
906 |
//get conection |
|
907 |
dbConn=DBConnectionPool. |
|
908 |
getDBConnection("ReplicationHandler.getServerLocation"); |
|
909 |
serialNumber=dbConn.getCheckOutSerialNumber(); |
|
910 |
pstmt=dbConn.prepareStatement("SELECT server_location FROM xml_documents " |
|
911 |
+ "WHERE docid LIKE '" + docId + "'"); |
|
912 |
pstmt.execute(); |
|
913 |
ResultSet rs = pstmt.getResultSet(); |
|
914 |
boolean tablehasrows = rs.next(); |
|
915 |
//If a document is find, return the server location for it |
|
916 |
if ( tablehasrows ) |
|
917 |
{ |
|
918 |
serverCode = rs.getInt(1); |
|
919 |
pstmt.close(); |
|
920 |
//conn.close(); |
|
921 |
return serverCode; |
|
922 |
} |
|
923 |
//if couldn't find in xml_documents table, we think server code is 1 |
|
924 |
//(this is new document) |
|
925 |
else |
|
926 |
{ |
|
927 |
pstmt.close(); |
|
928 |
//conn.close(); |
|
929 |
return serverCode; |
|
930 |
} |
|
931 |
|
|
932 |
} |
|
933 |
catch(Exception e) |
|
934 |
{ |
|
935 |
|
|
936 |
throw e; |
|
937 |
|
|
938 |
} |
|
939 |
finally |
|
940 |
{ |
|
941 |
try |
|
942 |
{ |
|
943 |
pstmt.close(); |
|
944 |
//conn.close(); |
|
945 |
|
|
946 |
} |
|
947 |
catch(Exception ee) |
|
948 |
{ |
|
949 |
MetaCatUtil.debugMessage("Erorr in Replication.getServerLocation "+ |
|
950 |
"to close pstmt"+ee.getMessage(), 30); |
|
951 |
} |
|
952 |
finally |
|
953 |
{ |
|
954 |
DBConnectionPool.returnDBConnection(dbConn, serialNumber); |
|
955 |
}//finally |
|
956 |
}//finally |
|
957 |
//return serverCode; |
|
958 |
} |
|
959 |
|
|
960 |
|
|
961 |
|
|
962 |
/** |
|
963 | 688 |
* Method to initialize the message parser |
964 | 689 |
*/ |
965 | 690 |
public static XMLReader initParser(DefaultHandler dh) |
Also available in: Unified diff
Merge cvs branch replication to cvs head.