Commit 8e0e9d4d authored by Dominik Hebeler's avatar Dominik Hebeler
Browse files

Erster Commit

parents
<?php
namespace App\MetaGer;
use App\lib\Redis;
class Forwarder
{
public static function getFreeServer()
{
# Variablen Deklarationen:
$host = $_SERVER["SERVER_NAME"]; # Dieser Server ist der Host für den Redis-Server
$redis; # In diesem Objekt erhalten wir Zugriff auf die Redis-Datenbank (Redis)
$cfg; # In diesem Objekt erhalten wir Zugriff auf unsere Konfiguration (Config::Simple)
$servers; # Beinhaltet später eine Liste, aller verbundenen Server, an die wir die Anfrage schicken können
$server;
$protocol; # Beinhaltet später den Server ( und sein Protokoll ), der die Suchanfrage tatsächlich beantworten soll
$result;
# Load Config File;
$cfg = parse_ini_file(config_path() . '/metager.ini', TRUE);
# Connect to our Redis Server
try {
$redis = new Redis($host, $cfg['redis']['port']);
} catch(\Exception $e){
$redis = new Redis($cfg['redis']['server'], $cfg['redis']['port']);
}
$response = $redis->cmd('auth', $cfg['redis']['password'] )->get();
if($response !== "OK"){
die("Couldn't authenticate to Redis Server");
}
# Fill $servers Array from Redis:
$serversArray = self::indexedToAssociative($redis->cmd('hgetall', 'servers')->get());
foreach($serversArray as $key => $value ){
$data = explode("\t", $value);
$age = time() - $data[0]; # Erste Stelle ist die Zeit in Sekunden, an der sich der Server das letzte Mal angemeldet hat.
if($age > 3){
# Der Server hat sich seit 3 Sekunden nicht mehr gemeldet. Er kommt schon einmal nicht in Frage und wird aus der Datenbank geworfen:
$redis->cmd("hdel", "servers", $key)->set();
}elseif()
}
return time();
# Select a matching Server:
}
/**
* Converts an indexed Array to an Associative one
* Every Element on an even index is the Ḱey to the Element on the next uneven index
*
* @param indexedArray $array
* @return associativeArray $result
*/
private static function indexedToAssociative($array){
$result = array();
for($i = 0; $i < sizeof($array); $i++){
if($i %2 === 0){
$server = $array[$i];
}else{
$result[$server] = $array[$i];
$server = "";
}
}
return $result;
}
}
\ No newline at end of file
<?php
namespace App\MetaGer;
class Results
{
}
\ No newline at end of file
<?php
namespace App\Providers;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
//
}
/**
* Register any application services.
*
* @return void
*/
public function register()
{
//
}
}
<?php
namespace App\Providers;
use Illuminate\Contracts\Auth\Access\Gate as GateContract;
use Illuminate\Foundation\Support\Providers\AuthServiceProvider as ServiceProvider;
class AuthServiceProvider extends ServiceProvider
{
/**
* The policy mappings for the application.
*
* @var array
*/
protected $policies = [
'App\Model' => 'App\Policies\ModelPolicy',
];
/**
* Register any application authentication / authorization services.
*
* @param \Illuminate\Contracts\Auth\Access\Gate $gate
* @return void
*/
public function boot(GateContract $gate)
{
$this->registerPolicies($gate);
//
}
}
<?php
namespace App\Providers;
use Illuminate\Contracts\Events\Dispatcher as DispatcherContract;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
class EventServiceProvider extends ServiceProvider
{
/**
* The event listener mappings for the application.
*
* @var array
*/
protected $listen = [
'App\Events\SomeEvent' => [
'App\Listeners\EventListener',
],
];
/**
* Register any other events for your application.
*
* @param \Illuminate\Contracts\Events\Dispatcher $events
* @return void
*/
public function boot(DispatcherContract $events)
{
parent::boot($events);
//
}
}
<?php
namespace App\Providers;
use Illuminate\Routing\Router;
use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;
class RouteServiceProvider extends ServiceProvider
{
/**
* This namespace is applied to your controller routes.
*
* In addition, it is set as the URL generator's root namespace.
*
* @var string
*/
protected $namespace = 'App\Http\Controllers';
/**
* Define your route model bindings, pattern filters, etc.
*
* @param \Illuminate\Routing\Router $router
* @return void
*/
public function boot(Router $router)
{
//
parent::boot($router);
}
/**
* Define the routes for the application.
*
* @param \Illuminate\Routing\Router $router
* @return void
*/
public function map(Router $router)
{
$this->mapWebRoutes($router);
//
}
/**
* Define the "web" routes for the application.
*
* These routes all receive session state, CSRF protection, etc.
*
* @param \Illuminate\Routing\Router $router
* @return void
*/
protected function mapWebRoutes(Router $router)
{
$router->group([
'namespace' => $this->namespace, 'middleware' => 'web',
], function ($router) {
require app_path('Http/routes.php');
});
}
}
<?php
namespace App;
/**
* Very simple Redis implementation, all commands passed in cli format
* Add commands via cmd ( $command [, $variable1 [, $variable2 ] ] ) method
* Fire commands via get () o set () methods ( first one will return output, usefull for get operations )
*
* Usage:
* $redis = new redis_cli ( '127.0.0.1', 6379 );
* $redis -> cmd ( 'SET', 'foo', 'bar' ) -> set ();
* $foo = $redis -> cmd ( 'GET', 'foo' ) -> get ();
*
* $redis -> cmd ( 'HSET', 'hash', 'foo', 'bar' ) -> cmd ( 'HSET', 'hash', 'abc', 'def' ) -> set ();
* $vals = $redis -> cmd ( 'HVALS', 'hash' ) -> get ();
*
* $redis -> cmd ( 'KEYS', 'online*' );
* $total_online = $redis -> get_len ();
*
* Based on http://redis.io/topics/protocol
*/
class Redis
{
const INTEGER = ':';
const INLINE = '+';
const BULK = '$';
const MULTIBULK = '*';
const ERROR = '-';
const NL = "\r\n";
private $handle = false;
private $host;
private $port;
private $silent_fail;
private $commands = array ();
//Timeout for stream, 30 seconds
private $timeout = 30;
//Timeout for socket connection
private $connect_timeout = 3;
//Use this with extreme caution
private $force_reconnect = false;
//Error handling, debug info
private $last_used_command = '';
//Error handling function, use set_error_function method ()
private $error_function = null;
public function __construct ( $host = false, $port = false, $silent_fail = false, $timeout = 60 )
{
if ( $host && $port )
{
$this -> connect ( $host, $port, $silent_fail, $timeout );
}
}
//Main method to establish connection
public function connect ( $host = '127.0.0.1', $port = 6379, $silent_fail = false, $timeout = 60 )
{
$this -> host = $host;
$this -> port = $port;
$this -> silent_fail = $silent_fail;
$this -> timeout = $timeout;
if ( $silent_fail )
{
$this -> handle = @fsockopen ( $host, $port, $errno, $errstr, $this -> connect_timeout );
if ( !$this -> handle )
{
$this -> handle = false;
}
}
else
{
$this -> handle = fsockopen ( $host, $port, $errno, $errstr, $this -> connect_timeout );
}
if ( is_resource ( $this -> handle ) )
{
stream_set_timeout ( $this -> handle, $this -> timeout );
}
}
public function reconnect ( )
{
$this -> __destruct ();
$this -> connect ( $this -> host, $this -> port, $this -> silent_fail );
}
public function __destruct ()
{
if ( is_resource ( $this -> handle ) )
{
fclose ( $this -> handle );
}
}
//Returns all commands array
public function commands ()
{
return $this -> commands;
}
//Used to push single command to queue
public function cmd ()
{
if ( !$this -> handle )
{
return $this;
}
$args = func_get_args ();
$rlen = count ( $args );
$output = '*'. $rlen . self::NL;
foreach ( $args as $arg )
{
$output .= '$'. strlen ( $arg ) . self::NL . $arg . self::NL;
}
$this -> commands [] = $output;
return $this;
}
//Used to push many commands at once, almost always for setting something
public function set ()
{
if ( !$this -> handle )
{
return false;
}
//Total size of commands
$size = $this -> exec ();
$response = array ();
for ( $i=0; $i<$size; $i++ )
{
$response [] = $this -> get_response ();
}
if ( $this -> force_reconnect )
{
$this -> reconnect ();
}
return $response;
}
//Used to get command response
public function get ( $line = false )
{
if ( !$this -> handle )
{
return false;
}
$return = false;
if ( $this -> exec () )
{
$return = $this -> get_response ();
if ( $this -> force_reconnect )
{
$this -> reconnect ();
}
}
return $return;
}
//Used to get length of the returned array. Most useful with `Keys` command
public function get_len ()
{
if ( !$this -> handle )
{
return false;
}
$return = null;
if ( $this -> exec () )
{
$char = fgetc ( $this -> handle );
if ( $char == self::BULK )
{
$return = sizeof ( $this -> bulk_response () );
}
elseif ( $char == self::MULTIBULK )
{
$return = sizeof ( $this -> multibulk_response () );
}
if ( $this -> force_reconnect )
{
$this -> reconnect ();
}
}
return $return;
}
//Forces to reconnect after every get() or set(). Use this with extreme caution
public function set_force_reconnect ( $flag )
{
$this -> force_reconnect = $flag;
return $this;
}
//Used to parse single command single response
private function get_response ()
{
$return = false;
$char = fgetc ( $this -> handle );
switch ( $char )
{
case self::INLINE:
$return = $this -> inline_response ();
break;
case self::INTEGER:
$return = $this -> integer_response ();
break;
case self::BULK:
$return = $this -> bulk_response ();
break;
case self::MULTIBULK:
$return = $this -> multibulk_response ();
break;
case self::ERROR:
$return = $this -> error_response ();
break;
}
return $return;
}
//For inline responses only
private function inline_response ()
{
return trim ( fgets ( $this -> handle ) );
}
//For integer responses only
private function integer_response ()
{
return ( int ) trim ( fgets ( $this -> handle ) );
}
//For error responses only
private function error_response ()
{
$error = fgets ( $this -> handle );
if ( $this -> error_function )
{
call_user_func ( $this -> error_function, $error .'('. $this -> last_used_command .')' );
}
return false;
}
//For bulk responses only
private function bulk_response ()
{
$return = trim ( fgets ( $this -> handle ) );
if ( $return === '-1' )
{
$return = null;
}
else
{
$return = $this -> read_bulk_response ( $return );
}
return $return;
}
//For multibulk responses only
private function multibulk_response ()
{
$size = trim ( fgets ( $this -> handle ) );
$return = false;
if ( $size === '-1' )
{
$return = null;
}
else
{
$return = array ();
for ( $i = 0; $i < $size; $i++ )
{
$tmp = trim ( fgets ( $this -> handle ) );
if ( $tmp === '-1' )
{
$return [] = null;
}
else
{
$return [] = $this -> read_bulk_response ( $tmp );
}
}
}
return $return;
}
//Sends command to the redis
private function exec ()
{
$size = sizeof ( $this -> commands );
if ( $size < 1 )
{
return null;
}
if ( $this -> error_function )
{
$this -> last_used_command = str_replace ( self::NL, '\\r\\n', implode ( ';', $this -> commands ) );
}
$command = implode ( self::NL, $this -> commands ) . self::NL;
fwrite ( $this -> handle, $command );
$this -> commands = array ();
return $size;
}
//Bulk response reader
private function read_bulk_response ( $tmp )
{
$response = null;
$read = 0;
$size = ( ( strlen ( $tmp ) > 1 && substr ( $tmp, 0, 1 ) === self::BULK ) ? substr ( $tmp, 1 ) : $tmp );
while ( $read < $size )
{
$diff = $size - $read;
$block_size = $diff > 8192 ? 8192 : $diff;
$response .= fread ( $this -> handle, $block_size );
$read += $block_size;
}
fgets ( $this -> handle );
return $response;
}
public function set_error_function ( $func )
{
$this -> error_function = $func;
}
}
<?php
namespace App;
use Illuminate\Foundation\Auth\User as Authenticatable;
class User extends Authenticatable
{
/**
* The attributes that are mass assignable.
*
* @var array
*/
protected $fillable = [
'name', 'email', 'password',
];
/**