git.m6w6.name Git - pharext/pharext.org/blob - app/Controller/Github/Hook/Receive.php

   1 <?php
   2
   3 namespace app\Controller\Github\Hook;
   4
   5 use app\Controller;
   6 use app\Github\API;
   7 use app\Model\Accounts;
   8 use app\Web;
   9 use http\Params;
  10 use pharext\Task;
  11 use pharext\Metadata;
  12 use pharext\SourceDir;
  13
  14 class Receive implements Controller
  15 {
  16         private $app;
  17         private $github;
  18         private $accounts;
  19
  20         function __construct(Web $app, API $github, Accounts $accounts) {
  21                 $this->app = $app;
  22                 $this->github = $github;
  23                 $this->accounts = $accounts;
  24         }
  25
  26         function __invoke(array $args = []) {
  27                 $request = $this->app->getRequest();
  28                 $response = $this->app->getResponse();
  29
  30                 if (!($sig = $request->getHeader("X-Hub-Signature")) || !($evt = $request->getHeader("X-Github-Event"))) {
  31                         $response->setResponseCode(400);
  32                         $response->setContentType("message/http");
  33                         $response->getBody()->append($request);
  34                 } else {
  35                         $key = $this->github->getConfig()->client->secret;
  36                         foreach ((new Params($sig))->params as $algo => $mac) {
  37                                 if ($mac["value"] !== hash_hmac($algo, $request->getBody(), $key)) {
  38                                         $response->setResponseCode(403);
  39                                         $response->getBody()->append("Invalid signature");
  40                                         return;
  41                                 }
  42                         }
  43                 }
  44
  45                 switch ($evt) {
  46                         default:
  47                                 $response->setResponseCode(202);
  48                                 $response->getBody()->append("Not a configured event");
  49                                 break;
  50                         case "ping";
  51                                 $response->setResponseCode(204);
  52                                 $response->setResponseStatus("PONG");
  53                                 break;
  54                         case "create":
  55                         case "release":
  56                                 if (($json = json_decode($request->getBody()))) {
  57                                         $this->$evt($json);
  58                                 } else {
  59                                         $response->setResponseCode(415);
  60                                         $response->setContentType($request->getHeader("Content-Type"));
  61                                         $response->getBody()->append($request->getBody());
  62                                 }
  63                                 break;
  64                 }
  65         }
  66
  67         function release($release) {
  68                 if ($release->action !== "published") {
  69                         $response = $this->app->getResponse();
  70                         $response->setResponseCode(202);
  71                         $response->getBody()->append("Not published");
  72                         return;
  73                 }
  74                 if (!empty($release->release->assets)) {
  75                         foreach ($release->release->assets as $asset) {
  76                                 if ($asset->content_type === "application/phar") {
  77                                         /* we've already uploaded the asset when we created the release */
  78                                         $response = $this->app->getResponse();
  79                                         $response->setResponseCode(202);
  80                                         $response->getBody()->append("Already published");
  81                                         return;
  82                                 }
  83                         }
  84                 }
  85
  86                 $this->uploadAssetForRelease($release->release, $release->repository)->send();
  87         }
  88
  89         private function uploadAssetForRelease($release, $repo) {
  90                 $this->setTokenForUser($repo->owner->login);
  91                 return $this->github->listHooks($repo->full_name, function($hooks) use($release, $repo) {
  92                         $repo->hooks = $hooks;
  93                         $asset = $this->createReleaseAsset($release, $repo);
  94                         $name = sprintf("%s-%s.ext.phar", $repo->name, $release->tag_name);
  95                         $url = uri_template($release->upload_url, compact("name"));
  96                         $this->github->createReleaseAsset($url, $asset, "application/phar", function($json) use($release, $repo) {
  97                                 if ($release->draft) {
  98                                         $this->github->publishRelease($repo->full_name, $release->id, $release->tag_name, function($json) {
  99                                                 $response = $this->app->getResponse();
 100                                                 $response->setResponseCode(201);
 101                                                 $response->setHeader("Location", $json->url);
 102                                         });
 103                                 } else {
 104                                         $response = $this->app->getResponse();
 105                                         $response->setResponseCode(201);
 106                                         $response->setHeader("Location", $json->url);
 107                                 }
 108                         });
 109                 });
 110         }
 111
 112         private function createReleaseAsset($release, $repo) {
 113                 $hook = $this->github->checkRepoHook($repo);
 114                 $dir = (new Task\GitClone($repo->clone_url, $release->tag_name))->run();
 115                 if (!empty($hook->config->pecl)) {
 116                         $src = new SoureDir\Pecl($dir);
 117                 } else {
 118                         $src = new SourceDir\Git($dir);
 119                 }
 120                 $meta = Metadata::all() + [
 121                         "name" => $repo->name,
 122                         "release" => $release->tag_name,
 123                         "license" => $src->getLicense(),
 124                         "stub" => "pharext_installer.php",
 125                         "type" => !empty($hook->config->zend) ? "zend_extension" : "extension",
 126                 ];
 127                 $file = (new Task\PharBuild($src, $meta))->run();
 128                 return $file;
 129         }
 130
 131         function create($create) {
 132                 if ($create->ref_type !== "tag") {
 133                         $response = $this->app->getResponse();
 134
 135                         $response->setResponseCode(202);
 136                         $response->getBody()->append("Not a tag");
 137                         return;
 138                 }
 139
 140                 $this->createReleaseFromTag($create->ref, $create->repository)->send();
 141         }
 142
 143         private function setTokenForUser($login) {
 144                 $relations = [
 145                         $this->accounts->getTokens()->getRelation("accounts"),
 146                         $this->accounts->getOwners()->getRelation("accounts")
 147                 ];
 148                 $tokens = $this->accounts->getTokens()->with($relations, [
 149                         "login=" => $login,
 150                         "tokens.authority=" => "github",
 151                 ]);
 152
 153                 if (count($tokens)) {
 154                         $this->github->setToken($tokens->current()->token->get());
 155                 }
 156         }
 157
 158         private function createReleaseFromTag($tag, $repo) {
 159                 $this->setTokenForUser($repo->owner->login);
 160                 return $this->github->createRelease($repo->full_name, $tag, function($json) use($repo) {
 161                         $this->uploadAssetForRelease($json, $repo);
 162                 });
 163         }
 164 }