Metacat

import edu.ucsb.nceas.metacat.accesscontrol.AccessControlException;

import edu.ucsb.nceas.metacat.accesscontrol.AccessControlForSingleFile;

import edu.ucsb.nceas.metacat.accesscontrol.AccessControlInterface;

import edu.ucsb.nceas.metacat.cart.CartManager;

import edu.ucsb.nceas.metacat.database.DBConnection;

import edu.ucsb.nceas.metacat.database.DBConnectionPool;

import edu.ucsb.nceas.metacat.properties.SkinPropertyService;

import edu.ucsb.nceas.metacat.replication.ForceReplicationHandler;

import edu.ucsb.nceas.metacat.replication.ReplicationService;

import edu.ucsb.nceas.metacat.service.ServiceService;

import edu.ucsb.nceas.metacat.service.SessionService;

import edu.ucsb.nceas.metacat.service.XMLSchemaService;

import edu.ucsb.nceas.metacat.shared.BaseException;

import edu.ucsb.nceas.metacat.shared.HandlerException;

import edu.ucsb.nceas.metacat.shared.MetacatUtilException;

import edu.ucsb.nceas.metacat.spatial.SpatialHarvester;

import edu.ucsb.nceas.metacat.spatial.SpatialQuery;

import edu.ucsb.nceas.metacat.util.AuthUtil;

	private static final long serialVersionUID = 1L;

	private Timer timer = null;

    // Constants -- these should be final in a servlet

    private static final String PROLOG = "<?xml version=\"1.0\"?>";

    public void init(ServletConfig config) throws ServletException {

    	Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

    	try {

    			return;

    		}

            context.setAttribute("APPLICATION_NAME", APPLICATION_NAME);

            ServiceService serviceService = ServiceService.getInstance(context);

            // Initialize the properties file

            String dirPath = ServiceService.getRealConfigDir();

            	return;

            }  

            initSecondHalf(context);

    	} catch (ServiceException se) {

        	String errorMessage = 

        		"Service problem while intializing MetaCat Servlet: " + se.getMessage();

            throw new ServletException(errorMessage);

        } catch (MetacatUtilException mue) {

        	String errorMessage = "Metacat utility problem while intializing MetaCat Servlet: " 

        		+ mue.getMessage();

            throw new ServletException(errorMessage);

        } 

    }

			// initialize DBConnection pool

			DBConnectionPool connPool = DBConnectionPool.getInstance();

			ServiceService.registerService("XMLSchemaService", XMLSchemaService.getInstance());

