public void OnInvalidMessageReceive(object sender, PacketMessage message)
 {
     // stop reciving in case of error
     if (IsReceiving())
     {
         _state = PackageBuilderState.IDLE;
     }
 }
        public void OnFileEndReceive(object sender, EventArgs args)
        {
            // verify current state
            if (_state != PackageBuilderState.RECEIVE_FILE_DATA)
            {
                throw new InvalidOperationException("OnFileHeaderReceive: Invalid internal state - " + _state.ToString());
            }

            if (_currentFileStrem == null)
            {
                throw new InvalidOperationException("OnFileHeaderReceive: File stream is empty!");
            }

            // notify observers
            OnFileReciveEnd();

            // close file and dispose stream
            string fileName = _currentFileStrem.Name;

            _currentFileStrem.Close();
            _currentFileStrem.Dispose();
            _currentFileStrem = null;

            // verify file
            if (_verifyChecksum)
            {
                string reveivedFileChecksum = ComputeFileChecksum(fileName);

                // verify if the check sum is the same as expected
                if (reveivedFileChecksum != _fileChecksum)
                {
                    throw new InvalidOperationException("OnFileHeaderReceive: Invalid checksum - computed(" +
                                                        reveivedFileChecksum + ") expected(" + _fileChecksum + ")");
                }
            }

            // reset rest of variables
            _expectedFileSize = 0;
            _fileChecksum     = String.Empty;

            // check if we expect another file and go to the next state
            _numberOfFilesReceived++;

            if (_numberOfFilesReceived < _numberOfExpectedFiles)
            {
                _state = PackageBuilderState.WAITING_FOR_FILE_BEGIN;
            }
            else
            {
                _state = PackageBuilderState.IDLE;
            }
        }
        public void OnFileHeaderReceive(object sender, XmlMessagePackageDataHeader message)
        {
            // verify current state
            if (_state != PackageBuilderState.WAITING_FOR_HEADER)
            {
                throw new InvalidOperationException("OnFileHeaderReceive: Invalid internal state - " + _state.ToString());
            }

            // do work
            _numberOfExpectedFiles = message.NumberOfFiles;
            _fullPackagePath       = Path.Combine(_currentRepositoryPath, message.RepositoryName, message.PackageName, message.Version);

            if (!Directory.Exists(_fullPackagePath))
            {
                Directory.CreateDirectory(_fullPackagePath);
            }

            // goto next state
            _state = PackageBuilderState.WAITING_FOR_FILE_BEGIN;
        }
        public void OnFileBeginReceive(object sender, XmlMessagePackageFileBegin message)
        {
            // verify current state
            if (_state != PackageBuilderState.WAITING_FOR_FILE_BEGIN)
            {
                throw new InvalidOperationException("OnFileHeaderReceive: Invalid internal state - " + _state.ToString());
            }

            // open file stream  - must be disposed
            string filePath = Path.Combine(_fullPackagePath, message.Name);

            _currentFileStrem = new FileStream(filePath, FileMode.Create);

            _expectedFileSize = message.Size;
            _fileChecksum     = message.Checksum;

            // notify observers
            OnFileReciveBegin();

            // goto next state
            _state = PackageBuilderState.RECEIVE_FILE_DATA;
        }
 public void StartReceiving(string currentRepositoryPath)
 {
     _currentRepositoryPath = currentRepositoryPath;
     _state = PackageBuilderState.WAITING_FOR_HEADER;
 }