gitroom 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  metadata.gz: 9b70a187ec96be19efadab5ec788a0b12695cf2e3b909fa00cb652a8967919f0033839a95391bb578a26171b73cceca5152867ac246b99edad2fa82bdb77109a
+  data.tar.gz: f4c16482a278339f43310ceb14d6b279d8aa75918985bc51e09d6257c15d7f0f4353a09459d766d0a2d1e3ebfd06eb823db46b018d1c9b204ccbff992d71376a
+SHA1: 
+  metadata.gz: 8a10e96a237e14edb7fec3a971c7fbbadb7cb112
+  data.tar.gz: aaaf090b281e4875d6beec32b4c7ea0d6e9d79fc

data/bin/gitfs

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby -rubygems
+
+require 'gitroom/connect'
+connect
+
+require 'gitroom/mounter'
+require 'rfuse'
+
+if ARGV.length == 0
+  print "\n"
+  print "Usage: [ruby [--debug]] #{$0} mountpoint [mount_options...]\n"
+  print "\n"
+  print "   mountpoint must be an existing directory\n"
+  print "   mount_option '-h' will list supported options\n"
+  print "\n"
+  print "   For verbose debugging output use --debug to ruby\n"
+  print "   and '-odebug' as mount_option\n"
+  print "\n"
+  exit(1)
+end
+
+building = GitRoom::Mounter.new
+
+fo = RFuse::FuseDelegator.new building, *ARGV
+
+if fo.mounted?
+  Signal.trap("TERM") { print "Caught TERM\n" ; fo.exit }
+  Signal.trap("INT") { print "Caught INT\n"; fo.exit }
+
+  begin
+    fo.loop
+  rescue
+    print "Error: #{$!}\n"
+  ensure
+    fo.unmount if fo.mounted?
+    print "Unmounted #{ARGV[0]}\n"
+  end
+end

data/bin/gitserve

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'gitroom'
+
+GitRoom::Server.serve ARGV.shift

data/lib/gitroom.rb

@@ -0,0 +1,5 @@
+require 'gitroom/mounter'
+require 'gitroom/server'
+
+module GitRoom
+end

data/lib/gitroom/admin.rb

@@ -0,0 +1,33 @@
+require 'gitroom/connect'
+connect
+
+require 'gitroom/models/node'
+require 'gitroom/models/log'
+
+module GitRoom
+  class Admin
+    attr_accessor :list
+
+    def find(regex_string = '')
+      @list = Node.where 'path ~ ?', regex_string
+    end
+
+    def pluck
+      @list.pluck :path
+    end
+
+    def delete
+      @list.each { |x| x.destroy }
+    end
+
+    def logs
+      Log.pluck :data
+    end
+
+    def logs!
+      res = logs
+      Log.destroy_all
+      res
+    end
+  end
+end

data/lib/gitroom/concerns/node_cached.rb

