Example #1
0
        /// <summary>
        /// Execute the task.
        /// </summary>
        public override bool Execute()
        {
            if (ItemsToHash != null && ItemsToHash.Length > 0)
            {
                using (var sha1 = SHA1.Create())
                {
                    var concatenatedItemStringSize = ComputeStringSize(ItemsToHash);

                    var hashStringSize = sha1.HashSize;

                    using (var stringBuilder = new ReuseableStringBuilder(Math.Max(concatenatedItemStringSize, hashStringSize)))
                    {
                        foreach (var item in ItemsToHash)
                        {
                            stringBuilder.Append(item.ItemSpec);
                            stringBuilder.Append(ItemSeparatorCharacter);
                        }

                        var hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(stringBuilder.ToString()));

                        stringBuilder.Clear();

                        foreach (var b in hash)
                        {
                            stringBuilder.Append(b.ToString("x2"));
                        }

                        HashResult = stringBuilder.ToString();
                    }
                }
            }

            return(true);
        }
Example #2
0
        /// <summary>
        /// Gets a text serialized value of a parameter for logging.
        /// </summary>
        internal static string GetParameterText(string prefix, string parameterName, IList parameterValue)
        {
            if (parameterValue == null || parameterValue.Count == 0)
            {
                return(parameterName);
            }

            using (var sb = new ReuseableStringBuilder())
            {
                sb.Append(prefix);

                bool firstEntryIsTaskItemWithSomeCustomMetadata = false;
                var  firstItem = parameterValue[0] as ITaskItem;
                if (firstItem != null)
                {
                    if (firstItem.CloneCustomMetadata().Count > 0)
                    {
                        firstEntryIsTaskItemWithSomeCustomMetadata = true;
                    }
                }

                // If it's just one entry in the list, and it's not a task item with metadata, keep it on one line like a scalar
                bool specialTreatmentForSingle = (parameterValue.Count == 1 && !firstEntryIsTaskItemWithSomeCustomMetadata);

                if (!specialTreatmentForSingle)
                {
                    sb.Append("\n    ");
                }

                sb.Append(parameterName + "=");

                if (!specialTreatmentForSingle)
                {
                    sb.Append("\n");
                }

                for (int i = 0; i < parameterValue.Count; i++)
                {
                    if (parameterValue[i] == null)
                    {
                        continue;
                    }

                    if (!specialTreatmentForSingle)
                    {
                        sb.Append("        ");
                    }

                    sb.Append(GetStringFromParameterValue(parameterValue[i]));

                    if (!specialTreatmentForSingle && i < parameterValue.Count - 1)
                    {
                        sb.Append("\n");
                    }
                }

                return(sb.ToString());
            }
        }
Example #3
0
        /// <summary>
        /// Gets a text serialized value of a parameter for logging.
        /// </summary>
        internal static string GetParameterText(string prefix, string parameterName, IList parameterValue, bool logItemMetadata = true)
        {
            if (parameterValue == null || parameterValue.Count == 0)
            {
                return(parameterName);
            }

            using (var sb = new ReuseableStringBuilder())
            {
                sb.Append(prefix);

                bool firstEntryIsTaskItemWithSomeCustomMetadata = false;
                var  firstItem = parameterValue[0] as ITaskItem;
                if (firstItem != null)
                {
                    if (firstItem.CloneCustomMetadata().Count > 0)
                    {
                        firstEntryIsTaskItemWithSomeCustomMetadata = true;
                    }
                }

                // If it's just one entry in the list, and it's not a task item with metadata, keep it on one line like a scalar
                bool specialTreatmentForSingle = (parameterValue.Count == 1 && !firstEntryIsTaskItemWithSomeCustomMetadata);

                // If the parameterName is not specified, no need to have an extra indent.
                // Without parameterName:
                //
                // Input files:
                //     a.txt
                //     b.txt
                //
                // With parameterName:
                //
                // Input files:
                //     ParamName=
                //         a.txt
                //         b.txt
                string indent = "        ";
                if (parameterName == null)
                {
                    indent = "    ";
                }

                if (!specialTreatmentForSingle)
                {
                    sb.Append("\n");
                    if (parameterName != null)
                    {
                        sb.Append("    ");
                    }
                }

                if (parameterName != null)
                {
                    sb.Append(parameterName);
                    sb.Append('=');

                    if (!specialTreatmentForSingle)
                    {
                        sb.Append("\n");
                    }
                }

                bool truncateTaskInputs = Traits.Instance.EscapeHatches.TruncateTaskInputs;

                for (int i = 0; i < parameterValue.Count; i++)
                {
                    if (parameterValue[i] == null)
                    {
                        continue;
                    }

                    if (!specialTreatmentForSingle)
                    {
                        sb.Append(indent);
                    }

                    AppendStringFromParameterValue(sb, parameterValue[i], logItemMetadata);

                    if (!specialTreatmentForSingle && i < parameterValue.Count - 1)
                    {
                        sb.Append("\n");
                    }

                    if (truncateTaskInputs && (sb.Length >= parameterCharacterLimit || i > parameterLimit))
                    {
                        sb.Append(ResourceUtilities.GetResourceString("LogTaskInputs.Truncated"));
                        break;
                    }
                }

                return(sb.ToString());
            }
        }
