LinuxParty

Este Tutorial demuestra cómo instalar un Cluster web server Apache con dos nodos que proporcione un alto rendimiento. Delante del Cluster de Apache creamos un balanceador de carga que divida las peticiones entrantes entre dos nodos de Apache. Porque no quisiéramos que el balanceador de carga se convirtiera en otro “simple punto fallido”, debemos proporcionarle también un alto rendimiento al balanceador de carga.

Por lo tanto nuestro balanceador de carga, consistirá en tener fuera en los dos nodos del balanceador de carga que supervisarán el funcionamiento del corazón del sistema, y si un balanceador de carga falla, el otro asume el control silenciosamente.

"Abandonadas a su propia suerte, una burbuja se debilitará y explotará cuando el líquido intercalado entre las dos capas finas de jabón sucumba a la gravedad y drene hacia el suelo. Pero cuando los investigadores atraparon una burbuja entre dos electrodos de platino  y le inyectaron tensión, el líquido invierte la dirección y el fluido, emergiendo contra la fuerza de gravedad. Las burbujas se hacen más fuertes y estables y pueden vivir durante horas y aún visiblemente cambiar los colores así como sus paredes hacerse más gruesas.

>

Tan sencillo como elaborar una lista de tus amigos de Facebook con los que querrías mantener relaciones sexuales y esperar a que ellos también te marquen en su lista.

Pensarás que la idea de Bang with friends se te podía haber ocurrido a ti después de una noche de juerga con los colegas, cachondeo y alcohol… pero es que se les ha ocurrido a un grupo de amigos en esa precisa circunstancia en que todo parece posible.

No solo Windows y Mac OS X son afectados por agujeros de seguridad. Una vulnerabilidad que acaba de ser solucionada ha sido probablemente explotada durante seis meses.

La vulnerabilidad en cuestión está situada en el Linux network stack, y puede ser aprovechada por intrusos para asignar derechos de administrador a un usuario corriente. El error radica en el archivo “net/core/sock_diag.c”, que hace posible para un atacante desencadenar un acceso de tipo out-of-bounds, consiguiendo así acceso directo al kernel.

Publica USA Today que el multimillonario australiano Clive Palmer ha revelado sus planes para la construcción del Titanic II, un crucero diseñado como una "gran escala re-creación" del Titanic, y agregó que la nave se construirá en China y comenzará el transporte de pasajeros en el año 2016. El Titanic II tendrá 883 metros de largo -. 3 pulgadas más largo que el Titanic original - y pesará 55.800 toneladas brutas, según Palmer, que no llama al buque insumergible. Llevará un máximo de 2.435 pasajeros y 900 miembros de la tripulación, y contará con gimnasio, baño turco, pista de squash, una piscina, un teatro y un casino. Al igual que la nave original, no habrá televisores a bordo y, probablemente, no habrá servicio de Internet, dice Palmer. Los pasajeros podrán a vestirse con ropa del estilo de 1912, dándoles la oportunidad de dar un paso atrás en el tiempo, o fingir que son Leo DiCaprio o Kate Winslet, quienes protagonizaron en 1997 la película de éxito de taquilla de James Cameron. Pero expertos de la industria son escépticos sobre la viabilidad comercial de la nave.

Ubuntu para móviles, o la versión de Ubuntu para dispositivos táctiles, está despertando bastante interés entre los usuarios y las empresas del sector, ganando además diversos reconocimientos en el camino. El último de ellos recibido en el marco del Mobile World Congress 2013.

Know Your Mobile ha otorgado a Canonical el reconocimiento a Mejor innovación (Best Innovation) por su trabajo en la versión táctil de Ubuntu para móviles y tabletas.

Un módulo es un elemento de contenido que puede ser situado junto a un artículo. Por ejemplo, un menú es un módulo. El pequeño bloque de registro de la parte izquierda, también es un módulo. Puedes crear tantos módulos como quieras, y colocarlos en distintas áreas predefinidas de la plantilla.En este tutorial se explica cómo crear un módulo simple. A través del cual, aprenderá la estructura básica de archivos de un módulo. Esta estructura básica puede ser ampliada para producir módulos más elaborados.

Tenemos la programación de un módulo algo más sencillo en este artículo.

Programar un módulo para Joomla! 2.5

Todo el contenido expuesto en este artículo, está extraído y traducido de la documentación que la comunidad de Joomla! ofrece íntegramente en inglés en su sección para desarrolladores. Para más información siga este enlace.

