Esta secuencia es la requerida para instalar java 8 manualmente:

mkdir /home/ubuntu/tempporal
cd /home/ubuntu/temporal


wget http://gustavo-arellano.com/jdk-8u121-linux-x64.gz
tar -xzvf jdk-8u121-linux-x64.gz
sudo mkdir /usr/java
sudo mv jdk1.8.0_121 /usr/java/
cd /usr/java/
sudo ln -s jdk1.8.0_121 current
sudo update-alternatives --install "/usr/bin/java" "java" "/usr/java/current/bin/java" 1
sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/java/current/bin/javac" 1


cd /home/ubuntu/temporal


wget http://www-us.apache.org/dist/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz
tar -xzvf apache-maven-3.3.9-bin.tar.gz
sudo mkdir /usr/maven
sudo mv apache-maven-3.3.9 /usr/maven/
cd /usr/maven/
sudo ln -s apache-maven-3.3.9 current
sudo update-alternatives --install "/usr/bin/mvn" "mvn" "/usr/maven/current/bin/mvn" 1


cd /home/ubuntu/
java -version
javac -version
mvn -version

Cheers,
Goose

mvn archetype:generate -B \
	-DarchetypeGroupId=mx.com.metasoft \
	-DarchetypeArtifactId=skeleton-archetype \
	-DarchetypeVersion=2.0.17-RELEASE \
	-DarchetypeRepository=http://52.91.168.238:8081/repository/maven-releases \
	-DgroupId=uk.org.queen \
	-DartifactId=king \
	-Dversion=0.0.1-SNAPSHOT \
	-Dpackage=uk.org.queen.king

Este post indica como instalar un cluster de cassandra con mas de un nodo. Asumo que la máquina en donde se va a instalar es un Ubuntu 16.04 obtenido de AWS:

sudo sh -c "echo 'LC_ALL=en_US.UTF-8\nLANG=en_US.UTF-8' >> /etc/environment"
sudo apt-get update
sudo apt-get install python2.7
sudo apt-get install default-jdk
    
sudo groupadd cassandra
sudo useradd -d /home/cassandra -s /bin/bash -m -g cassandra cassandra
sudo su cassandra -l
wget http://www-eu.apache.org/dist/cassandra/3.9/apache-cassandra-3.9-bin.tar.gz
tar -xzvf apache-cassandra-3.9-bin.tar.gz
nano apache-cassandra-3.9/conf/cassandra-env.sh
nano apache-cassandra-3.9/conf/cassandra.yaml

Posterior a los 11 comandos anteriores, hay que editar el archivo:

CASSANDRA_HOME/conf/cassandra.yaml

los cambios son los siguientes:

. . .
cluster_name: 'GooseDOCluster'
. . .
seed_provider:
  - class_name: org.apache.cassandra.locator.SimpleSeedProvider
    parameters:
         - seeds: "your_server_ip,your_server_ip_2,...your_server_ip_n"
. . .
listen_address: your_server_ip
. . .
rpc_address: your_server_ip
. . .
endpoint_snitch: GossipingPropertyFileSnitch
. . .

Yo puse las IP’s internas en cada : “your_server_ip” porque las externas (o públicas) no me funcionaron.
Ahora hay que reiniciar el servicio. Todos los binarios se encuentran en CASSANDRA_HOME/bin

Si llegara a haber algún problema de conexión, se tendrá que editar el archivo cassandra-env.sh reemplazando el hostname por el IP interno de la máquina:

JVM_OPTS="$JVM_OPTS -Djava.rmi.server.hostname=[host_name]"

Listo !!!

Hola !!!

Hoy vamos a crear un jar Ejecutable que incluya todas sus dependencias con MAVEN

Paso 1)
Agrega lo siguiente en el pom.xml:

<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<archive>
<manifest>
<mainClass>package-path.Main-Class-With-Main-Method</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</plugin>
</plugins>
</build>

Ahora desde tu terminal, ve al directorio en donde esta tu POM y teclea:


mvn clean compile assembly:single

Listo !!!!

