#126

Committed 27 Sep 2023 05:01PM UTC coverage: 0.0%. Remained the same

Build # #126

Build Type

push

Committed by

Commit Message

-Update docs

Run Details

0 of 6576 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/com/windhoverlabs/yamcs/archive/CSVExporter.java

package com.windhoverlabs.yamcs.archive;

import com.google.protobuf.ByteString;
import com.google.protobuf.Timestamp;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UncheckedIOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.yamcs.AbstractYamcsService;
import org.yamcs.InitException;
import org.yamcs.YConfiguration;
import org.yamcs.YamcsServer;
import org.yamcs.api.HttpBody;
import org.yamcs.api.Observer;
import org.yamcs.archive.ReplayOptions;
import org.yamcs.client.Helpers;
import org.yamcs.client.YamcsClient;
import org.yamcs.client.archive.ArchiveClient;
import org.yamcs.http.BadRequestException;
import org.yamcs.http.MediaType;
import org.yamcs.http.api.ManagementApi;
import org.yamcs.http.api.ParameterReplayListener;
import org.yamcs.http.api.ReplayFactory;
import org.yamcs.mdb.XtceDbFactory;
import org.yamcs.parameter.ParameterValueWithId;
import org.yamcs.protobuf.Archive.ExportParameterValuesRequest;
import org.yamcs.protobuf.Yamcs.NamedObjectId;
import org.yamcs.protobuf.Yamcs.ParameterReplayRequest;
import org.yamcs.security.ObjectPrivilegeType;
import org.yamcs.security.User;
import org.yamcs.utils.TimeEncoding;
import org.yamcs.xtce.Parameter;
import org.yamcs.xtce.XtceDb;
import org.yamcs.yarch.FileSystemBucket;
import org.yamcs.yarch.YarchDatabase;
import org.yamcs.yarch.YarchDatabaseInstance;

public class CSVExporter extends AbstractYamcsService implements Runnable {

  private static class CsvParameterStreamer extends ParameterReplayListener {

    Observer<HttpBody> observer;
    List<NamedObjectId> ids;
    boolean addRaw;
    boolean addMonitoring;
    int recordCount = 0;
    char columnDelimiter = '\t';
    Instant firstInstant;

    CsvParameterStreamer(
        Observer<HttpBody> observer,
        String filename,
        List<NamedObjectId> ids,
        boolean addRaw,
        boolean addMonitoring) {
      this.observer = observer;
      this.ids = ids;
      this.addRaw = addRaw;
      this.addMonitoring = addMonitoring;

      HttpBody metadata =
          HttpBody.newBuilder()
              .setContentType(MediaType.CSV.toString())
              .setFilename(filename)
              .build();

      observer.next(metadata);
    }

    @Override
    protected void onParameterData(List<ParameterValueWithId> params) {

      ByteString.Output data = ByteString.newOutput();
      try (Writer writer = new OutputStreamWriter(data, StandardCharsets.UTF_8);
          DeltaCountedParameterFormatter formatter =
              new DeltaCountedParameterFormatter(writer, ids, columnDelimiter)) {
        if (recordCount == 0) {
          firstInstant =
              Helpers.toInstant(params.get(0).getParameterValue().toGpb().getGenerationTime());
        }
        formatter.setWriteHeader(recordCount == 0);
        formatter.setPrintRaw(addRaw);
        formatter.setPrintMonitoring(addMonitoring);
        formatter.setFirstInstant(firstInstant);
        formatter.writeParameters(params);
      } catch (IOException e) {
        throw new UncheckedIOException(e);
      }

      HttpBody body = HttpBody.newBuilder().setData(data.toByteString()).build();
      observer.next(body);
      recordCount++;
    }

    @Override
    public void replayFailed(Throwable t) {
      observer.completeExceptionally(t);
    }

    @Override
    public void replayFinished() {
      observer.complete();
    }
  }

  private YamcsClient yamcsClient;
  private ArchiveClient archiveClient;
  private boolean realtime;
  private Instant start;
  private Instant stop;
  private String bucketName;
  private FileSystemBucket bucket;
  private Thread thread;
  private HashMap<String, FileOutputStream> fisMap = new HashMap<String, FileOutputStream>();
  private Path bucketPath;
  private static final String CSV_NAME_POST_FIX = ".csv";
  private Map<String, List<String>> paramsMap = null;