Este tutorial le proporciona lo básico, de lo que se necesita saber para desarrollar tu propio módulo y un poquito más. Para lograr esto, la mejor forma es crear un módulo básico que nos muestre, que es lo que debe tener un módulo para su operabilidad en Joomla! 2.5. Nuestro módulo de ejemplo, su función será, mostrar otros artículos del mismo autor. Aunque en el transcurso del tutorial iremos explicando y exponiendo el código de nuestro módulo, al final de este artículo encontrarán un enlace a la descarga del fichero adjunto, donde podrá obtener el módulo con todos los pasos aquí expuesto y listo para su instalación.

Estructura de archivos

Hay cuatro archivos básicos que se utilizan dentro del patrón estándar en el desarrollo de un módulo:

• mod_author_related.php - Este archivo es el principal punto de entrada para el módulo. Se llevarán a cabo las rutinas de inicialización necesarias, llamar a las rutinas auxiliares para recoger todos los datos necesarios, e incluir la plantilla que muestra la salida del módulo.
• mod_author_related.xml - Este archivo contiene información acerca del módulo. En él se definen los archivos que necesitan ser instalados por el instalador de Joomla! y especifica los parámetros de configuración del módulo.
• helper.php - Este archivo contiene la clase helper que se utiliza para hacer el trabajo real en la recuperación de la información que se muestra en el módulo (por lo general a partir de la base de datos o alguna otra fuente).
• tmpl/default.php - Esta es la plantilla del módulo. Este archivo tomará los datos recogidos por el mod_author_related.php y generará el código HTML que se muestra en la página.

Creación del mod_author_related.php

El archivo mod_author_related.php llevará a cabo tres tareas:

• Incluir el archivo helper.php que contiene la clase que se utiliza para recoger los datos necesarios.
• Invocar el método apropiado para recuperar los datos.
• Incluir la plantilla para mostrar la salida.

Siguiendo estos tres puntos, vamos a colocar un poco de código en nuestro archivo. La clase helper está definida en nuestro archivo helper.php . Este archivo se incluye con la declaración require_once .

require_once dirname(__FILE__).'/helper.php';

require_once se utiliza porque nuestras funciones auxiliares se definen dentro de una clase, y sólo queremos la clase definida, una vez.

Para invocar a nuestro método utilizaremos las siguientes líneas:

mod_author_related.php

<?php
 $cacheparams = new stdClass;
 $cacheparams->class = 'modAuthorRelatedHelper';
 $cacheparams->method = 'authorRelated';
 $list = JModuleHelper::moduleCache ($module, $params, $cacheparams);
 require JModuleHelper::getLayoutPath('mod_author_related', $params->get('layout', 'default'));
?>

Y para incluir la plantilla que muestra el HTML de nuestro módulo, usamos está línea:

require JModuleHelper::getLayoutPath('mod_author_related', $params->get('layout', 'default'));

Visto esto, nuestro archivo mod_author_related.php completo es el siguiente:

<?php
 // No permitir el acceso directo al archivo
 defined('_JEXEC') or die;

 // Incluye las funciones sólo una vez
 require_once dirname(__FILE__).'/helper.php';

 // Invocar el método apropiado
 $cacheparams = new stdClass;
 $cacheparams->cachemode = 'safeuri';
 $cacheparams->class = 'modAuthorRelatedHelper';
 $cacheparams->method = 'authorRelated';
 $cacheparams->methodparams = $params;
 $cacheparams->modeparams = array('id'=>'int', 'Itemid'=>'int');

 $list = JModuleHelper::moduleCache ($module, $params, $cacheparams);

 if (!count($list)) {
  return;
 }

 $moduleclass_sfx = htmlspecialchars($params->get('moduleclass_sfx'));
 $showDate = $params->get('showDate', 0);

 // Incluir la plantilla que mostrará los datos recogidos
 require JModuleHelper::getLayoutPath('mod_author_related', $params->get('layout', 'default'));
?>

Creación del helper.php

El archivo helper.php contiene la clase necesaria para recuperar los datos que se muestran en la salida del módulo. Esta clase a su vez tendrá un método que se encargara de dicha tarea.
Aquí está el código para el archivo helper.php:

Observe que no se incluye la etiqueta de cierre de php “?>”.

<?php
// No permitir el acceso directo al archivo
defined('_JEXEC') or die;

// Utilizado para la ruta a los artículos
require_once JPATH_SITE.'/components/com_content/helpers/route.php';

