lib/MogileFS/DevFID.pm

   1 package MogileFS::DevFID;
   2 use strict;
   3 use warnings;
   4 use MogileFS::Server;
   5 use overload '""' => \&as_string;
   6 use Carp qw(croak);
   7
   8 sub new {
   9     my ($class, $devarg, $fidarg) = @_;
  10     return bless {
  11         devid => ref $devarg ? $devarg->id : $devarg,
  12         dev   => ref $devarg ? $devarg     : undef,
  13         fidid => ref $fidarg ? $fidarg->id : $fidarg,
  14         fid   => ref $fidarg ? $fidarg     : undef,
  15     }, $class;
  16 }
  17
  18 # --------------------------------------------------------------------------
  19
  20 sub devid { $_[0]{devid} }
  21 sub fidid { $_[0]{fidid} }
  22
  23 sub as_string {
  24     "DevFID[d=" . $_[0]{devid} . ";f=" . $_[0]{fidid} . "]";
  25 }
  26
  27 sub device {
  28     my $self = shift;
  29     return $self->{dev} ||= Mgd::device_factory()->get_by_id($self->{devid});
  30 }
  31
  32 sub fid {
  33     my $self = shift;
  34     return $self->{fid} ||= MogileFS::FID->new($self->{fidid});
  35 }
  36
  37 # returns true if DevFID actually exists in database
  38 sub exists {
  39     my $self = shift;
  40     my $fid  = $self->fid;
  41     return (grep { $_ == $self->{devid} } $fid->devids) ? 1 : 0;
  42 }
  43
  44 sub url {
  45     my $self = shift;
  46     return $self->_make_full_url(0);
  47 }
  48
  49 sub get_url {
  50     my $self = shift;
  51     return $self->_make_full_url(1);
  52 }
  53
  54 sub vivify_directories {
  55     my $self = shift;
  56     my $url = $self->url;
  57     $self->device()->vivify_directories($url);
  58 }
  59
  60 # returns 0 on missing,
  61 # undef on connectivity error,
  62 # else size of file on disk (after HTTP HEAD or mogstored stat)
  63 sub size_on_disk {
  64     my $self = shift;
  65
  66     return undef unless $self->device->should_read_from;
  67
  68     my $url = $self->get_url;
  69     my $httpfile = $self->{_httpfile_get} ||= MogileFS::HTTPFile->at($url);
  70
  71     # check that it has size (>0) and is reachable (not undef)
  72     return $httpfile->size;
  73 }
  74
  75 # returns -1 on missing,
  76 # undef on connectivity error,
  77 # else checksum of file on disk (after HTTP GET or mogstored read)
  78 sub checksum_on_disk {
  79     my ($self, $alg, $ping_cb, $reason) = @_;
  80
  81     return undef unless $self->device->should_read_from;
  82
  83     my $url = $self->get_url;
  84     my $httpfile = $self->{_httpfile_get} ||= MogileFS::HTTPFile->at($url);
  85
  86     # check that it has size (>0) and is reachable (not undef)
  87     return $httpfile->digest($alg, $ping_cb, $reason);
  88 }
  89
  90 # returns true if size seen matches fid's length
  91 sub size_matches {
  92     my $self = shift;
  93     my $fid = $self->fid;
  94     my $disk_size = $self->size_on_disk;
  95
  96     # Temporary connectivity error with that disk/machine..
  97     return 0 unless defined $disk_size;
  98     return 0 if $disk_size == MogileFS::HTTPFile::FILE_MISSING;
  99
 100     return $disk_size == $fid->length;
 101 }
 102
 103 # returns just the URI path component without scheme/host
 104 sub uri_path {
 105     my $self = shift;
 106     my $devid = $self->{devid};
 107     my $fidid = $self->{fidid};
 108
 109     my $nfid;
 110     my $len = length $fidid;
 111     if ($len < 10) {
 112         $nfid = '0' x (10 - $len) . $fidid;
 113     } else {
 114         $nfid = $fidid;
 115     }
 116     my ( $b, $mmm, $ttt, $hto ) = ( $nfid =~ m{(\d)(\d{3})(\d{3})(\d{3})} );
 117
 118     return "/dev$devid/$b/$mmm/$ttt/$nfid.fid";
 119 }
 120
 121 sub _make_full_url {
 122     # set use_get_port to be true to specify to use the get port
 123     my ($self, $use_get_port) = @_;
 124
 125     # get some information we'll need
 126     my $dev  = $self->device   or return undef;
 127     my $host = $dev->host      or return undef;
 128
 129     my $path   = $self->uri_path;
 130     my $hostip = $host->ip;
 131     my $port   = $use_get_port ? $host->http_get_port : $host->http_port;
 132
 133     return "http://$hostip:$port$path";
 134 }
 135
 136 sub add_to_db {
 137     my ($self, $no_lock) = @_;
 138     croak("fidid not non-zero") unless $self->{fidid};
 139     croak("devid not non-zero") unless $self->{devid};
 140
 141     my $sto = Mgd::get_store();
 142     if ($sto->add_fidid_to_devid($self->{fidid}, $self->{devid})) {
 143         if (my $memc = MogileFS::Config->memcache_client) {
 144             $memc->delete("mogdevids:$self->{fidid}");
 145         }
 146         return $self->fid->update_devcount(no_lock => $no_lock);
 147     } else {
 148         # was already on that device
 149         return 1;
 150     }
 151 }
 152
 153 # Destroy a particular replica of a file via HTTP, remove it
 154 # from the tracker, and update the replication counts to be
 155 # accurate again.
 156 sub destroy {
 157     my $self = shift;
 158     my %opts = @_;
 159
 160     my $httpfile = MogileFS::HTTPFile->at($self->url)
 161         or die "Creation of HTTPFile object failed.";
 162
 163     my %delete_opts;
 164
 165     $delete_opts{ignore_missing} = 1
 166         if $opts{ignore_missing};
 167
 168     $httpfile->delete(%delete_opts)
 169         or die "Deletion of file via HTTP failed.";
 170
 171     my $sto = Mgd::get_store();
 172     $sto->remove_fidid_from_devid($self->fidid, $self->devid);
 173     $self->fid->update_devcount(no_lock => 1);
 174 }
 175
 176 1;
 177
 178 __END__
 179
 180 =head1 NAME
 181
 182 MogileFS::DevFID - represents a FID on a device
 183
 184 =head1 ABOUT
 185
 186 This class represents the (devid, fidid) tuple.  That is, a specific
 187 version on a file on a specific device.  See L<MogileFS::Device> and
 188 L<MogileFS::FID>.