  @Override
  public void init(String yamcsInstance, String serviceName, YConfiguration config)
      throws InitException {

    //    realtime =
    //        this.config.getBoolean(
    //            "realtime", false); // might be useful for "always" writing to a CSV file...
    //    start = Instant.parse("2023-09-23T23:00:00.000Z");
    start = Instant.parse(config.getString("start"));
    //    stop = Instant.parse("2023-09-24T00:10:00.000Z");
    stop = Instant.parse(config.getString("stop"));

    /* Read in our configuration parameters. */
    bucketName = config.getString("bucket");
    paramsMap = config.getMap("params");

    //    System.out.println("params:" + paramsMap);

    /* Iterate through the bucket names passed to us by the configuration file.  We're going to add the buckets
     * to our internal list so we can process them later. */
    YarchDatabaseInstance yarch = YarchDatabase.getInstance(YamcsServer.GLOBAL_INSTANCE);

    try {
      bucket = (FileSystemBucket) yarch.getBucket(bucketName);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  @Override
  protected void doStart() {

    thread = new Thread(this);
    thread.start();
    notifyStarted();
  }

  @Override
  protected void doStop() {
    // TODO Auto-generated method stub

  }

  private void export(
      User user, ExportParameterValuesRequest request, Observer<HttpBody> observer) {
    String instance = ManagementApi.verifyInstance(request.getInstance());
    //
    ReplayOptions repl = ReplayOptions.getAfapReplay();
    //
    List<NamedObjectId> ids = new ArrayList<>();
    XtceDb mdb = XtceDbFactory.getInstance(instance);
    String namespace = null;

    if (request.hasStart()) {
      repl.setRangeStart(TimeEncoding.fromProtobufTimestamp(request.getStart()));
    }
    if (request.hasStop()) {
      repl.setRangeStop(TimeEncoding.fromProtobufTimestamp(request.getStop()));
    }
    //    TODO:Get names from conofig/api request
    for (String id : request.getParametersList()) {
      ids.add(NamedObjectId.newBuilder().setName(id).build());
    }
    if (request.hasNamespace()) {
      namespace = request.getNamespace();
    }

    if (ids.isEmpty()) {
      for (Parameter p : mdb.getParameters()) {
        if (!user.hasObjectPrivilege(ObjectPrivilegeType.ReadParameter, p.getQualifiedName())) {
          continue;
        }
        if (namespace != null) {
          String alias = p.getAlias(namespace);
          if (alias != null) {
            ids.add(NamedObjectId.newBuilder().setNamespace(namespace).setName(alias).build());
          }
        } else {
          ids.add(NamedObjectId.newBuilder().setName(p.getQualifiedName()).build());
        }
      }
    }
    repl.setParameterRequest(ParameterReplayRequest.newBuilder().addAllNameFilter(ids).build());

    String filename;
    String dateString = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss").format(new Date());
    if (ids.size() == 1) {
      NamedObjectId id = ids.get(0);
      String parameterName = id.hasNamespace() ? id.getName() : id.getName().substring(1);
      filename = parameterName.replace('/', '_') + "_export_" + dateString + ".csv";
    } else {
      filename = "parameter_export_" + dateString + ".csv";
    }

    boolean addRaw = false;
    boolean addMonitoring = false;
    for (String extra : request.getExtraList()) {
      if (extra.equals("raw")) {
        addRaw = true;
      } else if (extra.equals("monitoring")) {
        addMonitoring = true;
      } else {
        throw new BadRequestException("Unexpected option for parameter 'extra': " + extra);
      }
    }
    CsvParameterStreamer l =
        new CsvParameterStreamer(observer, filename, ids, addRaw, addMonitoring);
    if (request.hasDelimiter()) {
      switch (request.getDelimiter()) {
        case "TAB":
          l.columnDelimiter = '\t';
          break;
        case "SEMICOLON":
          l.columnDelimiter = ';';
          break;
        case "COMMA":
          l.columnDelimiter = ',';
          break;
        default:
          throw new BadRequestException("Unexpected column delimiter");
      }
    }
    //    observer.setCancelHandler(l::requestReplayAbortion);
    ReplayFactory.replay(instance, user, repl, l);
  }

  @Override
  public void run() {
    exportPV();
  }

  private void exportPV() {

    for (Entry<String, List<String>> params : paramsMap.entrySet()) {
      ArrayList<String> parameters = new ArrayList<String>();
      //      String[] nameTokens = param.split("/");

      FileOutputStream fis = openFile(getNewFilePath(params.getKey()).toAbsolutePath().toString());
      fisMap.put(getNewFilePath(params.getKey()).toAbsolutePath().toString(), fis);
      for (String param : params.getValue()) {
        //        String p = "/cfs/ppd/apps/to/TO_HK_TLM_MID.ChannelInfo[0].MessagesSent";
        parameters.add(param);
      }
      this.export(
          YamcsServer.getServer().getSecurityStore().getDirectory().getUser("admin"),
          ExportParameterValuesRequest.newBuilder()
              .addAllParameters(parameters)
              .setStart(
                  Timestamp.newBuilder()
                      .setNanos(start.getNano())
                      .setSeconds(start.getEpochSecond())
                      .build())
              .setStop(
                  Timestamp.newBuilder()
                      .setNanos(stop.getNano())
                      .setSeconds(stop.getEpochSecond())
                      .build())
              .setInstance("fsw")
              .build(),
          new Observer<HttpBody>() {

            @Override
            public void next(HttpBody message) {
              //              // TODO Auto-generated method stub
              writeToCSV(
                  message.getData().toByteArray(),
                  getNewFilePath(params.getKey()).toAbsolutePath().toString());
            }

            @Override
            public void completeExceptionally(Throwable t) {
              // TODO Auto-generated method stub

            }

            @Override
            public void complete() {
              // TODO Auto-generated method stub
              closeFile(fis);
            }
          });
    }
  }

  private void writeToCSV(byte[] data, String path) {

    writeToFile(data, fisMap.get(path));
  }

  private void writeToFile(byte[] data, FileOutputStream fis) {
    try {
      fis.write(data, 0, data.length);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

  private void closeFile(FileOutputStream fis) {
    try {
      fis.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

  private FileOutputStream openFile(String path) {
    File inputFile = new File(path);
    FileOutputStream fis = null;
    try {
      fis = new FileOutputStream(inputFile);
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return fis;
  }

  private Path getNewFilePath(String name) {
    bucketPath = Paths.get(bucket.getBucketRoot().toString()).toAbsolutePath();
    Path filePath = bucketPath.resolve(name + "_" + CSV_NAME_POST_FIX);

    return filePath;
  }
}

1	package com.windhoverlabs.yamcs.archive;
2
3	import com.google.protobuf.ByteString;
4	import com.google.protobuf.Timestamp;
5	import java.io.File;
6	import java.io.FileNotFoundException;
7	import java.io.FileOutputStream;
8	import java.io.IOException;
9	import java.io.OutputStreamWriter;
10	import java.io.UncheckedIOException;
11	import java.io.Writer;
12	import java.nio.charset.StandardCharsets;
13	import java.nio.file.Path;
14	import java.nio.file.Paths;
15	import java.text.SimpleDateFormat;
16	import java.time.Instant;
17	import java.util.ArrayList;
18	import java.util.Date;
19	import java.util.HashMap;
20	import java.util.List;
21	import java.util.Map;
22	import java.util.Map.Entry;
23	import org.yamcs.AbstractYamcsService;
24	import org.yamcs.InitException;
25	import org.yamcs.YConfiguration;
26	import org.yamcs.YamcsServer;
27	import org.yamcs.api.HttpBody;
28	import org.yamcs.api.Observer;
29	import org.yamcs.archive.ReplayOptions;
30	import org.yamcs.client.Helpers;
31	import org.yamcs.client.YamcsClient;
32	import org.yamcs.client.archive.ArchiveClient;
33	import org.yamcs.http.BadRequestException;
34	import org.yamcs.http.MediaType;
35	import org.yamcs.http.api.ManagementApi;
36	import org.yamcs.http.api.ParameterReplayListener;
37	import org.yamcs.http.api.ReplayFactory;
38	import org.yamcs.mdb.XtceDbFactory;
39	import org.yamcs.parameter.ParameterValueWithId;
40	import org.yamcs.protobuf.Archive.ExportParameterValuesRequest;
41	import org.yamcs.protobuf.Yamcs.NamedObjectId;
42	import org.yamcs.protobuf.Yamcs.ParameterReplayRequest;
43	import org.yamcs.security.ObjectPrivilegeType;
44	import org.yamcs.security.User;
45	import org.yamcs.utils.TimeEncoding;
46	import org.yamcs.xtce.Parameter;
47	import org.yamcs.xtce.XtceDb;
48	import org.yamcs.yarch.FileSystemBucket;
49	import org.yamcs.yarch.YarchDatabase;
50	import org.yamcs.yarch.YarchDatabaseInstance;
51
52	public class CSVExporter extends AbstractYamcsService implements Runnable {	×
53
54	private static class CsvParameterStreamer extends ParameterReplayListener {
55
56	Observer<HttpBody> observer;
57	List<NamedObjectId> ids;
58	boolean addRaw;
59	boolean addMonitoring;
60	int recordCount = 0;	×
61	char columnDelimiter = '\t';	×
62	Instant firstInstant;
63
64	CsvParameterStreamer(
65	Observer<HttpBody> observer,
66	String filename,
67	List<NamedObjectId> ids,
68	boolean addRaw,
69	boolean addMonitoring) {	×
70	this.observer = observer;	×
71	this.ids = ids;	×
72	this.addRaw = addRaw;	×
73	this.addMonitoring = addMonitoring;	×
74
75	HttpBody metadata =
76	HttpBody.newBuilder()	×
77	.setContentType(MediaType.CSV.toString())	×
78	.setFilename(filename)	×
79	.build();	×
80
81	observer.next(metadata);	×
82	}	×
83
84	@Override
85	protected void onParameterData(List<ParameterValueWithId> params) {
86
87	ByteString.Output data = ByteString.newOutput();	×
88	try (Writer writer = new OutputStreamWriter(data, StandardCharsets.UTF_8);	×
89	DeltaCountedParameterFormatter formatter =	×
90	new DeltaCountedParameterFormatter(writer, ids, columnDelimiter)) {
91	if (recordCount == 0) {	×
92	firstInstant =	×
93	Helpers.toInstant(params.get(0).getParameterValue().toGpb().getGenerationTime());	×
94	}
95	formatter.setWriteHeader(recordCount == 0);	×
96	formatter.setPrintRaw(addRaw);	×
97	formatter.setPrintMonitoring(addMonitoring);	×
98	formatter.setFirstInstant(firstInstant);	×
99	formatter.writeParameters(params);	×
100	} catch (IOException e) {	×
101	throw new UncheckedIOException(e);	×
102	}	×
103
104	HttpBody body = HttpBody.newBuilder().setData(data.toByteString()).build();	×
105	observer.next(body);	×
106	recordCount++;	×
107	}	×
108
109	@Override
110	public void replayFailed(Throwable t) {
111	observer.completeExceptionally(t);	×
112	}	×
113
114	@Override
115	public void replayFinished() {
116	observer.complete();	×
117	}	×
118	}
119
120	private YamcsClient yamcsClient;
121	private ArchiveClient archiveClient;
122	private boolean realtime;
123	private Instant start;
124	private Instant stop;
125	private String bucketName;
126	private FileSystemBucket bucket;
127	private Thread thread;
128	private HashMap<String, FileOutputStream> fisMap = new HashMap<String, FileOutputStream>();	×
129	private Path bucketPath;
130	private static final String CSV_NAME_POST_FIX = ".csv";
131	private Map<String, List<String>> paramsMap = null;	×
132
133	@Override
134	public void init(String yamcsInstance, String serviceName, YConfiguration config)
135	throws InitException {
136
137	// realtime =
138	// this.config.getBoolean(
139	// "realtime", false); // might be useful for "always" writing to a CSV file...
140	// start = Instant.parse("2023-09-23T23:00:00.000Z");
141	start = Instant.parse(config.getString("start"));	×
142	// stop = Instant.parse("2023-09-24T00:10:00.000Z");
143	stop = Instant.parse(config.getString("stop"));	×
144
145	/* Read in our configuration parameters. */
146	bucketName = config.getString("bucket");	×
147	paramsMap = config.getMap("params");	×
148
149	// System.out.println("params:" + paramsMap);
150
151	/* Iterate through the bucket names passed to us by the configuration file. We're going to add the buckets
152	* to our internal list so we can process them later. */
153	YarchDatabaseInstance yarch = YarchDatabase.getInstance(YamcsServer.GLOBAL_INSTANCE);	×
154
155	try {
156	bucket = (FileSystemBucket) yarch.getBucket(bucketName);	×
157	} catch (IOException e) {	×
158	e.printStackTrace();	×
159	}	×
160	}	×
161
162	@Override
163	protected void doStart() {
164
165	thread = new Thread(this);	×
166	thread.start();	×
167	notifyStarted();	×
168	}	×
169
170	@Override
171	protected void doStop() {
172	// TODO Auto-generated method stub
173
174	}	×
175
176	private void export(
177	User user, ExportParameterValuesRequest request, Observer<HttpBody> observer) {
178	String instance = ManagementApi.verifyInstance(request.getInstance());	×
179	//
180	ReplayOptions repl = ReplayOptions.getAfapReplay();	×
181	//
182	List<NamedObjectId> ids = new ArrayList<>();	×
183	XtceDb mdb = XtceDbFactory.getInstance(instance);	×
184	String namespace = null;	×
185
186	if (request.hasStart()) {	×
187	repl.setRangeStart(TimeEncoding.fromProtobufTimestamp(request.getStart()));	×
188	}
189	if (request.hasStop()) {	×
190	repl.setRangeStop(TimeEncoding.fromProtobufTimestamp(request.getStop()));	×
191	}
192	// TODO:Get names from conofig/api request
193	for (String id : request.getParametersList()) {	×
194	ids.add(NamedObjectId.newBuilder().setName(id).build());	×
195	}	×
196	if (request.hasNamespace()) {	×
197	namespace = request.getNamespace();	×
198	}
199
200	if (ids.isEmpty()) {	×
201	for (Parameter p : mdb.getParameters()) {	×
202	if (!user.hasObjectPrivilege(ObjectPrivilegeType.ReadParameter, p.getQualifiedName())) {	×
203	continue;	×
204	}
205	if (namespace != null) {	×
206	String alias = p.getAlias(namespace);	×
207	if (alias != null) {	×
208	ids.add(NamedObjectId.newBuilder().setNamespace(namespace).setName(alias).build());	×
209	}
210	} else {	×
211	ids.add(NamedObjectId.newBuilder().setName(p.getQualifiedName()).build());	×
212	}
213	}	×
214	}
215	repl.setParameterRequest(ParameterReplayRequest.newBuilder().addAllNameFilter(ids).build());	×
216
217	String filename;
218	String dateString = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss").format(new Date());	×
219	if (ids.size() == 1) {	×
220	NamedObjectId id = ids.get(0);	×
221	String parameterName = id.hasNamespace() ? id.getName() : id.getName().substring(1);	×
222	filename = parameterName.replace('/', '_') + "_export_" + dateString + ".csv";	×
223	} else {	×
224	filename = "parameter_export_" + dateString + ".csv";	×
225	}
226
227	boolean addRaw = false;	×
228	boolean addMonitoring = false;	×
229	for (String extra : request.getExtraList()) {	×
230	if (extra.equals("raw")) {	×
231	addRaw = true;	×
232	} else if (extra.equals("monitoring")) {	×
233	addMonitoring = true;	×
234	} else {
235	throw new BadRequestException("Unexpected option for parameter 'extra': " + extra);	×
236	}
237	}	×
238	CsvParameterStreamer l =	×
239	new CsvParameterStreamer(observer, filename, ids, addRaw, addMonitoring);
240	if (request.hasDelimiter()) {	×
241	switch (request.getDelimiter()) {	×
242	case "TAB":
243	l.columnDelimiter = '\t';	×
244	break;	×
245	case "SEMICOLON":
246	l.columnDelimiter = ';';	×
247	break;	×
248	case "COMMA":
249	l.columnDelimiter = ',';	×
250	break;	×
251	default:
252	throw new BadRequestException("Unexpected column delimiter");	×
253	}
254	}
255	// observer.setCancelHandler(l::requestReplayAbortion);
256	ReplayFactory.replay(instance, user, repl, l);	×
257	}	×
258
259	@Override
260	public void run() {
261	exportPV();	×
262	}	×
263
264	private void exportPV() {
265
266	for (Entry<String, List<String>> params : paramsMap.entrySet()) {	×
267	ArrayList<String> parameters = new ArrayList<String>();	×
268	// String[] nameTokens = param.split("/");
269
270	FileOutputStream fis = openFile(getNewFilePath(params.getKey()).toAbsolutePath().toString());	×
271	fisMap.put(getNewFilePath(params.getKey()).toAbsolutePath().toString(), fis);	×
272	for (String param : params.getValue()) {	×
273	// String p = "/cfs/ppd/apps/to/TO_HK_TLM_MID.ChannelInfo[0].MessagesSent";
274	parameters.add(param);	×
275	}	×
276	this.export(	×
277	YamcsServer.getServer().getSecurityStore().getDirectory().getUser("admin"),	×
278	ExportParameterValuesRequest.newBuilder()	×
279	.addAllParameters(parameters)	×
280	.setStart(	×
281	Timestamp.newBuilder()	×
282	.setNanos(start.getNano())	×
283	.setSeconds(start.getEpochSecond())	×
284	.build())	×
285	.setStop(	×
286	Timestamp.newBuilder()	×
287	.setNanos(stop.getNano())	×
288	.setSeconds(stop.getEpochSecond())	×
289	.build())	×
290	.setInstance("fsw")	×
291	.build(),	×
292	new Observer<HttpBody>() {	×
293
294	@Override
295	public void next(HttpBody message) {
296	// // TODO Auto-generated method stub
297	writeToCSV(	×
298	message.getData().toByteArray(),	×
299	getNewFilePath(params.getKey()).toAbsolutePath().toString());	×
300	}	×
301
302	@Override
303	public void completeExceptionally(Throwable t) {
304	// TODO Auto-generated method stub
305
306	}	×
307
308	@Override
309	public void complete() {
310	// TODO Auto-generated method stub
311	closeFile(fis);	×
312	}	×
313	});
314	}	×
315	}	×
316
317	private void writeToCSV(byte[] data, String path) {
318
319	writeToFile(data, fisMap.get(path));	×
320	}	×
321
322	private void writeToFile(byte[] data, FileOutputStream fis) {
323	try {
324	fis.write(data, 0, data.length);	×
325	} catch (IOException e) {	×
326	// TODO Auto-generated catch block
327	e.printStackTrace();	×
328	}	×
329	}	×
330
331	private void closeFile(FileOutputStream fis) {
332	try {
333	fis.close();	×
334	} catch (IOException e) {	×
335	// TODO Auto-generated catch block
336	e.printStackTrace();	×
337	}	×
338	}	×
339
340	private FileOutputStream openFile(String path) {
341	File inputFile = new File(path);	×
342	FileOutputStream fis = null;	×
343	try {
344	fis = new FileOutputStream(inputFile);	×
345	} catch (FileNotFoundException e) {	×
346	// TODO Auto-generated catch block
347	e.printStackTrace();	×
348	}	×
349	return fis;	×
350	}
351
352	private Path getNewFilePath(String name) {
353	bucketPath = Paths.get(bucket.getBucketRoot().toString()).toAbsolutePath();	×
354	Path filePath = bucketPath.resolve(name + "_" + CSV_NAME_POST_FIX);	×
355
356	return filePath;	×
357	}
358	}

WindhoverLabs / yamcs-cfs / #126

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous