git.useribm.hu - mediacube.git/blob

   1 package user.jobengine.server.steps;\r
   2 \r
   3 import java.io.OutputStream;\r
   4 import java.net.InetAddress;\r
   5 import java.net.URI;\r
   6 import java.text.ParseException;\r
   7 import java.text.SimpleDateFormat;\r
   8 import java.util.Calendar;\r
   9 import java.util.Date;\r
  10 import java.util.List;\r
  11 import java.util.TimeZone;\r
  12 \r
  13 import org.apache.commons.lang.StringUtils;\r
  14 import org.apache.commons.net.ftp.FTP;\r
  15 import org.apache.commons.net.ftp.FTPClient;\r
  16 import org.apache.commons.net.ftp.FTPReply;\r
  17 import org.apache.logging.log4j.LogManager;\r
  18 import org.apache.logging.log4j.Logger;\r
  19 import org.apache.logging.log4j.Marker;\r
  20 \r
  21 import com.ibm.nosql.json.api.BasicDBList;\r
  22 import com.ibm.nosql.json.api.BasicDBObject;\r
  23 import com.ibm.nosql.json.api.DB;\r
  24 import com.ibm.nosql.json.api.DBCollection;\r
  25 import com.ibm.nosql.json.api.DBCursor;\r
  26 import com.ibm.nosql.json.api.DBObject;\r
  27 import com.ibm.nosql.json.api.QueryBuilder;\r
  28 \r
  29 import user.commons.CalendarUtils;\r
  30 import user.commons.ListUtils;\r
  31 import user.commons.StoreUri;\r
  32 import user.commons.nosql.NoSQLUtils;\r
  33 import user.commons.octopus.IOctopusAPI;\r
  34 import user.commons.octopus.OctopusAPI;\r
  35 import user.commons.remotestore.FtpDirectoryLister;\r
  36 import user.commons.remotestore.RemoteStoreProtocol;\r
  37 import user.jobengine.db.IItemManager;\r
  38 import user.jobengine.server.IJobEngine;\r
  39 import user.jobengine.server.IJobRuntime;\r
  40 \r
  41 public class CopyForArchiveNEXIORecordingsStep extends JobStep {\r
  42         private static final String MEDIATYPE = "Visszarögzített";\r
  43         private static final String SCHEDULED_FORMAT = "yyyy.MM.dd HH:mm";\r
  44         private static final String STARTTIME_FORMAT = "HHmm";\r
  45         private static final String RUNDOWNDATE_FORMAT = "yyyyMMdd";\r
  46         private static final Logger logger = LogManager.getLogger();\r
  47         private static final String UTF_8 = "utf-8";\r
  48         private static final String JSON_EXT = ".json";\r
  49         private static final String XML_EXT = ".xml";\r
  50         private static final String DURATION = "duration";\r
  51         private static final String MXFEXT = ".MXF";\r
  52         private static final String NEXIOCLIPS = "nexioclips";\r
  53         private static final String LONGNAMEID = "longnameid";\r
  54         private static final String EXTAGENCY = "extagency";\r
  55         private static final String RECORDDATE = "recorddate";\r
  56         private static final SimpleDateFormat startTimeformat = new SimpleDateFormat(STARTTIME_FORMAT);\r
  57         private static final SimpleDateFormat rundownDateformat = new SimpleDateFormat(RUNDOWNDATE_FORMAT);\r
  58 \r
  59         private OctopusAPI octopusAPI;\r
  60         private IItemManager manager;\r
  61 \r
  62         private DB db;\r
  63         private FTPClient sourceFtp;\r
  64         private FTPClient targetFtp;\r
  65         private StoreUri sourceUri;\r
  66         private StoreUri targetUri;\r
  67         private int nexioKillDateDays;\r
  68         private String nexioAgency;\r
  69         private Object[] filterAgencies;\r
  70         private Marker systemMarker;\r
  71 \r
  72         private int check(int value, String name) {\r
  73                 if (value == 0) {\r
  74                         logger.error(systemMarker, "A folyamat '{}' bemeneti paramétere 0.", name);\r
  75                         throw new NullPointerException(String.format("System is not configured properly, missing '%s' input parameter.", name));\r
  76                 }\r
  77                 return value;\r
  78         }\r
  79 \r
  80         private String check(String value, String name) {\r
  81                 if (StringUtils.isBlank(value)) {\r
  82                         logger.error(systemMarker, "A folyamat '{}' bemeneti paramétere üres.", name);\r
  83                         throw new NullPointerException(String.format("System is not configured properly, missing '%s' input parameter.", name));\r
  84                 }\r
  85                 return value;\r
  86         }\r
  87 \r
  88         private void copy(RundownArchive rundownArchive) {\r
  89                 for (StoryArchive storyArchive : rundownArchive.getStoryArchives()) {\r
  90                         for (FileArchive fileArchive : storyArchive.getFileArchives()) {\r
  91                                 try {\r
  92                                         copyFile(fileArchive, rundownArchive, storyArchive);\r
  93                                         logger.info(systemMarker, "Sikeres fájl archiválás a '{}' tükörhöz: '{}'.", rundownArchive.getItemTitle(), fileArchive.getFileName());\r
  94                                 } catch (Exception e) {\r
  95                                         logger.error(systemMarker, "Az '{}' fájl archiválása sikertelen. A rendszer üzenete: {}", fileArchive.getFileName(), e.getMessage());\r
  96                                 }\r
  97                         }\r
  98                 }\r
  99         }\r
 100 \r
 101         private void copyFile(FileArchive fileArchive, RundownArchive rundownArchive, StoryArchive storyArchive) throws Exception {\r
 102                 String sourceFileName = fileArchive.getFileName();\r
 103                 String targetFileName = getTargetFileName(rundownArchive, sourceFileName);\r
 104                 transferFile(sourceFileName, targetFileName);\r
 105                 BasicDBObject metadata = createMetadata(rundownArchive, storyArchive, fileArchive);\r
 106                 transferMetadata(targetFileName, metadata);\r
 107                 createSourceKillDateFile(rundownArchive, sourceFileName);\r
 108         }\r
 109 \r
 110         private BasicDBObject createMetadata(RundownArchive rundownArchive, StoryArchive storyArchive, FileArchive fileArchive) {\r
 111                 BasicDBObject result = new BasicDBObject();\r
 112                 result.put("itemHouseId", rundownArchive.getItemHouseId());\r
 113                 result.put("itemTitle", rundownArchive.getItemTitle());\r
 114                 result.put("itemDescription", rundownArchive.getItemDesc());\r
 115                 result.put("userName", "mediacube");\r
 116 \r
 117                 result.put("mediaHouseId", storyArchive.getMediaHouseId());\r
 118                 result.put("mediaTitle", storyArchive.getMediaTitle());\r
 119                 result.put("mediaDescription", storyArchive.getMediaDesc());\r
 120 \r
 121                 result.put("duration", fileArchive.getDuration());\r
 122                 result.put("mediaType", MEDIATYPE);\r
 123                 return result;\r
 124         }\r
 125 \r
 126         private void createSourceKillDateFile(RundownArchive rundownArchive, String fileName) throws Exception {\r
 127                 logger.info("Create killdate/agency for {}", fileName);\r
 128                 OutputStream outStream = null;\r
 129                 try {\r
 130                         sourceFtp = ((FtpDirectoryLister) sourceUri.getLister()).connect();\r
 131                         Calendar killDate = CalendarUtils.createCalendar(rundownArchive.getScheduleDate());\r
 132                         killDate.add(Calendar.DAY_OF_YEAR, nexioKillDateDays);\r
 133                         byte[] killDateFile = EscortFiles.createNEXIOKillDateFile(fileName, killDate.getTime(), null, nexioAgency);\r
 134                         outStream = sourceFtp.storeFileStream(fileName + XML_EXT);\r
 135                         if (outStream == null) {\r
 136                                 throw new NullPointerException("Can not open: " + fileName + XML_EXT + " Reply:" + sourceFtp.getReplyString());\r
 137                         }\r
 138                         outStream.write(killDateFile);\r
 139                         outStream.flush();\r
 140                 } catch (Exception e) {\r
 141                         logger.catching(e);\r
 142                         throw e;\r
 143                 } finally {\r
 144                         if (outStream != null)\r
 145                                 outStream.close();\r
 146                         sourceUri.cleanUp();\r
 147                 }\r
 148         }\r
 149 \r
 150         @StepEntry\r
 151         public Object[] execute(int nexioPort, String nexioUserName, String nexioPassword, String archiveFtp, String archiveUserName, String archivePassword,\r
 152                         String filterAgencies, int limit, int nexioKillDateDays, String targetAgency, IJobEngine jobEngine, IJobRuntime jobRuntime) throws Exception {\r
 153                 systemMarker = jobRuntime.getMarker();\r
 154                 setAndCheck(nexioPort, nexioUserName, nexioPassword, archiveFtp, archiveUserName, archivePassword, filterAgencies, limit, nexioKillDateDays,\r
 155                                 targetAgency, jobEngine);\r
 156                 octopusAPI = new OctopusAPI();\r
 157                 List<BasicDBObject> clips = queryClips();\r
 158                 processClips(clips, limit);\r
 159                 return null;\r
 160         }\r
 161 \r
 162         private Date getScheduledStart(String clipName, Date recordDate) {\r
 163                 if (StringUtils.isBlank(clipName)) {\r
 164                         logger.warn(systemMarker, "A fájlnak nincs neve, ezért nem archiválható.");\r
 165                         return null;\r
 166                 }\r
 167                 if (recordDate == null) {\r
 168                         logger.warn(systemMarker, "Az '{}' fájl rögzítésének ideje nem meghatározható, ezért nem archiválható.", clipName);\r
 169                         return null;\r
 170                 }\r
 171 \r
 172                 Date timePart = null;\r
 173                 try {\r
 174                         String clipNameTime = clipName.split("_")[0];\r
 175                         timePart = startTimeformat.parse(clipNameTime);\r
 176                 } catch (ParseException e) {\r
 177                         logger.warn(systemMarker, "A '{}' fájl neve nem időbélyeggel kezdődik, ezért nem archiválható.", clipName);\r
 178                         return null;\r
 179                 }\r
 180                 Calendar dateCal = CalendarUtils.createCalendar(recordDate);\r
 181                 dateCal.setTimeZone(TimeZone.getTimeZone("Europe/Budapest"));\r
 182                 Calendar wholeCal = CalendarUtils.createCalendar(CalendarUtils.createCalendar(recordDate), timePart);\r
 183                 wholeCal.setTimeZone(TimeZone.getTimeZone("Europe/Budapest"));\r
 184                 return wholeCal.getTime();\r
 185         }\r
 186 \r
 187         private String getTargetFileName(RundownArchive rundownArchive, String sourceFileName) {\r
 188                 String date = rundownDateformat.format(rundownArchive.getScheduleDate());\r
 189                 return String.format("%s-%s%s", date, sourceFileName, MXFEXT);\r
 190         }\r
 191 \r
 192         private RundownArchive processClip(BasicDBObject clip) {\r
 193                 RundownArchive result = null;\r
 194                 String clipName = NoSQLUtils.asString(clip, LONGNAMEID);\r
 195                 Date recordDate = clip.getDate(RECORDDATE);\r
 196                 long duration = NoSQLUtils.asLong(clip, DURATION);\r
 197                 logger.info("Processing {} {}", clipName, recordDate);\r
 198                 Date scheduledStart = getScheduledStart(clipName, recordDate);\r
 199                 if (scheduledStart == null)\r
 200                         return null;\r
 201                 DBObject rundown = octopusAPI.getRundown(scheduledStart);\r
 202                 if (rundown == null) {\r
 203                         logger.error(systemMarker, "A '{}' anyaghoz nem található tükör '{}' kezdéssel, ezért nem archiválható.", clipName, scheduledStart);\r
 204                         return null;\r
 205                 }\r
 206 \r
 207                 try {\r
 208                         result = processRundow(rundown, clipName, duration);\r
 209                 } catch (Exception e) {\r
 210                         logger.catching(e);\r
 211                         logger.error(systemMarker, "A '{}' anyag metaadatainak transzformálása sikertelen, ezért az nem archiválható. A rendszer hibaüzenete: {}",\r
 212                                         e.getMessage());\r
 213                         return null;\r
 214                 }\r
 215 \r
 216                 if (clipName.startsWith("1900_")) {\r
 217                         String clipNameNext = clipName.replace("1900_", "1908_");\r
 218                         scheduledStart = getScheduledStart(clipNameNext, recordDate);\r
 219                         rundown = octopusAPI.getRundown(scheduledStart);\r
 220                         if (rundown == null) {\r
 221                                 Calendar calendar = CalendarUtils.createCalendar(scheduledStart);\r
 222                                 int dow = calendar.get(Calendar.DAY_OF_WEEK);\r
 223                                 if (dow == Calendar.SATURDAY || dow == Calendar.SUNDAY) {\r
 224                                         logger.info(systemMarker, "A '{}' anyaghoz nem található tükör '{}' kezdéssel, de a hétvégi kivétel miatt archiválható.", clipName,\r
 225                                                         scheduledStart);\r
 226                                         return result;\r
 227                                 } else {\r
 228                                         logger.error(systemMarker, "A '{}' anyaghoz nem található tükör '{}' kezdéssel, ezért nem archiválható.", clipName, scheduledStart);\r
 229                                         return null;\r
 230                                 }\r
 231                         }\r
 232 \r
 233                         RundownArchive item2 = null;\r
 234 \r
 235                         try {\r
 236                                 item2 = processRundow(rundown, clipName, duration);\r
 237                         } catch (Exception e) {\r
 238                                 logger.catching(e);\r
 239                                 logger.error(systemMarker, "A '{}' anyag metaadatainak transzformálása sikertelen, ezért az nem archiválható. A rendszer hibaüzenete: {}",\r
 240                                                 e.getMessage());\r
 241                                 return null;\r
 242                         }\r
 243 \r
 244                         result.setItemTitle(result.getItemTitle() + " + NAPIAKT");\r
 245                         StoryArchive storyArchive = result.getStoryArchives().get(0);\r
 246                         StoryArchive storyArchive2 = item2.getStoryArchives().get(0);\r
 247                         storyArchive.setMediaDesc(storyArchive.getMediaDesc() + "\r\n\r\n****** NAPIAKT ******\r\n\r\n" + storyArchive2.getMediaDesc());\r
 248                 }\r
 249 \r
 250                 return result;\r
 251         }\r
 252 \r
 253         private void processClips(List<BasicDBObject> clips, int limit) {\r
 254                 logger.info(systemMarker, "A folyamat {} archiválható anyagot érzékelt.", clips.size());\r
 255                 int current = 0;\r
 256                 for (BasicDBObject clip : clips) {\r
 257                         RundownArchive rundownArchive = processClip(clip);\r
 258                         if (rundownArchive == null)\r
 259                                 continue;\r
 260 \r
 261                         copy(rundownArchive);\r
 262 \r
 263                         current++;\r
 264                         if (current == limit)\r
 265                                 break;\r
 266                         setProgress(current * 100 / limit);\r
 267                 }\r
 268         }\r
 269 \r
 270         private RundownArchive processRundow(DBObject r, String clipName, long duration) throws Exception {\r
 271                 BasicDBObject rundown = (BasicDBObject) r;\r
 272                 long rundownID = rundown.getLong(IOctopusAPI.ID);\r
 273                 logger.info("Processing rundown {} {}", rundownID, rundown.getString(IOctopusAPI.NAME));\r
 274 \r
 275                 List<DBObject> stories = octopusAPI.getRundownFullStories(rundownID);\r
 276                 if (stories == null)\r
 277                         return null;\r
 278                 RundownArchive result = new RundownArchive();\r
 279 \r
 280                 String name = NoSQLUtils.asString(NoSQLUtils.asDBObject(rundown, IOctopusAPI.RUNDOWN_TYPE), IOctopusAPI.NAME);\r
 281                 if (StringUtils.isBlank(name))\r
 282                         return null;\r
 283                 String channel = NoSQLUtils.asString(NoSQLUtils.asDBObject(rundown, IOctopusAPI.CHANNEL), IOctopusAPI.NAME);\r
 284                 Date scheduledStart = rundown.getDate(IOctopusAPI.SCHEDULED_START);\r
 285                 if (scheduledStart == null)\r
 286                         return null;\r
 287                 String start = CalendarUtils.toString(CalendarUtils.createCalendar(scheduledStart), SCHEDULED_FORMAT);\r
 288                 result.setScheduleDate(scheduledStart);\r
 289                 result.setItemHouseId(String.valueOf(rundownID));\r
 290                 result.setItemTitle(String.format("%s %s %s", start, name, channel));\r
 291 \r
 292                 //              StringBuilder sb = new StringBuilder();\r
 293                 //              for (DBObject s : stories) {\r
 294                 //                      BasicDBObject story = (BasicDBObject) s;\r
 295                 //                      sb.append(story.getString(IOctopusAPI.PARENT_STORY_ID));\r
 296                 //                      sb.append(" [" + story.getString(IOctopusAPI.FORMAT) + "] ");\r
 297                 //                      sb.append(story.getString(IOctopusAPI.NAME));\r
 298                 //                      sb.append("\r\n");\r
 299                 //              }\r
 300 \r
 301                 StringBuilder sb = new StringBuilder();\r
 302                 for (DBObject s : stories) {\r
 303                         BasicDBObject story = (BasicDBObject) s;\r
 304 \r
 305                         sb.append("*** ");\r
 306                         sb.append(story.getString(IOctopusAPI.PARENT_STORY_ID));\r
 307                         sb.append(" [" + story.getString(IOctopusAPI.FORMAT) + "] ");\r
 308                         sb.append(story.getString(IOctopusAPI.NAME));\r
 309                         sb.append(" ***");\r
 310                         sb.append("\r\n");\r
 311                         String content = story.getString(IOctopusAPI.SCRIPT_CONTENT);\r
 312                         if (content != null) {\r
 313                                 content = content.replace("\r\n\r\n\r\n\r\n", "\r\n");\r
 314                                 content = content.replace("\r\n\r\n\r\n", "\r\n");\r
 315                                 content = content.replace("\r\n\r\n", "\r\n");\r
 316                                 sb.append(content);\r
 317                                 sb.append("\r\n");\r
 318                         }\r
 319                 }\r
 320 \r
 321                 StoryArchive storyArchive = new StoryArchive();\r
 322                 storyArchive.setMediaHouseId(result.getItemHouseId());\r
 323                 storyArchive.setMediaTitle(clipName);\r
 324                 storyArchive.setMediaDesc(sb.toString());\r
 325                 result.addStoryArchive(storyArchive);\r
 326                 storyArchive.addFileArchive(new FileArchive(clipName, duration));\r
 327                 return result;\r
 328         }\r
 329 \r
 330         private List<BasicDBObject> queryClips() {\r
 331                 DBCollection collection = db.getCollection(NEXIOCLIPS);\r
 332                 BasicDBList agencies = new BasicDBList(filterAgencies);\r
 333 \r
 334                 Calendar now = CalendarUtils.createZeroCalendar();\r
 335                 QueryBuilder dateQueryBuilder = QueryBuilder.start(RECORDDATE).lessThan(now.getTime());\r
 336                 QueryBuilder queryBuilder = QueryBuilder.start(EXTAGENCY).in(agencies).and(dateQueryBuilder.get());\r
 337                 DBCursor cursor = collection.find(queryBuilder.get()).sort(RECORDDATE, -1);\r
 338                 if (!cursor.hasNext())\r
 339                         return null;\r
 340                 return ListUtils.cast(cursor.toArray());\r
 341         }\r
 342 \r
 343         private void setAndCheck(int nexioPort, String nexioUserName, String nexioPassword, String archiveFtp, String archiveUserName, String archivePassword,\r
 344                         String agencies, int limit, int nexioKillDateDays, String nexioAgency, IJobEngine jobEngine) throws Exception {\r
 345                 db = NoSQLUtils.getNoSQLDB();\r
 346                 if (db == null) {\r
 347                         logger.error(systemMarker, "Az NoSQL adatkezelő réteg nem elérhető.");\r
 348                         throw new NullPointerException("Internal error, missing NoSQL DB reference.");\r
 349                 }\r
 350 \r
 351                 if (jobEngine == null) {\r
 352                         logger.error(systemMarker, "Az folyamatkezelő réteg nem elérhető.");\r
 353                         throw new NullPointerException("Internal error, missing JobEngine reference.");\r
 354                 }\r
 355                 manager = jobEngine.getItemManager();\r
 356                 if (manager == null) {\r
 357                         logger.error(systemMarker, "Az adatbáziskezelő réteg nem elérhető.");\r
 358                         throw new NullPointerException("Internal error, missing ItemManager reference.");\r
 359                 }\r
 360                 String nexioHost = System.getProperty("nexio.host");\r
 361                 if (StringUtils.isBlank(nexioHost)) {\r
 362                         logger.error(systemMarker, "A 'nexio.host' rendszer paraméter nem található.");\r
 363                         throw new NullPointerException("System is not configured properly, 'jobengine.selenio.address' startup parameter missing.");\r
 364                 }\r
 365                 check(nexioPort, "nexioPort");\r
 366                 check(nexioUserName, "nexioUserName");\r
 367                 check(nexioPassword, "nexioPassword");\r
 368 \r
 369                 check(agencies, "filterAgencies");\r
 370                 filterAgencies = agencies.split(",");\r
 371 \r
 372                 check(limit, "limit");\r
 373 \r
 374                 check(nexioKillDateDays, "nexioKillDateDays");\r
 375                 this.nexioKillDateDays = nexioKillDateDays;\r
 376                 check(nexioAgency, "nexioAgency");\r
 377                 this.nexioAgency = nexioAgency;\r
 378 \r
 379                 sourceUri = manager.createStoreUri(RemoteStoreProtocol.FTP, nexioHost);\r
 380                 sourceUri.setPortNumber(nexioPort);\r
 381                 sourceUri.setUserName(nexioUserName);\r
 382                 sourceUri.setPassword(nexioPassword);\r
 383                 if (sourceUri == null) {\r
 384                         logger.error(systemMarker, "A forrás nem elérhető.");\r
 385                         throw new NullPointerException("Internal error, missing 'sourceUri'.");\r
 386                 }\r
 387 \r
 388                 check(archiveFtp, "archiveFtp");\r
 389                 check(archiveUserName, "archiveUserName");\r
 390                 check(archivePassword, "archivePassword");\r
 391 \r
 392                 targetUri = manager.createStoreUri(new URI(archiveFtp));\r
 393                 targetUri.setUserName(archiveUserName);\r
 394                 targetUri.setPassword(archivePassword);\r
 395                 if (targetUri == null) {\r
 396                         logger.error(systemMarker, "A cél nem elérhető.");\r
 397                         throw new NullPointerException("Internal error, missing 'targetUri'.");\r
 398                 }\r
 399 \r
 400         }\r
 401 \r
 402         private void transferFile(String sourceFileName, String targetFileName) throws Exception {\r
 403                 int reply = 0;\r
 404                 logger.info("Transfer clip {}", sourceFileName);\r
 405                 try {\r
 406                         sourceFtp = ((FtpDirectoryLister) sourceUri.getLister()).connect();\r
 407                         targetFtp = ((FtpDirectoryLister) targetUri.getLister()).connect();\r
 408 \r
 409                         if (!targetFtp.enterRemotePassiveMode())\r
 410                                 throw new Exception("!PASV");\r
 411 \r
 412                         reply = sourceFtp.port(InetAddress.getByName(targetFtp.getPassiveHost()), targetFtp.getPassivePort());\r
 413                         if (!FTPReply.isPositiveCompletion(reply))\r
 414                                 throw new Exception("PORT parancs válasza: " + sourceFtp.getReplyString());\r
 415 \r
 416                         if (!sourceFtp.setFileType(FTP.BINARY_FILE_TYPE))\r
 417                                 throw new Exception("!SOURCE TYPE");\r
 418 \r
 419                         reply = sourceFtp.retr(sourceFileName);\r
 420                         if (!FTPReply.isPositivePreliminary(reply))\r
 421                                 throw new Exception("RETR parancs válasza: " + sourceFtp.getReplyString());\r
 422 \r
 423                         if (!targetFtp.setFileType(FTP.BINARY_FILE_TYPE))\r
 424                                 throw new Exception("!TARGET TYPE");\r
 425 \r
 426                         reply = targetFtp.stor(targetFileName);\r
 427                         if (!FTPReply.isPositivePreliminary(reply))\r
 428                                 throw new Exception("STOR parancs válasza: " + sourceFtp.getReplyString());\r
 429 \r
 430                         while (true) {\r
 431                                 reply = sourceFtp.stat();\r
 432                                 if (!FTPReply.isPositiveCompletion(reply))\r
 433                                         throw new Exception("STAT parancs válasza: " + sourceFtp.getReplyString());\r
 434 \r
 435                                 //logger.info("Status: {}", sourceFtp.getReplyString());\r
 436                                 if (reply == 226) {\r
 437                                         break;\r
 438                                 }\r
 439                                 Thread.sleep(1000);\r
 440                         }\r
 441                 } catch (Exception e) {\r
 442                         logger.catching(e);\r
 443                         throw e;\r
 444                 } finally {\r
 445                         sourceUri.cleanUp();\r
 446                         targetUri.cleanUp();\r
 447                 }\r
 448 \r
 449         }\r
 450 \r
 451         private void transferMetadata(String fileName, BasicDBObject metadata) throws Exception {\r
 452                 logger.info("Transfer metadata {}", fileName);\r
 453                 OutputStream outStream = null;\r
 454                 try {\r
 455                         targetFtp = ((FtpDirectoryLister) targetUri.getLister()).connect();\r
 456                         if (!targetFtp.changeWorkingDirectory(EscortFiles.STATUSFOLDER)) {\r
 457                                 targetFtp.makeDirectory(EscortFiles.STATUSFOLDER);\r
 458                                 if (!targetFtp.changeWorkingDirectory(EscortFiles.STATUSFOLDER))\r
 459                                         throw new Exception("!STATUSFOLDER");\r
 460                         }\r
 461 \r
 462                         outStream = targetFtp.storeFileStream(fileName + JSON_EXT);\r
 463                         if (outStream == null) {\r
 464                                 throw new NullPointerException("Can not open: " + fileName + JSON_EXT + " Reply:" + targetFtp.getReplyString());\r
 465                         }\r
 466                         outStream.write(metadata.toString().getBytes(UTF_8));\r
 467                         outStream.flush();\r
 468                         //targetFtp.changeToParentDirectory();\r
 469                 } catch (Exception e) {\r
 470                         logger.catching(e);\r
 471                         throw e;\r
 472                 } finally {\r
 473                         if (outStream != null)\r
 474                                 outStream.close();\r
 475                         targetUri.cleanUp();\r
 476                 }\r
 477         }\r
 478 \r
 479 }\r