Ejemplo n.º 1
0
        public void StopTransfer(TransferQueue queue)
        {
            //If we're the uploading transfer, we'll just stop it.
            if (queue.Type == QueueType.Upload)
            {
                queue.Stop();
            }

            PacketWriter pw = new PacketWriter();

            pw.Write((byte)Headers.Stop);
            pw.Write(queue.ID);
            Send(pw.GetBytes());
            //Don't forget to close the queue.
            queue.Close();
        }
Ejemplo n.º 2
0
        private void process()
        {
            PacketReader pr = new PacketReader(_buffer); //Create our packet reader.

            Headers header = (Headers)pr.ReadByte();     //Read and cast our header.

            switch (header)
            {
            case Headers.Queue:
            {
                //Read the ID, Filename and length of the file (For progress) from the packet.
                int    id       = pr.ReadInt32();
                string fileName = pr.ReadString();
                long   length   = pr.ReadInt64();

                //Create our download queue.
                TransferQueue queue = TransferQueue.CreateDownloadQueue(this, id, Path.Combine(OutputFolder,
                                                                                               Path.GetFileName(fileName)), length);

                //Add it to our transfer list.
                _transfers.Add(id, queue);

                //Call queued.
                if (Queued != null)
                {
                    Queued(this, queue);
                }
            }
            break;

            case Headers.Start:
            {
                //Read the ID
                int id = pr.ReadInt32();

                //Start the upload.
                if (_transfers.ContainsKey(id))
                {
                    _transfers[id].Start();
                }
            }
            break;

            case Headers.Stop:
            {
                //Read the ID
                int id = pr.ReadInt32();

                if (_transfers.ContainsKey(id))
                {
                    //Get the queue.
                    TransferQueue queue = _transfers[id];

                    //Stop and close the queue
                    queue.Stop();
                    queue.Close();

                    //Call the stopped event.
                    if (Stopped != null)
                    {
                        Stopped(this, queue);
                    }

                    //Remove the queue
                    _transfers.Remove(id);
                }
            }
            break;

            case Headers.Pause:
            {
                int id = pr.ReadInt32();

                //Pause the upload.
                if (_transfers.ContainsKey(id))
                {
                    _transfers[id].Pause();
                }
            }
            break;

            case Headers.Chunk:
            {
                //Read the ID, index, size and buffer from the packet.
                int    id     = pr.ReadInt32();
                long   index  = pr.ReadInt64();
                int    size   = pr.ReadInt32();
                byte[] buffer = pr.ReadBytes(size);

                //Get the queue.
                TransferQueue queue = _transfers[id];

                //Write the newly transferred bytes to the queue based on the write index.
                queue.Write(buffer, index);

                //Get the progress of the current transfer with the formula
                //(AMOUNT_TRANSFERRED * 100) / COMPLETE SIZE
                queue.Progress = (int)((queue.Transferred * 100) / queue.Length);

                //This will prevent the us from calling progress changed multiple times.

                /* Such as
                 * 2, 2, 2, 2, 2, 2 (Since the actual progress minus the decimals will be the same for a bit
                 * It will be
                 * 1, 2, 3, 4, 5, 6
                 * Instead*/
                if (queue.LastProgress < queue.Progress)
                {
                    queue.LastProgress = queue.Progress;

                    if (ProgressChanged != null)
                    {
                        ProgressChanged(this, queue);
                    }

                    //If the transfer is complete, call the event.
                    if (queue.Progress == 100)
                    {
                        queue.Close();

                        if (Complete != null)
                        {
                            Complete(this, queue);
                        }
                    }
                }
            }
            break;
            }
            pr.Dispose(); //Dispose the reader.
        }
Ejemplo n.º 3
0
        private static void transferProc(object o)
        {
            //Cast our transfer queue from the parameter.
            TransferQueue queue = (TransferQueue)o;

            //If Running is true, the thread will keep going
            //If queue.Index is not the file length, the thread will continue.
            while (queue.Running && queue.Index < queue.Length)
            {
                //We will call WaitOne to see if we're paused or not.
                //If we are, it will block until notified.
                queue.pauseEvent.WaitOne();

                //Just in case the transfer was paused then stopped, check to see if we're still running
                if (!queue.Running)
                {
                    break;
                }

                //Lock the file buffer so only one queue can use it at a time.
                lock (file_buffer)
                {
                    //Set the read position to our current position
                    queue.FS.Position = queue.Index;

                    //Read a chunk into our buffer.
                    int read = queue.FS.Read(file_buffer, 0, file_buffer.Length);

                    //Create our packet writer and send our chunk packet.
                    PacketWriter pw = new PacketWriter();

                    pw.Write((byte)Headers.Chunk);
                    pw.Write(queue.ID);
                    pw.Write(queue.Index);
                    pw.Write(read);
                    pw.Write(file_buffer, 0, read);

                    /*The reason the buffer size is 8175 is so it'll be about 8 kilobytes
                     * It should be 8192, but its 8191. I missed a byte since I had to make a quick change, but eh.
                     * 4 Bytes = ID
                     * 8 Bytes = Index
                     * 4 Bytes = read
                     * 8175 Bytes = file_buffer
                     * All together (If the file buffer is full) 8192 Bytes
                     *
                     */

                    //Increase our data transffered and read index.
                    queue.Transferred += read;
                    queue.Index       += read;

                    //Send our data
                    queue.Client.Send(pw.GetBytes());

                    //Get our progress
                    queue.Progress = (int)((queue.Transferred * 100) / queue.Length);

                    if (queue.LastProgress < queue.Progress)
                    {
                        queue.LastProgress = queue.Progress;

                        queue.Client.callProgressChanged(queue);
                    }

                    //Sleep for a millisecond so we don't kill our CPU
                    Thread.Sleep(1);
                }
            }
            queue.Close(); //Once the loop is broken, close the queue.
        }