CPAN::Groonga

sename qw'dirname';
use File::Spec;
use File::Copy;
use Rex::Repositorio::Repository_Factory;
use JSON::XS;
use Data::Dumper;

our $VERSION = '1.2.1'; # VERSION

if ( !$Rex::Repositorio::VERSION ) {
 

 );

  require Mojolicious::Commands;

  # pass config to mojo app
  $ENV{'REPO_CONFIG'} = encode_json( $self->config );
  $ENV{'REPO_NAME'}   = $option{repo};
  $ENV{'MOJO_MAX_MESSAGE_SIZE'} = 1024 *

icious::Plugin';
use Data::Dumper;
use File::Spec;
use File::Path 'make_path', 'remove_tree';
use JSON::XS;
require IO::All;

sub register {
  my ( $self, $app ) = @_;

  my $session_dir =
    File::S

r, $session_id );
          if ( $session_id && -f $session_file ) {
            my $ref = decode_json( IO::All->new($session_file)->slurp );
            $self->stash( "session_token",         $sessio

n_dir;
        }

        open( my $fh, ">", $session_file ) or die($!);
        print $fh encode_json(
          {
            token => $self->stash->{session_token},
            user  => $self->stas

Carp;
use Params::Validate qw(:all);
use File::Spec;
use File::Path 'make_path';
use IO::All;
use JSON::XS;
use Mojo::DOM;

our $VERSION = '1.2.1'; # VERSION

extends "Rex::Repositorio::Repository::Ba

File::Basename qw'dirname';
use File::Spec;
use File::Copy;
use Digest::SHA;
use Digest::MD5;
use JSON::XS;
use List::MoreUtils 'firstidx';

our $VERSION = '1.2.1'; # VERSION

has app  => ( is => 'ro'

  substr( $option{package}, 0, 1 ), $option{package},
      "errata.json"
    )
    )
  {
    return {};
  }

  my $ref = decode_json(
    IO::All->new(
      File::Spec->catfile(
        $errata_dir,

 $option{arch},
        substr( $option{package}, 0, 1 ), $option{package},
        "errata.json"
      )
    )->slurp
  );

  my $package = $option{package};
  my $arch    = $option{arch};
  my $vers

Carp;
use Params::Validate qw(:all);
use File::Spec;
use File::Path 'make_path';
use IO::All;
use JSON::XS;
use Expect;

our $VERSION = '1.2.1'; # VERSION

extends "Rex::Repositorio::Repository::Base"

move_tree';
use Digest::MD5 'md5_base64';
use Rex::Repositorio::Server::Docker::Helper::Auth;
use JSON::XS;
use Data::Dumper;

our $VERSION = '1.2.1'; # VERSION

# TODO: implement authentication and a

name} );
  my $user_dir = File::Spec->catdir( $repo_dir, "users" );

  my $ref      = $self->req->json;
  my $username = $ref->{username};

  if ( !-d File::Spec->catdir( $user_dir, $username ) ) {
  

( $user_dir, $username, "user.json" ) )
      or die($!);
    my $ref = $self->req->json;
    $ref->{password} = md5_base64( $ref->{password} );
    print $fh encode_json($ref);
    close($fh);

    $

