public void PushMessages(IEnumerable <CommandMessage> messages)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException(this.GetType().FullName);
            }

            if (_protocolVersion == ProtocolVersion.Version1)
            {
                Stream stream = new BufferStream(_bufferManager);

                try
                {
                    var message = new CommandsMessage();
                    message.CommandMessages.AddRange(messages);

                    stream = new JoinStream(stream, message.Export(_bufferManager));

                    _connection.Send(stream, _sendTimeSpan);
                    _lastSendTime = DateTime.UtcNow;
                }
                catch (ConnectionException)
                {
                    this.OnClose(new EventArgs());
                }
                finally
                {
                    stream.Close();
                }
            }
            else
            {
                throw new ConnectionManagerException();
            }
        }
Exemple #2
0
 public void Unir(string fichero, string dirDest, JoinInfo info)
 {
     byte[] buffer = new byte[Consts.BUFFER_LENGTH];
     int leidos = 0;
     long transferidos = 0;
     OnProgress (0, info.Length);
     Stream fos = UtilidadesFicheros.CreateWriter (dirDest + Path.DirectorySeparatorChar + info.OriginalFile);
     Stream fis = new JoinStream (info);
     while ((leidos = fis.Read(buffer, 0, buffer.Length)) > 0) {
         transferidos += leidos;
         fos.Write (buffer, 0, leidos);
         OnProgress (transferidos, info.Length);
     }
     fis.Close ();
     fos.Close ();
 }
Exemple #3
0
        private static Stream ToStream <T>(ItemBase <T> item)
            where T : ItemBase <T>
        {
            Stream stream = null;

            try
            {
                stream = item.Export(_bufferManager);
                List <KeyValuePair <int, Stream> > list = new List <KeyValuePair <int, Stream> >();

                try
                {
                    BufferStream deflateBufferStream = new BufferStream(_bufferManager);
                    byte[]       compressBuffer      = null;

                    try
                    {
                        compressBuffer = _bufferManager.TakeBuffer(1024 * 1024);

                        using (DeflateStream deflateStream = new DeflateStream(deflateBufferStream, CompressionMode.Compress, true))
                        {
                            int i = -1;

                            while ((i = stream.Read(compressBuffer, 0, compressBuffer.Length)) > 0)
                            {
                                deflateStream.Write(compressBuffer, 0, i);
                            }
                        }
                    }
                    finally
                    {
                        _bufferManager.ReturnBuffer(compressBuffer);
                    }

                    deflateBufferStream.Seek(0, SeekOrigin.Begin);
                    list.Add(new KeyValuePair <int, Stream>(1, deflateBufferStream));
                }
                catch (Exception)
                {
                }

                list.Add(new KeyValuePair <int, Stream>(0, stream));

                list.Sort((x, y) =>
                {
                    return(x.Value.Length.CompareTo(y.Value.Length));
                });

#if DEBUG
                if (list[0].Value.Length != stream.Length)
                {
                    Debug.WriteLine("RosaConverter ToStream : {0}→{1} {2}",
                                    NetworkConverter.ToSizeString(stream.Length),
                                    NetworkConverter.ToSizeString(list[0].Value.Length),
                                    NetworkConverter.ToSizeString(list[0].Value.Length - stream.Length));
                }
#endif

                for (int i = 1; i < list.Count; i++)
                {
                    list[i].Value.Dispose();
                }

                BufferStream headerStream = new BufferStream(_bufferManager);
                headerStream.WriteByte((byte)list[0].Key);

                var dataStream = new JoinStream(headerStream, list[0].Value);

                MemoryStream crcStream = new MemoryStream(Crc32_Castagnoli.ComputeHash(dataStream));
                return(new JoinStream(dataStream, crcStream));
            }
            catch (Exception ex)
            {
                if (stream != null)
                {
                    stream.Dispose();
                }

                throw new ArgumentException(ex.Message, ex);
            }
        }
 public void setSession(int i, AmongSession amongSession)
 {
     Sessions[i] = amongSession;
     ActiveSessions++;
     InputStream[i] = new JoinStream();
 }