@@ -0,0 +1,108 @@
+require 'gitroom/models/node'
+require 'yaml'
+
+class Integer
+  def minutes
+    self * 60
+  end
+end
+
+module NodeCached
+  CACHE_FILES = 16384
+  MAX_FILE_SIZE = 65536
+  EXPIRE_TIME = 1.minutes
+  READ_SCORE = 2
+  WRITE_SCORE = -7
+
+  # redis.expire key, seconds
+
+  def find_cached_node(path)
+    present = cached_node_present? path
+    if present.nil? || present == 'true'
+      node = Node.where(:path => path).first
+      if node && present.nil?
+        cached_node_present! path
+      elsif !node
+        cached_node_absent! path
+      end
+      node
+    end
+  end
+
+  def read_cached_node(node, size, offset)
+    path = node.path
+    cached_file_rank_change! path, READ_SCORE
+    rank = cached_file_rank path
+    content = cached_file_content path
+    if content
+      print "CACHE HIT :: #{path}\n"
+      res = content[offset...offset + size]
+      if rank < CACHE_FILES
+        cached_file_content_touch! path, EXPIRE_TIME
+      end
+    else
+      print "DATABASE HIT :: #{path}\n"
+      content = node.get_full_content
+      full_size = content.size
+      if rank < CACHE_FILES && full_size < MAX_FILE_SIZE
+        res = content[offset...offset + size]
+        cache_file! path, content
+        cached_file_content_touch! path, EXPIRE_TIME
+      else
+        res = node.get_content offset, size
+      end
+    end
+    res
+  end
+
+  def write_cached_node(node, buf, offset)
+    path = node.path
+    cached_file_rank_change! path, WRITE_SCORE
+    cached_file_clean! path
+    node.set_content offset, buf
+    # read_cached_node node, buf.size, offset
+  end
+
+  def cached_node_present!(path)
+    redis.set "cache::node::#{path}::present?", 'true'
+  end
+
+  def cached_node_absent!(path)
+    redis.set "cache::node::#{path}::present?", 'false'
+    redis.del "cache::file::#{path}::content"
+    redis.zrem "cache::files::ranks", path
+  end
+
+  def cached_node_present?(path)
+    redis.get "cache::node::#{path}::present?"
+  end
+
+  def cached_file_rank_change!(path, incr)
+    redis.zincrby "cache::files::ranks", incr, path
+  end
+
+  def cached_file_rank(path)
+    redis.zrevrank "cache::files::ranks", path
+  end
+
+  def cached_file_content(path)
+    content = redis.get "cache::file::#{path}::content"
+    content && YAML.load(content)
+  end
+
+  def cache_file!(path, content)
+    redis.set "cache::file::#{path}::content", content.to_yaml
+  end
+
+  def cached_file_content_expires(path)
+    redis.ttl "cache::file::#{path}::content"
+  end
+
+  def cached_file_content_touch!(path, time)
+    redis.expire "cache::file::#{path}::content", time
+  end
+
+  def cached_file_clean!(path)
+    redis.del "cache::file::#{path}::content"
+  end
+end

data/lib/gitroom/connect.rb

@@ -0,0 +1,23 @@
+class Object
+  attr_accessor :redis_connection
+
+  def redis
+    Object.redis_connection
+  end
+end
+
+def connect
+  require 'yaml'
+  require 'active_record'
+  require 'redis'
+
+  env = ENV['ENVIRONMENT'] || 'development'
+
+  ar_connection = YAML.load_file('config/database.yml')[env]
+
+  ActiveRecord::Base.establish_connection ar_connection
+
+  red_connection = YAML.load_file('config/redis.yml')[env]
+
+  Object.redis_connection = Redis.new red_connection
+end

data/lib/gitroom/models/binary_file.rb

@@ -0,0 +1,6 @@
+require 'active_record'
+require 'gitroom/models/node'
+
+class BinaryFile < ActiveRecord::Base
+  has_one :node
+end

data/lib/gitroom/models/chunk.rb

@@ -0,0 +1,6 @@
+require 'active_record'
+require 'gitroom/models/node'
+
+class Chunk < ActiveRecord::Base
+  belongs_to :node
+end

data/lib/gitroom/models/log.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+
+class Log < ActiveRecord::Base
+end

data/lib/gitroom/models/node.rb

