Coverage report

| %line | %branch
--- | --- | ---
org.apache.commons.net.ftp.parser.VMSFTPEntryParser |
86% |
97% |

1 |  |
     /*
2 |  |
      * Copyright 2001-2005 The Apache Software Foundation
3 |  |
      *
4 |  |
      * Licensed under the Apache License, Version 2.0 (the "License");
5 |  |
      * you may not use this file except in compliance with the License.
6 |  |
      * You may obtain a copy of the License at
7 |  |
      *
8 |  |
      *     http://www.apache.org/licenses/LICENSE-2.0
9 |  |
      *
10 |  |
      * Unless required by applicable law or agreed to in writing, software
11 |  |
      * distributed under the License is distributed on an "AS IS" BASIS,
12 |  |
      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  |
      * See the License for the specific language governing permissions and
14 |  |
      * limitations under the License.
15 |  |
      */
16 |  |
     package org.apache.commons.net.ftp.parser;
17 |  |
     import java.io.BufferedReader;
18 |  |
     import java.io.IOException;
19 |  |
     import java.io.InputStream;
20 |  |
     import java.text.ParseException;
21 |  |
     import java.util.StringTokenizer;
22 |  |
23 |  |
     import org.apache.commons.net.ftp.FTPClientConfig;
24 |  |
     import org.apache.commons.net.ftp.FTPFile;
25 |  |
     import org.apache.commons.net.ftp.FTPListParseEngine;
26 |  |
27 |  |
     /**
28 |  |
      * Implementation FTPFileEntryParser and FTPFileListParser for VMS Systems.
29 |  |
      * This is a sample of VMS LIST output
30 |  |
      *
31 |  |
      *  "1-JUN.LIS;1              9/9           2-JUN-1998 07:32:04  [GROUP,OWNER]    (RWED,RWED,RWED,RE)",
32 |  |
      *  "1-JUN.LIS;2              9/9           2-JUN-1998 07:32:04  [GROUP,OWNER]    (RWED,RWED,RWED,RE)",
33 |  |
      *  "DATA.DIR;1               1/9           2-JUN-1998 07:32:04  [GROUP,OWNER]    (RWED,RWED,RWED,RE)",
34 |  |
      * <P><B>
35 |  |
      * Note: VMSFTPEntryParser can only be instantiated through the
36 |  |
      * DefaultFTPParserFactory by classname.  It will not be chosen
37 |  |
      * by the autodetection scheme.
38 |  |
      * </B>
39 |  |
      * <P>
40 |  |
      *
41 |  |
      * @author  <a href="Winston.Ojeda@qg.com">Winston Ojeda</a>
42 |  |
      * @author <a href="mailto:scohen@apache.org">Steve Cohen</a>
43 |  |
      * @author <a href="sestegra@free.fr">Stephane ESTE-GRACIAS</a>
44 |  |
      * @version $Id: VMSFTPEntryParser.java 155429 2005-02-26 13:13:04Z dirkv $
45 |  |
      *
46 |  |
      * @see org.apache.commons.net.ftp.FTPFileEntryParser FTPFileEntryParser (for usage instructions)
47 |  |
      * @see org.apache.commons.net.ftp.parser.DefaultFTPFileEntryParserFactory
48 |  |
      */
49 |  |
     public class VMSFTPEntryParser extends ConfigurableFTPFileEntryParserImpl
