コード例 #1
0
        /// <summary>
        /// Performs a get synchronously
        /// </summary>
        /// <param name="id">The ID of the file to get</param>
        /// <param name="hash">The hash of the files contents</param>
        /// <returns>The result of the get operation</returns>
        public UnityCacheClientGetResult Get(Guid id, string hash)
        {
            UnityCacheClientGetResult result = new UnityCacheClientGetResult();

            result.Id   = id;
            result.Hash = hash;

            byte[] command = Encoding.ASCII.GetBytes("g");
            this.stream.WriteByte(command[0]);

            UnityCacheUtilities.SendIdAndHashOnStream(this.stream, id, hash);

            this.stream.Read(command, 0, command.Length);
            string strResult = Encoding.ASCII.GetString(command);

            if (strResult == "-")
            {
                result.Result = CacheResult.CacheMiss;

                // Read and toss the hash since we don't need it
                UnityCacheUtilities.ReadGuid(this.stream);
                UnityCacheUtilities.ReadHash(this.stream);
            }
            else if (strResult == "+")
            {
                result.Result = CacheResult.CacheHit;

                // Read the length of the file
                byte[] buffer = new byte[16];
                this.stream.Read(buffer, 0, 16);
                ulong bytesToBeRead = UnityCacheUtilities.GetAsciiBytesAsUInt64(buffer);

                // Read the ID and hash.  Toss this, we don't need it
                UnityCacheUtilities.ReadGuid(this.stream);
                UnityCacheUtilities.ReadHash(this.stream);

                // Read the reply from the server
                buffer      = new byte[bytesToBeRead];
                result.Data = buffer;
                int offset = 0;

                while (bytesToBeRead > 0)
                {
                    int   len           = (bytesToBeRead > (ulong)this.streamBlockSize) ? this.streamBlockSize : (int)bytesToBeRead;
                    ulong bytesReturned = (ulong)this.stream.Read(buffer, offset, len);
                    bytesToBeRead -= (ulong)bytesReturned;
                    offset        += (int)bytesReturned;
                }
            }

            return(result);
        }
コード例 #2
0
        /// <summary>
        /// Process the client put request
        /// </summary>
        /// <param name="stream">The stream to the client requesting the put</param>
        private void ProcessPut(NetworkStream stream)
        {
            byte[] buffer = new byte[16];
            stream.Read(buffer, 0, 16);
            ulong bytesToBeRead = UnityCacheUtilities.GetAsciiBytesAsUInt64(buffer);

            // Read ID
            Guid id = UnityCacheUtilities.ReadGuid(stream);

            // Read HASH
            string hash = UnityCacheUtilities.ReadHash(stream);

            logger.Info("PUT: {0} {1}", id, hash);

            FileStream fileStream = this.fileManager.GetTemporaryFile(id, hash);

            buffer = new byte[this.streamBlockSize];

            while (bytesToBeRead > 0)
            {
                int   len           = (bytesToBeRead > (ulong)this.streamBlockSize) ? this.streamBlockSize : (int)bytesToBeRead;
                ulong bytesReturned = (ulong)stream.Read(buffer, 0, len);
                fileStream.Write(buffer, 0, (int)bytesReturned);
                bytesToBeRead -= (ulong)bytesReturned;
            }

            fileStream.Close();

            this.fileManager.CompleteFile(id, hash);

            // Notify listeners a get was processed
            if (this.OnPutProcessed != null)
            {
                this.OnPutProcessed(this, new EventArgs());
            }
        }
コード例 #3
0
        /// <summary>
        /// Processes the get command
        /// </summary>
        /// <param name="stream">The stream to the client</param>
        private void ProcessGet(NetworkStream stream)
        {
            // Read ID
            Guid   id   = UnityCacheUtilities.ReadGuid(stream);
            string hash = UnityCacheUtilities.ReadHash(stream);

            if (!CacheFile.IsFileCached(this.fileManager.Root, id, hash))
            {
                logger.Info("GET: Cache miss. {0} {1}", id, hash);

                // File is not cached
                // Send command it's not cached
                byte[] code = new byte[1];
                code[0] = 45;
                stream.Write(code, 0, 1);

                // Send id and hash
                UnityCacheUtilities.SendIdAndHashOnStream(stream, id, hash);
            }
            else
            {
                logger.Info("GET: Cache hit. {0} {1}", id, hash);

                using (MemoryStream memoryStream = new MemoryStream(49))
                {
                    // File is cached, send the response
                    byte[] code = new byte[1];
                    code[0] = 43;
                    memoryStream.Write(code, 0, 1);

                    // Send the file size in bytes
                    ulong  bytesToBeWritten = CacheFile.GetFileSizeBytes(this.fileManager.Root, id, hash);  // Dumb off by 1 hack
                    byte[] fileSizeBytes    = UnityCacheUtilities.GetUlongAsAsciiBytes(bytesToBeWritten);
                    memoryStream.Write(fileSizeBytes, 0, fileSizeBytes.Length);

                    // Send id and hash
                    UnityCacheUtilities.SendIdAndHashOnStream(memoryStream, id, hash);

                    // Send the file bytes
                    FileStream fileStream = this.fileManager.GetReadFileStream(id, hash);
                    byte[]     buffer     = new byte[this.streamBlockSize];

                    // Workaround to get enough bytes into a single packet so the Unity client doesn't choke
                    byte[] header = memoryStream.GetBuffer();
                    stream.Write(header, 0, header.Length);

                    while (bytesToBeWritten > 0)
                    {
                        int byteCount = (bytesToBeWritten > (ulong)this.streamBlockSize) ? this.streamBlockSize : (int)bytesToBeWritten;
                        fileStream.Read(buffer, 0, byteCount);
                        bytesToBeWritten -= (ulong)byteCount;
                        stream.Write(buffer, 0, byteCount);
                    }

                    fileStream.Close();
                }
            }

            // Notify listeners a get was processed
            if (this.OnGetProcessed != null)
            {
                this.OnGetProcessed(this, new EventArgs());
            }
        }