@@ -0,0 +1,194 @@
+require 'active_record'
+require 'json'
+require 'gitroom/models/chunk'
+
+class Node < ActiveRecord::Base
+  CHUNK_SIZE = 16384
+
+  has_many :nodes, :dependent => :destroy
+  belongs_to :node
+
+  has_many :chunks, :dependent => :destroy
+
+  def stat
+    if directory
+      RFuse::Stat.directory mode,:uid => uid, :gid => gid, :atime => updated_at,
+                            :mtime => updated_at, :size => 48
+    else
+      RFuse::Stat.file mode,:uid => uid, :gid => gid, :atime => updated_at,
+                       :mtime => updated_at, :size => content_size
+    end
+  end
+
+  def getxattr(name)
+    JSON.parse(xattrs)[name]
+  end
+
+  def setxattr(name, value, flag)
+    json = JSON.parse(xattrs)
+    json[name] = value
+    xattrs = json.to_s
+  end
+
+  def removexattr(name)
+    json = JSON.parse(xattrs)
+    json.delete name
+    xattrs = json.to_s
+  end
+
+  def listxattr
+    JSON.parse(xattrs).keys
+  end
+
+  def get_chunk(number, offset = 0, right = CHUNK_SIZE - 1)
+    chunk = chunks.where(:chunk_number => number).first
+    chunk && chunk.content[offset..right] || ''
+  end
+
+  def get_chunk_cached(chunk, offset = 0, right = CHUNK_SIZE - 1)
+    chunk && chunk.content[offset..right] || ''
+  end
+
+  def set_chunk(number, buf, offset = 0)
+    chunk = chunks.where(:chunk_number => number).first
+    unless chunk
+      chunk = chunks.create! :chunk_number => number, :node_id => id, :content => ""
+    end
+    if chunk.content.size < offset+buf.size
+      chunk.content += "\0" * (offset + buf.size - chunk.content.size)
+    end
+    chunk.content[offset...offset+buf.size] = buf
+    rechunk = Chunk.find chunk.id
+    rechunk.content = chunk.content.to_s
+    rechunk.save!
+  end
+
+  def get_content(offset, size)
+    num_start = offset / CHUNK_SIZE
+    offset_start = offset % CHUNK_SIZE
+    num_end = (offset + size - 1) / CHUNK_SIZE
+    offset_end = (offset + size - 1) % CHUNK_SIZE
+    content = ''
+    cached_chunks = chunks.where('chunk_number >= ? and chunk_number <= ?', num_start, num_end).order('chunk_number asc')
+    # (num_start..num_end).to_a.each do |num|
+    cached_chunks.each do |chunk|
+      num = chunk.chunk_number
+      offset = num == num_start ? offset_start : 0
+      right = num == num_end ? offset_end : (CHUNK_SIZE - 1)
+      content += get_chunk_cached chunk, offset, right
+    end
+    content
+  end
+
+  def get_full_content
+    chunks.order('chunk_number asc').pluck(:content).join
+  end
+
+  def set_content(offset, buf)
+    size = buf.size
+    num_start = offset / CHUNK_SIZE
+    offset_start = offset % CHUNK_SIZE
+    num_end = (offset + size - 1) / CHUNK_SIZE
+    offset_end = (offset + size - 1) % CHUNK_SIZE
+    (num_start..num_end).to_a.each do |num|
+      offset = num == num_start ? offset_start : 0
+      data_offset = num == num_start ? 0 : ((num - num_start) * CHUNK_SIZE - offset_start)
+      data_right = num == num_end ? -1 : (data_offset + CHUNK_SIZE - 1)
+      set_chunk num, buf[data_offset..data_right], offset
+    end
+    buf.size
+  end
+
+  # def get_content(offset, size)
+  #   print 'A'
+  #   num_start = offset / CHUNK_SIZE
+  #   offset_start = offset % CHUNK_SIZE
+  #   num_end = (offset + size - 1) / CHUNK_SIZE
+  #   offset_end = (offset + size - 1) % CHUNK_SIZE
+  #   print 'B'
+  #   selected_chunks = chunks.where('chunk_number >= ? and chunk_number <= ?', num_start, num_end)
+  #   selected_chunks = selected_chunks.pluck(:content)
+  #   print 'C'
+  #   if num_start == num_end || selected_chunks.size == 1
+  #     print 'D0'
+  #     selected_chunks[0] = selected_chunks[offset_start..offset_end]
+  #   else
+  #     print 'D1'
+  #     selected_chunks[0] = selected_chunks[offset_start..-1]
+  #     selected_chunks[-1] = selected_chunks[0..offset_end] if selected_chunks.count == num_end - num_start + 1
+  #   end
+  #   print 'E'
+  #   res = selected_chunks.join
+  #   print "F: #{res}"
+  #   res
+  # end
+
+  # def set_content(offset, buf)
+  #   print "\nset_content #{offset}, #{buf.size}:: \n#{buf}\n"
+  #   Chunk.transaction do
+  #     size = buf.size
+  #     num_start = offset / CHUNK_SIZE
+  #     offset_start = offset % CHUNK_SIZE
+  #     num_end = (offset + size - 1) / CHUNK_SIZE
+  #     offset_end = (offset + size - 1) % CHUNK_SIZE
+  #     chunk_count = chunks.count
+  #     last_chunk = chunks.last
+  #     if chunk_count <= num_end
+  #       if last_chunk && last_chunk.content.size < CHUNK_SIZE
+  #         last_chunk.content += "\0" * (CHUNK_SIZE - last_chunk.content.size)
+  #         rechunk = Chunk.find last_chunk.id
+  #         rechunk.content = last_chunk.content.to_s
+  #         rechunk.save!
+  #       end
+  #       while chunk_count <= num_end
+  #         content = "\0" * (chunk_count == num_end ? offset_end + 1 : CHUNK_SIZE)
+  #         chunks.create! :chunk_number => chunk_count, :node_id => id, :content => content
+  #         chunk_count += 1
+  #       end
+  #     end
+  #     selected_chunks = chunks.order('chunk_number asc').where('chunk_number >= ? and chunk_number <= ?', num_start, num_end)
+  #     if num_start == num_end
+  #       if selected_chunks[0].content.size <= offset_end
+  #         selected_chunks[0].content += "\0" * (offset_end + 1 - selected_chunks[0].content.size)
+  #       end
+  #       selected_chunks[0].content[offset_start..offset_end] = buf
+  #     else
+  #       selected_chunks[0].content[offset_start..-1] = buf[0..CHUNK_SIZE - offset_start - 1]
+  #       selected_chunks[-1].content[0..offset_end] = buf[-1 - offset_end..-1]
+
+  #       selected_chunks[1...-1].each do |chunk|
+  #         num = chunk.chunk_number - num_start
+  #         chunk.content = buf[num*CHUNK_SIZE...(num+1)*CHUNK_SIZE]
+  #       end
+  #     end
+  #     print "\n"
+  #     selected_chunks.each do |chunk|
+  #       rechunk = Chunk.find chunk.id
+  #       rechunk.content = chunk.content.to_s
+  #       print "set_content #{chunk.chunk_number} :: #{chunk.content}\n"
+  #       rechunk.save!
+  #     end
+  #     print "\n"
+  #   end
+  # end
+
+  def content_size
+    if chunks.count == 0
+      0
+    else
+      (chunks.count - 1) * CHUNK_SIZE + chunks.order('chunk_number asc').last.content.size
+    end
+  end
+
+  def truncate_content(offset)
+    Chunk.transaction do
+      num_end = (offset) / CHUNK_SIZE
+      offset_end = (offset) % CHUNK_SIZE
+      selected_chunks = chunks.where('chunk_number > ?', num_end)
+      selected_chunks.each { |chunk| chunk.destroy }
+      last_chunk = chunks.last
+      last_chunk.content = last_chunk.content[0..offset_end]
+      last_chunk.save
+    end
+  end
+end

