pax_global_header00006660000000000000000000000064127774460170014531gustar00rootroot0000000000000052 comment=0cc6cfc11be21597b11470c1c1aaa7e4a92618db gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/000077500000000000000000000000001277744601700220435ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/.gitignore000066400000000000000000000001511277744601700240300ustar00rootroot00000000000000config.yml tmp/* *.log /*.log* authorized_keys.lock coverage/ .gitlab_shell_secret .bundle tags .bundle/ gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/.gitlab-ci.yml000066400000000000000000000012451277744601700245010ustar00rootroot00000000000000image: "ruby:2.3" before_script: - export PATH=~/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin - apt-get update - apt-get install -y git-annex - gem install --bindir /usr/local/bin bundler - cp config.yml.example config.yml - bundle install rspec: script: - bundle exec rspec spec tags: - ruby except: - tags rubocop: script: - bundle exec rubocop tags: - ruby except: - tags #ruby 2.2 rspec:ruby2.2: image: ruby:2.2 script: - bundle exec rspec spec tags: - ruby except: - tags #ruby 2.1 rspec:ruby2.1: image: ruby:2.1 script: - bundle exec rspec spec tags: - ruby except: - tags gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/.rspec000066400000000000000000000000101277744601700231470ustar00rootroot00000000000000--color gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/.rubocop.yml000066400000000000000000000757331277744601700243340ustar00rootroot00000000000000Style/AccessModifierIndentation: Description: Check indentation of private/protected visibility modifiers. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#indent-public-private-protected' Enabled: true Style/AccessorMethodName: Description: Check the naming of accessor methods for get_/set_. Enabled: false Style/Alias: Description: 'Use alias_method instead of alias.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#alias-method' Enabled: true Style/AlignArray: Description: >- Align the elements of an array literal if they span more than one line. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#align-multiline-arrays' Enabled: true Style/AlignHash: Description: >- Align the elements of a hash literal if they span more than one line. Enabled: true Style/AlignParameters: Description: >- Align the parameters of a method call if they span more than one line. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-double-indent' Enabled: false Style/AndOr: Description: 'Use &&/|| instead of and/or.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-and-or-or' Enabled: false Style/ArrayJoin: Description: 'Use Array#join instead of Array#*.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#array-join' Enabled: false Style/AsciiComments: Description: 'Use only ascii symbols in comments.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#english-comments' Enabled: true Style/AsciiIdentifiers: Description: 'Use only ascii symbols in identifiers.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#english-identifiers' Enabled: true Style/Attr: Description: 'Checks for uses of Module#attr.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#attr' Enabled: false Style/BeginBlock: Description: 'Avoid the use of BEGIN blocks.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-BEGIN-blocks' Enabled: true Style/BarePercentLiterals: Description: 'Checks if usage of %() or %Q() matches configuration.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-q-shorthand' Enabled: false Style/BlockComments: Description: 'Do not use block comments.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-block-comments' Enabled: false Style/BlockEndNewline: Description: 'Put end statement of multiline block on its own line.' Enabled: true Style/Blocks: Description: >- Avoid using {...} for multi-line blocks (multiline chaining is always ugly). Prefer {...} over do...end for single-line blocks. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#single-line-blocks' Enabled: true Style/BracesAroundHashParameters: Description: 'Enforce braces style around hash parameters.' Enabled: false Style/CaseEquality: Description: 'Avoid explicit use of the case equality operator(===).' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-case-equality' Enabled: false Style/CaseIndentation: Description: 'Indentation of when in a case/when/[else/]end.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#indent-when-to-case' Enabled: true Style/CharacterLiteral: Description: 'Checks for uses of character literals.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-character-literals' Enabled: true Style/ClassAndModuleCamelCase: Description: 'Use CamelCase for classes and modules.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#camelcase-classes' Enabled: true Style/ClassAndModuleChildren: Description: 'Checks style of children classes and modules.' Enabled: false Style/ClassCheck: Description: 'Enforces consistent use of `Object#is_a?` or `Object#kind_of?`.' Enabled: false Style/ClassMethods: Description: 'Use self when defining module/class methods.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#def-self-singletons' Enabled: false Style/ClassVars: Description: 'Avoid the use of class variables.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-class-vars' Enabled: true Style/ColonMethodCall: Description: 'Do not use :: for method call.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#double-colons' Enabled: false Style/CommentAnnotation: Description: >- Checks formatting of special comments (TODO, FIXME, OPTIMIZE, HACK, REVIEW). StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#annotate-keywords' Enabled: false Style/CommentIndentation: Description: 'Indentation of comments.' Enabled: true Style/ConstantName: Description: 'Constants should use SCREAMING_SNAKE_CASE.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#screaming-snake-case' Enabled: true Style/DefWithParentheses: Description: 'Use def with parentheses when there are arguments.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#method-parens' Enabled: false Style/DeprecatedHashMethods: Description: 'Checks for use of deprecated Hash methods.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#hash-key' Enabled: false Style/Documentation: Description: 'Document classes and non-namespace modules.' Enabled: false Style/DotPosition: Description: 'Checks the position of the dot in multi-line method calls.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#consistent-multi-line-chains' Enabled: false Style/DoubleNegation: Description: 'Checks for uses of double negation (!!).' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-bang-bang' Enabled: false Style/EachWithObject: Description: 'Prefer `each_with_object` over `inject` or `reduce`.' Enabled: false Style/ElseAlignment: Description: 'Align elses and elsifs correctly.' Enabled: true Style/EmptyElse: Description: 'Avoid empty else-clauses.' Enabled: false Style/EmptyLineBetweenDefs: Description: 'Use empty lines between defs.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#empty-lines-between-methods' Enabled: false Style/EmptyLines: Description: "Don't use several empty lines in a row." Enabled: false Style/EmptyLinesAroundAccessModifier: Description: "Keep blank lines around access modifiers." Enabled: false Style/EmptyLinesAroundBlockBody: Description: "Keeps track of empty lines around block bodies." Enabled: false Style/EmptyLinesAroundClassBody: Description: "Keeps track of empty lines around class bodies." Enabled: false Style/EmptyLinesAroundModuleBody: Description: "Keeps track of empty lines around module bodies." Enabled: false Style/EmptyLinesAroundMethodBody: Description: "Keeps track of empty lines around method bodies." Enabled: false Style/EmptyLiteral: Description: 'Prefer literals to Array.new/Hash.new/String.new.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#literal-array-hash' Enabled: false Style/EndBlock: Description: 'Avoid the use of END blocks.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-END-blocks' Enabled: false Style/EndOfLine: Description: 'Use Unix-style line endings.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#crlf' Enabled: false Style/EvenOdd: Description: 'Favor the use of Fixnum#even? && Fixnum#odd?' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#predicate-methods' Enabled: false Style/FileName: Description: 'Use snake_case for source file names.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#snake-case-files' Enabled: false Style/FlipFlop: Description: 'Checks for flip flops' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-flip-flops' Enabled: false Style/For: Description: 'Checks use of for or each in multiline loops.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-for-loops' Enabled: false Style/FormatString: Description: 'Enforce the use of Kernel#sprintf, Kernel#format or String#%.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#sprintf' Enabled: false Style/GlobalVars: Description: 'Do not introduce global variables.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#instance-vars' Enabled: false Style/GuardClause: Description: 'Check for conditionals that can be replaced with guard clauses' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals' Enabled: false Style/HashSyntax: Description: >- Prefer Ruby 1.9 hash syntax { a: 1, b: 2 } over 1.8 syntax { :a => 1, :b => 2 }. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#hash-literals' Enabled: true Style/IfUnlessModifier: Description: >- Favor modifier if/unless usage when you have a single-line body. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#if-as-a-modifier' Enabled: false Style/IfWithSemicolon: Description: 'Do not use if x; .... Use the ternary operator instead.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-semicolon-ifs' Enabled: false Style/IndentationConsistency: Description: 'Keep indentation straight.' Enabled: true Style/IndentationWidth: Description: 'Use 2 spaces for indentation.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-indentation' Enabled: true Style/IndentArray: Description: >- Checks the indentation of the first element in an array literal. Enabled: false Style/IndentHash: Description: 'Checks the indentation of the first key in a hash literal.' Enabled: false Style/InfiniteLoop: Description: 'Use Kernel#loop for infinite loops.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#infinite-loop' Enabled: false Style/Lambda: Description: 'Use the new lambda literal syntax for single-line blocks.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#lambda-multi-line' Enabled: false Style/LambdaCall: Description: 'Use lambda.call(...) instead of lambda.(...).' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#proc-call' Enabled: false Style/LeadingCommentSpace: Description: 'Comments should start with a space.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#hash-space' Enabled: false Style/LineEndConcatenation: Description: >- Use \ instead of + or << to concatenate two string literals at line end. Enabled: false Style/MethodCallParentheses: Description: 'Do not use parentheses for method calls with no arguments.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-args-no-parens' Enabled: false Style/MethodDefParentheses: Description: >- Checks if the method definitions have or don't have parentheses. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#method-parens' Enabled: false Style/MethodName: Description: 'Use the configured style when naming methods.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#snake-case-symbols-methods-vars' Enabled: false Style/ModuleFunction: Description: 'Checks for usage of `extend self` in modules.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#module-function' Enabled: false Style/MultilineBlockChain: Description: 'Avoid multi-line chains of blocks.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#single-line-blocks' Enabled: false Style/MultilineBlockLayout: Description: 'Ensures newlines after multiline block do statements.' Enabled: false Style/MultilineIfThen: Description: 'Do not use then for multi-line if/unless.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-then' Enabled: false Style/MultilineOperationIndentation: Description: >- Checks indentation of binary operations that span more than one line. Enabled: false Style/MultilineTernaryOperator: Description: >- Avoid multi-line ?: (the ternary operator); use if/unless instead. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-multiline-ternary' Enabled: false Style/NegatedIf: Description: >- Favor unless over if for negative conditions (or control flow or). StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#unless-for-negatives' Enabled: false Style/NegatedWhile: Description: 'Favor until over while for negative conditions.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#until-for-negatives' Enabled: false Style/NestedTernaryOperator: Description: 'Use one expression per branch in a ternary operator.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-nested-ternary' Enabled: false Style/Next: Description: 'Use `next` to skip iteration instead of a condition at the end.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-nested-conditionals' Enabled: false Style/NilComparison: Description: 'Prefer x.nil? to x == nil.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#predicate-methods' Enabled: false Style/NonNilCheck: Description: 'Checks for redundant nil checks.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-non-nil-checks' Enabled: false Style/Not: Description: 'Use ! instead of not.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#bang-not-not' Enabled: false Style/NumericLiterals: Description: >- Add underscores to large numeric literals to improve their readability. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscores-in-numerics' Enabled: false Style/OneLineConditional: Description: >- Favor the ternary operator(?:) over if/then/else/end constructs. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#ternary-operator' Enabled: false Style/OpMethod: Description: 'When defining binary operators, name the argument other.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#other-arg' Enabled: false Style/ParenthesesAroundCondition: Description: >- Don't use parentheses around the condition of an if/unless/while. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-parens-if' Enabled: false Style/PercentLiteralDelimiters: Description: 'Use `%`-literal delimiters consistently' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-literal-braces' Enabled: false Style/PercentQLiterals: Description: 'Checks if uses of %Q/%q match the configured preference.' Enabled: false Style/PerlBackrefs: Description: 'Avoid Perl-style regex back references.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-perl-regexp-last-matchers' Enabled: false Style/PredicateName: Description: 'Check the names of predicate methods.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#bool-methods-qmark' Enabled: false Style/Proc: Description: 'Use proc instead of Proc.new.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#proc' Enabled: false Style/RaiseArgs: Description: 'Checks the arguments passed to raise/fail.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#exception-class-messages' Enabled: false Style/RedundantBegin: Description: "Don't use begin blocks when they are not needed." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#begin-implicit' Enabled: false Style/RedundantException: Description: "Checks for an obsolete RuntimeException argument in raise/fail." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-explicit-runtimeerror' Enabled: false Style/RedundantReturn: Description: "Don't use return where it's not required." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-explicit-return' Enabled: false Style/RedundantSelf: Description: "Don't use self where it's not needed." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-self-unless-required' Enabled: false Style/RegexpLiteral: Description: >- Use %r for regular expressions matching more than `MaxSlashes` '/' characters. Use %r only for regular expressions matching more than `MaxSlashes` '/' character. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-r' Enabled: false Style/RescueModifier: Description: 'Avoid using rescue in its modifier form.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-rescue-modifiers' Enabled: false Style/SelfAssignment: Description: >- Checks for places where self-assignment shorthand should have been used. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#self-assignment' Enabled: false Style/Semicolon: Description: "Don't use semicolons to terminate expressions." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-semicolon' Enabled: false Style/SignalException: Description: 'Checks for proper usage of fail and raise.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#fail-method' Enabled: false Style/SingleLineBlockParams: Description: 'Enforces the names of some block params.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#reduce-blocks' Enabled: false Style/SingleLineMethods: Description: 'Avoid single-line methods.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-single-line-methods' Enabled: false Style/SingleSpaceBeforeFirstArg: Description: >- Checks that exactly one space is used between a method name and the first argument for method calls without parentheses. Enabled: false Style/SpaceAfterColon: Description: 'Use spaces after colons.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-operators' Enabled: false Style/SpaceAfterComma: Description: 'Use spaces after commas.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-operators' Enabled: false Style/SpaceAfterControlKeyword: Description: 'Use spaces after if/elsif/unless/while/until/case/when.' Enabled: false Style/SpaceAfterMethodName: Description: >- Do not put a space between a method name and the opening parenthesis in a method definition. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#parens-no-spaces' Enabled: false Style/SpaceAfterNot: Description: Tracks redundant space after the ! operator. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-space-bang' Enabled: false Style/SpaceAfterSemicolon: Description: 'Use spaces after semicolons.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-operators' Enabled: false Style/SpaceBeforeBlockBraces: Description: >- Checks that the left block brace has or doesn't have space before it. Enabled: false Style/SpaceBeforeComma: Description: 'No spaces before commas.' Enabled: false Style/SpaceBeforeComment: Description: >- Checks for missing space between code and a comment on the same line. Enabled: false Style/SpaceBeforeSemicolon: Description: 'No spaces before semicolons.' Enabled: false Style/SpaceInsideBlockBraces: Description: >- Checks that block braces have or don't have surrounding space. For blocks taking parameters, checks that the left brace has or doesn't have trailing space. Enabled: false Style/SpaceAroundEqualsInParameterDefault: Description: >- Checks that the equals signs in parameter default assignments have or don't have surrounding space depending on configuration. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-around-equals' Enabled: false Style/SpaceAroundOperators: Description: 'Use spaces around operators.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-operators' Enabled: false Style/SpaceBeforeModifierKeyword: Description: 'Put a space before the modifier keyword.' Enabled: false Style/SpaceInsideBrackets: Description: 'No spaces after [ or before ].' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-spaces-braces' Enabled: false Style/SpaceInsideHashLiteralBraces: Description: "Use spaces inside hash literal braces - or don't." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-operators' Enabled: true Style/SpaceInsideParens: Description: 'No spaces after ( or before ).' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-spaces-braces' Enabled: false Style/SpaceInsideRangeLiteral: Description: 'No spaces inside range literals.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-space-inside-range-literals' Enabled: false Style/SpecialGlobalVars: Description: 'Avoid Perl-style global variables.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-cryptic-perlisms' Enabled: false Style/StringLiterals: Description: 'Checks if uses of quotes match the configured preference.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#consistent-string-literals' Enabled: false Style/StringLiteralsInInterpolation: Description: >- Checks if uses of quotes inside expressions in interpolated strings match the configured preference. Enabled: false Style/SymbolProc: Description: 'Use symbols as procs instead of blocks when possible.' Enabled: false Style/Tab: Description: 'No hard tabs.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#spaces-indentation' Enabled: false Style/TrailingBlankLines: Description: 'Checks trailing blank lines and final newline.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#newline-eof' Enabled: true Style/TrailingComma: Description: 'Checks for trailing comma in parameter lists and literals.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas' Enabled: false Style/TrailingWhitespace: Description: 'Avoid trailing whitespace.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-trailing-whitespace' Enabled: false Style/TrivialAccessors: Description: 'Prefer attr_* methods to trivial readers/writers.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#attr_family' Enabled: false Style/UnlessElse: Description: >- Do not use unless with else. Rewrite these with the positive case first. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-else-with-unless' Enabled: false Style/UnneededCapitalW: Description: 'Checks for %W when interpolation is not needed.' Enabled: false Style/UnneededPercentQ: Description: 'Checks for %q/%Q when single quotes or double quotes would do.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-q' Enabled: false Style/UnneededPercentX: Description: 'Checks for %x when `` would do.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-x' Enabled: false Style/VariableInterpolation: Description: >- Don't interpolate global, instance and class variables directly in strings. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#curlies-interpolate' Enabled: false Style/VariableName: Description: 'Use the configured style when naming variables.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#snake-case-symbols-methods-vars' Enabled: false Style/WhenThen: Description: 'Use when x then ... for one-line cases.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#one-line-cases' Enabled: false Style/WhileUntilDo: Description: 'Checks for redundant do after while or until.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-multiline-while-do' Enabled: false Style/WhileUntilModifier: Description: >- Favor modifier while/until usage when you have a single-line body. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#while-as-a-modifier' Enabled: false Style/WordArray: Description: 'Use %w or %W for arrays of words.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-w' Enabled: false #################### Metrics ################################ Metrics/AbcSize: Description: >- A calculated magnitude based on number of assignments, branches, and conditions. Enabled: false Metrics/BlockNesting: Description: 'Avoid excessive block nesting' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#three-is-the-number-thou-shalt-count' Enabled: false Metrics/ClassLength: Description: 'Avoid classes longer than 100 lines of code.' Enabled: false Metrics/CyclomaticComplexity: Description: >- A complexity metric that is strongly correlated to the number of test cases needed to validate a method. Enabled: false Metrics/LineLength: Description: 'Limit lines to 80 characters.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#80-character-limits' Enabled: false Metrics/MethodLength: Description: 'Avoid methods longer than 10 lines of code.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#short-methods' Enabled: false Metrics/ParameterLists: Description: 'Avoid parameter lists longer than three or four parameters.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#too-many-params' Enabled: false Metrics/PerceivedComplexity: Description: >- A complexity metric geared towards measuring complexity for a human reader. Enabled: false #################### Lint ################################ ### Warnings Lint/AmbiguousOperator: Description: >- Checks for ambiguous operators in the first argument of a method invocation without parentheses. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#parens-as-args' Enabled: false Lint/AmbiguousRegexpLiteral: Description: >- Checks for ambiguous regexp literals in the first argument of a method invocation without parenthesis. Enabled: false Lint/AssignmentInCondition: Description: "Don't use assignment in conditions." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#safe-assignment-in-condition' Enabled: false Lint/BlockAlignment: Description: 'Align block ends correctly.' Enabled: false Lint/ConditionPosition: Description: >- Checks for condition placed in a confusing position relative to the keyword. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#same-line-condition' Enabled: false Lint/Debugger: Description: 'Check for debugger calls.' Enabled: false Lint/DefEndAlignment: Description: 'Align ends corresponding to defs correctly.' Enabled: false Lint/DeprecatedClassMethods: Description: 'Check for deprecated class method calls.' Enabled: false Lint/ElseLayout: Description: 'Check for odd code arrangement in an else block.' Enabled: false Lint/EmptyEnsure: Description: 'Checks for empty ensure block.' Enabled: false Lint/EmptyInterpolation: Description: 'Checks for empty string interpolation.' Enabled: false Lint/EndAlignment: Description: 'Align ends correctly.' Enabled: false Lint/EndInMethod: Description: 'END blocks should not be placed inside method definitions.' Enabled: false Lint/EnsureReturn: Description: 'Do not use return in an ensure block.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-return-ensure' Enabled: false Lint/Eval: Description: 'The use of eval represents a serious security risk.' Enabled: false Lint/HandleExceptions: Description: "Don't suppress exception." StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#dont-hide-exceptions' Enabled: false Lint/InvalidCharacterLiteral: Description: >- Checks for invalid character literals with a non-escaped whitespace character. Enabled: false Lint/LiteralInCondition: Description: 'Checks of literals used in conditions.' Enabled: false Lint/LiteralInInterpolation: Description: 'Checks for literals used in interpolation.' Enabled: false Lint/Loop: Description: >- Use Kernel#loop with break rather than begin/end/until or begin/end/while for post-loop tests. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#loop-with-break' Enabled: false Lint/ParenthesesAsGroupedExpression: Description: >- Checks for method calls with a space before the opening parenthesis. StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#parens-no-spaces' Enabled: true Lint/RequireParentheses: Description: >- Use parentheses in the method call to avoid confusion about precedence. Enabled: false Lint/RescueException: Description: 'Avoid rescuing the Exception class.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-blind-rescues' Enabled: false Lint/ShadowingOuterLocalVariable: Description: >- Do not use the same name as outer local variable for block arguments or block local variables. Enabled: false Lint/SpaceBeforeFirstArg: Description: >- Put a space between a method name and the first argument in a method call without parentheses. Enabled: false Lint/StringConversionInInterpolation: Description: 'Checks for Object#to_s usage in string interpolation.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-to-s' Enabled: false Lint/UnderscorePrefixedVariableName: Description: 'Do not use prefix `_` for a variable that is used.' Enabled: true Lint/UnusedBlockArgument: Description: 'Checks for unused block arguments.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars' Enabled: false Lint/UnusedMethodArgument: Description: 'Checks for unused method arguments.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars' Enabled: false Lint/UnreachableCode: Description: 'Unreachable code.' Enabled: false Lint/UselessAccessModifier: Description: 'Checks for useless access modifiers.' Enabled: false Lint/UselessAssignment: Description: 'Checks for useless assignment to a local variable.' StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#underscore-unused-vars' Enabled: false Lint/UselessComparison: Description: 'Checks for comparison of something with itself.' Enabled: false Lint/UselessElseWithoutRescue: Description: 'Checks for useless `else` in `begin..end` without `rescue`.' Enabled: false Lint/UselessSetterCall: Description: 'Checks for useless setter call to a local variable.' Enabled: false Lint/Void: Description: 'Possible use of operator/literal/variable in void context.' Enabled: false # Exclude some of GitLab files # # AllCops: Exclude: - 'spec/**/*' - 'features/**/*' - 'vendor/**/*' - 'db/**/*' - 'tmp/**/*' - 'bin/**/*' - 'lib/backup/**/*' - 'lib/tasks/**/*' - 'lib/email_validator.rb' - 'lib/gitlab/upgrader.rb' - 'lib/gitlab/seeder.rb' - 'lib/vendor/**/*' gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/CHANGELOG000066400000000000000000000161061277744601700232610ustar00rootroot00000000000000v3.6.6 - Re-use the default logger when logging metrics data v3.6.5 - Test against ruby 2.3 - Instrument GitLab Shell and log metrics data to a file v3.6.4 - Fix rsync with ionice command building - Fix short circuit logic between rsync with and without ionice for storage migrations v3.6.3 - Re-exposing GL_ID to custom hooks v3.6.2 - Enable GIT_TRACE/GIT_TRACE_PACKET/GIT_TRACE_PERFORMANCE by providing the git_trace_log_file config key v3.6.1 - Set a low IO priority for storage moves to lower performance impact v3.6.0 - Added full support for `git-lfs-authenticate` to properly handle LFS requests and pass them on to Workhorse v3.5.0 - Add option to recover 2FA via SSH v3.4.0 - Redis Sentinel support v3.3.3 - Print URL for new or existing merge request after push v3.3.2 - Improve authorized_keys check v3.3.1 - Manage authorized_keys permissions continuously v3.3.0 - Track ongoing push commands - Add command to move repositories between repository storages v3.2.1 - Allow gitlab-project's fork-project command to fork projects between different repository storages v3.2.0 - Allow GitLab Shell to check for allowed access based on the used Git protocol - Add an error message when using shell commands with incompatible GitLab versions v3.1.0 - Refactor repository paths handling to allow multiple git mount points v3.0.1 - Update PostReceive worker to provide enqueued_at time. v3.0.0 - Remove rm-tag command (Robert Schilling) - Remove create-branch and rm-branch commands (Robert Schilling) - Update PostReceive worker so it logs a unique JID in Sidekiq - Remove update-head command - Use Redis Ruby client instead of shelling out to redis-cli v2.7.2 - Do not prune objects during 'git gc' v2.7.1 - Add new command to list tags from a remote repo - Add the ability to fetch remote repo with or without tags v2.7.0 - Add support for ssh AuthorizedKeysCommand query by key v2.6.13 - Add push-branches command - Add delete-remote-branches command v2.6.12 - Fix git-annex issue not working using custom SSH port repositories v2.6.11 - Increase HTTP timeout and log request durations - Workaround for a Webrick issue on Ruby 2.2 - New optional `--force` parameter for `gitlab-projects fetch-remote` v2.6.10 - Add git gc for housekeeping v2.6.9 - Remove trailing slashes from gitlab_url v2.6.8 - Revert git-lfs-authenticate command from white list v2.6.7 - Exit with non-zero status when import-repository fails - Add fetch-remote command v2.6.6 - Do not clean LANG environment variable for the git hooks when working through the SSH-protocol - Add git-lfs-authenticate command to white list (this command is used by git-lfs for SSO authentication through SSH-protocol) - Handle git-annex and gcryptsetup v2.6.5 - Handle broken symlinks in create-hooks v2.6.4 - Remove keys from authorized_keys in-place - Increase batch_add_keys lock timeout to 300 seconds - If git-annex is enabled set GIT_ANNEX_SHELL_LIMITED variable v2.6.3 - Prevent keys with a very specific comment from accidentally being deleted. v2.6.2 - Include ecdsa keys in `gitlab_keys list-keys`. - Refactor logic around GL_ID v2.6.1 - Write errors to stderr to get git to abort and show them as such. v2.6.0 - Prevent character encoding issues by sending received changes as raw data. v2.5.4 - Remove recursive commands from bin/install v2.5.3 - Improve git-annex integration v2.5.2 - Safer line sub for git-annex command v2.5.1 - Expect broadcast message to return empty JSON if no message now v2.5.0 - Support git-annex tool (disabled by default) - Add rubocop (Ruby static code analyzer) for development v2.4.3 - Print broadcast message if one is available v2.4.2 - Pass git changes list as string instead of array v2.4.1 - Access token masking in url before loging v2.4.0 - Show error message when git push is rejected v2.2.0 - Support for custom hooks (Drew Blessing and Jose Kahan) v2.1.0 - Use secret token with GitLab internal API. Requires GitLab 7.5 or higher v2.0.1 - Send post-receive changes to redis as a string instead of array v2.0.0 - Works with GitLab v7.3+ - Replace raise with abort when checking path to prevent path exposure - Handle invalid number of arguments on remote commands - Replace update hook with pre-receive and post-receive hooks. - Symlink the whole hooks directory - Ignore missing repositories in create-hooks - Connect to Redis via sockets by default v1.9.7 - Increased test coverage - By default use direct unicorn connection (localhost:8080) - Fix wrong repo path send to GitLab by GitlabUpdate hook v1.9.6 - Explicitly require 'timeout' from the standard library v1.9.5 - Put authorized_keys.lock in the same directory as authorized_keys - Use lock file when add new entries to authorized_keys v1.9.4 - Use lock file when modify authorized_keys v1.9.3 - Ignore force push detection for new branch or branch remove push v1.9.2 - Add support for force push detection v1.9.1 - Update hook sends branch and tag name v1.9.0 - Call api in update hook for both ssdh and http push. Requires GitLab 6.7+ - Pass oldrev and newrev to api.allowed? v1.8.5 - Add `gitlab-keys batch-add-keys` subcommand for authorized_keys rebuilds v1.8.4 - Dont do import if repository exists v1.8.3 - Add timeout option for repository import v1.8.2 - Fix broken 1.8.1 v1.8.1 - Restrict Environment Variables - Add bin/create-hooks command - More safe shell execution v1.8.0 - Fix return values in GitlabKeys v1.7.9 - Fix escape of repository path for custom ssh port v1.7.8 - Escape repository path to prevent relative links (CVE-2013-4583) v1.7.7 - Separate options from arguments with -- (CVE-2013-4582) - Bypass shell and use stdlib JSON for GitlabUpdate (CVE-2013-4581) v1.7.6 - Fix gitlab-projects update-head for improted repo when branch exists but not listed in refs/head v1.7.5 - Remove keys from authorized_keys using ruby instead of shell v1.7.4 - More protection against shell injection (CVE-2013-4546) v1.7.3 - Use Kernel#open to append lines to authorized_keys (CVE-2013-4490) v1.7.2 - More safe command execution v1.7.1 - Fixed issue when developers are able to push to protected branches that contain a '/' in the branch name. v1.7.0 - Clean authorized_keys file with `gitlab-keys clear` v1.6.0 - Create branch/tag functionality - Remove branch/tag functionality v1.5.0 - Logger - Ability to specify ca_file/ca_path - Update-head command for project - Better regexp for key_id inside shell v1.4.0 - Regex used in rm-key command was too lax v1.3.0 - Fork-project command - Custom redis configuration - Interpret login with deploy key as anonymous one v1.2.0 - Return non-zero result if gitlab-projects and gitlab-keys execution was not successful - http_settings configuration option added v1.1.0 - added mv-project feature - increased test coverage v1.0.4 - requires gitlab c9ca15e - don't use post-receive file any more. Make all updates in update - fixed issue with invalid GL_USER - use GL_ID instead of GL_USER gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/Gemfile000066400000000000000000000003441277744601700233370ustar00rootroot00000000000000source "http://rubygems.org" group :development, :test do gem 'coveralls', require: false gem 'rspec', '~> 2.14.0' gem 'webmock' gem 'guard' gem 'guard-rspec' gem 'vcr' gem 'rubocop', '0.28.0', require: false end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/Gemfile.lock000066400000000000000000000034301277744601700242650ustar00rootroot00000000000000GEM remote: http://rubygems.org/ specs: addressable (2.3.2) ast (2.0.0) astrolabe (1.3.0) parser (>= 2.2.0.pre.3, < 3.0) coderay (1.0.8) coveralls (0.7.1) multi_json (~> 1.3) rest-client simplecov (>= 0.7) term-ansicolor thor crack (0.3.1) diff-lcs (1.2.5) docile (1.1.5) guard (1.5.4) listen (>= 0.4.2) lumberjack (>= 1.0.2) pry (>= 0.9.10) thor (>= 0.14.6) guard-rspec (2.1.2) guard (>= 1.1) rspec (~> 2.11) listen (0.5.3) lumberjack (1.0.2) method_source (0.8.1) mime-types (2.3) multi_json (1.10.1) netrc (0.7.7) parser (2.2.0.2) ast (>= 1.1, < 3.0) powerpack (0.0.9) pry (0.9.10) coderay (~> 1.0.5) method_source (~> 0.8) slop (~> 3.3.1) rainbow (2.0.0) rest-client (1.7.2) mime-types (>= 1.16, < 3.0) netrc (~> 0.7) rspec (2.14.1) rspec-core (~> 2.14.0) rspec-expectations (~> 2.14.0) rspec-mocks (~> 2.14.0) rspec-core (2.14.8) rspec-expectations (2.14.5) diff-lcs (>= 1.1.3, < 2.0) rspec-mocks (2.14.6) rubocop (0.28.0) astrolabe (~> 1.3) parser (>= 2.2.0.pre.7, < 3.0) powerpack (~> 0.0.6) rainbow (>= 1.99.1, < 3.0) ruby-progressbar (~> 1.4) ruby-progressbar (1.7.1) simplecov (0.9.1) docile (~> 1.1.0) multi_json (~> 1.0) simplecov-html (~> 0.8.0) simplecov-html (0.8.0) slop (3.3.3) term-ansicolor (1.3.0) tins (~> 1.0) thor (0.19.1) tins (1.3.3) vcr (2.4.0) webmock (1.9.0) addressable (>= 2.2.7) crack (>= 0.1.7) PLATFORMS ruby DEPENDENCIES coveralls guard guard-rspec rspec (~> 2.14.0) rubocop (= 0.28.0) vcr webmock BUNDLED WITH 1.11.2 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/Guardfile000066400000000000000000000021761277744601700236760ustar00rootroot00000000000000# A sample Guardfile # More info at https://github.com/guard/guard#readme guard 'rspec' do watch(%r{^spec/.+_spec\.rb$}) watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" } watch('spec/spec_helper.rb') { "spec" } # Rails example watch(%r{^app/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" } watch(%r{^app/(.*)(\.erb|\.haml)$}) { |m| "spec/#{m[1]}#{m[2]}_spec.rb" } watch(%r{^app/controllers/(.+)_(controller)\.rb$}) { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] } watch(%r{^spec/support/(.+)\.rb$}) { "spec" } watch('config/routes.rb') { "spec/routing" } watch('app/controllers/application_controller.rb') { "spec/controllers" } # Capybara features specs watch(%r{^app/views/(.+)/.*\.(erb|haml)$}) { |m| "spec/features/#{m[1]}_spec.rb" } # Turnip features and steps watch(%r{^spec/acceptance/(.+)\.feature$}) watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' } end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/LICENSE000066400000000000000000000020501277744601700230450ustar00rootroot00000000000000Copyright (c) 2013 Dmitriy Zaporozhets Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/Makefile000066400000000000000000000004231277744601700235020ustar00rootroot00000000000000REDIS_RB_VERSION=v3.3.0 REDIS_RB_VENDOR_DIR=lib/vendor/redis PWD=`pwd` all: update-redis: rm -rf $(REDIS_RB_VENDOR_DIR) git clone -b $(REDIS_RB_VERSION) https://github.com/redis/redis-rb.git $(REDIS_RB_VENDOR_DIR) rm -rf $(REDIS_RB_VENDOR_DIR)/.git .PHONY=update-redis gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/README.md000066400000000000000000000144051277744601700233260ustar00rootroot00000000000000# GitLab Shell ## GitLab Shell handles git commands for GitLab GitLab Shell handles git commands for GitLab and modifies the list of authorized keys. GitLab Shell is not a Unix shell nor a replacement for Bash or Zsh. When you access the GitLab server over ssh then GitLab Shell will: 1. Limits you to predefined git commands (git push, git pull, git annex). 1. Call the GitLab Rails API to check if you are authorized 1. It will execute the pre-receive hooks (called Git Hooks in GitLab Enterprise Edition) 1. It will execute the action you requested 1. Process the GitLab post-receive actions 1. Process any custom post-receive actions If you access a GitLab server over http(s) what happens depends on if you pull from or push to the git repository. If you pull from git repositories over http(s) the GitLab Rails app will completely handle the authentication and execution. If you push to git repositories over http(s) the GitLab Rails app will not handle any authentication or execution but it will delegate the following to GitLab Shell: 1. Call the GitLab Rails API to check if you are authorized 1. It will execute the pre-receive hooks (called Git Hooks in GitLab Enterprise Edition) 1. It will excute the action you requested 1. Process the GitLab post-receive actions 1. Process any custom post-receive actions Maybe you wonder why in the case of git push over http(s) the Rails app doesn't handle authentication before delegating to GitLab Shell. This is because GitLab Rails doesn't have the logic to interpret git push commands. The idea is to have these interpretation code in only one place and this is GitLab Shell so we can reuse it for ssh access. Actually GitLab Shell executes all git push commands without checking authorizations and relies on the pre-receive hooks to check authorizations. When you do a git pull command the authorizations are checked before executing the commands (either in GitLab Rails or GitLab Shell with an API call to GitLab Rails). The authorization checks for git pull are much simpler since you only have to check if a user can access the repo (no need to check branch permissions). An overview of the four cases described above: 1. git pull over ssh -> gitlab-shell -> API call to gitlab-rails (Authorization) -> accept or decline -> execute git command 1. git pull over http -> gitlab-rails (Authorization) -> accept or decline -> execute git command 1. git push over ssh -> gitlab-shell (git command is not executed yet) -> execute git command -> gitlab-shell pre-receive hook -> API call to gitlab-rails (authorization) -> accept or decline push 1. git push over http -> gitlab-rails (git command is not executed yet) -> execute git command -> gitlab-shell pre-receive hook -> API call to gitlab-rails (authorization) -> accept or decline push ## Code status [![build status](https://gitlab.com/gitlab-org/gitlab-shell/badges/master/build.svg)](https://gitlab.com/gitlab-org/gitlab-shell/commits/master) [![Build Status](https://semaphoreapp.com/api/v1/projects/a71ddd46-a9cc-4062-875e-7ade19a44927/243336/badge.svg)](https://semaphoreapp.com/gitlabhq/gitlab-shell) [![Code Climate](https://codeclimate.com/github/gitlabhq/gitlab-shell.svg)](https://codeclimate.com/github/gitlabhq/gitlab-shell) [![Coverage Status](https://coveralls.io/repos/gitlabhq/gitlab-shell/badge.svg?branch=master)](https://coveralls.io/r/gitlabhq/gitlab-shell) ## Requirements **GitLab shell will always use your system ruby (normally located at /usr/bin/ruby) and will not use the ruby your installed with a ruby version manager (such as RVM).** It requires ruby 2.0 or higher. Please uninstall any old ruby versions from your system: ``` sudo apt-get remove ruby1.8 ``` Download Ruby and compile it with: ``` mkdir /tmp/ruby && cd /tmp/ruby curl -L --progress http://cache.ruby-lang.org/pub/ruby/2.1/ruby-2.1.5.tar.gz | tar xz cd ruby-2.1.5 ./configure --disable-install-rdoc make sudo make install ``` ## Setup ./bin/install ## Check ./bin/check ## Repos Add repo: ./bin/gitlab-projects add-project gitlab/gitlab-ci.git Remove repo: ./bin/gitlab-projects rm-project gitlab/gitlab-ci.git List repos: ./bin/gitlab-projects list-projects Import repo: # Default timeout is 2 minutes ./bin/gitlab-projects import-project randx/six.git https://github.com/randx/six.git # Override timeout in seconds ./bin/gitlab-projects import-project randx/six.git https://github.com/randx/six.git 90 Fork repo: ./bin/gitlab-projects fork-project gitlab/gitlab-ci.git randx Create tag (lightweight & annotated): ./bin/gitlab-projects create-tag gitlab/gitlab-ci.git v3.0.0 3-0-stable ./bin/gitlab-projects create-tag gitlab/gitlab-ci.git v3.0.0 3-0-stable 'annotated message goes here' Gc repo: ./bin/gitlab-projects gc gitlab/gitlab-ci.git ## Keys Add key: ./bin/gitlab-keys add-key key-782 "ssh-rsa AAAAx321..." Remove key: ./bin/gitlab-keys rm-key key-23 "ssh-rsa AAAAx321..." List all keys: ./bin/gitlab-keys list-keys Remove all keys from authorized_keys file: ./bin/gitlab-keys clear ## Git LFS remark If you want to play with git-lfs (https://git-lfs.github.com/) on GitLab, you should do the following: * Install LFS-server (no production-ready implementation yet, but you can use https://github.com/github/lfs-test-server) on any host; * Add some user on LFS-server (for example: user ```foo``` with password ```bar```); * Add ```git-lfs-authenticate``` script in any PATH-available directory on GIT-server like this: ``` #!/bin/sh echo "{ \"href\": \"http://lfs.test.local:9999/test/test\", \"header\": { \"Authorization\": \"Basic `echo -n foo:bar | base64`\" } }" ``` After that you can play with git-lfs (git-lfs feature will be available via ssh protocol). This design will work without a script git-lfs-authenticate, but with the following limitations: * You will need to manually configure lfs-server URL for every user working copy; * SSO don't work and you need to manually add lfs-server credentials for every user working copy (otherwise, git-lfs will ask for the password for each file). Useful links: * https://github.com/github/git-lfs/tree/master/docs/api - Git LFS API, also contains more information about ```git-lfs-authenticate```; * https://github.com/github/git-lfs/wiki/Implementations - Git LFS-server implementations. gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/VERSION000066400000000000000000000000061277744601700231070ustar00rootroot000000000000003.6.6 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/000077500000000000000000000000001277744601700226135ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/authorized_keys000077500000000000000000000013121277744601700257470ustar00rootroot00000000000000#!/usr/bin/env ruby # # GitLab shell authorized_keys. Query GitLab API to get the authorized command for a given ssh key fingerprint # # Ex. # /bin/authorized_keys BASE64-KEY # # Returns # command="/bin/gitlab-shell key-#",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa AAAAB3NzaC1yc2EAAAADAQA... # key = ARGV[0] abort "# No key provided" if key.nil? || key.empty? require_relative "../lib/gitlab_init" require_relative "../lib/gitlab_net" require_relative "../lib/gitlab_keys" authorized_key = GitlabNet.new.authorized_key(key) if authorized_key.nil? puts "# No key was found for #{key}" else puts GitlabKeys.key_line("key-#{authorized_key['id']}", authorized_key["key"]) end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/check000077500000000000000000000013751277744601700236240ustar00rootroot00000000000000#!/usr/bin/env ruby require_relative '../lib/gitlab_init' require_relative '../lib/gitlab_net' # # GitLab shell check task # print "Check GitLab API access: " begin resp = GitlabNet.new.check if resp.code == "200" print 'OK' else abort "FAILED. code: #{resp.code}" end rescue GitlabNet::ApiUnreachableError abort "FAILED: Failed to connect to internal API" end config = GitlabConfig.new abort("ERROR: missing option in config.yml") unless config.auth_file print "\nAccess to #{config.auth_file}: " if system(File.dirname(__FILE__) + '/gitlab-keys', 'check-permissions') print 'OK' else abort "FAILED" end puts "\n" print "Send ping to redis server: " if GitlabNet.new.redis_client.ping print 'OK' else abort 'FAILED' end puts "\n" gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/create-hooks000077500000000000000000000012101277744601700251170ustar00rootroot00000000000000#!/usr/bin/env ruby # Recreate GitLab hooks in the Git repositories managed by GitLab. # # This script is used when restoring a GitLab backup. require_relative '../lib/gitlab_init' require File.join(ROOT_PATH, 'lib', 'gitlab_projects') require File.join(ROOT_PATH, 'lib', 'gitlab_metrics') repository_storage_paths = ARGV repository_storage_paths.each do |repo_path| Dir["#{repo_path.chomp('/')}/*/*.git"].each do |repo| begin GitlabMetrics.measure('command-create-hooks') do GitlabProjects.create_hooks(repo) end rescue Errno::ENOENT # The user must have deleted their repository. Ignore. end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/gitlab-keys000077500000000000000000000010611277744601700247520ustar00rootroot00000000000000#!/usr/bin/env ruby require_relative '../lib/gitlab_init' # # GitLab Keys shell. Add/remove keys from ~/.ssh/authorized_keys # # Ex. # /bin/gitlab-keys add-key key-782 "ssh-rsa AAAAx321..." # # printf "key-782\tssh-rsa AAAAx321...\n" | /bin/gitlab-keys batch-add-keys # # /bin/gitlab-keys rm-key key-23 "ssh-rsa AAAAx321..." # # /bin/gitlab-keys list-keys # # /bin/gitlab-keys clear # require File.join(ROOT_PATH, 'lib', 'gitlab_keys') # Return non-zero if command execution was not successful if GitlabKeys.new.exec exit 0 else exit 1 end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/gitlab-projects000077500000000000000000000012761277744601700256400ustar00rootroot00000000000000#!/usr/bin/env ruby require_relative '../lib/gitlab_init' # # GitLab Projects shell. Add/remove projects from /home/git/repositories # # Ex. # /bin/gitlab-projects add-project gitlab/gitlab-ci.git # # /bin/gitlab-projects rm-project gitlab/gitlab-ci.git # # /bin/gitlab-projects list-projects # # /bin/gitlab-projects mv-project gitlab/gitlab-ci.git randx/fork.git # # /bin/gitlab-projects fork-project gitlab/gitlab-ci.git randx # # /bin/gitlab-projects import-project randx/six.git https://github.com/randx/six.git # require File.join(ROOT_PATH, 'lib', 'gitlab_projects') # Return non-zero if command execution was not successful if GitlabProjects.new.exec exit 0 else exit 1 end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/gitlab-shell000077500000000000000000000006301277744601700251070ustar00rootroot00000000000000#!/usr/bin/env ruby unless ENV['SSH_CONNECTION'] puts "Only ssh allowed" exit end key_id = /key-[0-9]+/.match(ARGV.join).to_s original_cmd = ENV.delete('SSH_ORIGINAL_COMMAND') require_relative '../lib/gitlab_init' # # # GitLab shell, invoked from ~/.ssh/authorized_keys # # require File.join(ROOT_PATH, 'lib', 'gitlab_shell') if GitlabShell.new(key_id).exec(original_cmd) exit 0 else exit 1 end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/bin/install000077500000000000000000000011741277744601700242120ustar00rootroot00000000000000#!/usr/bin/env ruby require_relative '../lib/gitlab_init' # # GitLab shell, invoked from ~/.ssh/authorized_keys # config = GitlabConfig.new key_dir = File.dirname("#{config.auth_file}") repository_storage_paths = ARGV commands = [ %W(mkdir -p #{key_dir}), %W(chmod 700 #{key_dir}), ] repository_storage_paths.each do |repository_storage_path| commands << %W(mkdir -p #{repository_storage_path}) commands << %W(chmod ug+rwX,o-rwx #{repository_storage_path}) end commands.each do |cmd| print "#{cmd.join(' ')}: " if system(*cmd) puts 'OK' else puts 'Failed' abort "#{$PROGRAM_NAME} failed" end end exit gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/config.yml.example000066400000000000000000000054431277744601700254730ustar00rootroot00000000000000# # If you change this file in a Merge Request, please also create # a Merge Request on https://gitlab.com/gitlab-org/omnibus-gitlab/merge_requests # # GitLab user. git by default user: git # URL to GitLab instance, used for API calls. Default: http://localhost:8080. # For relative URL support read http://doc.gitlab.com/ce/install/relative_url.html # You only have to change the default if you have configured Unicorn # to listen on a custom port, or if you have configured Unicorn to # only listen on a Unix domain socket. For Unix domain sockets use # "http+unix://", e.g. # "http+unix://%2Fpath%2Fto%2Fsocket" gitlab_url: "http://localhost:8080" # See installation.md#using-https for additional HTTPS configuration details. http_settings: # read_timeout: 300 # user: someone # password: somepass # ca_file: /etc/ssl/cert.pem # ca_path: /etc/pki/tls/certs self_signed_cert: false # File used as authorized_keys for gitlab user auth_file: "/home/git/.ssh/authorized_keys" # File that contains the secret key for verifying access to GitLab. # Default is .gitlab_shell_secret in the root directory. # secret_file: "/home/git/gitlab-shell/.gitlab_shell_secret" # Redis settings used for pushing commit notices to gitlab redis: bin: /usr/bin/redis-cli # host: 127.0.0.1 # port: 6379 # pass: redispass # Allows you to specify the password for Redis database: 0 socket: /var/run/redis/redis.sock # Comment out this line if you want to use TCP or Sentinel namespace: resque:gitlab # sentinels: # - # host: 127.0.0.1 # port: 26380 # - # host: 127.0.0.1 # port: 26381 # Log file. # Default is gitlab-shell.log in the root directory. # log_file: "/home/git/gitlab-shell/gitlab-shell.log" # Log level. INFO by default log_level: INFO # Audit usernames. # Set to true to see real usernames in the logs instead of key ids, which is easier to follow, but # incurs an extra API call on every gitlab-shell command. audit_usernames: false # Enable git-annex support # git-annex allows managing files with git, without checking the file contents into git # See https://git-annex.branchable.com/ for documentation # If enabled, git-annex needs to be installed on the server where gitlab-shell is setup # For Debian and Ubuntu systems this can be done with: sudo apt-get install git-annex # For CentOS: sudo yum install epel-release && sudo yum install git-annex git_annex_enabled: false # Git trace log file. # If set, git commands receive GIT_TRACE* environment variables # See https://git-scm.com/book/es/v2/Git-Internals-Environment-Variables#Debugging for documentation # An absolute path starting with / – the trace output will be appended to that file. # It needs to exist so we can check permissions and avoid to throwing warnings to the users. git_trace_log_file: gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/hooks/000077500000000000000000000000001277744601700231665ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/hooks/post-receive000077500000000000000000000006701277744601700255240ustar00rootroot00000000000000#!/usr/bin/env ruby # This file was placed here by GitLab. It makes sure that your pushed commits # will be processed properly. refs = $stdin.read key_id = ENV.delete('GL_ID') repo_path = Dir.pwd require_relative '../lib/gitlab_custom_hook' require_relative '../lib/gitlab_post_receive' if GitlabPostReceive.new(repo_path, key_id, refs).exec && GitlabCustomHook.new(key_id).post_receive(refs, repo_path) exit 0 else exit 1 end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/hooks/pre-receive000077500000000000000000000015531277744601700253260ustar00rootroot00000000000000#!/usr/bin/env ruby # This file was placed here by GitLab. It makes sure that your pushed commits # will be processed properly. refs = $stdin.read key_id = ENV.delete('GL_ID') protocol = ENV.delete('GL_PROTOCOL') repo_path = Dir.pwd require_relative '../lib/gitlab_custom_hook' require_relative '../lib/gitlab_reference_counter' require_relative '../lib/gitlab_access' # It's important that on pre-receive `increase_reference_counter` gets executed # last so that it only runs if everything else succeeded. On post-receive on the # other hand, we run GitlabPostReceive first because the push is already done # and we don't want to skip it if the custom hook fails. if GitlabAccess.new(repo_path, key_id, refs, protocol).exec && GitlabCustomHook.new(key_id).pre_receive(refs, repo_path) && GitlabReferenceCounter.new(repo_path).increase exit 0 else exit 1 end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/hooks/update000077500000000000000000000006161277744601700244010ustar00rootroot00000000000000#!/usr/bin/env ruby # This file was placed here by GitLab. It makes sure that your pushed commits # will be processed properly. ref_name = ARGV[0] old_value = ARGV[1] new_value = ARGV[2] repo_path = Dir.pwd key_id = ENV.delete('GL_ID') require_relative '../lib/gitlab_custom_hook' if GitlabCustomHook.new(key_id).update(ref_name, old_value, new_value, repo_path) exit 0 else exit 1 end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/000077500000000000000000000000001277744601700226115ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_access.rb000066400000000000000000000017721277744601700257300ustar00rootroot00000000000000require_relative 'gitlab_init' require_relative 'gitlab_net' require_relative 'gitlab_access_status' require_relative 'names_helper' require 'json' class GitlabAccess class AccessDeniedError < StandardError; end include NamesHelper attr_reader :config, :repo_path, :repo_name, :changes, :protocol def initialize(repo_path, actor, changes, protocol) @config = GitlabConfig.new @repo_path = repo_path.strip @actor = actor @repo_name = extract_repo_name(@repo_path.dup) @changes = changes.lines @protocol = protocol end def exec status = api.check_access('git-receive-pack', @repo_name, @actor, @changes, @protocol) raise AccessDeniedError, status.message unless status.allowed? true rescue GitlabNet::ApiUnreachableError $stderr.puts "GitLab: Failed to authorize your Git request: internal API unreachable" false rescue AccessDeniedError => ex $stderr.puts "GitLab: #{ex.message}" false end protected def api GitlabNet.new end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_access_status.rb000066400000000000000000000006261277744601700273300ustar00rootroot00000000000000require 'json' class GitAccessStatus attr_reader :message, :repository_path def initialize(status, message, repository_path) @status = status @message = message @repository_path = repository_path end def self.create_from_json(json) values = JSON.parse(json) self.new(values["status"], values["message"], values["repository_path"]) end def allowed? @status end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_authorized_keys.rb000066400000000000000000000000001277744601700276570ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_config.rb000066400000000000000000000021531277744601700257260ustar00rootroot00000000000000require 'yaml' class GitlabConfig attr_reader :config def initialize @config = YAML.load_file(File.join(ROOT_PATH, 'config.yml')) end def home ENV['HOME'] end def auth_file @config['auth_file'] ||= File.join(home, ".ssh/authorized_keys") end def secret_file @config['secret_file'] ||= File.join(ROOT_PATH, '.gitlab_shell_secret') end def gitlab_url (@config['gitlab_url'] ||= "http://localhost:8080").sub(%r{/*$}, '') end def http_settings @config['http_settings'] ||= {} end def redis @config['redis'] ||= {} end def redis_namespace redis['namespace'] || 'resque:gitlab' end def log_file @config['log_file'] ||= File.join(ROOT_PATH, 'gitlab-shell.log') end def log_level @config['log_level'] ||= 'INFO' end def audit_usernames @config['audit_usernames'] ||= false end def git_annex_enabled? @config['git_annex_enabled'] ||= false end def git_trace_log_file @config['git_trace_log_file'] end def metrics_log_file @config['metrics_log_file'] ||= File.join(ROOT_PATH, 'gitlab-shell-metrics.log') end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_custom_hook.rb000066400000000000000000000027321277744601700270160ustar00rootroot00000000000000require 'open3' class GitlabCustomHook attr_reader :vars def initialize(key_id) @vars = { 'GL_ID' => key_id } end def pre_receive(changes, repo_path) hook = hook_file('pre-receive', repo_path) return true if hook.nil? call_receive_hook(hook, changes) end def post_receive(changes, repo_path) hook = hook_file('post-receive', repo_path) return true if hook.nil? call_receive_hook(hook, changes) end def update(ref_name, old_value, new_value, repo_path) hook = hook_file('update', repo_path) return true if hook.nil? system(vars, hook, ref_name, old_value, new_value) end private def call_receive_hook(hook, changes) # Prepare the hook subprocess. Attach a pipe to its stdin, and merge # both its stdout and stderr into our own stdout. stdin_reader, stdin_writer = IO.pipe hook_pid = spawn(vars, hook, in: stdin_reader, err: :out) stdin_reader.close # Submit changes to the hook via its stdin. begin IO.copy_stream(StringIO.new(changes), stdin_writer) rescue Errno::EPIPE # It is not an error if the hook does not consume all of its input. end # Close the pipe to let the hook know there is no further input. stdin_writer.close Process.wait(hook_pid) $?.success? end def hook_file(hook_type, repo_path) hook_path = File.join(repo_path.strip, 'custom_hooks') hook_file = "#{hook_path}/#{hook_type}" hook_file if File.exist?(hook_file) end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_init.rb000066400000000000000000000001501277744601700254170ustar00rootroot00000000000000ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), "..")) require_relative 'gitlab_config' gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_keys.rb000066400000000000000000000075461277744601700254470ustar00rootroot00000000000000require 'timeout' require_relative 'gitlab_config' require_relative 'gitlab_logger' require_relative 'gitlab_metrics' class GitlabKeys class KeyError < StandardError ; end attr_accessor :auth_file, :key def self.command(key_id) raise KeyError.new("Invalid key_id: #{key_id.inspect}") unless /\A[a-z0-9-]+\z/ =~ key_id "#{ROOT_PATH}/bin/gitlab-shell #{key_id}" end def self.key_line(key_id, public_key) public_key.chomp! raise KeyError.new("Invalid public_key: #{public_key.inspect}") if public_key.include?("\n") "command=\"#{command(key_id)}\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty #{public_key}" end def initialize @command = ARGV.shift @key_id = ARGV.shift key = ARGV.shift @key = key.dup if key @auth_file = GitlabConfig.new.auth_file end def exec GitlabMetrics.measure("command-#{@command}") do case @command when 'add-key'; add_key when 'batch-add-keys'; batch_add_keys when 'rm-key'; rm_key when 'list-keys'; list_keys when 'clear'; clear when 'check-permissions'; check_permissions else $logger.warn "Attempt to execute invalid gitlab-keys command #{@command.inspect}." puts 'not allowed' false end end end protected def add_key lock do $logger.info "Adding key #{@key_id} => #{@key.inspect}" auth_line = self.class.key_line(@key_id, @key) open_auth_file('a') { |file| file.puts(auth_line) } end true end def list_keys $logger.info 'Listing all keys' keys = '' File.readlines(auth_file).each do |line| # key_id & public_key # command=".../bin/gitlab-shell key-741" ... ssh-rsa AAAAB3NzaDAxx2E\n # ^^^^^^^ ^^^^^^^^^^^^^^^ matches = /^command=\".+?\s+(.+?)\".+?(?:ssh|ecdsa)-.*?\s(.+)\s*.*\n*$/.match(line) keys << "#{matches[1]} #{matches[2]}\n" unless matches.nil? end keys end def batch_add_keys lock(300) do # Allow 300 seconds (5 minutes) for batch_add_keys open_auth_file('a') do |file| stdin.each_line do |input| tokens = input.strip.split("\t") abort("#{$0}: invalid input #{input.inspect}") unless tokens.count == 2 key_id, public_key = tokens $logger.info "Adding key #{key_id} => #{public_key.inspect}" file.puts(self.class.key_line(key_id, public_key)) end end end true end def stdin $stdin end def rm_key lock do $logger.info "Removing key #{@key_id}" open_auth_file('r+') do |f| while line = f.gets do next unless line.start_with?("command=\"#{self.class.command(@key_id)}\"") f.seek(-line.length, IO::SEEK_CUR) # Overwrite the line with #'s. Because the 'line' variable contains # a terminating '\n', we write line.length - 1 '#' characters. f.write('#' * (line.length - 1)) end end end true end def clear open_auth_file('w') { |file| file.puts '# Managed by gitlab-shell' } true end def check_permissions open_auth_file(File::RDWR | File::CREAT) { true } rescue => ex puts "error: could not open #{auth_file}: #{ex}" if File.exist?(auth_file) system('ls', '-l', auth_file) else # Maybe the parent directory is not writable? system('ls', '-ld', File.dirname(auth_file)) end false end def lock(timeout = 10) File.open(lock_file, "w+") do |f| begin f.flock File::LOCK_EX Timeout::timeout(timeout) { yield } ensure f.flock File::LOCK_UN end end end def lock_file @lock_file ||= auth_file + '.lock' end def open_auth_file(mode) open(auth_file, mode, 0600) do |file| file.chmod(0600) yield file end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_lfs_authentication.rb000066400000000000000000000013571277744601700303510ustar00rootroot00000000000000require 'base64' require 'json' class GitlabLfsAuthentication attr_accessor :username, :lfs_token, :repository_http_path def initialize(username, lfs_token, repository_http_path) @username = username @lfs_token = lfs_token @repository_http_path = repository_http_path end def self.build_from_json(json) begin values = JSON.parse(json) self.new(values['username'], values['lfs_token'], values['repository_http_path']) rescue nil end end def authentication_payload authorization = { header: { Authorization: "Basic #{Base64.strict_encode64("#{username}:#{lfs_token}")}" }, href: "#{repository_http_path}/info/lfs/" } JSON.generate(authorization) end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_logger.rb000066400000000000000000000006121277744601700257360ustar00rootroot00000000000000require 'logger' require_relative 'gitlab_config' def convert_log_level log_level Logger.const_get(log_level.upcase) rescue NameError $stderr.puts "WARNING: Unrecognized log level #{log_level.inspect}." $stderr.puts "WARNING: Falling back to INFO." Logger::INFO end config = GitlabConfig.new $logger = Logger.new(config.log_file) $logger.level = convert_log_level(config.log_level) gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_metrics.rb000066400000000000000000000025521277744601700261320ustar00rootroot00000000000000require 'logger' require_relative 'gitlab_config' require_relative 'gitlab_logger' module GitlabMetrics module System # THREAD_CPUTIME is not supported on OS X if Process.const_defined?(:CLOCK_THREAD_CPUTIME_ID) def self.cpu_time Process. clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :millisecond) end else def self.cpu_time Process. clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID, :millisecond) end end # Returns the current monotonic clock time in a given precision. # # Returns the time as a Fixnum. def self.monotonic_time Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) end end def self.logger $logger end # Measures the execution time of a block. # # Example: # # GitlabMetrics.measure(:find_by_username_duration) do # User.find_by_username(some_username) # end # # name - The name of the field to store the execution time in. # # Returns the value yielded by the supplied block. def self.measure(name) start_real = System.monotonic_time start_cpu = System.cpu_time retval = yield real_time = System.monotonic_time - start_real cpu_time = System.cpu_time - start_cpu logger.debug("metrics: name=#{name.inspect} wall_time=#{real_time} cpu_time=#{cpu_time}") retval end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_net.rb000066400000000000000000000130571277744601700252540ustar00rootroot00000000000000require 'net/http' require 'openssl' require 'json' require_relative 'gitlab_config' require_relative 'gitlab_logger' require_relative 'gitlab_access' require_relative 'gitlab_redis' require_relative 'gitlab_lfs_authentication' require_relative 'httpunix' class GitlabNet class ApiUnreachableError < StandardError; end CHECK_TIMEOUT = 5 READ_TIMEOUT = 300 def check_access(cmd, repo, actor, changes, protocol) changes = changes.join("\n") unless changes.kind_of?(String) params = { action: cmd, changes: changes, project: project_name(repo), protocol: protocol } if actor =~ /\Akey\-\d+\Z/ params.merge!(key_id: actor.gsub("key-", "")) elsif actor =~ /\Auser\-\d+\Z/ params.merge!(user_id: actor.gsub("user-", "")) end url = "#{host}/allowed" resp = post(url, params) if resp.code == '200' GitAccessStatus.create_from_json(resp.body) else GitAccessStatus.new(false, 'API is not accessible', nil) end end def discover(key) key_id = key.gsub("key-", "") resp = get("#{host}/discover?key_id=#{key_id}") JSON.parse(resp.body) rescue nil end def lfs_authenticate(key, repo) params = { project: project_name(repo), key_id: key.gsub('key-', '') } resp = post("#{host}/lfs_authenticate", params) if resp.code == '200' GitlabLfsAuthentication.build_from_json(resp.body) end end def broadcast_message resp = get("#{host}/broadcast_message") JSON.parse(resp.body) rescue {} end def merge_request_urls(repo_name, changes) changes = changes.join("\n") unless changes.kind_of?(String) changes = changes.encode('UTF-8', 'ASCII', invalid: :replace, replace: '') resp = get("#{host}/merge_request_urls?project=#{URI.escape(repo_name)}&changes=#{URI.escape(changes)}") JSON.parse(resp.body) rescue [] end def check get("#{host}/check", read_timeout: CHECK_TIMEOUT) end def authorized_key(key) resp = get("#{host}/authorized_keys?key=#{URI.escape(key, '+/=')}") JSON.parse(resp.body) if resp.code == "200" rescue nil end def two_factor_recovery_codes(key) key_id = key.gsub('key-', '') resp = post("#{host}/two_factor_recovery_codes", key_id: key_id) JSON.parse(resp.body) if resp.code == '200' rescue {} end def redis_client redis_config = config.redis database = redis_config['database'] || 0 params = { host: redis_config['host'] || '127.0.0.1', port: redis_config['port'] || 6379, db: database } if redis_config.has_key?('sentinels') params[:sentinels] = redis_config['sentinels'] .select { |s| s['host'] && s['port'] } .map { |s| { host: s['host'], port: s['port'] } } end if redis_config.has_key?("socket") params = { path: redis_config['socket'], db: database } elsif redis_config.has_key?("pass") params[:password] = redis_config['pass'] end Redis.new(params) end protected def project_name(repo) project_name = repo.gsub("'", "") project_name = project_name.gsub(/\.git\Z/, "") project_name.gsub(/\A\//, "") end def config @config ||= GitlabConfig.new end def host "#{config.gitlab_url}/api/v3/internal" end def http_client_for(uri, options={}) if uri.is_a?(URI::HTTPUNIX) http = Net::HTTPUNIX.new(uri.hostname) else http = Net::HTTP.new(uri.host, uri.port) end http.read_timeout = options[:read_timeout] || read_timeout if uri.is_a?(URI::HTTPS) http.use_ssl = true http.cert_store = cert_store http.verify_mode = OpenSSL::SSL::VERIFY_NONE if config.http_settings['self_signed_cert'] end http end def http_request_for(method, uri, params = {}) request_klass = method == :get ? Net::HTTP::Get : Net::HTTP::Post request = request_klass.new(uri.request_uri) user = config.http_settings['user'] password = config.http_settings['password'] request.basic_auth(user, password) if user && password request.set_form_data(params.merge(secret_token: secret_token)) request end def request(method, url, params = {}, options={}) $logger.debug "Performing #{method.to_s.upcase} #{url}" uri = URI.parse(url) http = http_client_for(uri, options) request = http_request_for(method, uri, params) begin start_time = Time.new response = http.start { http.request(request) } rescue => e $logger.warn "Failed to connect to internal API <#{method.to_s.upcase} #{url}>: #{e.inspect}" raise ApiUnreachableError ensure $logger.info do sprintf('%s %s %0.5f', method.to_s.upcase, url, Time.new - start_time) end end if response.code == "200" $logger.debug "Received response #{response.code} => <#{response.body}>." else $logger.error "API call <#{method.to_s.upcase} #{url}> failed: #{response.code} => <#{response.body}>." end response end def get(url, options={}) request(:get, url, {}, options) end def post(url, params) request(:post, url, params) end def cert_store @cert_store ||= begin store = OpenSSL::X509::Store.new store.set_default_paths if ca_file = config.http_settings['ca_file'] store.add_file(ca_file) end if ca_path = config.http_settings['ca_path'] store.add_path(ca_path) end store end end def secret_token @secret_token ||= File.read config.secret_file end def read_timeout config.http_settings['read_timeout'] || READ_TIMEOUT end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_post_receive.rb000066400000000000000000000064171277744601700271570ustar00rootroot00000000000000require_relative 'gitlab_init' require_relative 'gitlab_net' require_relative 'gitlab_reference_counter' require 'json' require 'base64' require 'securerandom' class GitlabPostReceive include NamesHelper attr_reader :config, :repo_path, :changes, :jid def initialize(repo_path, actor, changes) @config = GitlabConfig.new @repo_path, @actor = repo_path.strip, actor @repo_name = extract_repo_name(@repo_path.dup) @changes = changes @jid = SecureRandom.hex(12) end def exec result = update_redis begin broadcast_message = api.broadcast_message if broadcast_message.has_key?("message") puts print_broadcast_message(broadcast_message["message"]) end merge_request_urls = api.merge_request_urls(@repo_name, @changes) print_merge_request_links(merge_request_urls) rescue GitlabNet::ApiUnreachableError nil end result && GitlabReferenceCounter.new(repo_path).decrease end protected def api @api ||= GitlabNet.new end def print_merge_request_links(merge_request_urls) return if merge_request_urls.empty? puts merge_request_urls.each { |mr| print_merge_request_link(mr) } end def print_merge_request_link(merge_request) if merge_request["new_merge_request"] message = "Create merge request for #{merge_request["branch_name"]}:" else message = "View merge request for #{merge_request["branch_name"]}:" end puts message puts((" " * 2) + merge_request["url"]) puts end def print_broadcast_message(message) # A standard terminal window is (at least) 80 characters wide. total_width = 80 # Git prefixes remote messages with "remote: ", so this width is subtracted # from the width available to us. total_width -= "remote: ".length # Our centered text shouldn't start or end right at the edge of the window, # so we add some horizontal padding: 2 chars on either side. text_width = total_width - 2 * 2 # Automatically wrap message at text_width (= 68) characters: # Splits the message up into the longest possible chunks matching # "". # The last result is always an empty string (0 chars and the end-of-line), # so drop that. # message.scan returns a nested array of capture groups, so flatten. lines = message.scan(/(.{,#{text_width}})(?:\s|$)/)[0...-1].flatten puts "=" * total_width puts lines.each do |line| line.strip! # Center the line by calculating the left padding measured in characters. line_padding = [(total_width - line.length) / 2, 0].max puts((" " * line_padding) + line) end puts puts "=" * total_width end def update_redis # Encode changes as base64 so we don't run into trouble with non-UTF-8 input. changes = Base64.encode64(@changes) queue = "#{config.redis_namespace}:queue:post_receive" msg = JSON.dump({ 'class' => 'PostReceive', 'args' => [@repo_path, @actor, changes], 'jid' => @jid, 'enqueued_at' => Time.now.to_f }) begin GitlabNet.new.redis_client.rpush(queue, msg) true rescue => e $stderr.puts "GitLab: An unexpected error occurred in writing to Redis: #{e}" false end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_projects.rb000066400000000000000000000264421277744601700263210ustar00rootroot00000000000000require 'fileutils' require 'timeout' require 'open3' require_relative 'gitlab_config' require_relative 'gitlab_logger' require_relative 'gitlab_metrics' require_relative 'gitlab_reference_counter' class GitlabProjects GLOBAL_HOOKS_DIRECTORY = File.join(ROOT_PATH, 'hooks') # Project name is a directory name for repository with .git at the end # It may be namespaced or not. Like repo.git or gitlab/repo.git attr_reader :project_name # Absolute path to directory where repositories stored # By default it is /home/git/repositories attr_reader :repos_path # Full path is an absolute path to the repository # Ex /home/git/repositories/test.git attr_reader :full_path def self.create_hooks(path) local_hooks_directory = File.join(path, 'hooks') real_local_hooks_directory = :not_found begin real_local_hooks_directory = File.realpath(local_hooks_directory) rescue Errno::ENOENT # real_local_hooks_directory == :not_found end if real_local_hooks_directory != File.realpath(GLOBAL_HOOKS_DIRECTORY) if File.exist?(local_hooks_directory) $logger.info "Moving existing hooks directory and symlinking global hooks directory for #{path}." FileUtils.mv(local_hooks_directory, "#{local_hooks_directory}.old.#{Time.now.to_i}") end FileUtils.ln_sf(GLOBAL_HOOKS_DIRECTORY, local_hooks_directory) else $logger.info "Hooks already exist for #{path}." true end end def initialize @command = ARGV.shift @repos_path = ARGV.shift @project_name = ARGV.shift @full_path = File.join(@repos_path, @project_name) unless @project_name.nil? end def exec GitlabMetrics.measure("command-#{@command}") do case @command when 'create-tag'; create_tag when 'add-project'; add_project when 'list-projects'; puts list_projects when 'rm-project'; rm_project when 'mv-project'; mv_project when 'mv-storage'; mv_storage when 'import-project'; import_project when 'fork-project'; fork_project when 'fetch-remote'; fetch_remote when 'push-branches'; push_branches when 'delete-remote-branches'; delete_remote_branches when 'list-remote-tags'; list_remote_tags when 'gc'; gc else $logger.warn "Attempt to execute invalid gitlab-projects command #{@command.inspect}." puts 'not allowed' false end end end protected def list_remote_tags remote_name = ARGV.shift tag_list, exit_code, error = nil cmd = %W(git --git-dir=#{full_path} ls-remote --tags #{remote_name}) Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr| tag_list = stdout.read error = stderr.read exit_code = wait_thr.value.exitstatus end if exit_code.zero? puts tag_list true else puts error false end end def push_branches remote_name = ARGV.shift $logger.info "Pushing branches from #{full_path} to remote #{remote_name}: #{ARGV}" cmd = %W(git --git-dir=#{full_path} push -- #{remote_name}).concat(ARGV) pid = Process.spawn(*cmd) begin Process.wait(pid) $?.exitstatus.zero? rescue => exception $logger.error "Pushing branches to remote #{remote_name} failed due to: #{exception.message}" Process.kill('KILL', pid) Process.wait false end end def delete_remote_branches remote_name = ARGV.shift branches = ARGV.map { |branch_name| ":#{branch_name}" } $logger.info "Pushing deleted branches from #{full_path} to remote #{remote_name}: #{ARGV}" cmd = %W(git --git-dir=#{full_path} push -- #{remote_name}).concat(branches) pid = Process.spawn(*cmd) begin Process.wait(pid) $?.exitstatus.zero? rescue => exception $logger.error "Pushing deleted branches to remote #{remote_name} failed due to: #{exception.message}" Process.kill('KILL', pid) Process.wait false end end def create_tag tag_name = ARGV.shift ref = ARGV.shift || "HEAD" cmd = %W(git --git-dir=#{full_path} tag) if ARGV.size > 0 msg = ARGV.shift cmd += %W(-a -m #{msg}) end cmd += %W(-- #{tag_name} #{ref}) system(*cmd) end def add_project $logger.info "Adding project #{@project_name} at <#{full_path}>." FileUtils.mkdir_p(full_path, mode: 0770) cmd = %W(git --git-dir=#{full_path} init --bare) system(*cmd) && self.class.create_hooks(full_path) end def list_projects $logger.info 'Listing projects' Dir.chdir(repos_path) do next Dir.glob('**/*.git') end end def rm_project $logger.info "Removing project #{@project_name} from <#{full_path}>." FileUtils.rm_rf(full_path) end def mask_password_in_url(url) result = URI(url) result.password = "*****" unless result.password.nil? result.user = "*****" unless result.user.nil? #it's needed for oauth access_token result rescue url end def fetch_remote @name = ARGV.shift # timeout for fetch timeout = (ARGV.shift || 120).to_i # fetch with --force ? forced = ARGV.include?('--force') # fetch with --tags or --no-tags tags_option = ARGV.include?('--no-tags') ? '--no-tags' : '--tags' $logger.info "Fetching remote #{@name} for project #{@project_name}." cmd = %W(git --git-dir=#{full_path} fetch #{@name}) cmd << '--force' if forced cmd << tags_option pid = Process.spawn(*cmd) begin Timeout.timeout(timeout) do Process.wait(pid) end $?.exitstatus.zero? rescue Timeout::Error $logger.error "Fetching remote #{@name} for project #{@project_name} failed due to timeout." Process.kill('KILL', pid) Process.wait false end end def remove_origin_in_repo cmd = %W(git --git-dir=#{full_path} remote rm origin) pid = Process.spawn(*cmd) Process.wait(pid) end # Import project via git clone --bare # URL must be publicly cloneable def import_project # Skip import if repo already exists return false if File.exists?(full_path) @source = ARGV.shift masked_source = mask_password_in_url(@source) # timeout for clone timeout = (ARGV.shift || 120).to_i $logger.info "Importing project #{@project_name} from <#{masked_source}> to <#{full_path}>." cmd = %W(git clone --bare -- #{@source} #{full_path}) pid = Process.spawn(*cmd) begin Timeout.timeout(timeout) do Process.wait(pid) end return false unless $?.exitstatus.zero? rescue Timeout::Error $logger.error "Importing project #{@project_name} from <#{masked_source}> failed due to timeout." Process.kill('KILL', pid) Process.wait FileUtils.rm_rf(full_path) return false end self.class.create_hooks(full_path) # The project was imported successfully. # Remove the origin URL since it may contain password. remove_origin_in_repo true end # Move repository from one directory to another # # Ex. # gitlab.git -> gitlabhq.git # gitlab/gitlab-ci.git -> randx/six.git # # Wont work if target namespace directory does not exist # def mv_project new_path = ARGV.shift unless new_path $logger.error "mv-project failed: no destination path provided." return false end new_full_path = File.join(repos_path, new_path) # verify that the source repo exists unless File.exists?(full_path) $logger.error "mv-project failed: source path <#{full_path}> does not exist." return false end # ...and that the target repo does not exist if File.exists?(new_full_path) $logger.error "mv-project failed: destination path <#{new_full_path}> already exists." return false end $logger.info "Moving project #{@project_name} from <#{full_path}> to <#{new_full_path}>." FileUtils.mv(full_path, new_full_path) end # Move repository from one storage path to another # # Wont work if target namespace directory does not exist in the new storage path # def mv_storage new_storage = ARGV.shift unless new_storage $logger.error "mv-storage failed: no destination storage path provided." return false end new_full_path = File.join(new_storage, project_name) # verify that the source repo exists unless File.exists?(full_path) $logger.error "mv-storage failed: source path <#{full_path}> does not exist." return false end # Make sure the destination directory exists FileUtils.mkdir_p(new_full_path) # Make sure the source path ends with a slash so that rsync copies the # contents of the directory, as opposed to copying the directory by name source_path = File.join(full_path, '') if wait_for_pushes $logger.info "Syncing project #{@project_name} from <#{full_path}> to <#{new_full_path}>." # Set a low IO priority with ionice to not choke the server on moves if rsync(source_path, new_full_path, 'ionice -c2 -n7 rsync') true else # If the command fails with `ionice` (maybe because we're on a OS X # development machine), try again without `ionice`. rsync(source_path, new_full_path) end else $logger.error "mv-storage failed: source path <#{full_path}> is waiting for pushes to finish." false end end def fork_project destination_repos_path = ARGV.shift unless destination_repos_path $logger.error "fork-project failed: no destination repository path provided." return false end new_namespace = ARGV.shift # destination namespace must be provided unless new_namespace $logger.error "fork-project failed: no destination namespace provided." return false end # destination namespace must exist namespaced_path = File.join(destination_repos_path, new_namespace) unless File.exists?(namespaced_path) $logger.error "fork-project failed: destination namespace <#{namespaced_path}> does not exist." return false end # a project of the same name cannot already be within the destination namespace full_destination_path = File.join(namespaced_path, project_name.split('/')[-1]) if File.exists?(full_destination_path) $logger.error "fork-project failed: destination repository <#{full_destination_path}> already exists." return false end $logger.info "Forking project from <#{full_path}> to <#{full_destination_path}>." cmd = %W(git clone --bare -- #{full_path} #{full_destination_path}) system(*cmd) && self.class.create_hooks(full_destination_path) end def gc $logger.info "Running git gc for <#{full_path}>." unless File.exists?(full_path) $logger.error "gc failed: destination path <#{full_path}> does not exist." return false end cmd = %W(git --git-dir=#{full_path} gc) system(*cmd) end def wait_for_pushes # Try for 30 seconds, polling every 10 3.times do return true if gitlab_reference_counter.value == 0 sleep 10 end false end def gitlab_reference_counter @gitlab_reference_counter ||= GitlabReferenceCounter.new(full_path) end def rsync(src, dest, rsync_path = 'rsync') command = rsync_path.split + %W(-a --delete --rsync-path="#{rsync_path}" #{src} #{dest}) system(*command) end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_redis.rb000066400000000000000000000001441277744601700255650ustar00rootroot00000000000000$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'vendor/redis/lib'))) require 'redis' gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_reference_counter.rb000066400000000000000000000020101277744601700301460ustar00rootroot00000000000000require_relative 'gitlab_init' require_relative 'gitlab_net' class GitlabReferenceCounter REFERENCE_EXPIRE_TIME = 600 attr_reader :path, :key def initialize(path) @path = path @key = "git-receive-pack-reference-counter:#{path}" end def value (redis_client.get(key) || 0).to_i end def increase redis_cmd do redis_client.incr(key) redis_client.expire(key, REFERENCE_EXPIRE_TIME) end end def decrease redis_cmd do current_value = redis_client.decr(key) if current_value < 0 $logger.warn "Reference counter for #{path} decreased when its value was less than 1. Reseting the counter." redis_client.del(key) end end end private def redis_client @redis_client ||= GitlabNet.new.redis_client end def redis_cmd begin yield true rescue => e message = "GitLab: An unexpected error occurred in writing to Redis: #{e}" $stderr.puts message $logger.error message false end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/gitlab_shell.rb000066400000000000000000000173471277744601700256030ustar00rootroot00000000000000require 'shellwords' require 'pathname' require_relative 'gitlab_net' require_relative 'gitlab_metrics' class GitlabShell class AccessDeniedError < StandardError; end class DisallowedCommandError < StandardError; end class InvalidRepositoryPathError < StandardError; end GIT_COMMANDS = %w(git-upload-pack git-receive-pack git-upload-archive git-annex-shell git-lfs-authenticate).freeze API_COMMANDS = %w(2fa_recovery_codes) GL_PROTOCOL = 'ssh'.freeze attr_accessor :key_id, :repo_name, :command, :git_access attr_reader :repo_path def initialize(key_id) @key_id = key_id @config = GitlabConfig.new end # The origin_cmd variable contains UNTRUSTED input. If the user ran # ssh git@gitlab.example.com 'evil command', then origin_cmd contains # 'evil command'. def exec(origin_cmd) unless origin_cmd puts "Welcome to GitLab, #{username}!" return true end args = Shellwords.shellwords(origin_cmd) parse_cmd(args) if GIT_COMMANDS.include?(args.first) GitlabMetrics.measure('verify-access') { verify_access } end process_cmd(args) true rescue GitlabNet::ApiUnreachableError => ex $stderr.puts "GitLab: Failed to authorize your Git request: internal API unreachable" false rescue AccessDeniedError => ex message = "gitlab-shell: Access denied for git command <#{origin_cmd}> by #{log_username}." $logger.warn message $stderr.puts "GitLab: #{ex.message}" false rescue DisallowedCommandError => ex message = "gitlab-shell: Attempt to execute disallowed command <#{origin_cmd}> by #{log_username}." $logger.warn message $stderr.puts "GitLab: Disallowed command" false rescue InvalidRepositoryPathError => ex $stderr.puts "GitLab: Invalid repository path" false end protected def parse_cmd(args) @command = args.first @git_access = @command return if API_COMMANDS.include?(@command) raise DisallowedCommandError unless GIT_COMMANDS.include?(@command) case @command when 'git-annex-shell' raise DisallowedCommandError unless @config.git_annex_enabled? @repo_name = args[2].sub(/\A\/~\//, '') when 'git-lfs-authenticate' raise DisallowedCommandError unless args.count >= 2 @repo_name = args[1] case args[2] when 'download' @git_access = 'git-upload-pack' when 'upload' @git_access = 'git-receive-pack' else raise DisallowedCommandError end else raise DisallowedCommandError unless args.count == 2 @repo_name = args.last end end def verify_access status = api.check_access(@git_access, @repo_name, @key_id, '_any', GL_PROTOCOL) raise AccessDeniedError, status.message unless status.allowed? self.repo_path = status.repository_path end def process_cmd(args) return self.send("api_#{@command}") if API_COMMANDS.include?(@command) if @command == 'git-annex-shell' raise DisallowedCommandError unless @config.git_annex_enabled? # Make sure repository has git-annex enabled init_git_annex unless gcryptsetup?(args) parsed_args = args.map do |arg| # use full repo path if arg =~ /\A\/.*\.git\Z/ repo_path else arg end end $logger.info "gitlab-shell: executing git-annex command <#{parsed_args.join(' ')}> for #{log_username}." exec_cmd(*parsed_args) elsif @command == 'git-lfs-authenticate' GitlabMetrics.measure('lfs-authenticate') do $logger.info "gitlab-shell: Processing LFS authentication for #{log_username}." lfs_authenticate end else $logger.info "gitlab-shell: executing git command <#{@command} #{repo_path}> for #{log_username}." exec_cmd(@command, repo_path) end end # This method is not covered by Rspec because it ends the current Ruby process. def exec_cmd(*args) # If you want to call a command without arguments, use # exec_cmd(['my_command', 'my_command']) . Otherwise use # exec_cmd('my_command', 'my_argument', ...). if args.count == 1 && !args.first.is_a?(Array) raise DisallowedCommandError end env = { 'HOME' => ENV['HOME'], 'PATH' => ENV['PATH'], 'LD_LIBRARY_PATH' => ENV['LD_LIBRARY_PATH'], 'LANG' => ENV['LANG'], 'GL_ID' => @key_id, 'GL_PROTOCOL' => GL_PROTOCOL } if @config.git_annex_enabled? env.merge!({ 'GIT_ANNEX_SHELL_LIMITED' => '1' }) end if git_trace_available? env.merge!({ 'GIT_TRACE' => @config.git_trace_log_file, 'GIT_TRACE_PACKET' => @config.git_trace_log_file, 'GIT_TRACE_PERFORMANCE' => @config.git_trace_log_file, }) end Kernel::exec(env, *args, unsetenv_others: true) end def api GitlabNet.new end def user return @user if defined?(@user) begin @user = api.discover(@key_id) rescue GitlabNet::ApiUnreachableError @user = nil end end def username user && user['name'] || 'Anonymous' end # User identifier to be used in log messages. def log_username @config.audit_usernames ? username : "user with key #{@key_id}" end def init_git_annex unless File.exists?(File.join(repo_path, 'annex')) cmd = %W(git --git-dir=#{repo_path} annex init "GitLab") system(*cmd, err: '/dev/null', out: '/dev/null') $logger.info "Enable git-annex for repository: #{repo_name}." end end def gcryptsetup?(args) non_dashed = args.reject { |a| a.start_with?('-') } non_dashed[0, 2] == %w{git-annex-shell gcryptsetup} end def lfs_authenticate lfs_access = api.lfs_authenticate(@key_id, @repo_name) return unless lfs_access puts lfs_access.authentication_payload end private def continue?(question) puts "#{question} (yes/no)" STDOUT.flush # Make sure the question gets output before we wait for input continue = STDIN.gets.chomp puts '' # Add a buffer in the output continue == 'yes' end def api_2fa_recovery_codes continue = continue?( "Are you sure you want to generate new two-factor recovery codes?\n" \ "Any existing recovery codes you saved will be invalidated." ) unless continue puts 'New recovery codes have *not* been generated. Existing codes will remain valid.' return end resp = api.two_factor_recovery_codes(key_id) if resp['success'] codes = resp['recovery_codes'].join("\n") puts "Your two-factor authentication recovery codes are:\n\n" \ "#{codes}\n\n" \ "During sign in, use one of the codes above when prompted for\n" \ "your two-factor code. Then, visit your Profile Settings and add\n" \ "a new device so you do not lose access to your account again." else puts "An error occurred while trying to generate new recovery codes.\n" \ "#{resp['message']}" end end def git_trace_available? return false unless @config.git_trace_log_file if Pathname(@config.git_trace_log_file).relative? $logger.warn "gitlab-shell: is configured to trace git commands with #{@config.git_trace_log_file.inspect} but an absolute path needs to be provided" return false end begin File.open(@config.git_trace_log_file, 'a') { nil } return true rescue => ex $logger.warn "gitlab-shell: is configured to trace git commands with #{@config.git_trace_log_file.inspect} but it's not possible to write in that path #{ex.message}" return false end end def repo_path=(repo_path) raise ArgumentError, "Repository path not provided. Please make sure you're using GitLab v8.10 or later." unless repo_path raise InvalidRepositoryPathError if File.absolute_path(repo_path) != repo_path @repo_path = repo_path end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/httpunix.rb000066400000000000000000000026661277744601700250330ustar00rootroot00000000000000# support for http+unix://... connection scheme # # The URI scheme has the same structure as the similar one for python requests. See: # http://fixall.online/theres-no-need-to-reinvent-the-wheelhttpsgithubcommsabramorequests-unixsocketurl/241810/ # https://github.com/msabramo/requests-unixsocket require 'uri' require 'net/http' module URI class HTTPUNIX < HTTP def hostname # decode %XX from path to file v = self.host URI.decode(v) end # port is not allowed in URI DEFAULT_PORT = nil def set_port(v) return v unless v raise InvalidURIError, "http+unix:// cannot contain port" end end @@schemes['HTTP+UNIX'] = HTTPUNIX end # Based on: # - http://stackoverflow.com/questions/15637226/ruby-1-9-3-simple-get-request-to-unicorn-through-socket # - Net::HTTP::connect module Net class HTTPUNIX < HTTP def initialize(socketpath, port=nil) super(socketpath, port) @port = nil # HTTP will set it to default - override back -> set DEFAULT_PORT end # override to prevent ":" being appended to HTTP_HOST def addr_port address end def connect D "opening connection to #{address} ..." s = UNIXSocket.new(address) D "opened" @socket = BufferedIO.new(s) @socket.read_timeout = @read_timeout @socket.continue_timeout = @continue_timeout @socket.debug_output = @debug_output on_connect end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/names_helper.rb000066400000000000000000000004501277744601700255770ustar00rootroot00000000000000module NamesHelper def extract_repo_name(path) repo_name = path.strip repo_name.gsub!(/\.git$/, "") repo_name.gsub!(/^\//, "") repo_name.split(File::SEPARATOR).last(2).join(File::SEPARATOR) end def extract_ref_name(ref) ref.gsub(/\Arefs\/(tags|heads)\//, '') end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/000077500000000000000000000000001277744601700241065ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/000077500000000000000000000000001277744601700252145ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/000077500000000000000000000000001277744601700257625ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis.rb000066400000000000000000002270451277744601700274270ustar00rootroot00000000000000require "monitor" require "redis/errors" class Redis def self.deprecate(message, trace = caller[0]) $stderr.puts "\n#{message} (in #{trace})" end attr :client # @deprecated The preferred way to create a new client object is using `#new`. # This method does not actually establish a connection to Redis, # in contrary to what you might expect. def self.connect(options = {}) new(options) end def self.current @current ||= Redis.new end def self.current=(redis) @current = redis end include MonitorMixin # Create a new client instance # # @param [Hash] options # @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection: `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket connection: `unix://[path to Redis socket]`. This overrides all other options. # @option options [String] :host ("127.0.0.1") server hostname # @option options [Fixnum] :port (6379) server port # @option options [String] :path path to server socket (overrides host and port) # @option options [Float] :timeout (5.0) timeout in seconds # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds # @option options [String] :password Password to authenticate against server # @option options [Fixnum] :db (0) Database to select after initial connect # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony` # @option options [String] :id ID for the client connection, assigns name to current connection by sending `CLIENT SETNAME` # @option options [Hash, Fixnum] :tcp_keepalive Keepalive values, if Fixnum `intvl` and `probe` are calculated based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Fixnum # @option options [Fixnum] :reconnect_attempts Number of attempts trying to connect # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not # @option options [Array] :sentinels List of sentinels to contact # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave` # # @return [Redis] a new client instance def initialize(options = {}) @options = options.dup @original_client = @client = Client.new(options) @queue = Hash.new { |h, k| h[k] = [] } super() # Monitor#initialize end def synchronize mon_synchronize { yield(@client) } end # Run code with the client reconnecting def with_reconnect(val=true, &blk) synchronize do |client| client.with_reconnect(val, &blk) end end # Run code without the client reconnecting def without_reconnect(&blk) with_reconnect(false, &blk) end # Test whether or not the client is connected def connected? @original_client.connected? end # Disconnect the client as quickly and silently as possible. def close @original_client.disconnect end alias disconnect! close # Sends a command to Redis and returns its reply. # # Replies are converted to Ruby objects according to the RESP protocol, so # you can expect a Ruby array, integer or nil when Redis sends one. Higher # level transformations, such as converting an array of pairs into a Ruby # hash, are up to consumers. # # Redis error replies are raised as Ruby exceptions. def call(*command) synchronize do |client| client.call(command) end end # Queues a command for pipelining. # # Commands in the queue are executed with the Redis#commit method. # # See http://redis.io/topics/pipelining for more details. # def queue(*command) @queue[Thread.current.object_id] << command end # Sends all commands in the queue. # # See http://redis.io/topics/pipelining for more details. # def commit synchronize do |client| begin client.call_pipelined(@queue[Thread.current.object_id]) ensure @queue.delete(Thread.current.object_id) end end end # Authenticate to the server. # # @param [String] password must match the password specified in the # `requirepass` directive in the configuration file # @return [String] `OK` def auth(password) synchronize do |client| client.call([:auth, password]) end end # Change the selected database for the current connection. # # @param [Fixnum] db zero-based index of the DB to use (0 to 15) # @return [String] `OK` def select(db) synchronize do |client| client.db = db client.call([:select, db]) end end # Ping the server. # # @return [String] `PONG` def ping synchronize do |client| client.call([:ping]) end end # Echo the given string. # # @param [String] value # @return [String] def echo(value) synchronize do |client| client.call([:echo, value]) end end # Close the connection. # # @return [String] `OK` def quit synchronize do |client| begin client.call([:quit]) rescue ConnectionError ensure client.disconnect end end end # Asynchronously rewrite the append-only file. # # @return [String] `OK` def bgrewriteaof synchronize do |client| client.call([:bgrewriteaof]) end end # Asynchronously save the dataset to disk. # # @return [String] `OK` def bgsave synchronize do |client| client.call([:bgsave]) end end # Get or set server configuration parameters. # # @param [Symbol] action e.g. `:get`, `:set`, `:resetstat` # @return [String, Hash] string reply, or hash when retrieving more than one # property with `CONFIG GET` def config(action, *args) synchronize do |client| client.call([:config, action] + args) do |reply| if reply.kind_of?(Array) && action == :get Hashify.call(reply) else reply end end end end # Return the number of keys in the selected database. # # @return [Fixnum] def dbsize synchronize do |client| client.call([:dbsize]) end end def debug(*args) synchronize do |client| client.call([:debug] + args) end end # Remove all keys from all databases. # # @return [String] `OK` def flushall synchronize do |client| client.call([:flushall]) end end # Remove all keys from the current database. # # @return [String] `OK` def flushdb synchronize do |client| client.call([:flushdb]) end end # Get information and statistics about the server. # # @param [String, Symbol] cmd e.g. "commandstats" # @return [Hash] def info(cmd = nil) synchronize do |client| client.call([:info, cmd].compact) do |reply| if reply.kind_of?(String) reply = Hash[reply.split("\r\n").map do |line| line.split(":", 2) unless line =~ /^(#|$)/ end.compact] if cmd && cmd.to_s == "commandstats" # Extract nested hashes for INFO COMMANDSTATS reply = Hash[reply.map do |k, v| v = v.split(",").map { |e| e.split("=") } [k[/^cmdstat_(.*)$/, 1], Hash[v]] end] end end reply end end end # Get the UNIX time stamp of the last successful save to disk. # # @return [Fixnum] def lastsave synchronize do |client| client.call([:lastsave]) end end # Listen for all requests received by the server in real time. # # There is no way to interrupt this command. # # @yield a block to be called for every line of output # @yieldparam [String] line timestamp and command that was executed def monitor(&block) synchronize do |client| client.call_loop([:monitor], &block) end end # Synchronously save the dataset to disk. # # @return [String] def save synchronize do |client| client.call([:save]) end end # Synchronously save the dataset to disk and then shut down the server. def shutdown synchronize do |client| client.with_reconnect(false) do begin client.call([:shutdown]) rescue ConnectionError # This means Redis has probably exited. nil end end end end # Make the server a slave of another instance, or promote it as master. def slaveof(host, port) synchronize do |client| client.call([:slaveof, host, port]) end end # Interact with the slowlog (get, len, reset) # # @param [String] subcommand e.g. `get`, `len`, `reset` # @param [Fixnum] length maximum number of entries to return # @return [Array, Fixnum, String] depends on subcommand def slowlog(subcommand, length=nil) synchronize do |client| args = [:slowlog, subcommand] args << length if length client.call args end end # Internal command used for replication. def sync synchronize do |client| client.call([:sync]) end end # Return the server time. # # @example # r.time # => [ 1333093196, 606806 ] # # @return [Array] tuple of seconds since UNIX epoch and # microseconds in the current second def time synchronize do |client| client.call([:time]) do |reply| reply.map(&:to_i) if reply end end end # Remove the expiration from a key. # # @param [String] key # @return [Boolean] whether the timeout was removed or not def persist(key) synchronize do |client| client.call([:persist, key], &Boolify) end end # Set a key's time to live in seconds. # # @param [String] key # @param [Fixnum] seconds time to live # @return [Boolean] whether the timeout was set or not def expire(key, seconds) synchronize do |client| client.call([:expire, key, seconds], &Boolify) end end # Set the expiration for a key as a UNIX timestamp. # # @param [String] key # @param [Fixnum] unix_time expiry time specified as a UNIX timestamp # @return [Boolean] whether the timeout was set or not def expireat(key, unix_time) synchronize do |client| client.call([:expireat, key, unix_time], &Boolify) end end # Get the time to live (in seconds) for a key. # # @param [String] key # @return [Fixnum] remaining time to live in seconds. # # In Redis 2.6 or older the command returns -1 if the key does not exist or if # the key exist but has no associated expire. # # Starting with Redis 2.8 the return value in case of error changed: # # - The command returns -2 if the key does not exist. # - The command returns -1 if the key exists but has no associated expire. def ttl(key) synchronize do |client| client.call([:ttl, key]) end end # Set a key's time to live in milliseconds. # # @param [String] key # @param [Fixnum] milliseconds time to live # @return [Boolean] whether the timeout was set or not def pexpire(key, milliseconds) synchronize do |client| client.call([:pexpire, key, milliseconds], &Boolify) end end # Set the expiration for a key as number of milliseconds from UNIX Epoch. # # @param [String] key # @param [Fixnum] ms_unix_time expiry time specified as number of milliseconds from UNIX Epoch. # @return [Boolean] whether the timeout was set or not def pexpireat(key, ms_unix_time) synchronize do |client| client.call([:pexpireat, key, ms_unix_time], &Boolify) end end # Get the time to live (in milliseconds) for a key. # # @param [String] key # @return [Fixnum] remaining time to live in milliseconds # In Redis 2.6 or older the command returns -1 if the key does not exist or if # the key exist but has no associated expire. # # Starting with Redis 2.8 the return value in case of error changed: # # - The command returns -2 if the key does not exist. # - The command returns -1 if the key exists but has no associated expire. def pttl(key) synchronize do |client| client.call([:pttl, key]) end end # Return a serialized version of the value stored at a key. # # @param [String] key # @return [String] serialized_value def dump(key) synchronize do |client| client.call([:dump, key]) end end # Create a key using the serialized value, previously obtained using DUMP. # # @param [String] key # @param [String] ttl # @param [String] serialized_value # @return [String] `"OK"` def restore(key, ttl, serialized_value) synchronize do |client| client.call([:restore, key, ttl, serialized_value]) end end # Transfer a key from the connected instance to another instance. # # @param [String] key # @param [Hash] options # - `:host => String`: host of instance to migrate to # - `:port => Integer`: port of instance to migrate to # - `:db => Integer`: database to migrate to (default: same as source) # - `:timeout => Integer`: timeout (default: same as connection timeout) # @return [String] `"OK"` def migrate(key, options) host = options[:host] || raise(RuntimeError, ":host not specified") port = options[:port] || raise(RuntimeError, ":port not specified") db = (options[:db] || client.db).to_i timeout = (options[:timeout] || client.timeout).to_i synchronize do |client| client.call([:migrate, host, port, key, db, timeout]) end end # Delete one or more keys. # # @param [String, Array] keys # @return [Fixnum] number of keys that were deleted def del(*keys) synchronize do |client| client.call([:del] + keys) end end # Determine if a key exists. # # @param [String] key # @return [Boolean] def exists(key) synchronize do |client| client.call([:exists, key], &Boolify) end end # Find all keys matching the given pattern. # # @param [String] pattern # @return [Array] def keys(pattern = "*") synchronize do |client| client.call([:keys, pattern]) do |reply| if reply.kind_of?(String) reply.split(" ") else reply end end end end # Move a key to another database. # # @example Move a key to another database # redis.set "foo", "bar" # # => "OK" # redis.move "foo", 2 # # => true # redis.exists "foo" # # => false # redis.select 2 # # => "OK" # redis.exists "foo" # # => true # redis.get "foo" # # => "bar" # # @param [String] key # @param [Fixnum] db # @return [Boolean] whether the key was moved or not def move(key, db) synchronize do |client| client.call([:move, key, db], &Boolify) end end def object(*args) synchronize do |client| client.call([:object] + args) end end # Return a random key from the keyspace. # # @return [String] def randomkey synchronize do |client| client.call([:randomkey]) end end # Rename a key. If the new key already exists it is overwritten. # # @param [String] old_name # @param [String] new_name # @return [String] `OK` def rename(old_name, new_name) synchronize do |client| client.call([:rename, old_name, new_name]) end end # Rename a key, only if the new key does not exist. # # @param [String] old_name # @param [String] new_name # @return [Boolean] whether the key was renamed or not def renamenx(old_name, new_name) synchronize do |client| client.call([:renamenx, old_name, new_name], &Boolify) end end # Sort the elements in a list, set or sorted set. # # @example Retrieve the first 2 elements from an alphabetically sorted "list" # redis.sort("list", :order => "alpha", :limit => [0, 2]) # # => ["a", "b"] # @example Store an alphabetically descending list in "target" # redis.sort("list", :order => "desc alpha", :store => "target") # # => 26 # # @param [String] key # @param [Hash] options # - `:by => String`: use external key to sort elements by # - `:limit => [offset, count]`: skip `offset` elements, return a maximum # of `count` elements # - `:get => [String, Array]`: single key or array of keys to # retrieve per element in the result # - `:order => String`: combination of `ASC`, `DESC` and optionally `ALPHA` # - `:store => String`: key to store the result at # # @return [Array, Array>, Fixnum] # - when `:get` is not specified, or holds a single element, an array of elements # - when `:get` is specified, and holds more than one element, an array of # elements where every element is an array with the result for every # element specified in `:get` # - when `:store` is specified, the number of elements in the stored result def sort(key, options = {}) args = [] by = options[:by] args.concat(["BY", by]) if by limit = options[:limit] args.concat(["LIMIT"] + limit) if limit get = Array(options[:get]) args.concat(["GET"].product(get).flatten) unless get.empty? order = options[:order] args.concat(order.split(" ")) if order store = options[:store] args.concat(["STORE", store]) if store synchronize do |client| client.call([:sort, key] + args) do |reply| if get.size > 1 && !store if reply reply.each_slice(get.size).to_a end else reply end end end end # Determine the type stored at key. # # @param [String] key # @return [String] `string`, `list`, `set`, `zset`, `hash` or `none` def type(key) synchronize do |client| client.call([:type, key]) end end # Decrement the integer value of a key by one. # # @example # redis.decr("value") # # => 4 # # @param [String] key # @return [Fixnum] value after decrementing it def decr(key) synchronize do |client| client.call([:decr, key]) end end # Decrement the integer value of a key by the given number. # # @example # redis.decrby("value", 5) # # => 0 # # @param [String] key # @param [Fixnum] decrement # @return [Fixnum] value after decrementing it def decrby(key, decrement) synchronize do |client| client.call([:decrby, key, decrement]) end end # Increment the integer value of a key by one. # # @example # redis.incr("value") # # => 6 # # @param [String] key # @return [Fixnum] value after incrementing it def incr(key) synchronize do |client| client.call([:incr, key]) end end # Increment the integer value of a key by the given integer number. # # @example # redis.incrby("value", 5) # # => 10 # # @param [String] key # @param [Fixnum] increment # @return [Fixnum] value after incrementing it def incrby(key, increment) synchronize do |client| client.call([:incrby, key, increment]) end end # Increment the numeric value of a key by the given float number. # # @example # redis.incrbyfloat("value", 1.23) # # => 1.23 # # @param [String] key # @param [Float] increment # @return [Float] value after incrementing it def incrbyfloat(key, increment) synchronize do |client| client.call([:incrbyfloat, key, increment], &Floatify) end end # Set the string value of a key. # # @param [String] key # @param [String] value # @param [Hash] options # - `:ex => Fixnum`: Set the specified expire time, in seconds. # - `:px => Fixnum`: Set the specified expire time, in milliseconds. # - `:nx => true`: Only set the key if it does not already exist. # - `:xx => true`: Only set the key if it already exist. # @return [String, Boolean] `"OK"` or true, false if `:nx => true` or `:xx => true` def set(key, value, options = {}) args = [] ex = options[:ex] args.concat(["EX", ex]) if ex px = options[:px] args.concat(["PX", px]) if px nx = options[:nx] args.concat(["NX"]) if nx xx = options[:xx] args.concat(["XX"]) if xx synchronize do |client| if nx || xx client.call([:set, key, value.to_s] + args, &BoolifySet) else client.call([:set, key, value.to_s] + args) end end end alias :[]= :set # Set the time to live in seconds of a key. # # @param [String] key # @param [Fixnum] ttl # @param [String] value # @return [String] `"OK"` def setex(key, ttl, value) synchronize do |client| client.call([:setex, key, ttl, value.to_s]) end end # Set the time to live in milliseconds of a key. # # @param [String] key # @param [Fixnum] ttl # @param [String] value # @return [String] `"OK"` def psetex(key, ttl, value) synchronize do |client| client.call([:psetex, key, ttl, value.to_s]) end end # Set the value of a key, only if the key does not exist. # # @param [String] key # @param [String] value # @return [Boolean] whether the key was set or not def setnx(key, value) synchronize do |client| client.call([:setnx, key, value.to_s], &Boolify) end end # Set one or more values. # # @example # redis.mset("key1", "v1", "key2", "v2") # # => "OK" # # @param [Array] args array of keys and values # @return [String] `"OK"` # # @see #mapped_mset def mset(*args) synchronize do |client| client.call([:mset] + args) end end # Set one or more values. # # @example # redis.mapped_mset({ "f1" => "v1", "f2" => "v2" }) # # => "OK" # # @param [Hash] hash keys mapping to values # @return [String] `"OK"` # # @see #mset def mapped_mset(hash) mset(hash.to_a.flatten) end # Set one or more values, only if none of the keys exist. # # @example # redis.msetnx("key1", "v1", "key2", "v2") # # => true # # @param [Array] args array of keys and values # @return [Boolean] whether or not all values were set # # @see #mapped_msetnx def msetnx(*args) synchronize do |client| client.call([:msetnx] + args, &Boolify) end end # Set one or more values, only if none of the keys exist. # # @example # redis.mapped_msetnx({ "key1" => "v1", "key2" => "v2" }) # # => true # # @param [Hash] hash keys mapping to values # @return [Boolean] whether or not all values were set # # @see #msetnx def mapped_msetnx(hash) msetnx(hash.to_a.flatten) end # Get the value of a key. # # @param [String] key # @return [String] def get(key) synchronize do |client| client.call([:get, key]) end end alias :[] :get # Get the values of all the given keys. # # @example # redis.mget("key1", "key1") # # => ["v1", "v2"] # # @param [Array] keys # @return [Array] an array of values for the specified keys # # @see #mapped_mget def mget(*keys, &blk) synchronize do |client| client.call([:mget] + keys, &blk) end end # Get the values of all the given keys. # # @example # redis.mapped_mget("key1", "key2") # # => { "key1" => "v1", "key2" => "v2" } # # @param [Array] keys array of keys # @return [Hash] a hash mapping the specified keys to their values # # @see #mget def mapped_mget(*keys) mget(*keys) do |reply| if reply.kind_of?(Array) Hash[keys.zip(reply)] else reply end end end # Overwrite part of a string at key starting at the specified offset. # # @param [String] key # @param [Fixnum] offset byte offset # @param [String] value # @return [Fixnum] length of the string after it was modified def setrange(key, offset, value) synchronize do |client| client.call([:setrange, key, offset, value.to_s]) end end # Get a substring of the string stored at a key. # # @param [String] key # @param [Fixnum] start zero-based start offset # @param [Fixnum] stop zero-based end offset. Use -1 for representing # the end of the string # @return [Fixnum] `0` or `1` def getrange(key, start, stop) synchronize do |client| client.call([:getrange, key, start, stop]) end end # Sets or clears the bit at offset in the string value stored at key. # # @param [String] key # @param [Fixnum] offset bit offset # @param [Fixnum] value bit value `0` or `1` # @return [Fixnum] the original bit value stored at `offset` def setbit(key, offset, value) synchronize do |client| client.call([:setbit, key, offset, value]) end end # Returns the bit value at offset in the string value stored at key. # # @param [String] key # @param [Fixnum] offset bit offset # @return [Fixnum] `0` or `1` def getbit(key, offset) synchronize do |client| client.call([:getbit, key, offset]) end end # Append a value to a key. # # @param [String] key # @param [String] value value to append # @return [Fixnum] length of the string after appending def append(key, value) synchronize do |client| client.call([:append, key, value]) end end # Count the number of set bits in a range of the string value stored at key. # # @param [String] key # @param [Fixnum] start start index # @param [Fixnum] stop stop index # @return [Fixnum] the number of bits set to 1 def bitcount(key, start = 0, stop = -1) synchronize do |client| client.call([:bitcount, key, start, stop]) end end # Perform a bitwise operation between strings and store the resulting string in a key. # # @param [String] operation e.g. `and`, `or`, `xor`, `not` # @param [String] destkey destination key # @param [String, Array] keys one or more source keys to perform `operation` # @return [Fixnum] the length of the string stored in `destkey` def bitop(operation, destkey, *keys) synchronize do |client| client.call([:bitop, operation, destkey] + keys) end end # Return the position of the first bit set to 1 or 0 in a string. # # @param [String] key # @param [Fixnum] bit whether to look for the first 1 or 0 bit # @param [Fixnum] start start index # @param [Fixnum] stop stop index # @return [Fixnum] the position of the first 1/0 bit. # -1 if looking for 1 and it is not found or start and stop are given. def bitpos(key, bit, start=nil, stop=nil) if stop and not start raise(ArgumentError, 'stop parameter specified without start parameter') end synchronize do |client| command = [:bitpos, key, bit] command << start if start command << stop if stop client.call(command) end end # Set the string value of a key and return its old value. # # @param [String] key # @param [String] value value to replace the current value with # @return [String] the old value stored in the key, or `nil` if the key # did not exist def getset(key, value) synchronize do |client| client.call([:getset, key, value.to_s]) end end # Get the length of the value stored in a key. # # @param [String] key # @return [Fixnum] the length of the value stored in the key, or 0 # if the key does not exist def strlen(key) synchronize do |client| client.call([:strlen, key]) end end # Get the length of a list. # # @param [String] key # @return [Fixnum] def llen(key) synchronize do |client| client.call([:llen, key]) end end # Prepend one or more values to a list, creating the list if it doesn't exist # # @param [String] key # @param [String, Array] value string value, or array of string values to push # @return [Fixnum] the length of the list after the push operation def lpush(key, value) synchronize do |client| client.call([:lpush, key, value]) end end # Prepend a value to a list, only if the list exists. # # @param [String] key # @param [String] value # @return [Fixnum] the length of the list after the push operation def lpushx(key, value) synchronize do |client| client.call([:lpushx, key, value]) end end # Append one or more values to a list, creating the list if it doesn't exist # # @param [String] key # @param [String] value # @return [Fixnum] the length of the list after the push operation def rpush(key, value) synchronize do |client| client.call([:rpush, key, value]) end end # Append a value to a list, only if the list exists. # # @param [String] key # @param [String] value # @return [Fixnum] the length of the list after the push operation def rpushx(key, value) synchronize do |client| client.call([:rpushx, key, value]) end end # Remove and get the first element in a list. # # @param [String] key # @return [String] def lpop(key) synchronize do |client| client.call([:lpop, key]) end end # Remove and get the last element in a list. # # @param [String] key # @return [String] def rpop(key) synchronize do |client| client.call([:rpop, key]) end end # Remove the last element in a list, append it to another list and return it. # # @param [String] source source key # @param [String] destination destination key # @return [nil, String] the element, or nil when the source key does not exist def rpoplpush(source, destination) synchronize do |client| client.call([:rpoplpush, source, destination]) end end def _bpop(cmd, args) options = {} case args.last when Hash options = args.pop when Integer # Issue deprecation notice in obnoxious mode... options[:timeout] = args.pop end if args.size > 1 # Issue deprecation notice in obnoxious mode... end keys = args.flatten timeout = options[:timeout] || 0 synchronize do |client| command = [cmd, keys, timeout] timeout += client.timeout if timeout > 0 client.call_with_timeout(command, timeout) end end # Remove and get the first element in a list, or block until one is available. # # @example With timeout # list, element = redis.blpop("list", :timeout => 5) # # => nil on timeout # # => ["list", "element"] on success # @example Without timeout # list, element = redis.blpop("list") # # => ["list", "element"] # @example Blocking pop on multiple lists # list, element = redis.blpop(["list", "another_list"]) # # => ["list", "element"] # # @param [String, Array] keys one or more keys to perform the # blocking pop on # @param [Hash] options # - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout # # @return [nil, [String, String]] # - `nil` when the operation timed out # - tuple of the list that was popped from and element was popped otherwise def blpop(*args) _bpop(:blpop, args) end # Remove and get the last element in a list, or block until one is available. # # @param [String, Array] keys one or more keys to perform the # blocking pop on # @param [Hash] options # - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout # # @return [nil, [String, String]] # - `nil` when the operation timed out # - tuple of the list that was popped from and element was popped otherwise # # @see #blpop def brpop(*args) _bpop(:brpop, args) end # Pop a value from a list, push it to another list and return it; or block # until one is available. # # @param [String] source source key # @param [String] destination destination key # @param [Hash] options # - `:timeout => Fixnum`: timeout in seconds, defaults to no timeout # # @return [nil, String] # - `nil` when the operation timed out # - the element was popped and pushed otherwise def brpoplpush(source, destination, options = {}) case options when Integer # Issue deprecation notice in obnoxious mode... options = { :timeout => options } end timeout = options[:timeout] || 0 synchronize do |client| command = [:brpoplpush, source, destination, timeout] timeout += client.timeout if timeout > 0 client.call_with_timeout(command, timeout) end end # Get an element from a list by its index. # # @param [String] key # @param [Fixnum] index # @return [String] def lindex(key, index) synchronize do |client| client.call([:lindex, key, index]) end end # Insert an element before or after another element in a list. # # @param [String] key # @param [String, Symbol] where `BEFORE` or `AFTER` # @param [String] pivot reference element # @param [String] value # @return [Fixnum] length of the list after the insert operation, or `-1` # when the element `pivot` was not found def linsert(key, where, pivot, value) synchronize do |client| client.call([:linsert, key, where, pivot, value]) end end # Get a range of elements from a list. # # @param [String] key # @param [Fixnum] start start index # @param [Fixnum] stop stop index # @return [Array] def lrange(key, start, stop) synchronize do |client| client.call([:lrange, key, start, stop]) end end # Remove elements from a list. # # @param [String] key # @param [Fixnum] count number of elements to remove. Use a positive # value to remove the first `count` occurrences of `value`. A negative # value to remove the last `count` occurrences of `value`. Or zero, to # remove all occurrences of `value` from the list. # @param [String] value # @return [Fixnum] the number of removed elements def lrem(key, count, value) synchronize do |client| client.call([:lrem, key, count, value]) end end # Set the value of an element in a list by its index. # # @param [String] key # @param [Fixnum] index # @param [String] value # @return [String] `OK` def lset(key, index, value) synchronize do |client| client.call([:lset, key, index, value]) end end # Trim a list to the specified range. # # @param [String] key # @param [Fixnum] start start index # @param [Fixnum] stop stop index # @return [String] `OK` def ltrim(key, start, stop) synchronize do |client| client.call([:ltrim, key, start, stop]) end end # Get the number of members in a set. # # @param [String] key # @return [Fixnum] def scard(key) synchronize do |client| client.call([:scard, key]) end end # Add one or more members to a set. # # @param [String] key # @param [String, Array] member one member, or array of members # @return [Boolean, Fixnum] `Boolean` when a single member is specified, # holding whether or not adding the member succeeded, or `Fixnum` when an # array of members is specified, holding the number of members that were # successfully added def sadd(key, member) synchronize do |client| client.call([:sadd, key, member]) do |reply| if member.is_a? Array # Variadic: return integer reply else # Single argument: return boolean Boolify.call(reply) end end end end # Remove one or more members from a set. # # @param [String] key # @param [String, Array] member one member, or array of members # @return [Boolean, Fixnum] `Boolean` when a single member is specified, # holding whether or not removing the member succeeded, or `Fixnum` when an # array of members is specified, holding the number of members that were # successfully removed def srem(key, member) synchronize do |client| client.call([:srem, key, member]) do |reply| if member.is_a? Array # Variadic: return integer reply else # Single argument: return boolean Boolify.call(reply) end end end end # Remove and return a random member from a set. # # @param [String] key # @return [String] def spop(key) synchronize do |client| client.call([:spop, key]) end end # Get one or more random members from a set. # # @param [String] key # @param [Fixnum] count # @return [String] def srandmember(key, count = nil) synchronize do |client| if count.nil? client.call([:srandmember, key]) else client.call([:srandmember, key, count]) end end end # Move a member from one set to another. # # @param [String] source source key # @param [String] destination destination key # @param [String] member member to move from `source` to `destination` # @return [Boolean] def smove(source, destination, member) synchronize do |client| client.call([:smove, source, destination, member], &Boolify) end end # Determine if a given value is a member of a set. # # @param [String] key # @param [String] member # @return [Boolean] def sismember(key, member) synchronize do |client| client.call([:sismember, key, member], &Boolify) end end # Get all the members in a set. # # @param [String] key # @return [Array] def smembers(key) synchronize do |client| client.call([:smembers, key]) end end # Subtract multiple sets. # # @param [String, Array] keys keys pointing to sets to subtract # @return [Array] members in the difference def sdiff(*keys) synchronize do |client| client.call([:sdiff] + keys) end end # Subtract multiple sets and store the resulting set in a key. # # @param [String] destination destination key # @param [String, Array] keys keys pointing to sets to subtract # @return [Fixnum] number of elements in the resulting set def sdiffstore(destination, *keys) synchronize do |client| client.call([:sdiffstore, destination] + keys) end end # Intersect multiple sets. # # @param [String, Array] keys keys pointing to sets to intersect # @return [Array] members in the intersection def sinter(*keys) synchronize do |client| client.call([:sinter] + keys) end end # Intersect multiple sets and store the resulting set in a key. # # @param [String] destination destination key # @param [String, Array] keys keys pointing to sets to intersect # @return [Fixnum] number of elements in the resulting set def sinterstore(destination, *keys) synchronize do |client| client.call([:sinterstore, destination] + keys) end end # Add multiple sets. # # @param [String, Array] keys keys pointing to sets to unify # @return [Array] members in the union def sunion(*keys) synchronize do |client| client.call([:sunion] + keys) end end # Add multiple sets and store the resulting set in a key. # # @param [String] destination destination key # @param [String, Array] keys keys pointing to sets to unify # @return [Fixnum] number of elements in the resulting set def sunionstore(destination, *keys) synchronize do |client| client.call([:sunionstore, destination] + keys) end end # Get the number of members in a sorted set. # # @example # redis.zcard("zset") # # => 4 # # @param [String] key # @return [Fixnum] def zcard(key) synchronize do |client| client.call([:zcard, key]) end end # Add one or more members to a sorted set, or update the score for members # that already exist. # # @example Add a single `[score, member]` pair to a sorted set # redis.zadd("zset", 32.0, "member") # @example Add an array of `[score, member]` pairs to a sorted set # redis.zadd("zset", [[32.0, "a"], [64.0, "b"]]) # # @param [String] key # @param [[Float, String], Array<[Float, String]>] args # - a single `[score, member]` pair # - an array of `[score, member]` pairs # @param [Hash] options # - `:xx => true`: Only update elements that already exist (never # add elements) # - `:nx => true`: Don't update already existing elements (always # add new elements) # - `:ch => true`: Modify the return value from the number of new # elements added, to the total number of elements changed (CH is an # abbreviation of changed); changed elements are new elements added # and elements already existing for which the score was updated # - `:incr => true`: When this option is specified ZADD acts like # ZINCRBY; only one score-element pair can be specified in this mode # # @return [Boolean, Fixnum, Float] # - `Boolean` when a single pair is specified, holding whether or not it was # **added** to the sorted set. # - `Fixnum` when an array of pairs is specified, holding the number of # pairs that were **added** to the sorted set. # - `Float` when option :incr is specified, holding the score of the member # after incrementing it. def zadd(key, *args) #, options zadd_options = [] if args.last.is_a?(Hash) options = args.pop nx = options[:nx] zadd_options << "NX" if nx xx = options[:xx] zadd_options << "XX" if xx ch = options[:ch] zadd_options << "CH" if ch incr = options[:incr] zadd_options << "INCR" if incr end synchronize do |client| if args.size == 1 && args[0].is_a?(Array) # Variadic: return float if INCR, integer if !INCR client.call([:zadd, key] + zadd_options + args[0], &(incr ? Floatify : nil)) elsif args.size == 2 # Single pair: return float if INCR, boolean if !INCR client.call([:zadd, key] + zadd_options + args, &(incr ? Floatify : Boolify)) else raise ArgumentError, "wrong number of arguments" end end end # Increment the score of a member in a sorted set. # # @example # redis.zincrby("zset", 32.0, "a") # # => 64.0 # # @param [String] key # @param [Float] increment # @param [String] member # @return [Float] score of the member after incrementing it def zincrby(key, increment, member) synchronize do |client| client.call([:zincrby, key, increment, member], &Floatify) end end # Remove one or more members from a sorted set. # # @example Remove a single member from a sorted set # redis.zrem("zset", "a") # @example Remove an array of members from a sorted set # redis.zrem("zset", ["a", "b"]) # # @param [String] key # @param [String, Array] member # - a single member # - an array of members # # @return [Boolean, Fixnum] # - `Boolean` when a single member is specified, holding whether or not it # was removed from the sorted set # - `Fixnum` when an array of pairs is specified, holding the number of # members that were removed to the sorted set def zrem(key, member) synchronize do |client| client.call([:zrem, key, member]) do |reply| if member.is_a? Array # Variadic: return integer reply else # Single argument: return boolean Boolify.call(reply) end end end end # Get the score associated with the given member in a sorted set. # # @example Get the score for member "a" # redis.zscore("zset", "a") # # => 32.0 # # @param [String] key # @param [String] member # @return [Float] score of the member def zscore(key, member) synchronize do |client| client.call([:zscore, key, member], &Floatify) end end # Return a range of members in a sorted set, by index. # # @example Retrieve all members from a sorted set # redis.zrange("zset", 0, -1) # # => ["a", "b"] # @example Retrieve all members and their scores from a sorted set # redis.zrange("zset", 0, -1, :with_scores => true) # # => [["a", 32.0], ["b", 64.0]] # # @param [String] key # @param [Fixnum] start start index # @param [Fixnum] stop stop index # @param [Hash] options # - `:with_scores => true`: include scores in output # # @return [Array, Array<[String, Float]>] # - when `:with_scores` is not specified, an array of members # - when `:with_scores` is specified, an array with `[member, score]` pairs def zrange(key, start, stop, options = {}) args = [] with_scores = options[:with_scores] || options[:withscores] if with_scores args << "WITHSCORES" block = FloatifyPairs end synchronize do |client| client.call([:zrange, key, start, stop] + args, &block) end end # Return a range of members in a sorted set, by index, with scores ordered # from high to low. # # @example Retrieve all members from a sorted set # redis.zrevrange("zset", 0, -1) # # => ["b", "a"] # @example Retrieve all members and their scores from a sorted set # redis.zrevrange("zset", 0, -1, :with_scores => true) # # => [["b", 64.0], ["a", 32.0]] # # @see #zrange def zrevrange(key, start, stop, options = {}) args = [] with_scores = options[:with_scores] || options[:withscores] if with_scores args << "WITHSCORES" block = FloatifyPairs end synchronize do |client| client.call([:zrevrange, key, start, stop] + args, &block) end end # Determine the index of a member in a sorted set. # # @param [String] key # @param [String] member # @return [Fixnum] def zrank(key, member) synchronize do |client| client.call([:zrank, key, member]) end end # Determine the index of a member in a sorted set, with scores ordered from # high to low. # # @param [String] key # @param [String] member # @return [Fixnum] def zrevrank(key, member) synchronize do |client| client.call([:zrevrank, key, member]) end end # Remove all members in a sorted set within the given indexes. # # @example Remove first 5 members # redis.zremrangebyrank("zset", 0, 4) # # => 5 # @example Remove last 5 members # redis.zremrangebyrank("zset", -5, -1) # # => 5 # # @param [String] key # @param [Fixnum] start start index # @param [Fixnum] stop stop index # @return [Fixnum] number of members that were removed def zremrangebyrank(key, start, stop) synchronize do |client| client.call([:zremrangebyrank, key, start, stop]) end end # Return a range of members with the same score in a sorted set, by lexicographical ordering # # @example Retrieve members matching a # redis.zrangebylex("zset", "[a", "[a\xff") # # => ["aaren", "aarika", "abagael", "abby"] # @example Retrieve the first 2 members matching a # redis.zrangebylex("zset", "[a", "[a\xff", :limit => [0, 2]) # # => ["aaren", "aarika"] # # @param [String] key # @param [String] min # - inclusive minimum is specified by prefixing `(` # - exclusive minimum is specified by prefixing `[` # @param [String] max # - inclusive maximum is specified by prefixing `(` # - exclusive maximum is specified by prefixing `[` # @param [Hash] options # - `:limit => [offset, count]`: skip `offset` members, return a maximum of # `count` members # # @return [Array, Array<[String, Float]>] def zrangebylex(key, min, max, options = {}) args = [] limit = options[:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrangebylex, key, min, max] + args) end end # Return a range of members with the same score in a sorted set, by reversed lexicographical ordering. # Apart from the reversed ordering, #zrevrangebylex is similar to #zrangebylex. # # @example Retrieve members matching a # redis.zrevrangebylex("zset", "[a", "[a\xff") # # => ["abbygail", "abby", "abagael", "aaren"] # @example Retrieve the last 2 members matching a # redis.zrevrangebylex("zset", "[a", "[a\xff", :limit => [0, 2]) # # => ["abbygail", "abby"] # # @see #zrangebylex def zrevrangebylex(key, max, min, options = {}) args = [] limit = options[:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrevrangebylex, key, max, min] + args) end end # Return a range of members in a sorted set, by score. # # @example Retrieve members with score `>= 5` and `< 100` # redis.zrangebyscore("zset", "5", "(100") # # => ["a", "b"] # @example Retrieve the first 2 members with score `>= 0` # redis.zrangebyscore("zset", "0", "+inf", :limit => [0, 2]) # # => ["a", "b"] # @example Retrieve members and their scores with scores `> 5` # redis.zrangebyscore("zset", "(5", "+inf", :with_scores => true) # # => [["a", 32.0], ["b", 64.0]] # # @param [String] key # @param [String] min # - inclusive minimum score is specified verbatim # - exclusive minimum score is specified by prefixing `(` # @param [String] max # - inclusive maximum score is specified verbatim # - exclusive maximum score is specified by prefixing `(` # @param [Hash] options # - `:with_scores => true`: include scores in output # - `:limit => [offset, count]`: skip `offset` members, return a maximum of # `count` members # # @return [Array, Array<[String, Float]>] # - when `:with_scores` is not specified, an array of members # - when `:with_scores` is specified, an array with `[member, score]` pairs def zrangebyscore(key, min, max, options = {}) args = [] with_scores = options[:with_scores] || options[:withscores] if with_scores args << "WITHSCORES" block = FloatifyPairs end limit = options[:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrangebyscore, key, min, max] + args, &block) end end # Return a range of members in a sorted set, by score, with scores ordered # from high to low. # # @example Retrieve members with score `< 100` and `>= 5` # redis.zrevrangebyscore("zset", "(100", "5") # # => ["b", "a"] # @example Retrieve the first 2 members with score `<= 0` # redis.zrevrangebyscore("zset", "0", "-inf", :limit => [0, 2]) # # => ["b", "a"] # @example Retrieve members and their scores with scores `> 5` # redis.zrevrangebyscore("zset", "+inf", "(5", :with_scores => true) # # => [["b", 64.0], ["a", 32.0]] # # @see #zrangebyscore def zrevrangebyscore(key, max, min, options = {}) args = [] with_scores = options[:with_scores] || options[:withscores] if with_scores args << ["WITHSCORES"] block = FloatifyPairs end limit = options[:limit] args.concat(["LIMIT"] + limit) if limit synchronize do |client| client.call([:zrevrangebyscore, key, max, min] + args, &block) end end # Remove all members in a sorted set within the given scores. # # @example Remove members with score `>= 5` and `< 100` # redis.zremrangebyscore("zset", "5", "(100") # # => 2 # @example Remove members with scores `> 5` # redis.zremrangebyscore("zset", "(5", "+inf") # # => 2 # # @param [String] key # @param [String] min # - inclusive minimum score is specified verbatim # - exclusive minimum score is specified by prefixing `(` # @param [String] max # - inclusive maximum score is specified verbatim # - exclusive maximum score is specified by prefixing `(` # @return [Fixnum] number of members that were removed def zremrangebyscore(key, min, max) synchronize do |client| client.call([:zremrangebyscore, key, min, max]) end end # Count the members in a sorted set with scores within the given values. # # @example Count members with score `>= 5` and `< 100` # redis.zcount("zset", "5", "(100") # # => 2 # @example Count members with scores `> 5` # redis.zcount("zset", "(5", "+inf") # # => 2 # # @param [String] key # @param [String] min # - inclusive minimum score is specified verbatim # - exclusive minimum score is specified by prefixing `(` # @param [String] max # - inclusive maximum score is specified verbatim # - exclusive maximum score is specified by prefixing `(` # @return [Fixnum] number of members in within the specified range def zcount(key, min, max) synchronize do |client| client.call([:zcount, key, min, max]) end end # Intersect multiple sorted sets and store the resulting sorted set in a new # key. # # @example Compute the intersection of `2*zsetA` with `1*zsetB`, summing their scores # redis.zinterstore("zsetC", ["zsetA", "zsetB"], :weights => [2.0, 1.0], :aggregate => "sum") # # => 4 # # @param [String] destination destination key # @param [Array] keys source keys # @param [Hash] options # - `:weights => [Float, Float, ...]`: weights to associate with source # sorted sets # - `:aggregate => String`: aggregate function to use (sum, min, max, ...) # @return [Fixnum] number of elements in the resulting sorted set def zinterstore(destination, keys, options = {}) args = [] weights = options[:weights] args.concat(["WEIGHTS"] + weights) if weights aggregate = options[:aggregate] args.concat(["AGGREGATE", aggregate]) if aggregate synchronize do |client| client.call([:zinterstore, destination, keys.size] + keys + args) end end # Add multiple sorted sets and store the resulting sorted set in a new key. # # @example Compute the union of `2*zsetA` with `1*zsetB`, summing their scores # redis.zunionstore("zsetC", ["zsetA", "zsetB"], :weights => [2.0, 1.0], :aggregate => "sum") # # => 8 # # @param [String] destination destination key # @param [Array] keys source keys # @param [Hash] options # - `:weights => [Float, Float, ...]`: weights to associate with source # sorted sets # - `:aggregate => String`: aggregate function to use (sum, min, max, ...) # @return [Fixnum] number of elements in the resulting sorted set def zunionstore(destination, keys, options = {}) args = [] weights = options[:weights] args.concat(["WEIGHTS"] + weights) if weights aggregate = options[:aggregate] args.concat(["AGGREGATE", aggregate]) if aggregate synchronize do |client| client.call([:zunionstore, destination, keys.size] + keys + args) end end # Get the number of fields in a hash. # # @param [String] key # @return [Fixnum] number of fields in the hash def hlen(key) synchronize do |client| client.call([:hlen, key]) end end # Set the string value of a hash field. # # @param [String] key # @param [String] field # @param [String] value # @return [Boolean] whether or not the field was **added** to the hash def hset(key, field, value) synchronize do |client| client.call([:hset, key, field, value], &Boolify) end end # Set the value of a hash field, only if the field does not exist. # # @param [String] key # @param [String] field # @param [String] value # @return [Boolean] whether or not the field was **added** to the hash def hsetnx(key, field, value) synchronize do |client| client.call([:hsetnx, key, field, value], &Boolify) end end # Set one or more hash values. # # @example # redis.hmset("hash", "f1", "v1", "f2", "v2") # # => "OK" # # @param [String] key # @param [Array] attrs array of fields and values # @return [String] `"OK"` # # @see #mapped_hmset def hmset(key, *attrs) synchronize do |client| client.call([:hmset, key] + attrs) end end # Set one or more hash values. # # @example # redis.mapped_hmset("hash", { "f1" => "v1", "f2" => "v2" }) # # => "OK" # # @param [String] key # @param [Hash] hash a non-empty hash with fields mapping to values # @return [String] `"OK"` # # @see #hmset def mapped_hmset(key, hash) hmset(key, hash.to_a.flatten) end # Get the value of a hash field. # # @param [String] key # @param [String] field # @return [String] def hget(key, field) synchronize do |client| client.call([:hget, key, field]) end end # Get the values of all the given hash fields. # # @example # redis.hmget("hash", "f1", "f2") # # => ["v1", "v2"] # # @param [String] key # @param [Array] fields array of fields # @return [Array] an array of values for the specified fields # # @see #mapped_hmget def hmget(key, *fields, &blk) synchronize do |client| client.call([:hmget, key] + fields, &blk) end end # Get the values of all the given hash fields. # # @example # redis.mapped_hmget("hash", "f1", "f2") # # => { "f1" => "v1", "f2" => "v2" } # # @param [String] key # @param [Array] fields array of fields # @return [Hash] a hash mapping the specified fields to their values # # @see #hmget def mapped_hmget(key, *fields) hmget(key, *fields) do |reply| if reply.kind_of?(Array) Hash[fields.zip(reply)] else reply end end end # Delete one or more hash fields. # # @param [String] key # @param [String, Array] field # @return [Fixnum] the number of fields that were removed from the hash def hdel(key, field) synchronize do |client| client.call([:hdel, key, field]) end end # Determine if a hash field exists. # # @param [String] key # @param [String] field # @return [Boolean] whether or not the field exists in the hash def hexists(key, field) synchronize do |client| client.call([:hexists, key, field], &Boolify) end end # Increment the integer value of a hash field by the given integer number. # # @param [String] key # @param [String] field # @param [Fixnum] increment # @return [Fixnum] value of the field after incrementing it def hincrby(key, field, increment) synchronize do |client| client.call([:hincrby, key, field, increment]) end end # Increment the numeric value of a hash field by the given float number. # # @param [String] key # @param [String] field # @param [Float] increment # @return [Float] value of the field after incrementing it def hincrbyfloat(key, field, increment) synchronize do |client| client.call([:hincrbyfloat, key, field, increment], &Floatify) end end # Get all the fields in a hash. # # @param [String] key # @return [Array] def hkeys(key) synchronize do |client| client.call([:hkeys, key]) end end # Get all the values in a hash. # # @param [String] key # @return [Array] def hvals(key) synchronize do |client| client.call([:hvals, key]) end end # Get all the fields and values in a hash. # # @param [String] key # @return [Hash] def hgetall(key) synchronize do |client| client.call([:hgetall, key], &Hashify) end end # Post a message to a channel. def publish(channel, message) synchronize do |client| client.call([:publish, channel, message]) end end def subscribed? synchronize do |client| client.kind_of? SubscribedClient end end # Listen for messages published to the given channels. def subscribe(*channels, &block) synchronize do |client| _subscription(:subscribe, 0, channels, block) end end # Listen for messages published to the given channels. Throw a timeout error if there is no messages for a timeout period. def subscribe_with_timeout(timeout, *channels, &block) synchronize do |client| _subscription(:subscribe_with_timeout, timeout, channels, block) end end # Stop listening for messages posted to the given channels. def unsubscribe(*channels) synchronize do |client| raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed? client.unsubscribe(*channels) end end # Listen for messages published to channels matching the given patterns. def psubscribe(*channels, &block) synchronize do |client| _subscription(:psubscribe, 0, channels, block) end end # Listen for messages published to channels matching the given patterns. Throw a timeout error if there is no messages for a timeout period. def psubscribe_with_timeout(timeout, *channels, &block) synchronize do |client| _subscription(:psubscribe_with_timeout, timeout, channels, block) end end # Stop listening for messages posted to channels matching the given patterns. def punsubscribe(*channels) synchronize do |client| raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed? client.punsubscribe(*channels) end end # Inspect the state of the Pub/Sub subsystem. # Possible subcommands: channels, numsub, numpat. def pubsub(subcommand, *args) synchronize do |client| client.call([:pubsub, subcommand] + args) end end # Watch the given keys to determine execution of the MULTI/EXEC block. # # Using a block is optional, but is necessary for thread-safety. # # An `#unwatch` is automatically issued if an exception is raised within the # block that is a subclass of StandardError and is not a ConnectionError. # # @example With a block # redis.watch("key") do # if redis.get("key") == "some value" # redis.multi do |multi| # multi.set("key", "other value") # multi.incr("counter") # end # else # redis.unwatch # end # end # # => ["OK", 6] # # @example Without a block # redis.watch("key") # # => "OK" # # @param [String, Array] keys one or more keys to watch # @return [Object] if using a block, returns the return value of the block # @return [String] if not using a block, returns `OK` # # @see #unwatch # @see #multi def watch(*keys) synchronize do |client| res = client.call([:watch] + keys) if block_given? begin yield(self) rescue ConnectionError raise rescue StandardError unwatch raise end else res end end end # Forget about all watched keys. # # @return [String] `OK` # # @see #watch # @see #multi def unwatch synchronize do |client| client.call([:unwatch]) end end def pipelined synchronize do |client| begin original, @client = @client, Pipeline.new yield(self) original.call_pipeline(@client) ensure @client = original end end end # Mark the start of a transaction block. # # Passing a block is optional. # # @example With a block # redis.multi do |multi| # multi.set("key", "value") # multi.incr("counter") # end # => ["OK", 6] # # @example Without a block # redis.multi # # => "OK" # redis.set("key", "value") # # => "QUEUED" # redis.incr("counter") # # => "QUEUED" # redis.exec # # => ["OK", 6] # # @yield [multi] the commands that are called inside this block are cached # and written to the server upon returning from it # @yieldparam [Redis] multi `self` # # @return [String, Array<...>] # - when a block is not given, `OK` # - when a block is given, an array with replies # # @see #watch # @see #unwatch def multi synchronize do |client| if !block_given? client.call([:multi]) else begin pipeline = Pipeline::Multi.new original, @client = @client, pipeline yield(self) original.call_pipeline(pipeline) ensure @client = original end end end end # Execute all commands issued after MULTI. # # Only call this method when `#multi` was called **without** a block. # # @return [nil, Array<...>] # - when commands were not executed, `nil` # - when commands were executed, an array with their replies # # @see #multi # @see #discard def exec synchronize do |client| client.call([:exec]) end end # Discard all commands issued after MULTI. # # Only call this method when `#multi` was called **without** a block. # # @return [String] `"OK"` # # @see #multi # @see #exec def discard synchronize do |client| client.call([:discard]) end end # Control remote script registry. # # @example Load a script # sha = redis.script(:load, "return 1") # # => # @example Check if a script exists # redis.script(:exists, sha) # # => true # @example Check if multiple scripts exist # redis.script(:exists, [sha, other_sha]) # # => [true, false] # @example Flush the script registry # redis.script(:flush) # # => "OK" # @example Kill a running script # redis.script(:kill) # # => "OK" # # @param [String] subcommand e.g. `exists`, `flush`, `load`, `kill` # @param [Array] args depends on subcommand # @return [String, Boolean, Array, ...] depends on subcommand # # @see #eval # @see #evalsha def script(subcommand, *args) subcommand = subcommand.to_s.downcase if subcommand == "exists" synchronize do |client| arg = args.first client.call([:script, :exists, arg]) do |reply| reply = reply.map { |r| Boolify.call(r) } if arg.is_a?(Array) reply else reply.first end end end else synchronize do |client| client.call([:script, subcommand] + args) end end end def _eval(cmd, args) script = args.shift options = args.pop if args.last.is_a?(Hash) options ||= {} keys = args.shift || options[:keys] || [] argv = args.shift || options[:argv] || [] synchronize do |client| client.call([cmd, script, keys.length] + keys + argv) end end # Evaluate Lua script. # # @example EVAL without KEYS nor ARGV # redis.eval("return 1") # # => 1 # @example EVAL with KEYS and ARGV as array arguments # redis.eval("return { KEYS, ARGV }", ["k1", "k2"], ["a1", "a2"]) # # => [["k1", "k2"], ["a1", "a2"]] # @example EVAL with KEYS and ARGV in a hash argument # redis.eval("return { KEYS, ARGV }", :keys => ["k1", "k2"], :argv => ["a1", "a2"]) # # => [["k1", "k2"], ["a1", "a2"]] # # @param [Array] keys optional array with keys to pass to the script # @param [Array] argv optional array with arguments to pass to the script # @param [Hash] options # - `:keys => Array`: optional array with keys to pass to the script # - `:argv => Array`: optional array with arguments to pass to the script # @return depends on the script # # @see #script # @see #evalsha def eval(*args) _eval(:eval, args) end # Evaluate Lua script by its SHA. # # @example EVALSHA without KEYS nor ARGV # redis.evalsha(sha) # # => # @example EVALSHA with KEYS and ARGV as array arguments # redis.evalsha(sha, ["k1", "k2"], ["a1", "a2"]) # # => # @example EVALSHA with KEYS and ARGV in a hash argument # redis.evalsha(sha, :keys => ["k1", "k2"], :argv => ["a1", "a2"]) # # => # # @param [Array] keys optional array with keys to pass to the script # @param [Array] argv optional array with arguments to pass to the script # @param [Hash] options # - `:keys => Array`: optional array with keys to pass to the script # - `:argv => Array`: optional array with arguments to pass to the script # @return depends on the script # # @see #script # @see #eval def evalsha(*args) _eval(:evalsha, args) end def _scan(command, cursor, args, options = {}, &block) # SSCAN/ZSCAN/HSCAN already prepend the key to +args+. args << cursor if match = options[:match] args.concat(["MATCH", match]) end if count = options[:count] args.concat(["COUNT", count]) end synchronize do |client| client.call([command] + args, &block) end end # Scan the keyspace # # @example Retrieve the first batch of keys # redis.scan(0) # # => ["4", ["key:21", "key:47", "key:42"]] # @example Retrieve a batch of keys matching a pattern # redis.scan(4, :match => "key:1?") # # => ["92", ["key:13", "key:18"]] # # @param [String, Integer] cursor the cursor of the iteration # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [String, Array] the next cursor and all found keys def scan(cursor, options={}) _scan(:scan, cursor, [], options) end # Scan the keyspace # # @example Retrieve all of the keys (with possible duplicates) # redis.scan_each.to_a # # => ["key:21", "key:47", "key:42"] # @example Execute block for each key matching a pattern # redis.scan_each(:match => "key:1?") {|key| puts key} # # => key:13 # # => key:18 # # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [Enumerator] an enumerator for all found keys def scan_each(options={}, &block) return to_enum(:scan_each, options) unless block_given? cursor = 0 loop do cursor, keys = scan(cursor, options) keys.each(&block) break if cursor == "0" end end # Scan a hash # # @example Retrieve the first batch of key/value pairs in a hash # redis.hscan("hash", 0) # # @param [String, Integer] cursor the cursor of the iteration # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [String, Array<[String, String]>] the next cursor and all found keys def hscan(key, cursor, options={}) _scan(:hscan, cursor, [key], options) do |reply| [reply[0], reply[1].each_slice(2).to_a] end end # Scan a hash # # @example Retrieve all of the key/value pairs in a hash # redis.hscan_each("hash").to_a # # => [["key70", "70"], ["key80", "80"]] # # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [Enumerator] an enumerator for all found keys def hscan_each(key, options={}, &block) return to_enum(:hscan_each, key, options) unless block_given? cursor = 0 loop do cursor, values = hscan(key, cursor, options) values.each(&block) break if cursor == "0" end end # Scan a sorted set # # @example Retrieve the first batch of key/value pairs in a hash # redis.zscan("zset", 0) # # @param [String, Integer] cursor the cursor of the iteration # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [String, Array<[String, Float]>] the next cursor and all found # members and scores def zscan(key, cursor, options={}) _scan(:zscan, cursor, [key], options) do |reply| [reply[0], FloatifyPairs.call(reply[1])] end end # Scan a sorted set # # @example Retrieve all of the members/scores in a sorted set # redis.zscan_each("zset").to_a # # => [["key70", "70"], ["key80", "80"]] # # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [Enumerator] an enumerator for all found scores and members def zscan_each(key, options={}, &block) return to_enum(:zscan_each, key, options) unless block_given? cursor = 0 loop do cursor, values = zscan(key, cursor, options) values.each(&block) break if cursor == "0" end end # Scan a set # # @example Retrieve the first batch of keys in a set # redis.sscan("set", 0) # # @param [String, Integer] cursor the cursor of the iteration # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [String, Array] the next cursor and all found members def sscan(key, cursor, options={}) _scan(:sscan, cursor, [key], options) end # Scan a set # # @example Retrieve all of the keys in a set # redis.sscan_each("set").to_a # # => ["key1", "key2", "key3"] # # @param [Hash] options # - `:match => String`: only return keys matching the pattern # - `:count => Integer`: return count keys at most per iteration # # @return [Enumerator] an enumerator for all keys in the set def sscan_each(key, options={}, &block) return to_enum(:sscan_each, key, options) unless block_given? cursor = 0 loop do cursor, keys = sscan(key, cursor, options) keys.each(&block) break if cursor == "0" end end # Add one or more members to a HyperLogLog structure. # # @param [String] key # @param [String, Array] member one member, or array of members # @return [Boolean] true if at least 1 HyperLogLog internal register was altered. false otherwise. def pfadd(key, member) synchronize do |client| client.call([:pfadd, key, member], &Boolify) end end # Get the approximate cardinality of members added to HyperLogLog structure. # # If called with multiple keys, returns the approximate cardinality of the # union of the HyperLogLogs contained in the keys. # # @param [String, Array] keys # @return [Fixnum] def pfcount(*keys) synchronize do |client| client.call([:pfcount] + keys) end end # Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of # the observed Sets of the source HyperLogLog structures. # # @param [String] dest_key destination key # @param [String, Array] source_key source key, or array of keys # @return [Boolean] def pfmerge(dest_key, *source_key) synchronize do |client| client.call([:pfmerge, dest_key, *source_key], &BoolifySet) end end # Interact with the sentinel command (masters, master, slaves, failover) # # @param [String] subcommand e.g. `masters`, `master`, `slaves` # @param [Array] args depends on subcommand # @return [Array, Hash, String] depends on subcommand def sentinel(subcommand, *args) subcommand = subcommand.to_s.downcase synchronize do |client| client.call([:sentinel, subcommand] + args) do |reply| case subcommand when "get-master-addr-by-name" reply else if reply.kind_of?(Array) if reply[0].kind_of?(Array) reply.map(&Hashify) else Hashify.call(reply) end else reply end end end end end def id @original_client.id end def inspect "#" end def dup self.class.new(@options) end def method_missing(command, *args) synchronize do |client| client.call([command] + args) end end private # Commands returning 1 for true and 0 for false may be executed in a pipeline # where the method call will return nil. Propagate the nil instead of falsely # returning false. Boolify = lambda { |value| value == 1 if value } BoolifySet = lambda { |value| if value && "OK" == value true else false end } Hashify = lambda { |array| hash = Hash.new array.each_slice(2) do |field, value| hash[field] = value end hash } Floatify = lambda { |str| if str if (inf = str.match(/^(-)?inf/i)) (inf[1] ? -1.0 : 1.0) / 0.0 else Float(str) end end } FloatifyPairs = lambda { |array| if array array.each_slice(2).map do |member, score| [member, Floatify.call(score)] end end } def _subscription(method, timeout, channels, block) return @client.call([method] + channels) if subscribed? begin original, @client = @client, SubscribedClient.new(@client) if timeout > 0 @client.send(method, timeout, *channels, &block) else @client.send(method, *channels, &block) end ensure @client = original end end end require "redis/version" require "redis/connection" require "redis/client" require "redis/pipeline" require "redis/subscribe" gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/000077500000000000000000000000001277744601700270705ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/client.rb000066400000000000000000000350121277744601700306740ustar00rootroot00000000000000require "redis/errors" require "socket" require "cgi" class Redis class Client DEFAULTS = { :url => lambda { ENV["REDIS_URL"] }, :scheme => "redis", :host => "127.0.0.1", :port => 6379, :path => nil, :timeout => 5.0, :password => nil, :db => 0, :driver => nil, :id => nil, :tcp_keepalive => 0, :reconnect_attempts => 1, :inherit_socket => false } def options Marshal.load(Marshal.dump(@options)) end def scheme @options[:scheme] end def host @options[:host] end def port @options[:port] end def path @options[:path] end def read_timeout @options[:read_timeout] end def connect_timeout @options[:connect_timeout] end def timeout @options[:read_timeout] end def password @options[:password] end def db @options[:db] end def db=(db) @options[:db] = db.to_i end def driver @options[:driver] end def inherit_socket? @options[:inherit_socket] end attr_accessor :logger attr_reader :connection attr_reader :command_map def initialize(options = {}) @options = _parse_options(options) @reconnect = true @logger = @options[:logger] @connection = nil @command_map = {} @pending_reads = 0 if options.include?(:sentinels) @connector = Connector::Sentinel.new(@options) else @connector = Connector.new(@options) end end def connect @pid = Process.pid # Don't try to reconnect when the connection is fresh with_reconnect(false) do establish_connection call [:auth, password] if password call [:select, db] if db != 0 call [:client, :setname, @options[:id]] if @options[:id] @connector.check(self) end self end def id @options[:id] || "redis://#{location}/#{db}" end def location path || "#{host}:#{port}" end def call(command) reply = process([command]) { read } raise reply if reply.is_a?(CommandError) if block_given? yield reply else reply end end def call_loop(command, timeout = 0) error = nil result = with_socket_timeout(timeout) do process([command]) do loop do reply = read if reply.is_a?(CommandError) error = reply break else yield reply end end end end # Raise error when previous block broke out of the loop. raise error if error # Result is set to the value that the provided block used to break. result end def call_pipeline(pipeline) with_reconnect pipeline.with_reconnect? do begin pipeline.finish(call_pipelined(pipeline.commands)).tap do self.db = pipeline.db if pipeline.db end rescue ConnectionError => e return nil if pipeline.shutdown? # Assume the pipeline was sent in one piece, but execution of # SHUTDOWN caused none of the replies for commands that were executed # prior to it from coming back around. raise e end end end def call_pipelined(commands) return [] if commands.empty? # The method #ensure_connected (called from #process) reconnects once on # I/O errors. To make an effort in making sure that commands are not # executed more than once, only allow reconnection before the first reply # has been read. When an error occurs after the first reply has been # read, retrying would re-execute the entire pipeline, thus re-issuing # already successfully executed commands. To circumvent this, don't retry # after the first reply has been read successfully. result = Array.new(commands.size) reconnect = @reconnect begin exception = nil process(commands) do result[0] = read @reconnect = false (commands.size - 1).times do |i| reply = read result[i + 1] = reply exception = reply if exception.nil? && reply.is_a?(CommandError) end end raise exception if exception ensure @reconnect = reconnect end result end def call_with_timeout(command, timeout, &blk) with_socket_timeout(timeout) do call(command, &blk) end rescue ConnectionError retry end def call_without_timeout(command, &blk) call_with_timeout(command, 0, &blk) end def process(commands) logging(commands) do ensure_connected do commands.each do |command| if command_map[command.first] command = command.dup command[0] = command_map[command.first] end write(command) end yield if block_given? end end end def connected? !! (connection && connection.connected?) end def disconnect connection.disconnect if connected? end def reconnect disconnect connect end def io yield rescue TimeoutError => e1 # Add a message to the exception without destroying the original stack e2 = TimeoutError.new("Connection timed out") e2.set_backtrace(e1.backtrace) raise e2 rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e raise ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last] end def read io do value = connection.read @pending_reads -= 1 value end end def write(command) io do @pending_reads += 1 connection.write(command) end end def with_socket_timeout(timeout) connect unless connected? begin connection.timeout = timeout yield ensure connection.timeout = self.timeout if connected? end end def without_socket_timeout(&blk) with_socket_timeout(0, &blk) end def with_reconnect(val=true) begin original, @reconnect = @reconnect, val yield ensure @reconnect = original end end def without_reconnect(&blk) with_reconnect(false, &blk) end protected def logging(commands) return yield unless @logger && @logger.debug? begin commands.each do |name, *args| logged_args = args.map do |a| case when a.respond_to?(:inspect) then a.inspect when a.respond_to?(:to_s) then a.to_s else # handle poorly-behaved descendants of BasicObject klass = a.instance_exec { (class << self; self end).superclass } "\#<#{klass}:#{a.__id__}>" end end @logger.debug("[Redis] command=#{name.to_s.upcase} args=#{logged_args.join(' ')}") end t1 = Time.now yield ensure @logger.debug("[Redis] call_time=%0.2f ms" % ((Time.now - t1) * 1000)) if t1 end end def establish_connection server = @connector.resolve.dup @options[:host] = server[:host] @options[:port] = Integer(server[:port]) if server.include?(:port) @connection = @options[:driver].connect(@options) @pending_reads = 0 rescue TimeoutError, Errno::ECONNREFUSED, Errno::EHOSTDOWN, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ETIMEDOUT raise CannotConnectError, "Error connecting to Redis on #{location} (#{$!.class})" end def ensure_connected disconnect if @pending_reads > 0 attempts = 0 begin attempts += 1 if connected? unless inherit_socket? || Process.pid == @pid raise InheritedError, "Tried to use a connection from a child process without reconnecting. " + "You need to reconnect to Redis after forking " + "or set :inherit_socket to true." end else connect end yield rescue BaseConnectionError disconnect if attempts <= @options[:reconnect_attempts] && @reconnect retry else raise end rescue Exception disconnect raise end end def _parse_options(options) return options if options[:_parsed] defaults = DEFAULTS.dup options = options.dup defaults.keys.each do |key| # Fill in defaults if needed if defaults[key].respond_to?(:call) defaults[key] = defaults[key].call end # Symbolize only keys that are needed options[key] = options[key.to_s] if options.has_key?(key.to_s) end url = options[:url] || defaults[:url] # Override defaults from URL if given if url require "uri" uri = URI(url) if uri.scheme == "unix" defaults[:path] = uri.path elsif uri.scheme == "redis" || uri.scheme == "rediss" defaults[:scheme] = uri.scheme defaults[:host] = uri.host if uri.host defaults[:port] = uri.port if uri.port defaults[:password] = CGI.unescape(uri.password) if uri.password defaults[:db] = uri.path[1..-1].to_i if uri.path defaults[:role] = :master else raise ArgumentError, "invalid uri scheme '#{uri.scheme}'" end defaults[:ssl] = true if uri.scheme == "rediss" end # Use default when option is not specified or nil defaults.keys.each do |key| options[key] = defaults[key] if options[key].nil? end if options[:path] # Unix socket options[:scheme] = "unix" options.delete(:host) options.delete(:port) else # TCP socket options[:host] = options[:host].to_s options[:port] = options[:port].to_i end if options.has_key?(:timeout) options[:connect_timeout] ||= options[:timeout] options[:read_timeout] ||= options[:timeout] options[:write_timeout] ||= options[:timeout] end options[:connect_timeout] = Float(options[:connect_timeout]) options[:read_timeout] = Float(options[:read_timeout]) options[:write_timeout] = Float(options[:write_timeout]) options[:db] = options[:db].to_i options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last case options[:tcp_keepalive] when Hash [:time, :intvl, :probes].each do |key| unless options[:tcp_keepalive][key].is_a?(Fixnum) raise "Expected the #{key.inspect} key in :tcp_keepalive to be a Fixnum" end end when Fixnum if options[:tcp_keepalive] >= 60 options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2} elsif options[:tcp_keepalive] >= 30 options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 10, :intvl => 5, :probes => 2} elsif options[:tcp_keepalive] >= 5 options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 2, :intvl => 2, :probes => 1} end end options[:_parsed] = true options end def _parse_driver(driver) driver = driver.to_s if driver.is_a?(Symbol) if driver.kind_of?(String) begin require "redis/connection/#{driver}" driver = Connection.const_get(driver.capitalize) rescue LoadError, NameError raise RuntimeError, "Cannot load driver #{driver.inspect}" end end driver end class Connector def initialize(options) @options = options.dup end def resolve @options end def check(client) end class Sentinel < Connector def initialize(options) super(options) @options[:password] = DEFAULTS.fetch(:password) @options[:db] = DEFAULTS.fetch(:db) @sentinels = @options.delete(:sentinels).dup @role = @options.fetch(:role, "master").to_s @master = @options[:host] end def check(client) # Check the instance is really of the role we are looking for. # We can't assume the command is supported since it was introduced # recently and this client should work with old stuff. begin role = client.call([:role])[0] rescue Redis::CommandError # Assume the test is passed if we can't get a reply from ROLE... role = @role end if role != @role client.disconnect raise ConnectionError, "Instance role mismatch. Expected #{@role}, got #{role}." end end def resolve result = case @role when "master" resolve_master when "slave" resolve_slave else raise ArgumentError, "Unknown instance role #{@role}" end result || (raise ConnectionError, "Unable to fetch #{@role} via Sentinel.") end def sentinel_detect @sentinels.each do |sentinel| client = Client.new(@options.merge({ :host => sentinel[:host], :port => sentinel[:port], :reconnect_attempts => 0, })) begin if result = yield(client) # This sentinel responded. Make sure we ask it first next time. @sentinels.delete(sentinel) @sentinels.unshift(sentinel) return result end rescue BaseConnectionError ensure client.disconnect end end raise CannotConnectError, "No sentinels available." end def resolve_master sentinel_detect do |client| if reply = client.call(["sentinel", "get-master-addr-by-name", @master]) {:host => reply[0], :port => reply[1]} end end end def resolve_slave sentinel_detect do |client| if reply = client.call(["sentinel", "slaves", @master]) slave = Hash[*reply.sample] {:host => slave.fetch("ip"), :port => slave.fetch("port")} end end end end end end end connection.rb000066400000000000000000000010111277744601700314660ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redisrequire "redis/connection/registry" # If a connection driver was required before this file, the array # Redis::Connection.drivers will contain one or more classes. The last driver # in this array will be used as default driver. If this array is empty, we load # the plain Ruby driver as our default. Another driver can be required at a # later point in time, causing it to be the last element of the #drivers array # and therefore be chosen by default. require "redis/connection/ruby" if Redis::Connection.drivers.empty?gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/connection/000077500000000000000000000000001277744601700312275ustar00rootroot00000000000000command_helper.rb000066400000000000000000000015531277744601700344560ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/connectionclass Redis module Connection module CommandHelper COMMAND_DELIMITER = "\r\n" def build_command(args) command = [nil] args.each do |i| if i.is_a? Array i.each do |j| j = j.to_s command << "$#{j.bytesize}" command << j end else i = i.to_s command << "$#{i.bytesize}" command << i end end command[0] = "*#{(command.length - 1) / 2}" # Trailing delimiter command << "" command.join(COMMAND_DELIMITER) end protected if defined?(Encoding::default_external) def encode(string) string.force_encoding(Encoding::default_external) end else def encode(string) string end end end end end hiredis.rb000066400000000000000000000032531277744601700331270ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/connectionrequire "redis/connection/registry" require "redis/errors" require "hiredis/connection" require "timeout" class Redis module Connection class Hiredis def self.connect(config) connection = ::Hiredis::Connection.new connect_timeout = (config.fetch(:connect_timeout, 0) * 1_000_000).to_i if config[:scheme] == "unix" connection.connect_unix(config[:path], connect_timeout) elsif config[:scheme] == "rediss" || config[:ssl] raise NotImplementedError, "SSL not supported by hiredis driver" else connection.connect(config[:host], config[:port], connect_timeout) end instance = new(connection) instance.timeout = config[:read_timeout] instance rescue Errno::ETIMEDOUT raise TimeoutError end def initialize(connection) @connection = connection end def connected? @connection && @connection.connected? end def timeout=(timeout) # Hiredis works with microsecond timeouts @connection.timeout = Integer(timeout * 1_000_000) end def disconnect @connection.disconnect @connection = nil end def write(command) @connection.write(command.flatten(1)) rescue Errno::EAGAIN raise TimeoutError end def read reply = @connection.read reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError) reply rescue Errno::EAGAIN raise TimeoutError rescue RuntimeError => err raise ProtocolError.new(err.message) end end end end Redis::Connection.drivers << Redis::Connection::Hiredis registry.rb000066400000000000000000000005441277744601700333500ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/connectionclass Redis module Connection # Store a list of loaded connection drivers in the Connection module. # Redis::Client uses the last required driver by default, and will be aware # of the loaded connection drivers if the user chooses to override the # default connection driver. def self.drivers @drivers ||= [] end end end ruby.rb000066400000000000000000000234351277744601700324650ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/connectionrequire "redis/connection/registry" require "redis/connection/command_helper" require "redis/errors" require "socket" require "timeout" begin require "openssl" rescue LoadError # Not all systems have OpenSSL support end class Redis module Connection module SocketMixin CRLF = "\r\n".freeze # Exceptions raised during non-blocking I/O ops that require retrying the op NBIO_EXCEPTIONS = [Errno::EWOULDBLOCK, Errno::EAGAIN] NBIO_EXCEPTIONS << IO::WaitReadable if RUBY_VERSION >= "1.9.3" def initialize(*args) super(*args) @timeout = @write_timeout = nil @buffer = "" end def timeout=(timeout) if timeout && timeout > 0 @timeout = timeout else @timeout = nil end end def write_timeout=(timeout) if timeout && timeout > 0 @write_timeout = timeout else @write_timeout = nil end end def read(nbytes) result = @buffer.slice!(0, nbytes) while result.bytesize < nbytes result << _read_from_socket(nbytes - result.bytesize) end result end def gets crlf = nil while (crlf = @buffer.index(CRLF)) == nil @buffer << _read_from_socket(1024) end @buffer.slice!(0, crlf + CRLF.bytesize) end def _read_from_socket(nbytes) begin read_nonblock(nbytes) rescue *NBIO_EXCEPTIONS if IO.select([self], nil, nil, @timeout) retry else raise Redis::TimeoutError end end rescue EOFError raise Errno::ECONNRESET end # UNIXSocket and TCPSocket don't support write timeouts def write(*args) Timeout.timeout(@write_timeout, TimeoutError) { super } end end if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby" require "timeout" class TCPSocket < ::TCPSocket include SocketMixin def self.connect(host, port, timeout) Timeout.timeout(timeout) do sock = new(host, port) sock end rescue Timeout::Error raise TimeoutError end end if defined?(::UNIXSocket) class UNIXSocket < ::UNIXSocket include SocketMixin def self.connect(path, timeout) Timeout.timeout(timeout) do sock = new(path) sock end rescue Timeout::Error raise TimeoutError end # JRuby raises Errno::EAGAIN on #read_nonblock even when IO.select # says it is readable (1.6.6, in both 1.8 and 1.9 mode). # Use the blocking #readpartial method instead. def _read_from_socket(nbytes) readpartial(nbytes) rescue EOFError raise Errno::ECONNRESET end end end else class TCPSocket < ::Socket include SocketMixin def self.connect_addrinfo(ai, port, timeout) sock = new(::Socket.const_get(ai[0]), Socket::SOCK_STREAM, 0) sockaddr = ::Socket.pack_sockaddr_in(port, ai[3]) begin sock.connect_nonblock(sockaddr) rescue Errno::EINPROGRESS if IO.select(nil, [sock], nil, timeout) == nil raise TimeoutError end begin sock.connect_nonblock(sockaddr) rescue Errno::EISCONN end end sock end def self.connect(host, port, timeout) # Don't pass AI_ADDRCONFIG as flag to getaddrinfo(3) # # From the man page for getaddrinfo(3): # # If hints.ai_flags includes the AI_ADDRCONFIG flag, then IPv4 # addresses are returned in the list pointed to by res only if the # local system has at least one IPv4 address configured, and IPv6 # addresses are returned only if the local system has at least one # IPv6 address configured. The loopback address is not considered # for this case as valid as a configured address. # # We do want the IPv6 loopback address to be returned if applicable, # even if it is the only configured IPv6 address on the machine. # Also see: https://github.com/redis/redis-rb/pull/394. addrinfo = ::Socket.getaddrinfo(host, nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM) # From the man page for getaddrinfo(3): # # Normally, the application should try using the addresses in the # order in which they are returned. The sorting function used # within getaddrinfo() is defined in RFC 3484 [...]. # addrinfo.each_with_index do |ai, i| begin return connect_addrinfo(ai, port, timeout) rescue SystemCallError # Raise if this was our last attempt. raise if addrinfo.length == i+1 end end end end class UNIXSocket < ::Socket include SocketMixin def self.connect(path, timeout) sock = new(::Socket::AF_UNIX, Socket::SOCK_STREAM, 0) sockaddr = ::Socket.pack_sockaddr_un(path) begin sock.connect_nonblock(sockaddr) rescue Errno::EINPROGRESS if IO.select(nil, [sock], nil, timeout) == nil raise TimeoutError end begin sock.connect_nonblock(sockaddr) rescue Errno::EISCONN end end sock end end end if defined?(OpenSSL) class SSLSocket < ::OpenSSL::SSL::SSLSocket include SocketMixin def self.connect(host, port, timeout, ssl_params) # Note: this is using Redis::Connection::TCPSocket tcp_sock = TCPSocket.connect(host, port, timeout) ctx = OpenSSL::SSL::SSLContext.new ctx.set_params(ssl_params) if ssl_params && !ssl_params.empty? ssl_sock = new(tcp_sock, ctx) ssl_sock.hostname = host ssl_sock.connect ssl_sock.post_connection_check(host) ssl_sock end end end class Ruby include Redis::Connection::CommandHelper MINUS = "-".freeze PLUS = "+".freeze COLON = ":".freeze DOLLAR = "$".freeze ASTERISK = "*".freeze def self.connect(config) if config[:scheme] == "unix" raise ArgumentError, "SSL incompatible with unix sockets" if config[:ssl] sock = UNIXSocket.connect(config[:path], config[:connect_timeout]) elsif config[:scheme] == "rediss" || config[:ssl] sock = SSLSocket.connect(config[:host], config[:port], config[:connect_timeout], config[:ssl_params]) else sock = TCPSocket.connect(config[:host], config[:port], config[:connect_timeout]) end instance = new(sock) instance.timeout = config[:timeout] instance.write_timeout = config[:write_timeout] instance.set_tcp_keepalive config[:tcp_keepalive] instance end if [:SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all?{|c| Socket.const_defined? c} def set_tcp_keepalive(keepalive) return unless keepalive.is_a?(Hash) @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true) @sock.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, keepalive[:time]) @sock.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, keepalive[:intvl]) @sock.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, keepalive[:probes]) end def get_tcp_keepalive { :time => @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE).int, :intvl => @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL).int, :probes => @sock.getsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT).int, } end else def set_tcp_keepalive(keepalive) end def get_tcp_keepalive { } end end def initialize(sock) @sock = sock end def connected? !! @sock end def disconnect @sock.close rescue ensure @sock = nil end def timeout=(timeout) if @sock.respond_to?(:timeout=) @sock.timeout = timeout end end def write_timeout=(timeout) @sock.write_timeout = timeout end def write(command) @sock.write(build_command(command)) end def read line = @sock.gets reply_type = line.slice!(0, 1) format_reply(reply_type, line) rescue Errno::EAGAIN raise TimeoutError end def format_reply(reply_type, line) case reply_type when MINUS then format_error_reply(line) when PLUS then format_status_reply(line) when COLON then format_integer_reply(line) when DOLLAR then format_bulk_reply(line) when ASTERISK then format_multi_bulk_reply(line) else raise ProtocolError.new(reply_type) end end def format_error_reply(line) CommandError.new(line.strip) end def format_status_reply(line) line.strip end def format_integer_reply(line) line.to_i end def format_bulk_reply(line) bulklen = line.to_i return if bulklen == -1 reply = encode(@sock.read(bulklen)) @sock.read(2) # Discard CRLF. reply end def format_multi_bulk_reply(line) n = line.to_i return if n == -1 Array.new(n) { read } end end end end Redis::Connection.drivers << Redis::Connection::Ruby synchrony.rb000066400000000000000000000057651277744601700335460ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/connectionrequire "redis/connection/command_helper" require "redis/connection/registry" require "redis/errors" require "em-synchrony" require "hiredis/reader" class Redis module Connection class RedisClient < EventMachine::Connection include EventMachine::Deferrable attr_accessor :timeout def post_init @req = nil @connected = false @reader = ::Hiredis::Reader.new end def connection_completed @connected = true succeed end def connected? @connected end def receive_data(data) @reader.feed(data) loop do begin reply = @reader.gets rescue RuntimeError => err @req.fail [:error, ProtocolError.new(err.message)] break end break if reply == false reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError) @req.succeed [:reply, reply] end end def read @req = EventMachine::DefaultDeferrable.new if @timeout > 0 @req.timeout(@timeout, :timeout) end EventMachine::Synchrony.sync @req end def send(data) callback { send_data data } end def unbind @connected = false if @req @req.fail [:error, Errno::ECONNRESET] @req = nil else fail end end end class Synchrony include Redis::Connection::CommandHelper def self.connect(config) if config[:scheme] == "unix" conn = EventMachine.connect_unix_domain(config[:path], RedisClient) elsif config[:scheme] == "rediss" || config[:ssl] raise NotImplementedError, "SSL not supported by synchrony driver" else conn = EventMachine.connect(config[:host], config[:port], RedisClient) do |c| c.pending_connect_timeout = [config[:connect_timeout], 0.1].max end end fiber = Fiber.current conn.callback { fiber.resume } conn.errback { fiber.resume :refused } raise Errno::ECONNREFUSED if Fiber.yield == :refused instance = new(conn) instance.timeout = config[:read_timeout] instance end def initialize(connection) @connection = connection end def connected? @connection && @connection.connected? end def timeout=(timeout) @connection.timeout = timeout end def disconnect @connection.close_connection @connection = nil end def write(command) @connection.send(build_command(command)) end def read type, payload = @connection.read if type == :reply payload elsif type == :error raise payload elsif type == :timeout raise TimeoutError else raise "Unknown type #{type.inspect}" end end end end end Redis::Connection.drivers << Redis::Connection::Synchrony distributed.rb000066400000000000000000000541231277744601700316650ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redisrequire "redis/hash_ring" class Redis class Distributed class CannotDistribute < RuntimeError def initialize(command) @command = command end def message "#{@command.to_s.upcase} cannot be used in Redis::Distributed because the keys involved need to be on the same server or because we cannot guarantee that the operation will be atomic." end end attr_reader :ring def initialize(node_configs, options = {}) @tag = options[:tag] || /^\{(.+?)\}/ @ring = options[:ring] || HashRing.new @node_configs = node_configs.dup @default_options = options.dup node_configs.each { |node_config| add_node(node_config) } @subscribed_node = nil end def node_for(key) @ring.get_node(key_tag(key.to_s) || key.to_s) end def nodes @ring.nodes end def add_node(options) options = { :url => options } if options.is_a?(String) options = @default_options.merge(options) @ring.add_node Redis.new( options ) end # Change the selected database for the current connection. def select(db) on_each_node :select, db end # Ping the server. def ping on_each_node :ping end # Echo the given string. def echo(value) on_each_node :echo, value end # Close the connection. def quit on_each_node :quit end # Asynchronously save the dataset to disk. def bgsave on_each_node :bgsave end # Return the number of keys in the selected database. def dbsize on_each_node :dbsize end # Remove all keys from all databases. def flushall on_each_node :flushall end # Remove all keys from the current database. def flushdb on_each_node :flushdb end # Get information and statistics about the server. def info(cmd = nil) on_each_node :info, cmd end # Get the UNIX time stamp of the last successful save to disk. def lastsave on_each_node :lastsave end # Listen for all requests received by the server in real time. def monitor raise NotImplementedError end # Synchronously save the dataset to disk. def save on_each_node :save end # Get server time: an UNIX timestamp and the elapsed microseconds in the current second. def time on_each_node :time end # Remove the expiration from a key. def persist(key) node_for(key).persist(key) end # Set a key's time to live in seconds. def expire(key, seconds) node_for(key).expire(key, seconds) end # Set the expiration for a key as a UNIX timestamp. def expireat(key, unix_time) node_for(key).expireat(key, unix_time) end # Get the time to live (in seconds) for a key. def ttl(key) node_for(key).ttl(key) end # Set a key's time to live in milliseconds. def pexpire(key, milliseconds) node_for(key).pexpire(key, milliseconds) end # Set the expiration for a key as number of milliseconds from UNIX Epoch. def pexpireat(key, ms_unix_time) node_for(key).pexpireat(key, ms_unix_time) end # Get the time to live (in milliseconds) for a key. def pttl(key) node_for(key).pttl(key) end # Return a serialized version of the value stored at a key. def dump(key) node_for(key).dump(key) end # Create a key using the serialized value, previously obtained using DUMP. def restore(key, ttl, serialized_value) node_for(key).restore(key, ttl, serialized_value) end # Transfer a key from the connected instance to another instance. def migrate(key, options) raise CannotDistribute, :migrate end # Delete a key. def del(*args) keys_per_node = args.group_by { |key| node_for(key) } keys_per_node.inject(0) do |sum, (node, keys)| sum + node.del(*keys) end end # Determine if a key exists. def exists(key) node_for(key).exists(key) end # Find all keys matching the given pattern. def keys(glob = "*") on_each_node(:keys, glob).flatten end # Move a key to another database. def move(key, db) node_for(key).move(key, db) end # Return a random key from the keyspace. def randomkey raise CannotDistribute, :randomkey end # Rename a key. def rename(old_name, new_name) ensure_same_node(:rename, [old_name, new_name]) do |node| node.rename(old_name, new_name) end end # Rename a key, only if the new key does not exist. def renamenx(old_name, new_name) ensure_same_node(:renamenx, [old_name, new_name]) do |node| node.renamenx(old_name, new_name) end end # Sort the elements in a list, set or sorted set. def sort(key, options = {}) keys = [key, options[:by], options[:store], *Array(options[:get])].compact ensure_same_node(:sort, keys) do |node| node.sort(key, options) end end # Determine the type stored at key. def type(key) node_for(key).type(key) end # Decrement the integer value of a key by one. def decr(key) node_for(key).decr(key) end # Decrement the integer value of a key by the given number. def decrby(key, decrement) node_for(key).decrby(key, decrement) end # Increment the integer value of a key by one. def incr(key) node_for(key).incr(key) end # Increment the integer value of a key by the given integer number. def incrby(key, increment) node_for(key).incrby(key, increment) end # Increment the numeric value of a key by the given float number. def incrbyfloat(key, increment) node_for(key).incrbyfloat(key, increment) end # Set the string value of a key. def set(key, value, options = {}) node_for(key).set(key, value, options) end # Set the time to live in seconds of a key. def setex(key, ttl, value) node_for(key).setex(key, ttl, value) end # Set the time to live in milliseconds of a key. def psetex(key, ttl, value) node_for(key).psetex(key, ttl, value) end # Set the value of a key, only if the key does not exist. def setnx(key, value) node_for(key).setnx(key, value) end # Set multiple keys to multiple values. def mset(*args) raise CannotDistribute, :mset end def mapped_mset(hash) raise CannotDistribute, :mapped_mset end # Set multiple keys to multiple values, only if none of the keys exist. def msetnx(*args) raise CannotDistribute, :msetnx end def mapped_msetnx(hash) raise CannotDistribute, :mapped_msetnx end # Get the value of a key. def get(key) node_for(key).get(key) end # Get the values of all the given keys. def mget(*keys) raise CannotDistribute, :mget end def mapped_mget(*keys) raise CannotDistribute, :mapped_mget end # Overwrite part of a string at key starting at the specified offset. def setrange(key, offset, value) node_for(key).setrange(key, offset, value) end # Get a substring of the string stored at a key. def getrange(key, start, stop) node_for(key).getrange(key, start, stop) end # Sets or clears the bit at offset in the string value stored at key. def setbit(key, offset, value) node_for(key).setbit(key, offset, value) end # Returns the bit value at offset in the string value stored at key. def getbit(key, offset) node_for(key).getbit(key, offset) end # Append a value to a key. def append(key, value) node_for(key).append(key, value) end # Count the number of set bits in a range of the string value stored at key. def bitcount(key, start = 0, stop = -1) node_for(key).bitcount(key, start, stop) end # Perform a bitwise operation between strings and store the resulting string in a key. def bitop(operation, destkey, *keys) ensure_same_node(:bitop, [destkey] + keys) do |node| node.bitop(operation, destkey, *keys) end end # Return the position of the first bit set to 1 or 0 in a string. def bitpos(key, bit, start=nil, stop=nil) node_for(key).bitpos(key, bit, start, stop) end # Set the string value of a key and return its old value. def getset(key, value) node_for(key).getset(key, value) end # Get the length of the value stored in a key. def strlen(key) node_for(key).strlen(key) end def [](key) get(key) end def []=(key,value) set(key, value) end # Get the length of a list. def llen(key) node_for(key).llen(key) end # Prepend one or more values to a list. def lpush(key, value) node_for(key).lpush(key, value) end # Prepend a value to a list, only if the list exists. def lpushx(key, value) node_for(key).lpushx(key, value) end # Append one or more values to a list. def rpush(key, value) node_for(key).rpush(key, value) end # Append a value to a list, only if the list exists. def rpushx(key, value) node_for(key).rpushx(key, value) end # Remove and get the first element in a list. def lpop(key) node_for(key).lpop(key) end # Remove and get the last element in a list. def rpop(key) node_for(key).rpop(key) end # Remove the last element in a list, append it to another list and return # it. def rpoplpush(source, destination) ensure_same_node(:rpoplpush, [source, destination]) do |node| node.rpoplpush(source, destination) end end def _bpop(cmd, args) options = {} case args.last when Hash options = args.pop when Integer # Issue deprecation notice in obnoxious mode... options[:timeout] = args.pop end if args.size > 1 # Issue deprecation notice in obnoxious mode... end keys = args.flatten ensure_same_node(cmd, keys) do |node| node.__send__(cmd, keys, options) end end # Remove and get the first element in a list, or block until one is # available. def blpop(*args) _bpop(:blpop, args) end # Remove and get the last element in a list, or block until one is # available. def brpop(*args) _bpop(:brpop, args) end # Pop a value from a list, push it to another list and return it; or block # until one is available. def brpoplpush(source, destination, options = {}) case options when Integer # Issue deprecation notice in obnoxious mode... options = { :timeout => options } end ensure_same_node(:brpoplpush, [source, destination]) do |node| node.brpoplpush(source, destination, options) end end # Get an element from a list by its index. def lindex(key, index) node_for(key).lindex(key, index) end # Insert an element before or after another element in a list. def linsert(key, where, pivot, value) node_for(key).linsert(key, where, pivot, value) end # Get a range of elements from a list. def lrange(key, start, stop) node_for(key).lrange(key, start, stop) end # Remove elements from a list. def lrem(key, count, value) node_for(key).lrem(key, count, value) end # Set the value of an element in a list by its index. def lset(key, index, value) node_for(key).lset(key, index, value) end # Trim a list to the specified range. def ltrim(key, start, stop) node_for(key).ltrim(key, start, stop) end # Get the number of members in a set. def scard(key) node_for(key).scard(key) end # Add one or more members to a set. def sadd(key, member) node_for(key).sadd(key, member) end # Remove one or more members from a set. def srem(key, member) node_for(key).srem(key, member) end # Remove and return a random member from a set. def spop(key) node_for(key).spop(key) end # Get a random member from a set. def srandmember(key, count = nil) node_for(key).srandmember(key, count) end # Move a member from one set to another. def smove(source, destination, member) ensure_same_node(:smove, [source, destination]) do |node| node.smove(source, destination, member) end end # Determine if a given value is a member of a set. def sismember(key, member) node_for(key).sismember(key, member) end # Get all the members in a set. def smembers(key) node_for(key).smembers(key) end # Subtract multiple sets. def sdiff(*keys) ensure_same_node(:sdiff, keys) do |node| node.sdiff(*keys) end end # Subtract multiple sets and store the resulting set in a key. def sdiffstore(destination, *keys) ensure_same_node(:sdiffstore, [destination] + keys) do |node| node.sdiffstore(destination, *keys) end end # Intersect multiple sets. def sinter(*keys) ensure_same_node(:sinter, keys) do |node| node.sinter(*keys) end end # Intersect multiple sets and store the resulting set in a key. def sinterstore(destination, *keys) ensure_same_node(:sinterstore, [destination] + keys) do |node| node.sinterstore(destination, *keys) end end # Add multiple sets. def sunion(*keys) ensure_same_node(:sunion, keys) do |node| node.sunion(*keys) end end # Add multiple sets and store the resulting set in a key. def sunionstore(destination, *keys) ensure_same_node(:sunionstore, [destination] + keys) do |node| node.sunionstore(destination, *keys) end end # Get the number of members in a sorted set. def zcard(key) node_for(key).zcard(key) end # Add one or more members to a sorted set, or update the score for members # that already exist. def zadd(key, *args) node_for(key).zadd(key, *args) end # Increment the score of a member in a sorted set. def zincrby(key, increment, member) node_for(key).zincrby(key, increment, member) end # Remove one or more members from a sorted set. def zrem(key, member) node_for(key).zrem(key, member) end # Get the score associated with the given member in a sorted set. def zscore(key, member) node_for(key).zscore(key, member) end # Return a range of members in a sorted set, by index. def zrange(key, start, stop, options = {}) node_for(key).zrange(key, start, stop, options) end # Return a range of members in a sorted set, by index, with scores ordered # from high to low. def zrevrange(key, start, stop, options = {}) node_for(key).zrevrange(key, start, stop, options) end # Determine the index of a member in a sorted set. def zrank(key, member) node_for(key).zrank(key, member) end # Determine the index of a member in a sorted set, with scores ordered from # high to low. def zrevrank(key, member) node_for(key).zrevrank(key, member) end # Remove all members in a sorted set within the given indexes. def zremrangebyrank(key, start, stop) node_for(key).zremrangebyrank(key, start, stop) end # Return a range of members in a sorted set, by score. def zrangebyscore(key, min, max, options = {}) node_for(key).zrangebyscore(key, min, max, options) end # Return a range of members in a sorted set, by score, with scores ordered # from high to low. def zrevrangebyscore(key, max, min, options = {}) node_for(key).zrevrangebyscore(key, max, min, options) end # Remove all members in a sorted set within the given scores. def zremrangebyscore(key, min, max) node_for(key).zremrangebyscore(key, min, max) end # Get the number of members in a particular score range. def zcount(key, min, max) node_for(key).zcount(key, min, max) end # Intersect multiple sorted sets and store the resulting sorted set in a new # key. def zinterstore(destination, keys, options = {}) ensure_same_node(:zinterstore, [destination] + keys) do |node| node.zinterstore(destination, keys, options) end end # Add multiple sorted sets and store the resulting sorted set in a new key. def zunionstore(destination, keys, options = {}) ensure_same_node(:zunionstore, [destination] + keys) do |node| node.zunionstore(destination, keys, options) end end # Get the number of fields in a hash. def hlen(key) node_for(key).hlen(key) end # Set the string value of a hash field. def hset(key, field, value) node_for(key).hset(key, field, value) end # Set the value of a hash field, only if the field does not exist. def hsetnx(key, field, value) node_for(key).hsetnx(key, field, value) end # Set multiple hash fields to multiple values. def hmset(key, *attrs) node_for(key).hmset(key, *attrs) end def mapped_hmset(key, hash) node_for(key).hmset(key, *hash.to_a.flatten) end # Get the value of a hash field. def hget(key, field) node_for(key).hget(key, field) end # Get the values of all the given hash fields. def hmget(key, *fields) node_for(key).hmget(key, *fields) end def mapped_hmget(key, *fields) Hash[*fields.zip(hmget(key, *fields)).flatten] end # Delete one or more hash fields. def hdel(key, field) node_for(key).hdel(key, field) end # Determine if a hash field exists. def hexists(key, field) node_for(key).hexists(key, field) end # Increment the integer value of a hash field by the given integer number. def hincrby(key, field, increment) node_for(key).hincrby(key, field, increment) end # Increment the numeric value of a hash field by the given float number. def hincrbyfloat(key, field, increment) node_for(key).hincrbyfloat(key, field, increment) end # Get all the fields in a hash. def hkeys(key) node_for(key).hkeys(key) end # Get all the values in a hash. def hvals(key) node_for(key).hvals(key) end # Get all the fields and values in a hash. def hgetall(key) node_for(key).hgetall(key) end # Post a message to a channel. def publish(channel, message) node_for(channel).publish(channel, message) end def subscribed? !! @subscribed_node end # Listen for messages published to the given channels. def subscribe(channel, *channels, &block) if channels.empty? @subscribed_node = node_for(channel) @subscribed_node.subscribe(channel, &block) else ensure_same_node(:subscribe, [channel] + channels) do |node| @subscribed_node = node node.subscribe(channel, *channels, &block) end end end # Stop listening for messages posted to the given channels. def unsubscribe(*channels) raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed? @subscribed_node.unsubscribe(*channels) end # Listen for messages published to channels matching the given patterns. def psubscribe(*channels, &block) raise NotImplementedError end # Stop listening for messages posted to channels matching the given # patterns. def punsubscribe(*channels) raise NotImplementedError end # Watch the given keys to determine execution of the MULTI/EXEC block. def watch(*keys) raise CannotDistribute, :watch end # Forget about all watched keys. def unwatch raise CannotDistribute, :unwatch end def pipelined raise CannotDistribute, :pipelined end # Mark the start of a transaction block. def multi raise CannotDistribute, :multi end # Execute all commands issued after MULTI. def exec raise CannotDistribute, :exec end # Discard all commands issued after MULTI. def discard raise CannotDistribute, :discard end # Control remote script registry. def script(subcommand, *args) on_each_node(:script, subcommand, *args) end # Add one or more members to a HyperLogLog structure. def pfadd(key, member) node_for(key).pfadd(key, member) end # Get the approximate cardinality of members added to HyperLogLog structure. def pfcount(*keys) ensure_same_node(:pfcount, keys.flatten(1)) do |node| node.pfcount(keys) end end # Merge multiple HyperLogLog values into an unique value that will approximate the cardinality of the union of # the observed Sets of the source HyperLogLog structures. def pfmerge(dest_key, *source_key) ensure_same_node(:pfmerge, [dest_key, *source_key]) do |node| node.pfmerge(dest_key, *source_key) end end def _eval(cmd, args) script = args.shift options = args.pop if args.last.is_a?(Hash) options ||= {} keys = args.shift || options[:keys] || [] argv = args.shift || options[:argv] || [] ensure_same_node(cmd, keys) do |node| node.send(cmd, script, keys, argv) end end # Evaluate Lua script. def eval(*args) _eval(:eval, args) end # Evaluate Lua script by its SHA. def evalsha(*args) _eval(:evalsha, args) end def inspect "#" end def dup self.class.new(@node_configs, @default_options) end protected def on_each_node(command, *args) nodes.map do |node| node.send(command, *args) end end def node_index_for(key) nodes.index(node_for(key)) end def key_tag(key) key.to_s[@tag, 1] if @tag end def ensure_same_node(command, keys) all = true tags = keys.map do |key| tag = key_tag(key) all = false unless tag tag end if (all && tags.uniq.size != 1) || (!all && keys.uniq.size != 1) # Not 1 unique tag or not 1 unique key raise CannotDistribute, command end yield(node_for(keys.first)) end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/errors.rb000066400000000000000000000021031277744601700307250ustar00rootroot00000000000000class Redis # Base error for all redis-rb errors. class BaseError < RuntimeError end # Raised by the connection when a protocol error occurs. class ProtocolError < BaseError def initialize(reply_type) super(<<-EOS.gsub(/(?:^|\n)\s*/, " ")) Got '#{reply_type}' as initial reply byte. If you're in a forking environment, such as Unicorn, you need to connect to Redis after forking. EOS end end # Raised by the client when command execution returns an error reply. class CommandError < BaseError end # Base error for connection related errors. class BaseConnectionError < BaseError end # Raised when connection to a Redis server cannot be made. class CannotConnectError < BaseConnectionError end # Raised when connection to a Redis server is lost. class ConnectionError < BaseConnectionError end # Raised when performing I/O times out. class TimeoutError < BaseConnectionError end # Raised when the connection was inherited by a child process. class InheritedError < BaseConnectionError end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/hash_ring.rb000066400000000000000000000067611277744601700313710ustar00rootroot00000000000000require 'zlib' class Redis class HashRing POINTS_PER_SERVER = 160 # this is the default in libmemcached attr_reader :ring, :sorted_keys, :replicas, :nodes # nodes is a list of objects that have a proper to_s representation. # replicas indicates how many virtual points should be used pr. node, # replicas are required to improve the distribution. def initialize(nodes=[], replicas=POINTS_PER_SERVER) @replicas = replicas @ring = {} @nodes = [] @sorted_keys = [] nodes.each do |node| add_node(node) end end # Adds a `node` to the hash ring (including a number of replicas). def add_node(node) @nodes << node @replicas.times do |i| key = Zlib.crc32("#{node.id}:#{i}") raise "Node ID collision" if @ring.has_key?(key) @ring[key] = node @sorted_keys << key end @sorted_keys.sort! end def remove_node(node) @nodes.reject!{|n| n.id == node.id} @replicas.times do |i| key = Zlib.crc32("#{node.id}:#{i}") @ring.delete(key) @sorted_keys.reject! {|k| k == key} end end # get the node in the hash ring for this key def get_node(key) get_node_pos(key)[0] end def get_node_pos(key) return [nil,nil] if @ring.size == 0 crc = Zlib.crc32(key) idx = HashRing.binary_search(@sorted_keys, crc) return [@ring[@sorted_keys[idx]], idx] end def iter_nodes(key) return [nil,nil] if @ring.size == 0 _, pos = get_node_pos(key) @ring.size.times do |n| yield @ring[@sorted_keys[(pos+n) % @ring.size]] end end class << self # gem install RubyInline to use this code # Native extension to perform the binary search within the hashring. # There's a pure ruby version below so this is purely optional # for performance. In testing 20k gets and sets, the native # binary search shaved about 12% off the runtime (9sec -> 8sec). begin require 'inline' inline do |builder| builder.c <<-EOM int binary_search(VALUE ary, unsigned int r) { int upper = RARRAY_LEN(ary) - 1; int lower = 0; int idx = 0; while (lower <= upper) { idx = (lower + upper) / 2; VALUE continuumValue = RARRAY_PTR(ary)[idx]; unsigned int l = NUM2UINT(continuumValue); if (l == r) { return idx; } else if (l > r) { upper = idx - 1; } else { lower = idx + 1; } } if (upper < 0) { upper = RARRAY_LEN(ary) - 1; } return upper; } EOM end rescue Exception # Find the closest index in HashRing with value <= the given value def binary_search(ary, value, &block) upper = ary.size - 1 lower = 0 idx = 0 while(lower <= upper) do idx = (lower + upper) / 2 comp = ary[idx] <=> value if comp == 0 return idx elsif comp > 0 upper = idx - 1 else lower = idx + 1 end end if upper < 0 upper = ary.size - 1 end return upper end end end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/pipeline.rb000066400000000000000000000060111277744601700312200ustar00rootroot00000000000000class Redis unless defined?(::BasicObject) class BasicObject instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ } end end class Pipeline attr_accessor :db attr :futures def initialize @with_reconnect = true @shutdown = false @futures = [] end def with_reconnect? @with_reconnect end def without_reconnect? !@with_reconnect end def shutdown? @shutdown end def call(command, &block) # A pipeline that contains a shutdown should not raise ECONNRESET when # the connection is gone. @shutdown = true if command.first == :shutdown future = Future.new(command, block) @futures << future future end def call_pipeline(pipeline) @shutdown = true if pipeline.shutdown? @futures.concat(pipeline.futures) @db = pipeline.db nil end def commands @futures.map { |f| f._command } end def with_reconnect(val=true) @with_reconnect = false unless val yield end def without_reconnect(&blk) with_reconnect(false, &blk) end def finish(replies, &blk) if blk futures.each_with_index.map do |future, i| future._set(blk.call(replies[i])) end else futures.each_with_index.map do |future, i| future._set(replies[i]) end end end class Multi < self def finish(replies) exec = replies.last return if exec.nil? # The transaction failed because of WATCH. # EXEC command failed. raise exec if exec.is_a?(CommandError) if exec.size < futures.size # Some command wasn't recognized by Redis. raise replies.detect { |r| r.is_a?(CommandError) } end super(exec) do |reply| # Because an EXEC returns nested replies, hiredis won't be able to # convert an error reply to a CommandError instance itself. This is # specific to MULTI/EXEC, so we solve this here. reply.is_a?(::RuntimeError) ? CommandError.new(reply.message) : reply end end def commands [[:multi]] + super + [[:exec]] end end end class FutureNotReady < RuntimeError def initialize super("Value will be available once the pipeline executes.") end end class Future < BasicObject FutureNotReady = ::Redis::FutureNotReady.new def initialize(command, transformation) @command = command @transformation = transformation @object = FutureNotReady end def inspect "" end def _set(object) @object = @transformation ? @transformation.call(object) : object value end def _command @command end def value ::Kernel.raise(@object) if @object.kind_of?(::RuntimeError) @object end def is_a?(other) self.class.ancestors.include?(other) end def class Future end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/subscribe.rb000066400000000000000000000037561277744601700314110ustar00rootroot00000000000000class Redis class SubscribedClient def initialize(client) @client = client end def call(command) @client.process([command]) end def subscribe(*channels, &block) subscription("subscribe", "unsubscribe", channels, block) end def subscribe_with_timeout(timeout, *channels, &block) subscription("subscribe", "unsubscribe", channels, block, timeout) end def psubscribe(*channels, &block) subscription("psubscribe", "punsubscribe", channels, block) end def psubscribe_with_timeout(timeout, *channels, &block) subscription("psubscribe", "punsubscribe", channels, block, timeout) end def unsubscribe(*channels) call([:unsubscribe, *channels]) end def punsubscribe(*channels) call([:punsubscribe, *channels]) end protected def subscription(start, stop, channels, block, timeout = 0) sub = Subscription.new(&block) unsubscribed = false begin @client.call_loop([start, *channels], timeout) do |line| type, *rest = line sub.callbacks[type].call(*rest) unsubscribed = type == stop && rest.last == 0 break if unsubscribed end ensure # No need to unsubscribe here. The real client closes the connection # whenever an exception is raised (see #ensure_connected). end end end class Subscription attr :callbacks def initialize @callbacks = Hash.new do |hash, key| hash[key] = lambda { |*_| } end yield(self) end def subscribe(&block) @callbacks["subscribe"] = block end def unsubscribe(&block) @callbacks["unsubscribe"] = block end def message(&block) @callbacks["message"] = block end def psubscribe(&block) @callbacks["psubscribe"] = block end def punsubscribe(&block) @callbacks["punsubscribe"] = block end def pmessage(&block) @callbacks["pmessage"] = block end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/lib/vendor/redis/lib/redis/version.rb000066400000000000000000000000441277744601700311000ustar00rootroot00000000000000class Redis VERSION = "3.3.0" end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/000077500000000000000000000000001277744601700227755ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/fixtures/000077500000000000000000000000001277744601700246465ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/fixtures/gitlab_config_redis.yml000066400000000000000000000003231277744601700313440ustar00rootroot00000000000000redis: bin: /usr/bin/redis-cli host: 127.0.1.1 port: 6378 pass: secure database: 1 socket: /var/run/redis/redis.sock namespace: my:gitlab sentinels: - host: 127.0.0.1 port: 26380 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_access_spec.rb000066400000000000000000000027031277744601700271210ustar00rootroot00000000000000require 'spec_helper' require 'gitlab_access' describe GitlabAccess do let(:repository_path) { "/home/git/repositories" } let(:repo_name) { 'dzaporozhets/gitlab-ci' } let(:repo_path) { File.join(repository_path, repo_name) + ".git" } let(:api) do double(GitlabNet).tap do |api| api.stub(check_access: GitAccessStatus.new(true, 'ok', '/home/git/repositories')) end end subject do GitlabAccess.new(repo_path, 'key-123', 'wow', 'ssh').tap do |access| access.stub(exec_cmd: :exec_called) access.stub(api: api) end end before do GitlabConfig.any_instance.stub(repos_path: repository_path) end describe :initialize do it { subject.repo_name.should == repo_name } it { subject.repo_path.should == repo_path } it { subject.changes.should == ['wow'] } it { subject.protocol.should == 'ssh' } end describe "#exec" do context "access is granted" do it "returns true" do expect(subject.exec).to be_true end end context "access is denied" do before do api.stub(check_access: GitAccessStatus.new(false, 'denied', nil)) end it "returns false" do expect(subject.exec).to be_false end end context "API connection fails" do before do api.stub(:check_access).and_raise(GitlabNet::ApiUnreachableError) end it "returns false" do expect(subject.exec).to be_false end end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_config_spec.rb000066400000000000000000000024441277744601700271270ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_config' describe GitlabConfig do let(:config) { GitlabConfig.new } describe :redis do before do config_file = File.read('spec/fixtures/gitlab_config_redis.yml') config.instance_variable_set(:@config, YAML.load(config_file)) end it { config.redis['bin'].should eq('/usr/bin/redis-cli') } it { config.redis['host'].should eq('127.0.1.1') } it { config.redis['port'].should eq(6378) } it { config.redis['database'].should eq(1) } it { config.redis['namespace'].should eq('my:gitlab') } it { config.redis['socket'].should eq('/var/run/redis/redis.sock') } it { config.redis['pass'].should eq('secure') } it { config.redis['sentinels'].should eq([{ 'host' => '127.0.0.1', 'port' => 26380 }]) } end describe :gitlab_url do let(:url) { 'http://test.com' } subject { config.gitlab_url } before { config.send(:config)['gitlab_url'] = url } it { should_not be_empty } it { should eq(url) } context 'remove trailing slashes' do before { config.send(:config)['gitlab_url'] = url + '//' } it { should eq(url) } end end describe :audit_usernames do subject { config.audit_usernames } it("returns false by default") { should eq(false) } end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_custom_hook_spec.rb000066400000000000000000000017371277744601700302200ustar00rootroot00000000000000# coding: utf-8 require 'spec_helper' require 'pry' require 'gitlab_custom_hook' describe GitlabCustomHook do let(:gitlab_custom_hook) { GitlabCustomHook.new('key_1') } let(:hook_path) { File.join(ROOT_PATH, 'spec/support/gl_id_test_hook') } context 'pre_receive hook' do it 'passes GL_ID variable to hook' do allow(gitlab_custom_hook).to receive(:hook_file).and_return(hook_path) expect(gitlab_custom_hook.pre_receive('changes', 'repo_path')).to be_true end end context 'post_receive hook' do it 'passes GL_ID variable to hook' do allow(gitlab_custom_hook).to receive(:hook_file).and_return(hook_path) expect(gitlab_custom_hook.post_receive('changes', 'repo_path')).to be_true end end context 'update hook' do it 'passes GL_ID variable to hook' do allow(gitlab_custom_hook).to receive(:hook_file).and_return(hook_path) expect(gitlab_custom_hook.update('master', '', '', 'repo_path')).to be_true end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_keys_spec.rb000066400000000000000000000224301277744601700266320ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_keys' require 'stringio' describe GitlabKeys do before do $logger = double('logger').as_null_object end describe '.command' do it 'returns the "command" part of the key line' do command = "#{ROOT_PATH}/bin/gitlab-shell key-123" expect(described_class.command('key-123')).to eq(command) end it 'raises KeyError on invalid input' do expect { described_class.command("\nssh-rsa AAA") }.to raise_error(described_class::KeyError) end end describe '.key_line' do let(:line) { %(command="#{ROOT_PATH}/bin/gitlab-shell key-741",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa AAAAB3NzaDAxx2E) } it 'returns the key line' do expect(described_class.key_line('key-741', 'ssh-rsa AAAAB3NzaDAxx2E')).to eq(line) end it 'silently removes a trailing newline' do expect(described_class.key_line('key-741', "ssh-rsa AAAAB3NzaDAxx2E\n")).to eq(line) end it 'raises KeyError on invalid input' do expect { described_class.key_line('key-741', "ssh-rsa AAA\nssh-rsa AAA") }.to raise_error(described_class::KeyError) end end describe :initialize do let(:gitlab_keys) { build_gitlab_keys('add-key', 'key-741', 'ssh-rsa AAAAB3NzaDAxx2E') } it { gitlab_keys.key.should == 'ssh-rsa AAAAB3NzaDAxx2E' } it { gitlab_keys.instance_variable_get(:@command).should == 'add-key' } it { gitlab_keys.instance_variable_get(:@key_id).should == 'key-741' } end describe :add_key do let(:gitlab_keys) { build_gitlab_keys('add-key', 'key-741', 'ssh-rsa AAAAB3NzaDAxx2E') } it "adds a line at the end of the file" do create_authorized_keys_fixture gitlab_keys.send :add_key auth_line = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-741\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa AAAAB3NzaDAxx2E" File.read(tmp_authorized_keys_path).should == "existing content\n#{auth_line}\n" end context "without file writing" do before { allow(gitlab_keys).to receive(:open) } before { create_authorized_keys_fixture } it "should log an add-key event" do $logger.should_receive(:info).with('Adding key key-741 => "ssh-rsa AAAAB3NzaDAxx2E"') gitlab_keys.send :add_key end it "should return true" do gitlab_keys.send(:add_key).should be_true end end end describe :list_keys do let(:gitlab_keys) do build_gitlab_keys('add-key', 'key-741', 'ssh-rsa AAAAB3NzaDAxx2E') end it 'adds a key and lists it' do create_authorized_keys_fixture gitlab_keys.send :add_key auth_line1 = 'key-741 AAAAB3NzaDAxx2E' gitlab_keys.send(:list_keys).should == "#{auth_line1}\n" end end describe :batch_add_keys do let(:gitlab_keys) { build_gitlab_keys('batch-add-keys') } let(:fake_stdin) { StringIO.new("key-12\tssh-dsa ASDFASGADG\nkey-123\tssh-rsa GFDGDFSGSDFG\n", 'r') } before do create_authorized_keys_fixture gitlab_keys.stub(stdin: fake_stdin) end it "adds lines at the end of the file" do gitlab_keys.send :batch_add_keys auth_line1 = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-12\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-dsa ASDFASGADG" auth_line2 = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-123\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa GFDGDFSGSDFG" File.read(tmp_authorized_keys_path).should == "existing content\n#{auth_line1}\n#{auth_line2}\n" end context "with invalid input" do let(:fake_stdin) { StringIO.new("key-12\tssh-dsa ASDFASGADG\nkey-123\tssh-rsa GFDGDFSGSDFG\nfoo\tbar\tbaz\n", 'r') } it "aborts" do gitlab_keys.should_receive(:abort) gitlab_keys.send :batch_add_keys end end context "without file writing" do before do gitlab_keys.should_receive(:open).and_yield(double(:file, puts: nil, chmod: nil)) end it "should log an add-key event" do $logger.should_receive(:info).with('Adding key key-12 => "ssh-dsa ASDFASGADG"') $logger.should_receive(:info).with('Adding key key-123 => "ssh-rsa GFDGDFSGSDFG"') gitlab_keys.send :batch_add_keys end it "should return true" do gitlab_keys.send(:batch_add_keys).should be_true end end end describe :stdin do let(:gitlab_keys) { build_gitlab_keys } subject { gitlab_keys.send :stdin } before { $stdin = 1 } it { should equal(1) } end describe :rm_key do let(:gitlab_keys) { build_gitlab_keys('rm-key', 'key-741', 'ssh-rsa AAAAB3NzaDAxx2E') } it "removes the right line" do create_authorized_keys_fixture other_line = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-742\",options ssh-rsa AAAAB3NzaDAxx2E" delete_line = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-741\",options ssh-rsa AAAAB3NzaDAxx2E" open(tmp_authorized_keys_path, 'a') do |auth_file| auth_file.puts delete_line auth_file.puts other_line end gitlab_keys.send :rm_key erased_line = delete_line.gsub(/./, '#') File.read(tmp_authorized_keys_path).should == "existing content\n#{erased_line}\n#{other_line}\n" end context "without file writing" do before do gitlab_keys.stub(:open) gitlab_keys.stub(:lock).and_yield end it "should log an rm-key event" do $logger.should_receive(:info).with('Removing key key-741') gitlab_keys.send :rm_key end it "should return true" do gitlab_keys.send(:rm_key).should be_true end end end describe :clear do let(:gitlab_keys) { build_gitlab_keys('clear') } it "should return true" do gitlab_keys.stub(:open) gitlab_keys.send(:clear).should be_true end end describe :check_permissions do let(:gitlab_keys) { build_gitlab_keys('check-permissions') } it 'returns true when the file can be opened' do create_authorized_keys_fixture expect(gitlab_keys.exec).to eq(true) end it 'returns false if opening raises an exception' do gitlab_keys.should_receive(:open_auth_file).and_raise("imaginary error") expect(gitlab_keys.exec).to eq(false) end it 'creates the keys file if it does not exist' do create_authorized_keys_fixture FileUtils.rm(tmp_authorized_keys_path) expect(gitlab_keys.exec).to eq(true) expect(File.exist?(tmp_authorized_keys_path)).to eq(true) end end describe :exec do it 'add-key arg should execute add_key method' do gitlab_keys = build_gitlab_keys('add-key') gitlab_keys.should_receive(:add_key) gitlab_keys.exec end it 'batch-add-keys arg should execute batch_add_keys method' do gitlab_keys = build_gitlab_keys('batch-add-keys') gitlab_keys.should_receive(:batch_add_keys) gitlab_keys.exec end it 'rm-key arg should execute rm_key method' do gitlab_keys = build_gitlab_keys('rm-key') gitlab_keys.should_receive(:rm_key) gitlab_keys.exec end it 'clear arg should execute clear method' do gitlab_keys = build_gitlab_keys('clear') gitlab_keys.should_receive(:clear) gitlab_keys.exec end it 'check-permissions arg should execute check_permissions method' do gitlab_keys = build_gitlab_keys('check-permissions') gitlab_keys.should_receive(:check_permissions) gitlab_keys.exec end it 'should puts message if unknown command arg' do gitlab_keys = build_gitlab_keys('change-key') gitlab_keys.should_receive(:puts).with('not allowed') gitlab_keys.exec end it 'should log a warning on unknown commands' do gitlab_keys = build_gitlab_keys('nooope') gitlab_keys.stub(puts: nil) $logger.should_receive(:warn).with('Attempt to execute invalid gitlab-keys command "nooope".') gitlab_keys.exec end end describe :lock do before do GitlabKeys.any_instance.stub(lock_file: tmp_lock_file_path) end it "should raise exception if operation lasts more then timeout" do key = GitlabKeys.new expect do key.send :lock, 1 do sleep 2 end end.to raise_error end it "should actually lock file" do $global = "" key = GitlabKeys.new thr1 = Thread.new do key.send :lock do # Put bigger sleep here to test if main thread will # wait for lock file released before executing code sleep 1 $global << "foo" end end # make sure main thread start lock command after # thread above sleep 0.5 key.send :lock do $global << "bar" end thr1.join $global.should == "foobar" end end def build_gitlab_keys(*args) argv(*args) GitlabKeys.new end def argv(*args) args.each_with_index do |arg, i| ARGV[i] = arg.freeze end end def create_authorized_keys_fixture FileUtils.mkdir_p(File.dirname(tmp_authorized_keys_path)) open(tmp_authorized_keys_path, 'w') { |file| file.puts('existing content') } gitlab_keys.stub(auth_file: tmp_authorized_keys_path) end def tmp_authorized_keys_path File.join(ROOT_PATH, 'tmp', 'authorized_keys') end def tmp_lock_file_path tmp_authorized_keys_path + '.lock' end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_lfs_authentication_spec.rb000066400000000000000000000022271277744601700315440ustar00rootroot00000000000000require 'spec_helper' require 'gitlab_lfs_authentication' require 'json' describe GitlabLfsAuthentication do subject do GitlabLfsAuthentication.build_from_json( JSON.generate( { username: 'dzaporozhets', lfs_token: 'wsnys8Zm8Jn7zyhHTAAK', repository_http_path: 'http://gitlab.dev/repo' } ) ) end describe '#build_from_json' do it { subject.username.should == 'dzaporozhets' } it { subject.lfs_token.should == 'wsnys8Zm8Jn7zyhHTAAK' } it { subject.repository_http_path.should == 'http://gitlab.dev/repo' } end describe '#authentication_payload' do result = "{\"header\":{\"Authorization\":\"Basic ZHphcG9yb3poZXRzOndzbnlzOFptOEpuN3p5aEhUQUFL\"},\"href\":\"http://gitlab.dev/repo/info/lfs/\"}" it { subject.authentication_payload.should eq(result) } it 'should be a proper JSON' do payload = subject.authentication_payload json_payload = JSON.parse(payload) json_payload['header']['Authorization'].should eq('Basic ZHphcG9yb3poZXRzOndzbnlzOFptOEpuN3p5aEhUQUFL') json_payload['href'].should eq('http://gitlab.dev/repo/info/lfs/') end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_logger_spec.rb000066400000000000000000000004361277744601700271400ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_logger' describe :convert_log_level do subject { convert_log_level :extreme } it "converts invalid log level to Logger::INFO" do $stderr.should_receive(:puts).at_least(:once) should eq(Logger::INFO) end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_metrics_spec.rb000066400000000000000000000013761277744601700273330ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_metrics' describe GitlabMetrics do describe '.measure' do it 'returns the return value of the block' do val = described_class.measure('foo') { 10 } expect(val).to eq(10) end it 'writes the metrics data to a log file' do expect(described_class.logger).to receive(:debug). with(/metrics: name=\"foo\" wall_time=\d+ cpu_time=\d+/) described_class.measure('foo') { 10 } end it 'calls proper measure methods' do expect(described_class::System).to receive(:monotonic_time).twice.and_call_original expect(described_class::System).to receive(:cpu_time).twice.and_call_original described_class.measure('foo') { 10 } end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_net_spec.rb000066400000000000000000000312711277744601700264500ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_net' require_relative '../lib/gitlab_access_status' describe GitlabNet, vcr: true do let(:gitlab_net) { GitlabNet.new } let(:changes) { ['0000000000000000000000000000000000000000 92d0970eefd7acb6d548878925ce2208cfe2d2ec refs/heads/branch4'] } before do gitlab_net.stub(:host).and_return('https://dev.gitlab.org/api/v3/internal') gitlab_net.stub(:secret_token).and_return('a123') end describe :check do it 'should return 200 code for gitlab check' do VCR.use_cassette("check-ok") do result = gitlab_net.check result.code.should == '200' end end it 'adds the secret_token to request' do VCR.use_cassette("check-ok") do Net::HTTP::Get.any_instance.should_receive(:set_form_data).with(hash_including(secret_token: 'a123')) gitlab_net.check end end it "raises an exception if the connection fails" do Net::HTTP.any_instance.stub(:request).and_raise(StandardError) expect { gitlab_net.check }.to raise_error(GitlabNet::ApiUnreachableError) end end describe :discover do it 'should return user has based on key id' do VCR.use_cassette("discover-ok") do user = gitlab_net.discover('key-126') user['name'].should == 'Dmitriy Zaporozhets' user['username'].should == 'dzaporozhets' end end it 'adds the secret_token to request' do VCR.use_cassette("discover-ok") do Net::HTTP::Get.any_instance.should_receive(:set_form_data).with(hash_including(secret_token: 'a123')) gitlab_net.discover('key-126') end end it "raises an exception if the connection fails" do VCR.use_cassette("discover-ok") do Net::HTTP.any_instance.stub(:request).and_raise(StandardError) expect { gitlab_net.discover('key-126') }.to raise_error(GitlabNet::ApiUnreachableError) end end end describe '#lfs_authenticate' do context 'lfs authentication succeeded' do it 'should return the correct data' do VCR.use_cassette('lfs-authenticate-ok') do lfs_access = gitlab_net.lfs_authenticate('key-126', 'gitlab/gitlabhq.git') lfs_access.username.should == 'dzaporozhets' lfs_access.lfs_token.should == 'wsnys8Zm8Jn7zyhHTAAK' lfs_access.repository_http_path.should == 'http://gitlab.dev/gitlab/gitlabhq.git' end end end end describe :broadcast_message do context "broadcast message exists" do it 'should return message' do VCR.use_cassette("broadcast_message-ok") do result = gitlab_net.broadcast_message result["message"].should == "Message" end end end context "broadcast message doesn't exist" do it 'should return nil' do VCR.use_cassette("broadcast_message-none") do result = gitlab_net.broadcast_message result.should == {} end end end end describe :authorized_key do let (:ssh_key) { "AAAAB3NzaC1yc2EAAAADAQABAAACAQDPKPqqnqQ9PDFw65cO7iHXrKw6ucSZg8Bd2CZ150Yy1YRDPJOWeRNCnddS+M/Lk" } it "should return nil when the resource is not implemented" do VCR.use_cassette("ssh-key-not-implemented") do result = gitlab_net.authorized_key("whatever") result.should be_nil end end it "should return nil when the fingerprint is not found" do VCR.use_cassette("ssh-key-not-found") do result = gitlab_net.authorized_key("whatever") result.should be_nil end end it "should return a ssh key with a valid fingerprint" do VCR.use_cassette("ssh-key-ok") do result = gitlab_net.authorized_key(ssh_key) result.should eq({ "created_at" => "2016-03-04T18:27:36.959Z", "id" => 2, "key" => "ssh-rsa a-made=up-rsa-key dummy@gitlab.com", "title" => "some key title" }) end end end describe '#two_factor_recovery_codes' do it 'returns two factor recovery codes' do VCR.use_cassette('two-factor-recovery-codes') do result = gitlab_net.two_factor_recovery_codes('key-1') expect(result['success']).to be_true expect(result['recovery_codes']).to eq(['f67c514de60c4953','41278385fc00c1e0']) end end it 'returns false when recovery codes cannot be generated' do VCR.use_cassette('two-factor-recovery-codes-fail') do result = gitlab_net.two_factor_recovery_codes('key-1') expect(result['success']).to be_false expect(result['message']).to eq('Could not find the given key') end end end describe :check_access do context 'ssh key with access to project' do it 'should allow pull access for dev.gitlab.org' do VCR.use_cassette("allowed-pull") do access = gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-126', changes, 'ssh') access.allowed?.should be_true end end it 'adds the secret_token to the request' do VCR.use_cassette("allowed-pull") do Net::HTTP::Post.any_instance.should_receive(:set_form_data).with(hash_including(secret_token: 'a123')) gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-126', changes, 'ssh') end end it 'should allow push access for dev.gitlab.org' do VCR.use_cassette("allowed-push") do access = gitlab_net.check_access('git-upload-pack', 'gitlab/gitlabhq.git', 'key-126', changes, 'ssh') access.allowed?.should be_true end end end context 'ssh access has been disabled' do it 'should deny pull access for dev.gitlab.org' do VCR.use_cassette('ssh-access-disabled') do access = gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-2', changes, 'ssh') access.allowed?.should be_false access.message.should eq 'Git access over SSH is not allowed' end end it 'should deny pull access for dev.gitlab.org' do VCR.use_cassette('ssh-access-disabled') do access = gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-2', changes, 'ssh') access.allowed?.should be_false access.message.should eq 'Git access over SSH is not allowed' end end end context 'http access has been disabled' do it 'should deny pull access for dev.gitlab.org' do VCR.use_cassette('http-access-disabled') do access = gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-2', changes, 'http') access.allowed?.should be_false access.message.should eq 'Git access over HTTP is not allowed' end end it 'should deny pull access for dev.gitlab.org' do VCR.use_cassette('http-access-disabled') do access = gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-2', changes, 'http') access.allowed?.should be_false access.message.should eq 'Git access over HTTP is not allowed' end end end context 'ssh key without access to project' do it 'should deny pull access for dev.gitlab.org' do VCR.use_cassette("denied-pull") do access = gitlab_net.check_access('git-receive-pack', 'gitlab/gitlabhq.git', 'key-2', changes, 'ssh') access.allowed?.should be_false end end it 'should deny push access for dev.gitlab.org' do VCR.use_cassette("denied-push") do access = gitlab_net.check_access('git-upload-pack', 'gitlab/gitlabhq.git', 'key-2', changes, 'ssh') access.allowed?.should be_false end end it 'should deny push access for dev.gitlab.org (with user)' do VCR.use_cassette("denied-push-with-user") do access = gitlab_net.check_access('git-upload-pack', 'gitlab/gitlabhq.git', 'user-1', changes, 'ssh') access.allowed?.should be_false end end end it "raises an exception if the connection fails" do Net::HTTP.any_instance.stub(:request).and_raise(StandardError) expect { gitlab_net.check_access('git-upload-pack', 'gitlab/gitlabhq.git', 'user-1', changes, 'ssh') }.to raise_error(GitlabNet::ApiUnreachableError) end end describe :host do let(:net) { GitlabNet.new } subject { net.send :host } it { should include(net.send(:config).gitlab_url) } it("uses API version 3") { should include("api/v3") } end describe :http_client_for do subject { gitlab_net.send :http_client_for, URI('https://localhost/') } before do gitlab_net.stub :cert_store gitlab_net.send(:config).stub(:http_settings) { {'self_signed_cert' => true} } end its(:verify_mode) { should eq(OpenSSL::SSL::VERIFY_NONE) } end describe :http_request_for do let(:get) do double(Net::HTTP::Get).tap do |get| Net::HTTP::Get.stub(:new) { get } end end let(:user) { 'user' } let(:password) { 'password' } let(:url) { URI 'http://localhost/' } subject { gitlab_net.send :http_request_for, :get, url } before do gitlab_net.send(:config).http_settings.stub(:[]).with('user') { user } gitlab_net.send(:config).http_settings.stub(:[]).with('password') { password } get.should_receive(:basic_auth).with(user, password).once get.should_receive(:set_form_data).with(hash_including(secret_token: 'a123')).once end it { should_not be_nil } end describe :cert_store do let(:store) do double(OpenSSL::X509::Store).tap do |store| OpenSSL::X509::Store.stub(:new) { store } end end before :each do store.should_receive(:set_default_paths).once end after do gitlab_net.send :cert_store end it "calls add_file with http_settings['ca_file']" do gitlab_net.send(:config).http_settings.stub(:[]).with('ca_file') { 'test_file' } gitlab_net.send(:config).http_settings.stub(:[]).with('ca_path') { nil } store.should_receive(:add_file).with('test_file') store.should_not_receive(:add_path) end it "calls add_path with http_settings['ca_path']" do gitlab_net.send(:config).http_settings.stub(:[]).with('ca_file') { nil } gitlab_net.send(:config).http_settings.stub(:[]).with('ca_path') { 'test_path' } store.should_not_receive(:add_file) store.should_receive(:add_path).with('test_path') end end describe '#redis_client' do let(:config) { double('config') } context "with empty redis config" do it 'returns default parameters' do allow(gitlab_net).to receive(:config).and_return(config) allow(config).to receive(:redis).and_return( {} ) expect_any_instance_of(Redis).to receive(:initialize).with({ host: '127.0.0.1', port: 6379, db: 0 }) gitlab_net.redis_client end end context "with password" do it 'uses the specified host, port, and password' do allow(gitlab_net).to receive(:config).and_return(config) allow(config).to receive(:redis).and_return( { 'host' => 'localhost', 'port' => 1123, 'pass' => 'secret' } ) expect_any_instance_of(Redis).to receive(:initialize).with({ host: 'localhost', port: 1123, db: 0, password: 'secret'}) gitlab_net.redis_client end end context "with sentinels" do it 'uses the specified sentinels' do allow(gitlab_net).to receive(:config).and_return(config) allow(config).to receive(:redis).and_return({ 'host' => 'localhost', 'port' => 1123, 'sentinels' => [{'host' => '127.0.0.1', 'port' => 26380}] }) expect_any_instance_of(Redis).to receive(:initialize).with({ host: 'localhost', port: 1123, db: 0, sentinels: [{host: '127.0.0.1', port: 26380}] }) gitlab_net.redis_client end end context "with redis socket" do let(:socket) { '/tmp/redis.socket' } it 'uses the socket' do allow(gitlab_net).to receive(:config).and_return(config) allow(config).to receive(:redis).and_return( { 'socket' => socket }) expect_any_instance_of(Redis).to receive(:initialize).with({ path: socket, db: 0 }) gitlab_net.redis_client end end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_post_receive_spec.rb000066400000000000000000000161371277744601700303550ustar00rootroot00000000000000# coding: utf-8 require 'spec_helper' require 'gitlab_post_receive' describe GitlabPostReceive do let(:repository_path) { "/home/git/repositories" } let(:repo_name) { 'dzaporozhets/gitlab-ci' } let(:actor) { 'key-123' } let(:changes) { "123456 789012 refs/heads/tést\n654321 210987 refs/tags/tag" } let(:wrongly_encoded_changes) { changes.encode("ISO-8859-1").force_encoding("UTF-8") } let(:base64_changes) { Base64.encode64(wrongly_encoded_changes) } let(:repo_path) { File.join(repository_path, repo_name) + ".git" } let(:gitlab_post_receive) { GitlabPostReceive.new(repo_path, actor, wrongly_encoded_changes) } let(:message) { "test " * 10 + "message " * 10 } let(:redis_client) { double('redis_client') } let(:enqueued_at) { Time.new(2016, 6, 23, 6, 59) } before do GitlabConfig.any_instance.stub(repos_path: repository_path) GitlabNet.any_instance.stub(broadcast_message: { }) GitlabNet.any_instance.stub(:merge_request_urls).with(repo_name, wrongly_encoded_changes) { [] } expect(Time).to receive(:now).and_return(enqueued_at) end describe "#exec" do before do allow_any_instance_of(GitlabNet).to receive(:redis_client).and_return(redis_client) allow_any_instance_of(GitlabReferenceCounter).to receive(:redis_client).and_return(redis_client) allow(redis_client).to receive(:get).and_return(1) allow(redis_client).to receive(:incr).and_return(true) allow(redis_client).to receive(:decr).and_return(0) allow(redis_client).to receive(:rpush).and_return(true) end context 'Without broad cast message' do context 'pushing new branch' do before do GitlabNet.any_instance.stub(:merge_request_urls).with(repo_name, wrongly_encoded_changes) do [{ "branch_name" => "new_branch", "url" => "http://localhost/dzaporozhets/gitlab-ci/merge_requests/new?merge_request%5Bsource_branch%5D=new_branch", "new_merge_request" => true }] end end it "prints the new merge request url" do expect(redis_client).to receive(:rpush) expect(gitlab_post_receive).to receive(:puts).ordered expect(gitlab_post_receive).to receive(:puts).with( "Create merge request for new_branch:" ).ordered expect(gitlab_post_receive).to receive(:puts).with( " http://localhost/dzaporozhets/gitlab-ci/merge_requests/new?merge_request%5Bsource_branch%5D=new_branch" ).ordered expect(gitlab_post_receive).to receive(:puts).ordered gitlab_post_receive.exec end end context 'pushing existing branch with merge request created' do before do GitlabNet.any_instance.stub(:merge_request_urls).with(repo_name, wrongly_encoded_changes) do [{ "branch_name" => "feature_branch", "url" => "http://localhost/dzaporozhets/gitlab-ci/merge_requests/1", "new_merge_request" => false }] end end it "prints the view merge request url" do expect(redis_client).to receive(:rpush) expect(gitlab_post_receive).to receive(:puts).ordered expect(gitlab_post_receive).to receive(:puts).with( "View merge request for feature_branch:" ).ordered expect(gitlab_post_receive).to receive(:puts).with( " http://localhost/dzaporozhets/gitlab-ci/merge_requests/1" ).ordered expect(gitlab_post_receive).to receive(:puts).ordered gitlab_post_receive.exec end end end context 'show broadcast message and merge request link' do before do GitlabNet.any_instance.stub(:merge_request_urls).with(repo_name, wrongly_encoded_changes) do [{ "branch_name" => "new_branch", "url" => "http://localhost/dzaporozhets/gitlab-ci/merge_requests/new?merge_request%5Bsource_branch%5D=new_branch", "new_merge_request" => true }] end GitlabNet.any_instance.stub(broadcast_message: { "message" => message }) end it 'prints the broadcast message and create new merge request link' do expect(redis_client).to receive(:rpush) expect(gitlab_post_receive).to receive(:puts).ordered expect(gitlab_post_receive).to receive(:puts).with( "========================================================================" ).ordered expect(gitlab_post_receive).to receive(:puts).ordered expect(gitlab_post_receive).to receive(:puts).with( " test test test test test test test test test test message message" ).ordered expect(gitlab_post_receive).to receive(:puts).with( " message message message message message message message message" ).ordered expect(gitlab_post_receive).to receive(:puts).ordered expect(gitlab_post_receive).to receive(:puts).with( "========================================================================" ).ordered expect(gitlab_post_receive).to receive(:puts).ordered expect(gitlab_post_receive).to receive(:puts).with( "Create merge request for new_branch:" ).ordered expect(gitlab_post_receive).to receive(:puts).with( " http://localhost/dzaporozhets/gitlab-ci/merge_requests/new?merge_request%5Bsource_branch%5D=new_branch" ).ordered expect(gitlab_post_receive).to receive(:puts).ordered gitlab_post_receive.exec end end it "pushes a Sidekiq job onto the queue" do expect(redis_client).to receive(:rpush).with( 'resque:gitlab:queue:post_receive', %Q/{"class":"PostReceive","args":["#{repo_path}","#{actor}",#{base64_changes.inspect}],"jid":"#{gitlab_post_receive.jid}","enqueued_at":#{enqueued_at.to_f}}/ ).and_return(true) gitlab_post_receive.exec end context 'reference counter' do it 'decreases the reference counter for the project' do expect_any_instance_of(GitlabReferenceCounter).to receive(:decrease).and_return(true) gitlab_post_receive.exec end context "when the redis command succeeds" do before do allow(redis_client).to receive(:decr).and_return(0) end it "returns true" do expect(gitlab_post_receive.exec).to eq(true) end end context "when the redis command fails" do before do allow(redis_client).to receive(:decr).and_raise('Fail') end it "returns false" do expect(gitlab_post_receive.exec).to eq(false) end end end context "when the redis command succeeds" do before do allow(redis_client).to receive(:rpush).and_return(true) end it "returns true" do expect(gitlab_post_receive.exec).to eq(true) end end context "when the redis command fails" do before do allow(redis_client).to receive(:rpush).and_raise('Fail') end it "returns false" do expect(gitlab_post_receive.exec).to eq(false) end end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_projects_spec.rb000066400000000000000000000403631277744601700275150ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_projects' describe GitlabProjects do before do FileUtils.mkdir_p(tmp_repos_path) $logger = double('logger').as_null_object end after do FileUtils.rm_rf(tmp_repos_path) end describe :create_hooks do let(:repo_path) { File.join(tmp_repos_path, 'hook-test.git') } let(:hooks_dir) { File.join(repo_path, 'hooks') } let(:target_hooks_dir) { File.join(ROOT_PATH, 'hooks') } let(:existing_target) { File.join(repo_path, 'foobar') } before do FileUtils.rm_rf(repo_path) FileUtils.mkdir_p(repo_path) end context 'hooks is a directory' do let(:existing_file) { File.join(hooks_dir, 'my-file') } before do FileUtils.mkdir_p(hooks_dir) FileUtils.touch(existing_file) GitlabProjects.create_hooks(repo_path) end it { File.readlink(hooks_dir).should == target_hooks_dir } it { Dir[File.join(repo_path, "hooks.old.*/my-file")].count.should == 1 } end context 'hooks is a valid symlink' do before do FileUtils.mkdir_p existing_target File.symlink(existing_target, hooks_dir) GitlabProjects.create_hooks(repo_path) end it { File.readlink(hooks_dir).should == target_hooks_dir } end context 'hooks is a broken symlink' do before do FileUtils.rm_f(existing_target) File.symlink(existing_target, hooks_dir) GitlabProjects.create_hooks(repo_path) end it { File.readlink(hooks_dir).should == target_hooks_dir } end end describe :initialize do before do argv('add-project', tmp_repos_path, repo_name) @gl_projects = GitlabProjects.new end it { @gl_projects.project_name.should == repo_name } it { @gl_projects.repos_path.should == tmp_repos_path } it { @gl_projects.full_path.should == "#{tmp_repos_path}/gitlab-ci.git" } it { @gl_projects.instance_variable_get(:@command).should == 'add-project' } end describe :create_tag do let(:gl_projects_create) { build_gitlab_projects('import-project', tmp_repos_path, repo_name, 'https://github.com/randx/six.git') } context "lightweight tag" do let(:gl_projects) { build_gitlab_projects('create-tag', tmp_repos_path, repo_name, 'test_tag', 'master') } it "should create a tag" do gl_projects_create.exec gl_projects.exec tag_ref = capture_in_tmp_repo(%W(git rev-parse test_tag)) master_ref = capture_in_tmp_repo(%W(git rev-parse master)) tag_ref.should == master_ref end end context "annotated tag" do msg = 'some message' tag_name = 'test_annotated_tag' let(:gl_projects) { build_gitlab_projects('create-tag', tmp_repos_path, repo_name, tag_name, 'master', msg) } it "should create an annotated tag" do gl_projects_create.exec system(*%W(git --git-dir=#{tmp_repo_path} config user.name Joe)) system(*%W(git --git-dir=#{tmp_repo_path} config user.email joe@smith.com)) gl_projects.exec tag_ref = capture_in_tmp_repo(%W(git rev-parse #{tag_name}^{})) master_ref = capture_in_tmp_repo(%W(git rev-parse master)) tag_msg = capture_in_tmp_repo(%W(git tag -l -n1 #{tag_name})) tag_ref.should == master_ref tag_msg.should == tag_name + ' ' + msg end end end describe :add_project do let(:gl_projects) { build_gitlab_projects('add-project', tmp_repos_path, repo_name) } it "should create a directory" do gl_projects.stub(system: true) GitlabProjects.stub(create_hooks: true) gl_projects.exec File.exists?(tmp_repo_path).should be_true end it "should receive valid cmd" do valid_cmd = ['git', "--git-dir=#{tmp_repo_path}", 'init', '--bare'] gl_projects.should_receive(:system).with(*valid_cmd).and_return(true) GitlabProjects.should_receive(:create_hooks).with(tmp_repo_path) gl_projects.exec end it "should log an add-project event" do $logger.should_receive(:info).with("Adding project #{repo_name} at <#{tmp_repo_path}>.") gl_projects.exec end end describe :list_projects do let(:gl_projects) do build_gitlab_projects('add-project', tmp_repos_path, "list_test/#{repo_name}") end before do FileUtils.mkdir_p(tmp_repos_path) end it 'should create projects and list them' do GitlabProjects.stub(create_hooks: true) gl_projects.exec gl_projects.send(:list_projects).should == ["list_test/#{repo_name}"] end end describe :mv_project do let(:gl_projects) { build_gitlab_projects('mv-project', tmp_repos_path, repo_name, 'repo.git') } let(:new_repo_path) { File.join(tmp_repos_path, 'repo.git') } before do FileUtils.mkdir_p(tmp_repo_path) end it "should move a repo directory" do File.exists?(tmp_repo_path).should be_true gl_projects.exec File.exists?(tmp_repo_path).should be_false File.exists?(new_repo_path).should be_true end it "should fail if no destination path is provided" do incomplete = build_gitlab_projects('mv-project', tmp_repos_path, repo_name) $logger.should_receive(:error).with("mv-project failed: no destination path provided.") incomplete.exec.should be_false end it "should fail if the source path doesn't exist" do bad_source = build_gitlab_projects('mv-project', tmp_repos_path, 'bad-src.git', 'dest.git') $logger.should_receive(:error).with("mv-project failed: source path <#{tmp_repos_path}/bad-src.git> does not exist.") bad_source.exec.should be_false end it "should fail if the destination path already exists" do FileUtils.mkdir_p(File.join(tmp_repos_path, 'already-exists.git')) bad_dest = build_gitlab_projects('mv-project', tmp_repos_path, repo_name, 'already-exists.git') message = "mv-project failed: destination path <#{tmp_repos_path}/already-exists.git> already exists." $logger.should_receive(:error).with(message) bad_dest.exec.should be_false end it "should log an mv-project event" do message = "Moving project #{repo_name} from <#{tmp_repo_path}> to <#{new_repo_path}>." $logger.should_receive(:info).with(message) gl_projects.exec end end describe :rm_project do let(:gl_projects) { build_gitlab_projects('rm-project', tmp_repos_path, repo_name) } before do FileUtils.mkdir_p(tmp_repo_path) end it "should remove a repo directory" do File.exists?(tmp_repo_path).should be_true gl_projects.exec File.exists?(tmp_repo_path).should be_false end it "should log an rm-project event" do $logger.should_receive(:info).with("Removing project #{repo_name} from <#{tmp_repo_path}>.") gl_projects.exec end end describe :mv_storage do let(:alternative_storage_path) { File.join(ROOT_PATH, 'tmp', 'alternative') } let(:gl_projects) { build_gitlab_projects('mv-storage', tmp_repos_path, repo_name, alternative_storage_path) } let(:new_repo_path) { File.join(alternative_storage_path, repo_name) } before do FileUtils.mkdir_p(tmp_repo_path) FileUtils.mkdir_p(File.join(tmp_repo_path, 'hooks')) # Add some contents to copy FileUtils.mkdir_p(alternative_storage_path) allow_any_instance_of(GitlabReferenceCounter).to receive(:value).and_return(0) end after { FileUtils.rm_rf(alternative_storage_path) } it "should rsync a repo directory" do File.exists?(tmp_repo_path).should be_true gl_projects.exec File.exists?(new_repo_path).should be_true # Make sure the target directory isn't empty (i.e. contents were copied) FileUtils.cd(new_repo_path) { Dir['**/*'].length.should_not be(0) } end it "should attempt rsync with ionice first" do expect(gl_projects).to receive(:system).with( 'ionice', '-c2', '-n7', 'rsync', '-a', '--delete', '--rsync-path="ionice -c2 -n7 rsync"', "#{tmp_repo_path}/", new_repo_path ).and_return(true) gl_projects.exec.should be_true end it "should attempt rsync without ionice if with ionice fails" do expect(gl_projects).to receive(:system).with( 'ionice', '-c2', '-n7', 'rsync', '-a', '--delete', '--rsync-path="ionice -c2 -n7 rsync"', "#{tmp_repo_path}/", new_repo_path ).and_return(false) expect(gl_projects).to receive(:system).with( 'rsync', '-a', '--delete', '--rsync-path="rsync"', "#{tmp_repo_path}/", new_repo_path ).and_return(true) gl_projects.exec.should be_true end it "should fail if both rsync attempts fail" do expect(gl_projects).to receive(:system).with( 'ionice', '-c2', '-n7', 'rsync', '-a', '--delete', '--rsync-path="ionice -c2 -n7 rsync"', "#{tmp_repo_path}/", new_repo_path ).and_return(false) expect(gl_projects).to receive(:system).with( 'rsync', '-a', '--delete', '--rsync-path="rsync"', "#{tmp_repo_path}/", new_repo_path ).and_return(false) gl_projects.exec.should be_false end it "should fail if no destination path is provided" do incomplete = build_gitlab_projects('mv-storage', tmp_repos_path, repo_name) $logger.should_receive(:error).with("mv-storage failed: no destination storage path provided.") incomplete.exec.should be_false end it "should fail if the source path doesn't exist" do bad_source = build_gitlab_projects('mv-storage', tmp_repos_path, 'bad-src.git', alternative_storage_path) $logger.should_receive(:error).with("mv-storage failed: source path <#{tmp_repos_path}/bad-src.git> does not exist.") bad_source.exec.should be_false end it "should fail if there are pushes ongoing" do allow_any_instance_of(GitlabReferenceCounter).to receive(:value).and_return(1) $logger.should_receive(:error).with("mv-storage failed: source path <#{tmp_repo_path}> is waiting for pushes to finish.") gl_projects.exec.should be_false end it "should log an mv-storage event" do message = "Syncing project #{repo_name} from <#{tmp_repo_path}> to <#{new_repo_path}>." $logger.should_receive(:info).with(message) gl_projects.exec end end describe :import_project do context 'success import' do let(:gl_projects) { build_gitlab_projects('import-project', tmp_repos_path, repo_name, 'https://github.com/randx/six.git') } it { gl_projects.exec.should be_true } it "should import a repo" do gl_projects.exec File.exists?(File.join(tmp_repo_path, 'HEAD')).should be_true end it "should log an import-project event" do message = "Importing project #{repo_name} from to <#{tmp_repo_path}>." $logger.should_receive(:info).with(message) gl_projects.exec end end context 'already exists' do let(:gl_projects) { build_gitlab_projects('import-project', tmp_repos_path, repo_name, 'https://github.com/randx/six.git') } it 'should import only once' do gl_projects.exec.should be_true gl_projects.exec.should be_false end end context 'timeout' do let(:gl_projects) { build_gitlab_projects('import-project', tmp_repos_path, repo_name, 'https://github.com/gitlabhq/gitlabhq.git', '1') } it { gl_projects.exec.should be_false } it "should not import a repo" do gl_projects.exec File.exists?(File.join(tmp_repo_path, 'HEAD')).should be_false end it "should log an import-project event" do message = "Importing project #{repo_name} from failed due to timeout." $logger.should_receive(:error).with(message) gl_projects.exec end end end describe :fork_project do let(:source_repo_name) { File.join('source-namespace', repo_name) } let(:dest_repo) { File.join(tmp_repos_path, 'forked-to-namespace', repo_name) } let(:gl_projects_fork) { build_gitlab_projects('fork-project', tmp_repos_path, source_repo_name, tmp_repos_path, 'forked-to-namespace') } let(:gl_projects_import) { build_gitlab_projects('import-project', tmp_repos_path, source_repo_name, 'https://github.com/randx/six.git') } before do gl_projects_import.exec end it "should not fork without a source repository path" do missing_arg = build_gitlab_projects('fork-project', tmp_repos_path, source_repo_name) $logger.should_receive(:error).with("fork-project failed: no destination repository path provided.") missing_arg.exec.should be_false end it "should not fork without a destination namespace" do missing_arg = build_gitlab_projects('fork-project', tmp_repos_path, source_repo_name, tmp_repos_path) $logger.should_receive(:error).with("fork-project failed: no destination namespace provided.") missing_arg.exec.should be_false end it "should not fork into a namespace that doesn't exist" do message = "fork-project failed: destination namespace <#{tmp_repos_path}/forked-to-namespace> does not exist." $logger.should_receive(:error).with(message) gl_projects_fork.exec.should be_false end it "should fork the repo" do # create destination namespace FileUtils.mkdir_p(File.join(tmp_repos_path, 'forked-to-namespace')) gl_projects_fork.exec.should be_true File.exists?(dest_repo).should be_true File.exists?(File.join(dest_repo, '/hooks/pre-receive')).should be_true File.exists?(File.join(dest_repo, '/hooks/post-receive')).should be_true end it "should not fork if a project of the same name already exists" do # create a fake project at the intended destination FileUtils.mkdir_p(File.join(tmp_repos_path, 'forked-to-namespace', repo_name)) # trying to fork again should fail as the repo already exists message = "fork-project failed: destination repository <#{tmp_repos_path}/forked-to-namespace/#{repo_name}> " message << "already exists." $logger.should_receive(:error).with(message) gl_projects_fork.exec.should be_false end it "should log a fork-project event" do message = "Forking project from <#{File.join(tmp_repos_path, source_repo_name)}> to <#{dest_repo}>." $logger.should_receive(:info).with(message) # create destination namespace FileUtils.mkdir_p(File.join(tmp_repos_path, 'forked-to-namespace')) gl_projects_fork.exec.should be_true end context 'different storages' do let(:alternative_repos_path) { File.join(ROOT_PATH, 'tmp', 'alternative') } let(:dest_repo) { File.join(alternative_repos_path, 'forked-to-namespace', repo_name) } let(:gl_projects_fork) { build_gitlab_projects('fork-project', tmp_repos_path, source_repo_name, alternative_repos_path, 'forked-to-namespace') } before do FileUtils.mkdir_p(alternative_repos_path) end after do FileUtils.rm_rf(alternative_repos_path) end it "should fork the repo" do # create destination namespace FileUtils.mkdir_p(File.join(alternative_repos_path, 'forked-to-namespace')) gl_projects_fork.exec.should be_true File.exists?(dest_repo).should be_true File.exists?(File.join(dest_repo, '/hooks/pre-receive')).should be_true File.exists?(File.join(dest_repo, '/hooks/post-receive')).should be_true end end end describe :exec do it 'should puts message if unknown command arg' do gitlab_projects = build_gitlab_projects('edit-project', tmp_repos_path, repo_name) gitlab_projects.should_receive(:puts).with('not allowed') gitlab_projects.exec end it 'should log a warning for unknown commands' do gitlab_projects = build_gitlab_projects('hurf-durf', tmp_repos_path, repo_name) $logger.should_receive(:warn).with('Attempt to execute invalid gitlab-projects command "hurf-durf".') gitlab_projects.exec end end def build_gitlab_projects(*args) argv(*args) GitlabProjects.new end def argv(*args) args.each_with_index do |arg, i| ARGV[i] = arg end end def tmp_repos_path File.join(ROOT_PATH, 'tmp', 'repositories') end def tmp_repo_path File.join(tmp_repos_path, repo_name) end def repo_name 'gitlab-ci.git' end def capture_in_tmp_repo(cmd) IO.popen([*cmd, {chdir: tmp_repo_path}]).read.strip end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_reference_counter_spec.rb000066400000000000000000000031231277744601700313520ustar00rootroot00000000000000# coding: utf-8 require 'spec_helper' require 'gitlab_reference_counter' describe GitlabReferenceCounter do let(:redis_client) { double('redis_client') } let(:reference_counter_key) { "git-receive-pack-reference-counter:/test/path" } let(:gitlab_reference_counter) { GitlabReferenceCounter.new('/test/path') } before do allow(gitlab_reference_counter).to receive(:redis_client).and_return(redis_client) $logger = double('logger').as_null_object end it 'increases and set the expire time of a reference count for a path' do expect(redis_client).to receive(:incr).with(reference_counter_key) expect(redis_client).to receive(:expire).with(reference_counter_key, GitlabReferenceCounter::REFERENCE_EXPIRE_TIME) expect(gitlab_reference_counter.increase).to be(true) end it 'decreases the reference count for a path' do allow(redis_client).to receive(:decr).and_return(0) expect(redis_client).to receive(:decr).with(reference_counter_key) expect(gitlab_reference_counter.decrease).to be(true) end it 'warns if attempting to decrease a counter with a value of one or less, and resets the counter' do expect(redis_client).to receive(:decr).and_return(-1) expect(redis_client).to receive(:del) expect($logger).to receive(:warn).with("Reference counter for /test/path decreased when its value was less than 1. Reseting the counter.") expect(gitlab_reference_counter.decrease).to be(true) end it 'get the reference count for a path' do allow(redis_client).to receive(:get).and_return(1) expect(gitlab_reference_counter.value).to be(1) end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/gitlab_shell_spec.rb000066400000000000000000000331621277744601700267720ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/gitlab_shell' require_relative '../lib/gitlab_access_status' describe GitlabShell do before do FileUtils.mkdir_p(tmp_repos_path) end after do FileUtils.rm_rf(tmp_repos_path) end subject do ARGV[0] = key_id GitlabShell.new(key_id).tap do |shell| shell.stub(exec_cmd: :exec_called) shell.stub(api: api) end end let(:api) do double(GitlabNet).tap do |api| api.stub(discover: { 'name' => 'John Doe' }) api.stub(check_access: GitAccessStatus.new(true, 'ok', repo_path)) api.stub(two_factor_recovery_codes: { 'success' => true, 'recovery_codes' => ['f67c514de60c4953', '41278385fc00c1e0'] }) end end let(:key_id) { "key-#{rand(100) + 100}" } let(:ssh_cmd) { nil } let(:tmp_repos_path) { File.join(ROOT_PATH, 'tmp', 'repositories') } let(:repo_name) { 'gitlab-ci.git' } let(:repo_path) { File.join(tmp_repos_path, repo_name) } before do GitlabConfig.any_instance.stub(audit_usernames: false) end describe :initialize do let(:ssh_cmd) { 'git-receive-pack' } its(:key_id) { should == key_id } end describe :parse_cmd do describe 'git' do context 'w/o namespace' do let(:ssh_args) { %W(git-upload-pack gitlab-ci.git) } before do subject.send :parse_cmd, ssh_args end its(:repo_name) { should == 'gitlab-ci.git' } its(:command) { should == 'git-upload-pack' } end context 'namespace' do let(:repo_name) { 'dmitriy.zaporozhets/gitlab-ci.git' } let(:ssh_args) { %W(git-upload-pack dmitriy.zaporozhets/gitlab-ci.git) } before do subject.send :parse_cmd, ssh_args end its(:repo_name) { should == 'dmitriy.zaporozhets/gitlab-ci.git' } its(:command) { should == 'git-upload-pack' } end context 'with an invalid number of arguments' do let(:ssh_args) { %W(foobar) } it "should raise an DisallowedCommandError" do expect { subject.send :parse_cmd, ssh_args }.to raise_error(GitlabShell::DisallowedCommandError) end end context 'with an API command' do before do subject.send :parse_cmd, ssh_args end context 'when generating recovery codes' do let(:ssh_args) { %w(2fa_recovery_codes) } it 'sets the correct command' do expect(subject.command).to eq('2fa_recovery_codes') end it 'does not set repo name' do expect(subject.repo_name).to be_nil end end end end describe 'git-annex' do let(:repo_name) { 'dzaporozhets/gitlab.git' } let(:ssh_args) { %W(git-annex-shell inannex /~/dzaporozhets/gitlab.git SHA256E) } before do GitlabConfig.any_instance.stub(git_annex_enabled?: true) subject.send :parse_cmd, ssh_args end its(:repo_name) { should == 'dzaporozhets/gitlab.git' } its(:command) { should == 'git-annex-shell' } end describe 'git-lfs' do let(:repo_name) { 'dzaporozhets/gitlab.git' } let(:ssh_args) { %W(git-lfs-authenticate dzaporozhets/gitlab.git download) } before do subject.send :parse_cmd, ssh_args end its(:repo_name) { should == 'dzaporozhets/gitlab.git' } its(:command) { should == 'git-lfs-authenticate' } its(:git_access) { should == 'git-upload-pack' } end describe 'git-lfs old clients' do let(:repo_name) { 'dzaporozhets/gitlab.git' } let(:ssh_args) { %W(git-lfs-authenticate dzaporozhets/gitlab.git download long_oid) } before do subject.send :parse_cmd, ssh_args end its(:repo_name) { should == 'dzaporozhets/gitlab.git' } its(:command) { should == 'git-lfs-authenticate' } its(:git_access) { should == 'git-upload-pack' } end end describe :exec do context 'git-upload-pack' do let(:ssh_cmd) { "git-upload-pack gitlab-ci.git" } after { subject.exec(ssh_cmd) } it "should process the command" do subject.should_receive(:process_cmd).with(%W(git-upload-pack gitlab-ci.git)) end it "should execute the command" do subject.should_receive(:exec_cmd).with("git-upload-pack", repo_path) end it "should log the command execution" do message = "gitlab-shell: executing git command " message << " " message << "for user with key #{key_id}." $logger.should_receive(:info).with(message) end it "should use usernames if configured to do so" do GitlabConfig.any_instance.stub(audit_usernames: true) $logger.should_receive(:info) { |msg| msg.should =~ /for John Doe/ } end end context 'git-receive-pack' do let(:ssh_cmd) { "git-receive-pack gitlab-ci.git" } after { subject.exec(ssh_cmd) } it "should process the command" do subject.should_receive(:process_cmd).with(%W(git-receive-pack gitlab-ci.git)) end it "should execute the command" do subject.should_receive(:exec_cmd).with("git-receive-pack", repo_path) end it "should log the command execution" do message = "gitlab-shell: executing git command " message << " " message << "for user with key #{key_id}." $logger.should_receive(:info).with(message) end end context 'arbitrary command' do let(:ssh_cmd) { 'arbitrary command' } after { subject.exec(ssh_cmd) } it "should not process the command" do subject.should_not_receive(:process_cmd) end it "should not execute the command" do subject.should_not_receive(:exec_cmd) end it "should log the attempt" do message = "gitlab-shell: Attempt to execute disallowed command by user with key #{key_id}." $logger.should_receive(:warn).with(message) end end context 'no command' do after { subject.exec(nil) } it "should call api.discover" do api.should_receive(:discover).with(key_id) end end context "failed connection" do let(:ssh_cmd) { 'git-upload-pack gitlab-ci.git' } before { api.stub(:check_access).and_raise(GitlabNet::ApiUnreachableError) } after { subject.exec(ssh_cmd) } it "should not process the command" do subject.should_not_receive(:process_cmd) end it "should not execute the command" do subject.should_not_receive(:exec_cmd) end end describe 'git-annex' do let(:repo_name) { 'dzaporozhets/gitlab.git' } before do GitlabConfig.any_instance.stub(git_annex_enabled?: true) end context 'initialization' do let(:ssh_cmd) { "git-annex-shell inannex /~/gitlab-ci.git SHA256E" } before do # Create existing project FileUtils.mkdir_p(repo_path) cmd = %W(git --git-dir=#{repo_path} init --bare) system(*cmd) subject.exec(ssh_cmd) end it 'should init git-annex' do File.exists?(repo_path).should be_true end context 'with git-annex-shell gcryptsetup' do let(:ssh_cmd) { "git-annex-shell gcryptsetup /~/dzaporozhets/gitlab.git" } it 'should not init git-annex' do File.exists?(File.join(tmp_repos_path, 'dzaporozhets/gitlab.git/annex')).should be_false end end context 'with git-annex and relative path without ~/' do # Using a SSH URL on a custom port will generate /dzaporozhets/gitlab.git let(:ssh_cmd) { "git-annex-shell inannex dzaporozhets/gitlab.git SHA256E" } it 'should init git-annex' do File.exists?(File.join(tmp_repos_path, "dzaporozhets/gitlab.git/annex")).should be_true end end end context 'execution' do let(:ssh_cmd) { "git-annex-shell commit /~/gitlab-ci.git SHA256" } after { subject.exec(ssh_cmd) } it "should execute the command" do subject.should_receive(:exec_cmd).with("git-annex-shell", "commit", repo_path, "SHA256") end end end context 'with an API command' do before do allow(subject).to receive(:continue?).and_return(true) end context 'when generating recovery codes' do let(:ssh_cmd) { '2fa_recovery_codes' } after do subject.exec(ssh_cmd) end it 'does not call verify_access' do expect(subject).not_to receive(:verify_access) end it 'calls the corresponding method' do expect(subject).to receive(:api_2fa_recovery_codes) end it 'outputs recovery codes' do expect($stdout).to receive(:puts) .with(/f67c514de60c4953\n41278385fc00c1e0/) end context 'when the process is unsuccessful' do it 'displays the error to the user' do api.stub(two_factor_recovery_codes: { 'success' => false, 'message' => 'Could not find the given key' }) expect($stdout).to receive(:puts) .with(/Could not find the given key/) end end end end end describe :validate_access do let(:ssh_cmd) { "git-upload-pack gitlab-ci.git" } describe 'check access with api' do after { subject.exec(ssh_cmd) } it "should call api.check_access" do api.should_receive(:check_access).with('git-upload-pack', 'gitlab-ci.git', key_id, '_any', 'ssh') end it "should disallow access and log the attempt if check_access returns false status" do api.stub(check_access: GitAccessStatus.new(false, 'denied', nil)) message = "gitlab-shell: Access denied for git command " message << "by user with key #{key_id}." $logger.should_receive(:warn).with(message) end end describe 'set the repository path' do context 'with a correct path' do before { subject.exec(ssh_cmd) } its(:repo_path) { should == repo_path } end context "with a path that doesn't match an absolute path" do before do File.stub(:absolute_path) { 'y/gitlab-ci.git' } end it "refuses to assign the path" do $stderr.should_receive(:puts).with("GitLab: Invalid repository path") expect(subject.exec(ssh_cmd)).to be_false end end end end describe :exec_cmd do let(:shell) { GitlabShell.new(key_id) } before { Kernel.stub(:exec) } it "uses Kernel::exec method" do Kernel.should_receive(:exec).with(kind_of(Hash), 1, 2, unsetenv_others: true).once shell.send :exec_cmd, 1, 2 end it "refuses to execute a lone non-array argument" do expect { shell.send :exec_cmd, 1 }.to raise_error(GitlabShell::DisallowedCommandError) end it "allows one argument if it is an array" do Kernel.should_receive(:exec).with(kind_of(Hash), [1, 2], unsetenv_others: true).once shell.send :exec_cmd, [1, 2] end context "when specifying a git_tracing log file" do let(:git_trace_log_file) { '/tmp/git_trace_performance.log' } before do GitlabConfig.any_instance.stub(git_trace_log_file: git_trace_log_file) shell end it "uses GIT_TRACE_PERFORMANCE" do expected_hash = hash_including( 'GIT_TRACE' => git_trace_log_file, 'GIT_TRACE_PACKET' => git_trace_log_file, 'GIT_TRACE_PERFORMANCE' => git_trace_log_file ) Kernel.should_receive(:exec).with(expected_hash, [1, 2], unsetenv_others: true).once shell.send :exec_cmd, [1, 2] end context "when provides a relative path" do let(:git_trace_log_file) { 'git_trace_performance.log' } it "does not uses GIT_TRACE*" do # If we try to use it we'll show a warning to the users expected_hash = hash_excluding( 'GIT_TRACE', 'GIT_TRACE_PACKET', 'GIT_TRACE_PERFORMANCE' ) Kernel.should_receive(:exec).with(expected_hash, [1, 2], unsetenv_others: true).once shell.send :exec_cmd, [1, 2] end it "writes an entry on the log" do expect($logger).to receive(:warn). with("gitlab-shell: is configured to trace git commands with #{git_trace_log_file.inspect} but an absolute path needs to be provided") Kernel.should_receive(:exec).with(kind_of(Hash), [1, 2], unsetenv_others: true).once shell.send :exec_cmd, [1, 2] end end context "when provides a file not writable" do before do expect(File).to receive(:open).with(git_trace_log_file, 'a').and_raise(Errno::EACCES) end it "does not uses GIT_TRACE*" do # If we try to use it we'll show a warning to the users expected_hash = hash_excluding( 'GIT_TRACE', 'GIT_TRACE_PACKET', 'GIT_TRACE_PERFORMANCE' ) Kernel.should_receive(:exec).with(expected_hash, [1, 2], unsetenv_others: true).once shell.send :exec_cmd, [1, 2] end it "writes an entry on the log" do expect($logger).to receive(:warn). with("gitlab-shell: is configured to trace git commands with #{git_trace_log_file.inspect} but it's not possible to write in that path Permission denied") Kernel.should_receive(:exec).with(kind_of(Hash), [1, 2], unsetenv_others: true).once shell.send :exec_cmd, [1, 2] end end end end describe :api do let(:shell) { GitlabShell.new(key_id) } subject { shell.send :api } it { should be_a(GitlabNet) } end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/httpunix_spec.rb000066400000000000000000000036261277744601700262260ustar00rootroot00000000000000require_relative 'spec_helper' require_relative '../lib/httpunix' require 'webrick' describe URI::HTTPUNIX do describe :parse do uri = URI::parse('http+unix://%2Fpath%2Fto%2Fsocket/img.jpg') subject { uri } it { should be_an_instance_of(URI::HTTPUNIX) } its(:scheme) { should eq('http+unix') } its(:hostname) { should eq('/path/to/socket') } its(:path) { should eq('/img.jpg') } end end # like WEBrick::HTTPServer, but listens on UNIX socket class HTTPUNIXServer < WEBrick::HTTPServer def listen(address, port) socket = Socket.unix_server_socket(address) socket.autoclose = false server = UNIXServer.for_fd(socket.fileno) socket.close @listeners << server end # Workaround: # https://bugs.ruby-lang.org/issues/10956 # Affecting Ruby 2.2 # Fix for 2.2 is at https://github.com/ruby/ruby/commit/ab0a64e1 # However, this doesn't work with 2.1. The following should work for both: def start(&block) @shutdown_pipe = IO.pipe shutdown_pipe = @shutdown_pipe super(&block) end def cleanup_shutdown_pipe(shutdown_pipe) @shutdown_pipe = nil return if !shutdown_pipe super(shutdown_pipe) end end def tmp_socket_path File.join(ROOT_PATH, 'tmp', 'socket') end describe Net::HTTPUNIX do # "hello world" over unix socket server in background thread FileUtils.mkdir_p(File.dirname(tmp_socket_path)) server = HTTPUNIXServer.new(:BindAddress => tmp_socket_path) server.mount_proc '/' do |req, resp| resp.body = "Hello World (at #{req.path})" end Thread.start { server.start } it "talks via HTTP ok" do VCR.turned_off do begin WebMock.allow_net_connect! http = Net::HTTPUNIX.new(tmp_socket_path) expect(http.get('/').body).to eq('Hello World (at /)') expect(http.get('/path').body).to eq('Hello World (at /path)') ensure WebMock.disable_net_connect! end end end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/names_helper_spec.rb000066400000000000000000000011141277744601700267730ustar00rootroot00000000000000require 'spec_helper' require 'names_helper' describe NamesHelper do include NamesHelper describe :extract_repo_name do it { extract_repo_name(' /opt/repos/randx/gitlab.git').should == 'randx/gitlab' } it { extract_repo_name("/opt/repos/randx/gitlab.git\r\n").should == 'randx/gitlab' } end describe :extract_ref_name do it { extract_ref_name('refs/heads/awesome-feature').should == 'awesome-feature' } it { extract_ref_name('refs/tags/v2.2.1').should == 'v2.2.1' } it { extract_ref_name('refs/tags/releases/v2.2.1').should == 'releases/v2.2.1' } end end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/spec_helper.rb000066400000000000000000000005241277744601700256140ustar00rootroot00000000000000ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), "..")) if ENV['COVERALLS'] require 'coveralls' Coveralls.wear! else require 'simplecov' SimpleCov.start end require 'vcr' require 'webmock' VCR.configure do |c| c.cassette_library_dir = 'spec/vcr_cassettes' c.hook_into :webmock c.configure_rspec_metadata! end gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/support/000077500000000000000000000000001277744601700245115ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/support/gl_id_test_hook000077500000000000000000000000551277744601700275740ustar00rootroot00000000000000#!/bin/sh printenv GL_ID | grep -q '^key_1$' gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/000077500000000000000000000000001277744601700256455ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/allowed-pull.yml000066400000000000000000000023211277744601700307670ustar00rootroot00000000000000--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-receive-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&key_id=126&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:36 GMT Content-Type: - application/json Content-Length: - '4' Connection: - keep-alive Status: - 200 OK Etag: - '"b326b5062b2f0e69046810717534cb09"' Cache-Control: - max-age=0, private, must-revalidate X-Request-Id: - 85bfa9b3-fddc-4810-a033-f1eabc04c66c X-Runtime: - '0.089741' body: encoding: UTF-8 string: '{"status": "true"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:36 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/allowed-push.yml000066400000000000000000000023201277744601700307710ustar00rootroot00000000000000--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-upload-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&key_id=126&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:37 GMT Content-Type: - application/json Content-Length: - '4' Connection: - keep-alive Status: - 200 OK Etag: - '"b326b5062b2f0e69046810717534cb09"' Cache-Control: - max-age=0, private, must-revalidate X-Request-Id: - 115e7a72-b3a6-49e1-b531-980c71088c9d X-Runtime: - '0.833195' body: encoding: UTF-8 string: '{"status": "true"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:37 GMT recorded_with: VCR 2.4.0 broadcast_message-none.yml000066400000000000000000000014071277744601700327160ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/broadcast_message body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby response: status: code: 200 message: Not Found headers: Server: - nginx/1.1.19 Date: - Sat, 07 Feb 2015 16:45:35 GMT Content-Type: - application/json Content-Length: - '27' Connection: - keep-alive Status: - 200 OK body: encoding: UTF-8 string: '{}' http_version: recorded_at: Sat, 07 Feb 2015 16:45:35 GMT recorded_with: VCR 2.4.0 broadcast_message-ok.yml000066400000000000000000000015651277744601700323750ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/broadcast_message body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Sat, 07 Feb 2015 16:44:35 GMT Content-Type: - application/json Content-Length: - '118' Connection: - keep-alive Status: - 200 OK body: encoding: UTF-8 string: '{"message":"Message","starts_at":"2015-02-07T15:35:00.000Z","ends_at":"2015-02-07T16:35:00.000Z","color":"","font":""}' http_version: recorded_at: Sat, 07 Feb 2015 16:44:35 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/check-ok.yml000066400000000000000000000020311277744601700300500ustar00rootroot00000000000000--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/check body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:35 GMT Content-Type: - application/json Content-Length: - '72' Connection: - keep-alive Status: - 200 OK Etag: - '"23ee74bf6981b57b9d0e0d8a91f3ec1b"' Cache-Control: - max-age=0, private, must-revalidate X-Request-Id: - c389e282-4d7b-4041-9aed-336e5b007424 X-Runtime: - '0.958718' body: encoding: UTF-8 string: '{"api_version":"v3","gitlab_version":"7.3.0.pre","gitlab_rev":"e8f1331"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:35 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/denied-pull.yml000066400000000000000000000022441277744601700305740ustar00rootroot00000000000000--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-receive-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&key_id=2&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 404 message: Not Found headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:38 GMT Content-Type: - application/json Content-Length: - '27' Connection: - keep-alive Status: - 404 Not Found Cache-Control: - no-cache X-Request-Id: - f9c23a82-be65-41c8-958a-5f3e1b9aa58b X-Runtime: - '0.028027' body: encoding: UTF-8 string: '{"status": false, "message":"404 Not found"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:38 GMT recorded_with: VCR 2.4.0 denied-push-with-user.yml000066400000000000000000000023161277744601700324450ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-upload-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&user_id=1&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:39 GMT Content-Type: - application/json Content-Length: - '4' Connection: - keep-alive Status: - 200 OK Etag: - '"b326b5062b2f0e69046810717534cb09"' Cache-Control: - max-age=0, private, must-revalidate X-Request-Id: - 8bd01f76-6029-4921-ba97-12323a7d5750 X-Runtime: - '0.019640' body: encoding: UTF-8 string: '{"status": false}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:39 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/denied-push.yml000066400000000000000000000022431277744601700305760ustar00rootroot00000000000000--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-upload-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&key_id=2&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 404 message: Not Found headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:38 GMT Content-Type: - application/json Content-Length: - '27' Connection: - keep-alive Status: - 404 Not Found Cache-Control: - no-cache X-Request-Id: - 8b0210d2-4db5-4325-8120-740e22eaf7d5 X-Runtime: - '0.015198' body: encoding: UTF-8 string: '{"status": false, "message":"404 Not found"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:38 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/discover-ok.yml000066400000000000000000000020271277744601700306160ustar00rootroot00000000000000--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/discover?key_id=126 body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:35 GMT Content-Type: - application/json Content-Length: - '56' Connection: - keep-alive Status: - 200 OK Etag: - '"1d75c1cf3d4bfa4d2b7bb6a0bcfd7f55"' Cache-Control: - max-age=0, private, must-revalidate X-Request-Id: - ef4513ae-0424-4941-8be0-b5a3a7b4bf12 X-Runtime: - '0.016934' body: encoding: UTF-8 string: '{"name":"Dmitriy Zaporozhets","username":"dzaporozhets"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:35 GMT recorded_with: VCR 2.4.0 http-access-disabled.yml000066400000000000000000000022141277744601700322730ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-receive-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&protocol=http&key_id=2&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Cache-Control: - no-cache Content-Length: - '30' Content-Type: - application/json Date: - Wed, 22 Jun 2016 01:03:41 GMT Status: - 200 OK Vary: - Origin X-Request-Id: - 55b7af2c-3559-41d2-b301-9b86ad1d8fac X-Runtime: - '2.280895' body: encoding: UTF-8 string: '{"status": false, "message":"Git access over HTTP is not allowed"}' http_version: recorded_at: Wed, 22 Jun 2016 01:03:41 GMT recorded_with: VCR 2.4.0lfs-authenticate-ok.yml000066400000000000000000000021761277744601700321660ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/lfs_authenticate body: encoding: US-ASCII string: project=gitlab%2Fgitlabhq&key_id=126&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:35 GMT Content-Type: - application/json Content-Length: - '56' Connection: - keep-alive Status: - 200 OK Etag: - '"1d75c1cf3d4bfa4d2b7bb6a0bcfd7f55"' Cache-Control: - max-age=0, private, must-revalidate X-Request-Id: - ef4513ae-0424-4941-8be0-b5a3a7b4bf12 X-Runtime: - '0.016934' body: encoding: UTF-8 string: '{"username":"dzaporozhets","lfs_token":"wsnys8Zm8Jn7zyhHTAAK","repository_http_path":"http://gitlab.dev/gitlab/gitlabhq.git"}' http_version: recorded_at: Wed, 03 Sep 2014 11:27:35 GMT recorded_with: VCR 2.4.0 ssh-access-disabled.yml000066400000000000000000000022121277744601700321070ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/allowed body: encoding: US-ASCII string: action=git-receive-pack&changes=0000000000000000000000000000000000000000+92d0970eefd7acb6d548878925ce2208cfe2d2ec+refs%2Fheads%2Fbranch4&project=gitlab%2Fgitlabhq&protocol=ssh&key_id=2&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Cache-Control: - no-cache Content-Length: - '30' Content-Type: - application/json Date: - Wed, 22 Jun 2016 01:01:41 GMT Status: - 200 OK Vary: - Origin X-Request-Id: - 55b7af2c-3559-41d2-b301-9b86ad1d8fac X-Runtime: - '2.280895' body: encoding: UTF-8 string: '{"status": false, "message":"Git access over SSH is not allowed"}' http_version: recorded_at: Wed, 22 Jun 2016 01:01:41 GMT recorded_with: VCR 2.4.0 ssh-key-not-found.yml000066400000000000000000000022511277744601700316030ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/authorized_keys?key=whatever body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 404 message: Not Found headers: Server: - nginx Date: - Mon, 07 Mar 2016 12:09:59 GMT Content-Type: - text/html; charset=utf-8 Connection: - keep-alive Cache-Control: - no-cache Set-Cookie: - _gitlab_session=a924e63729e538c9efe10fa8338077d7; path=/; expires=Mon, 14 Mar 2016 12:09:59 -0000; secure; HttpOnly Status: - 404 Not Found X-Content-Type-Options: - nosniff X-Frame-Options: - SAMEORIGIN X-Request-Id: - 275ad011-515f-4239-80be-e537fd7c9086 X-Runtime: - '2.169401' X-Xss-Protection: - 1; mode=block http_version: recorded_at: Mon, 07 Mar 2016 12:10:00 GMT recorded_with: VCR 2.4.0 ssh-key-not-implemented.yml000066400000000000000000000022651277744601700330000ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/authorized_keys?key=whatever body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 501 message: Not Implemented headers: Server: - nginx Date: - Mon, 07 Mar 2016 12:09:59 GMT Content-Type: - text/html; charset=utf-8 Connection: - keep-alive Cache-Control: - no-cache Set-Cookie: - _gitlab_session=a924e63729e538c9efe10fa8338077d7; path=/; expires=Mon, 14 Mar 2016 12:09:59 -0000; secure; HttpOnly Status: - 501 Not Implemented X-Content-Type-Options: - nosniff X-Frame-Options: - SAMEORIGIN X-Request-Id: - 275ad011-515f-4239-80be-e537fd7c9086 X-Runtime: - '2.169401' X-Xss-Protection: - 1; mode=block http_version: recorded_at: Mon, 07 Mar 2016 12:10:00 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes/ssh-key-ok.yml000066400000000000000000000020711277744601700303620ustar00rootroot00000000000000--- http_interactions: - request: method: get uri: https://dev.gitlab.org/api/v3/internal/authorized_keys?key=AAAAB3NzaC1yc2EAAAADAQABAAACAQDPKPqqnqQ9PDFw65cO7iHXrKw6ucSZg8Bd2CZ150Yy1YRDPJOWeRNCnddS+M/Lk body: encoding: US-ASCII string: secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Server: - nginx/1.1.19 Date: - Wed, 03 Sep 2014 11:27:35 GMT Content-Type: - application/json Connection: - keep-alive Status: - 200 OK Cache-Control: - max-age=0, private, must-revalidate body: encoding: UTF-8 string: '{"id":2, "title":"some key title", "key":"ssh-rsa a-made=up-rsa-key dummy@gitlab.com", "created_at":"2016-03-04T18:27:36.959Z"}' http_version: recorded_at: Mon, 07 Mar 2016 12:10:00 GMT recorded_with: VCR 2.4.0 two-factor-recovery-codes-fail.yml000066400000000000000000000017161277744601700342430ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/two_factor_recovery_codes body: encoding: US-ASCII string: username=user-1&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Server: - nginx Date: - Tue, 16 Aug 2016 22:10:11 GMT Content-Type: - application/json Connection: - keep-alive Status: - 200 OK X-Request-Id: - 4467029d-51c6-41bc-af5f-6da279dbb238 X-Runtime: - '0.004589' body: encoding: UTF-8 string: '{ "success": false, "message": "Could not find the given key" }' http_version: recorded_at: Tue, 16 Aug 2016 22:10:11 GMT recorded_with: VCR 2.4.0 two-factor-recovery-codes.yml000066400000000000000000000017351277744601700333330ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/spec/vcr_cassettes--- http_interactions: - request: method: post uri: https://dev.gitlab.org/api/v3/internal/two_factor_recovery_codes body: encoding: US-ASCII string: username=user-1&secret_token=a123 headers: Accept-Encoding: - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 Accept: - "*/*" User-Agent: - Ruby Content-Type: - application/x-www-form-urlencoded response: status: code: 200 message: OK headers: Server: - nginx Date: - Tue, 16 Aug 2016 22:10:11 GMT Content-Type: - application/json Connection: - keep-alive Status: - 200 OK X-Request-Id: - 4467029d-51c6-41bc-af5f-6da279dbb238 X-Runtime: - '0.004589' body: encoding: UTF-8 string: '{ "success": true, "recovery_codes": ["f67c514de60c4953","41278385fc00c1e0"] }' http_version: recorded_at: Tue, 16 Aug 2016 22:10:11 GMT recorded_with: VCR 2.4.0 gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/support/000077500000000000000000000000001277744601700235575ustar00rootroot00000000000000gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/support/rewrite-hooks.sh000077500000000000000000000002431277744601700267170ustar00rootroot00000000000000#!/bin/bash # This script is deprecated. Use bin/create-hooks instead. gitlab_shell_dir="$(cd $(dirname $0) && pwd)/.." exec ${gitlab_shell_dir}/bin/create-hooks gitlab-shell-v3.6.6-0cc6cfc11be21597b11470c1c1aaa7e4a92618db/support/truncate_repositories.sh000077500000000000000000000007721277744601700305600ustar00rootroot00000000000000#!/bin/bash # $1 is an optional argument specifying the location of the repositories directory. # Defaults to /home/git/repositories if not provided home_dir="/home/git/repositories" src=${1:-"$home_dir"} echo "Danger!!! Data Loss" while true; do read -p "Do you wish to delete all directories from $home_dir/ (y/n) ?: " yn case $yn in [Yy]* ) sh -c "find $home_dir/. -maxdepth 1 -not -name '.' | xargs rm -rf"; break;; [Nn]* ) exit;; * ) echo "Please answer yes or no.";; esac done