Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "h", "*", "ExtendedHeader", ")", "GetLength", "(", "v", "protocol", ".", "VersionNumber", ")", "protocol", ".", "ByteCount", "{", "if", "h", ".", "IsLongHeader", "{", "length", ":=", "1", "/* type byte */", "+", "4", "/* version */", "+", "1", "/* conn id len byte */", "+", "protocol", ".", "ByteCount", "(", "h", ".", "DestConnectionID", ".", "Len", "(", ")", "+", "h", ".", "SrcConnectionID", ".", "Len", "(", ")", ")", "+", "protocol", ".", "ByteCount", "(", "h", ".", "PacketNumberLen", ")", "+", "utils", ".", "VarIntLen", "(", "uint64", "(", "h", ".", "Length", ")", ")", "\n", "if", "h", ".", "Type", "==", "protocol", ".", "PacketTypeInitial", "{", "length", "+=", "utils", ".", "VarIntLen", "(", "uint64", "(", "len", "(", "h", ".", "Token", ")", ")", ")", "+", "protocol", ".", "ByteCount", "(", "len", "(", "h", ".", "Token", ")", ")", "\n", "}", "\n", "return", "length", "\n", "}", "\n\n", "length", ":=", "protocol", ".", "ByteCount", "(", "1", "/* type byte */", "+", "h", ".", "DestConnectionID", ".", "Len", "(", ")", ")", "\n", "length", "+=", "protocol", ".", "ByteCount", "(", "h", ".", "PacketNumberLen", ")", "\n", "return", "length", "\n", "}" ]

[ "GetLength", "determines", "the", "length", "of", "the", "Header", "." ]

[ "func", "(", "h", "*", "ExtendedHeader", ")", "Log", "(", "logger", "utils", ".", "Logger", ")", "{", "if", "h", ".", "IsLongHeader", "{", "var", "token", "string", "\n", "if", "h", ".", "Type", "==", "protocol", ".", "PacketTypeInitial", "||", "h", ".", "Type", "==", "protocol", ".", "PacketTypeRetry", "{", "if", "len", "(", "h", ".", "Token", ")", "==", "0", "{", "token", "=", "\"", "\"", "\n", "}", "else", "{", "token", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "h", ".", "Token", ")", "\n", "}", "\n", "if", "h", ".", "Type", "==", "protocol", ".", "PacketTypeRetry", "{", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "h", ".", "Type", ",", "h", ".", "DestConnectionID", ",", "h", ".", "SrcConnectionID", ",", "token", ",", "h", ".", "OrigDestConnectionID", ",", "h", ".", "Version", ")", "\n", "return", "\n", "}", "\n", "}", "\n", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "h", ".", "Type", ",", "h", ".", "DestConnectionID", ",", "h", ".", "SrcConnectionID", ",", "token", ",", "h", ".", "PacketNumber", ",", "h", ".", "PacketNumberLen", ",", "h", ".", "Length", ",", "h", ".", "Version", ")", "\n", "}", "else", "{", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "h", ".", "DestConnectionID", ",", "h", ".", "PacketNumber", ",", "h", ".", "PacketNumberLen", ",", "h", ".", "KeyPhase", ")", "\n", "}", "\n", "}" ]

[ "Log", "logs", "the", "Header" ]

[ "func", "DecodePacketNumber", "(", "packetNumberLength", "PacketNumberLen", ",", "lastPacketNumber", "PacketNumber", ",", "wirePacketNumber", "PacketNumber", ",", ")", "PacketNumber", "{", "var", "epochDelta", "PacketNumber", "\n", "switch", "packetNumberLength", "{", "case", "PacketNumberLen1", ":", "epochDelta", "=", "PacketNumber", "(", "1", ")", "<<", "8", "\n", "case", "PacketNumberLen2", ":", "epochDelta", "=", "PacketNumber", "(", "1", ")", "<<", "16", "\n", "case", "PacketNumberLen3", ":", "epochDelta", "=", "PacketNumber", "(", "1", ")", "<<", "24", "\n", "case", "PacketNumberLen4", ":", "epochDelta", "=", "PacketNumber", "(", "1", ")", "<<", "32", "\n", "}", "\n", "epoch", ":=", "lastPacketNumber", "&", "^", "(", "epochDelta", "-", "1", ")", "\n", "prevEpochBegin", ":=", "epoch", "-", "epochDelta", "\n", "nextEpochBegin", ":=", "epoch", "+", "epochDelta", "\n", "return", "closestTo", "(", "lastPacketNumber", "+", "1", ",", "epoch", "+", "wirePacketNumber", ",", "closestTo", "(", "lastPacketNumber", "+", "1", ",", "prevEpochBegin", "+", "wirePacketNumber", ",", "nextEpochBegin", "+", "wirePacketNumber", ")", ",", ")", "\n", "}" ]

[ "DecodePacketNumber", "calculates", "the", "packet", "number", "based", "on", "the", "received", "packet", "number", "its", "length", "and", "the", "last", "seen", "packet", "number" ]

[ "func", "GetPacketNumberLengthForHeader", "(", "packetNumber", ",", "leastUnacked", "PacketNumber", ")", "PacketNumberLen", "{", "diff", ":=", "uint64", "(", "packetNumber", "-", "leastUnacked", ")", "\n", "if", "diff", "<", "(", "1", "<<", "(", "16", "-", "1", ")", ")", "{", "return", "PacketNumberLen2", "\n", "}", "\n", "if", "diff", "<", "(", "1", "<<", "(", "24", "-", "1", ")", ")", "{", "return", "PacketNumberLen3", "\n", "}", "\n", "return", "PacketNumberLen4", "\n", "}" ]

[ "GetPacketNumberLengthForHeader", "gets", "the", "length", "of", "the", "packet", "number", "for", "the", "public", "header", "it", "never", "chooses", "a", "PacketNumberLen", "of", "1", "byte", "since", "this", "is", "too", "short", "under", "certain", "circumstances" ]

[ "func", "GetPacketNumberLength", "(", "packetNumber", "PacketNumber", ")", "PacketNumberLen", "{", "if", "packetNumber", "<", "(", "1", "<<", "(", "uint8", "(", "PacketNumberLen1", ")", "*", "8", ")", ")", "{", "return", "PacketNumberLen1", "\n", "}", "\n", "if", "packetNumber", "<", "(", "1", "<<", "(", "uint8", "(", "PacketNumberLen2", ")", "*", "8", ")", ")", "{", "return", "PacketNumberLen2", "\n", "}", "\n", "if", "packetNumber", "<", "(", "1", "<<", "(", "uint8", "(", "PacketNumberLen3", ")", "*", "8", ")", ")", "{", "return", "PacketNumberLen3", "\n", "}", "\n", "return", "PacketNumberLen4", "\n", "}" ]

[ "GetPacketNumberLength", "gets", "the", "minimum", "length", "needed", "to", "fully", "represent", "the", "packet", "number" ]

[ "func", "newExtensionHandler", "(", "params", "[", "]", "byte", ",", "pers", "protocol", ".", "Perspective", ")", "tlsExtensionHandler", "{", "return", "&", "extensionHandler", "{", "ourParams", ":", "params", ",", "paramsChan", ":", "make", "(", "chan", "[", "]", "byte", ")", ",", "perspective", ":", "pers", ",", "}", "\n", "}" ]

[ "newExtensionHandler", "creates", "a", "new", "extension", "handler" ]

[ "func", "NewSentPacketHandler", "(", "initialPacketNumber", "protocol", ".", "PacketNumber", ",", "rttStats", "*", "congestion", ".", "RTTStats", ",", "logger", "utils", ".", "Logger", ",", ")", "SentPacketHandler", "{", "congestion", ":=", "congestion", ".", "NewCubicSender", "(", "congestion", ".", "DefaultClock", "{", "}", ",", "rttStats", ",", "false", ",", "/* don't use reno since chromium doesn't (why?) */", "protocol", ".", "InitialCongestionWindow", ",", "protocol", ".", "DefaultMaxCongestionWindow", ",", ")", "\n\n", "return", "&", "sentPacketHandler", "{", "initialPackets", ":", "newPacketNumberSpace", "(", "initialPacketNumber", ")", ",", "handshakePackets", ":", "newPacketNumberSpace", "(", "0", ")", ",", "oneRTTPackets", ":", "newPacketNumberSpace", "(", "0", ")", ",", "rttStats", ":", "rttStats", ",", "congestion", ":", "congestion", ",", "logger", ":", "logger", ",", "}", "\n", "}" ]

[ "NewSentPacketHandler", "creates", "a", "new", "sentPacketHandler" ]

[ "func", "newStream", "(", "streamID", "protocol", ".", "StreamID", ",", "sender", "streamSender", ",", "flowController", "flowcontrol", ".", "StreamFlowController", ",", "version", "protocol", ".", "VersionNumber", ",", ")", "*", "stream", "{", "s", ":=", "&", "stream", "{", "sender", ":", "sender", ",", "version", ":", "version", "}", "\n", "senderForSendStream", ":=", "&", "uniStreamSender", "{", "streamSender", ":", "sender", ",", "onStreamCompletedImpl", ":", "func", "(", ")", "{", "s", ".", "completedMutex", ".", "Lock", "(", ")", "\n", "s", ".", "sendStreamCompleted", "=", "true", "\n", "s", ".", "checkIfCompleted", "(", ")", "\n", "s", ".", "completedMutex", ".", "Unlock", "(", ")", "\n", "}", ",", "}", "\n", "s", ".", "sendStream", "=", "*", "newSendStream", "(", "streamID", ",", "senderForSendStream", ",", "flowController", ",", "version", ")", "\n", "senderForReceiveStream", ":=", "&", "uniStreamSender", "{", "streamSender", ":", "sender", ",", "onStreamCompletedImpl", ":", "func", "(", ")", "{", "s", ".", "completedMutex", ".", "Lock", "(", ")", "\n", "s", ".", "receiveStreamCompleted", "=", "true", "\n", "s", ".", "checkIfCompleted", "(", ")", "\n", "s", ".", "completedMutex", ".", "Unlock", "(", ")", "\n", "}", ",", "}", "\n", "s", ".", "receiveStream", "=", "*", "newReceiveStream", "(", "streamID", ",", "senderForReceiveStream", ",", "flowController", ",", "version", ")", "\n", "return", "s", "\n", "}" ]

[ "newStream", "creates", "a", "new", "Stream" ]

[ "func", "(", "s", "*", "stream", ")", "checkIfCompleted", "(", ")", "{", "if", "s", ".", "sendStreamCompleted", "&&", "s", ".", "receiveStreamCompleted", "{", "s", ".", "sender", ".", "onStreamCompleted", "(", "s", ".", "StreamID", "(", ")", ")", "\n", "}", "\n", "}" ]

[ "checkIfCompleted", "is", "called", "from", "the", "uniStreamSender", "when", "one", "of", "the", "stream", "halves", "is", "completed", ".", "It", "makes", "sure", "that", "the", "onStreamCompleted", "callback", "is", "only", "called", "if", "both", "receive", "and", "send", "side", "have", "completed", "." ]

[ "func", "(", "p", "*", "packetPacker", ")", "PackConnectionClose", "(", "ccf", "*", "wire", ".", "ConnectionCloseFrame", ")", "(", "*", "packedPacket", ",", "error", ")", "{", "payload", ":=", "payload", "{", "frames", ":", "[", "]", "wire", ".", "Frame", "{", "ccf", "}", ",", "length", ":", "ccf", ".", "Length", "(", "p", ".", "version", ")", ",", "}", "\n", "encLevel", ",", "sealer", ":=", "p", ".", "cryptoSetup", ".", "GetSealer", "(", ")", "\n", "header", ":=", "p", ".", "getHeader", "(", "encLevel", ")", "\n", "return", "p", ".", "writeAndSealPacket", "(", "header", ",", "payload", ",", "encLevel", ",", "sealer", ")", "\n", "}" ]

[ "PackConnectionClose", "packs", "a", "packet", "that", "ONLY", "contains", "a", "ConnectionCloseFrame" ]