// Clase helper que se utiliza para hacer el trabajo real en la recuperación de la información
abstract class modAuthorRelatedHelper
{

// Método que implementa la captura de la información necesaria a ser mostrada
public static function authorRelated($params)
 {
  $db  = JFactory::getDbo();
  $app  = JFactory::getApplication();
  $user  = JFactory::getUser();
  $userId = (int) $user->get('id');
  $count  = intval($params->get('count', 5));
  $groups = implode(',', $user->getAuthorisedViewLevels());
  $date  = JFactory::getDate();
  
  $option = JRequest::getCmd('option');
  $view  = JRequest::getCmd('view');

  $temp  = JRequest::getString('id');
  $temp  = explode(':', $temp);
  $id  = $temp[0];
  
  $showDate = $params->get('showDate', 0);
  $nullDate = $db->getNullDate();
  $now  = $date->toSql();
  $related = array();
  $query  = $db->getQuery(true);
  
  if ($option == 'com_content' && $view == 'article' && $id) 
  {  
   // seleccionar el autor del artículo

    $query->select('created_by');
    $query->from('#__content');
    $query->where('id = ' . (int) $id);
    $db->setQuery($query);
   
    $author = $db->loadResult();
    $query->clear();
   
   // Filtrar el contenido del autor 
  
    $query->select('a.id as art');
    $query->select('a.title');
    $query->select('DATE_FORMAT(a.created, "%Y-%m-%d") as created');
    $query->select('a.catid as cat');
                
    $query->from('#__content AS a');
    
    $query->where('a.id != ' . (int) $id);
    $query->where('a.state = 1');
    $query->where('a.access IN (' . $groups . ')');
    $query->where('(a.publish_up = '.$db->Quote($nullDate).' OR a.publish_up <= '.$db->Quote($now).')');
    $query->where('(a.publish_down = '.$db->Quote($nullDate).' OR a.publish_down >= '.$db->Quote($now).')');    
    $query->where('a.created_by = ' . (int) $author);
    // Filtrar por idioma
    if ($app->getLanguageFilter()) {
     $query->where('a.language in (' . $db->Quote(JFactory::getLanguage()->getTag()) . ',' . $db->Quote('*') . ')');
    }    
            
    $db->setQuery($query);
    $temp = $db->loadObjectList();
    
    if (count($temp))
    {
     foreach ($temp as $row)
     {
      $row->route = JRoute::_(ContentHelperRoute::getArticleRoute($row->art, $row->cat));
      $related[] = $row;     
     }
    }
    unset ($temp);
  }
  return $related;
 }
}

Como puedes darte cuenta, tenemos dos cosas importantes en este archivo:

• La clase modAuthorRelatedHelper : Que no existe ninguna regla, que obligue a escribir el nombre de dicha clase de esa forma, pero nos ayuda a hacer esto para que sea fácilmente identificable y localizable.
• Y el método authorRelated() : Que es donde dejamos volar nuestros conocimientos, y ponemos o programamos la captura de la información que se desea mostrar.

Creación del tmpl/default.php

El archivo default.php es la plantilla que muestra la salida del módulo. El código para el archivo default.php es el siguiente:

<?php
// No permitir el acceso directo al archivo
defined('_JEXEC') or die;
?>

<ul class="authorelated<?php echo $moduleclass_sfx; ?>">
 <?php foreach ($list as $item) : ?>
  <li>
   <a href="/<?php echo $item->route; ?>">
    <?php if ($showDate) echo JHTML::_('date', $item->created, JText::_('DATE_FORMAT_LC4')). " - "; ?>
    <?php echo $item->title; ?>
   </a>
  </li>
 <?php endforeach; ?>
</ul>

Aquí mostramos los títulos de los otros artículos del autor a través de $item->title, con la opción de mostrar o no la fecha. Esta opción de mostrar o no la fecha se hace a través del parámetro showDate, que vamos a definir a continuación en el archivo XML de nuestro módulo.

OpenLDAP es una implementación libre y de código abierto del protocolo Lightweight Directory Access Protocol (LDAP) desarrollada por el proyecto OpenLDAP.

LDAP permite el acceso a un servicio de directorio ordenado y distribuido para buscar  información diversa en un entorno de red.

Han pasado algo más de 6 meses desde que Google Fiber comenzase a operar en Kansas City, ofreciendo a los habitantes de esta ciudad una conexión FTTH de 1 Gbps (tanto en subida como en bajada) por un precio de 70 dólares al mes además de un servicio básico de acceso gratuito con 5 Mbps de velocidad (tras pagar los costes de instalación que rondan los 300 dólares). La irrupción de Google en el sector de los operadores era algo que no iba a pasar inadvertido y, gracias a este proyecto piloto, comienzan a verse algunos efectos en el sector de las telecomunicaciones de Estados Unidos que muestran que Google Fiber puede ser un importante tractor que haga evolucionar este mercado. Más información y datos concretos en el artículo El impacto de Google Fiber en el sector de las telecomunicaciones de EE.UU..