data/lib/gitroom/mounter.rb

@@ -0,0 +1,232 @@
+require 'git'
+require 'yaml'
+require 'rfuse'
+require 'gitroom/models/node'
+require 'gitroom/models/log'
+require 'test/unit/assertions'
+require 'gitroom/concerns/node_cached'
+
+module GitRoom
+  class Mounter
+    include Test::Unit::Assertions
+    include NodeCached
+
+    def readdir(ctx, path, filler, offset, ffi)
+      find_node path
+      @node.nodes.each do |node|
+        filler.push node.name, node.stat, 0
+      end
+    end
+
+    def getattr(ctx, path)
+      find_node path
+      begin
+        @node.stat
+      rescue
+        print "Unexpected in stat #{path}"
+        enoent(path)
+      end
+    end
+
+    def mkdir(ctx, path, mode)
+      update_node path, mode
+      cached_node_present! path
+    end
+
+    def mknod(ctx, path, mode, major, minor)
+      update_node path, mode, ctx.uid, ctx.gid, false, ''
+      cached_node_present! path
+    end
+
+    def open(ctx, path, ffi)
+    end
+
+    def chmod(ctx, path, mode)
+      find_node path
+      @node.update_attributes! :mode => mode
+    end
+
+    def chown(ctx, path, uid, gid)
+      find_node path
+      @node.update_attributes! :uid => uid, :gid => gid
+    end
+
+    def truncate(ctx, path, offset)
+      find_node path
+      # @node.update_attributes! :content => @node.content[0..offset]
+      @node.truncate_content offset
+    end
+
+    def utime(ctx, path, actime, modtime)
+      find_node path
+      @node.update_attributes! :updated_at => Time.at([actime, modtime].max)
+    end
+
+    def unlink(ctx, path)
+      find_node path
+      @node.destroy
+      cached_node_absent! path
+    end
+
+    def rmdir(ctx, path)
+      find_node path
+      @node.destroy
+      cached_node_absent! path
+    end
+
+    # TODO:: Make symlink and link methods
+
+    # def symlink(ctx, path, as)
+    # end
+
+    # def link(ctx, path, as)
+    # end
+
+    def rename(ctx, path, as)
+      find_node path
+      move_node(@node, as)
+      cached_node_absent! path
+      cached_node_absent! as
+      cached_node_present! as
+    end
+
+    def read(ctx, path, size, offset, fi)
+      find_node path
+      eisdir(path) if @node.directory
+      res = ''
+      begin
+        res = read_cached_node @node, size, offset
+      rescue
+        print "Unexpected in read #{path}: #{$!}\n"
+        enoent(path)
+      end
+      res
+    end
+
+    def write(ctx, path, buf, offset, fi)
+      find_node path
+      eisdir(path) if @node.directory
+      begin
+        write_cached_node @node, buf, offset
+      rescue
+        print "Unexpected in write #{path}: #{$!}\n"
+        enoent(path)
+      end
+      buf.size
+    end
+
+    def setxattr(ctx, path, name, value, size, flags)
+      find_node path
+      @node.setxattr name, value, flags
+    end
+
+    def getxattr(ctx, path, name)
+      find_node path
+      @node.getxattr(name) || ''
+    end
+
+    def listxattr(ctx, path)
+      find_node path
+      @node.listxattr
+    end
+
+    def removexattr(ctx, path, name)
+      find_node path
+      @node.removexattr name
+    end
+
+
+    def statfs(ctx,path)
+      s = RFuse::StatVfs.new
+      s.f_bsize    = 1024
+      s.f_frsize   = 1024
+      s.f_blocks   = 1000000
+      s.f_bfree    = 500000
+      s.f_bavail   = 990000
+      s.f_files    = 10000
+      s.f_ffree    = 9900
+      s.f_favail   = 9900
+      s.f_fsid     = 23423
+      s.f_flag     = 0
+      s.f_namemax  = 10000
+      return s
+    end
+
+    def ioctl(ctx, path, cmd, arg, ffi, flags, data)
+      # FT: I was not been able to test it.
+      print "*** IOCTL: command: ", cmd, "\n"
+    end
+
+    def poll(ctx, path, ffi, ph, reventsp)
+      print "*** POLL: ", path, "\n"
+      # This is how we notify the caller if something happens:
+      ph.notifyPoll
+      # when the GC harvests the object it calls fuse_pollhandle_destroy
+      # by itself.
+    end
+
+    def init(ctx,rfuseconninfo)
+      print "RFuse TestFS started\n"
+      print "init called\n"
+      print "proto_major:#{rfuseconninfo.proto_major}\n"
+    end
+
+    private
+
+    def find_node(path, ignore = false)
+      @node = nil
+      # @node = Node.where(:path => path).first
+      @node = find_cached_node(path)
+      enoent(path) if @node.nil? && !ignore
+      @node
+    end
+
+    def update_node(path, mode, uid = nil, gid = nil, directory = true, content = nil)
+      nodes = split_dirnode(path)
+      uid ||= nodes[:dirnode].uid
+      gid ||= nodes[:dirnode].gid
+      nodes[:node] ||= if directory
+        Node.create! :name => nodes[:name], :path => path, :directory => true,
+                     :node_id => nodes[:dirnode].id, :mode => mode,
+                     :uid => uid, :gid => gid
+      else
+        Node.create! :name => nodes[:name], :path => path, :directory => false,
+                         :node_id => nodes[:dirnode].id, :mode => mode
+      end
+    end
+
+    def split_dirpath(path)
+      pathname = Pathname.new path
+      { :name => pathname.basename.to_s, :dirname => pathname.dirname.to_s }
+    end
+
+    def split_dirnode(path)
+      names = split_dirpath path
+      node = find_node path, true
+      dirnode = find_node names[:dirname]
+      enotdir(path) unless dirnode.directory
+      { :node => node, :dirnode => dirnode, :name => names[:name], :dirname => names[:dirname] }
+    end
+
+    def move_node(node, path)
+      nodes = split_dirnode(path)
+      nodes[:node] && nodes[:node].destroy
+      node.update_attributes! :path => path, :node_id => nodes[:dirnode].id, :name => nodes[:name]
+    end
+
+    def enoent(path = nil)
+      # print "Raising enoent #{path}\n"
+      raise Errno::ENOENT.new(path)
+    end
+
+    def enotdir(path = nil)
+      # print "Raising enotdir #{path}\n"
+      raise Errno::ENOTDIR.new(path)
+    end
+
+    def eisdir(path = nil)
+      # print "Raising eisdir #{path}\n"
+      raise Errno::EISDIR.new(path)
+    end
+  end
+end