scp guest@10.11.12.13:/usr/java/jdk-8u65-linux-x64.tar.gz .

sudo su
mkdir /usr/java
mv jdk-8u65-linux-x64.tar.gz /usr/java/
cd /usr/java/
tar -xzvf jdk-8u65-linux-x64.tar.gz

ln -s jdk1.8.0_65 current
update-alternatives –install “/usr/bin/javac” “javac” “/usr/java/current/bin/javac” 1
update-alternatives –install “/usr/bin/java” “java” “/usr/java/current/bin/java” 1

update-alternatives –display java
update-alternatives –display javac
exit

java -version

Problema:

Tenemos un Spring REST controller como este:

	@RequestMapping( 
			value = "/slots/{nodePath}/{slot}.json",  
			method = RequestMethod.DELETE,  
			produces = "application/json") 
	@ResponseBody 
	public ContentSlot deleteSlot( 
	        @RequestParam(value = "format", required = false) final String format, 
	        @RequestParam(value = "geo", required = false) final String geo, 
	        @RequestParam(value = "segment", required = false) final String segment, 
	        @RequestParam(value = "version", required = false) final String version, 
	        @PathVariable final String slot, 
	        @PathVariable final String nodePath, 
	        HttpServletRequest request, 
	        Principal principal 
	                    ) { 
                  .....
       }

Ojo en la linea que trae algo como esto:

@PathVariable final String nodePath,

Se quiere validar la cadena “nodePath”, pero no se desea tener un metodo “validador” en cada Controller que reciba esa cadena y que la valide (o transforme) en lo requerido.

Se desea que para cuando recuperemos el valor de tal objeto, este ya este validado/transformado en lo que realmente se requiere.

Para ello, hacemos lo siguiente:

1) Creamos esta anotación:

/**
 * Annotate any custom converter in the application with @UiParamConverter so it can be discovered
 * at runtime and registered
 */
@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Qualifier
@Component
public @interface UiParamConverter {
}

2) Creamos esta clase convertidora:

@UiParamConverter
public class NodeConverter implements Converter {

	/**
	 * This NodePath object is used by the controllers to reference a node path in a safe way
	 */
	public static class NodePath {

		/**
		 * The nodepath (e.g. standard/home)
		 */
		private String nodePath;
		
		/**
		 * Constructor. Initializes the nodePath by converting ~ to /
		 * @param dirtyNodePath		The unvalidated node path, e.g. standard~home
		 */
		public NodePath(String dirtyNodePath) {
			if (dirtyNodePath == null) {
				throw new IllegalArgumentException("Node Path cannot be null");
			}
			if (dirtyNodePath != null) {
				nodePath = dirtyNodePath.replaceAll("[~]", "/");
			}
		}

		/**
		 * Returns the value of the node path after the validations and transformations
		 * @return		The nodepath that we want to work with
		 */
		public String get() {
			return nodePath;
		}
	}

	/**
	 * Cache for the empty node path as a performance optimization
	 */
	private static final NodePath emptyNodePath = new NodePath("");
	
	/**
	 * Implementation of the converter. Transforms a node path that is in the format of standard~home to standard/home
	 */
    @Override
    public NodePath convert(final String nodePath) {
    	if (nodePath == null) {
    		return null;
    	}
        if (ASStringUtilities.isNullOrEmpty(nodePath)) {
            return emptyNodePath;
        }
        return new NodePath(nodePath);
    }
}

3) Lo usamos en el controller original:

	public ContentSlot deleteSlot( 
	        @RequestParam(value = "format", required = false) final String format, 
	        @RequestParam(value = "geo", required = false) final String geo, 
	        @RequestParam(value = "segment", required = false) final String segment, 
	        @RequestParam(value = "version", required = false) final String version, 
	        @PathVariable final String slot, 
	        @PathVariable final NodePath nodePath, 
	        HttpServletRequest request, 
	        Principal principal 
	                    ) { 
                String value = nodePath.get();
        }

Cheers,
Goose

