danog
/
MadelineProto
2
2
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor and clean up serialization and APIFactory APIs, automatically unreference instance on destruction to clean up memory

This commit is contained in:
Daniil Gentili 2020-02-25 18:02:32 +01:00
parent 82599e686e
commit b5267beaa2
Signed by: danog
GPG Key ID: 8C1BE3B34B230CA7
20 changed files with 779 additions and 493 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

392
src/danog/MadelineProto/API.php
View File

@ -19,13 +19,6 @@
namespace danog\MadelineProto;
use Amp\Deferred;
use Amp\Promise;
use function Amp\File\exists;
use function Amp\File\get;
use function Amp\File\put;
use function Amp\File\rename as renameAsync;
if (!\defined('MADELINEPROTO_TEST')) {
\define('MADELINEPROTO_TEST', 'NOT PONY');
}
@ -36,16 +29,31 @@ if (!\defined('MADELINEPROTO_TEST')) {
class API extends InternalDoc
{
use \danog\Serializable;
use \danog\MadelineProto\Wrappers\ApiStart;
use \danog\MadelineProto\Wrappers\ApiTemplates;
public $session;
public $serialized = 0;
use \danog\MadelineProto\ApiWrappers\Start;
use \danog\MadelineProto\ApiWrappers\Templates;
/**
* Session path.
*
* @internal
*
* @var string
*/
public string $session = '';
/**
* Instance of MadelineProto.
*
* @var MTProto
* @var ?MTProto
*/
public $API;
/**
* Storage for externally set properties to be serialized.
*
* @var array
*/
protected array $storage = [];
/**
* Whether we're getting our API ID.
*
@ -53,172 +61,107 @@ class API extends InternalDoc
*
* @var boolean
*/
public $getting_api_id = false;
private bool $gettingApiId = false;
/**
* my.telegram.org API wrapper.
*
* @internal
*
* @var MyTelegramOrgWrapper
* @var ?MyTelegramOrgWrapper
*/
public $my_telegram_org_wrapper;
private $myTelegramOrgWrapper;
/**
* Async ini tpromise.
* Whether this is an old instance.
*
* @var Promise
* @var boolean
*/
public $asyncAPIPromise;
private $oldInstance = false;
private $destructing = false;
private bool $oldInstance = false;
/**
* Whether we're destructing.
*
* @var boolean
*/
private bool $destructing = false;
/**
* API wrapper (to avoid circular references).
*
* @var APIWrapper
*/
private $wrapper;
/**
* Magic constructor function.
*
* @param array $params Params
* @param array $settings Settings
* @param string $session Session name
* @param array $settings Settings
*
* @return void
*/
public function __magic_construct($params = [], $settings = []): void
public function __magic_construct(string $session, array $settings = []): void
{
$this->wrapper = new APIWrapper($this, $this->exportNamespace());
Magic::classExists();
$deferred = new Deferred();
$this->asyncAPIPromise = $deferred->promise();
$this->asyncAPIPromise->onResolve(function () {
$this->asyncAPIPromise = null;
});
$this->setInitPromise($this->__construct_async($params, $settings, $deferred));
foreach (\get_object_vars(new APIFactory('', $this, $this->async)) as $key => $var) {
if (\in_array($key, ['namespace', 'API', 'lua', 'async', 'asyncAPIPromise', 'methods', 'asyncInitPromise'])) {
$this->setInitPromise($this->__construct_async($session, $settings));
foreach (\get_class_vars(APIFactory::class) as $key => $var) {
if (\in_array($key, ['namespace', 'API', 'lua', 'async', 'asyncAPIPromise', 'methods'])) {
continue;
}
if (\is_null($this->{$key})) {
$this->{$key} = new APIFactory($key, $this->API, $this->async);
if (!$this->{$key}) {
$this->{$key} = $this->exportNamespace($key);
}
}
}
/**
* Async constructor function.
*
* @param mixed $params Params
* @param mixed $settings Settings
* @param mixed $deferred Deferred
* @param string $session Session name
* @param array $settings Settings
*
* @return \Generator
*/
public function __construct_async($params, $settings, $deferred): \Generator
public function __construct_async(string $session, array $settings = []): \Generator
{
if (\is_string($params)) {
Logger::constructorFromSettings($settings);
$realpaths = Serialization::realpaths($params);
$this->session = $realpaths['file'];
if (yield exists($realpaths['file'])) {
Logger::log('Waiting for shared lock of serialization lockfile...');
$unlock = yield Tools::flock($realpaths['lockfile'], LOCK_SH);
Logger::log('Shared lock acquired, deserializing...');
try {
$tounserialize = yield get($realpaths['file']);
} finally {
$unlock();
}
\danog\MadelineProto\Magic::classExists();
try {
$unserialized = \unserialize($tounserialize);
} catch (\danog\MadelineProto\Bug74586Exception $e) {
\class_exists('\\Volatile');
$tounserialize = \str_replace('O:26:"danog\\MadelineProto\\Button":', 'O:35:"danog\\MadelineProto\\TL\\Types\\Button":', $tounserialize);
foreach (['RSA', 'TL\\TLMethods', 'TL\\TLConstructors', 'MTProto', 'API', 'DataCenter', 'Connection', 'TL\\Types\\Button', 'TL\\Types\\Bytes', 'APIFactory'] as $class) {
\class_exists('\\danog\\MadelineProto\\' . $class);
}
$unserialized = \danog\Serialization::unserialize($tounserialize);
} catch (\danog\MadelineProto\Exception $e) {
if ($e->getFile() === 'MadelineProto' && $e->getLine() === 1) {
throw $e;
}
if (\MADELINEPROTO_TEST === 'pony') {
throw $e;
}
\class_exists('\\Volatile');
foreach (['RSA', 'TL\\TLMethods', 'TL\\TLConstructors', 'MTProto', 'API', 'DataCenter', 'Connection', 'TL\\Types\\Button', 'TL\\Types\\Bytes', 'APIFactory'] as $class) {
\class_exists('\\danog\\MadelineProto\\' . $class);
}
$changed = false;
if (\strpos($tounserialize, 'O:26:"danog\\MadelineProto\\Button":') !== false) {
Logger::log("SUBBING BUTTONS!");
$tounserialize = \str_replace('O:26:"danog\\MadelineProto\\Button":', 'O:35:"danog\\MadelineProto\\TL\\Types\\Button":', $tounserialize);
$changed = true;
}
if (\strpos($e->getMessage(), "Erroneous data format for unserializing 'phpseclib\\Math\\BigInteger'") === 0) {
Logger::log("SUBBING BIGINTEGOR!");
$tounserialize = \str_replace('phpseclib\\Math\\BigInteger', 'phpseclib\\Math\\BigIntegor', $tounserialize);
$changed = true;
}
if (\strpos($tounserialize, 'C:25:"phpseclib\\Math\\BigInteger"') !== false) {
Logger::log("SUBBING TGSECLIB old!");
$tounserialize = \str_replace('C:25:"phpseclib\\Math\\BigInteger"', 'C:24:"tgseclib\\Math\\BigInteger"', $tounserialize);
$changed = true;
}
if (\strpos($tounserialize, 'C:26:"phpseclib3\\Math\\BigInteger"') !== false) {
Logger::log("SUBBING TGSECLIB!");
$tounserialize = \str_replace('C:26:"phpseclib3\\Math\\BigInteger"', 'C:24:"tgseclib\\Math\\BigInteger"', $tounserialize);
$changed = true;
}
Logger::log((string) $e, Logger::ERROR);
if (!$changed) {
throw $e;
}
try {
$unserialized = \danog\Serialization::unserialize($tounserialize);
} catch (\Throwable $e) {
$unserialized = \unserialize($tounserialize);
}
} catch (\Throwable $e) {
Logger::log((string) $e, Logger::ERROR);
throw $e;
}
if ($unserialized instanceof \danog\PlaceHolder) {
$unserialized = \danog\Serialization::unserialize($tounserialize);
}
if ($unserialized === false) {
throw new Exception(\danog\MadelineProto\Lang::$current_lang['deserialization_error']);
}
$this->web_api_template = $unserialized->web_api_template;
$this->my_telegram_org_wrapper = $unserialized->my_telegram_org_wrapper;
$this->getting_api_id = $unserialized->getting_api_id;
if (isset($unserialized->API)) {
$this->API = $unserialized->API;
$this->APIFactory();
$unserialized->oldInstance = true;
$deferred->resolve();
yield from $this->API->initAsynchronously();
$this->APIFactory();
//\danog\MadelineProto\Logger::log('Ping...', Logger::ULTRA_VERBOSE);
$this->asyncInitPromise = null;
//$pong = yield $this->ping(['ping_id' => 3], ['async' => true]);
//\danog\MadelineProto\Logger::log('Pong: '.$pong['ping_id'], Logger::ULTRA_VERBOSE);
\danog\MadelineProto\Logger::log(\danog\MadelineProto\Lang::$current_lang['madelineproto_ready'], Logger::NOTICE);
return;
}
}
$params = $settings;
}
Logger::constructorFromSettings($settings);
if (!isset($params['app_info']['api_id']) || !$params['app_info']['api_id']) {
$app = (yield from $this->APIStart($params));
$params['app_info']['api_id'] = $app['api_id'];
$params['app_info']['api_hash'] = $app['api_hash'];
$session = Absolute::absolute($session);
if ($unserialized = yield from Serialization::legacyUnserialize($session)) {
$unserialized->storage = $unserialized->storage ?? [];
$unserialized->session = $session;
APIWrapper::link($this, $unserialized);
APIWrapper::link($this->wrapper, $this);
var_dump($this, $unserialized);
if (isset($this->API)) {
$this->storage = $this->API->storage ?? $this->storage;
unset($unserialized);
yield from $this->API->initAsynchronously();
$this->APIFactory();
$this->logger->logger(Lang::$current_lang['madelineproto_ready'], Logger::NOTICE);
return;
}
}
$this->API = new MTProto($params);
$this->APIFactory();
$deferred->resolve();
Logger::log(\danog\MadelineProto\Lang::$current_lang['apifactory_start'], Logger::VERBOSE);
if (!isset($settings['app_info']['api_id']) || !$settings['app_info']['api_id']) {
$app = (yield from $this->APIStart($settings));
if (!$app) {
$this->forceInit(true);
die();
}
$settings['app_info']['api_id'] = $app['api_id'];
$settings['app_info']['api_hash'] = $app['api_hash'];
}
$this->API = new MTProto($settings);
yield from $this->API->initAsynchronously();
$this->APIFactory();
$this->asyncInitPromise = null;
//\danog\MadelineProto\Logger::log('Ping...', Logger::ULTRA_VERBOSE);
//$pong = yield $this->ping(['ping_id' => 3], ['async' => true]);
//\danog\MadelineProto\Logger::log('Pong: '.$pong['ping_id'], Logger::ULTRA_VERBOSE);
\danog\MadelineProto\Logger::log(\danog\MadelineProto\Lang::$current_lang['madelineproto_ready'], Logger::NOTICE);
$this->logger->logger(Lang::$current_lang['madelineproto_ready'], Logger::NOTICE);
}
/**
* Enable or disable async.
*
@ -228,9 +171,9 @@ class API extends InternalDoc
*/
public function async(bool $async): void
{
$this->async = $async;
parent::async($async);
if ($this->API) {
if ($this->API->event_handler && \class_exists($this->API->event_handler) && \is_subclass_of($this->API->event_handler, '\\danog\\MadelineProto\\EventHandler')) {
if ($this->API->event_handler && \class_exists($this->API->event_handler) && \is_subclass_of($this->API->event_handler, EventHandler::class)) {
$this->API->setEventHandler($this->API->event_handler);
}
}
@ -242,23 +185,27 @@ class API extends InternalDoc
*/
public function __destruct()
{
if (\danog\MadelineProto\Magic::$has_thread && \is_object(\Thread::getCurrentThread()) || Magic::isFork()) {
return;
}
if ($this->asyncInitPromise) {
$this->init();
}
$this->init();
if (!$this->oldInstance) {
$this->logger('Shutting down MadelineProto (API)');
if ($this->API) {
$this->API->logger('Shutting down MadelineProto (normally or due to an exception, idk)');
$this->API->destructing = true;
} else {
Logger::log('Shutting down MadelineProto (normally or due to an exception, idk)');
}
$this->destructing = true;
Tools::wait($this->serialize(), true);
Tools::wait($this->wrapper->serialize(), true);
$this->API->unreference();
} else {
$this->logger('Shutting down MadelineProto (old deserialized instance of API)');
}
//restore_error_handler();
}
/**
* Wakeup function
*
* @return void
*/
public function __wakeup(): void
{
$this->oldInstance = true;
}
/**
* Sleep function.
@ -269,18 +216,7 @@ class API extends InternalDoc
*/
public function __sleep(): array
{
return ['API', 'web_api_template', 'getting_api_id', 'my_telegram_org_wrapper'];
}
/**
* Custom fast getSelf.
*
* @internal
*
* @return array|false
*/
public function myGetSelf()
{
return isset($this->API) && isset($this->API->authorization['user']) ? $this->API->authorization['user'] : false;
return APIWrapper::__sleep();
}
/**
* Init API wrapper.
@ -289,122 +225,20 @@ class API extends InternalDoc
*/
private function APIFactory(): void
{
if ($this->API && !$this->API->asyncInitPromise) {
if ($this->API && $this->API->inited()) {
foreach ($this->API->getMethodNamespaces() as $namespace) {
$this->{$namespace} = new APIFactory($namespace, $this->API, $this->async);
}
$methods = \get_class_methods($this->API);
foreach ($methods as $method) {
if ($method == 'methodCallAsyncRead') {
unset($methods[\array_search('methodCall', $methods)]);
} elseif (\stripos($method, 'async') !== false) {
if (\strpos($method, '_async') !== false) {
unset($methods[\array_search(\str_ireplace('_async', '', $method), $methods)]);
} else {
unset($methods[\array_search(\str_ireplace('async', '', $method), $methods)]);
}
if (!$this->{$namespace}) {
$this->{$namespace} = $this->exportNamespace($namespace);
}
}
$this->methods = [];
foreach ($methods as $method) {
$actual_method = $method;
if ($method == 'methodCallAsyncRead') {
$method = 'methodCall';
} elseif (\stripos($method, 'async') !== false) {
if (\strpos($method, '_async') !== false) {
$method = \str_ireplace('_async', '', $method);
} else {
$method = \str_ireplace('async', '', $method);
}
}
$actual_method = $actual_method === 'getSelf' ? [$this, 'myGetSelf'] : [$this->API, $actual_method];
$this->methods[\strtolower($method)] = $actual_method;
if (\strpos($method, '_') !== false) {
$this->methods[\strtolower(\str_replace('_', '', $method))] = $actual_method;
} else {
$this->methods[\strtolower(Tools::fromCamelCase($method))] = $actual_method;
}
}
$this->API->wrapper = $this;
if ($this->API->event_handler && \class_exists($this->API->event_handler) && \is_subclass_of($this->API->event_handler, '\\danog\\MadelineProto\\EventHandler')) {
$this->methods = self::getInternalMethodList($this->API);
$this->API->wrapper = $this->wrapper;
if ($this->API->event_handler && \class_exists($this->API->event_handler) && \is_subclass_of($this->API->event_handler, EventHandler::class)) {
$this->API->setEventHandler($this->API->event_handler);
}
}
}
/**
* Get full list of MTProto and API methods.
*
* @return array
*/
public function getAllMethods(): array
{
if ($this->asyncInitPromise) {
$this->init();
}
$methods = [];
foreach ($this->API->methods->by_id as $method) {
$methods[] = $method['method'];
}
return \array_merge($methods, \get_class_methods($this->API));
}
/**
* Serialize session.
*
* @param string $filename File name
*
* @internal Do not use this manually, the session is already serialized automatically
*
* @return Promise
*/
public function serialize(string $filename = ''): Promise
{
return Tools::callFork((function () use ($filename): \Generator {
if (empty($filename)) {
$filename = $this->session;
}
//Logger::log(\danog\MadelineProto\Lang::$current_lang['serializing_madelineproto']);
if ($filename == '') {
return;
}
if (isset($this->API->flushSettings) && $this->API->flushSettings) {
$this->API->flushSettings = false;
$this->API->__construct($this->API->settings);
}
if ($this->API === null && !$this->getting_api_id) {
return false;
}
if ($this->API && $this->API->asyncInitPromise) {
yield from $this->API->initAsynchronously();
}
$this->serialized = \time();
$realpaths = Serialization::realpaths($filename);
//Logger::log('Waiting for exclusive lock of serialization lockfile...');
$unlock = yield Tools::flock($realpaths['lockfile'], LOCK_EX);
//Logger::log('Lock acquired, serializing');
try {
if (!$this->getting_api_id) {
$update_closure = $this->API->settings['updates']['callback'];
if ($this->API->settings['updates']['callback'] instanceof \Closure) {
$this->API->settings['updates']['callback'] = [$this->API, 'noop'];
}
$logger_closure = $this->API->settings['logger']['logger_param'];
if ($this->API->settings['logger']['logger_param'] instanceof \Closure) {
$this->API->settings['logger']['logger_param'] = [$this->API, 'noop'];
}
}
$wrote = yield put($realpaths['tempfile'], \serialize($this));
yield renameAsync($realpaths['tempfile'], $realpaths['file']);
} finally {
if (!$this->getting_api_id) {
$this->API->settings['updates']['callback'] = $update_closure;
$this->API->settings['logger']['logger_param'] = $logger_closure;
}
$unlock();
}
//Logger::log('Done serializing');
return $wrote;
})());
}
/**
* Start MadelineProto and the event handler (enables async).
@ -428,10 +262,10 @@ class API extends InternalDoc
$this->loop();
} catch (\Throwable $e) {
$thrown = true;
$this->logger((string) $e, Logger::FATAL_ERROR);
try {
$this->report("Surfaced: $e");
} catch (\Throwable $e) {
$this->logger((string) $e, Logger::FATAL_ERROR);
}
}
} while ($thrown);

188
src/danog/MadelineProto/APIWrapper.php Normal file
View File

@ -0,0 +1,188 @@
<?php
/**
* API wrapper module.
*
* This file is part of MadelineProto.
* MadelineProto is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
* MadelineProto is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Affero General Public License for more details.
* You should have received a copy of the GNU General Public License along with MadelineProto.
* If not, see <http://www.gnu.org/licenses/>.
*
* @author Daniil Gentili <daniil@daniil.it>
* @copyright 2016-2020 Daniil Gentili <daniil@daniil.it>
* @license https://opensource.org/licenses/AGPL-3.0 AGPLv3
*
* @link https://docs.madelineproto.xyz MadelineProto documentation
*/
namespace danog\MadelineProto;
use Amp\Promise;
use Amp\Success;
use function Amp\File\put;
use function Amp\File\rename as renameAsync;
final class APIWrapper
{
/**
* MTProto instance.
*
* @var ?MTProto
*/
private ?MTProto $API = null;
/**
* Session path.
*
* @var string
*/
public string $session = '';
/**
* Getting API ID flag.
*
* @var bool
*/
private bool $gettingApiId = false;
/**
* Web API template
*
* @var string
*/
private string $webApiTemplate = '';
/**
* My.telegram.org wrapper
*
* @var ?MyTelegramOrgWrapper
*/
private $myTelegramOrgWrapper;
/**
* Serialization date.
*
* @var integer
*/
private int $serialized = 0;
/**
* AbstractAPIFactory instance
*
* @var AbstractAPIFactory
*/
private AbstractAPIFactory $factory;
/**
* API wrapper
*
* @param API $API API instance to wrap
* @param AbstractAPIFactory $factory Factory
*/
public function __construct(API $API, AbstractAPIFactory $factory)
{
self::link($this, $API);
$this->factory = $factory;
}
/**
* Link two APIWrapper and API instances
*
* @param API|APIWrapper $a Instance to which link
* @param API|APIWrapper $b Instance from which link
*
* @return void
*/
public static function link($a, $b): void
{
foreach (self::__sleep() as $var) {
Tools::setVar($a, $var, Tools::getVar($b, $var));
}
Tools::setVar($a, 'session', Tools::getVar($b, 'session'));
}
/**
* Sleep function.
*
* @internal
*
* @return array
*/
public static function __sleep(): array
{
return ['API', 'webApiTemplate', 'gettingApiId', 'myTelegramOrgWrapper', 'storage'];
}
/**
* Get MTProto instance
*
* @return MTProto|null
*/
public function &getAPI(): ?MTProto
{
return $this->API;
}
/**
* Get API factory
*
* @return AbstractAPIFactory
*/
public function getFactory(): AbstractAPIFactory
{
return $this->factory;
}
/**
* Serialie session.
*
* @return Promise
*/
public function serialize(): Promise
{
if (!$this->session) {
Logger::log("Not serializing, no session");
return new Success();
}
return Tools::callFork((function (): \Generator {
if (isset($this->API->flushSettings) && $this->API->flushSettings) {
$this->API->flushSettings = false;
$this->API->__construct($this->API->settings);
}
if ($this->API === null && !$this->gettingApiId) {
return false;
}
if ($this->API) {
yield from $this->API->initAsynchronously();
}
$this->serialized = \time();
$realpaths = Serialization::realpaths($this->session);
//Logger::log('Waiting for exclusive lock of serialization lockfile...');
$unlock = yield Tools::flock($realpaths['lockfile'], LOCK_EX);
//Logger::log('Lock acquired, serializing');
try {
if (!$this->gettingApiId) {
$update_closure = $this->API->settings['updates']['callback'];
if ($this->API->settings['updates']['callback'] instanceof \Closure) {
$this->API->settings['updates']['callback'] = [$this->API, 'noop'];
}
$logger_closure = $this->API->settings['logger']['logger_param'];
if ($this->API->settings['logger']['logger_param'] instanceof \Closure) {
$this->API->settings['logger']['logger_param'] = [$this->API, 'noop'];
}
}
$wrote = yield put($realpaths['tempfile'], \serialize($this));
yield renameAsync($realpaths['tempfile'], $realpaths['file']);
} finally {
if (!$this->gettingApiId) {
$this->API->settings['updates']['callback'] = $update_closure;
$this->API->settings['logger']['logger_param'] = $logger_closure;
}
$unlock();
}
//Logger::log('Done serializing');
return $wrote;
})());
}
}

165
src/danog/MadelineProto/AbstractAPIFactory.php
View File

@ -30,7 +30,7 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*
* @var string
*/
public $namespace = '';
private string $namespace = '';
/**
* MTProto instance.
*
@ -46,7 +46,7 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*
* @var boolean
*/
public $lua = false;
public bool $lua = false;
/**
* Whether async is enabled.
*
@ -54,24 +54,43 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*
* @var boolean
*/
public $async = false;
/**
* Async init promise.
*
* @var Promise
*/
public $asyncAPIPromise;
private bool $async = false;
/**
* Method list.
*
* @var string[]
*/
protected $methods = [];
public function __construct($namespace, &$API, &$async)
protected array $methods = [];
/**
* Export APIFactory instance with the specified namespace.
*
* @param string $namespace Namespace
*
* @return self
*/
protected function exportNamespace(string $namespace = ''): self
{
$this->namespace = $namespace.'.';
$this->API =& $API;
$this->async =& $async;
$class = array_reverse(array_values(class_parents(static::class)))[3];
$instance = new $class;
$instance->namespace = $namespace.'.';
self::link($instance, $this);
return $instance;
}
/**
* Link two APIFactory instances
*
* @param self $a First instance
* @param self $b Second instance
*
* @return void
*/
protected static function link(self $a, self $b): void
{
$a->API =& $b->API;
$a->lua =& $b->lua;
$a->async =& $b->async;
$a->methods =& $b->methods;
}
/**
* Enable or disable async.
@ -101,7 +120,9 @@ abstract class AbstractAPIFactory extends AsyncConstruct
if ($async) {
return $yielded;
}
$yielded = Tools::wait($yielded);
if (!$this->lua) {
return $yielded;
}
@ -124,30 +145,8 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*/
public function __call_async(string $name, array $arguments): \Generator
{
if ($this->asyncInitPromise) {
yield from $this->initAsynchronously();
$this->API->logger->logger('Finished init asynchronously');
}
if (!$this->API) {
throw new Exception('API did not init!');
}
if ($this->API->asyncInitPromise) {
yield from $this->API->initAsynchronously();
$this->API->logger->logger('Finished init asynchronously');
}
if (isset($this->session) && !\is_null($this->session) && \time() - $this->serialized > $this->API->settings['serialization']['serialization_interval']) {
Logger::log("Didn't serialize in a while, doing that now...");
$this->serialize($this->session);
}
if ($this->API->flushSettings) {
$this->API->flushSettings = false;
$this->API->__construct($this->API->settings);
yield from $this->API->initAsynchronously();
}
if ($this->API->asyncInitPromise) {
yield from $this->API->initAsynchronously();
$this->API->logger->logger('Finished init asynchronously');
}
yield from $this->initAsynchronously();
$lower_name = \strtolower($name);
if ($this->namespace !== '' || !isset($this->methods[$lower_name])) {
$name = $this->namespace.$name;
@ -160,6 +159,61 @@ abstract class AbstractAPIFactory extends AsyncConstruct
$res = $this->methods[$lower_name](...$arguments);
return $res instanceof \Generator ? yield from $res : yield $res;
}
/**
* Get fully resolved method list for object, including snake_case and camelCase variants.
*
* @param API $value Value
*
* @return array
*/
protected static function getInternalMethodList($value): array
{
static $cache = [];
$class = \get_class($value);
if (isset($cache[$class])) {
return \array_map(
static function ($v) use ($value) {
return [$value, $v];
},
$cache[$class]
);
}
$methods = \get_class_methods($value);
foreach ($methods as $method) {
if ($method == 'methodCallAsyncRead') {
unset($methods[\array_search('methodCall', $methods)]);
} elseif (\stripos($method, 'async') !== false) {
if (\strpos($method, '_async') !== false) {
unset($methods[\array_search(\str_ireplace('_async', '', $method), $methods)]);
} else {
unset($methods[\array_search(\str_ireplace('async', '', $method), $methods)]);
}
}
}
$finalMethods = [];
foreach ($methods as $method) {
$actual_method = $method;
if ($method == 'methodCallAsyncRead') {
$method = 'methodCall';
} elseif (\stripos($method, 'async') !== false) {
if (\strpos($method, '_async') !== false) {
$method = \str_ireplace('_async', '', $method);
} else {
$method = \str_ireplace('async', '', $method);
}
}
$finalMethods[\strtolower($method)] = $actual_method;
if (\strpos($method, '_') !== false) {
$finalMethods[\strtolower(\str_replace('_', '', $method))] = $actual_method;
} else {
$finalMethods[\strtolower(Tools::toSnakeCase($method))] = $actual_method;
}
}
$cache[$class] = $finalMethods;
return self::getInternalMethodList($value);
}
/**
* Get attribute.
*
@ -171,17 +225,13 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*/
public function &__get(string $name)
{
if ($this->asyncAPIPromise) {
Tools::wait($this->asyncAPIPromise);
}
if ($name === 'settings') {
$this->API->flushSettings = true;
return $this->API->settings;
}
if ($name === 'logger') {
return $this->API->logger;
if (isset($this->API)) {
return $this->API->logger;
}
return Logger::$default;
}
return $this->API->storage[$name];
return $this->storage[$name];
}
/**
* Set an attribute.
@ -195,16 +245,7 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*/
public function __set(string $name, $value)
{
if ($this->asyncAPIPromise) {
Tools::wait($this->asyncAPIPromise);
}
if ($name === 'settings') {
if ($this->API->asyncInitPromise) {
$this->API->init();
}
return $this->API->__construct(\array_replace_recursive($this->API->settings, $value));
}
return $this->API->storage[$name] = $value;
return $this->storage[$name] = $value;
}
/**
* Whether an attribute exists.
@ -215,10 +256,7 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*/
public function __isset(string $name): bool
{
if ($this->asyncAPIPromise) {
Tools::wait($this->asyncAPIPromise);
}
return isset($this->API->storage[$name]);
return isset($this->storage[$name]);
}
/**
* Unset attribute.
@ -229,9 +267,6 @@ abstract class AbstractAPIFactory extends AsyncConstruct
*/
public function __unset(string $name): void
{
if ($this->asyncAPIPromise) {
Tools::wait($this->asyncAPIPromise);
}
unset($this->API->storage[$name]);
unset($this->storage[$name]);
}
}

2
src/danog/MadelineProto/AnnotationsBuilder.php
View File

@ -184,7 +184,7 @@ class AnnotationsBuilder
$name = \str_ireplace('async', '', $name);
}
}
$name = Tools::fromSnakeCase($name);
$name = Tools::toCamelCase($name);
$name = \str_ireplace(['mtproto', 'api'], ['MTProto', 'API'], $name);
$doc = 'public function ';
$doc .= $name;

57
src/danog/MadelineProto/Wrappers/ApiStart.php → src/danog/MadelineProto/ApiWrappers/Start.php
View File

@ -17,17 +17,25 @@
* @link https://docs.madelineproto.xyz MadelineProto documentation
*/
namespace danog\MadelineProto\Wrappers;
namespace danog\MadelineProto\ApiWrappers;
use danog\MadelineProto\MyTelegramOrgWrapper;
use danog\MadelineProto\Tools;
use function Amp\ByteStream\getStdout;
/**
* Manages simple logging in and out.
*/
trait ApiStart
trait Start
{
public function APIStart($settings): \Generator
/**
* Start API ID generation process.
*
* @param array $settings Settings
*
* @return \Generator
*/
private function APIStart(array $settings): \Generator
{
if (PHP_SAPI === 'cli') {
$stdout = getStdout();
@ -46,66 +54,65 @@ Note that you can also provide the API parameters directly in the code using the
$app['api_hash'] = yield Tools::readLine('6) Enter your API hash: ');
return $app;
}
$this->my_telegram_org_wrapper = new \danog\MadelineProto\MyTelegramOrgWrapper($settings);
yield from $this->my_telegram_org_wrapper->login(yield Tools::readLine('Enter a phone number that is already registered on Telegram: '));
yield from $this->my_telegram_org_wrapper->completeLogin(yield Tools::readLine('Enter the verification code you received in telegram: '));
if (!(yield from $this->my_telegram_org_wrapper->hasApp())) {
$this->myTelegramOrgWrapper = new \danog\MadelineProto\MyTelegramOrgWrapper($settings);
yield from $this->myTelegramOrgWrapper->login(yield Tools::readLine('Enter a phone number that is already registered on Telegram: '));
yield from $this->myTelegramOrgWrapper->completeLogin(yield Tools::readLine('Enter the verification code you received in telegram: '));
if (!(yield from $this->myTelegramOrgWrapper->hasApp())) {
$app_title = yield Tools::readLine('Enter the app\'s name, can be anything: ');
$short_name = yield Tools::readLine('Enter the app\'s short name, can be anything: ');
$url = yield Tools::readLine('Enter the app/website\'s URL, or t.me/yourusername: ');
$description = yield Tools::readLine('Describe your app: ');
$app = (yield from $this->my_telegram_org_wrapper->createApp(['app_title' => $app_title, 'app_shortname' => $short_name, 'app_url' => $url, 'app_platform' => 'web', 'app_desc' => $description]));
$app = (yield from $this->myTelegramOrgWrapper->createApp(['app_title' => $app_title, 'app_shortname' => $short_name, 'app_url' => $url, 'app_platform' => 'web', 'app_desc' => $description]));
} else {
$app = (yield from $this->my_telegram_org_wrapper->getApp());
$app = (yield from $this->myTelegramOrgWrapper->getApp());
}
return $app;
}
$this->getting_api_id = true;
if (!isset($this->my_telegram_org_wrapper)) {
$this->gettingApiId = true;
if (!isset($this->myTelegramOrgWrapper)) {
if (isset($_POST['api_id']) && isset($_POST['api_hash'])) {
$app['api_id'] = (int) $_POST['api_id'];
$app['api_hash'] = $_POST['api_hash'];
$this->getting_api_id = false;
$this->gettingApiId = false;
return $app;
} elseif (isset($_POST['phone_number'])) {
yield from $this->webAPIPhoneLogin($settings);
} else {
yield from $this->webAPIEcho();
}
} elseif (!$this->my_telegram_org_wrapper->loggedIn()) {
} elseif (!$this->myTelegramOrgWrapper->loggedIn()) {
if (isset($_POST['code'])) {
yield from $this->webAPICompleteLogin();
if (yield from $this->my_telegram_org_wrapper->hasApp()) {
return yield from $this->my_telegram_org_wrapper->getApp();
if (yield from $this->myTelegramOrgWrapper->hasApp()) {
return yield from $this->myTelegramOrgWrapper->getApp();
}
yield from $this->webAPIEcho();
} elseif (isset($_POST['api_id']) && isset($_POST['api_hash'])) {
$app['api_id'] = (int) $_POST['api_id'];
$app['api_hash'] = $_POST['api_hash'];
$this->getting_api_id = false;
$this->gettingApiId = false;
return $app;
} elseif (isset($_POST['phone_number'])) {
yield from $this->webAPIPhoneLogin($settings);
} else {
$this->my_telegram_org_wrapper = null;
$this->myTelegramOrgWrapper = null;
yield from $this->webAPIEcho();
}
} else {
if (isset($_POST['app_title'], $_POST['app_shortname'], $_POST['app_url'], $_POST['app_platform'], $_POST['app_desc'])) {
$app = (yield from $this->webAPICreateApp());
$this->getting_api_id = false;
$this->gettingApiId = false;
return $app;
}
yield from $this->webAPIEcho("You didn't provide all of the required parameters!");
}
$this->asyncInitPromise = null;
exit;
return null;
}
private function webAPIPhoneLogin($settings): \Generator
private function webAPIPhoneLogin(array $settings): \Generator
{
try {
$this->my_telegram_org_wrapper = new \danog\MadelineProto\MyTelegramOrgWrapper($settings);
yield from $this->my_telegram_org_wrapper->login($_POST['phone_number']);
$this->myTelegramOrgWrapper = new MyTelegramOrgWrapper($settings);
yield from $this->myTelegramOrgWrapper->login($_POST['phone_number']);
yield from $this->webAPIEcho();
} catch (\Throwable $e) {
yield from $this->webAPIEcho('ERROR: ' . $e->getMessage() . '. Try again.');
@ -114,7 +121,7 @@ Note that you can also provide the API parameters directly in the code using the
private function webAPICompleteLogin(): \Generator
{
try {
yield from $this->my_telegram_org_wrapper->completeLogin($_POST['code']);
yield from $this->myTelegramOrgWrapper->completeLogin($_POST['code']);
} catch (\danog\MadelineProto\RPCErrorException $e) {
yield from $this->webAPIEcho('ERROR: ' . $e->getMessage() . '. Try again.');
} catch (\danog\MadelineProto\Exception $e) {
@ -126,7 +133,7 @@ Note that you can also provide the API parameters directly in the code using the
try {
$params = $_POST;
unset($params['creating_app']);
$app = (yield from $this->my_telegram_org_wrapper->createApp($params));
$app = (yield from $this->myTelegramOrgWrapper->createApp($params));
return $app;
} catch (\danog\MadelineProto\RPCErrorException $e) {
yield from $this->webAPIEcho('ERROR: ' . $e->getMessage() . ' Try again.');

65
src/danog/MadelineProto/Wrappers/ApiTemplates.php → src/danog/MadelineProto/ApiWrappers/Templates.php
View File

@ -17,29 +17,29 @@
* @link https://docs.madelineproto.xyz MadelineProto documentation
*/
namespace danog\MadelineProto\Wrappers;
namespace danog\MadelineProto\ApiWrappers;
use function Amp\ByteStream\getOutputBufferStream;
trait ApiTemplates
trait Templates
{
private $web_api_template = '<!DOCTYPE html>
<html>
<head>
<title>MadelineProto</title>
</head>
<body>
<h1>MadelineProto</h1>
<p>%s</p>
<form method="POST">
%s
<button type="submit"/>Go</button>
</form>
</body>
</html>';
private function webAPIEchoTemplate($message, $form)
/**
* API template.
*
* @var string
*/
private $webApiTemplate = '<!DOCTYPE html><html><head><title>MadelineProto</title></head><body><h1>MadelineProto</h1><p>%s</p><form method="POST">%s<button type="submit"/>Go</button></form></body></html>';
/**
* Generate page from template.
*
* @param string $message Message
* @param string $form Form
*
* @return string
*/
private function webAPIEchoTemplate(string $message, string $form): string
{
return \sprintf($this->web_api_template, $message, $form);
return \sprintf($this->webApiTemplate, $message, $form);
}
/**
* Get web API login HTML template string.
@ -48,24 +48,31 @@ trait ApiTemplates
*/
public function getWebAPITemplate(): string
{
return $this->web_template;
return $this->webApiTemplate;
}
/**
* Set web API login HTML template string.
*
* @return string
*/
public function setWebAPITemplate(string $template)
public function setWebAPITemplate(string $template): void
{
$this->web_template = $template;
$this->webApiTemplate = $template;
}
/**
* Echo to browser.
*
* @param string $message Message to echo
*
* @return \Generator
*/
private function webAPIEcho(string $message = ''): \Generator
{
$stdout = getOutputBufferStream();
if (!isset($this->my_telegram_org_wrapper)) {
if (!isset($this->myTelegramOrgWrapper)) {
if (isset($_POST['type'])) {
if ($_POST['type'] === 'manual') {
yield $stdout->write($this->webAPIEchoTemplate('Enter your API ID and API hash<br><b>' . $message . '</b><ol>
yield $stdout->write($this->webAPIEchoTemplate('Enter your API ID and API hash<br><b>'.$message.'</b><ol>
<li>Login to my.telegram.org</li>
<li>Go to API development tools</li>
<li>
@ -79,19 +86,19 @@ trait ApiTemplates
<li>Click on create application</li>
</ol>', '<input type="string" name="api_id" placeholder="API ID" required/><input type="string" name="api_hash" placeholder="API hash" required/>'));
} else {
yield $stdout->write($this->webAPIEchoTemplate('Enter a phone number that is <b>already registered</b> on telegram to get the API ID<br><b>' . $message . '</b>', '<input type="text" name="phone_number" placeholder="Phone number" required/>'));
yield $stdout->write($this->webAPIEchoTemplate('Enter a phone number that is <b>already registered</b> on telegram to get the API ID<br><b>'.$message.'</b>', '<input type="text" name="phone_number" placeholder="Phone number" required/>'));
}
} else {
if ($message) {
$message = '<br><br>' . $message;
$message = '<br><br>'.$message;
}
yield $stdout->write($this->webAPIEchoTemplate('Do you want to enter the API id and the API hash manually or automatically?<br>Note that you can also provide it directly in the code using the <a href="https://docs.madelineproto.xyz/docs/SETTINGS.html#settingsapp_infoapi_id">settings</a>.<b>' . $message . '</b>', '<select name="type"><option value="automatic">Automatically</option><option value="manual">Manually</option></select>'));
yield $stdout->write($this->webAPIEchoTemplate('Do you want to enter the API id and the API hash manually or automatically?<br>Note that you can also provide it directly in the code using the <a href="https://docs.madelineproto.xyz/docs/SETTINGS.html#settingsapp_infoapi_id">settings</a>.<b>'.$message.'</b>', '<select name="type"><option value="automatic">Automatically</option><option value="manual">Manually</option></select>'));
}
} else {
if (!$this->my_telegram_org_wrapper->loggedIn()) {
yield $stdout->write($this->webAPIEchoTemplate('Enter your code<br><b>' . $message . '</b>', '<input type="text" name="code" placeholder="Code" required/>'));
if (!$this->myTelegramOrgWrapper->loggedIn()) {
yield $stdout->write($this->webAPIEchoTemplate('Enter your code<br><b>'.$message.'</b>', '<input type="text" name="code" placeholder="Code" required/>'));
} else {
yield $stdout->write($this->webAPIEchoTemplate('Enter the API info<br><b>' . $message . '</b>', '<input type="hidden" name="creating_app" value="yes" required/>
yield $stdout->write($this->webAPIEchoTemplate('Enter the API info<br><b>'.$message.'</b>', '<input type="hidden" name="creating_app" value="yes" required/>
Enter the app name, can be anything: <br><input type="text" name="app_title" required/><br>
<br>Enter the app&apos;s short name, alphanumeric, 5-32 chars: <br><input type="text" name="app_shortname" required/><br>
<br>Enter the app/website URL, or https://t.me/yourusername: <br><input type="text" name="app_url" required/><br>

38
src/danog/MadelineProto/Async/AsyncConstruct.php
View File

@ -35,7 +35,7 @@ class AsyncConstruct
*
* @var Promise
*/
public $asyncInitPromise;
private $asyncInitPromise;
/**
* Blockingly init.
*
@ -58,10 +58,30 @@ class AsyncConstruct
yield $this->asyncInitPromise;
}
}
/**
* Check if we've already inited.
*
* @return boolean
*/
public function inited(): bool
{
return !$this->asyncInitPromise;
}
/**
* Mark instance as (de)inited forcefully
*
* @param boolean $inited Whether to mark the instance as inited or deinited
*
* @return void
*/
public function forceInit(bool $inited): void
{
$this->asyncInitPromise = $inited ? null : true;
}
/**
* Set init promise.
*
* @param Promise $promise Promise
* @param Promise|\Generator $promise Promise
*
* @internal
*
@ -69,12 +89,14 @@ class AsyncConstruct
*/
public function setInitPromise($promise): void
{
$this->asyncInitPromise = Tools::callFork($promise);
$this->asyncInitPromise->onResolve(function ($error, $result) {
if ($error) {
throw $error;
$this->asyncInitPromise = Tools::call($promise);
$this->asyncInitPromise->onResolve(
function (?\Throwable $error, $result): void {
if ($error) {
throw $error;
}
$this->asyncInitPromise = null;
}
$this->asyncInitPromise = null;
});
);
}
}

11
src/danog/MadelineProto/EventHandler.php
View File

@ -27,18 +27,17 @@ class EventHandler extends InternalDoc
/**
* Constructor.
*
* @param API|null $MadelineProto MadelineProto instance
* @param APIWrapper|null $MadelineProto MadelineProto instance
*/
public function __construct(?API $MadelineProto)
public function __construct(?APIWrapper $MadelineProto)
{
if (!$MadelineProto) {
return;
}
$this->API = $MadelineProto->API;
$this->async =& $MadelineProto->async;
$this->methods =& $MadelineProto->methods;
self::link($this, $MadelineProto->getFactory());
$this->API =& $MadelineProto->getAPI();
foreach ($this->API->getMethodNamespaces() as $namespace) {
$this->{$namespace} = new APIFactory($namespace, $this->API, $this->async);
$this->{$namespace} = $this->exportNamespace($namespace);
}
}
/**

46
src/danog/MadelineProto/InternalDoc.php
View File

@ -4134,6 +4134,18 @@ class InternalDoc extends APIFactory
{
return \danog\MadelineProto\MTProto::getSettings($settings, $previousSettings);
}
/**
* Parse, update and store settings.
*
* @param array $settings Settings
* @param bool $reinit Whether to reinit the instance
*
* @return void
*/
public function updateSettings(array $settings, bool $reinit = true, array $extra = [])
{
return $this->__call(__FUNCTION__, [$settings, $reinit, $extra]);
}
/**
* Setup logger.
*
@ -4207,14 +4219,23 @@ class InternalDoc extends APIFactory
return $this->__call(__FUNCTION__, [$config, $options, $extra]);
}
/**
* Get info about the logged-in user.
* Get info about the logged-in user, cached.
*
* @return \Generator<array>
* @return array|bool
*/
public function getSelf(array $extra = [])
{
return $this->__call(__FUNCTION__, [$extra]);
}
/**
* Get info about the logged-in user, not cached.
*
* @return \Generator<array|bool>
*/
public function fullGetSelf(array $extra = [])
{
return $this->__call(__FUNCTION__, [$extra]);
}
/**
* Check if has report peers.
*
@ -4246,6 +4267,15 @@ class InternalDoc extends APIFactory
{
return $this->__call(__FUNCTION__, [$message, $extra]);
}
/**
* Get full list of MTProto and API methods.
*
* @return array
*/
public function getAllMethods(): array
{
return $this->API->getAllMethods();
}
/**
* Call method and wait asynchronously for response.
*
@ -5250,24 +5280,24 @@ class InternalDoc extends APIFactory
/**
* Convert to camelCase.
*
* @param string $input
* @param string $input String
*
* @return string
*/
public function fromSnakeCase(string $input): string
public function toCamelCase(string $input): string
{
return \danog\MadelineProto\MTProto::fromSnakeCase($input);
return \danog\MadelineProto\MTProto::toCamelCase($input);
}
/**
* Convert to snake_case.
*
* @param string $input
* @param string $input String
*
* @return string
*/
public function fromCamelCase(string $input): string
public function toSnakeCase(string $input): string
{
return \danog\MadelineProto\MTProto::fromCamelCase($input);
return \danog\MadelineProto\MTProto::toSnakeCase($input);
}
/**
* Create array.

27
src/danog/MadelineProto/Loop/Generic/PeriodicLoop.php
View File

@ -29,18 +29,33 @@ use danog\MadelineProto\MTProto;
*/
class PeriodicLoop extends ResumableSignalLoop
{
/**
* Callback
*
* @var callable
*/
private $callback;
private $name;
/**
* Loop name
*
* @var string
*/
private string $name;
/**
* Loop timeeout
*
* @var int
*/
private $timeout;
/**
* Constructor.
*
* @param \danog\MadelineProto\MTProto $API Instance of MTProto class
* @param callable $callback Callback to call
* @param string $name Loop name
* @param int $timeout Loop timeout
* @param \danog\MadelineProto\API $API Instance of MTProto class
* @param callable $callback Callback to call
* @param string $name Loop name
* @param int|float $timeout Loop timeout
*/
public function __construct(MTProto $API, $callback, string $name, $timeout)
public function __construct($API, callable $callback, string $name, $timeout)
{
$this->API = $API;
$this->callback = $callback;

2
src/danog/MadelineProto/Loop/Impl/Loop.php
View File

@ -54,7 +54,6 @@ abstract class Loop implements LoopInterface
}
private function loopImpl(): \Generator
{
//yield ['my_trace' => debug_backtrace(0, 1)[0], (string) $this];
$this->startedLoop();
$this->API->logger->logger("Entered {$this}", Logger::ULTRA_VERBOSE);
try {
@ -62,7 +61,6 @@ abstract class Loop implements LoopInterface
} finally {
$this->exitedLoop();
$this->API->logger->logger("Physically exited {$this}", Logger::ULTRA_VERBOSE);
//return null;
}
}
public function exitedLoop()

11
src/danog/MadelineProto/Loop/Impl/ResumableSignalLoop.php
View File

@ -36,7 +36,7 @@ abstract class ResumableSignalLoop extends SignalLoop implements ResumableLoopIn
use Tools;
private $resume;
private $pause;
private $resumeWatcher;
protected $resumeWatcher;
public function pause($time = null): Promise
{
if (!\is_null($time)) {
@ -80,4 +80,13 @@ abstract class ResumableSignalLoop extends SignalLoop implements ResumableLoopIn
Loop::defer([$this, 'resume']);
return $this->pause ? $this->pause->promise() : null;
}
public function exitedLoop()
{
parent::exitedLoop();
if ($this->resumeWatcher) {
Loop::cancel($this->resumeWatcher);
$this->resumeWatcher = null;
}
}
}

102
src/danog/MadelineProto/MTProto.php
View File

@ -22,6 +22,7 @@ namespace danog\MadelineProto;
use Amp\Dns\Resolver;
use Amp\Http\Client\DelegateHttpClient;
use Amp\Loop;
use Amp\Success;
use danog\MadelineProto\Async\AsyncConstruct;
use danog\MadelineProto\Loop\Generic\PeriodicLoop;
use danog\MadelineProto\Loop\Update\FeedLoop;
@ -204,7 +205,7 @@ class MTProto extends AsyncConstruct implements TLCallback
/**
* Instance of wrapper API.
*
* @var API|null
* @var ?APIWrapper
*/
public $wrapper;
/**
@ -321,18 +322,6 @@ class MTProto extends AsyncConstruct implements TLCallback
* @var array
*/
private $dialog_params = ['limit' => 0, 'offset_date' => 0, 'offset_id' => 0, 'offset_peer' => ['_' => 'inputPeerEmpty'], 'count' => 0];
/**
* Whether new settings were set and should be applied.
*
* @var boolean
*/
public $flushSettings = false;
/**
* Storage for arbitrary data.
*
* @var array
*/
public $storage = [];
/**
* Support user ID.
*
@ -439,7 +428,7 @@ class MTProto extends AsyncConstruct implements TLCallback
{
Magic::classExists();
// Parse and store settings
$this->parseSettings($settings);
yield from $this->updateSettings($settings, false);
$this->logger->logger(Lang::$current_lang['inst_dc'], Logger::ULTRA_VERBOSE);
$this->cleanupProperties();
// Load rsa keys
@ -544,9 +533,6 @@ class MTProto extends AsyncConstruct implements TLCallback
'temp_requested_secret_chats',
'temp_rekeyed_secret_chats',
// Object storage
'storage',
// Report URI
'reportDest'
];
@ -659,13 +645,14 @@ class MTProto extends AsyncConstruct implements TLCallback
/**
* Prompt serialization of instance.
*
* @internal
*
* @return void
*/
public function serialize()
{
if ($this->wrapper instanceof API && isset($this->wrapper->session) && !\is_null($this->wrapper->session) && !$this->asyncInitPromise) {
//$this->logger->logger("Didn't serialize in a while, doing that now...");
$this->wrapper->serialize($this->wrapper->session);
if ($this->wrapper && $this->inited()) {
$this->wrapper->serialize();
}
}
/**
@ -852,8 +839,9 @@ class MTProto extends AsyncConstruct implements TLCallback
*/
public function __wakeup()
{
$backtrace = \debug_backtrace(0, 3);
$this->asyncInitPromise = true;
$backtrace = \debug_backtrace(0, 4);
$backtrace = end($backtrace);
$this->forceInit(false);
$this->setInitPromise($this->__wakeup_async($backtrace));
}
/**
@ -884,9 +872,9 @@ class MTProto extends AsyncConstruct implements TLCallback
}
$force = false;
$this->resetMTProtoSession();
if (isset($backtrace[2]['function'], $backtrace[2]['class'], $backtrace[2]['args']) && $backtrace[2]['class'] === 'danog\\MadelineProto\\API' && $backtrace[2]['function'] === '__construct_async') {
if (\count($backtrace[2]['args']) >= 2) {
$this->parseSettings(\array_replace_recursive($this->settings, $backtrace[2]['args'][1]));
if (isset($backtrace['function'], $backtrace['class'], $backtrace['args']) && $backtrace['class'] === 'danog\\MadelineProto\\API' && $backtrace['function'] === '__construct_async') {
if (\count($backtrace['args']) >= 2) {
yield from $this->updateSettings($backtrace['args'][1], false);
}
}
if (($this->settings['tl_schema']['src']['botAPI'] ?? '') !== __DIR__.'/TL_botAPI.tl') {
@ -922,7 +910,7 @@ class MTProto extends AsyncConstruct implements TLCallback
}
}
$this->startLoops();
if (yield from $this->getSelf()) {
if (yield from $this->fullGetSelf()) {
$this->authorized = self::LOGGED_IN;
}
if ($this->authorized === self::LOGGED_IN) {
@ -940,9 +928,13 @@ class MTProto extends AsyncConstruct implements TLCallback
$this->updaters[false]->start();
}
/**
* Destructor.
* Unreference instance, allowing destruction.
*
* @internal
*
* @return void
*/
public function __destruct()
public function unreference()
{
$this->stopLoops();
if (isset($this->seqUpdater)) {
@ -957,13 +949,21 @@ class MTProto extends AsyncConstruct implements TLCallback
if (isset($this->feeders[$channelId])) {
$this->feeders[$channelId]->signal(true);
}
if (!isset($this->updaters[$channelId])) {
if (isset($this->updaters[$channelId])) {
$this->updaters[$channelId]->signal(true);
}
}
foreach ($this->datacenter->getDataCenterConnections() as $datacenter) {
$datacenter->disconnect();
}
}
/**
* Destructor.
*/
public function __destruct()
{
$this->logger('Shutting down MadelineProto (MTProto)');
$this->unreference();
$this->logger("Successfully destroyed MadelineProto");
}
/**
@ -1284,13 +1284,14 @@ class MTProto extends AsyncConstruct implements TLCallback
return $settings;
}
/**
* Parse and store settings.
* Parse, update and store settings.
*
* @param array $settings Settings
* @param bool $reinit Whether to reinit the instance
*
* @return void
*/
private function parseSettings(array $settings): void
public function updateSettings(array $settings, bool $reinit = true): \Generator
{
$settings = self::getSettings($settings, $this->settings);
if ($settings['app_info'] === null) {
@ -1302,6 +1303,11 @@ class MTProto extends AsyncConstruct implements TLCallback
}
// Setup logger
$this->setupLogger();
if ($reinit) {
$this->__construct();
yield from $this->initAsynchronously();
}
}
/**
* Setup logger.
@ -1439,7 +1445,7 @@ class MTProto extends AsyncConstruct implements TLCallback
$this->feeders[$channelId]->signal(true);
unset($this->feeders[$channelId]);
}
if (!isset($this->updaters[$channelId])) {
if (isset($this->updaters[$channelId])) {
$this->updaters[$channelId]->signal(true);
unset($this->updaters[$channelId]);
}
@ -1487,7 +1493,7 @@ class MTProto extends AsyncConstruct implements TLCallback
if (isset($this->feeders[$channelId])) {
$this->feeders[$channelId]->signal(true);
}
if (!isset($this->updaters[$channelId])) {
if (isset($this->updaters[$channelId])) {
$this->updaters[$channelId]->signal(true);
}
}
@ -1505,7 +1511,7 @@ class MTProto extends AsyncConstruct implements TLCallback
*/
public function startUpdateSystem($anyway = false): void
{
if ($this->asyncInitPromise && !$anyway) {
if (!$this->inited() && !$anyway) {
$this->logger("Not starting update system");
return;
}
@ -1652,11 +1658,20 @@ class MTProto extends AsyncConstruct implements TLCallback
$this->datacenter->curdc = $curdc;
}
/**
* Get info about the logged-in user.
* Get info about the logged-in user, cached.
*
* @return \Generator<array>
* @return array|bool
*/
public function getSelf(): \Generator
public function getSelf()
{
return $this->authorization['user'] ?? false;
}
/**
* Get info about the logged-in user, not cached.
*
* @return \Generator<array|bool>
*/
public function fullGetSelf(): \Generator
{
try {
$this->authorization = ['user' => (yield from $this->methodCallAsyncRead('users.getUsers', ['id' => [['_' => 'inputUserSelf']]], ['datacenter' => $this->datacenter->curdc]))[0]];
@ -1718,6 +1733,19 @@ class MTProto extends AsyncConstruct implements TLCallback
}
}
}
/**
* Get full list of MTProto and API methods.
*
* @return array
*/
public function getAllMethods(): array
{
$methods = [];
foreach ($this->getTL()->getMethods()->by_id as $method) {
$methods[] = $method['method'];
}
return \array_merge($methods, \get_class_methods(InternalDoc::class));
}
/**
* Called right before serialization of method starts.
*

2
src/danog/MadelineProto/MTProtoTools/Files.php
View File

@ -22,8 +22,8 @@ namespace danog\MadelineProto\MTProtoTools;
use Amp\ByteStream\InputStream;
use Amp\ByteStream\IteratorStream;
use Amp\ByteStream\OutputStream;
use Amp\ByteStream\ResourceOutputStream;
use Amp\ByteStream\ResourceInputStream;
use Amp\ByteStream\ResourceOutputStream;
use Amp\ByteStream\StreamException;
use Amp\Deferred;
use Amp\File\BlockingFile;

97
src/danog/MadelineProto/Serialization.php
View File

@ -19,14 +19,109 @@
namespace danog\MadelineProto;
use function Amp\File\exists;
use function Amp\File\get;
/**
* Manages serialization of the MadelineProto instance.
*/
class Serialization
{
public static function realpaths($file)
/**
* Extract path components for serialization.
*
* @param string $file Session path
*
* @return array
*/
public static function realpaths(string $file): array
{
$file = Absolute::absolute($file);
return ['file' => $file, 'lockfile' => $file . '.lock', 'tempfile' => $file . '.temp.session'];
}
/**
* Unserialize legacy session.
*
* @param string $session Session name
*
* @internal
*
* @return \Generator
*/
public static function legacyUnserialize(string $session): \Generator
{
$realpaths = self::realpaths($session);
if (yield exists($realpaths['file'])) {
Logger::log('Waiting for shared lock of serialization lockfile...');
$unlock = yield Tools::flock($realpaths['lockfile'], LOCK_SH);
Logger::log('Shared lock acquired, deserializing...');
try {
$tounserialize = yield get($realpaths['file']);
} finally {
$unlock();
}
\danog\MadelineProto\Magic::classExists();
try {
$unserialized = \unserialize($tounserialize);
} catch (\danog\MadelineProto\Bug74586Exception $e) {
\class_exists('\\Volatile');
$tounserialize = \str_replace('O:26:"danog\\MadelineProto\\Button":', 'O:35:"danog\\MadelineProto\\TL\\Types\\Button":', $tounserialize);
foreach (['RSA', 'TL\\TLMethods', 'TL\\TLConstructors', 'MTProto', 'API', 'DataCenter', 'Connection', 'TL\\Types\\Button', 'TL\\Types\\Bytes', 'APIFactory'] as $class) {
\class_exists('\\danog\\MadelineProto\\'.$class);
}
$unserialized = \danog\Serialization::unserialize($tounserialize);
} catch (\danog\MadelineProto\Exception $e) {
if ($e->getFile() === 'MadelineProto' && $e->getLine() === 1) {
throw $e;
}
if (\MADELINEPROTO_TEST === 'pony') {
throw $e;
}
\class_exists('\\Volatile');
foreach (['RSA', 'TL\\TLMethods', 'TL\\TLConstructors', 'MTProto', 'API', 'DataCenter', 'Connection', 'TL\\Types\\Button', 'TL\\Types\\Bytes', 'APIFactory'] as $class) {
\class_exists('\\danog\\MadelineProto\\'.$class);
}
$changed = false;
if (\strpos($tounserialize, 'O:26:"danog\\MadelineProto\\Button":') !== false) {
Logger::log("SUBBING BUTTONS!");
$tounserialize = \str_replace('O:26:"danog\\MadelineProto\\Button":', 'O:35:"danog\\MadelineProto\\TL\\Types\\Button":', $tounserialize);
$changed = true;
}
if (\strpos($e->getMessage(), "Erroneous data format for unserializing 'phpseclib\\Math\\BigInteger'") === 0) {
Logger::log("SUBBING BIGINTEGOR!");
$tounserialize = \str_replace('phpseclib\\Math\\BigInteger', 'phpseclib\\Math\\BigIntegor', $tounserialize);
$changed = true;
}
if (\strpos($tounserialize, 'C:25:"phpseclib\\Math\\BigInteger"') !== false) {
Logger::log("SUBBING TGSECLIB old!");
$tounserialize = \str_replace('C:25:"phpseclib\\Math\\BigInteger"', 'C:24:"tgseclib\\Math\\BigInteger"', $tounserialize);
$changed = true;
}
if (\strpos($tounserialize, 'C:26:"phpseclib3\\Math\\BigInteger"') !== false) {
Logger::log("SUBBING TGSECLIB!");
$tounserialize = \str_replace('C:26:"phpseclib3\\Math\\BigInteger"', 'C:24:"tgseclib\\Math\\BigInteger"', $tounserialize);
$changed = true;
}
Logger::log((string) $e, Logger::ERROR);
if (!$changed) {
throw $e;
}
try {
$unserialized = \danog\Serialization::unserialize($tounserialize);
} catch (\Throwable $e) {
$unserialized = \unserialize($tounserialize);
}
} catch (\Throwable $e) {
Logger::log((string) $e, Logger::ERROR);
throw $e;
}
if ($unserialized instanceof \danog\PlaceHolder) {
$unserialized = \danog\Serialization::unserialize($tounserialize);
}
if ($unserialized === false) {
throw new Exception(\danog\MadelineProto\Lang::$current_lang['deserialization_error']);
}
return $unserialized;
}
}
}

3
src/danog/MadelineProto/TL/Conversion/BotAPI.php
View File

@ -540,6 +540,9 @@ trait BotAPI
if (($arguments['message'] ?? '') === '' || !isset($arguments['parse_mode'])) {
return $arguments;
}
if (!(\is_string($arguments['message']) || \is_object($arguments['message']) && \method_exists($arguments['message'], '__toString'))) {
throw new Exception('Messages can only be strings');
}
if (isset($arguments['parse_mode']['_'])) {
$arguments['parse_mode'] = \str_replace('textParseMode', '', $arguments['parse_mode']['_']);
}

52
src/danog/MadelineProto/Tools.php
View File

@ -30,6 +30,7 @@ use function Amp\ByteStream\getOutputBufferStream;
use function Amp\ByteStream\getStdin;
use function Amp\ByteStream\getStdout;
use function Amp\File\exists;
use function Amp\File\get;
use function Amp\Promise\all;
use function Amp\Promise\any;
use function Amp\Promise\first;
@ -304,6 +305,7 @@ trait Tools
});
} catch (\Throwable $throwable) {
Logger::log('Loop exceptionally stopped without resolving the promise', Logger::FATAL_ERROR);
Logger::log((string) $throwable, Logger::FATAL_ERROR);
throw $throwable;
}
} while (!$resolved && !(Magic::$signaled && !$ignoreSignal));
@ -411,15 +413,6 @@ trait Tools
{
if ($actual) {
$promise = $actual;
} else {
$trace = \debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
$file = '';
if (isset($trace['file'])) {
$file .= \basename($trace['file'], '.php');
}
if (isset($trace['line'])) {
$file .= ":{$trace['line']}";
}
}
if ($promise instanceof \Generator) {
$promise = new Coroutine($promise);
@ -632,22 +625,22 @@ trait Tools
/**
* Convert to camelCase.
*
* @param string $input
* @param string $input String
*
* @return string
*/
public static function fromSnakeCase(string $input): string
public static function toCamelCase(string $input): string
{
return \lcfirst(\str_replace('_', '', \ucwords($input, '_')));
}
/**
* Convert to snake_case.
*
* @param string $input
* @param string $input String
*
* @return string
*/
public static function fromCamelCase(string $input): string
public static function toSnakeCase(string $input): string
{
\preg_match_all('!([A-Z][A-Z0-9]*(?=$|[A-Z][a-z0-9])|[A-Za-z][a-z0-9]+)!', $input, $matches);
$ret = $matches[0];
@ -831,11 +824,34 @@ trait Tools
* @return mixed
* @access public
*/
public static function getVar($obj, string $var)
public static function &getVar($obj, string $var)
{
$reflection = new \ReflectionClass(\get_class($obj));
$prop = $reflection->getProperty($var);
$prop->setAccessible(true);
return $prop->getValue($obj);
return \Closure::bind(
function & () use ($var) {
return $this->{$var};
},
$obj,
\get_class($obj)
)->__invoke();
}
/**
* Sets a private variable in an object.
*
* @param object $obj Object
* @param string $var Attribute name
* @param mixed $val Attribute value
*
* @return mixed
* @access public
*/
public static function setVar($obj, string $var, &$val): void
{
\Closure::bind(
function () use ($var, &$val) {
$this->{$var} =& $val;
},
$obj,
\get_class($obj)
)->__invoke();
}
}

2
src/danog/MadelineProto/Wrappers/Events.php
View File

@ -82,7 +82,7 @@ trait Events
$this->settings['updates']['callback'] = [$this, 'eventUpdateHandler'];
$this->settings['updates']['handle_updates'] = true;
$this->settings['updates']['run_callback'] = true;
if (!$this->asyncInitPromise) {
if ($this->inited()) {
$this->startUpdateSystem();
}
}

4
src/danog/MadelineProto/Wrappers/Login.php
View File

@ -170,7 +170,7 @@ trait Login
$this->authorized = self::LOGGED_IN;
yield from $this->initAuthorization();
yield from $this->getPhoneConfig();
$res = (yield from $this->getSelf());
$res = (yield from $this->fullGetSelf());
$callbacks = [$this, $this->referenceDatabase];
if (!($this->authorization['user']['bot'] ?? false)) {
$callbacks[] = $this->minDatabase;
@ -189,7 +189,7 @@ trait Login
if ($this->authorized !== self::LOGGED_IN) {
throw new \danog\MadelineProto\Exception(\danog\MadelineProto\Lang::$current_lang['not_loggedIn']);
}
yield from $this->getSelf();
yield from $this->fullGetSelf();
$this->authorized_dc = $this->datacenter->curdc;
return [$this->datacenter->curdc, $this->datacenter->getDataCenterConnection($this->datacenter->curdc)->getPermAuthKey()->getAuthKey()];
}

6
src/danog/MadelineProto/Wrappers/Start.php
View File

@ -34,7 +34,7 @@ trait Start
public function start(): \Generator
{
if ($this->authorized === self::LOGGED_IN) {
return yield from $this->getSelf();
return yield from $this->fullGetSelf();
}
if (PHP_SAPI === 'cli') {
if (\strpos(yield Tools::readLine('Do you want to login as user or bot (u/b)? '), 'b') !== false) {
@ -50,7 +50,7 @@ trait Start
}
}
$this->serialize();
return yield from $this->getSelf();
return yield from $this->fullGetSelf();
}
if ($this->authorized === self::NOT_LOGGED_IN) {
if (isset($_POST['phone_number'])) {
@ -81,7 +81,7 @@ trait Start
}
if ($this->authorized === self::LOGGED_IN) {
$this->serialize();
return yield from $this->getSelf();
return yield from $this->fullGetSelf();
}
exit;
}