//			ServiceService.registerService("SchedulerService", SchedulerService.getInstance());

			// check if eml201 document were corrected or not. if not, correct eml201 documents.

			// Before Metacat 1.8.1, metacat uses tag RELEASE_EML_2_0_1_UPDATE_6 as eml

			// schema, which accidentily points to wrong version of eml-resource.xsd.

			if (correctedEML201Doc != null && correctedEML201Doc.equals(FALSE)) {

				EML201DocumentCorrector correct = new EML201DocumentCorrector();

				boolean success = correct.run();

				if (success) {

					PropertyService.setProperty("document.eml201DocumentCorrected", TRUE);

				}

			}

			// Index the paths specified in the metacat.properties

				// End timer

				long after = System.currentTimeMillis();

						+ (after - before) + "ms");

			} else {

			}

			// Set up the replication log file by setting the "replication.logfile.name" 

			}

			if (FileUtil.getFileStatus(replicationLogPath) < FileUtil.EXISTS_READ_WRITABLE) {

						+ " does not exist read/writable.");

			}

			System.setProperty("replication.logfile.name", replicationLogPath);			

			PropertyConfigurator.configureAndWatch(LOG_CONFIG_NAME);

					+ ") initialized.");

		} catch (SQLException e) {

			String errorMessage = "SQL problem while intializing MetaCat Servlet: "

					+ e.getMessage();

			throw new ServletException(errorMessage);

		} catch (IOException ie) {

			String errorMessage = "IO problem while intializing MetaCat Servlet: "

					+ ie.getMessage();

			throw new ServletException(errorMessage);

		} catch (GeneralPropertyException gpe) {

			String errorMessage = "Could not retrieve property while intializing MetaCat Servlet: "

					+ gpe.getMessage();

			throw new ServletException(errorMessage);

		} catch (ServiceException se) {

			String errorMessage = "Service problem while intializing MetaCat Servlet: "

				+ se.getMessage();

			throw new ServletException(errorMessage);

		} catch (UtilException ue) {

        	String errorMessage = "Utility problem while intializing MetaCat Servlet: " 

        		+ ue.getMessage();

            throw new ServletException(errorMessage);

        } 

	}

    	ServiceService.stopAllServices();

        // Close all db connection

        timer.cancel();

        IndexingQueue.getInstance().setMetacatRunning(false);

        DBConnectionPool.release();

        }

        catch (MetacatUtilException ue) {

        	pathsForIndexing = null;

            		+ "pathsForIndexing to null: " + ue.getMessage());

        }

        if (pathsForIndexing != null && !pathsForIndexing.isEmpty()) {

            DBConnection conn = null;

            int serialNumber = -1;

            ResultSet rs = null;

            for (String pathIndex : pathsForIndexing) {

                try {

                    //check out DBConnection

                    rs = pstmt.getResultSet();

                    if (!rs.next()) {

                        rs.close();

                        pstmt.close();

                        conn.increaseUsageCount(1);

                                + pathIndex);

                        if(pathIndex.indexOf("@")<0){

                            pstmt = conn.prepareStatement("SELECT DISTINCT n.docid, "

                        rs = pstmt.getResultSet();

                        int count = 0;

                                + pathIndex);

                        try {

                                }

                            }

                        } catch (Exception e) {

                            e.printStackTrace();

                        }

                        pstmt.close();

                        conn.increaseUsageCount(1);

                                + pathIndex + "'");

                    } else {

                    }

                    rs.close();

                    conn.increaseUsageCount(1);

                } catch (Exception e) {

                            + e.getMessage());

                }finally {

                    //check in DBonnection

            }

        }

    }

    /**

	 * Control servlet response depending on the action parameter specified

	 */

	private void handleGetOrPost(HttpServletRequest request,

			HttpServletResponse response) throws ServletException, IOException {

		Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

		// if we get here, metacat is configured.  If we have not completed the 

		// second half of the initialization, do so now.  This allows us to initially

		// configure metacat without a restart.

			initSecondHalf(request.getSession().getServletContext());

		}

		// Debug message to print out the method which have a busy DBConnection

		try {

			DBConnectionPool pool = DBConnectionPool.getInstance();

		} catch (SQLException e) {

			e.printStackTrace();

		}

					String docidToRead = path[1];

					String docs[] = new String[1];

					docs[0] = docidToRead;

					params.put("docid", docs);

					String skin = null;

					if (path.length > 2) {

			}

			String action = (params.get("action"))[0];

			// This block handles session management for the servlet

			// by looking up the current session information for all actions

					sessionId = sessionData.getId();

				}

			}

			// Now that we know the session is valid, we can delegate the

			// request to a particular action handler

			} else if (action.trim().equals("spatial_query")) {

				logMetacat

				ServletOutputStream streamOut = response.getOutputStream();

				PrintWriter out = new PrintWriter(streamOut);

				handleSpatialQuery(out, params, response, userName, groupNames, sessionId);

			} else if (action.trim().equals("dataquery")) {

				handleDataquery(params, response, sessionId);

			} else if (action.trim().equals("editcart")) {

				handleEditCart(params, response, sessionId);

			} else if (action.equals("export")) {

		} catch (PropertyNotFoundException pnfe) {

			String errorString = "Critical property not found: " + pnfe.getMessage();

			throw new ServletException(errorString);

		} catch (MetacatUtilException ue) {

			String errorString = "Utility error: " + ue.getMessage();

			throw new ServletException(errorString);

		} catch (ServiceException ue) {

			String errorString = "Service error: " + ue.getMessage();

			throw new ServletException(errorString);

		} catch (HandlerException he) {

			String errorString = "Handler error: " + he.getMessage();

			throw new ServletException(errorString);

		} catch (ErrorSendingErrorException esee) {

			String errorString = "Error sending error message: " + esee.getMessage();

			throw new ServletException(errorString);

		} catch (ErrorHandledException ehe) {

			// Nothing to do here.  We assume if we get here, the error has been 

        } catch (java.lang.NullPointerException e) {

            // should be "default" but keep this for backwards compatibility

			// with knp site

            qformatArray[0] = "knp";

        }

        params.put("qformat", qformatArray);

        }

        String un = (params.get("username"))[0];

        String pw = (params.get("password"))[0];

        String qformat = "xml";

        try {

            sess = new AuthSession();

        } catch (Exception e) {

                + e.getMessage();

            logMetacat.error(errorMsg);

            out.println(errorMsg);

            HttpSession session = sess.getSessions();

            String id = session.getId();

                    + " which has username" + session.getAttribute("username")

                    + " into hash in login method");

            try {

						(String) session.getAttribute("password"), 

						(String) session.getAttribute("name"));

			} catch (ServiceException se) {

						+ se.getMessage();

				out.println(errorMsg);

				return;

			} 			

                        "-//NCEAS//login//EN", "-//W3C//HTML//EN", qformat,

                        out, null, null);

            } catch (Exception e) {               

                        + e.getMessage());

            }

        }

        // close the connection

        HttpSession sess = request.getSession(false);

        if (sess != null) {

            + " will be invalidate in logout action");

                    + sess.getAttribute("username")

                    + " will be invalidate in logout action");

            sess.invalidate();

                        out, null, null);

            } catch (Exception e) {

                logMetacat.error(

                        + e.getMessage());

            }

        }

    private void handleSQuery(PrintWriter out, Hashtable<String, String[]> params,

            HttpServletResponse response, String user, String[] groups,

            String sessionid) throws PropertyNotFoundException {

        DBQuery queryobj = new DBQuery();

        queryobj.findDocuments(response, out, params, user, groups, sessionid);

    }

    /**

    private void handleQuery(PrintWriter out, Hashtable<String, String[]> params,

            HttpServletResponse response, String user, String[] groups,

            String sessionid) throws PropertyNotFoundException {

        //create the query and run it

        String xmlquery = DBQuery.createSQuery(params);

        String[] queryArray = new String[1];

        queryArray[0] = xmlquery;

        params.put("query", queryArray);

        DBQuery queryobj = new DBQuery();

        queryobj.findDocuments(response, out, params, user, groups, sessionid);

    }

    // END OF SQUERY & QUERY SECTION

                    zOut.close();

                }

            } catch (IOException ioe) {

                        + ioe.getMessage());

            }

                    + e.getMessage());

            e.printStackTrace(System.out);

                    out.close();

                }

            } catch (IOException ioe) {

                        + ioe.getMessage());

            }

                    + e.getMessage());

        }

    }

            // the docid which didn't be found

            String notFoundDocId = notFoundE.getUnfoundDocId();

            String notFoundRevision = notFoundE.getUnfoundRevision();

            try {

                // read docid from remote server

                readFromRemoteMetaCat(response, notFoundDocId,

                }

            } catch (Exception exc) {

                        + exc.getMessage());

                try {

                    if (out != null) {

                        zout.close();

                    }

                } catch (IOException ie) {

                            + ie.getMessage());

                }

            }

                    zout.close();

                }

            }

                    + e.getMessage());

            //e.printStackTrace(System.out);

        }

                    ContentTypeProvider provider = new ContentTypeProvider(

                            docid);

                    contentType = provider.getContentType();

                            + contentType);

                }

					} catch (Exception e) {

						// any exceptions in reading the xml from disc, and we go back to the

						// old way of creating the xml directly.

								+ ": " + e.getMessage());

						PrintWriter out = new PrintWriter(streamOut);

						doc.toXmlFromDb(out, user, groups, withInlineData);

            out.println("<error>");

            out.println("Docid not specified");

            out.println("</error>");

            return;

        }

				out.println("<error>");

				out.println("User '" + user + "' not allowed to insert and update");

				out.println("</error>");

				return;

			}

		} catch (MetacatUtilException ue) {

					+ ue.getMessage());

		}

        try {

            // Get the document indicated

            String[] doctext = params.get("doctext");

            String pub = null;

                return;

            }

            StringReader xml = new StringReader(doctext[0]);

            boolean validate = false;

            DocumentImplWrapper documentWrapper = null;

                            // set eml2 base	 validation parser

                            String rule = DocumentImpl.EML200;

                            // using emlparser to check id validation

                            documentWrapper = new DocumentImplWrapper(rule, true);

                        } else if (namespace.compareTo(

                                DocumentImpl.EML2_1_0NAMESPACE) == 0) {

                            // set eml2 base validation parser

                            String rule = DocumentImpl.EML210;

                            // using emlparser to check id validation

                            documentWrapper = new DocumentImplWrapper(rule, true);

                        } else {

                            // set schema base validation parser

                    // write the document to the database and disk

                    try {

                        String accNumber = docid[0];

                                + accNumber + "...");

                        if (accNumber.equals("")) {

                            accNumber = null;

                                user, accNumber, action[0]);

                    } catch (NullPointerException npe) {

                      // MCD this seems a bit dubious, since many things can throw npe

                        newdocid = documentWrapper.write(dbConn, xml, pub, dtd,

                                doAction, null, user, groups);

                        EventLog.getInstance().log(request.getRemoteAddr(),

                output += "<error>";

                output += npe.getMessage();

                output += "</error>";

                npe.printStackTrace();

            }

        } catch (Exception e) {

            output += "<error>";

            output += e.getMessage();

            output += "</error>";

            e.printStackTrace();

        }

                        out, null, null);

            } catch (Exception e) {

                        + e.getMessage());

            }

        }

            }

        }

        return validate;

    }

            out.println("<error>");

            out.println("Docid not specified.");

            out.println("</error>");

        } else {

            // delete the document from the database

                    out.println("<success>");

                    out.println("Document deleted.");

                    out.println("</success>");

                    // Delete from spatial cache if runningSpatialOption

                    if ( PropertyService.getProperty("spatial.runSpatialOption").equals("true") ) {

                    //out.println("Error deleting document!!!");

                    out.println(ane.getMessage());

                    out.println("</error>");

                            + ane.getMessage());

                }

            } catch (Exception e) {

                out.println("<error>");

                out.println(e.getMessage());

                out.println("</error>");

                        + e.getMessage());

            }

        }

        		String actualDocId = LSIDUtil.getDocId(docid, false);

        		docid = actualDocId;

        	} catch (ParseLSIDException ple) {

        				"could not parse lsid: " + docid + " : " + ple.getMessage());        		

        	}

        }

                    endDate = new Timestamp((format.parse(end)).getTime());

                }

            } catch (ParseException e) {

            }

            // Request the report by passing the filter parameters

                    docid, event, startDate, endDate));

            out.close();

        } catch (IOException e) {

					+ e.getMessage());

		} catch (MetacatUtilException ue) {

					+ ue.getMessage());

		}

    }

            out.println("</success>");

            out.close();

        } catch (IOException e) {

                    + e.getMessage());

        } catch (MetacatUtilException ue) {

					+ ue.getMessage());

		}

    }

        	sizeLimit = 

        		(new Integer(PropertyService.getProperty("replication.datafilesizelimit"))).intValue();

        } catch (PropertyNotFoundException pnfe) {

        			+ pnfe.getMessage());

        }

        try {

            MultipartParser mp = new MultipartParser(request,

                    fileList.put("filename", fileName);

                    fileList.put("name", fileTempLocation);

                } else {

                }

            }

        } catch (IOException ioe) {

            try {

                out = response.getWriter();

            } catch (IOException ioe2) {

            }

            out.println("<?xml version=\"1.0\"?>");

            out.println("<error>");

        try {

            out = response.getWriter();

        } catch (IOException ioe2) {

                    + "output stream.");

        }

            }

        } else if(action.equals("insertmultipart")) {

          if (username != null && !username.equals("public")) {

              handleInsertMultipartAction(request, response,

                            out, params, fileList, username, groupnames);

          } else {

      // Make sure we have a docid and datafile

      if (docid != null && fileList.containsKey("datafile")) 

      {

        // Get a reference to the file part of the form

        //FilePart filePart = (FilePart) fileList.get("datafile");

        String fileName = fileList.get("filename");

        // Check if the right file existed in the uploaded data

        if (fileName != null) 

        {

              {

                newFile = new File(newFileName);

                fileExists = newFile.exists();

                if(fileExists)

                {

                  newFile.delete();

                    } 

                    catch (IOException ioe) 

                    {

                                ioe.getMessage());

                    }

                    size = newFile.length();

                    if (size == 0) 

                    {

                    }

                }

                        fileName + ", " + docid + ", " +

                        username + ", " + groupnames);

                FileReader fr = new FileReader(newFile);

          }

          catch(Exception e)

          {

              e.printStackTrace();

          }

        }

        // Make sure we have a docid and datafile

        if (docid != null && fileList.containsKey("datafile")) {

            // Get a reference to the file part of the form

            //FilePart filePart = (FilePart) fileList.get("datafile");

            String fileName = fileList.get("filename");

            // Check if the right file existed in the uploaded data

            if (fileName != null) {

                        try {

                            newFile = new File(newFileName);

                            fileExists = newFile.exists();

                            if ( fileExists == false ) {

                                // copy file to desired output location

                                try {

                                    throw new IOException("Uploaded file is 0 bytes!");

                                }

                            }

                                    fileName + ", " + docid + ", " +

                                    username + ", " + groupnames);

                            //register the file in the database (which generates

                            if ( fileExists == false ) {

                                newFile.delete();

                            }

                            throw ee;

                        }

                        // not get force replication info from another metacat

                        ForceReplicationHandler frh = new ForceReplicationHandler(

                                docid, "insert", false, null);

                        // set content type and other response header fields

                        // first

                        out, null, null);

            } catch (Exception e) {

                        + e.getMessage());

            }

        }

            		String actualDocId = LSIDUtil.getDocId(docid, false);

            		docid = actualDocId;

            	} catch (ParseLSIDException ple) {

            				"could not parse lsid: " + docid + " : " + ple.getMessage());        		

            	}

            }

                        + accessionNumber);

            }

        } catch (Exception e) {

                    + e.getMessage());

            throw e;

        } finally {

                docList.add(docid + "." + rev);

            }

        } catch (SQLException e) {

                    + e.getMessage());

            throw e;

        } finally {

                pstmt.close();

            } catch (SQLException se) {

                        + se.getMessage());

                throw se;

            } finally {

     */

    private void scheduleSitemapGeneration(HttpServletRequest request) {

    	Logger logMetacat = Logger.getLogger(MetaCatServlet.class);

        	String directoryName = null;

        	String skin = null;

        	long sitemapInterval = 0;

				sitemapInterval = 

					Integer.parseInt(PropertyService.getProperty("sitemap.interval"));

			} catch (PropertyNotFoundException pnfe) {

						+ "could not be found: " + pnfe.getMessage());

			}

            Sitemap smap = new Sitemap(directory, urlRoot, skin);

            long firstDelay = 60*1000;   // 60 seconds delay

            timer.schedule(smap, firstDelay, sitemapInterval);

        }

    }

     * @return true if fully intialized, false otherwise

     */

    public static boolean isFullyInitialized() {

    }

}