Algunas veces es agradable ver un segmento de código sólo por si mismo, sin que realmente este dedicado a resolver ningún problema específico… simplemente se percibe una sensación agradable al verlo. Este es un ejemplito de ello:

@UiParamConverter
public class VersionConverter implements GenericConverter {

    @Target({ ElementType.PARAMETER, ElementType.FIELD })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface VersionCode {

    }

    @Target({ ElementType.PARAMETER, ElementType.FIELD })
    @Retention(RetentionPolicy.RUNTIME)
    public @interface VersionId {

    }

    @Autowired(required = false)
    private VersionService versionService;

    private static final Logger log = LoggerFactory.getLogger(VersionConverter.class);

    @Override
    public Set getConvertibleTypes() {
        return Collections.singleton(new ConvertiblePair(String.class, PublishingVersion.class));
    }

    @Override
    public Object convert(final Object source, final TypeDescriptor sourceType, final TypeDescriptor targetType) {
        if ((!(source instanceof String)) || StringUtils.isBlank((String) source)) {
            return null;
        }

        final String fieldValue = (String) source;
        String fieldType = null;

        PublishingVersion version = null;

        try {
            // see what Version type annotation is on the TargetType
            if (targetType.hasAnnotation(VersionId.class)) {
                fieldType = new String("versionId");
                version = versionService.getVersionById(fieldValue);
            } else if (targetType.hasAnnotation(VersionCode.class)) {
                fieldType = new String("code");
                version = versionService.getVersionByCode(fieldValue);
            } else {
                // Default - assume we're dealing with a code
                fieldType = new String("code");
                version = versionService.getVersionByCode(fieldValue);
            }
        } catch (final Exception e) {
            log.warn(String.format("Error fetching version using field '%s' and value '%s'.", fieldType, fieldValue), e);
        }

        if (version == null) {
            log.info(String.format("Could not find version using field '%s' and value '%s'.", fieldType, fieldValue));
        }
        return version;
    }
}

Cheers,
Goose

A veces es útil NO tener que crear una clase que implemente una interfaz y luego hacer una instancia de esa clase.
En esos casos es posible simplemente crear la interfaz y hacer una instanciacion “directa”… mas o memos así:

Crear una interfaz así:

public interface ServerVars {
    String getAppName();
    Map getVars();
}

y ahora crear una instancia de “ese tipo” así:

    public ServerVars serverVars() {
        return new ServerVars() {
            @Override
            public String getAppName() {
                return "nemo";
            }
            @Override
            public Map getVars() {
                return Collections.emptyMap();
            }};
    }

Listo !!!

Cheers,
Goose

Instalar OracleJava:
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer

Instalar Tomcat
Bajar el binario
Descomprimirlo
Ir a su directorio bin y dar permisos de ejecución a los archivos .sh

Instalar Maven:


Método 1:

Bajar tar y descomprimirlo
Poner las variables de ambiente en /etc/environment
Crear un archivo x.sh en: /etc/profile.d
Agregar a x.sh la linea: export PATH=$PATH:$MAVEN_HOME/bin


Método 2:

$ sudo apt-get install maven
(y sólo si es necesario:)
$ sudo apt-get remove maven2
$ sudo apt-get update
$ sudo apt-get install maven

Bajar Eclipse (en este ejemplo es el Kepler) de:

http://www.mirrorservice.org/sites/download.eclipse.org/eclipseMirror/technology/epp/downloads/release/kepler/SR1/

(con wget)

LISTO

Hola a todos!!!

Al ejecutar: mvn archetype:create-from-project maven me da el siguiente error:
(TOO MANY OPEN FILES)
¿Cómo lo resolví? Así:
———————————————–
1) Agregar, al final de: /etc/sysctl.conf
la siguiente línea:
fs.file-max=16000000
———————————————–
2) Agregar, al final de: /etc/security/limits.conf
las siguientes 2 líneas:
* soft nofile 40960
* hard nofile 102400
———————————————–

Cheers,
Goose

© 2017 Goose Workshop Suffusion theme by Sayontan Sinha