[ "func", "(", "p", "*", "packetPacker", ")", "PackPacket", "(", ")", "(", "*", "packedPacket", ",", "error", ")", "{", "packet", ",", "err", ":=", "p", ".", "maybePackCryptoPacket", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "packet", "!=", "nil", "{", "return", "packet", ",", "nil", "\n", "}", "\n\n", "encLevel", ",", "sealer", ":=", "p", ".", "cryptoSetup", ".", "GetSealer", "(", ")", "\n", "header", ":=", "p", ".", "getHeader", "(", "encLevel", ")", "\n", "headerLen", ":=", "header", ".", "GetLength", "(", "p", ".", "version", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "maxSize", ":=", "p", ".", "maxPacketSize", "-", "protocol", ".", "ByteCount", "(", "sealer", ".", "Overhead", "(", ")", ")", "-", "headerLen", "\n", "payload", ",", "err", ":=", "p", ".", "composeNextPacket", "(", "maxSize", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// check if we have anything to send", "if", "len", "(", "payload", ".", "frames", ")", "==", "0", "&&", "payload", ".", "ack", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "if", "len", "(", "payload", ".", "frames", ")", "==", "0", "{", "// the packet only contains an ACK", "if", "p", ".", "numNonAckElicitingAcks", ">=", "protocol", ".", "MaxNonAckElicitingAcks", "{", "ping", ":=", "&", "wire", ".", "PingFrame", "{", "}", "\n", "payload", ".", "frames", "=", "append", "(", "payload", ".", "frames", ",", "ping", ")", "\n", "payload", ".", "length", "+=", "ping", ".", "Length", "(", "p", ".", "version", ")", "\n", "p", ".", "numNonAckElicitingAcks", "=", "0", "\n", "}", "else", "{", "p", ".", "numNonAckElicitingAcks", "++", "\n", "}", "\n", "}", "else", "{", "p", ".", "numNonAckElicitingAcks", "=", "0", "\n", "}", "\n\n", "return", "p", ".", "writeAndSealPacket", "(", "header", ",", "payload", ",", "encLevel", ",", "sealer", ")", "\n", "}" ]

[ "PackPacket", "packs", "a", "new", "packet", "the", "other", "controlFrames", "are", "sent", "in", "the", "next", "packet", "but", "might", "be", "queued", "and", "sent", "in", "the", "next", "packet", "if", "the", "packet", "would", "overflow", "MaxPacketSize", "otherwise" ]

[ "func", "(", "h", "*", "receivedPacketHistory", ")", "ReceivedPacket", "(", "p", "protocol", ".", "PacketNumber", ")", "error", "{", "if", "h", ".", "ranges", ".", "Len", "(", ")", ">=", "protocol", ".", "MaxTrackedReceivedAckRanges", "{", "return", "errTooManyOutstandingReceivedAckRanges", "\n", "}", "\n\n", "if", "h", ".", "ranges", ".", "Len", "(", ")", "==", "0", "{", "h", ".", "ranges", ".", "PushBack", "(", "utils", ".", "PacketInterval", "{", "Start", ":", "p", ",", "End", ":", "p", "}", ")", "\n", "return", "nil", "\n", "}", "\n\n", "for", "el", ":=", "h", ".", "ranges", ".", "Back", "(", ")", ";", "el", "!=", "nil", ";", "el", "=", "el", ".", "Prev", "(", ")", "{", "// p already included in an existing range. Nothing to do here", "if", "p", ">=", "el", ".", "Value", ".", "Start", "&&", "p", "<=", "el", ".", "Value", ".", "End", "{", "return", "nil", "\n", "}", "\n\n", "var", "rangeExtended", "bool", "\n", "if", "el", ".", "Value", ".", "End", "==", "p", "-", "1", "{", "// extend a range at the end", "rangeExtended", "=", "true", "\n", "el", ".", "Value", ".", "End", "=", "p", "\n", "}", "else", "if", "el", ".", "Value", ".", "Start", "==", "p", "+", "1", "{", "// extend a range at the beginning", "rangeExtended", "=", "true", "\n", "el", ".", "Value", ".", "Start", "=", "p", "\n", "}", "\n\n", "// if a range was extended (either at the beginning or at the end, maybe it is possible to merge two ranges into one)", "if", "rangeExtended", "{", "prev", ":=", "el", ".", "Prev", "(", ")", "\n", "if", "prev", "!=", "nil", "&&", "prev", ".", "Value", ".", "End", "+", "1", "==", "el", ".", "Value", ".", "Start", "{", "// merge two ranges", "prev", ".", "Value", ".", "End", "=", "el", ".", "Value", ".", "End", "\n", "h", ".", "ranges", ".", "Remove", "(", "el", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "nil", "// if the two ranges were not merge, we're done here", "\n", "}", "\n\n", "// create a new range at the end", "if", "p", ">", "el", ".", "Value", ".", "End", "{", "h", ".", "ranges", ".", "InsertAfter", "(", "utils", ".", "PacketInterval", "{", "Start", ":", "p", ",", "End", ":", "p", "}", ",", "el", ")", "\n", "return", "nil", "\n", "}", "\n", "}", "\n\n", "// create a new range at the beginning", "h", ".", "ranges", ".", "InsertBefore", "(", "utils", ".", "PacketInterval", "{", "Start", ":", "p", ",", "End", ":", "p", "}", ",", "h", ".", "ranges", ".", "Front", "(", ")", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "ReceivedPacket", "registers", "a", "packet", "with", "PacketNumber", "p", "and", "updates", "the", "ranges" ]

[ "func", "(", "h", "*", "receivedPacketHistory", ")", "GetAckRanges", "(", ")", "[", "]", "wire", ".", "AckRange", "{", "if", "h", ".", "ranges", ".", "Len", "(", ")", "==", "0", "{", "return", "nil", "\n", "}", "\n\n", "ackRanges", ":=", "make", "(", "[", "]", "wire", ".", "AckRange", ",", "h", ".", "ranges", ".", "Len", "(", ")", ")", "\n", "i", ":=", "0", "\n", "for", "el", ":=", "h", ".", "ranges", ".", "Back", "(", ")", ";", "el", "!=", "nil", ";", "el", "=", "el", ".", "Prev", "(", ")", "{", "ackRanges", "[", "i", "]", "=", "wire", ".", "AckRange", "{", "Smallest", ":", "el", ".", "Value", ".", "Start", ",", "Largest", ":", "el", ".", "Value", ".", "End", "}", "\n", "i", "++", "\n", "}", "\n", "return", "ackRanges", "\n", "}" ]

[ "GetAckRanges", "gets", "a", "slice", "of", "all", "AckRanges", "that", "can", "be", "used", "in", "an", "AckFrame" ]

[ "func", "(", "p", "*", "PrrSender", ")", "OnPacketLost", "(", "priorInFlight", "protocol", ".", "ByteCount", ")", "{", "p", ".", "bytesSentSinceLoss", "=", "0", "\n", "p", ".", "bytesInFlightBeforeLoss", "=", "priorInFlight", "\n", "p", ".", "bytesDeliveredSinceLoss", "=", "0", "\n", "p", ".", "ackCountSinceLoss", "=", "0", "\n", "}" ]

[ "OnPacketLost", "should", "be", "called", "on", "the", "first", "loss", "that", "triggers", "a", "recovery", "period", "and", "all", "other", "methods", "in", "this", "class", "should", "only", "be", "called", "when", "in", "recovery", "." ]

[ "func", "(", "p", "*", "PrrSender", ")", "OnPacketAcked", "(", "ackedBytes", "protocol", ".", "ByteCount", ")", "{", "p", ".", "bytesDeliveredSinceLoss", "+=", "ackedBytes", "\n", "p", ".", "ackCountSinceLoss", "++", "\n", "}" ]

[ "OnPacketAcked", "should", "be", "called", "after", "a", "packet", "was", "acked" ]

[ "func", "(", "p", "*", "PrrSender", ")", "CanSend", "(", "congestionWindow", ",", "bytesInFlight", ",", "slowstartThreshold", "protocol", ".", "ByteCount", ")", "bool", "{", "// Return QuicTime::Zero In order to ensure limited transmit always works.", "if", "p", ".", "bytesSentSinceLoss", "==", "0", "||", "bytesInFlight", "<", "protocol", ".", "DefaultTCPMSS", "{", "return", "true", "\n", "}", "\n", "if", "congestionWindow", ">", "bytesInFlight", "{", "// During PRR-SSRB, limit outgoing packets to 1 extra MSS per ack, instead", "// of sending the entire available window. This prevents burst retransmits", "// when more packets are lost than the CWND reduction.", "// limit = MAX(prr_delivered - prr_out, DeliveredData) + MSS", "return", "p", ".", "bytesDeliveredSinceLoss", "+", "p", ".", "ackCountSinceLoss", "*", "protocol", ".", "DefaultTCPMSS", ">", "p", ".", "bytesSentSinceLoss", "\n", "}", "\n", "// Implement Proportional Rate Reduction (RFC6937).", "// Checks a simplified version of the PRR formula that doesn't use division:", "// AvailableSendWindow =", "// CEIL(prr_delivered * ssthresh / BytesInFlightAtLoss) - prr_sent", "return", "p", ".", "bytesDeliveredSinceLoss", "*", "slowstartThreshold", ">", "p", ".", "bytesSentSinceLoss", "*", "p", ".", "bytesInFlightBeforeLoss", "\n", "}" ]

[ "CanSend", "returns", "if", "packets", "can", "be", "sent" ]

[ "func", "(", "c", "*", "baseFlowController", ")", "IsNewlyBlocked", "(", ")", "(", "bool", ",", "protocol", ".", "ByteCount", ")", "{", "if", "c", ".", "sendWindowSize", "(", ")", "!=", "0", "||", "c", ".", "sendWindow", "==", "c", ".", "lastBlockedAt", "{", "return", "false", ",", "0", "\n", "}", "\n", "c", ".", "lastBlockedAt", "=", "c", ".", "sendWindow", "\n", "return", "true", ",", "c", ".", "sendWindow", "\n", "}" ]

[ "IsNewlyBlocked", "says", "if", "it", "is", "newly", "blocked", "by", "flow", "control", ".", "For", "every", "offset", "it", "only", "returns", "true", "once", ".", "If", "it", "is", "blocked", "the", "offset", "is", "returned", "." ]

[ "func", "(", "c", "*", "baseFlowController", ")", "UpdateSendWindow", "(", "offset", "protocol", ".", "ByteCount", ")", "{", "if", "offset", ">", "c", ".", "sendWindow", "{", "c", ".", "sendWindow", "=", "offset", "\n", "}", "\n", "}" ]

[ "UpdateSendWindow", "should", "be", "called", "after", "receiving", "a", "WindowUpdateFrame", "it", "returns", "true", "if", "the", "window", "was", "actually", "updated" ]

[ "func", "(", "c", "*", "baseFlowController", ")", "getWindowUpdate", "(", ")", "protocol", ".", "ByteCount", "{", "if", "!", "c", ".", "hasWindowUpdate", "(", ")", "{", "return", "0", "\n", "}", "\n\n", "c", ".", "maybeAdjustWindowSize", "(", ")", "\n", "c", ".", "receiveWindow", "=", "c", ".", "bytesRead", "+", "c", ".", "receiveWindowSize", "\n", "return", "c", ".", "receiveWindow", "\n", "}" ]

[ "getWindowUpdate", "updates", "the", "receive", "window", "if", "necessary", "it", "returns", "the", "new", "offset" ]

[ "func", "GenerateConnectionID", "(", "len", "int", ")", "(", "ConnectionID", ",", "error", ")", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "len", ")", "\n", "if", "_", ",", "err", ":=", "rand", ".", "Read", "(", "b", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "ConnectionID", "(", "b", ")", ",", "nil", "\n", "}" ]

[ "GenerateConnectionID", "generates", "a", "connection", "ID", "using", "cryptographic", "random" ]

[ "func", "GenerateConnectionIDForInitial", "(", ")", "(", "ConnectionID", ",", "error", ")", "{", "r", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "if", "_", ",", "err", ":=", "rand", ".", "Read", "(", "r", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "len", ":=", "MinConnectionIDLenInitial", "+", "int", "(", "r", "[", "0", "]", ")", "%", "(", "maxConnectionIDLen", "-", "MinConnectionIDLenInitial", "+", "1", ")", "\n", "return", "GenerateConnectionID", "(", "len", ")", "\n", "}" ]

[ "GenerateConnectionIDForInitial", "generates", "a", "connection", "ID", "for", "the", "Initial", "packet", ".", "It", "uses", "a", "length", "randomly", "chosen", "between", "8", "and", "18", "bytes", "." ]

[ "func", "ReadConnectionID", "(", "r", "io", ".", "Reader", ",", "len", "int", ")", "(", "ConnectionID", ",", "error", ")", "{", "if", "len", "==", "0", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "c", ":=", "make", "(", "ConnectionID", ",", "len", ")", "\n", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "r", ",", "c", ")", "\n", "if", "err", "==", "io", ".", "ErrUnexpectedEOF", "{", "return", "nil", ",", "io", ".", "EOF", "\n", "}", "\n", "return", "c", ",", "err", "\n", "}" ]

[ "ReadConnectionID", "reads", "a", "connection", "ID", "of", "length", "len", "from", "the", "given", "io", ".", "Reader", ".", "It", "returns", "io", ".", "EOF", "if", "there", "are", "not", "enough", "bytes", "to", "read", "." ]

[ "func", "(", "c", "ConnectionID", ")", "Equal", "(", "other", "ConnectionID", ")", "bool", "{", "return", "bytes", ".", "Equal", "(", "c", ",", "other", ")", "\n", "}" ]

[ "Equal", "says", "if", "two", "connection", "IDs", "are", "equal" ]

[ "func", "(", "h", "*", "receivedPacketTracker", ")", "IgnoreBelow", "(", "p", "protocol", ".", "PacketNumber", ")", "{", "if", "p", "<=", "h", ".", "ignoreBelow", "{", "return", "\n", "}", "\n", "h", ".", "ignoreBelow", "=", "p", "\n", "h", ".", "packetHistory", ".", "DeleteBelow", "(", "p", ")", "\n", "if", "h", ".", "logger", ".", "Debug", "(", ")", "{", "h", ".", "logger", ".", "Debugf", "(", "\"", "\\t", "\"", ",", "p", ")", "\n", "}", "\n", "}" ]

[ "IgnoreBelow", "sets", "a", "lower", "limit", "for", "acking", "packets", ".", "Packets", "with", "packet", "numbers", "smaller", "than", "p", "will", "not", "be", "acked", "." ]

[ "func", "(", "h", "*", "receivedPacketTracker", ")", "isMissing", "(", "p", "protocol", ".", "PacketNumber", ")", "bool", "{", "if", "h", ".", "lastAck", "==", "nil", "||", "p", "<", "h", ".", "ignoreBelow", "{", "return", "false", "\n", "}", "\n", "return", "p", "<", "h", ".", "lastAck", ".", "LargestAcked", "(", ")", "&&", "!", "h", ".", "lastAck", ".", "AcksPacket", "(", "p", ")", "\n", "}" ]

[ "isMissing", "says", "if", "a", "packet", "was", "reported", "missing", "in", "the", "last", "ACK", "." ]

[ "func", "ComposeVersionNegotiation", "(", "destConnID", ",", "srcConnID", "protocol", ".", "ConnectionID", ",", "versions", "[", "]", "protocol", ".", "VersionNumber", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "greasedVersions", ":=", "protocol", ".", "GetGreasedVersions", "(", "versions", ")", "\n", "expectedLen", ":=", "1", "/* type byte */", "+", "4", "/* version field */", "+", "1", "/* connection ID length field */", "+", "destConnID", ".", "Len", "(", ")", "+", "srcConnID", ".", "Len", "(", ")", "+", "len", "(", "greasedVersions", ")", "*", "4", "\n", "buf", ":=", "bytes", ".", "NewBuffer", "(", "make", "(", "[", "]", "byte", ",", "0", ",", "expectedLen", ")", ")", "\n", "r", ":=", "make", "(", "[", "]", "byte", ",", "1", ")", "\n", "_", ",", "_", "=", "rand", ".", "Read", "(", "r", ")", "// ignore the error here. It is not critical to have perfect random here.", "\n", "buf", ".", "WriteByte", "(", "r", "[", "0", "]", "|", "0xc0", ")", "\n", "utils", ".", "BigEndian", ".", "WriteUint32", "(", "buf", ",", "0", ")", "// version 0", "\n", "connIDLen", ",", "err", ":=", "encodeConnIDLen", "(", "destConnID", ",", "srcConnID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "buf", ".", "WriteByte", "(", "connIDLen", ")", "\n", "buf", ".", "Write", "(", "destConnID", ")", "\n", "buf", ".", "Write", "(", "srcConnID", ")", "\n", "for", "_", ",", "v", ":=", "range", "greasedVersions", "{", "utils", ".", "BigEndian", ".", "WriteUint32", "(", "buf", ",", "uint32", "(", "v", ")", ")", "\n", "}", "\n", "return", "buf", ".", "Bytes", "(", ")", ",", "nil", "\n", "}" ]

[ "ComposeVersionNegotiation", "composes", "a", "Version", "Negotiation" ]

[ "func", "NewStreamFlowController", "(", "streamID", "protocol", ".", "StreamID", ",", "cfc", "ConnectionFlowController", ",", "receiveWindow", "protocol", ".", "ByteCount", ",", "maxReceiveWindow", "protocol", ".", "ByteCount", ",", "initialSendWindow", "protocol", ".", "ByteCount", ",", "queueWindowUpdate", "func", "(", "protocol", ".", "StreamID", ")", ",", "rttStats", "*", "congestion", ".", "RTTStats", ",", "logger", "utils", ".", "Logger", ",", ")", "StreamFlowController", "{", "return", "&", "streamFlowController", "{", "streamID", ":", "streamID", ",", "connection", ":", "cfc", ".", "(", "connectionFlowControllerI", ")", ",", "queueWindowUpdate", ":", "func", "(", ")", "{", "queueWindowUpdate", "(", "streamID", ")", "}", ",", "baseFlowController", ":", "baseFlowController", "{", "rttStats", ":", "rttStats", ",", "receiveWindow", ":", "receiveWindow", ",", "receiveWindowSize", ":", "receiveWindow", ",", "maxReceiveWindowSize", ":", "maxReceiveWindow", ",", "sendWindow", ":", "initialSendWindow", ",", "logger", ":", "logger", ",", "}", ",", "}", "\n", "}" ]

[ "NewStreamFlowController", "gets", "a", "new", "flow", "controller", "for", "a", "stream" ]

[ "func", "(", "c", "*", "streamFlowController", ")", "UpdateHighestReceived", "(", "offset", "protocol", ".", "ByteCount", ",", "final", "bool", ")", "error", "{", "c", ".", "mutex", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mutex", ".", "Unlock", "(", ")", "\n\n", "// If the final offset for this stream is already known, check for consistency.", "if", "c", ".", "receivedFinalOffset", "{", "// If we receive another final offset, check that it's the same.", "if", "final", "&&", "offset", "!=", "c", ".", "highestReceived", "{", "return", "qerr", ".", "Error", "(", "qerr", ".", "FinalSizeError", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "c", ".", "streamID", ",", "c", ".", "highestReceived", ",", "offset", ")", ")", "\n", "}", "\n", "// Check that the offset is below the final offset.", "if", "offset", ">", "c", ".", "highestReceived", "{", "return", "qerr", ".", "Error", "(", "qerr", ".", "FinalSizeError", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "offset", ",", "c", ".", "streamID", ",", "c", ".", "highestReceived", ")", ")", "\n", "}", "\n", "}", "\n\n", "if", "final", "{", "c", ".", "receivedFinalOffset", "=", "true", "\n", "}", "\n", "if", "offset", "==", "c", ".", "highestReceived", "{", "return", "nil", "\n", "}", "\n", "// A higher offset was received before.", "// This can happen due to reordering.", "if", "offset", "<=", "c", ".", "highestReceived", "{", "if", "final", "{", "return", "qerr", ".", "Error", "(", "qerr", ".", "FinalSizeError", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "offset", ",", "c", ".", "streamID", ",", "c", ".", "highestReceived", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "increment", ":=", "offset", "-", "c", ".", "highestReceived", "\n", "c", ".", "highestReceived", "=", "offset", "\n", "if", "c", ".", "checkFlowControlViolation", "(", ")", "{", "return", "qerr", ".", "Error", "(", "qerr", ".", "FlowControlError", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "offset", ",", "c", ".", "streamID", ",", "c", ".", "receiveWindow", ")", ")", "\n", "}", "\n", "return", "c", ".", "connection", ".", "IncrementHighestReceived", "(", "increment", ")", "\n", "}" ]

[ "UpdateHighestReceived", "updates", "the", "highestReceived", "value", "if", "the", "offset", "is", "higher", "." ]

[ "func", "(", "f", "*", "CryptoFrame", ")", "MaxDataLen", "(", "maxSize", "protocol", ".", "ByteCount", ")", "protocol", ".", "ByteCount", "{", "// pretend that the data size will be 1 bytes", "// if it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterwards", "headerLen", ":=", "1", "+", "utils", ".", "VarIntLen", "(", "uint64", "(", "f", ".", "Offset", ")", ")", "+", "1", "\n", "if", "headerLen", ">", "maxSize", "{", "return", "0", "\n", "}", "\n", "maxDataLen", ":=", "maxSize", "-", "headerLen", "\n", "if", "utils", ".", "VarIntLen", "(", "uint64", "(", "maxDataLen", ")", ")", "!=", "1", "{", "maxDataLen", "--", "\n", "}", "\n", "return", "maxDataLen", "\n", "}" ]

[ "MaxDataLen", "returns", "the", "maximum", "data", "length" ]

[ "func", "newSingleCheckout", "(", "gitEnv", "config", ".", "Environment", ",", "remote", "string", ")", "abstractCheckout", "{", "manifest", ":=", "getTransferManifestOperationRemote", "(", "\"", "\"", ",", "remote", ")", "\n\n", "clean", ",", "ok", ":=", "gitEnv", ".", "Get", "(", "\"", "\"", ")", "\n", "if", "!", "ok", "||", "len", "(", "clean", ")", "==", "0", "{", "return", "&", "noOpCheckout", "{", "manifest", ":", "manifest", "}", "\n", "}", "\n\n", "// Get a converter from repo-relative to cwd-relative", "// Since writing data & calling git update-index must be relative to cwd", "pathConverter", ",", "err", ":=", "lfs", ".", "NewRepoToCurrentPathConverter", "(", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "Panic", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "singleCheckout", "{", "gitIndexer", ":", "&", "gitIndexer", "{", "}", ",", "pathConverter", ":", "pathConverter", ",", "manifest", ":", "manifest", ",", "}", "\n", "}" ]

[ "Handles", "the", "process", "of", "checking", "out", "a", "single", "file", "and", "updating", "the", "git", "index", "." ]

[ "func", "(", "c", "*", "singleCheckout", ")", "RunToPath", "(", "p", "*", "lfs", ".", "WrappedPointer", ",", "path", "string", ")", "error", "{", "gitfilter", ":=", "lfs", ".", "NewGitFilter", "(", "cfg", ")", "\n", "return", "gitfilter", ".", "SmudgeToFile", "(", "path", ",", "p", ".", "Pointer", ",", "false", ",", "c", ".", "manifest", ",", "nil", ")", "\n", "}" ]

[ "RunToPath", "checks", "out", "the", "pointer", "specified", "by", "p", "to", "the", "given", "path", ".", "It", "does", "not", "perform", "any", "sort", "of", "sanity", "checking", "or", "add", "the", "path", "to", "the", "index", "." ]

[ "func", "(", "ctxt", "*", "CredentialHelperContext", ")", "GetCredentialHelper", "(", "helper", "CredentialHelper", ",", "u", "*", "url", ".", "URL", ")", "(", "CredentialHelper", ",", "Creds", ")", "{", "rawurl", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "u", ".", "Scheme", ",", "u", ".", "Host", ",", "u", ".", "Path", ")", "\n", "input", ":=", "Creds", "{", "\"", "\"", ":", "u", ".", "Scheme", ",", "\"", "\"", ":", "u", ".", "Host", "}", "\n", "if", "u", ".", "User", "!=", "nil", "&&", "u", ".", "User", ".", "Username", "(", ")", "!=", "\"", "\"", "{", "input", "[", "\"", "\"", "]", "=", "u", ".", "User", ".", "Username", "(", ")", "\n", "}", "\n", "if", "u", ".", "Scheme", "==", "\"", "\"", "||", "ctxt", ".", "urlConfig", ".", "Bool", "(", "\"", "\"", ",", "rawurl", ",", "\"", "\"", ",", "false", ")", "{", "input", "[", "\"", "\"", "]", "=", "strings", ".", "TrimPrefix", "(", "u", ".", "Path", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "helper", "!=", "nil", "{", "return", "helper", ",", "input", "\n", "}", "\n\n", "helpers", ":=", "make", "(", "[", "]", "CredentialHelper", ",", "0", ",", "4", ")", "\n", "if", "ctxt", ".", "netrcCredHelper", "!=", "nil", "{", "helpers", "=", "append", "(", "helpers", ",", "ctxt", ".", "netrcCredHelper", ")", "\n", "}", "\n", "if", "ctxt", ".", "cachingCredHelper", "!=", "nil", "{", "helpers", "=", "append", "(", "helpers", ",", "ctxt", ".", "cachingCredHelper", ")", "\n", "}", "\n", "if", "ctxt", ".", "askpassCredHelper", "!=", "nil", "{", "helper", ",", "_", ":=", "ctxt", ".", "urlConfig", ".", "Get", "(", "\"", "\"", ",", "rawurl", ",", "\"", "\"", ")", "\n", "if", "len", "(", "helper", ")", "==", "0", "{", "helpers", "=", "append", "(", "helpers", ",", "ctxt", ".", "askpassCredHelper", ")", "\n", "}", "\n", "}", "\n\n", "return", "NewCredentialHelpers", "(", "append", "(", "helpers", ",", "ctxt", ".", "commandCredHelper", ")", ")", ",", "input", "\n", "}" ]

[ "getCredentialHelper", "parses", "a", "credsConfig", "from", "the", "git", "and", "OS", "environments", "returning", "the", "appropriate", "CredentialHelper", "to", "authenticate", "requests", "with", ".", "It", "returns", "an", "error", "if", "any", "configuration", "was", "invalid", "or", "otherwise", "un", "-", "useable", "." ]

[ "func", "NewCredentialHelpers", "(", "helpers", "[", "]", "CredentialHelper", ")", "CredentialHelper", "{", "return", "&", "CredentialHelpers", "{", "helpers", ":", "helpers", ",", "skippedHelpers", ":", "make", "(", "map", "[", "int", "]", "bool", ")", ",", "}", "\n", "}" ]

[ "NewCredentialHelpers", "initializes", "a", "new", "CredentialHelpers", "from", "the", "given", "slice", "of", "CredentialHelper", "instances", "." ]

[ "func", "(", "s", "*", "CredentialHelpers", ")", "Fill", "(", "what", "Creds", ")", "(", "Creds", ",", "error", ")", "{", "errs", ":=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "s", ".", "helpers", ")", ")", "\n", "for", "i", ",", "h", ":=", "range", "s", ".", "helpers", "{", "if", "s", ".", "skipped", "(", "i", ")", "{", "continue", "\n", "}", "\n\n", "creds", ",", "err", ":=", "h", ".", "Fill", "(", "what", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "!=", "credHelperNoOp", "{", "s", ".", "skip", "(", "i", ")", "\n", "tracerx", ".", "Printf", "(", "\"", "\"", ",", "err", ")", "\n", "errs", "=", "append", "(", "errs", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "if", "creds", "!=", "nil", "{", "return", "creds", ",", "nil", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "errs", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\\n", "\"", "+", "strings", ".", "Join", "(", "errs", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "Fill", "implements", "CredentialHelper", ".", "Fill", "by", "asking", "each", "CredentialHelper", "in", "order", "to", "fill", "the", "credentials", ".", "If", "a", "fill", "was", "successful", "it", "is", "returned", "immediately", "and", "no", "other", "CredentialHelper", "s", "are", "consulted", ".", "If", "any", "CredentialHelper", "returns", "an", "error", "it", "is", "reported", "to", "tracerx", "and", "the", "next", "one", "is", "attempted", ".", "If", "they", "all", "error", "then", "a", "collection", "of", "all", "the", "error", "messages", "is", "returned", ".", "Erroring", "credential", "helpers", "are", "added", "to", "the", "skip", "list", "and", "never", "attempted", "again", "for", "the", "lifetime", "of", "the", "current", "Git", "LFS", "command", "." ]

[ "func", "(", "s", "*", "CredentialHelpers", ")", "Reject", "(", "what", "Creds", ")", "error", "{", "for", "i", ",", "h", ":=", "range", "s", ".", "helpers", "{", "if", "s", ".", "skipped", "(", "i", ")", "{", "continue", "\n", "}", "\n\n", "if", "err", ":=", "h", ".", "Reject", "(", "what", ")", ";", "err", "!=", "credHelperNoOp", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Reject", "implements", "CredentialHelper", ".", "Reject", "and", "rejects", "the", "given", "Creds", "what", "with", "the", "first", "successful", "attempt", "." ]

[ "func", "(", "a", "*", "adapterBase", ")", "worker", "(", "workerNum", "int", ",", "ctx", "interface", "{", "}", ")", "{", "a", ".", "Trace", "(", "\"", "\"", ",", "a", ".", "Name", "(", ")", ",", "workerNum", ")", "\n", "waitForAuth", ":=", "workerNum", ">", "0", "\n", "signalAuthOnResponse", ":=", "workerNum", "==", "0", "\n\n", "// First worker is the only one allowed to start immediately", "// The rest wait until successful response from 1st worker to", "// make sure only 1 login prompt is presented if necessary", "// Deliberately outside jobChan processing so we know worker 0 will process 1st item", "if", "waitForAuth", "{", "a", ".", "Trace", "(", "\"", "\"", ",", "a", ".", "Name", "(", ")", ",", "workerNum", ")", "\n", "a", ".", "authWait", ".", "Wait", "(", ")", "\n", "a", ".", "Trace", "(", "\"", "\"", ",", "a", ".", "Name", "(", ")", ",", "workerNum", ")", "\n", "}", "\n\n", "for", "job", ":=", "range", "a", ".", "jobChan", "{", "t", ":=", "job", ".", "T", "\n\n", "var", "authCallback", "func", "(", ")", "\n", "if", "signalAuthOnResponse", "{", "authCallback", "=", "func", "(", ")", "{", "a", ".", "authWait", ".", "Done", "(", ")", "\n", "signalAuthOnResponse", "=", "false", "\n", "}", "\n", "}", "\n", "a", ".", "Trace", "(", "\"", "\"", ",", "a", ".", "Name", "(", ")", ",", "workerNum", ",", "t", ".", "Oid", ")", "\n\n", "// Actual transfer happens here", "var", "err", "error", "\n", "if", "t", ".", "Size", "<", "0", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "t", ".", "Oid", ",", "t", ".", "Size", ")", "\n", "}", "else", "{", "err", "=", "a", ".", "transferImpl", ".", "DoTransfer", "(", "ctx", ",", "t", ",", "a", ".", "cb", ",", "authCallback", ")", "\n", "}", "\n\n", "// Mark the job as completed, and alter all listeners", "job", ".", "Done", "(", "err", ")", "\n\n", "a", ".", "Trace", "(", "\"", "\"", ",", "a", ".", "Name", "(", ")", ",", "workerNum", ",", "t", ".", "Oid", ")", "\n", "}", "\n", "// This will only happen if no jobs were submitted; just wake up all workers to finish", "if", "signalAuthOnResponse", "{", "a", ".", "authWait", ".", "Done", "(", ")", "\n", "}", "\n", "a", ".", "Trace", "(", "\"", "\"", ",", "a", ".", "Name", "(", ")", ",", "workerNum", ")", "\n", "a", ".", "transferImpl", ".", "WorkerEnding", "(", "workerNum", ",", "ctx", ")", "\n", "a", ".", "workerWait", ".", "Done", "(", ")", "\n", "}" ]

[ "worker", "function", "many", "of", "these", "run", "per", "adapter" ]

[ "func", "ClampInt", "(", "n", ",", "min", ",", "max", "int", ")", "int", "{", "return", "MinInt", "(", "min", ",", "MaxInt", "(", "max", ",", "n", ")", ")", "\n", "}" ]

[ "ClampInt", "returns", "the", "integer", "n", "bounded", "between", "min", "and", "max", "." ]

[ "func", "(", "s", "*", "lockableNameSet", ")", "Check", "(", "blobSha", "string", ")", "(", "string", ",", "bool", ")", "{", "if", "s", "==", "nil", "||", "s", ".", "opt", "==", "nil", "||", "s", ".", "set", "==", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n\n", "name", ",", "ok", ":=", "s", ".", "opt", ".", "GetName", "(", "blobSha", ")", "\n", "if", "!", "ok", "{", "return", "name", ",", "ok", "\n", "}", "\n\n", "if", "s", ".", "set", ".", "Contains", "(", "name", ")", "{", "return", "name", ",", "true", "\n", "}", "\n", "return", "name", ",", "false", "\n", "}" ]

[ "Determines", "if", "the", "given", "blob", "sha", "matches", "a", "locked", "file", "." ]

[ "func", "scanRefsToChan", "(", "scanner", "*", "GitScanner", ",", "pointerCb", "GitScannerFoundPointer", ",", "include", ",", "exclude", "[", "]", "string", ",", "opt", "*", "ScanRefsOptions", ")", "error", "{", "if", "opt", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "revs", ",", "err", ":=", "revListShas", "(", "include", ",", "exclude", ",", "opt", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "lockableSet", ":=", "&", "lockableNameSet", "{", "opt", ":", "opt", ",", "set", ":", "scanner", ".", "PotentialLockables", "}", "\n", "smallShas", ",", "batchLockableCh", ",", "err", ":=", "catFileBatchCheck", "(", "revs", ",", "lockableSet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "lockableCb", ":=", "scanner", ".", "FoundLockable", "\n", "if", "lockableCb", "==", "nil", "{", "lockableCb", "=", "noopFoundLockable", "\n", "}", "\n\n", "go", "func", "(", "cb", "GitScannerFoundLockable", ",", "ch", "chan", "string", ")", "{", "for", "name", ":=", "range", "ch", "{", "cb", "(", "name", ")", "\n", "}", "\n", "}", "(", "lockableCb", ",", "batchLockableCh", ")", "\n\n", "pointers", ",", "checkLockableCh", ",", "err", ":=", "catFileBatch", "(", "smallShas", ",", "lockableSet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "p", ":=", "range", "pointers", ".", "Results", "{", "if", "name", ",", "ok", ":=", "opt", ".", "GetName", "(", "p", ".", "Sha1", ")", ";", "ok", "{", "p", ".", "Name", "=", "name", "\n", "}", "\n\n", "if", "scanner", ".", "Filter", ".", "Allows", "(", "p", ".", "Name", ")", "{", "pointerCb", "(", "p", ",", "nil", ")", "\n", "}", "\n", "}", "\n\n", "for", "lockableName", ":=", "range", "checkLockableCh", "{", "if", "scanner", ".", "Filter", ".", "Allows", "(", "lockableName", ")", "{", "lockableCb", "(", "lockableName", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "pointers", ".", "Wait", "(", ")", ";", "err", "!=", "nil", "{", "pointerCb", "(", "nil", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "scanRefsToChan", "scans", "through", "all", "commits", "reachable", "by", "refs", "contained", "in", "include", "and", "not", "reachable", "by", "any", "refs", "included", "in", "excluded", "and", "returns", "a", "channel", "of", "WrappedPointer", "objects", "for", "all", "Git", "LFS", "pointers", "it", "finds", ".", "Reports", "unique", "oids", "once", "only", "not", "multiple", "times", "if", ">", "1", "file", "uses", "the", "same", "content" ]

[ "func", "scanLeftRightToChan", "(", "scanner", "*", "GitScanner", ",", "pointerCb", "GitScannerFoundPointer", ",", "refLeft", ",", "refRight", "string", ",", "opt", "*", "ScanRefsOptions", ")", "error", "{", "return", "scanRefsToChan", "(", "scanner", ",", "pointerCb", ",", "[", "]", "string", "{", "refLeft", ",", "refRight", "}", ",", "nil", ",", "opt", ")", "\n", "}" ]

[ "scanLeftRightToChan", "takes", "a", "ref", "and", "returns", "a", "channel", "of", "WrappedPointer", "objects", "for", "all", "Git", "LFS", "pointers", "it", "finds", "for", "that", "ref", ".", "Reports", "unique", "oids", "once", "only", "not", "multiple", "times", "if", ">", "1", "file", "uses", "the", "same", "content" ]

[ "func", "revListShas", "(", "include", ",", "exclude", "[", "]", "string", ",", "opt", "*", "ScanRefsOptions", ")", "(", "*", "StringChannelWrapper", ",", "error", ")", "{", "scanner", ",", "err", ":=", "git", ".", "NewRevListScanner", "(", "include", ",", "exclude", ",", "&", "git", ".", "ScanRefsOptions", "{", "Mode", ":", "git", ".", "ScanningMode", "(", "opt", ".", "ScanMode", ")", ",", "Remote", ":", "opt", ".", "RemoteName", ",", "SkipDeletedBlobs", ":", "opt", ".", "SkipDeletedBlobs", ",", "SkippedRefs", ":", "opt", ".", "skippedRefs", ",", "Mutex", ":", "opt", ".", "mutex", ",", "Names", ":", "opt", ".", "nameMap", ",", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "revs", ":=", "make", "(", "chan", "string", ",", "chanBufSize", ")", "\n", "errs", ":=", "make", "(", "chan", "error", ",", "5", ")", "// may be multiple errors", "\n\n", "go", "func", "(", ")", "{", "for", "scanner", ".", "Scan", "(", ")", "{", "sha", ":=", "hex", ".", "EncodeToString", "(", "scanner", ".", "OID", "(", ")", ")", "\n", "if", "name", ":=", "scanner", ".", "Name", "(", ")", ";", "len", "(", "name", ")", ">", "0", "{", "opt", ".", "SetName", "(", "sha", ",", "name", ")", "\n", "}", "\n", "revs", "<-", "sha", "\n", "}", "\n\n", "if", "err", "=", "scanner", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "errs", "<-", "err", "\n", "}", "\n\n", "if", "err", "=", "scanner", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "errs", "<-", "err", "\n", "}", "\n\n", "close", "(", "revs", ")", "\n", "close", "(", "errs", ")", "\n", "}", "(", ")", "\n\n", "return", "NewStringChannelWrapper", "(", "revs", ",", "errs", ")", ",", "nil", "\n", "}" ]

[ "revListShas", "uses", "git", "rev", "-", "list", "to", "return", "the", "list", "of", "object", "sha1s", "for", "the", "given", "ref", ".", "If", "all", "is", "true", "ref", "is", "ignored", ".", "It", "returns", "a", "channel", "from", "which", "sha1", "strings", "can", "be", "read", "." ]

[ "func", "(", "c", "*", "LockCache", ")", "Add", "(", "l", "Lock", ")", "error", "{", "// Store reference in both directions", "// Path -> Lock", "c", ".", "kv", ".", "Set", "(", "l", ".", "Path", ",", "&", "l", ")", "\n", "// EncodedId -> Lock (encoded so we can easily identify)", "c", ".", "kv", ".", "Set", "(", "c", ".", "encodeIdKey", "(", "l", ".", "Id", ")", ",", "&", "l", ")", "\n", "return", "nil", "\n", "}" ]

[ "Cache", "a", "successful", "lock", "for", "faster", "local", "lookup", "later" ]

[ "func", "(", "c", "*", "LockCache", ")", "RemoveByPath", "(", "filePath", "string", ")", "error", "{", "ilock", ":=", "c", ".", "kv", ".", "Get", "(", "filePath", ")", "\n", "if", "lock", ",", "ok", ":=", "ilock", ".", "(", "*", "Lock", ")", ";", "ok", "&&", "lock", "!=", "nil", "{", "c", ".", "kv", ".", "Remove", "(", "lock", ".", "Path", ")", "\n", "// Id as key is encoded", "c", ".", "kv", ".", "Remove", "(", "c", ".", "encodeIdKey", "(", "lock", ".", "Id", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Remove", "a", "cached", "lock", "by", "path", "becuase", "it", "s", "been", "relinquished" ]

[ "func", "(", "c", "*", "LockCache", ")", "RemoveById", "(", "id", "string", ")", "error", "{", "// Id as key is encoded", "idkey", ":=", "c", ".", "encodeIdKey", "(", "id", ")", "\n", "ilock", ":=", "c", ".", "kv", ".", "Get", "(", "idkey", ")", "\n", "if", "lock", ",", "ok", ":=", "ilock", ".", "(", "*", "Lock", ")", ";", "ok", "&&", "lock", "!=", "nil", "{", "c", ".", "kv", ".", "Remove", "(", "idkey", ")", "\n", "c", ".", "kv", ".", "Remove", "(", "lock", ".", "Path", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Remove", "a", "cached", "lock", "by", "id", "because", "it", "s", "been", "relinquished" ]

[ "func", "(", "c", "*", "LockCache", ")", "Locks", "(", ")", "[", "]", "Lock", "{", "var", "locks", "[", "]", "Lock", "\n", "c", ".", "kv", ".", "Visit", "(", "func", "(", "key", "string", ",", "val", "interface", "{", "}", ")", "bool", "{", "// Only report file->id entries not reverse", "if", "!", "c", ".", "isIdKey", "(", "key", ")", "{", "lock", ":=", "val", ".", "(", "*", "Lock", ")", "\n", "locks", "=", "append", "(", "locks", ",", "*", "lock", ")", "\n", "}", "\n", "return", "true", "// continue", "\n", "}", ")", "\n", "return", "locks", "\n", "}" ]

[ "Get", "the", "list", "of", "cached", "locked", "files" ]

[ "func", "NewClient", "(", "remote", "string", ",", "lfsClient", "*", "lfsapi", ".", "Client", ",", "cfg", "*", "config", ".", "Configuration", ")", "(", "*", "Client", ",", "error", ")", "{", "return", "&", "Client", "{", "Remote", ":", "remote", ",", "client", ":", "&", "lockClient", "{", "Client", ":", "lfsClient", "}", ",", "cache", ":", "&", "nilLockCacher", "{", "}", ",", "cfg", ":", "cfg", ",", "ModifyIgnoredFiles", ":", "lfsClient", ".", "GitEnv", "(", ")", ".", "Bool", "(", "\"", "\"", ",", "false", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "locking", "client", "with", "the", "given", "configuration", "You", "must", "call", "the", "returned", "object", "s", "Close", "method", "when", "you", "are", "finished", "with", "it" ]

[ "func", "(", "c", "*", "Client", ")", "LockFile", "(", "path", "string", ")", "(", "Lock", ",", "error", ")", "{", "lockRes", ",", "_", ",", "err", ":=", "c", ".", "client", ".", "Lock", "(", "c", ".", "Remote", ",", "&", "lockRequest", "{", "Path", ":", "path", ",", "Ref", ":", "&", "lockRef", "{", "Name", ":", "c", ".", "RemoteRef", ".", "Refspec", "(", ")", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Lock", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "lockRes", ".", "Message", ")", ">", "0", "{", "if", "len", "(", "lockRes", ".", "RequestID", ")", ">", "0", "{", "tracerx", ".", "Printf", "(", "\"", "\"", ",", "lockRes", ".", "RequestID", ")", "\n", "}", "\n", "return", "Lock", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "lockRes", ".", "Message", ")", "\n", "}", "\n\n", "lock", ":=", "*", "lockRes", ".", "Lock", "\n", "if", "err", ":=", "c", ".", "cache", ".", "Add", "(", "lock", ")", ";", "err", "!=", "nil", "{", "return", "Lock", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "abs", ",", "err", ":=", "getAbsolutePath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "Lock", "{", "}", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Ensure writeable on return", "if", "err", ":=", "tools", ".", "SetFileWriteFlag", "(", "abs", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "Lock", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "lock", ",", "nil", "\n", "}" ]

[ "LockFile", "attempts", "to", "lock", "a", "file", "on", "the", "current", "remote", "path", "must", "be", "relative", "to", "the", "root", "of", "the", "repository", "Returns", "the", "lock", "id", "if", "successful", "or", "an", "error" ]

[ "func", "(", "c", "*", "Client", ")", "UnlockFile", "(", "path", "string", ",", "force", "bool", ")", "error", "{", "id", ",", "err", ":=", "c", ".", "lockIdFromPath", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "c", ".", "UnlockFileById", "(", "id", ",", "force", ")", "\n", "}" ]

[ "UnlockFile", "attempts", "to", "unlock", "a", "file", "on", "the", "current", "remote", "path", "must", "be", "relative", "to", "the", "root", "of", "the", "repository", "Force", "causes", "the", "file", "to", "be", "unlocked", "from", "other", "users", "as", "well" ]

[ "func", "(", "c", "*", "Client", ")", "UnlockFileById", "(", "id", "string", ",", "force", "bool", ")", "error", "{", "unlockRes", ",", "_", ",", "err", ":=", "c", ".", "client", ".", "Unlock", "(", "c", ".", "RemoteRef", ",", "c", ".", "Remote", ",", "id", ",", "force", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "unlockRes", ".", "Message", ")", ">", "0", "{", "if", "len", "(", "unlockRes", ".", "RequestID", ")", ">", "0", "{", "tracerx", ".", "Printf", "(", "\"", "\"", ",", "unlockRes", ".", "RequestID", ")", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "unlockRes", ".", "Message", ")", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "cache", ".", "RemoveById", "(", "id", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "unlockRes", ".", "Lock", "!=", "nil", "{", "abs", ",", "err", ":=", "getAbsolutePath", "(", "unlockRes", ".", "Lock", ".", "Path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// Make non-writeable if required", "if", "c", ".", "SetLockableFilesReadOnly", "&&", "c", ".", "IsFileLockable", "(", "unlockRes", ".", "Lock", ".", "Path", ")", "{", "return", "tools", ".", "SetFileWriteFlag", "(", "abs", ",", "false", ")", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "UnlockFileById", "attempts", "to", "unlock", "a", "lock", "with", "a", "given", "id", "on", "the", "current", "remote", "Force", "causes", "the", "file", "to", "be", "unlocked", "from", "other", "users", "as", "well" ]

[ "func", "(", "c", "*", "Client", ")", "IsFileLockedByCurrentCommitter", "(", "path", "string", ")", "bool", "{", "filter", ":=", "map", "[", "string", "]", "string", "{", "\"", "\"", ":", "path", "}", "\n", "locks", ",", "err", ":=", "c", ".", "searchLocalLocks", "(", "filter", ",", "1", ")", "\n", "if", "err", "!=", "nil", "{", "tracerx", ".", "Printf", "(", "\"", "\\n", "\"", ",", "err", ")", "\n", "locks", ",", "_", "=", "c", ".", "searchRemoteLocks", "(", "filter", ",", "1", ")", "\n", "}", "\n", "return", "len", "(", "locks", ")", ">", "0", "\n", "}" ]

[ "IsFileLockedByCurrentCommitter", "returns", "whether", "a", "file", "is", "locked", "by", "the", "current", "user", "as", "cached", "locally" ]

[ "func", "linesInTree", "(", "db", "*", "gitobj", ".", "ObjectDatabase", ",", "t", "*", "gitobj", ".", "Tree", ")", "(", "[", "]", "*", "Line", ",", "string", ",", "error", ")", "{", "var", "at", "int", "=", "-", "1", "\n", "for", "i", ",", "e", ":=", "range", "t", ".", "Entries", "{", "if", "e", ".", "Name", "==", "\"", "\"", "{", "at", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "at", "<", "0", "{", "return", "nil", ",", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "blob", ",", "err", ":=", "db", ".", "Blob", "(", "t", ".", "Entries", "[", "at", "]", ".", "Oid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n", "defer", "blob", ".", "Close", "(", ")", "\n\n", "return", "ParseLines", "(", "blob", ".", "Contents", ")", "\n", "}" ]

[ "linesInTree", "parses", "a", "given", "tree", "s", ".", "gitattributes", "and", "returns", "a", "slice", "of", "lines", "in", "that", ".", "gitattributes", "or", "an", "error", ".", "If", "no", ".", "gitattributes", "blob", "was", "found", "return", "nil", "." ]

[ "func", "(", "t", "*", "Tree", ")", "Applied", "(", "to", "string", ")", "[", "]", "*", "Attr", "{", "var", "attrs", "[", "]", "*", "Attr", "\n", "for", "_", ",", "line", ":=", "range", "t", ".", "Lines", "{", "if", "line", ".", "Pattern", ".", "Match", "(", "to", ")", "{", "attrs", "=", "append", "(", "attrs", ",", "line", ".", "Attrs", "...", ")", "\n", "}", "\n", "}", "\n\n", "splits", ":=", "strings", ".", "SplitN", "(", "to", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "splits", ")", "==", "2", "{", "car", ",", "cdr", ":=", "splits", "[", "0", "]", ",", "splits", "[", "1", "]", "\n", "if", "child", ",", "ok", ":=", "t", ".", "Children", "[", "car", "]", ";", "ok", "{", "attrs", "=", "append", "(", "attrs", ",", "child", ".", "Applied", "(", "cdr", ")", "...", ")", "\n", "}", "\n", "}", "\n\n", "return", "attrs", "\n", "}" ]

[ "Applied", "returns", "a", "slice", "of", "attributes", "applied", "to", "the", "given", "path", "relative", "to", "the", "receiving", "tree", ".", "It", "traverse", "through", "sub", "-", "trees", "in", "a", "topological", "ordering", "if", "there", "are", "relevant", ".", "gitattributes", "matching", "that", "path", "." ]

[ "func", "NewMeter", "(", "cfg", "*", "config", ".", "Configuration", ")", "*", "Meter", "{", "m", ":=", "&", "Meter", "{", "fileIndex", ":", "make", "(", "map", "[", "string", "]", "int64", ")", ",", "fileIndexMutex", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "updates", ":", "make", "(", "chan", "*", "tasklog", ".", "Update", ")", ",", "cfg", ":", "cfg", ",", "}", "\n\n", "return", "m", "\n", "}" ]

[ "NewMeter", "creates", "a", "new", "Meter", "." ]

[ "func", "(", "m", "*", "Meter", ")", "Skip", "(", "size", "int64", ")", "{", "if", "m", "==", "nil", "{", "return", "\n", "}", "\n\n", "defer", "m", ".", "update", "(", "false", ")", "\n", "atomic", ".", "AddInt64", "(", "&", "m", ".", "finishedFiles", ",", "1", ")", "\n", "atomic", ".", "AddInt64", "(", "&", "m", ".", "currentBytes", ",", "size", ")", "\n", "}" ]

[ "Skip", "tells", "the", "progress", "meter", "that", "a", "file", "of", "size", "size", "is", "being", "skipped", "because", "the", "transfer", "is", "unnecessary", "." ]

[ "func", "(", "m", "*", "Meter", ")", "StartTransfer", "(", "name", "string", ")", "{", "if", "m", "==", "nil", "{", "return", "\n", "}", "\n\n", "defer", "m", ".", "update", "(", "false", ")", "\n", "idx", ":=", "atomic", ".", "AddInt64", "(", "&", "m", ".", "transferringFiles", ",", "1", ")", "\n", "m", ".", "fileIndexMutex", ".", "Lock", "(", ")", "\n", "m", ".", "fileIndex", "[", "name", "]", "=", "idx", "\n", "m", ".", "fileIndexMutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "StartTransfer", "tells", "the", "progress", "meter", "that", "a", "transferring", "file", "is", "being", "added", "to", "the", "TransferQueue", "." ]

[ "func", "(", "m", "*", "Meter", ")", "TransferBytes", "(", "direction", ",", "name", "string", ",", "read", ",", "total", "int64", ",", "current", "int", ")", "{", "if", "m", "==", "nil", "{", "return", "\n", "}", "\n\n", "defer", "m", ".", "update", "(", "false", ")", "\n\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "since", ":=", "now", ".", "Sub", "(", "m", ".", "lastAvg", ")", "\n", "atomic", ".", "AddInt64", "(", "&", "m", ".", "currentBytes", ",", "int64", "(", "current", ")", ")", "\n", "atomic", ".", "AddInt64", "(", "&", "m", ".", "lastBytes", ",", "int64", "(", "current", ")", ")", "\n\n", "if", "since", ">", "time", ".", "Second", "{", "m", ".", "lastAvg", "=", "now", "\n\n", "bps", ":=", "float64", "(", "m", ".", "lastBytes", ")", "/", "since", ".", "Seconds", "(", ")", "\n\n", "m", ".", "avgBytes", "=", "(", "m", ".", "avgBytes", "*", "float64", "(", "m", ".", "sampleCount", ")", "+", "bps", ")", "/", "(", "float64", "(", "m", ".", "sampleCount", ")", "+", "1.0", ")", "\n\n", "atomic", ".", "StoreInt64", "(", "&", "m", ".", "lastBytes", ",", "0", ")", "\n", "atomic", ".", "AddUint64", "(", "&", "m", ".", "sampleCount", ",", "1", ")", "\n", "}", "\n\n", "m", ".", "logBytes", "(", "direction", ",", "name", ",", "read", ",", "total", ")", "\n", "}" ]

[ "TransferBytes", "increments", "the", "number", "of", "bytes", "transferred" ]

[ "func", "(", "m", "*", "Meter", ")", "FinishTransfer", "(", "name", "string", ")", "{", "if", "m", "==", "nil", "{", "return", "\n", "}", "\n\n", "defer", "m", ".", "update", "(", "false", ")", "\n", "atomic", ".", "AddInt64", "(", "&", "m", ".", "finishedFiles", ",", "1", ")", "\n", "m", ".", "fileIndexMutex", ".", "Lock", "(", ")", "\n", "delete", "(", "m", ".", "fileIndex", ",", "name", ")", "\n", "m", ".", "fileIndexMutex", ".", "Unlock", "(", ")", "\n", "}" ]

[ "FinishTransfer", "increments", "the", "finished", "transfer", "count" ]

[ "func", "(", "m", "*", "Meter", ")", "Finish", "(", ")", "{", "if", "m", "==", "nil", "{", "return", "\n", "}", "\n\n", "m", ".", "update", "(", "false", ")", "\n", "close", "(", "m", ".", "updates", ")", "\n", "}" ]

[ "Finish", "shuts", "down", "the", "Meter", "." ]

[ "func", "clamp", "(", "x", "int64", ")", "uint64", "{", "if", "x", "<", "0", "{", "return", "0", "\n", "}", "\n", "if", "x", ">", "math", ".", "MaxInt64", "{", "return", "math", ".", "MaxUint64", "\n", "}", "\n", "return", "uint64", "(", "x", ")", "\n", "}" ]

[ "clamp", "clamps", "the", "given", "x", "within", "the", "acceptable", "domain", "of", "the", "uint64", "integer", "type", "so", "as", "to", "prevent", "over", "-", "and", "underflow", "." ]

[ "func", "postMergeCommand", "(", "cmd", "*", "cobra", ".", "Command", ",", "args", "[", "]", "string", ")", "{", "if", "len", "(", "args", ")", "!=", "1", "{", "Print", "(", "\"", "\"", ")", "\n", "os", ".", "Exit", "(", "1", ")", "\n", "}", "\n\n", "// Skip entire hook if lockable read only feature is disabled", "if", "!", "cfg", ".", "SetLockableFilesReadOnly", "(", ")", "{", "os", ".", "Exit", "(", "0", ")", "\n", "}", "\n\n", "requireGitVersion", "(", ")", "\n\n", "lockClient", ":=", "newLockClient", "(", ")", "\n\n", "// Skip this hook if no lockable patterns have been configured", "if", "len", "(", "lockClient", ".", "GetLockablePatterns", "(", ")", ")", "==", "0", "{", "os", ".", "Exit", "(", "0", ")", "\n", "}", "\n\n", "// The only argument this hook receives is a flag indicating whether the", "// merge was a squash merge; we don't know what files changed.", "// Whether it's squash or not is irrelevant, either way it could have", "// reset the read-only flag on files that got merged.", "tracerx", ".", "Printf", "(", "\"", "\"", ")", "\n", "// Sadly we don't get any information about what files were checked out,", "// so we have to check the entire repo", "err", ":=", "lockClient", ".", "FixAllLockableFileWriteFlags", "(", ")", "\n", "if", "err", "!=", "nil", "{", "LoggedError", "(", "err", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}" ]

[ "postMergeCommand", "is", "run", "through", "Git", "s", "post", "-", "merge", "hook", ".", "This", "hook", "checks", "that", "files", "which", "are", "lockable", "and", "not", "locked", "are", "made", "read", "-", "only", "optimising", "that", "as", "best", "it", "can", "based", "on", "the", "available", "information", "." ]

[ "func", "(", "o", "*", "FilterProcessScanner", ")", "Init", "(", ")", "error", "{", "tracerx", ".", "Printf", "(", "\"", "\"", ")", "\n", "reqVer", ":=", "\"", "\"", "\n\n", "initMsg", ",", "err", ":=", "o", ".", "pl", ".", "readPacketText", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "initMsg", "!=", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "initMsg", ")", "\n", "}", "\n\n", "supVers", ",", "err", ":=", "o", ".", "pl", ".", "readPacketList", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "!", "isStringInSlice", "(", "supVers", ",", "reqVer", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reqVer", ",", "supVers", ")", "\n", "}", "\n\n", "err", "=", "o", ".", "pl", ".", "writePacketList", "(", "[", "]", "string", "{", "\"", "\"", ",", "reqVer", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Init", "initializes", "the", "filter", "and", "ACKs", "back", "and", "forth", "between", "the", "Git", "LFS", "subprocess", "and", "the", "Git", "parent", "process", "that", "each", "is", "a", "git", "-", "filter", "-", "server", "and", "client", "respectively", ".", "If", "either", "side", "wrote", "an", "invalid", "sequence", "of", "data", "or", "did", "not", "meet", "expectations", "an", "error", "will", "be", "returned", ".", "If", "the", "filter", "type", "is", "not", "supported", "an", "error", "will", "be", "returned", ".", "If", "the", "pkt", "-", "line", "welcome", "message", "was", "invalid", "an", "error", "will", "be", "returned", ".", "If", "there", "was", "an", "error", "reading", "or", "writing", "any", "of", "the", "packets", "below", "an", "error", "will", "be", "returned", "." ]

[ "func", "(", "o", "*", "FilterProcessScanner", ")", "NegotiateCapabilities", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "reqCaps", ":=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n\n", "supCaps", ",", "err", ":=", "o", ".", "pl", ".", "readPacketList", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "for", "_", ",", "sup", ":=", "range", "supCaps", "{", "if", "sup", "==", "\"", "\"", "{", "reqCaps", "=", "append", "(", "reqCaps", ",", "\"", "\"", ")", "\n", "break", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "reqCap", ":=", "range", "reqCaps", "{", "if", "!", "isStringInSlice", "(", "supCaps", ",", "reqCap", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reqCap", ",", "supCaps", ")", "\n", "}", "\n", "}", "\n\n", "err", "=", "o", ".", "pl", ".", "writePacketList", "(", "reqCaps", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "supCaps", ",", "nil", "\n", "}" ]

[ "NegotiateCapabilities", "executes", "the", "process", "of", "negotiating", "capabilities", "between", "the", "filter", "client", "and", "server", ".", "If", "we", "don", "t", "support", "any", "of", "the", "capabilities", "given", "to", "LFS", "by", "Git", "an", "error", "will", "be", "returned", ".", "If", "there", "was", "an", "error", "reading", "or", "writing", "capabilities", "between", "the", "two", "an", "error", "will", "be", "returned", "." ]

[ "func", "(", "o", "*", "FilterProcessScanner", ")", "readRequest", "(", ")", "(", "*", "Request", ",", "error", ")", "{", "requestList", ",", "err", ":=", "o", ".", "pl", ".", "readPacketList", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "req", ":=", "&", "Request", "{", "Header", ":", "make", "(", "map", "[", "string", "]", "string", ")", ",", "Payload", ":", "&", "pktlineReader", "{", "pl", ":", "o", ".", "pl", "}", ",", "}", "\n\n", "for", "_", ",", "pair", ":=", "range", "requestList", "{", "v", ":=", "strings", ".", "SplitN", "(", "pair", ",", "\"", "\"", ",", "2", ")", "\n", "req", ".", "Header", "[", "v", "[", "0", "]", "]", "=", "v", "[", "1", "]", "\n", "}", "\n\n", "return", "req", ",", "nil", "\n", "}" ]

[ "readRequest", "reads", "the", "headers", "of", "a", "request", "and", "yields", "an", "io", ".", "Reader", "which", "will", "read", "the", "body", "of", "the", "request", ".", "Since", "the", "body", "is", "_not_", "offset", "one", "request", "should", "be", "read", "in", "its", "entirety", "before", "consuming", "the", "next", "request", "." ]

[ "func", "(", "o", "*", "FilterProcessScanner", ")", "WriteList", "(", "list", "[", "]", "string", ")", "error", "{", "return", "o", ".", "pl", ".", "writePacketList", "(", "list", ")", "\n", "}" ]

[ "WriteList", "writes", "a", "list", "of", "strings", "to", "the", "underlying", "pktline", "data", "stream", "in", "pktline", "format", "." ]

[ "func", "WithRetries", "(", "req", "*", "http", ".", "Request", ",", "n", "int", ")", "*", "http", ".", "Request", "{", "ctx", ":=", "req", ".", "Context", "(", ")", "\n", "ctx", "=", "context", ".", "WithValue", "(", "ctx", ",", "contextKeyRetries", ",", "n", ")", "\n\n", "return", "req", ".", "WithContext", "(", "ctx", ")", "\n", "}" ]

[ "WithRetries", "stores", "the", "desired", "number", "of", "retries", "n", "on", "the", "given", "http", ".", "Request", "and", "causes", "it", "to", "be", "retried", "n", "times", "in", "the", "case", "of", "a", "non", "-", "nil", "network", "related", "error", "." ]

[ "func", "Retries", "(", "req", "*", "http", ".", "Request", ")", "(", "int", ",", "bool", ")", "{", "n", ",", "ok", ":=", "req", ".", "Context", "(", ")", ".", "Value", "(", "contextKeyRetries", ")", ".", "(", "int", ")", "\n\n", "return", "n", ",", "ok", "\n", "}" ]

[ "Retries", "returns", "the", "number", "of", "retries", "requested", "for", "a", "given", "http", ".", "Request", "." ]

[ "func", "(", "s", "*", "SimpleTask", ")", "Logf", "(", "str", "string", ",", "vals", "...", "interface", "{", "}", ")", "{", "s", ".", "ch", "<-", "&", "Update", "{", "S", ":", "fmt", ".", "Sprintf", "(", "str", ",", "vals", "...", ")", ",", "At", ":", "time", ".", "Now", "(", ")", ",", "}", "\n", "}" ]

[ "Logf", "logs", "some", "formatted", "string", "which", "is", "interpreted", "according", "to", "the", "rules", "defined", "in", "package", "fmt", "." ]

[ "func", "CopyWithCallback", "(", "writer", "io", ".", "Writer", ",", "reader", "io", ".", "Reader", ",", "totalSize", "int64", ",", "cb", "CopyCallback", ")", "(", "int64", ",", "error", ")", "{", "if", "success", ",", "_", ":=", "CloneFile", "(", "writer", ",", "reader", ")", ";", "success", "{", "if", "cb", "!=", "nil", "{", "cb", "(", "totalSize", ",", "totalSize", ",", "0", ")", "\n", "}", "\n", "return", "totalSize", ",", "nil", "\n", "}", "\n", "if", "cb", "==", "nil", "{", "return", "io", ".", "Copy", "(", "writer", ",", "reader", ")", "\n", "}", "\n\n", "cbReader", ":=", "&", "CallbackReader", "{", "C", ":", "cb", ",", "TotalSize", ":", "totalSize", ",", "Reader", ":", "reader", ",", "}", "\n", "return", "io", ".", "Copy", "(", "writer", ",", "cbReader", ")", "\n", "}" ]

[ "CopyWithCallback", "copies", "reader", "to", "writer", "while", "performing", "a", "progress", "callback" ]

[ "func", "Spool", "(", "to", "io", ".", "Writer", ",", "from", "io", ".", "Reader", ",", "dir", "string", ")", "(", "n", "int64", ",", "err", "error", ")", "{", "// First, buffer up to `memoryBufferLimit` in memory.", "buf", ":=", "make", "(", "[", "]", "byte", ",", "memoryBufferLimit", ")", "\n", "if", "bn", ",", "err", ":=", "from", ".", "Read", "(", "buf", ")", ";", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "int64", "(", "bn", ")", ",", "err", "\n", "}", "else", "{", "buf", "=", "buf", "[", ":", "bn", "]", "\n", "}", "\n\n", "var", "spool", "io", ".", "Reader", "=", "bytes", ".", "NewReader", "(", "buf", ")", "\n", "if", "err", "!=", "io", ".", "EOF", "{", "// If we weren't at the end of the stream, create a temporary", "// file, and spool the remaining contents there.", "tmp", ",", "err", ":=", "ioutil", ".", "TempFile", "(", "dir", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "defer", "os", ".", "Remove", "(", "tmp", ".", "Name", "(", ")", ")", "\n\n", "if", "n", ",", "err", "=", "io", ".", "Copy", "(", "tmp", ",", "from", ")", ";", "err", "!=", "nil", "{", "return", "n", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "_", ",", "err", "=", "tmp", ".", "Seek", "(", "0", ",", "io", ".", "SeekStart", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "// The spooled contents will now be the concatenation of the", "// contents we stored in memory, then the remainder of the", "// contents on disk.", "spool", "=", "io", ".", "MultiReader", "(", "spool", ",", "tmp", ")", "\n", "}", "\n\n", "return", "io", ".", "Copy", "(", "to", ",", "spool", ")", "\n", "}" ]

[ "Spool", "spools", "the", "contents", "from", "from", "to", "to", "by", "buffering", "the", "entire", "contents", "of", "from", "into", "a", "temprorary", "file", "created", "in", "the", "directory", "dir", ".", "That", "buffer", "is", "held", "in", "memory", "until", "the", "file", "grows", "to", "larger", "than", "memoryBufferLimit", "then", "the", "remaining", "contents", "are", "spooled", "to", "disk", ".", "The", "temporary", "file", "is", "cleaned", "up", "after", "the", "copy", "is", "complete", ".", "The", "number", "of", "bytes", "written", "to", "to", "as", "well", "as", "any", "error", "encountered", "are", "returned", "." ]

[ "func", "lsTreeBlobs", "(", "ref", "string", ",", "filter", "*", "filepathfilter", ".", "Filter", ")", "(", "*", "TreeBlobChannelWrapper", ",", "error", ")", "{", "cmd", ",", "err", ":=", "git", ".", "LsTree", "(", "ref", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "cmd", ".", "Stdin", ".", "Close", "(", ")", "\n\n", "blobs", ":=", "make", "(", "chan", "TreeBlob", ",", "chanBufSize", ")", "\n", "errchan", ":=", "make", "(", "chan", "error", ",", "1", ")", "\n\n", "go", "func", "(", ")", "{", "scanner", ":=", "newLsTreeScanner", "(", "cmd", ".", "Stdout", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "if", "t", ":=", "scanner", ".", "TreeBlob", "(", ")", ";", "t", "!=", "nil", "&&", "filter", ".", "Allows", "(", "t", ".", "Filename", ")", "{", "blobs", "<-", "*", "t", "\n", "}", "\n", "}", "\n\n", "stderr", ",", "_", ":=", "ioutil", ".", "ReadAll", "(", "cmd", ".", "Stderr", ")", "\n", "err", ":=", "cmd", ".", "Wait", "(", ")", "\n", "if", "err", "!=", "nil", "{", "errchan", "<-", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ",", "string", "(", "stderr", ")", ")", "\n", "}", "\n", "close", "(", "blobs", ")", "\n", "close", "(", "errchan", ")", "\n", "}", "(", ")", "\n\n", "return", "NewTreeBlobChannelWrapper", "(", "blobs", ",", "errchan", ")", ",", "nil", "\n", "}" ]

[ "Use", "ls", "-", "tree", "at", "ref", "to", "find", "a", "list", "of", "candidate", "tree", "blobs", "which", "might", "be", "lfs", "files", "The", "returned", "channel", "will", "be", "sent", "these", "blobs", "which", "should", "be", "sent", "to", "catFileBatchTree", "for", "final", "check", "&", "conversion", "to", "Pointer" ]

[ "func", "main", "(", ")", "{", "flag", ".", "Parse", "(", ")", "\n\n", "infof", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ")", "\n", "rootDir", ",", "fs", ":=", "readManDir", "(", ")", "\n", "manDir", ":=", "filepath", ".", "Join", "(", "rootDir", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "out", ",", "err", ":=", "os", ".", "Create", "(", "filepath", ".", "Join", "(", "rootDir", ",", "\"", "\"", ",", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "warnf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "err", ")", "\n", "os", ".", "Exit", "(", "2", ")", "\n", "}", "\n", "out", ".", "WriteString", "(", "\"", "\\n", "\\n", "\\n", "\"", ")", "\n", "out", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "out", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "fileregex", ":=", "regexp", ".", "MustCompile", "(", "`git-lfs(?:-([A-Za-z\\-]+))?.\\d.ronn`", ")", "\n", "headerregex", ":=", "regexp", ".", "MustCompile", "(", "`^###?\\s+([A-Za-z0-9 ]+)`", ")", "\n", "// only pick up caps in links to avoid matching optional args", "linkregex", ":=", "regexp", ".", "MustCompile", "(", "`\\[([A-Z\\- ]+)\\]`", ")", "\n", "// man links", "manlinkregex", ":=", "regexp", ".", "MustCompile", "(", "`(git)(?:-(lfs))?-([a-z\\-]+)\\(\\d\\)`", ")", "\n", "count", ":=", "0", "\n", "for", "_", ",", "f", ":=", "range", "fs", "{", "if", "match", ":=", "fileregex", ".", "FindStringSubmatch", "(", "f", ".", "Name", "(", ")", ")", ";", "match", "!=", "nil", "{", "infof", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "f", ".", "Name", "(", ")", ")", "\n", "cmd", ":=", "match", "[", "1", "]", "\n", "if", "len", "(", "cmd", ")", "==", "0", "{", "// This is git-lfs.1.ronn", "cmd", "=", "\"", "\"", "\n", "}", "\n", "out", ".", "WriteString", "(", "\"", "\\\"", "\"", "+", "cmd", "+", "\"", "\\\"", "\"", ")", "\n", "contentf", ",", "err", ":=", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "manDir", ",", "f", ".", "Name", "(", ")", ")", ")", "\n", "if", "err", "!=", "nil", "{", "warnf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "f", ".", "Name", "(", ")", ",", "err", ")", "\n", "os", ".", "Exit", "(", "2", ")", "\n", "}", "\n", "// Process the ronn to make it nicer as help text", "scanner", ":=", "bufio", ".", "NewScanner", "(", "contentf", ")", "\n", "firstHeaderDone", ":=", "false", "\n", "skipNextLineIfBlank", ":=", "false", "\n", "lastLineWasBullet", ":=", "false", "\n", "scanloop", ":", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "trimmedline", ":=", "strings", ".", "TrimSpace", "(", "line", ")", "\n", "if", "skipNextLineIfBlank", "&&", "len", "(", "trimmedline", ")", "==", "0", "{", "skipNextLineIfBlank", "=", "false", "\n", "lastLineWasBullet", "=", "false", "\n", "continue", "\n", "}", "\n\n", "// Special case headers", "if", "hmatch", ":=", "headerregex", ".", "FindStringSubmatch", "(", "line", ")", ";", "hmatch", "!=", "nil", "{", "header", ":=", "strings", ".", "ToLower", "(", "hmatch", "[", "1", "]", ")", "\n", "switch", "header", "{", "case", "\"", "\"", ":", "// Ignore this, just go direct to command", "case", "\"", "\"", ":", "// Just skip the header & newline", "skipNextLineIfBlank", "=", "true", "\n", "case", "\"", "\"", ":", "out", ".", "WriteString", "(", "\"", "\"", "+", "\"", "\\n", "\"", ")", "\n", "case", "\"", "\"", ":", "// don't include any content after this", "break", "scanloop", "\n", "default", ":", "out", ".", "WriteString", "(", "strings", ".", "ToUpper", "(", "header", "[", ":", "1", "]", ")", "+", "header", "[", "1", ":", "]", "+", "\"", "\\n", "\"", ")", "\n", "out", ".", "WriteString", "(", "strings", ".", "Repeat", "(", "\"", "\"", ",", "len", "(", "header", ")", ")", "+", "\"", "\\n", "\"", ")", "\n", "}", "\n", "firstHeaderDone", "=", "true", "\n", "lastLineWasBullet", "=", "false", "\n", "continue", "\n", "}", "\n\n", "if", "lmatches", ":=", "linkregex", ".", "FindAllStringSubmatch", "(", "line", ",", "-", "1", ")", ";", "lmatches", "!=", "nil", "{", "for", "_", ",", "lmatch", ":=", "range", "lmatches", "{", "linktext", ":=", "strings", ".", "ToLower", "(", "lmatch", "[", "1", "]", ")", "\n", "line", "=", "strings", ".", "Replace", "(", "line", ",", "lmatch", "[", "0", "]", ",", "`\"`", "+", "strings", ".", "ToUpper", "(", "linktext", "[", ":", "1", "]", ")", "+", "linktext", "[", "1", ":", "]", "+", "`\"`", ",", "1", ")", "\n", "}", "\n", "}", "\n", "if", "manmatches", ":=", "manlinkregex", ".", "FindAllStringSubmatch", "(", "line", ",", "-", "1", ")", ";", "manmatches", "!=", "nil", "{", "for", "_", ",", "manmatch", ":=", "range", "manmatches", "{", "line", "=", "strings", ".", "Replace", "(", "line", ",", "manmatch", "[", "0", "]", ",", "strings", ".", "Join", "(", "manmatch", "[", "1", ":", "]", ",", "\"", "\"", ")", ",", "1", ")", "\n", "}", "\n", "}", "\n\n", "// Skip content until after first header", "if", "!", "firstHeaderDone", "{", "continue", "\n", "}", "\n", "// OK, content here", "// remove characters that markdown would render invisible in a text env.", "for", "_", ",", "invis", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "{", "line", "=", "strings", ".", "Replace", "(", "line", ",", "invis", ",", "\"", "\"", ",", "-", "1", ")", "\n", "}", "\n\n", "// indent bullets", "if", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "{", "lastLineWasBullet", "=", "true", "\n", "}", "else", "if", "lastLineWasBullet", "&&", "!", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "{", "// indent paragraphs under bullets if not already done", "line", "=", "\"", "\"", "+", "line", "\n", "}", "\n\n", "out", ".", "WriteString", "(", "line", "+", "\"", "\\n", "\"", ")", "\n", "}", "\n", "out", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "contentf", ".", "Close", "(", ")", "\n", "count", "++", "\n", "}", "\n", "}", "\n", "out", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "infof", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "count", ")", "\n\n", "}" ]

[ "Reads", "all", ".", "ronn", "files", "&", "and", "converts", "them", "to", "string", "literals", "triggered", "by", "go", "generate", "comment", "Literals", "are", "inserted", "into", "a", "map", "using", "an", "init", "function", "this", "means", "that", "there", "are", "no", "compilation", "errors", "if", "go", "generate", "hasn", "t", "been", "run", "just", "blank", "man", "files", "." ]

[ "func", "compareHosts", "(", "searchHostname", ",", "configHostname", "string", ")", "int", "{", "searchHost", ":=", "strings", ".", "Split", "(", "searchHostname", ",", "\"", "\"", ")", "\n", "configHost", ":=", "strings", ".", "Split", "(", "configHostname", ",", "\"", "\"", ")", "\n\n", "if", "len", "(", "searchHost", ")", "!=", "len", "(", "configHost", ")", "{", "return", "0", "\n", "}", "\n\n", "score", ":=", "len", "(", "searchHost", ")", "+", "1", "\n\n", "for", "i", ",", "subdomain", ":=", "range", "searchHost", "{", "if", "configHost", "[", "i", "]", "==", "\"", "\"", "{", "score", "--", "\n", "continue", "\n", "}", "\n\n", "if", "subdomain", "!=", "configHost", "[", "i", "]", "{", "return", "0", "\n", "}", "\n", "}", "\n\n", "return", "score", "\n", "}" ]

[ "compareHosts", "compares", "a", "hostname", "with", "a", "configuration", "hostname", "to", "determine", "a", "match", ".", "It", "returns", "an", "integer", "indicating", "the", "strength", "of", "the", "match", "or", "0", "if", "the", "two", "hostnames", "did", "not", "match", "." ]

[ "func", "comparePaths", "(", "rawSearchPath", ",", "rawConfigPath", "string", ")", "int", "{", "f", ":=", "func", "(", "c", "rune", ")", "bool", "{", "return", "c", "==", "'/'", "\n", "}", "\n", "searchPath", ":=", "strings", ".", "FieldsFunc", "(", "rawSearchPath", ",", "f", ")", "\n", "configPath", ":=", "strings", ".", "FieldsFunc", "(", "rawConfigPath", ",", "f", ")", "\n\n", "if", "len", "(", "searchPath", ")", "<", "len", "(", "configPath", ")", "{", "return", "0", "\n", "}", "\n\n", "// Start with a base score of 1, so we return something above 0 for a", "// zero-length path", "score", ":=", "1", "\n\n", "for", "i", ",", "element", ":=", "range", "configPath", "{", "searchElement", ":=", "searchPath", "[", "i", "]", "\n\n", "if", "element", "==", "searchElement", "{", "score", "+=", "2", "\n", "continue", "\n", "}", "\n\n", "if", "isDefaultLFSUrl", "(", "searchElement", ",", "searchPath", ",", "i", "+", "1", ")", "{", "if", "searchElement", "[", "0", ":", "len", "(", "searchElement", ")", "-", "4", "]", "==", "element", "{", "// Since we matched without the `.git` prefix, only add one", "// point to the score instead of 2", "score", "++", "\n", "continue", "\n", "}", "\n", "}", "\n\n", "return", "0", "\n", "}", "\n\n", "return", "score", "\n", "}" ]

[ "comparePaths", "compares", "a", "path", "with", "a", "configuration", "path", "to", "determine", "a", "match", ".", "It", "returns", "an", "integer", "indicating", "the", "strength", "of", "the", "match", "or", "0", "if", "the", "two", "paths", "did", "not", "match", "." ]

[ "func", "(", "a", "*", "customAdapter", ")", "sendMessage", "(", "ctx", "*", "customAdapterWorkerContext", ",", "req", "interface", "{", "}", ")", "error", "{", "b", ",", "err", ":=", "json", ".", "Marshal", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "a", ".", "Trace", "(", "\"", "\"", ",", "ctx", ".", "workerNum", ",", "string", "(", "b", ")", ")", "\n", "// Line oriented JSON", "b", "=", "append", "(", "b", ",", "'\\n'", ")", "\n", "_", ",", "err", "=", "ctx", ".", "stdin", ".", "Write", "(", "b", ")", "\n", "return", "err", "\n", "}" ]

[ "sendMessage", "sends", "a", "JSON", "message", "to", "the", "custom", "adapter", "process" ]

[ "func", "(", "a", "*", "customAdapter", ")", "exchangeMessage", "(", "ctx", "*", "customAdapterWorkerContext", ",", "req", "interface", "{", "}", ")", "(", "*", "customAdapterResponseMessage", ",", "error", ")", "{", "err", ":=", "a", ".", "sendMessage", "(", "ctx", ",", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "a", ".", "readResponse", "(", "ctx", ")", "\n", "}" ]

[ "exchangeMessage", "sends", "a", "message", "to", "a", "process", "and", "reads", "a", "response", "if", "resp", "!", "=", "nil", "Only", "fatal", "errors", "to", "communicate", "return", "an", "error", "errors", "may", "be", "embedded", "in", "reply" ]

[ "func", "(", "a", "*", "customAdapter", ")", "abortWorkerProcess", "(", "ctx", "*", "customAdapterWorkerContext", ")", "{", "a", ".", "Trace", "(", "\"", "\"", ",", "ctx", ".", "workerNum", ")", "\n", "ctx", ".", "stdin", ".", "Close", "(", ")", "\n", "ctx", ".", "stdout", ".", "Close", "(", ")", "\n", "ctx", ".", "cmd", ".", "Process", ".", "Kill", "(", ")", "\n", "}" ]

[ "abortWorkerProcess", "terminates", "&", "aborts", "untidily", "most", "probably", "breakdown", "of", "comms", "or", "internal", "error" ]

[ "func", "configureCustomAdapters", "(", "git", "Env", ",", "m", "*", "Manifest", ")", "{", "pathRegex", ":=", "regexp", ".", "MustCompile", "(", "`lfs.customtransfer.([^.]+).path`", ")", "\n", "for", "k", ",", "_", ":=", "range", "git", ".", "All", "(", ")", "{", "match", ":=", "pathRegex", ".", "FindStringSubmatch", "(", "k", ")", "\n", "if", "match", "==", "nil", "{", "continue", "\n", "}", "\n\n", "name", ":=", "match", "[", "1", "]", "\n", "path", ",", "_", ":=", "git", ".", "Get", "(", "k", ")", "\n", "// retrieve other values", "args", ",", "_", ":=", "git", ".", "Get", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "concurrent", ":=", "git", ".", "Bool", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ",", "true", ")", "\n", "direction", ",", "_", ":=", "git", ".", "Get", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ")", ")", "\n", "if", "len", "(", "direction", ")", "==", "0", "{", "direction", "=", "\"", "\"", "\n", "}", "else", "{", "direction", "=", "strings", ".", "ToLower", "(", "direction", ")", "\n", "}", "\n\n", "// Separate closure for each since we need to capture vars above", "newfunc", ":=", "func", "(", "name", "string", ",", "dir", "Direction", ")", "Adapter", "{", "standalone", ":=", "m", ".", "standaloneTransferAgent", "!=", "\"", "\"", "\n", "return", "newCustomAdapter", "(", "m", ".", "fs", ",", "name", ",", "dir", ",", "path", ",", "args", ",", "concurrent", ",", "standalone", ")", "\n", "}", "\n\n", "if", "direction", "==", "\"", "\"", "||", "direction", "==", "\"", "\"", "{", "m", ".", "RegisterNewAdapterFunc", "(", "name", ",", "Download", ",", "newfunc", ")", "\n", "}", "\n", "if", "direction", "==", "\"", "\"", "||", "direction", "==", "\"", "\"", "{", "m", ".", "RegisterNewAdapterFunc", "(", "name", ",", "Upload", ",", "newfunc", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Initialise", "custom", "adapters", "based", "on", "current", "config" ]

[ "func", "FileExistsOfSize", "(", "path", "string", ",", "sz", "int64", ")", "bool", "{", "fi", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "false", "\n", "}", "\n\n", "return", "!", "fi", ".", "IsDir", "(", ")", "&&", "fi", ".", "Size", "(", ")", "==", "sz", "\n", "}" ]

[ "FileExistsOfSize", "determines", "if", "a", "file", "exists", "and", "is", "of", "a", "specific", "size", "." ]

[ "func", "ResolveSymlinks", "(", "path", "string", ")", "string", "{", "if", "len", "(", "path", ")", "==", "0", "{", "return", "path", "\n", "}", "\n\n", "if", "resolved", ",", "err", ":=", "filepath", ".", "EvalSymlinks", "(", "path", ")", ";", "err", "==", "nil", "{", "return", "resolved", "\n", "}", "\n", "return", "path", "\n", "}" ]

[ "ResolveSymlinks", "ensures", "that", "if", "the", "path", "supplied", "is", "a", "symlink", "it", "is", "resolved", "to", "the", "actual", "concrete", "path" ]

[ "func", "RenameFileCopyPermissions", "(", "srcfile", ",", "destfile", "string", ")", "error", "{", "info", ",", "err", ":=", "os", ".", "Stat", "(", "destfile", ")", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "// no original file", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "if", "err", ":=", "os", ".", "Chmod", "(", "srcfile", ",", "info", ".", "Mode", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "srcfile", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "os", ".", "Rename", "(", "srcfile", ",", "destfile", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "destfile", ",", "srcfile", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "RenameFileCopyPermissions", "moves", "srcfile", "to", "destfile", "replacing", "destfile", "if", "necessary", "and", "also", "copying", "the", "permissions", "of", "destfile", "if", "it", "already", "exists" ]

[ "func", "MkdirAll", "(", "path", "string", ",", "config", "repositoryPermissionFetcher", ")", "error", "{", "umask", ":=", "0777", "&", "^", "config", ".", "RepositoryPermissions", "(", "true", ")", "\n", "return", "doWithUmask", "(", "int", "(", "umask", ")", ",", "func", "(", ")", "error", "{", "return", "os", ".", "MkdirAll", "(", "path", ",", "config", ".", "RepositoryPermissions", "(", "true", ")", ")", "\n", "}", ")", "\n", "}" ]

[ "MkdirAll", "makes", "a", "directory", "and", "any", "intervening", "directories", "with", "the", "permissions", "specified", "by", "the", "core", ".", "sharedRepository", "setting", "." ]

[ "func", "VerifyFileHash", "(", "oid", ",", "path", "string", ")", "error", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "h", ":=", "NewLfsContentHash", "(", ")", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "h", ",", "f", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "calcOid", ":=", "hex", ".", "EncodeToString", "(", "h", ".", "Sum", "(", "nil", ")", ")", "\n", "if", "calcOid", "!=", "oid", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "path", ",", "calcOid", ",", "oid", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "VerifyFileHash", "reads", "a", "file", "and", "verifies", "whether", "the", "SHA", "is", "correct", "Returns", "an", "error", "if", "there", "is", "a", "problem" ]

[ "func", "loadExcludeFilename", "(", "filename", ",", "workDir", "string", ",", "excludePaths", "[", "]", "filepathfilter", ".", "Pattern", ")", "(", "[", "]", "filepathfilter", ".", "Pattern", ",", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "OpenFile", "(", "filename", ",", "os", ".", "O_RDONLY", ",", "0644", ")", "\n", "if", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "excludePaths", ",", "nil", "\n", "}", "\n", "return", "excludePaths", ",", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "retPaths", ":=", "excludePaths", "\n", "modified", ":=", "false", "\n\n", "scanner", ":=", "bufio", ".", "NewScanner", "(", "f", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "strings", ".", "TrimSpace", "(", "scanner", ".", "Text", "(", ")", ")", "\n", "// Skip blanks, comments and negations (not supported right now)", "if", "len", "(", "line", ")", "==", "0", "||", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "||", "strings", ".", "HasPrefix", "(", "line", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n\n", "if", "!", "modified", "{", "// copy on write", "retPaths", "=", "make", "(", "[", "]", "filepathfilter", ".", "Pattern", ",", "len", "(", "excludePaths", ")", ")", "\n", "copy", "(", "retPaths", ",", "excludePaths", ")", "\n", "modified", "=", "true", "\n", "}", "\n\n", "path", ":=", "line", "\n", "// Add pattern in context if exclude has separator, or no wildcard", "// Allow for both styles of separator at this point", "if", "strings", ".", "ContainsAny", "(", "path", ",", "\"", "\\\\", "\"", ")", "||", "!", "strings", ".", "Contains", "(", "path", ",", "\"", "\"", ")", "{", "path", "=", "join", "(", "workDir", ",", "line", ")", "\n", "}", "\n", "retPaths", "=", "append", "(", "retPaths", ",", "filepathfilter", ".", "NewPattern", "(", "path", ")", ")", "\n", "}", "\n\n", "return", "retPaths", ",", "nil", "\n", "}" ]

[ "loadExcludeFilename", "reads", "the", "given", "file", "in", "gitignore", "format", "and", "returns", "a", "revised", "array", "of", "exclude", "paths", "if", "there", "are", "any", "changes", ".", "If", "any", "changes", "are", "made", "a", "copy", "of", "the", "array", "is", "taken", "so", "the", "original", "is", "not", "modified" ]

[ "func", "(", "w", "*", "PktlineWriter", ")", "Flush", "(", ")", "error", "{", "if", "w", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "w", ".", "flush", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "pl", ".", "writeFlush", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Flush", "empties", "the", "internal", "buffer", "used", "to", "store", "data", "temporarily", "and", "then", "writes", "the", "pkt", "-", "line", "s", "FLUSH", "packet", "to", "signal", "that", "it", "is", "done", "writing", "this", "chunk", "of", "data", "." ]

[ "func", "(", "w", "*", "PktlineWriter", ")", "flush", "(", ")", "(", "int", ",", "error", ")", "{", "var", "n", "int", "\n\n", "for", "len", "(", "w", ".", "buf", ")", ">", "0", "{", "if", "err", ":=", "w", ".", "pl", ".", "writePacket", "(", "w", ".", "buf", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "m", ":=", "tools", ".", "MinInt", "(", "len", "(", "w", ".", "buf", ")", ",", "MaxPacketLength", ")", "\n\n", "w", ".", "buf", "=", "w", ".", "buf", "[", "m", ":", "]", "\n\n", "n", "=", "n", "+", "m", "\n", "}", "\n\n", "return", "n", ",", "nil", "\n", "}" ]

[ "flush", "writes", "any", "data", "in", "the", "internal", "buffer", "out", "to", "the", "underlying", "protocol", "stream", ".", "If", "the", "amount", "of", "data", "in", "the", "internal", "buffer", "exceeds", "the", "MaxPacketLength", "the", "data", "will", "be", "written", "in", "multiple", "packets", "to", "accommodate", ".", "flush", "returns", "the", "number", "of", "bytes", "written", "to", "the", "underlying", "packet", "stream", "and", "any", "error", "that", "it", "encountered", "along", "the", "way", "." ]

[ "func", "ParseBytes", "(", "str", "string", ")", "(", "uint64", ",", "error", ")", "{", "var", "sep", "int", "\n", "for", "_", ",", "r", ":=", "range", "str", "{", "if", "!", "(", "unicode", ".", "IsDigit", "(", "r", ")", "||", "r", "==", "'.'", "||", "r", "==", "','", ")", "{", "break", "\n", "}", "\n\n", "sep", "=", "sep", "+", "1", "\n", "}", "\n\n", "var", "f", "float64", "\n\n", "if", "s", ":=", "strings", ".", "Replace", "(", "str", "[", ":", "sep", "]", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", ";", "len", "(", "s", ")", ">", "0", "{", "var", "err", "error", "\n\n", "f", ",", "err", "=", "strconv", ".", "ParseFloat", "(", "s", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "}", "\n\n", "m", ",", "err", ":=", "ParseByteUnit", "(", "str", "[", "sep", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "f", "=", "f", "*", "float64", "(", "m", ")", "\n", "if", "f", ">=", "math", ".", "MaxUint64", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "uint64", "(", "f", ")", ",", "nil", "\n", "}" ]

[ "ParseBytes", "parses", "a", "given", "human", "-", "readable", "bytes", "or", "ibytes", "string", "into", "a", "number", "of", "bytes", "or", "an", "error", "if", "the", "string", "was", "unable", "to", "be", "parsed", "." ]

[ "func", "ParseByteUnit", "(", "str", "string", ")", "(", "uint64", ",", "error", ")", "{", "str", "=", "strings", ".", "TrimSpace", "(", "str", ")", "\n", "str", "=", "strings", ".", "ToLower", "(", "str", ")", "\n\n", "if", "u", ",", "ok", ":=", "bytesTable", "[", "str", "]", ";", "ok", "{", "return", "u", ",", "nil", "\n", "}", "\n", "return", "0", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "str", ")", "\n", "}" ]

[ "ParseByteUnit", "returns", "the", "number", "of", "bytes", "in", "a", "given", "unit", "of", "storage", "or", "an", "error", "if", "that", "unit", "is", "unrecognized", "." ]

[ "func", "FormatBytes", "(", "s", "uint64", ")", "string", "{", "var", "e", "float64", "\n", "if", "s", "==", "0", "{", "e", "=", "0", "\n", "}", "else", "{", "e", "=", "math", ".", "Floor", "(", "log", "(", "float64", "(", "s", ")", ",", "1000", ")", ")", "\n", "}", "\n\n", "unit", ":=", "uint64", "(", "math", ".", "Pow", "(", "1000", ",", "e", ")", ")", "\n", "suffix", ":=", "sizes", "[", "int", "(", "e", ")", "]", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "FormatBytesUnit", "(", "s", ",", "unit", ")", ",", "suffix", ")", "\n", "}" ]

[ "FormatBytes", "outputs", "the", "given", "number", "of", "bytes", "s", "as", "a", "human", "-", "readable", "string", "rounding", "to", "the", "nearest", "half", "within", ".", "01", "." ]

[ "func", "FormatBytesUnit", "(", "s", ",", "u", "uint64", ")", "string", "{", "var", "rounded", "float64", "\n", "if", "s", "<", "10", "{", "rounded", "=", "float64", "(", "s", ")", "\n", "}", "else", "{", "rounded", "=", "math", ".", "Floor", "(", "float64", "(", "s", ")", "/", "float64", "(", "u", ")", "*", "10", "+", ".5", ")", "/", "10", "\n", "}", "\n\n", "format", ":=", "\"", "\"", "\n", "if", "rounded", "<", "10", "&&", "u", ">", "1", "{", "format", "=", "\"", "\"", "\n", "}", "\n\n", "return", "fmt", ".", "Sprintf", "(", "format", ",", "rounded", ")", "\n", "}" ]

[ "FormatBytesUnit", "outputs", "the", "given", "number", "of", "bytes", "s", "as", "a", "quantity", "of", "the", "given", "units", "u", "to", "the", "nearest", "half", "within", ".", "01", "." ]

[ "func", "fetchRecent", "(", "fetchconf", "lfs", ".", "FetchPruneConfig", ",", "alreadyFetchedRefs", "[", "]", "*", "git", ".", "Ref", ",", "filter", "*", "filepathfilter", ".", "Filter", ")", "bool", "{", "if", "fetchconf", ".", "FetchRecentRefsDays", "==", "0", "&&", "fetchconf", ".", "FetchRecentCommitsDays", "==", "0", "{", "return", "true", "\n", "}", "\n\n", "ok", ":=", "true", "\n", "// Make a list of what unique commits we've already fetched for to avoid duplicating work", "uniqueRefShas", ":=", "make", "(", "map", "[", "string", "]", "string", ",", "len", "(", "alreadyFetchedRefs", ")", ")", "\n", "for", "_", ",", "ref", ":=", "range", "alreadyFetchedRefs", "{", "uniqueRefShas", "[", "ref", ".", "Sha", "]", "=", "ref", ".", "Name", "\n", "}", "\n", "// First find any other recent refs", "if", "fetchconf", ".", "FetchRecentRefsDays", ">", "0", "{", "Print", "(", "\"", "\"", ",", "fetchconf", ".", "FetchRecentRefsDays", ")", "\n", "refsSince", ":=", "time", ".", "Now", "(", ")", ".", "AddDate", "(", "0", ",", "0", ",", "-", "fetchconf", ".", "FetchRecentRefsDays", ")", "\n", "refs", ",", "err", ":=", "git", ".", "RecentBranches", "(", "refsSince", ",", "fetchconf", ".", "FetchRecentRefsIncludeRemotes", ",", "cfg", ".", "Remote", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "Panic", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "_", ",", "ref", ":=", "range", "refs", "{", "// Don't fetch for the same SHA twice", "if", "prevRefName", ",", "ok", ":=", "uniqueRefShas", "[", "ref", ".", "Sha", "]", ";", "ok", "{", "if", "ref", ".", "Name", "!=", "prevRefName", "{", "tracerx", ".", "Printf", "(", "\"", "\"", ",", "ref", ".", "Name", ",", "prevRefName", ")", "\n", "}", "\n", "}", "else", "{", "uniqueRefShas", "[", "ref", ".", "Sha", "]", "=", "ref", ".", "Name", "\n", "Print", "(", "\"", "\"", ",", "ref", ".", "Name", ")", "\n", "k", ":=", "fetchRef", "(", "ref", ".", "Sha", ",", "filter", ")", "\n", "ok", "=", "ok", "&&", "k", "\n", "}", "\n", "}", "\n", "}", "\n", "// For every unique commit we've fetched, check recent commits too", "if", "fetchconf", ".", "FetchRecentCommitsDays", ">", "0", "{", "for", "commit", ",", "refName", ":=", "range", "uniqueRefShas", "{", "// We measure from the last commit at the ref", "summ", ",", "err", ":=", "git", ".", "GetCommitSummary", "(", "commit", ")", "\n", "if", "err", "!=", "nil", "{", "Error", "(", "\"", "\"", ",", "refName", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "Print", "(", "\"", "\"", ",", "fetchconf", ".", "FetchRecentCommitsDays", ",", "refName", ")", "\n", "commitsSince", ":=", "summ", ".", "CommitDate", ".", "AddDate", "(", "0", ",", "0", ",", "-", "fetchconf", ".", "FetchRecentCommitsDays", ")", "\n", "k", ":=", "fetchPreviousVersions", "(", "commit", ",", "commitsSince", ",", "filter", ")", "\n", "ok", "=", "ok", "&&", "k", "\n", "}", "\n\n", "}", "\n", "return", "ok", "\n", "}" ]

[ "Fetch", "recent", "objects", "based", "on", "config" ]

[ "func", "(", "p", "*", "pktline", ")", "readPacketList", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "list", "[", "]", "string", "\n", "for", "{", "data", ",", "err", ":=", "p", ".", "readPacketText", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "data", ")", "==", "0", "{", "break", "\n", "}", "\n\n", "list", "=", "append", "(", "list", ",", "data", ")", "\n", "}", "\n\n", "return", "list", ",", "nil", "\n", "}" ]

[ "readPacketList", "reads", "as", "many", "packets", "as", "possible", "using", "the", "readPacketText", "function", "before", "encountering", "a", "flush", "packet", ".", "It", "returns", "a", "slice", "of", "all", "the", "packets", "it", "read", "or", "an", "error", "if", "one", "was", "encountered", "." ]

[ "func", "(", "p", "*", "pktline", ")", "writeFlush", "(", ")", "error", "{", "if", "_", ",", "err", ":=", "p", ".", "w", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "0", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "p", ".", "w", ".", "Flush", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "writeFlush", "writes", "the", "terminating", "flush", "packet", "and", "then", "flushes", "the", "underlying", "buffered", "writer", ".", "If", "any", "error", "was", "encountered", "along", "the", "way", "it", "will", "be", "returned", "immediately" ]

[ "func", "(", "p", "*", "pktline", ")", "writePacketText", "(", "data", "string", ")", "error", "{", "return", "p", ".", "writePacket", "(", "[", "]", "byte", "(", "data", "+", "\"", "\\n", "\"", ")", ")", "\n", "}" ]

[ "writePacketText", "follows", "the", "same", "semantics", "as", "writePacket", "but", "appends", "a", "trailing", "\\", "n", "LF", "character", "to", "the", "end", "of", "the", "data", "." ]

[ "func", "(", "p", "*", "pktline", ")", "writePacketList", "(", "list", "[", "]", "string", ")", "error", "{", "for", "_", ",", "i", ":=", "range", "list", "{", "if", "err", ":=", "p", ".", "writePacketText", "(", "i", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "p", ".", "writeFlush", "(", ")", "\n", "}" ]

[ "writePacketList", "writes", "a", "slice", "of", "strings", "using", "the", "semantics", "of", "and", "then", "writes", "a", "terminating", "flush", "sequence", "afterwords", ".", "If", "any", "error", "was", "encountered", "it", "will", "be", "returned", "immediately", "." ]

[ "func", "fileExistsOfSize", "(", "p", "*", "lfs", ".", "WrappedPointer", ")", "bool", "{", "path", ":=", "cfg", ".", "Filesystem", "(", ")", ".", "DecodePathname", "(", "p", ".", "Name", ")", "\n", "info", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", "\n", "return", "err", "==", "nil", "&&", "info", ".", "Size", "(", ")", "==", "p", ".", "Size", "\n", "}" ]

[ "Returns", "true", "if", "a", "pointer", "appears", "to", "be", "properly", "smudge", "on", "checkout" ]

[ "func", "(", "r", "*", "BodyWithCallback", ")", "Read", "(", "p", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "n", ",", "err", ":=", "r", ".", "ReadSeekCloser", ".", "Read", "(", "p", ")", "\n\n", "if", "n", ">", "0", "{", "r", ".", "readSize", "+=", "int64", "(", "n", ")", "\n\n", "if", "(", "err", "==", "nil", "||", "err", "==", "io", ".", "EOF", ")", "&&", "r", ".", "c", "!=", "nil", "{", "err", "=", "r", ".", "c", "(", "r", ".", "totalSize", ",", "r", ".", "readSize", ",", "n", ")", "\n", "}", "\n", "}", "\n", "return", "n", ",", "err", "\n", "}" ]

[ "Read", "wraps", "the", "underlying", "Reader", "s", "Read", "method", ".", "It", "also", "captures", "the", "number", "of", "bytes", "read", "and", "calls", "the", "callback", "." ]

[ "func", "(", "r", "*", "BodyWithCallback", ")", "Seek", "(", "offset", "int64", ",", "whence", "int", ")", "(", "int64", ",", "error", ")", "{", "switch", "whence", "{", "case", "io", ".", "SeekStart", ":", "r", ".", "readSize", "=", "offset", "\n", "case", "io", ".", "SeekCurrent", ":", "r", ".", "readSize", "+=", "offset", "\n", "case", "io", ".", "SeekEnd", ":", "r", ".", "readSize", "=", "r", ".", "totalSize", "+", "offset", "\n", "}", "\n\n", "return", "r", ".", "ReadSeekCloser", ".", "Seek", "(", "offset", ",", "whence", ")", "\n", "}" ]

[ "Seek", "wraps", "the", "underlying", "Seeker", "s", "Seek", "method", "updating", "the", "number", "of", "bytes", "that", "have", "been", "consumed", "by", "this", "reader", "." ]

[ "func", "(", "r", "*", "BodyWithCallback", ")", "ResetProgress", "(", ")", "error", "{", "return", "r", ".", "c", "(", "r", ".", "totalSize", ",", "r", ".", "readSize", ",", "-", "int", "(", "r", ".", "readSize", ")", ")", "\n", "}" ]

[ "ResetProgress", "calls", "the", "callback", "with", "a", "negative", "read", "size", "equal", "to", "the", "total", "number", "of", "bytes", "read", "so", "far", "effectively", "resetting", "the", "progress", "." ]

[ "func", "(", "s", "DiffIndexStatus", ")", "String", "(", ")", "string", "{", "switch", "s", "{", "case", "StatusAddition", ":", "return", "\"", "\"", "\n", "case", "StatusCopy", ":", "return", "\"", "\"", "\n", "case", "StatusDeletion", ":", "return", "\"", "\"", "\n", "case", "StatusModification", ":", "return", "\"", "\"", "\n", "case", "StatusRename", ":", "return", "\"", "\"", "\n", "case", "StatusTypeChange", ":", "return", "\"", "\"", "\n", "case", "StatusUnmerged", ":", "return", "\"", "\"", "\n", "case", "StatusUnknown", ":", "return", "\"", "\"", "\n", "}", "\n", "return", "\"", "\"", "\n", "}" ]

[ "String", "implements", "fmt", ".", "Stringer", "by", "returning", "a", "human", "-", "readable", "name", "for", "each", "status", "." ]

[ "func", "SetContext", "(", "err", "error", ",", "key", "string", ",", "value", "interface", "{", "}", ")", "{", "if", "e", ",", "ok", ":=", "err", ".", "(", "withContext", ")", ";", "ok", "{", "e", ".", "Set", "(", "key", ",", "value", ")", "\n", "}", "\n", "}" ]

[ "ErrorSetContext", "sets", "a", "value", "in", "the", "error", "s", "context", ".", "If", "the", "error", "has", "not", "been", "wrapped", "it", "does", "nothing", "." ]