GridFS

Criando um objeto GridFS ("Grid::FSBucket")

Você pode criar um objeto GridFS chamando fs em um reconhecimento de data center, com argumentos opcionais. fs retorna um objeto Grid::FSBucket .

As opções que o Grid::FSBucket suporta são:

Por exemplo, você pode criar um objeto de bucket GridFS com uma read preference específica:

fs_bucket = database.fs( read: { mode: :secondary } )

Trabalhando com fluxos de gravação

Para carregar um arquivo no GridFS usando um fluxo de gravação, você pode abrir um fluxo e escrever nele diretamente ou gravar todo o conteúdo de um objeto IO no GridFS de uma só vez.

Para abrir um fluxo de upload e gravar nele:

File.open('/path/to/my-file.txt', 'r') do |file|
  fs_bucket.open_upload_stream('my-file.txt') do |stream|
    stream.write(file)
  end
end

Para carregar todo o conteúdo de um objeto IO em uma chamada:

File.open('/path/to/my-file.txt', 'r') do |file|
  fs_bucket.upload_from_stream('my-file.txt', file)
end

Os fluxos de gravação suportam as seguintes opções:

As opções podem ser fornecidas como o último argumento para os métodos de fluxo de gravação:

fs_bucket.open_upload_stream('my-file.txt', write_concern: {w: 2}) do |stream|
  stream.write_concern
  # => #<Mongo::WriteConcern::Acknowledged:0x46980201422160 options={:w=>2}>
  # ...
end
fs_bucket.upload_from_stream('my-file.txt', file, write_concern: {w: 2})

Trabalhando com fluxos de leitura

Para baixar um arquivo do GridFS usando um fluxo de leitura, você pode abrir um fluxo de leitura e ler dele diretamente ou baixar o arquivo inteiro de uma só vez.

Para abrir um stream de download e ler:

File.open('/path/to/my-output-file.txt', 'w') do |file|
  fs_bucket.open_download_stream(file_id) do |stream|
    file.write(stream.read)
  end
end

Para baixar o arquivo de uma só vez e escrevê-lo em um objeto IO:

File.open('/path/to/my-output-file.txt', 'w') do |file|
  fs_bucket.download_from_stream(file_id, file)
end

Você também pode baixar um arquivo especificado por um nome e (opcionalmente) número de revisão. Os números de revisão são usados para distinguir entre arquivos que compartilham o mesmo nome, ordenados por data de upload. O número de revisão passado para open_download_stream_by_name pode ser positivo ou negativo.

File.open('/path/to/my-output-file.txt', 'w') do |file|
  fs_bucket.open_download_stream_by_name('my-file.txt', revision: -2) do |stream|
    file.write(stream.read)
  end
end

Para baixar todo o conteúdo do arquivo especificado por nome e (opcional) número de revisão:

File.open('/path/to/my-output-file.txt', 'w') do |file|
  fs_bucket.download_to_stream_by_name('my-file.txt', file, revision: -2)
end

Os fluxos de leitura suportam as seguintes opções:

Alguns, mas não todos, dos métodos de leitura listados acima passam essas opções para os fluxos de leitura subjacentes. Consulte a documentação da API para cada método para determinar se ele oferece suporte a uma opção específica.

Encontrando metadados de arquivo

Você pode recuperar documentos contendo metadados sobre arquivos na collection de arquivos GridFS.

fs_bucket.find(filename: 'my-file.txt')

Excluindo arquivos

Você pode excluir um arquivo por id.

fs_bucket.delete(file_id)

Trabalhando com objetos Grid::File

Esse objeto pode ser usado para envolver um arquivo a ser inserido no reconhecimento de data center usando o GridFS e o objeto que é recuperado.

Para criar um arquivo com dados brutos:

file = Mongo::Grid::File.new('I am a file', :filename => 'new-file.txt')

Para criar um arquivo a partir de um objeto Ruby File :

file = File.open('/path/to/my-file.txt')
grid_file = Mongo::Grid::File.new(file.read, :filename => File.basename(file.path))

Para alterar as opções do arquivo, como o tamanho do bloco, passe opções para o construtor:

file = File.open('/path/to/my-file.txt')
grid_file = Mongo::Grid::File.new(
  file.read,
  :filename => File.basename(file.path),
  :chunk_size => 1024
)

A seguir está uma lista completa das opções disponíveis que os arquivos suportam.

Inserindo arquivos

Os arquivos podem ser inseridos no reconhecimento de data center um de cada vez. Os blocos de arquivos são inseridos por padrão na coleção fs.chunks e os metadados do arquivo são inseridos na coleção fs.files .

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
file = Mongo::Grid::File.new('I am a file', :filename => 'new-file.txt')
client.database.fs.insert_one(file)

Para inserir em collection com um prefixo de nome diferente de fs, acesse o sistema de arquivos com uma opção :fs_name .

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
file = Mongo::Grid::File.new('I am a file', :filename => 'new-file.txt')
client.database.fs(:fs_name => 'grid').insert_one(file)

Quando o driver estiver inserindo o primeiro arquivo em um bucket, ele tentará criar os índices necessários na collection files e chunks . Os índices necessários são os seguintes:

# files collection
{ :filename => 1, :uploadDate => 1 }
# chunks collection
{ :files_id => 1, :n => 1 }, { :unique => true }

Os arquivos também podem ser transmitidos como uma alternativa a uma inserção direta.

client.database.fs.open_upload_stream(filename) do |stream|
  stream.write(file)
end

Encontrando arquivos

Para recuperar um arquivo do reconhecimento de data center, chame find_one com o filtro apropriado.

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client.database.fs.find_one(:filename => 'new-file.txt') # Returns a Mongo::Grid::File

Os arquivos também podem ser transmitidos como uma alternativa a uma busca direta.

client.database.fs.open_download_stream(file_id) do |stream|
  io.write(stream.read)
end
fs.download_to_stream(file_id, io)

Excluindo arquivos

Para excluir um arquivo, passe o objeto do arquivo para delete_one.

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
fs = client.database.fs
file = fs.find_one(:filename => 'new-file.txt')
fs.delete_one(file)