data/lib/gitroom/server.rb

@@ -0,0 +1,32 @@
+require 'git'
+require 'yaml'
+require 'fusefs'
+require 'gitroom/models/node'
+require 'gitroom/models/log'
+
+module GitRoom
+  class Server
+    def self.serve(user)
+      permissions = 'rw'
+      command = ENV['SSH_ORIGINAL_COMMAND']
+      abort unless user and permissions and command
+
+      STDERR.write ENV.to_hash.to_yaml
+
+      valid_actions = ['git-receive-pack', 'git-upload-pack']
+      action = command.split[0]
+      repo = command.split[1]
+      commands = command.split
+      commands[1] = "repos/#{repo}"
+      command = commands.join ' '
+      abort unless valid_actions.include? action
+
+      abort "read denied for #{user}" unless permissions =~ /r/
+      abort "write denied for #{user}" if action == 'git-receive-pack' and permissions !~ /w/
+
+      STDERR.write "user #{user} authorized\n"
+
+      Kernel.exec 'git', 'shell', '-c', command
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: gitroom
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexey Fedorov (waterlink)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-08-01 00:00:00 Z
+dependencies: []
+
+description: Simplest git server with permissions
+email: waterlink000@gmail.com
+executables: 
+- gitserve
+- gitfs
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/gitroom.rb
+- lib/gitroom/connect.rb
+- lib/gitroom/server.rb
+- lib/gitroom/mounter.rb
+- lib/gitroom/admin.rb
+- lib/gitroom/models/node.rb
+- lib/gitroom/models/log.rb
+- lib/gitroom/models/binary_file.rb
+- lib/gitroom/models/chunk.rb
+- lib/gitroom/concerns/node_cached.rb
+- bin/gitserve
+- bin/gitfs
+homepage: https://rubygems.org/gems/gitroom
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id001 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id001
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Git Room!
+test_files: []
+