Сообщения без ответов | Активные темы Текущее время: 18 ноя 2017, 04:55



Ответить на тему  [ 1 сообщение ] 
Будьте так любезны, помогите разобраться с проблемой. 
Автор Сообщение
Новичок

Зарегистрирован: 16 окт 2017, 13:16
Сообщения: 1
Сообщение Будьте так любезны, помогите разобраться с проблемой.
Будьте так любезны, помогите разобраться с проблемой.

Пытаюсь организовать работу с XML документами, которые лежат на FTP сервере.
Весь код модуля огромный, проблемная часть кода заключается в следующей функции.
При использование fileStream.open(file, FileMode.WRITE), выскакивает ошибка


Error: Error #3013: File or directory is in use.
at flash.filesystem::FileStream/open()
at visionlore::SmartFTP/download()[C:\Users\Admin\Desktop\Project\visionlore\SmartFTP.as:314]


  1.  
  2. public function download(localPath:String, ftpPath:String):void
  3. {
  4.    if (connected && _busy == false)
  5.    {
  6.       var file:File = new File(localPath);
  7.       if (ftpPath.length)
  8.       {
  9.          _busy = true;
  10.          _task = 'download';
  11.          _path = ftpPath;
  12.          fileStream.open(file, FileMode.WRITE);
  13.          cmdSocket.writeUTFBytes('TYPE I\n');
  14.          cmdSocket.writeUTFBytes('PASV \n');
  15.          cmdSocket.flush();
  16.       }
  17.       else
  18.       {
  19.          addError("Incorrect URL path");
  20.       }
  21.    }
  22.    else
  23.    {
  24.       addError("Can't download with closed or busy connection");
  25.    }
  26. }
  27.  


Вызывалась данная функция так:

  1.  
  2. trace("Загружаем базу");      
  3. mySmartDispFTP.download("C:/Windows/Temp/test_base.xml","db/test_base.xml");
  4. trace(" --- LOAD COMPLETE --- ");
  5.  


Перечитал все что мог найти в интернете, из идей было использование таймера. Но где и каким образом не уточнялось.

Притом вероятность появления не постоянная , ошибка может не появиться не разу за 3-4 запуска , а может появиться сразу.
Проект сам собран на AIR и при работе глюков не наблюдалось , но все же хочется разобраться с ошибкой, чтобы их не было и на стадии отладки.
Не знаю на сколько важна следующая информация, но все же укажу:
Операционная система: Windows 7 х64 Максимальная;
Среда разработки: Adobe Flash Professional CS6;

