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