ge->get('/json')->to('image#get_image');
  $auth_image->get('/ancestry')->to('image#get_image_ancestry');
  $auth_image->get('/layer')->to('image#get_image_layer');
  $auth_image->put('/json')->to('im

Carp;
use Params::Validate qw(:all);
use File::Spec;
use File::Path 'make_path';
use IO::All;
use JSON::XS;

our $VERSION = '1.2.1'; # VERSION

extends "Rex::Repositorio::Repository::Yum";

sub mirror

ious::Controller';

our $VERSION = '1.2.1'; # VERSION

sub index {
  my ($self) = @_;
  $self->render( json => { ok => 1 } );
}

sub ping {
  my ($self) = @_;
  $self->render( text => 'true' );
}

1;

:

package Rex::Repositorio::Server::Docker::Helper::Auth::Plain;

use Moose;
use File::Spec;
use JSON::XS;
require IO::All;

our $VERSION = '1.2.1'; # VERSION

has user_path => ( is => 'ro' );

sub l

);
  my $user_file = File::Spec->catfile( $user_dir, "user.json" );

  if ( !-f $user_file ) {
    return 0;
  }

  my $user_ref = decode_json( IO::All->new($user_file)->slurp );

  if ( $user_ref->{p

:Repositorio::Server::Yum::Errata;

use Mojo::Base 'Mojolicious::Controller';
use File::Spec;
use JSON::XS;
use List::MoreUtils 'firstidx';
use Data::Dumper;
require IO::All;

our $VERSION = '1.2.1'; 

->debug("Looking for errata: $errata_dir");

  if ( !-d $errata_dir ) {
    return $self->render( json => {}, status => 404 );
  }

  my $package = $self->param("package");
  my $arch    = $self->para

rch, substr( $package, 0, 1 ),
      $package, "errata.json"
    )
    )
  {
    return $self->render( json => {} );
  }

  my $ref = decode_json(
    IO::All->new(
      File::Spec->catfile(
        

:Validate qw(:all);
use File::Spec;
use JSON::XS;

sub register {
  my ( $self, $app ) = @_;

  $app->helper(
    config => sub {
      my $config = decode_json( $ENV{REPO_CONFIG} );
      return $con

::Docker::Search;

use Mojo::Base 'Mojolicious::Controller';
use File::Spec;
require IO::All;
use JSON::XS;
use Data::Dumper;

our $VERSION = '1.2.1'; # VERSION

sub search {
  my ($self) = @_;

  my 

Spec->catdir( $self->app->get_repo_dir( repo => $self->repo->{name} ),
    "repository" );

  my @json_files;
  my @dirs = ($repo_dir);
  for my $dir (@dirs) {
    opendir( my $dh, $dir );
    while (

  }
      if ( -f File::Spec->catfile( $dir, $entry, "repo.json" ) ) {
        push @json_files, File::Spec->catfile( $dir, $entry, "repo.json" );
      }
    }
    closedir($dh);
  }

  my $search = 

c;
use File::Path 'make_path', 'remove_tree';
use File::Basename 'basename';
require IO::All;
use JSON::XS;
use MIME::Base64;

our $VERSION = '1.2.1'; # VERSION

sub put_image {
  my ($self) = @_;

  

ages", $self->param("name") );
  my $image_json = File::Spec->catfile( $image_dir, "image.json" );

  make_path $image_dir;

  open( my $fh, ">", $image_json ) or die($!);
  print $fh $self->req->body

;
  close($fh);

  eval {
    my $ref = decode_json $self->req->body;
    if ( exists $ref->{parent} ) {
      symlink File::Spec->catfile( $repo_dir, "images", $ref->{parent} ),
        File::Spec->c

r;
use File::Spec;
use File::Path 'make_path', 'remove_tree';
use File::Basename qw'dirname';
use JSON::XS;
use MIME::Base64;
require IO::All;

our $VERSION = '1.2.1'; # VERSION

sub get_repo_images {

catfile( $repo_dir, "repo.json" );

  if ( -f $repo_file ) {
    my $content = IO::All->new($repo_file)->slurp;
    $self->res->headers->add( 'Content-Type', 'application/json' );
    $self->render( t

   binmode $fh;
        print $fh $tx->res->body;
        close $fh;

        my $ref = $tx->res->json;
        my $repo_dir = $self->app->get_repo_dir( repo => $self->repo->{name} );
        for my $

tab:

package Rex::Repositorio::Server::Yum;

use Mojo::Base 'Mojolicious';
use Data::Dumper;
use JSON::XS;
use File::Spec;
use Params::Validate qw(:all);
use File::Basename 'dirname';
use File::Spec: