plugins/OStatus/classes/Ostatus_profile.php

   1 <?php
   2 /*
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2009-2010, StatusNet, Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /**
  21  * @package OStatusPlugin
  22  * @maintainer Brion Vibber <brion@status.net>
  23  */
  24
  25 class Ostatus_profile extends Memcached_DataObject
  26 {
  27     public $__table = 'ostatus_profile';
  28
  29     public $uri;
  30
  31     public $profile_id;
  32     public $group_id;
  33
  34     public $feeduri;
  35     public $salmonuri;
  36     public $avatar; // remote URL of the last avatar we saved
  37
  38     public $created;
  39     public $modified;
  40
  41     public /*static*/ function staticGet($k, $v=null)
  42     {
  43         return parent::staticGet(__CLASS__, $k, $v);
  44     }
  45
  46     /**
  47      * return table definition for DB_DataObject
  48      *
  49      * DB_DataObject needs to know something about the table to manipulate
  50      * instances. This method provides all the DB_DataObject needs to know.
  51      *
  52      * @return array array of column definitions
  53      */
  54
  55     function table()
  56     {
  57         return array('uri' => DB_DATAOBJECT_STR + DB_DATAOBJECT_NOTNULL,
  58                      'profile_id' => DB_DATAOBJECT_INT,
  59                      'group_id' => DB_DATAOBJECT_INT,
  60                      'feeduri' => DB_DATAOBJECT_STR,
  61                      'salmonuri' =>  DB_DATAOBJECT_STR,
  62                      'avatar' =>  DB_DATAOBJECT_STR,
  63                      'created' => DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME + DB_DATAOBJECT_NOTNULL,
  64                      'modified' => DB_DATAOBJECT_STR + DB_DATAOBJECT_DATE + DB_DATAOBJECT_TIME + DB_DATAOBJECT_NOTNULL);
  65     }
  66
  67     static function schemaDef()
  68     {
  69         return array(new ColumnDef('uri', 'varchar',
  70                                    255, false, 'PRI'),
  71                      new ColumnDef('profile_id', 'integer',
  72                                    null, true, 'UNI'),
  73                      new ColumnDef('group_id', 'integer',
  74                                    null, true, 'UNI'),
  75                      new ColumnDef('feeduri', 'varchar',
  76                                    255, true, 'UNI'),
  77                      new ColumnDef('salmonuri', 'text',
  78                                    null, true),
  79                      new ColumnDef('avatar', 'text',
  80                                    null, true),
  81                      new ColumnDef('created', 'datetime',
  82                                    null, false),
  83                      new ColumnDef('modified', 'datetime',
  84                                    null, false));
  85     }
  86
  87     /**
  88      * return key definitions for DB_DataObject
  89      *
  90      * DB_DataObject needs to know about keys that the table has; this function
  91      * defines them.
  92      *
  93      * @return array key definitions
  94      */
  95
  96     function keys()
  97     {
  98         return array_keys($this->keyTypes());
  99     }
 100
 101     /**
 102      * return key definitions for Memcached_DataObject
 103      *
 104      * Our caching system uses the same key definitions, but uses a different
 105      * method to get them.
 106      *
 107      * @return array key definitions
 108      */
 109
 110     function keyTypes()
 111     {
 112         return array('uri' => 'K', 'profile_id' => 'U', 'group_id' => 'U', 'feeduri' => 'U');
 113     }
 114
 115     function sequenceKey()
 116     {
 117         return array(false, false, false);
 118     }
 119
 120     /**
 121      * Fetch the StatusNet-side profile for this feed
 122      * @return Profile
 123      */
 124     public function localProfile()
 125     {
 126         if ($this->profile_id) {
 127             return Profile::staticGet('id', $this->profile_id);
 128         }
 129         return null;
 130     }
 131
 132     /**
 133      * Fetch the StatusNet-side profile for this feed
 134      * @return Profile
 135      */
 136     public function localGroup()
 137     {
 138         if ($this->group_id) {
 139             return User_group::staticGet('id', $this->group_id);
 140         }
 141         return null;
 142     }
 143
 144     /**
 145      * Returns an ActivityObject describing this remote user or group profile.
 146      * Can then be used to generate Atom chunks.
 147      *
 148      * @return ActivityObject
 149      */
 150     function asActivityObject()
 151     {
 152         if ($this->isGroup()) {
 153             return ActivityObject::fromGroup($this->localGroup());
 154         } else {
 155             return ActivityObject::fromProfile($this->localProfile());
 156         }
 157     }
 158
 159     /**
 160      * Returns an XML string fragment with profile information as an
 161      * Activity Streams noun object with the given element type.
 162      *
 163      * Assumes that 'activity' namespace has been previously defined.
 164      *
 165      * @fixme replace with wrappers on asActivityObject when it's got everything.
 166      *
 167      * @param string $element one of 'actor', 'subject', 'object', 'target'
 168      * @return string
 169      */
 170     function asActivityNoun($element)
 171     {
 172         if ($this->isGroup()) {
 173             $noun = ActivityObject::fromGroup($this->localGroup());
 174             return $noun->asString('activity:' . $element);
 175         } else {
 176             $noun = ActivityObject::fromProfile($this->localProfile());
 177             return $noun->asString('activity:' . $element);
 178         }
 179     }
 180
 181     /**
 182      * @return boolean true if this is a remote group
 183      */
 184     function isGroup()
 185     {
 186         if ($this->profile_id && !$this->group_id) {
 187             return false;
 188         } else if ($this->group_id && !$this->profile_id) {
 189             return true;
 190         } else if ($this->group_id && $this->profile_id) {
 191             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs set for $this->uri");
 192         } else {
 193             throw new ServerException("Invalid ostatus_profile state: both group and profile IDs empty for $this->uri");
 194         }
 195     }
 196
 197     /**
 198      * Send a subscription request to the hub for this feed.
 199      * The hub will later send us a confirmation POST to /main/push/callback.
 200      *
 201      * @return bool true on success, false on failure
 202      * @throws ServerException if feed state is not valid
 203      */
 204     public function subscribe()
 205     {
 206         $feedsub = FeedSub::ensureFeed($this->feeduri);
 207         if ($feedsub->sub_state == 'active' || $feedsub->sub_state == 'subscribe') {
 208             return true;
 209         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive') {
 210             return $feedsub->subscribe();
 211         } else if ('unsubscribe') {
 212             throw new FeedSubException("Unsub is pending, can't subscribe...");
 213         }
 214     }
 215
 216     /**
 217      * Send a PuSH unsubscription request to the hub for this feed.
 218      * The hub will later send us a confirmation POST to /main/push/callback.
 219      *
 220      * @return bool true on success, false on failure
 221      * @throws ServerException if feed state is not valid
 222      */
 223     public function unsubscribe() {
 224         $feedsub = FeedSub::staticGet('uri', $this->feeduri);
 225         if (!$feedsub) {
 226             return true;
 227         }
 228         if ($feedsub->sub_state == 'active') {
 229             return $feedsub->unsubscribe();
 230         } else if ($feedsub->sub_state == '' || $feedsub->sub_state == 'inactive' || $feedsub->sub_state == 'unsubscribe') {
 231             return true;
 232         } else if ($feedsub->sub_state == 'subscribe') {
 233             throw new FeedSubException("Feed is awaiting subscription, can't unsub...");
 234         }
 235     }
 236
 237     /**
 238      * Check if this remote profile has any active local subscriptions, and
 239      * if not drop the PuSH subscription feed.
 240      *
 241      * @return boolean
 242      */
 243     public function garbageCollect()
 244     {
 245         if ($this->isGroup()) {
 246             $members = $this->localGroup()->getMembers(0, 1);
 247             $count = $members->N;
 248         } else {
 249             $count = $this->localProfile()->subscriberCount();
 250         }
 251         if ($count == 0) {
 252             common_log(LOG_INFO, "Unsubscribing from now-unused remote feed $this->feeduri");
 253             $this->unsubscribe();
 254             return true;
 255         } else {
 256             return false;
 257         }
 258     }
 259
 260     /**
 261      * Send an Activity Streams notification to the remote Salmon endpoint,
 262      * if so configured.
 263      *
 264      * @param Profile $actor  Actor who did the activity
 265      * @param string  $verb   Activity::SUBSCRIBE or Activity::JOIN
 266      * @param Object  $object object of the action; must define asActivityNoun($tag)
 267      */
 268     public function notify($actor, $verb, $object=null)
 269     {
 270         if (!($actor instanceof Profile)) {
 271             $type = gettype($actor);
 272             if ($type == 'object') {
 273                 $type = get_class($actor);
 274             }
 275             throw new ServerException("Invalid actor passed to " . __METHOD__ . ": " . $type);
 276         }
 277         if ($object == null) {
 278             $object = $this;
 279         }
 280         if ($this->salmonuri) {
 281
 282             $text = 'update';
 283             $id = TagURI::mint('%s:%s:%s',
 284                                $verb,
 285                                $actor->getURI(),
 286                                common_date_iso8601(time()));
 287
 288             // @fixme consolidate all these NS settings somewhere
 289             $attributes = array('xmlns' => Activity::ATOM,
 290                                 'xmlns:activity' => 'http://activitystrea.ms/spec/1.0/',
 291                                 'xmlns:thr' => 'http://purl.org/syndication/thread/1.0',
 292                                 'xmlns:georss' => 'http://www.georss.org/georss',
 293                                 'xmlns:ostatus' => 'http://ostatus.org/schema/1.0',
 294                                 'xmlns:poco' => 'http://portablecontacts.net/spec/1.0',
 295                                 'xmlns:media' => 'http://purl.org/syndication/atommedia');
 296
 297             $entry = new XMLStringer();
 298             $entry->elementStart('entry', $attributes);
 299             $entry->element('id', null, $id);
 300             $entry->element('title', null, $text);
 301             $entry->element('summary', null, $text);
 302             $entry->element('published', null, common_date_w3dtf(common_sql_now()));
 303
 304             $entry->element('activity:verb', null, $verb);
 305             $entry->raw($actor->asAtomAuthor());
 306             $entry->raw($actor->asActivityActor());
 307             $entry->raw($object->asActivityNoun('object'));
 308             $entry->elementEnd('entry');
 309
 310             $xml = $entry->getString();
 311             common_log(LOG_INFO, "Posting to Salmon endpoint $this->salmonuri: $xml");
 312
 313             $salmon = new Salmon(); // ?
 314             return $salmon->post($this->salmonuri, $xml, $actor);
 315         }
 316         return false;
 317     }
 318
 319     /**
 320      * Send a Salmon notification ping immediately, and confirm that we got
 321      * an acceptable response from the remote site.
 322      *
 323      * @param mixed $entry XML string, Notice, or Activity
 324      * @return boolean success
 325      */
 326     public function notifyActivity($entry, $actor)
 327     {
 328         if ($this->salmonuri) {
 329             $salmon = new Salmon();
 330             return $salmon->post($this->salmonuri, $this->notifyPrepXml($entry), $actor);
 331         }
 332
 333         return false;
 334     }
 335
 336     /**
 337      * Queue a Salmon notification for later. If queues are disabled we'll
 338      * send immediately but won't get the return value.
 339      *
 340      * @param mixed $entry XML string, Notice, or Activity
 341      * @return boolean success
 342      */
 343     public function notifyDeferred($entry, $actor)
 344     {
 345         if ($this->salmonuri) {
 346             $data = array('salmonuri' => $this->salmonuri,
 347                           'entry' => $this->notifyPrepXml($entry),
 348                           'actor' => $actor->id);
 349
 350             $qm = QueueManager::get();
 351             return $qm->enqueue($data, 'salmon');
 352         }
 353
 354         return false;
 355     }
 356
 357     protected function notifyPrepXml($entry)
 358     {
 359         $preamble = '<?xml version="1.0" encoding="UTF-8" ?' . '>';
 360         if (is_string($entry)) {
 361             return $entry;
 362         } else if ($entry instanceof Activity) {
 363             return $preamble . $entry->asString(true);
 364         } else if ($entry instanceof Notice) {
 365             return $preamble . $entry->asAtomEntry(true, true);
 366         } else {
 367             throw new ServerException("Invalid type passed to Ostatus_profile::notify; must be XML string or Activity entry");
 368         }
 369     }
 370
 371     function getBestName()
 372     {
 373         if ($this->isGroup()) {
 374             return $this->localGroup()->getBestName();
 375         } else {
 376             return $this->localProfile()->getBestName();
 377         }
 378     }
 379
 380     /**
 381      * Read and post notices for updates from the feed.
 382      * Currently assumes that all items in the feed are new,
 383      * coming from a PuSH hub.
 384      *
 385      * @param DOMDocument $doc
 386      * @param string $source identifier ("push")
 387      */
 388     public function processFeed(DOMDocument $doc, $source)
 389     {
 390         $feed = $doc->documentElement;
 391
 392         if ($feed->localName != 'feed' || $feed->namespaceURI != Activity::ATOM) {
 393             common_log(LOG_ERR, __METHOD__ . ": not an Atom feed, ignoring");
 394             return;
 395         }
 396
 397         $entries = $feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 398         if ($entries->length == 0) {
 399             common_log(LOG_ERR, __METHOD__ . ": no entries in feed update, ignoring");
 400             return;
 401         }
 402
 403         for ($i = 0; $i < $entries->length; $i++) {
 404             $entry = $entries->item($i);
 405             $this->processEntry($entry, $feed, $source);
 406         }
 407     }
 408
 409     /**
 410      * Process a posted entry from this feed source.
 411      *
 412      * @param DOMElement $entry
 413      * @param DOMElement $feed for context
 414      * @param string $source identifier ("push" or "salmon")
 415      */
 416     public function processEntry($entry, $feed, $source)
 417     {
 418         $activity = new Activity($entry, $feed);
 419
 420         if ($activity->verb == ActivityVerb::POST) {
 421             $this->processPost($activity, $source);
 422         } else {
 423             common_log(LOG_INFO, "Ignoring activity with unrecognized verb $activity->verb");
 424         }
 425     }
 426
 427     /**
 428      * Process an incoming post activity from this remote feed.
 429      * @param Activity $activity
 430      * @param string $method 'push' or 'salmon'
 431      * @return mixed saved Notice or false
 432      * @fixme break up this function, it's getting nasty long
 433      */
 434     public function processPost($activity, $method)
 435     {
 436         if ($this->isGroup()) {
 437             // A group feed will contain posts from multiple authors.
 438             // @fixme validate these profiles in some way!
 439             $oprofile = self::ensureActorProfile($activity);
 440             if ($oprofile->isGroup()) {
 441                 // Groups can't post notices in StatusNet.
 442                 common_log(LOG_WARNING, "OStatus: skipping post with group listed as author: $oprofile->uri in feed from $this->uri");
 443                 return false;
 444             }
 445         } else {
 446             // Individual user feeds may contain only posts from themselves.
 447             // Authorship is validated against the profile URI on upper layers,
 448             // through PuSH setup or Salmon signature checks.
 449             $actorUri = self::getActorProfileURI($activity);
 450             if ($actorUri == $this->uri) {
 451                 // Check if profile info has changed and update it
 452                 $this->updateFromActivityObject($activity->actor);
 453             } else {
 454                 common_log(LOG_WARNING, "OStatus: skipping post with bad author: got $actorUri expected $this->uri");
 455                 return false;
 456             }
 457             $oprofile = $this;
 458         }
 459
 460         // The id URI will be used as a unique identifier for for the notice,
 461         // protecting against duplicate saves. It isn't required to be a URL;
 462         // tag: URIs for instance are found in Google Buzz feeds.
 463         $sourceUri = $activity->object->id;
 464         $dupe = Notice::staticGet('uri', $sourceUri);
 465         if ($dupe) {
 466             common_log(LOG_INFO, "OStatus: ignoring duplicate post: $sourceUri");
 467             return false;
 468         }
 469
 470         // We'll also want to save a web link to the original notice, if provided.
 471         $sourceUrl = null;
 472         if ($activity->object->link) {
 473             $sourceUrl = $activity->object->link;
 474         } else if ($activity->link) {
 475             $sourceUrl = $activity->link;
 476         } else if (preg_match('!^https?://!', $activity->object->id)) {
 477             $sourceUrl = $activity->object->id;
 478         }
 479
 480         // Get (safe!) HTML and text versions of the content
 481         $rendered = $this->purify($activity->object->content);
 482         $content = html_entity_decode(strip_tags($rendered));
 483
 484         $shortened = common_shorten_links($content);
 485
 486         // If it's too long, try using the summary, and make the
 487         // HTML an attachment.
 488
 489         $attachment = null;
 490
 491         if (Notice::contentTooLong($shortened)) {
 492             $attachment = $this->saveHTMLFile($activity->object->title, $rendered);
 493             $summary = $activity->object->summary;
 494             if (empty($summary)) {
 495                 $summary = $content;
 496             }
 497             $shortSummary = common_shorten_links($summary);
 498             if (Notice::contentTooLong($shortSummary)) {
 499                 $url = common_shorten_url(common_local_url('attachment',
 500                                                            array('attachment' => $attachment->id)));
 501                 $shortSummary = substr($shortSummary,
 502                                        0,
 503                                        Notice::maxContent() - (mb_strlen($url) + 2));
 504                 $shortSummary .= '… ' . $url;
 505                 $content = $shortSummary;
 506                 $rendered = common_render_text($content);
 507             }
 508         }
 509
 510         $options = array('is_local' => Notice::REMOTE_OMB,
 511                         'url' => $sourceUrl,
 512                         'uri' => $sourceUri,
 513                         'rendered' => $rendered,
 514                         'replies' => array(),
 515                         'groups' => array(),
 516                         'tags' => array(),
 517                         'urls' => array());
 518
 519         // Check for optional attributes...
 520
 521         if (!empty($activity->time)) {
 522             $options['created'] = common_sql_date($activity->time);
 523         }
 524
 525         if ($activity->context) {
 526             // Any individual or group attn: targets?
 527             $replies = $activity->context->attention;
 528             $options['groups'] = $this->filterReplies($oprofile, $replies);
 529             $options['replies'] = $replies;
 530
 531             // Maintain direct reply associations
 532             // @fixme what about conversation ID?
 533             if (!empty($activity->context->replyToID)) {
 534                 $orig = Notice::staticGet('uri',
 535                                           $activity->context->replyToID);
 536                 if (!empty($orig)) {
 537                     $options['reply_to'] = $orig->id;
 538                 }
 539             }
 540
 541             $location = $activity->context->location;
 542             if ($location) {
 543                 $options['lat'] = $location->lat;
 544                 $options['lon'] = $location->lon;
 545                 if ($location->location_id) {
 546                     $options['location_ns'] = $location->location_ns;
 547                     $options['location_id'] = $location->location_id;
 548                 }
 549             }
 550         }
 551
 552         // Atom categories <-> hashtags
 553         foreach ($activity->categories as $cat) {
 554             if ($cat->term) {
 555                 $term = common_canonical_tag($cat->term);
 556                 if ($term) {
 557                     $options['tags'][] = $term;
 558                 }
 559             }
 560         }
 561
 562         // Atom enclosures -> attachment URLs
 563         foreach ($activity->enclosures as $href) {
 564             // @fixme save these locally or....?
 565             $options['urls'][] = $href;
 566         }
 567
 568         try {
 569             $saved = Notice::saveNew($oprofile->profile_id,
 570                                      $content,
 571                                      'ostatus',
 572                                      $options);
 573             if ($saved) {
 574                 Ostatus_source::saveNew($saved, $this, $method);
 575                 if (!empty($attachment)) {
 576                     File_to_post::processNew($attachment->id, $saved->id);
 577                 }
 578             }
 579         } catch (Exception $e) {
 580             common_log(LOG_ERR, "OStatus save of remote message $sourceUri failed: " . $e->getMessage());
 581             throw $e;
 582         }
 583         common_log(LOG_INFO, "OStatus saved remote message $sourceUri as notice id $saved->id");
 584         return $saved;
 585     }
 586
 587     /**
 588      * Clean up HTML
 589      */
 590     protected function purify($html)
 591     {
 592         require_once INSTALLDIR.'/extlib/htmLawed/htmLawed.php';
 593         $config = array('safe' => 1,
 594                         'deny_attribute' => 'id,style,on*');
 595         return htmLawed($html, $config);
 596     }
 597
 598     /**
 599      * Filters a list of recipient ID URIs to just those for local delivery.
 600      * @param Ostatus_profile local profile of sender
 601      * @param array in/out &$attention_uris set of URIs, will be pruned on output
 602      * @return array of group IDs
 603      */
 604     protected function filterReplies($sender, &$attention_uris)
 605     {
 606         common_log(LOG_DEBUG, "Original reply recipients: " . implode(', ', $attention_uris));
 607         $groups = array();
 608         $replies = array();
 609         foreach ($attention_uris as $recipient) {
 610             // Is the recipient a local user?
 611             $user = User::staticGet('uri', $recipient);
 612             if ($user) {
 613                 // @fixme sender verification, spam etc?
 614                 $replies[] = $recipient;
 615                 continue;
 616             }
 617
 618             // Is the recipient a remote group?
 619             $oprofile = Ostatus_profile::staticGet('uri', $recipient);
 620             if ($oprofile) {
 621                 if ($oprofile->isGroup()) {
 622                     // Deliver to local members of this remote group.
 623                     // @fixme sender verification?
 624                     $groups[] = $oprofile->group_id;
 625                 } else {
 626                     common_log(LOG_DEBUG, "Skipping reply to remote profile $recipient");
 627                 }
 628                 continue;
 629             }
 630
 631             // Is the recipient a local group?
 632             // @fixme uri on user_group isn't reliable yet
 633             // $group = User_group::staticGet('uri', $recipient);
 634             $id = OStatusPlugin::localGroupFromUrl($recipient);
 635             if ($id) {
 636                 $group = User_group::staticGet('id', $id);
 637                 if ($group) {
 638                     // Deliver to all members of this local group if allowed.
 639                     $profile = $sender->localProfile();
 640                     if ($profile->isMember($group)) {
 641                         $groups[] = $group->id;
 642                     } else {
 643                         common_log(LOG_DEBUG, "Skipping reply to local group $group->nickname as sender $profile->id is not a member");
 644                     }
 645                     continue;
 646                 } else {
 647                     common_log(LOG_DEBUG, "Skipping reply to bogus group $recipient");
 648                 }
 649             }
 650
 651             common_log(LOG_DEBUG, "Skipping reply to unrecognized profile $recipient");
 652
 653         }
 654         $attention_uris = $replies;
 655         common_log(LOG_DEBUG, "Local reply recipients: " . implode(', ', $replies));
 656         common_log(LOG_DEBUG, "Local group recipients: " . implode(', ', $groups));
 657         return $groups;
 658     }
 659
 660     /**
 661      * @param string $profile_url
 662      * @return Ostatus_profile
 663      * @throws FeedSubException
 664      */
 665
 666     public static function ensureProfileURL($profile_url, $hints=array())
 667     {
 668         $oprofile = self::getFromProfileURL($profile_url);
 669
 670         if (!empty($oprofile)) {
 671             return $oprofile;
 672         }
 673
 674         $hints['profileurl'] = $profile_url;
 675
 676         // Fetch the URL
 677         // XXX: HTTP caching
 678
 679         $client = new HTTPClient();
 680         $client->setHeader('Accept', 'text/html,application/xhtml+xml');
 681         $response = $client->get($profile_url);
 682
 683         if (!$response->isOk()) {
 684             return null;
 685         }
 686
 687         // Check if we have a non-canonical URL
 688
 689         $finalUrl = $response->getUrl();
 690
 691         if ($finalUrl != $profile_url) {
 692
 693             $hints['profileurl'] = $finalUrl;
 694
 695             $oprofile = self::getFromProfileURL($finalUrl);
 696
 697             if (!empty($oprofile)) {
 698                 return $oprofile;
 699             }
 700         }
 701
 702         // Try to get some hCard data
 703
 704         $body = $response->getBody();
 705
 706         $hcardHints = DiscoveryHints::hcardHints($body, $finalUrl);
 707
 708         if (!empty($hcardHints)) {
 709             $hints = array_merge($hints, $hcardHints);
 710         }
 711
 712         // Check if they've got an LRDD header
 713
 714         $lrdd = LinkHeader::getLink($response, 'lrdd', 'application/xrd+xml');
 715
 716         if (!empty($lrdd)) {
 717
 718             $xrd = Discovery::fetchXrd($lrdd);
 719             $xrdHints = DiscoveryHints::fromXRD($xrd);
 720
 721             $hints = array_merge($hints, $xrdHints);
 722         }
 723
 724         // If discovery found a feedurl (probably from LRDD), use it.
 725
 726         if (array_key_exists('feedurl', $hints)) {
 727             return self::ensureFeedURL($hints['feedurl'], $hints);
 728         }
 729
 730         // Get the feed URL from HTML
 731
 732         $discover = new FeedDiscovery();
 733
 734         $feedurl = $discover->discoverFromHTML($finalUrl, $body);
 735
 736         if (!empty($feedurl)) {
 737             $hints['feedurl'] = $feedurl;
 738
 739             return self::ensureFeedURL($feedurl, $hints);
 740         }
 741     }
 742
 743     static function getFromProfileURL($profile_url)
 744     {
 745         $profile = Profile::staticGet('profileurl', $profile_url);
 746
 747         if (empty($profile)) {
 748             return null;
 749         }
 750
 751         // Is it a known Ostatus profile?
 752
 753         $oprofile = Ostatus_profile::staticGet('profile_id', $profile->id);
 754
 755         if (!empty($oprofile)) {
 756             return $oprofile;
 757         }
 758
 759         // Is it a local user?
 760
 761         $user = User::staticGet('id', $profile->id);
 762
 763         if (!empty($user)) {
 764             throw new Exception("'$profile_url' is the profile for local user '{$user->nickname}'.");
 765         }
 766
 767         // Continue discovery; it's a remote profile
 768         // for OMB or some other protocol, may also
 769         // support OStatus
 770
 771         return null;
 772     }
 773
 774     public static function ensureFeedURL($feed_url, $hints=array())
 775     {
 776         $discover = new FeedDiscovery();
 777
 778         $feeduri = $discover->discoverFromFeedURL($feed_url);
 779         $hints['feedurl'] = $feeduri;
 780
 781         $huburi = $discover->getAtomLink('hub');
 782         $hints['hub'] = $huburi;
 783         $salmonuri = $discover->getAtomLink(Salmon::NS_REPLIES);
 784         $hints['salmon'] = $salmonuri;
 785
 786         if (!$huburi) {
 787             // We can only deal with folks with a PuSH hub
 788             throw new FeedSubNoHubException();
 789         }
 790
 791         // Try to get a profile from the feed activity:subject
 792
 793         $feedEl = $discover->feed->documentElement;
 794
 795         $subject = ActivityUtils::child($feedEl, Activity::SUBJECT, Activity::SPEC);
 796
 797         if (!empty($subject)) {
 798             $subjObject = new ActivityObject($subject);
 799             return self::ensureActivityObjectProfile($subjObject, $hints);
 800         }
 801
 802         // Otherwise, try the feed author
 803
 804         $author = ActivityUtils::child($feedEl, Activity::AUTHOR, Activity::ATOM);
 805
 806         if (!empty($author)) {
 807             $authorObject = new ActivityObject($author);
 808             return self::ensureActivityObjectProfile($authorObject, $hints);
 809         }
 810
 811         // Sheesh. Not a very nice feed! Let's try fingerpoken in the
 812         // entries.
 813
 814         $entries = $discover->feed->getElementsByTagNameNS(Activity::ATOM, 'entry');
 815
 816         if (!empty($entries) && $entries->length > 0) {
 817
 818             $entry = $entries->item(0);
 819
 820             $actor = ActivityUtils::child($entry, Activity::ACTOR, Activity::SPEC);
 821
 822             if (!empty($actor)) {
 823                 $actorObject = new ActivityObject($actor);
 824                 return self::ensureActivityObjectProfile($actorObject, $hints);
 825
 826             }
 827
 828             $author = ActivityUtils::child($entry, Activity::AUTHOR, Activity::ATOM);
 829
 830             if (!empty($author)) {
 831                 $authorObject = new ActivityObject($author);
 832                 return self::ensureActivityObjectProfile($authorObject, $hints);
 833             }
 834         }
 835
 836         // XXX: make some educated guesses here
 837
 838         throw new FeedSubException("Can't find enough profile information to make a feed.");
 839     }
 840
 841     /**
 842      * Download and update given avatar image
 843      *
 844      * @param string $url
 845      * @throws Exception in various failure cases
 846      */
 847     protected function updateAvatar($url)
 848     {
 849         if ($url == $this->avatar) {
 850             // We've already got this one.
 851             return;
 852         }
 853         if (!common_valid_http_url($url)) {
 854             throw new ServerException(_m("Invalid avatar URL %s"), $url);
 855         }
 856
 857         if ($this->isGroup()) {
 858             $self = $this->localGroup();
 859         } else {
 860             $self = $this->localProfile();
 861         }
 862         if (!$self) {
 863             throw new ServerException(sprintf(
 864                 _m("Tried to update avatar for unsaved remote profile %s"),
 865                 $this->uri));
 866         }
 867
 868         // @fixme this should be better encapsulated
 869         // ripped from oauthstore.php (for old OMB client)
 870         $temp_filename = tempnam(sys_get_temp_dir(), 'listener_avatar');
 871         if (!copy($url, $temp_filename)) {
 872             throw new ServerException(sprintf(_m("Unable to fetch avatar from %s"), $url));
 873         }
 874
 875         if ($this->isGroup()) {
 876             $id = $this->group_id;
 877         } else {
 878             $id = $this->profile_id;
 879         }
 880         // @fixme should we be using different ids?
 881         $imagefile = new ImageFile($id, $temp_filename);
 882         $filename = Avatar::filename($id,
 883                                      image_type_to_extension($imagefile->type),
 884                                      null,
 885                                      common_timestamp());
 886         rename($temp_filename, Avatar::path($filename));
 887         $self->setOriginal($filename);
 888
 889         $orig = clone($this);
 890         $this->avatar = $url;
 891         $this->update($orig);
 892     }
 893
 894     /**
 895      * Pull avatar URL from ActivityObject or profile hints
 896      *
 897      * @param ActivityObject $object
 898      * @param array $hints
 899      * @return mixed URL string or false
 900      */
 901
 902     protected static function getActivityObjectAvatar($object, $hints=array())
 903     {
 904         if ($object->avatarLinks) {
 905             $best = false;
 906             // Take the exact-size avatar, or the largest avatar, or the first avatar if all sizeless
 907             foreach ($object->avatarLinks as $avatar) {
 908                 if ($avatar->width == AVATAR_PROFILE_SIZE && $avatar->height = AVATAR_PROFILE_SIZE) {
 909                     // Exact match!
 910                     $best = $avatar;
 911                     break;
 912                 }
 913                 if (!$best || $avatar->width > $best->width) {
 914                     $best = $avatar;
 915                 }
 916             }
 917             return $best->url;
 918         } else if (array_key_exists('avatar', $hints)) {
 919             return $hints['avatar'];
 920         }
 921         return false;
 922     }
 923
 924     /**
 925      * Get an appropriate avatar image source URL, if available.
 926      *
 927      * @param ActivityObject $actor
 928      * @param DOMElement $feed
 929      * @return string
 930      */
 931
 932     protected static function getAvatar($actor, $feed)
 933     {
 934         $url = '';
 935         $icon = '';
 936         if ($actor->avatar) {
 937             $url = trim($actor->avatar);
 938         }
 939         if (!$url) {
 940             // Check <atom:logo> and <atom:icon> on the feed
 941             $els = $feed->childNodes();
 942             if ($els && $els->length) {
 943                 for ($i = 0; $i < $els->length; $i++) {
 944                     $el = $els->item($i);
 945                     if ($el->namespaceURI == Activity::ATOM) {
 946                         if (empty($url) && $el->localName == 'logo') {
 947                             $url = trim($el->textContent);
 948                             break;
 949                         }
 950                         if (empty($icon) && $el->localName == 'icon') {
 951                             // Use as a fallback
 952                             $icon = trim($el->textContent);
 953                         }
 954                     }
 955                 }
 956             }
 957             if ($icon && !$url) {
 958                 $url = $icon;
 959             }
 960         }
 961         if ($url) {
 962             $opts = array('allowed_schemes' => array('http', 'https'));
 963             if (Validate::uri($url, $opts)) {
 964                 return $url;
 965             }
 966         }
 967         return common_path('plugins/OStatus/images/96px-Feed-icon.svg.png');
 968     }
 969
 970     /**
 971      * Fetch, or build if necessary, an Ostatus_profile for the actor
 972      * in a given Activity Streams activity.
 973      *
 974      * @param Activity $activity
 975      * @param string $feeduri if we already know the canonical feed URI!
 976      * @param string $salmonuri if we already know the salmon return channel URI
 977      * @return Ostatus_profile
 978      */
 979
 980     public static function ensureActorProfile($activity, $hints=array())
 981     {
 982         return self::ensureActivityObjectProfile($activity->actor, $hints);
 983     }
 984
 985     public static function ensureActivityObjectProfile($object, $hints=array())
 986     {
 987         $profile = self::getActivityObjectProfile($object);
 988         if ($profile) {
 989             $profile->updateFromActivityObject($object, $hints);
 990         } else {
 991             $profile = self::createActivityObjectProfile($object, $hints);
 992         }
 993         return $profile;
 994     }
 995
 996     /**
 997      * @param Activity $activity
 998      * @return mixed matching Ostatus_profile or false if none known
 999      */
1000     public static function getActorProfile($activity)
1001     {
1002         return self::getActivityObjectProfile($activity->actor);
1003     }
1004
1005     protected static function getActivityObjectProfile($object)
1006     {
1007         $uri = self::getActivityObjectProfileURI($object);
1008         return Ostatus_profile::staticGet('uri', $uri);
1009     }
1010
1011     protected static function getActorProfileURI($activity)
1012     {
1013         return self::getActivityObjectProfileURI($activity->actor);
1014     }
1015
1016     /**
1017      * @param Activity $activity
1018      * @return string
1019      * @throws ServerException
1020      */
1021     protected static function getActivityObjectProfileURI($object)
1022     {
1023         $opts = array('allowed_schemes' => array('http', 'https'));
1024         if ($object->id && Validate::uri($object->id, $opts)) {
1025             return $object->id;
1026         }
1027         if ($object->link && Validate::uri($object->link, $opts)) {
1028             return $object->link;
1029         }
1030         throw new ServerException("No author ID URI found");
1031     }
1032
1033     /**
1034      * @fixme validate stuff somewhere
1035      */
1036
1037     /**
1038      * Create local ostatus_profile and profile/user_group entries for
1039      * the provided remote user or group.
1040      *
1041      * @param ActivityObject $object
1042      * @param array $hints
1043      *
1044      * @return Ostatus_profile
1045      */
1046     protected static function createActivityObjectProfile($object, $hints=array())
1047     {
1048         $homeuri = $object->id;
1049         $discover = false;
1050
1051         if (!$homeuri) {
1052             common_log(LOG_DEBUG, __METHOD__ . " empty actor profile URI: " . var_export($activity, true));
1053             throw new Exception("No profile URI");
1054         }
1055
1056         if (OStatusPlugin::localProfileFromUrl($homeuri)) {
1057             throw new Exception("Local user can't be referenced as remote.");
1058         }
1059
1060         if (OStatusPlugin::localGroupFromUrl($homeuri)) {
1061             throw new Exception("Local group can't be referenced as remote.");
1062         }
1063
1064         if (array_key_exists('feedurl', $hints)) {
1065             $feeduri = $hints['feedurl'];
1066         } else {
1067             $discover = new FeedDiscovery();
1068             $feeduri = $discover->discoverFromURL($homeuri);
1069         }
1070
1071         if (array_key_exists('salmon', $hints)) {
1072             $salmonuri = $hints['salmon'];
1073         } else {
1074             if (!$discover) {
1075                 $discover = new FeedDiscovery();
1076                 $discover->discoverFromFeedURL($hints['feedurl']);
1077             }
1078             $salmonuri = $discover->getAtomLink(Salmon::NS_REPLIES);
1079         }
1080
1081         if (array_key_exists('hub', $hints)) {
1082             $huburi = $hints['hub'];
1083         } else {
1084             if (!$discover) {
1085                 $discover = new FeedDiscovery();
1086                 $discover->discoverFromFeedURL($hints['feedurl']);
1087             }
1088             $huburi = $discover->getAtomLink('hub');
1089         }
1090
1091         if (!$huburi) {
1092             // We can only deal with folks with a PuSH hub
1093             throw new FeedSubNoHubException();
1094         }
1095
1096         $oprofile = new Ostatus_profile();
1097
1098         $oprofile->uri        = $homeuri;
1099         $oprofile->feeduri    = $feeduri;
1100         $oprofile->salmonuri  = $salmonuri;
1101
1102         $oprofile->created    = common_sql_now();
1103         $oprofile->modified   = common_sql_now();
1104
1105         if ($object->type == ActivityObject::PERSON) {
1106             $profile = new Profile();
1107             $profile->created = common_sql_now();
1108             self::updateProfile($profile, $object, $hints);
1109
1110             $oprofile->profile_id = $profile->insert();
1111             if (!$oprofile->profile_id) {
1112                 throw new ServerException("Can't save local profile");
1113             }
1114         } else {
1115             $group = new User_group();
1116             $group->uri = $homeuri;
1117             $group->created = common_sql_now();
1118             self::updateGroup($group, $object, $hints);
1119
1120             $oprofile->group_id = $group->insert();
1121             if (!$oprofile->group_id) {
1122                 throw new ServerException("Can't save local profile");
1123             }
1124         }
1125
1126         $ok = $oprofile->insert();
1127
1128         if ($ok) {
1129             $avatar = self::getActivityObjectAvatar($object, $hints);
1130             if ($avatar) {
1131                 $oprofile->updateAvatar($avatar);
1132             }
1133             return $oprofile;
1134         } else {
1135             throw new ServerException("Can't save OStatus profile");
1136         }
1137     }
1138
1139     /**
1140      * Save any updated profile information to our local copy.
1141      * @param ActivityObject $object
1142      * @param array $hints
1143      */
1144     public function updateFromActivityObject($object, $hints=array())
1145     {
1146         if ($this->isGroup()) {
1147             $group = $this->localGroup();
1148             self::updateGroup($group, $object, $hints);
1149         } else {
1150             $profile = $this->localProfile();
1151             self::updateProfile($profile, $object, $hints);
1152         }
1153         $avatar = self::getActivityObjectAvatar($object, $hints);
1154         if ($avatar) {
1155             $this->updateAvatar($avatar);
1156         }
1157     }
1158
1159     protected static function updateProfile($profile, $object, $hints=array())
1160     {
1161         $orig = clone($profile);
1162
1163         $profile->nickname = self::getActivityObjectNickname($object, $hints);
1164
1165         if (!empty($object->title)) {
1166             $profile->fullname = $object->title;
1167         } else if (array_key_exists('fullname', $hints)) {
1168             $profile->fullname = $hints['fullname'];
1169         }
1170
1171         if (!empty($object->link)) {
1172             $profile->profileurl = $object->link;
1173         } else if (array_key_exists('profileurl', $hints)) {
1174             $profile->profileurl = $hints['profileurl'];
1175         } else if (Validate::uri($object->id, array('allowed_schemes' => array('http', 'https')))) {
1176             $profile->profileurl = $object->id;
1177         }
1178
1179         $profile->bio      = self::getActivityObjectBio($object, $hints);
1180         $profile->location = self::getActivityObjectLocation($object, $hints);
1181         $profile->homepage = self::getActivityObjectHomepage($object, $hints);
1182
1183         if (!empty($object->geopoint)) {
1184             $location = ActivityContext::locationFromPoint($object->geopoint);
1185             if (!empty($location)) {
1186                 $profile->lat = $location->lat;
1187                 $profile->lon = $location->lon;
1188             }
1189         }
1190
1191         // @fixme tags/categories
1192         // @todo tags from categories
1193
1194         if ($profile->id) {
1195             common_log(LOG_DEBUG, "Updating OStatus profile $profile->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1196             $profile->update($orig);
1197         }
1198     }
1199
1200     protected static function updateGroup($group, $object, $hints=array())
1201     {
1202         $orig = clone($group);
1203
1204         $group->nickname = self::getActivityObjectNickname($object, $hints);
1205         $group->fullname = $object->title;
1206
1207         if (!empty($object->link)) {
1208             $group->mainpage = $object->link;
1209         } else if (array_key_exists('profileurl', $hints)) {
1210             $group->mainpage = $hints['profileurl'];
1211         }
1212
1213         // @todo tags from categories
1214         $group->description = self::getActivityObjectBio($object, $hints);
1215         $group->location = self::getActivityObjectLocation($object, $hints);
1216         $group->homepage = self::getActivityObjectHomepage($object, $hints);
1217
1218         if ($group->id) {
1219             common_log(LOG_DEBUG, "Updating OStatus group $group->id from remote info $object->id: " . var_export($object, true) . var_export($hints, true));
1220             $group->update($orig);
1221         }
1222     }
1223
1224     protected static function getActivityObjectHomepage($object, $hints=array())
1225     {
1226         $homepage = null;
1227         $poco     = $object->poco;
1228
1229         if (!empty($poco)) {
1230             $url = $poco->getPrimaryURL();
1231             if ($url && $url->type == 'homepage') {
1232                 $homepage = $url->value;
1233             }
1234         }
1235
1236         // @todo Try for a another PoCo URL?
1237
1238         return $homepage;
1239     }
1240
1241     protected static function getActivityObjectLocation($object, $hints=array())
1242     {
1243         $location = null;
1244
1245         if (!empty($object->poco) &&
1246             isset($object->poco->address->formatted)) {
1247             $location = $object->poco->address->formatted;
1248         } else if (array_key_exists('location', $hints)) {
1249             $location = $hints['location'];
1250         }
1251
1252         if (!empty($location)) {
1253             if (mb_strlen($location) > 255) {
1254                 $location = mb_substr($note, 0, 255 - 3) . ' … ';
1255             }
1256         }
1257
1258         // @todo Try to find location some othe way? Via goerss point?
1259
1260         return $location;
1261     }
1262
1263     protected static function getActivityObjectBio($object, $hints=array())
1264     {
1265         $bio  = null;
1266
1267         if (!empty($object->poco)) {
1268             $note = $object->poco->note;
1269         } else if (array_key_exists('bio', $hints)) {
1270             $note = $hints['bio'];
1271         }
1272
1273         if (!empty($note)) {
1274             if (Profile::bioTooLong($note)) {
1275                 // XXX: truncate ok?
1276                 $bio = mb_substr($note, 0, Profile::maxBio() - 3) . ' … ';
1277             } else {
1278                 $bio = $note;
1279             }
1280         }
1281
1282         // @todo Try to get bio info some other way?
1283
1284         return $bio;
1285     }
1286
1287     protected static function getActivityObjectNickname($object, $hints=array())
1288     {
1289         if ($object->poco) {
1290             if (!empty($object->poco->preferredUsername)) {
1291                 return common_nicknamize($object->poco->preferredUsername);
1292             }
1293         }
1294
1295         if (!empty($object->nickname)) {
1296             return common_nicknamize($object->nickname);
1297         }
1298
1299         if (array_key_exists('nickname', $hints)) {
1300             return $hints['nickname'];
1301         }
1302
1303         // Try the definitive ID
1304
1305         $nickname = self::nicknameFromURI($object->id);
1306
1307         // Try a Webfinger if one was passed (way) down
1308
1309         if (empty($nickname)) {
1310             if (array_key_exists('webfinger', $hints)) {
1311                 $nickname = self::nicknameFromURI($hints['webfinger']);
1312             }
1313         }
1314
1315         // Try the name
1316
1317         if (empty($nickname)) {
1318             $nickname = common_nicknamize($object->title);
1319         }
1320
1321         return $nickname;
1322     }
1323
1324     protected static function nicknameFromURI($uri)
1325     {
1326         preg_match('/(\w+):/', $uri, $matches);
1327
1328         $protocol = $matches[1];
1329
1330         switch ($protocol) {
1331         case 'acct':
1332         case 'mailto':
1333             if (preg_match("/^$protocol:(.*)?@.*\$/", $uri, $matches)) {
1334                 return common_canonical_nickname($matches[1]);
1335             }
1336             return null;
1337         case 'http':
1338             return common_url_to_nickname($uri);
1339             break;
1340         default:
1341             return null;
1342         }
1343     }
1344
1345     /**
1346      * @param string $addr webfinger address
1347      * @return Ostatus_profile
1348      * @throws Exception on error conditions
1349      */
1350     public static function ensureWebfinger($addr)
1351     {
1352         // First, try the cache
1353
1354         $uri = self::cacheGet(sprintf('ostatus_profile:webfinger:%s', $addr));
1355
1356         if ($uri !== false) {
1357             if (is_null($uri)) {
1358                 // Negative cache entry
1359                 throw new Exception('Not a valid webfinger address.');
1360             }
1361             $oprofile = Ostatus_profile::staticGet('uri', $uri);
1362             if (!empty($oprofile)) {
1363                 return $oprofile;
1364             }
1365         }
1366
1367         // Try looking it up
1368
1369         $oprofile = Ostatus_profile::staticGet('uri', 'acct:'.$addr);
1370
1371         if (!empty($oprofile)) {
1372             self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1373             return $oprofile;
1374         }
1375
1376         // Now, try some discovery
1377
1378         $disco = new Discovery();
1379
1380         try {
1381             $xrd = $disco->lookup($addr);
1382         } catch (Exception $e) {
1383             // Save negative cache entry so we don't waste time looking it up again.
1384             // @fixme distinguish temporary failures?
1385             self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), null);
1386             throw new Exception('Not a valid webfinger address.');
1387         }
1388
1389         $hints = array('webfinger' => $addr);
1390
1391         $dhints = DiscoveryHints::fromXRD($xrd);
1392
1393         $hints = array_merge($hints, $dhints);
1394
1395         // If there's an Hcard, let's grab its info
1396
1397         if (array_key_exists('hcard', $hints)) {
1398             if (!array_key_exists('profileurl', $hints) ||
1399                 $hints['hcard'] != $hints['profileurl']) {
1400                 $hcardHints = DiscoveryHints::fromHcardUrl($hints['hcard']);
1401                 $hints = array_merge($hcardHints, $hints);
1402             }
1403         }
1404
1405         // If we got a feed URL, try that
1406
1407         if (array_key_exists('feedurl', $hints)) {
1408             try {
1409                 common_log(LOG_INFO, "Discovery on acct:$addr with feed URL " . $hints['feedurl']);
1410                 $oprofile = self::ensureFeedURL($hints['feedurl'], $hints);
1411                 self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1412                 return $oprofile;
1413             } catch (Exception $e) {
1414                 common_log(LOG_WARNING, "Failed creating profile from feed URL '$feedUrl': " . $e->getMessage());
1415                 // keep looking
1416             }
1417         }
1418
1419         // If we got a profile page, try that!
1420
1421         if (array_key_exists('profileurl', $hints)) {
1422             try {
1423                 common_log(LOG_INFO, "Discovery on acct:$addr with profile URL $profileUrl");
1424                 $oprofile = self::ensureProfileURL($hints['profileurl'], $hints);
1425                 self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1426                 return $oprofile;
1427             } catch (Exception $e) {
1428                 common_log(LOG_WARNING, "Failed creating profile from profile URL '$profileUrl': " . $e->getMessage());
1429                 // keep looking
1430             }
1431         }
1432
1433         // XXX: try hcard
1434         // XXX: try FOAF
1435
1436         if (array_key_exists('salmon', $hints)) {
1437
1438             $salmonEndpoint = $hints['salmon'];
1439
1440             // An account URL, a salmon endpoint, and a dream? Not much to go
1441             // on, but let's give it a try
1442
1443             $uri = 'acct:'.$addr;
1444
1445             $profile = new Profile();
1446
1447             $profile->nickname = self::nicknameFromUri($uri);
1448             $profile->created  = common_sql_now();
1449
1450             if (isset($profileUrl)) {
1451                 $profile->profileurl = $profileUrl;
1452             }
1453
1454             $profile_id = $profile->insert();
1455
1456             if (!$profile_id) {
1457                 common_log_db_error($profile, 'INSERT', __FILE__);
1458                 throw new Exception("Couldn't save profile for '$addr'");
1459             }
1460
1461             $oprofile = new Ostatus_profile();
1462
1463             $oprofile->uri        = $uri;
1464             $oprofile->salmonuri  = $salmonEndpoint;
1465             $oprofile->profile_id = $profile_id;
1466             $oprofile->created    = common_sql_now();
1467
1468             if (isset($feedUrl)) {
1469                 $profile->feeduri = $feedUrl;
1470             }
1471
1472             $result = $oprofile->insert();
1473
1474             if (!$result) {
1475                 common_log_db_error($oprofile, 'INSERT', __FILE__);
1476                 throw new Exception("Couldn't save ostatus_profile for '$addr'");
1477             }
1478
1479             self::cacheSet(sprintf('ostatus_profile:webfinger:%s', $addr), $oprofile->uri);
1480             return $oprofile;
1481         }
1482
1483         throw new Exception("Couldn't find a valid profile for '$addr'");
1484     }
1485
1486     function saveHTMLFile($title, $rendered)
1487     {
1488         $final = sprintf("<!DOCTYPE html>\n<html><head><title>%s</title></head>".
1489                          '<body><div>%s</div></body></html>',
1490                          htmlspecialchars($title),
1491                          $rendered);
1492
1493         $filename = File::filename($this->localProfile(),
1494                                    'ostatus', // ignored?
1495                                    'text/html');
1496
1497         $filepath = File::path($filename);
1498
1499         file_put_contents($filepath, $final);
1500
1501         $file = new File;
1502
1503         $file->filename = $filename;
1504         $file->url      = File::url($filename);
1505         $file->size     = filesize($filepath);
1506         $file->date     = time();
1507         $file->mimetype = 'text/html';
1508
1509         $file_id = $file->insert();
1510
1511         if ($file_id === false) {
1512             common_log_db_error($file, "INSERT", __FILE__);
1513             throw new ServerException(_('Could not store HTML content of long post as file.'));
1514         }
1515
1516         return $file;
1517     }
1518 }