50 |  |
     {
51 |  |
52 |  |
         private static final String DEFAULT_DATE_FORMAT
53 |  |
     		= "d-MMM-yyyy HH:mm:ss"; //9-NOV-2001 12:30:24
54 |  |
55 |  |
         /**
56 |  |
          * this is the regular expression used by this parser.
57 |  |
          */
58 |  |
         private static final String REGEX =
59 |  |
             "(.*;[0-9]+)\\s*"
60 |  |
             + "(\\d+)/\\d+\\s*"
61 |  |
             +"(\\S+)\\s+(\\S+)\\s+"
62 |  |
             + "\\[(([0-9$A-Za-z_]+)|([0-9$A-Za-z_]+),([0-9$a-zA-Z_]+))\\]?\\s*"
63 |  |
             + "\\([a-zA-Z]*,[a-zA-Z]*,[a-zA-Z]*,[a-zA-Z]*\\)";
64 |  |
65 |  |
66 |  |
67 |  |
         /**
68 |  |
          * Constructor for a VMSFTPEntryParser object.
69 |  |
          *
70 |  |
          * @exception IllegalArgumentException
71 |  |
          * Thrown if the regular expression is unparseable.  Should not be seen
72 |  |
          * under normal conditions.  It it is seen, this is a sign that
73 |  |
          * <code>REGEX</code> is  not a valid regular expression.
74 |  |
          */
75 |  |
         public VMSFTPEntryParser()
76 |  |
         {
77 | 26 |
             this(null);
78 | 26 |
         }
79 |  |
80 |  |
         /**
81 |  |
          * This constructor allows the creation of a VMSFTPEntryParser object with
82 |  |
          * something other than the default configuration.
83 |  |
          *
84 |  |
          * @param config The {@link FTPClientConfig configuration} object used to
85 |  |
          * configure this parser.
86 |  |
          * @exception IllegalArgumentException
87 |  |
          * Thrown if the regular expression is unparseable.  Should not be seen
88 |  |
          * under normal conditions.  It it is seen, this is a sign that
89 |  |
          * <code>REGEX</code> is  not a valid regular expression.
90 |  |
          * @since 1.4
91 |  |
          */
92 |  |
         public VMSFTPEntryParser(FTPClientConfig config)
93 |  |
         {
94 | 26 |
             super(REGEX);
95 | 26 |
             configure(config);
96 | 26 |
         }
97 |  |
98 |  |
99 |  |
100 |  |
         /***
101 |  |
          * Parses an FTP server file listing and converts it into a usable format
102 |  |
          * in the form of an array of <code> FTPFile </code> instances.  If the
103 |  |
          * file list contains no files, <code> null </code> should be
104 |  |
          * returned, otherwise an array of <code> FTPFile </code> instances
105 |  |
          * representing the files in the directory is returned.
106 |  |
          * <p>
107 |  |
          * @param listStream The InputStream from which the file list should be
108 |  |
          *        read.
109 |  |
          * @return The list of file information contained in the given path.  null
110 |  |
          *     if the list could not be obtained or if there are no files in
111 |  |
          *     the directory.
112 |  |
          * @exception IOException  If an I/O error occurs reading the listStream.
113 |  |
          ***/
114 |  |
         public FTPFile[] parseFileList(InputStream listStream) throws IOException {
115 | 0 |
             FTPListParseEngine engine = new FTPListParseEngine(this);
116 | 0 |
             engine.readServerList(listStream);
117 | 0 |
             return engine.getFiles();
118 |  |
         }
119 |  |
120 |  |
121 |  |
122 |  |
         /**
123 |  |
          * Parses a line of a VMS FTP server file listing and converts it into a
124 |  |
          * usable format in the form of an <code> FTPFile </code> instance.  If the
125 |  |
          * file listing line doesn't describe a file, <code> null </code> is
126 |  |
          * returned, otherwise a <code> FTPFile </code> instance representing the
127 |  |
          * files in the directory is returned.
128 |  |
          * <p>
129 |  |
          * @param entry A line of text from the file listing
130 |  |
          * @return An FTPFile instance corresponding to the supplied entry
131 |  |
          */
132 |  |
         public FTPFile parseFTPEntry(String entry)
133 |  |
         {
134 |  |
             //one block in VMS equals 512 bytes
135 | 80 |
             long class="keyword">longBlock = 512;
136 |  |
137 | 80 |
             if (matches(entry))
138 |  |
             {
139 | 66 |
                 FTPFile f = new FTPFile();
140 | 66 |
                 f.setRawListing(entry);
141 | 66 |
                 String name = group(1);
142 | 66 |
                 String size = group(2);
143 | 66 |
             	String datestr = group(3)+" "+group(4);
144 | 66 |
                 String owner = group(5);
145 |  |
                 try
146 |  |
                 {
147 | 66 |
                     f.setTimestamp(super.parseTimestamp(datestr));
148 |  |
                 }
149 | 4 |
                 catch (ParseException e)
150 |  |
                 {
151 | 4 |
                 	return null;  // this is a parsing failure too.
152 | 62 |
                 }
153 |  |
154 |  |
155 |  |
                 String grp;
156 |  |
                 String user;
157 | 62 |
                 StringTokenizer t = new StringTokenizer(owner, ",");
158 | 62 |
                 switch (t.countTokens()) {
159 |  |
                     case 1:
160 | 8 |
                         grp  = null;
161 | 8 |
                         user = t.nextToken();
162 | 8 |
                         break;
163 |  |
                     case 2:
164 | 54 |
                         grp  = t.nextToken();
165 | 54 |
                         user = t.nextToken();
166 | 54 |
                         break;
167 |  |
                     default:
168 | 0 |
                         grp  = null;
169 | 0 |
                         user = null;
170 |  |
                 }
171 |  |
172 | 62 |
                 if (name.lastIndexOf(".DIR") != -1)
173 |  |
                 {
174 | 8 |
                     f.setType(FTPFile.DIRECTORY_TYPE);
175 |  |
                 }
176 |  |
                 else
177 |  |
                 {
178 | 54 |
                     f.setType(FTPFile.FILE_TYPE);
179 |  |
                 }
180 |  |
                 //set FTPFile name
181 |  |
                 //Check also for versions to be returned or not
182 | 62 |
                 if (isVersioning())
183 |  |
                 {
184 | 8 |
                     f.setName(name);
185 |  |
                 }
186 |  |
                 else
187 |  |
                 {
188 | 54 |
                     name = name.substring(0, name.lastIndexOf(";"));
189 | 54 |
                     f.setName(name);
190 |  |
                 }
191 |  |
                 //size is retreived in blocks and needs to be put in bytes
192 |  |
                 //for us humans and added to the FTPFile array
193 | 62 |
                 long sizeInBytes = Long.parseLong(size) * class="keyword">longBlock;
194 | 62 |
                 f.setSize(sizeInBytes);
195 |  |
196 | 62 |
                 f.setGroup(grp);
197 | 62 |
                 f.setUser(user);
198 |  |
                 //set group and owner
199 |  |
                 //Since I don't need the persmissions on this file (RWED), I'll
200 |  |
                 //leave that for further development. 'Cause it will be a bit
201 |  |
                 //elaborate to do it right with VMSes World, Global and so forth.
202 | 62 |
                 return f;
203 |  |
             }
204 | 14 |
             return null;
205 |  |
         }
206 |  |
207 |  |
208 |  |
         /**
209 |  |
          * Reads the next entry using the supplied BufferedReader object up to
210 |  |
          * whatever delemits one entry from the next.   This parser cannot use
211 |  |
          * the default implementation of simply calling BufferedReader.readLine(),
212 |  |
          * because one entry may span multiple lines.
213 |  |
          *
214 |  |
          * @param reader The BufferedReader object from which entries are to be
215 |  |
          * read.
216 |  |
          *
217 |  |
          * @return A string representing the next ftp entry or null if none found.
218 |  |
          * @exception IOException thrown on any IO Error reading from the reader.
219 |  |
          */
220 |  |
         public String readNextEntry(BufferedReader reader) throws IOException
221 |  |
         {
222 | 28 |
             String line = reader.readLine();
223 | 28 |
             StringBuffer entry = new StringBuffer();
224 | 44 |
             while (line != null)
225 |  |
             {
226 | 40 |
                 if (line.startsWith("Directory") || line.startsWith("Total")) {
227 | 8 |
                     line = reader.readLine();
228 | 8 |
                     continue;
229 |  |
                 }
230 |  |
231 | 32 |
                 entry.append(line);
232 | 32 |
                 if (line.trim().endsWith(")"))
233 |  |
                 {
234 | 24 |
                     break;
235 |  |
                 }
236 | 8 |
                 line = reader.readLine();
237 |  |
             }
238 | 28 |
             return (entry.length() == 0 ? null : entry.toString());
239 |  |
         }
240 |  |
241 |  |
         protected boolean isVersioning() {
242 | 54 |
             return false;
243 |  |
         }
244 |  |
245 |  |
         /**
246 |  |
          * Defines a default configuration to be used when this class is
247 |  |
          * instantiated without a {@link  FTPClientConfig  FTPClientConfig}
248 |  |
          * parameter being specified.
249 |  |
          * @return the default configuration for this parser.
250 |  |
          */
251 |  |
        protected FTPClientConfig getDefaultConfiguration() {
252 | 56 |
             return new FTPClientConfig(
253 |  |
                     FTPClientConfig.SYST_VMS,
254 |  |
                     DEFAULT_DATE_FORMAT,
255 |  |
                     null, class="keyword">null, class="keyword">null, class="keyword">null);
256 |  |
         }
257 |  |
258 |  |
259 |  |
     }
260 |  |
261 |  |
     /* Emacs configuration
262 |  |
      * Local variables:        **
263 |  |
      * mode:             java  **
264 |  |
      * c-basic-offset:   4     **
265 |  |
      * indent-tabs-mode: nil   **
266 |  |
      * End:                    **
267 |  |
      */

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.