| 1,14 → 1,28 |
|---|
| package net.brutex.xservices.ws.rs; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.io.PrintStream; |
| import java.net.URI; |
| import java.util.List; |
| import java.util.StringTokenizer; |
| |
| import javax.ws.rs.core.GenericEntity; |
| import javax.ws.rs.core.HttpHeaders; |
| import javax.ws.rs.core.Response; |
| |
| import javax.ws.rs.core.Response.ResponseBuilder; |
| import net.brutex.xservices.types.scm.AttributeType; |
| import net.brutex.xservices.types.scm.ItemListType; |
| import net.brutex.xservices.types.scm.ItemType; |
| import net.brutex.xservices.types.scm.ModuleListType; |
| import net.brutex.xservices.types.scm.ModuleType; |
| import net.brutex.xservices.types.scm.ObjectFactory; |
| import net.brutex.xservices.types.scm.RevisionType; |
| import net.brutex.xservices.types.scm.TagListType; |
| import net.brutex.xservices.types.scmfindings.FindingsListType; |
| import net.brutex.xservices.util.BasicCVSListener; |
| import net.brutex.xservices.util.CVSClient; |
| import net.brutex.xservices.util.CVSRoot; |
| import org.apache.commons.configuration.ConfigurationException; |
| import org.apache.jcs.JCS; |
| import org.apache.jcs.access.exception.CacheException; |
| 16,188 → 30,184 |
|---|
| import org.netbeans.lib.cvsclient.Client; |
| import org.netbeans.lib.cvsclient.command.CommandAbortedException; |
| import org.netbeans.lib.cvsclient.command.CommandException; |
| import org.netbeans.lib.cvsclient.command.FileInfoContainer; |
| import org.netbeans.lib.cvsclient.command.PipedFileInformation; |
| import org.netbeans.lib.cvsclient.command.checkout.CheckoutCommand; |
| import org.netbeans.lib.cvsclient.command.checkout.ModuleListInformation; |
| import org.netbeans.lib.cvsclient.command.log.LogInformation; |
| import org.netbeans.lib.cvsclient.command.log.LogInformation.Revision; |
| import org.netbeans.lib.cvsclient.command.log.RlogCommand; |
| import org.netbeans.lib.cvsclient.connection.AuthenticationException; |
| import org.netbeans.lib.cvsclient.event.EventManager; |
| import org.netbeans.lib.cvsclient.event.FileInfoEvent; |
| |
| import net.brutex.xservices.types.scm.ModuleType; |
| import net.brutex.xservices.types.scm.FileType; |
| import net.brutex.xservices.types.scm.Revision; |
| import net.brutex.xservices.util.BasicCVSListener; |
| import net.brutex.xservices.util.CVSClient; |
| |
| /** |
| * @author Brian Rosenberger |
| * @since 0.5.0-20120824 |
| * |
| */ |
| public class CVSInfoImpl implements CVSInfo { |
| |
| final Logger logger = Logger.getLogger(CVSInfoImpl.class); |
| final ObjectFactory FACTORY = new ObjectFactory(); |
| final ItemListType list = this.FACTORY.createItemListType(); |
| |
| public Response getRepositoryFiles(HttpHeaders h, File f, String modules, |
| boolean showRevisions, |
| boolean forceNoCache) { |
| |
| final List<FileType> list = new ArrayList<FileType>(); |
| |
| boolean isRecursive, boolean showRevisions, boolean forceNoCache) { |
| String cachekey = "getFiles" + f.toURI().toString(); |
| logger.debug("forceNoCache="+forceNoCache); |
| List<FileType> cacheresult = (List<FileType>) getCacheInstance().get( |
| this.logger.debug("forceNoCache=" + forceNoCache); |
| ItemListType cacheresult = (ItemListType) getCacheInstance().get( |
| cachekey); |
| |
| if (!forceNoCache && cacheresult != null) { |
| // Cache hit |
| list.addAll(cacheresult); |
| } else { |
| // Cache miss |
| if ((!forceNoCache) && (cacheresult != null)) { |
| return Response.ok(cacheresult).build(); |
| } |
| Client client; |
| try { |
| CVSClient cvsclient = new CVSClient(f); |
| Client client = cvsclient.client; |
| final CVSClient cvsclient = new CVSClient(f); |
| client = cvsclient.client; |
| |
| client.getEventManager().addCVSListener(new BasicCVSListener() { |
| @Override |
| public void fileInfoGenerated(FileInfoEvent arg0) { |
| LogInformation info = (LogInformation) arg0 |
| .getInfoContainer(); |
| FileType cvsfile = new FileType(info.getFile(), info |
| .getRepositoryFilename(), info.getDescription()); |
| cvsfile.setHeadRevision(info.getHeadRevision()); |
| cvsfile.setBranch(info.getBranch()); |
| cvsfile.setTotalRevisions(info.getTotalRevisions()); |
| String repoPath = cvsclient.client.getRepository(); |
| |
| ItemType cvsfile = CVSInfoImpl.this.FACTORY |
| .createItemType(); |
| cvsfile.setIsLeaf(true); |
| cvsfile.setIsBinary(false); |
| |
| cvsfile.setFullname(info.getRepositoryFilename().substring( |
| repoPath.length() + 2, |
| info.getRepositoryFilename().length() - 2)); |
| |
| cvsfile.setRemotename(info.getRepositoryFilename()); |
| cvsfile.setRemotefullname(info.getRepositoryFilename()); |
| RevisionType revision = CVSInfoImpl.this.FACTORY |
| .createRevisionType(); |
| revision.setRevision(info.getHeadRevision()); |
| revision.setComment(info.getDescription()); |
| cvsfile.setTipRevision(revision); |
| |
| for (LogInformation.Revision r : info.getRevisionList()) { |
| cvsfile.addRevision(new Revision(r.getNumber(), r |
| .getMessage())); |
| revision = CVSInfoImpl.this.FACTORY |
| .createRevisionType(); |
| revision.setRevision(r.getNumber()); |
| revision.setComment(r.getMessage()); |
| cvsfile.getRevisions().add(revision); |
| } |
| list.add(cvsfile); |
| |
| cvsfile.getAttributes().add( |
| CVSInfoImpl.this.getAttribute("TOTALREVISIONS", |
| info.getTotalRevisions())); |
| cvsfile.getAttributes().add( |
| CVSInfoImpl.this.getAttribute("BRANCH", |
| info.getBranch())); |
| cvsfile.getAttributes().add( |
| CVSInfoImpl.this.getAttribute( |
| "KEYWORDSUBSTITUTION", |
| info.getKeywordSubstitution())); |
| cvsfile.getAttributes().add( |
| CVSInfoImpl.this.getAttribute("LOCKS", |
| info.getLocks())); |
| cvsfile.getAttributes().add( |
| CVSInfoImpl.this.getAttribute("SELECTEDREVISIONS", |
| info.getSelectedRevisions())); |
| cvsfile.setROOT(cvsclient.getRoot().host + "@" |
| + cvsclient.getRoot().repository); |
| |
| CVSInfoImpl.this.list.getItems().add(cvsfile); |
| |
| String key = CVSClient.generateID(cvsfile); |
| try { |
| CVSInfoImpl.this.getCacheInstance().put(key, cvsfile); |
| } catch (CacheException e) { |
| CVSInfoImpl.this.logger.error("Could not cache item '" |
| + key + "'", e); |
| } |
| } |
| }); |
| |
| RlogCommand rlog = new RlogCommand(); |
| StringTokenizer tk = new StringTokenizer(modules, ","); |
| while (tk.hasMoreTokens()) { |
| rlog.setModule(tk.nextToken()); |
| } |
| if (rlog.getModules().length == 0) |
| if (rlog.getModules().length == 0) { |
| rlog.setModule(""); |
| } |
| rlog.setDefaultBranch(false); |
| |
| rlog.setDefaultBranch(true); // -b Print information about the |
| // revisions on the default |
| // branch, |
| // normally the highest branch |
| // on |
| // the trunk. |
| rlog.setNoTags(true); // -N Do not print the list of tags for |
| // this |
| // file. This option can be very useful |
| // when |
| // your site uses a lot of tags, so |
| // rather |
| // than "more"'ing over 3 pages of tag |
| // information, the log information is |
| // presented without tags at all. |
| rlog.setHeaderAndDescOnly(false); // -t Print only the name of |
| // the |
| // rcs file, name of the |
| // file in |
| // the working directory, |
| // head, |
| // default branch, access |
| // list, |
| // locks, symbolic names, |
| // and |
| // suffix. + description |
| // rlog.setRevisionFilter("1.1."); |
| // rlog.setSuppressHeader(true); // -S Supress log output when |
| // no |
| // revisions are selected within a file. |
| rlog.setNoTags(false); |
| |
| rlog.setHeaderAndDescOnly(false); |
| |
| rlog.setRecursive(isRecursive); |
| |
| this.logger.info("Executing CVS command '" + rlog.getCVSCommand() |
| + "' against '" + cvsclient.getRoot().host + "@" |
| + cvsclient.getRoot().repository + "'"); |
| client.executeCommand(rlog, cvsclient.getGlobalOptions()); |
| logger.info("Execute CVS command '" + rlog.getCVSCommand() + "' against '"+cvsclient.getRoot().host+"@" + cvsclient.getRoot().repository+"'"); |
| //need to put a new list into cache as we will filter the result |
| //afterwards |
| getCacheInstance().put(cachekey, new ArrayList<FileType>(list)); |
| |
| |
| getCacheInstance().put(cachekey, this.list); |
| } catch (ConfigurationException e) { |
| logger.error("CVS Configuration File '" |
| + f.getAbsolutePath() + f.getName() + "'not found.", e); |
| |
| this.logger.error("CVS Configuration File '" + f.getAbsolutePath() |
| + f.getName() + "'not found.", e); |
| } catch (CommandAbortedException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } catch (AuthenticationException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } catch (CommandException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } catch (CacheException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| |
| } |
| |
| |
| // prepare output after everything is cached |
| if (!showRevisions) { |
| for (FileType t : list) { |
| t.clearRevisionList(); |
| for (ItemType t : this.list.getItems()) { |
| t.getRevisions().clear(); |
| } |
| } |
| |
| GenericEntity entity = new GenericEntity<List<FileType>>(list) {}; |
| return Response.ok(entity).build(); |
| return Response.ok(this.list).build(); |
| } |
| |
| @Override |
| public Response getModules(HttpHeaders h, File f, boolean forceNoCache) { |
| String cachekey = "Modules" + f.toURI().toString(); |
| this.logger.debug("forceNoCache=" + forceNoCache); |
| |
| // Try to deliver from Cache |
| String cachekey = "Modules" + f.toURI().toString(); |
| logger.debug("forceNoCache="+forceNoCache); |
| List<ModuleType> response = (List<ModuleType>) getCacheInstance().get( |
| ModuleListType response = (ModuleListType) getCacheInstance().get( |
| cachekey); |
| if (!forceNoCache && response != null) { |
| GenericEntity entity = new GenericEntity<List<ModuleType>>(response) { |
| }; |
| return Response.ok(entity).build(); |
| if ((!forceNoCache) && (response != null)) { |
| return Response.ok(response).build(); |
| } |
| // ------------------------- |
| |
| try { |
| CVSClient cvsclient = new CVSClient(f); |
| Client client = cvsclient.client; |
| final ModuleListType list = this.FACTORY.createModuleListType(); |
| |
| final List<ModuleType> list = new ArrayList<ModuleType>(); |
| |
| client.getEventManager().addCVSListener(new BasicCVSListener() { |
| public void fileInfoGenerated(FileInfoEvent e) { |
| ModuleListInformation info = (ModuleListInformation) e |
| .getInfoContainer(); |
| |
| list.add(new ModuleType(info.getModuleName(), info |
| .getModuleStatus(), info.getPaths(), info.getType())); |
| ModuleType module = CVSInfoImpl.this.FACTORY |
| .createModuleType(); |
| module.setName(info.getModuleName()); |
| module.setStatus(info.getModuleStatus()); |
| module.setPath(info.getPaths()); |
| module.setType(info.getType()); |
| list.getModules().add(module); |
| } |
| }); |
| |
| CheckoutCommand co = new CheckoutCommand(); |
| co.setShowModulesWithStatus(true); |
| |
| this.logger.info("Executing CVS command '" + co.getCVSCommand() |
| + "' against '" + cvsclient.getRoot().host + "@" |
| + cvsclient.getRoot().repository + "'"); |
| client.executeCommand(co, cvsclient.getGlobalOptions()); |
| logger.info("Execute CVS command '" + co.getCVSCommand() + "' against '"+cvsclient.getRoot().host+"@" + cvsclient.getRoot().repository+"'"); |
| if(list.size()==0) { |
| logger.warn("Repository '" + cvsclient.getRoot().repository + "' does not have modules"); |
| list.add(new ModuleType("","","","")); |
| if (list.getModules().size() == 0) { |
| this.logger.warn("Repository '" |
| + cvsclient.getRoot().repository |
| + "' does not have modules"); |
| } |
| |
| GenericEntity entity = new GenericEntity<List<ModuleType>>(list) { |
| }; |
| getCacheInstance().put(cachekey, list); |
| return Response.ok(entity).build(); |
| return Response.ok(list).build(); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } |
| 204,22 → 214,164 |
|---|
| return Response.serverError().build(); |
| } |
| |
| /** |
| * Get the caching manager for CVS objects |
| * |
| * @return The CVSCaching JCS region |
| */ |
| public Response getTags(HttpHeaders h, File f, boolean withFiles) { |
| String cachekey = f.toURI().toString() + ":taglist"; |
| this.logger.debug("Retrieving Tags from cache using key '" + cachekey |
| + "'"); |
| TagListType tags = (TagListType) getCacheInstance().get(cachekey); |
| if (tags != null) { |
| this.logger.debug("Delivering Tags from cache."); |
| return Response.ok(tags).build(); |
| } |
| this.logger.warn("Taglist not found in cache."); |
| return Response.noContent().build(); |
| } |
| |
| public Response getFileContent(HttpHeaders h, File f, String filestring, |
| boolean forceNoCache) { |
| final ItemType result = this.FACTORY.createItemType(); |
| final String cachekey = f.toURI().toString() + ":" + filestring |
| + ":content"; |
| ItemListType list = null; |
| |
| if (!forceNoCache) { |
| this.logger.debug("Retrieving file content from cache using key '" |
| + cachekey + "'"); |
| list = (ItemListType) getCacheInstance().get(cachekey); |
| } |
| |
| if (list != null) { |
| this.logger.debug("Delivering file content from cache."); |
| return Response.ok(list).build(); |
| } |
| |
| this.logger.warn("File content not found in cache."); |
| list = this.FACTORY.createItemListType(); |
| try { |
| CVSClient cvsclient = new CVSClient(f); |
| Client client = cvsclient.getClient(); |
| |
| CheckoutCommand checkout = new CheckoutCommand(); |
| BasicCVSListener listener = new BasicCVSListener() { |
| public void fileInfoGenerated(FileInfoEvent arg0) { |
| System.out.println(arg0.getInfoContainer().getFile() |
| .toURI().toString()); |
| PipedFileInformation info = (PipedFileInformation) arg0 |
| .getInfoContainer(); |
| result.setName(info.getFile().getName()); |
| try { |
| boolean isBinary = false; |
| result.setIsBinary(isBinary); |
| result.setRemotename(info.getRepositoryFileName()); |
| RevisionType revision = CVSInfoImpl.this.FACTORY |
| .createRevisionType(); |
| revision.setRevision(info.getRepositoryRevision()); |
| revision.setComment(""); |
| |
| if (!isBinary) { |
| FileReader fin = new FileReader(info.getTempFile()); |
| |
| ByteArrayOutputStream bout = new ByteArrayOutputStream(); |
| StringBuffer sbuf = new StringBuffer(); |
| int c; |
| while ((c = fin.read()) != -1) { |
| bout.write(c); |
| sbuf.append((char) c); |
| } |
| result.setData(bout.toByteArray()); |
| result.setContent(sbuf.toString()); |
| } |
| |
| } catch (IOException e2) { |
| e2.printStackTrace(); |
| } catch (NullPointerException ne) { |
| ne.printStackTrace(); |
| } |
| |
| String key = CVSClient.generateID(result); |
| try { |
| CVSInfoImpl.this.getCacheInstance().put(cachekey, |
| result); |
| } catch (CacheException e1) { |
| e1.printStackTrace(); |
| } |
| } |
| }; |
| client.getEventManager().addCVSListener(listener); |
| |
| checkout.setModule(filestring); |
| checkout.setPipeToOutput(true); |
| |
| this.logger.info("Execute CVS command '" + checkout.getCVSCommand() |
| + "' against '" + cvsclient.getRoot().host + "@" |
| + cvsclient.getRoot().repository + "'"); |
| client.executeCommand(checkout, cvsclient.getGlobalOptions()); |
| } catch (CommandAbortedException e) { |
| e.printStackTrace(); |
| } catch (ConfigurationException e) { |
| e.printStackTrace(); |
| } catch (AuthenticationException e) { |
| e.printStackTrace(); |
| } catch (CommandException e) { |
| e.printStackTrace(); |
| } |
| |
| if (result.getContent() != null) { |
| return Response.ok(result).build(); |
| } |
| return Response.noContent().build(); |
| } |
| |
| public JCS getCacheInstance() { |
| JCS jcs = null; |
| final String cacheinstance = "CVSCache"; |
| String cacheinstance = "CVSCache"; |
| try { |
| logger.debug("Getting cache instance named '"+cacheinstance+"'" ); |
| jcs = JCS.getInstance(cacheinstance); |
| this.logger.trace("Getting cache instance named 'CVSCache'"); |
| jcs = JCS.getInstance("CVSCache"); |
| } catch (CacheException e) { |
| logger.error("Failed to get cache instance", e); |
| this.logger.error("Failed to get cache instance", e); |
| e.printStackTrace(); |
| } |
| return jcs; |
| } |
| |
| public Response searchFileContent(HttpHeaders h, File f, |
| String file_regexp, String content_regexp, boolean forceNoCache) { |
| try { |
| CVSClient client = new CVSClient(f); |
| String cvsroot = client.getRoot().host + "@" |
| + client.getRoot().repository; |
| |
| String cachestring = "FINDINGS-" + cvsroot; |
| this.logger |
| .debug("Fetch searchFileContent response from cache using cachekey '" |
| + cachestring + "'"); |
| FindingsListType result = (FindingsListType) getCacheInstance() |
| .get(cachestring); |
| if (result != null) |
| this.logger.debug("Found object for key '" + cachestring |
| + "' in cache."); |
| else { |
| this.logger.debug("Found no object for key '" + cachestring |
| + "' in cache."); |
| } |
| |
| if (result != null) |
| return Response.ok(result).build(); |
| } catch (CommandAbortedException e) { |
| e.printStackTrace(); |
| } catch (ConfigurationException e) { |
| e.printStackTrace(); |
| } catch (AuthenticationException e) { |
| e.printStackTrace(); |
| } |
| return Response.noContent().build(); |
| } |
| |
| private AttributeType getAttribute(String name, String value) { |
| AttributeType attribute = this.FACTORY.createAttributeType(); |
| attribute.setName(name); |
| attribute.setValue(value); |
| return attribute; |
| } |
| } |