Код класса(Осторожно, порядка 500 строк):
  1.  
  2. package visionlore {
  3.    import flash.events.ProgressEvent;
  4.    import flash.events.Event;
  5.    import flash.events.TimerEvent;
  6.    import flash.net.Socket;
  7.    import flash.events.IOErrorEvent;
  8.    import flash.filesystem.FileStream;
  9.    import flash.filesystem.FileMode;
  10.    import flash.filesystem.File;
  11.    import flash.utils.ByteArray;
  12.    import flash.utils.Timer;
  13.  
  14.    public class SmartFTP {
  15.       public static var LOGIN_SUCCESS = 'loginSuccess';
  16.       public static var DOWNLOAD_SUCCESS = 'downloadSuccess';
  17.       public static var UPLOAD_SUCCESS = 'uploadSuccess';
  18.       public static var CONNECTION_CLOSED = 'connectionClosed';
  19.       public static var CONNECTION_TIMEOUT = 'connectionTimeout';
  20.       public static var LOGIN_FAILD = 'loginFaild';
  21.       public static var DIRECTORY_FAILD = 'directoryFaild';
  22.       public static var UPLOAD_STREAM_SUCCESS = 'uploadStreamSuccess';
  23.       public static var STREAM_CLOSED = 'streamClosed';
  24.       public static var ERROR = 'error';
  25.       public static var DIR_LIST_RECEIVED = 'dirListReceived';
  26.       //
  27.       private var _host:String;
  28.       private var _username:String;
  29.       private var _password:String;
  30.       private var _port:int;
  31.       private var _path:String;
  32.       private var _task:String;
  33.       private var _message:Vector.<String>;
  34.       private var _error:Vector.<String>;
  35.       private var _taskList:Vector.<Object>;
  36.       private var _busy:Boolean;
  37.       private var busyChecker:Boolean;
  38.       //
  39.       public var listener:Function;
  40.       //
  41.       private var cmdSocket:Socket;
  42.       private var dataSocket:Socket;
  43.       private var fileStream:FileStream;
  44.       private var streamBuffer:int;
  45.       private var closeStreamTimer:Timer;
  46.       private var uploadAndCloseTimer:Timer;
  47.       private var busyTimeout:Timer;
  48.       private var byteArray:ByteArray;
  49.  
  50.       public function SmartFTP(host:String = null, username:String = null, password:String = null, port:int = 21):void {
  51.          _host = host;
  52.          _username = username;
  53.          _password = password;
  54.          _port = port;
  55.          _task = null;
  56.          _message = new Vector.<String>();
  57.          _error = new Vector.<String>();
  58.          _taskList = new Vector.<Object>();
  59.          //
  60.          closeStreamTimer = new Timer(20, 0);
  61.          closeStreamTimer.addEventListener(TimerEvent.TIMER, closeStreamCheck);
  62.          uploadAndCloseTimer = new Timer(333, 0);
  63.          uploadAndCloseTimer.addEventListener(TimerEvent.TIMER, uploadAndCloseCheck);
  64.          busyTimeout = new Timer(3000, 0);
  65.          busyTimeout.addEventListener(TimerEvent.TIMER, busyCheck);
  66.          //
  67.          fileStream = new FileStream();
  68.          cmdSocket = new Socket();
  69.          cmdSocket.addEventListener(ProgressEvent.SOCKET_DATA, onReceivedSCmd);
  70.          cmdSocket.addEventListener(Event.CONNECT, onConnectSCmd);
  71.          cmdSocket.addEventListener(IOErrorEvent.IO_ERROR, onSocketError);
  72.          cmdSocket.addEventListener(Event.CLOSE, onCloseSCmd);
  73.          dataSocket = new Socket();
  74.          dataSocket.addEventListener(ProgressEvent.SOCKET_DATA, onReceivedSData);
  75.          dataSocket.addEventListener(Event.CONNECT, onConnectSData);
  76.          dataSocket.addEventListener(IOErrorEvent.IO_ERROR, onSocketError);
  77.          dataSocket.addEventListener(Event.CLOSE, onCloseSData);
  78.          if (host && username && password) {
  79.             _busy = true;
  80.             cmdSocket.connect(host, port);
  81.          }
  82.       }
  83.  
  84.       //--------------SOCKET CMD
  85.       //Handle codes received from server
  86.       private function onReceivedSCmd(e:ProgressEvent):void {
  87.          var code:String = cmdSocket.readUTFBytes(cmdSocket.bytesAvailable);
  88.          addMsg('Received: ' + code);
  89.          if (code.indexOf('220 ') > -1) { //Send user name
  90.             cmdSocket.writeUTFBytes('USER ' + _username + '\n');
  91.             cmdSocket.flush();
  92.          }
  93.          if (code.indexOf('331 ') > -1) { //Username accepted now send _password
  94.             cmdSocket.writeUTFBytes('PASS ' + _password + '\n');
  95.             cmdSocket.flush();
  96.          }
  97.          if (code.indexOf('230') > -1) { //Passwor accepted
  98.             _busy = false;
  99.             addMsg('LOGIN SUCCESSFUL - CONNECTION OPEN');
  100.             _listener({target: this, code: 230, type: 'loginSuccess', task: _task, msg: code});
  101.             busyTimeout.start();
  102.          }
  103.          if (code.indexOf('421') > -1) { //Transfer timeout
  104.             _busy = false;
  105.             busyChecker = false;
  106.             addMsg('TRANSFER TIMEOUT - CONTROL CONNECTION CLOSED');
  107.             _listener({target: this, code: 421, type: 'connectionTimeout', task: _task, msg: code});
  108.          }
  109.          if (code.indexOf('530') > -1) { //Login faild
  110.             closeData();
  111.             addError('LOGIN FAILED - CONNECTION CLOSED');
  112.             _listener({target: this, code: 530, type: 'loginFaild', task: _task, msg: code});
  113.             _listener({target: this, code: 530, type: 'streamClosed', task: _task, msg: code});
  114.          }
  115.          if (code.indexOf('550') > -1) { //Wrong directory
  116.             closeData();
  117.             addError('WRONG DIRECTORY');
  118.             _listener({target: this, code: 550, type: 'directoryFaild', task: _task, msg: code});
  119.             _listener({target: this, code: 550, type: 'streamClosed', task: _task, msg: code});
  120.          }
  121.          var index:int = code.indexOf('227');
  122.          if (index > -1) { //Entering passive mode
  123.             //Passive mode message example: 227 Entering Passive Mode (288,120,88,233,161,214)
  124.             //And interpretation: IP is 288.120.88.233, and PORT is 161*256+214 = 41430
  125.             var st:int = code.indexOf('(', index);
  126.             var en:int = code.indexOf(')', index);
  127.             var str:String = code.substring(st + 1, en);
  128.             var ar:Array = str.split(',');
  129.             var p1:int = int(ar.pop());
  130.             var p2:int = int(ar.pop());
  131.             _host = ar.join('.');
  132.             _port = (p2 * 256) + (p1 * 1);
  133.             _busy = true;
  134.             dataSocket.connect(_host, _port);
  135.          }
  136.          if (code.indexOf('226 ') > -1) { //Requested file action successful (download/upload/abort)
  137.             //Forece disconnect socket cmd after action if you want
  138.             //cmdSocket.writeUTFBytes("QUIT \n");
  139.             //cmdSocket.flush();
  140.             if (_task == 'download') {
  141.                addMsg('DOWNLOAD COMPLETE');
  142.                _listener({target: this, code: 226, type: 'downloadSuccess', task: _task, msg: code});
  143.             }
  144.             if (_task == 'upload') {
  145.                addMsg('UPLOAD COMPLETE');
  146.                _listener({target: this, code: 226, type: 'uploadSuccess', task: _task, msg: code});
  147.             }
  148.             closeStreamTimer.start(); //Close stream if data socket connection is closed
  149.          }
  150.          if (code.indexOf('221 ') > -1) { //Service closing control connection
  151.             _busy = false;
  152.             addMsg('CONTROL CONNECTION CLOSED');
  153.             _listener({target: this, code: 221, type: 'connectionClosed', task: _task, msg: code});
  154.          }
  155.          if (code.indexOf('150 ') > -1) { //Ready for data connection after we send 'PASV' command
  156.             if (_task == 'upload') {
  157.                _busy = true;
  158.                uploadAndCloseTimer.start();
  159.             } else if (_task == 'download') {
  160.                _busy = true;
  161.             } else {
  162.                _busy = false;
  163.             }
  164.          }
  165.       }
  166.  
  167.       private function onConnectSCmd(e:Event):void {
  168.          addMsg('CONNECTED TO FTP');
  169.       }
  170.  
  171.       private function onCloseSCmd(e:Event):void {
  172.          addMsg('COMMAND CHANELL CLOSED');
  173.       }
  174.  
  175.       //Used by Socket Cmd
  176.  
  177.       private function closeStreamCheck(e:TimerEvent):void { //Keep connection until data is written (connection is open)
  178.          if (!dataSocket.connected) {
  179.             fileStream.close()
  180.             closeStreamTimer.stop();
  181.             _busy = false;
  182.             addMsg('UPLOAD STREAM SUCCESS');
  183.             var code:String = dataSocket.readUTFBytes(dataSocket.bytesAvailable);
  184.             _listener({target: this, code: null, type: 'uploadStreamSuccess', task: _task, msg: code});
  185.             _listener({target: this, code: null, type: 'streamClosed', task: _task, msg: code});
  186.          }
  187.       }
  188.  
  189.       private function uploadAndCloseCheck(e:TimerEvent):void {
  190.          if (fileStream.bytesAvailable <= 0) {
  191.             uploadAndCloseTimer.stop();
  192.             dataSocket.close();
  193.          } else { //if something gets wrong and after first try there is still data available
  194.             if (fileStream.bytesAvailable < streamBuffer) { //avoid problems - make sure there is always lower buffer on
  195.                streamBuffer = fileStream.bytesAvailable;
  196.             }
  197.             byteArray = new ByteArray();
  198.             //Non async stream
  199.             fileStream.readBytes(byteArray, 0, streamBuffer); //load fileStream data to byteArray
  200.             dataSocket.writeBytes(byteArray, 0, byteArray.bytesAvailable); //save byteArray via data socket
  201.             dataSocket.flush();
  202.          }
  203.       }
  204.  
  205.       //--------------SOCKET DATA
  206.  
  207.       private function onReceivedSData(e:ProgressEvent):void {
  208.          var code:String;
  209.          if (_task == 'dirList') {
  210.             code = dataSocket.readUTFBytes(dataSocket.bytesAvailable);
  211.             addMsg('Received: ' + code);
  212.             _listener({target: this, code: null, type: 'dirListReceived', task: _task, msg: code});
  213.          } else if (_task == 'download') {
  214.             byteArray = new ByteArray();
  215.             dataSocket.readBytes(byteArray, 0, dataSocket.bytesAvailable); //load dataSocket data to byteArray
  216.             fileStream.writeBytes(byteArray, 0, byteArray.bytesAvailable); //save byteArray via file stream
  217.          }
  218.       }
  219.  
  220.       private function onConnectSData(e:Event):void {
  221.          _busy = true;
  222.          addMsg('Connected to DATA port');
  223.          if (_task == 'dirList') {
  224.             //example path: /public_html
  225.             cmdSocket.writeUTFBytes("NLST " + _path + "\n");
  226.          } else if (_task == 'download') {
  227.             //example path: /public_html/oldBanner.jpg
  228.             cmdSocket.writeUTFBytes("RETR " + _path + "\n");
  229.          } else if (_task == 'upload') {
  230.             //example path: /public_html/newBanner.jpg
  231.             cmdSocket.writeUTFBytes("STOR " + _path + "\n");
  232.          }
  233.          cmdSocket.flush();
  234.       }
  235.  
  236.       private function onCloseSData(e:Event):void {
  237.          addMsg('DATA CHANELL CLOSED');
  238.       }
  239.  
  240.       //For both sockets
  241.  
  242.       private function onSocketError(e:IOErrorEvent):void {
  243.          close();
  244.          addMsg(e.errorID + ':' + e.text);
  245.          _busy = false;
  246.          var code:String = dataSocket.readUTFBytes(dataSocket.bytesAvailable);
  247.          _listener({target: this, code: null, type: 'error', task: _task, msg: code});
  248.          _listener({target: this, code: e.errorID, type: 'streamClosed', task: _task, msg: code});
  249.       }
  250.  
  251.       //--------------TRIGGERS
  252.  
  253.       public function upload(localPath:String, ftpPath:String = ''):void {
  254.          if (connected && _busy == false) {
  255.             var file:File = new File(localPath);
  256.             if (file.exists && ftpPath.length) {
  257.                _busy = true;
  258.                _task = 'upload';
  259.                _path = ftpPath;
  260.                fileStream.open(file, FileMode.READ);
  261.                cmdSocket.writeUTFBytes('TYPE I\n'); //set data as binary
  262.                cmdSocket.writeUTFBytes('PASV \n'); //use passive mode
  263.                cmdSocket.flush();
  264.             } else {
  265.                addError("Incorrect URL path");
  266.             }
  267.          } else {
  268.             addError("Can't upload with closed or busy connection");
  269.          }
  270.       }
  271.  
  272.       public function uploadTask(localPath:String, ftpPath:String = ''):void {
  273.          _taskList.push({task: 'upload', localPath: localPath, ftpPath: ftpPath});
  274.       }
  275.  
  276.       public function download(localPath:String, ftpPath:String):void {
  277.          if (connected && _busy == false) {
  278.             var file:File = new File(localPath);
  279.             if (ftpPath.length) {
  280.                _busy = true;
  281.                _task = 'download';
  282.                _path = ftpPath;
  283.                fileStream.close;
  284.                fileStream.open(file, FileMode.WRITE);
  285.                cmdSocket.writeUTFBytes('TYPE I\n');
  286.                cmdSocket.writeUTFBytes('PASV \n');
  287.                cmdSocket.flush();
  288.             } else {
  289.                addError("Incorrect URL path");
  290.             }
  291.          } else {
  292.             addError("Can't download with closed or busy connection");
  293.          }
  294.       }
  295.  
  296.       public function downloadTask(localPath:String, ftpPath:String):void {
  297.          _taskList.push({task: 'download', localPath: localPath, ftpPath: ftpPath});
  298.       }
  299.  
  300.       public function dirListMsg(ftpPath:String):void {
  301.          if (connected && _busy == false) {
  302.             _busy = true;
  303.             _task = 'dirList';
  304.             _path = ftpPath;
  305.             cmdSocket.writeUTFBytes('PASV \n');
  306.             cmdSocket.flush();
  307.          } else {
  308.             addError("Can't get directory list with closed or busy connection");
  309.          }
  310.       }
  311.  
  312.       public function dirListMsgTask(ftpPath:String):void {
  313.          _taskList.push({task: 'dirList', ftpPath: ftpPath});
  314.       }
  315.  
  316.       public function open(host:String = null, username:String = null, password:String = null, port:int = 21):void {
  317.          close();
  318.          _host = host;
  319.          _username = username;
  320.          _password = password;
  321.          _port = port;
  322.          _message.length = 0;
  323.          if (host && username && password) {
  324.             _busy = true;
  325.             cmdSocket.connect(host, port);
  326.          } else {
  327.             addError("Not enough data to open FTP [host, username, password]");
  328.          }
  329.       }
  330.  
  331.       public function close():void {
  332.          uploadAndCloseTimer.stop();
  333.          closeStreamTimer.stop();
  334.          busyTimeout.stop();
  335.          if (cmdSocket.connected) {
  336.             cmdSocket.close();
  337.          }
  338.          fileStream.close();
  339.          if (dataSocket.connected) {
  340.             dataSocket.close();
  341.          }
  342.          busyChecker = false;
  343.          _busy = false;
  344.       }
  345.  
  346.       public function closeStream():void {
  347.          fileStream.close();
  348.       }
  349.  
  350.       public function closeTask():void {
  351.          _taskList.push({task: 'close'});
  352.       }
  353.  
  354.       public function closeData(closeDataTasks:Boolean = true):void {
  355.          uploadAndCloseTimer.stop();
  356.          closeStreamTimer.stop();
  357.          fileStream.close();
  358.          if (dataSocket.connected) {
  359.             dataSocket.close();
  360.          }
  361.          if (closeDataTasks) {
  362.             for (var i:int = 0; i < _taskList.length; i += 1) {
  363.                if (_taskList[i].task == 'upload' || _taskList[i].task == 'download' || _taskList[i].task == 'dirList') {
  364.                   _taskList.splice(i, 1);
  365.                   if (i > 0) {
  366.                      i -= 1;
  367.                   }
  368.                }
  369.             }
  370.          }
  371.          _busy = false;
  372.       }
  373.  
  374.       //--------------MANAGE
  375.  
  376.       private function busyCheck(e:TimerEvent):void {
  377.          if (_busy && busyChecker && dataSocket.connected == false) {
  378.             _busy = false;
  379.             var code:String = dataSocket.readUTFBytes(dataSocket.bytesAvailable);
  380.             _listener({target: this, code: null, type: 'busyCheckDrop', task: _task, msg: code});
  381.          }
  382.          busyChecker = _busy;
  383.          if (!cmdSocket.connected) {
  384.             close();
  385.          }
  386.       }
  387.  
  388.       private function _listener(obj:Object):void {
  389.          trace('BUSY: ' + _busy);
  390.          if (!_busy && _taskList.length > 0) {
  391.             var o:Object = _taskList.shift();
  392.             if (o.task == 'upload') {
  393.                upload(o.localPath, o.ftpPath);
  394.             } else if (o.task == 'download') {
  395.                download(o.localPath, o.ftpPath);
  396.             } else if (o.task == 'dirList') {
  397.                dirListMsg(o.ftpPath);
  398.             } else if (o.task == 'close') {
  399.                _taskList.length = 0;
  400.                close();
  401.             }
  402.          }
  403.          if (listener is Function) {
  404.             listener(obj);
  405.          }
  406.       }
  407.  
  408.       private function addMsg(s:String):void {
  409.          trace('MESSAGE: ' + s);
  410.          if (s.indexOf('\n') > -1) {
  411.             _message.unshift(s);
  412.          } else {
  413.             _message.unshift(s + '\n');
  414.          }
  415.       }
  416.  
  417.       private function addError(s:String):void {
  418.          trace('ERROR: ' + s);
  419.          if (s.indexOf('\n') > -1) {
  420.             _error.unshift(s);
  421.          } else {
  422.             _error.unshift(s + '\n');
  423.          }
  424.       }
  425.  
  426.       public function clearMessage():void {
  427.          _message.length = 0;
  428.       }
  429.  
  430.       public function get message():String {
  431.          return _message.join('');
  432.       }
  433.  
  434.       public function get messageVec():Vector.<String> {
  435.          var v:Vector.<String> = _message.concat();
  436.          return v;
  437.       }
  438.  
  439.       public function clearError():void {
  440.          _error.length = 0;
  441.       }
  442.  
  443.       public function get error():String {
  444.          return _error.join('');
  445.       }
  446.  
  447.       public function get errorVec():Vector.<String> {
  448.          var v:Vector.<String> = _error.concat();
  449.          return v;
  450.       }
  451.  
  452.       public function get taskList():Vector.<Object> {
  453.          return _taskList;
  454.       }
  455.  
  456.       public function get fileData():ByteArray {
  457.          return byteArray;
  458.       }
  459.  
  460.       public function get connected():Boolean {
  461.          return cmdSocket.connected;
  462.       }
  463.  
  464.       public function get connectedData():Boolean {
  465.          return dataSocket.connected;
  466.       }
  467.  
  468.       public function get busy():Boolean {
  469.          return _busy;
  470.       }
  471.  
  472.       public function get host():String {
  473.          return _host;
  474.       }
  475.  
  476.       public function get username():String {
  477.          return _username;
  478.       }
  479.  
  480.       public function get password():String {
  481.          return _password;
  482.       }
  483.  
  484.       public function get port():int {
  485.          return _port;
  486.       }
  487.  
  488.       public function get path():String {
  489.          return _path;
  490.       }
  491.  
  492.       public function get task():String {
  493.          return _task;
  494.       }
  495.    }
  496. }
  497.  


P.S. Я новенький на форуме,и если вдруг создал тему не там или не так, прошу больно ногами не пинайте, а укажите на мои ошибки,
я постараюсь впредь не нарушать и по возможности исправить. Заранее спасибо!


16 окт 2017, 13:37
Профиль ICQ
Показать сообщения за:  Поле сортировки  
Ответить на тему   [ 1 сообщение ] 

Кто сейчас на конференции

Сейчас этот форум просматривают: нет зарегистрированных пользователей и гости: 4


Вы не можете начинать темы
Вы не можете отвечать на сообщения
Вы не можете редактировать свои сообщения
Вы не можете удалять свои сообщения
Вы не можете добавлять вложения

Найти:
Перейти:  
cron