Example #4
0
        private static void AppendStringFromParameterValue(ReuseableStringBuilder sb, object parameterValue, bool logItemMetadata = true)
        {
            if (parameterValue is string text)
            {
                sb.Append(text);
            }
            else if (parameterValue is ITaskItem item)
            {
                sb.Append(item.ItemSpec);

                if (!logItemMetadata)
                {
                    return;
                }

                var customMetadata = item.CloneCustomMetadata();
                int count          = customMetadata.Count;

                if (count > 0)
                {
                    sb.Append('\n');

                    // need to initialize the thread static on each new thread
                    if (keyValuePairList == null)
                    {
                        keyValuePairList = new List <KeyValuePair <string, string> >(count);
                    }

                    if (customMetadata is IDictionary <string, string> customMetadataDictionary)
                    {
                        foreach (KeyValuePair <string, string> kvp in customMetadataDictionary)
                        {
                            keyValuePairList.Add(kvp);
                        }
                    }
                    else
                    {
                        foreach (DictionaryEntry kvp in customMetadata)
                        {
                            keyValuePairList.Add(new KeyValuePair <string, string>((string)kvp.Key, (string)kvp.Value));
                        }
                    }

                    if (count > 1)
                    {
                        keyValuePairList.Sort((l, r) => StringComparer.OrdinalIgnoreCase.Compare(l.Key, r.Key));
                    }

                    for (int i = 0; i < count; i++)
                    {
                        var kvp = keyValuePairList[i];
                        sb.Append("                ");
                        sb.Append(kvp.Key);
                        sb.Append('=');
                        sb.Append(kvp.Value);

                        if (i < count - 1)
                        {
                            sb.Append('\n');
                        }
                    }

                    keyValuePairList.Clear();
                }
            }
            else if (parameterValue.GetType().IsValueType)
            {
                sb.Append((string)Convert.ChangeType(parameterValue, typeof(string), CultureInfo.CurrentCulture));
            }
            else
            {
                ErrorUtilities.ThrowInternalErrorUnreachable();
            }
        }
Example #5
0
        public override bool Execute()
        {
            if (ItemsToHash?.Length > 0)
            {
                using (var sha1 = SHA1.Create())
                {
                    // Buffer in which bytes of the strings are to be stored until their number reaches the limit size.
                    // Once the limit is reached, the sha1.TransformBlock is to be run on all the bytes of this buffer.
                    byte[] sha1Buffer = null;

                    // Buffer in which bytes of items' ItemSpec are to be stored.
                    byte[] itemSpecChunkByteBuffer = null;

                    try
                    {
                        sha1Buffer = System.Buffers.ArrayPool <byte> .Shared.Rent(Sha1BufferSize);

                        itemSpecChunkByteBuffer = System.Buffers.ArrayPool <byte> .Shared.Rent(s_encoding.GetMaxByteCount(MaxInputChunkLength));

                        int sha1BufferPosition = 0;
                        for (int i = 0; i < ItemsToHash.Length; i++)
                        {
                            string itemSpec = IgnoreCase ? ItemsToHash[i].ItemSpec.ToUpperInvariant() : ItemsToHash[i].ItemSpec;

                            // Slice the itemSpec string into chunks of reasonable size and add them to sha1 buffer.
                            for (int itemSpecPosition = 0; itemSpecPosition < itemSpec.Length; itemSpecPosition += MaxInputChunkLength)
                            {
                                int charsToProcess = Math.Min(itemSpec.Length - itemSpecPosition, MaxInputChunkLength);
                                int byteCount      = s_encoding.GetBytes(itemSpec, itemSpecPosition, charsToProcess, itemSpecChunkByteBuffer, 0);

                                sha1BufferPosition = AddBytesToSha1Buffer(sha1, sha1Buffer, sha1BufferPosition, Sha1BufferSize, itemSpecChunkByteBuffer, byteCount);
                            }

                            sha1BufferPosition = AddBytesToSha1Buffer(sha1, sha1Buffer, sha1BufferPosition, Sha1BufferSize, s_itemSeparatorCharacterBytes, s_itemSeparatorCharacterBytes.Length);
                        }

                        sha1.TransformFinalBlock(sha1Buffer, 0, sha1BufferPosition);

                        using (var stringBuilder = new ReuseableStringBuilder(sha1.HashSize))
                        {
                            foreach (var b in sha1.Hash)
                            {
                                stringBuilder.Append(b.ToString("x2"));
                            }
                            HashResult = stringBuilder.ToString();
                        }
                    }
                    finally
                    {
                        if (sha1Buffer != null)
                        {
                            System.Buffers.ArrayPool <byte> .Shared.Return(sha1Buffer);
                        }
                        if (itemSpecChunkByteBuffer != null)
                        {
                            System.Buffers.ArrayPool <byte> .Shared.Return(itemSpecChunkByteBuffer);
                        }
                    }
                }
            }
            return(true);
        }