//###
//# #%L
//# mosaic-mjades
//# %%
//# Copyright (C) 2010 - 2012 Seconda Università di Napoli
//#Authors: Massimiliano Rak, Giuseppe Aversano
//# %%
//# Licensed under the Apache License, Version 2.0 (the "License");
//# you may not use this file except in compliance with the License.
//# You may obtain a copy of the License at
//#
//# http://www.apache.org/licenses/LICENSE-2.0
//#
//# Unless required by applicable law or agreed to in writing, software
//# distributed under the License is distributed on an "AS IS" BASIS,
//# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//# See the License for the specific language governing permissions and
//# limitations under the License.
//# #L%
//###
package eu.mosaic_cloud.sunutilities;
import eu.mosaic_cloud.cloudlets.connectors.kvstore.IKvStoreConnector;
import eu.mosaic_cloud.cloudlets.connectors.kvstore.IKvStoreConnectorFactory;
import eu.mosaic_cloud.cloudlets.connectors.kvstore.KvStoreCallbackCompletionArguments;
import eu.mosaic_cloud.cloudlets.connectors.queue.amqp.AmqpQueueConsumeCallbackArguments;
import eu.mosaic_cloud.cloudlets.connectors.queue.amqp.IAmqpQueueConsumerConnector;
import eu.mosaic_cloud.cloudlets.connectors.queue.amqp.IAmqpQueueConsumerConnectorFactory;
import eu.mosaic_cloud.cloudlets.connectors.queue.amqp.IAmqpQueuePublisherConnector;
import eu.mosaic_cloud.cloudlets.connectors.queue.amqp.IAmqpQueuePublisherConnectorFactory;
import eu.mosaic_cloud.cloudlets.core.CallbackArguments;
import eu.mosaic_cloud.cloudlets.core.CloudletCallbackArguments;
import eu.mosaic_cloud.cloudlets.core.CloudletCallbackCompletionArguments;
import eu.mosaic_cloud.cloudlets.core.GenericCallbackCompletionArguments;
import eu.mosaic_cloud.cloudlets.core.ICallback;
import eu.mosaic_cloud.cloudlets.core.ICloudletController;
import eu.mosaic_cloud.cloudlets.tools.DefaultAmqpPublisherConnectorCallback;
import eu.mosaic_cloud.cloudlets.tools.DefaultAmqpQueueConsumerConnectorCallback;
import eu.mosaic_cloud.cloudlets.tools.DefaultCloudletCallback;
import eu.mosaic_cloud.cloudlets.tools.DefaultKvStoreConnectorCallback;
import eu.mosaic_cloud.platform.core.configuration.ConfigurationIdentifier;
import eu.mosaic_cloud.platform.core.configuration.IConfiguration;
import eu.mosaic_cloud.platform.core.utils.PlainTextDataEncoder;
import eu.mosaic_cloud.platform.core.utils.SerializedDataEncoder;
import eu.mosaic_cloud.tools.callbacks.core.CallbackCompletion;
import eu.mosaic_cloud.platform.core.utils.JsonDataEncoder;
import java.util.Vector;
public class XmlAnalyzerCloudlet
{
// Consumer dal client
/*
* Il mio callback consumer deve implementare l'interfaccia IAmqpQueueConsumerCallback o estendere la classe DefaultAmqpConsumerCallback.
*
* Default AMQP Consumer callback.
*
* Il contesto della cloudlet callback
* Il tipo di valore scambiato
* Valore extra.
*
* Quando un messaggio per l'istanza Cloudlet arriva al connector, il metodo di consumo () di callback viene chiamata e il messaggio viene recapitato.
* Il messaggio può essere confermato (acknowledge) con il metodo acknowledge()
*/
public static final class AmqpConsumerCallback
extends DefaultAmqpQueueConsumerConnectorCallback<XmlAnalyzerCloudletContext, String, Void>
{
/*
* Si noti che i metodi di callback prendono un argomento di tipo AmqpQueueConsumeCallbackArguments. Questo estende CallbackArguments
* e contiene i dati restituiti dalle operazioni.
*/
@Override
public CallbackCompletion<Void> consume (final XmlAnalyzerCloudletContext context, final AmqpQueueConsumeCallbackArguments<String> arguments)
{
final String data = arguments.getMessage ();
this.logger.info("\nDato ricevuto da XmlAnalyzerCloudlet:"+data+"\n");
context.Count=CountElements.count(data);
//this.logger.info("\n Numero caratteri contati\n"+context.Count);
this.logger.info("\nPubblicazione Numero elementi contati:\n"+context.Count);
//this.logger.info("\nPubblicazione Numero elementi contati\n");
context.publisher.publish(context.Count, null);
context.consumer.acknowledge (arguments.getToken ());
return ICallback.SUCCESS;
}
@Override
public CallbackCompletion<Void> destroySucceeded (final XmlAnalyzerCloudletContext context, final CallbackArguments arguments)
{
this.logger.info ("XmlAnalyzerCloudlet destroyed successfully.");
return ICallback.SUCCESS;
}
@Override
public CallbackCompletion<Void> initializeSucceeded (final XmlAnalyzerCloudletContext context, final CallbackArguments arguments)
{
this.logger.info ("XmlAnalyzerCloudlet ConsumerClient initialized successfully.");
return ICallback.SUCCESS;
}
public CallbackCompletion<Void> acknowledgeSucceeded (final XmlAnalyzerCloudletContext context, final GenericCallbackCompletionArguments<Void> arguments)
{
// context.cloudlet.destroy ();
return ICallback.SUCCESS;
}
}
//Push verso il WG
/*
* Il mio callback publisher deve implementare l'interfaccia IAmqpQueuePublisherCallback o estendere la classe DefaultAmqpPublisherCallback.
*
* Default AMQP publisher callback.
*
* Il contesto della cloudlet callback
* Il tipo di valore scambiato
* Valore extra.
*
*
* La Cloudlet può inviare messaggi utilizzando il metodo publisher().
* Quando l'operazione termina, uno dei metodi publishSucceeded () o publishFailed () viene chiamato.
*/
public static final class AmqpPublisherCallback
extends DefaultAmqpPublisherConnectorCallback<XmlAnalyzerCloudletContext, String, Void>
{
@Override
public CallbackCompletion<Void> destroySucceeded (final XmlAnalyzerCloudletContext context, final CallbackArguments arguments)
{
this.logger.info ("XmlAnalyzerCloudlet publisher destroyed successfully.");
return ICallback.SUCCESS;
}
@Override
public CallbackCompletion<Void> initializeSucceeded (final XmlAnalyzerCloudletContext context, final CallbackArguments arguments)
{
this.logger.info ("XmlAnalyzerCloudlet publisher initialized successfully.");
return ICallback.SUCCESS;
}
public CallbackCompletion<Void> publishSucceeded (final XmlAnalyzerCloudletContext context, final GenericCallbackCompletionArguments<Void> arguments)
{
this.logger.info ("XmlAnalyzerCloudlet publisher push successfully");
this.logger.info("\nPublisher Valutazione OK\n");
//context.cloudlet.destroy ();
return ICallback.SUCCESS;
}
}
/* Definisce il ciclo di vita della cloudlet
* e vuole come parametro il tipo di contesto.
*/
public static final class LifeCycleHandler
extends DefaultCloudletCallback<XmlAnalyzerCloudletContext>
/*
* Tutti i metodi della classe Callback vogliono due parametri:
* 1) il contesto del Cloudlet e un oggetto che contiene i dati effettivi necessari per elaborare l'evento corrispondente al metodo di callback.
* 2) Il tipo del secondo argomento deve essere derivata dalla classe CallbackArguments.La classe CallbackArguments definisce il metodo getCloudlet (),
* che restituisce un oggetto controller Cloudlet che può essere utilizzato in seguito per la creazione e la distruzione di connettori di risorse cloud.
*/
{
@Override
public CallbackCompletion<Void> destroy (final XmlAnalyzerCloudletContext context, final CloudletCallbackArguments<XmlAnalyzerCloudletContext> arguments)
{
this.logger.info ("XmlAnalyzerCloudlet destroying...");
return CallbackCompletion.createAndChained (context.consumer.destroy (),context.publisher.destroy());
}
@Override
public CallbackCompletion<Void> destroySucceeded (final XmlAnalyzerCloudletContext context, final CloudletCallbackCompletionArguments<XmlAnalyzerCloudletContext> arguments)
{
this.logger.info ("XmlAnalyzerCloudlet destroyed successfully.");
return ICallback.SUCCESS;
}
@Override
public CallbackCompletion<Void> initialize (final XmlAnalyzerCloudletContext context, final CloudletCallbackArguments<XmlAnalyzerCloudletContext> arguments)
{
this.logger.info ("XmlAnalyzerCloudlet initializing...");
/*context.cloudlet = arguments.getCloudlet ();
* che restituisce un oggetto controller Cloudlet che può essere utilizzato per la creazione e la distruzione
* dei connector di risorse cloud;
*
*/
context.cloudlet = arguments.getCloudlet ();
/* final IConfiguration configuration = context.cloudlet.getConfiguration ();
*
* Interfaccia generica per la gestione del file di configurazione (descrittore Cloudlet)
*
*/
final IConfiguration configuration = context.cloudlet.getConfiguration ();
/*
* spliceConfiguration
*
* Restituisce una configurazione che contiene tutti i parametri
* i cui nomi iniziano con un determinato identificatore (identificatore di root).
*/
final IConfiguration queueConfiguration2 = configuration.spliceConfiguration (ConfigurationIdentifier.resolveAbsolute ("queue1.consumer"));
/* L'implementare dei connector richiede una classe di callback.
* Inoltre, si dovrebbe anche fornire un encoder (serializzatore e deserializzatore) per i dati.
* La ragione di questo è che i connettori e driver gestiscono i dati utilizzando i flussi di byte e lasciano
* il compito di interpretare questi flussi di byte.
*
*/
context.consumer = context.cloudlet.getConnectorFactory (IAmqpQueueConsumerConnectorFactory.class).create (queueConfiguration2, String.class, PlainTextDataEncoder.DEFAULT_INSTANCE, new AmqpConsumerCallback (), context);
final IConfiguration queueConfiguration = configuration.spliceConfiguration (ConfigurationIdentifier.resolveAbsolute ("queue2.publisher"));
context.publisher = context.cloudlet.getConnectorFactory (IAmqpQueuePublisherConnectorFactory.class).create (queueConfiguration, String.class, PlainTextDataEncoder.DEFAULT_INSTANCE, new AmqpPublisherCallback (), context);
return CallbackCompletion.createAndChained (context.consumer.initialize (),context.publisher.initialize ());
}
@Override
public CallbackCompletion<Void> initializeSucceeded (final XmlAnalyzerCloudletContext context, final CloudletCallbackCompletionArguments<XmlAnalyzerCloudletContext> arguments)
{
this.logger.info ("XmlAnalyzerCloudlet initialized successfully.");
return ICallback.SUCCESS;
}
}
/*Classe Context.
* Vienen definito lo stato della cloudlet, più precisamente il contesto della cloudlet, perchè
* le cloudlet sono di tipo stateless.Le API mOSAIC si aspettano l'oggetto che definisce il contesto della Cloudlet
* e tale oggetto contiene i riferimenti utilizzati per accedere alle risorse cloudlet.
*
*/
public static final class XmlAnalyzerCloudletContext
{
/*
* E' possibile accedere alle proprietà del descrittore Cloudlet nel codice sorgente della Cloudlet utilizzando il controller Cloudlet.
*/
/*
* Per ogni risorsa Cloud utilizzato dal Cloudlet, è necessario creare una connector di accesso che deve essere memorizzato nel
* context Cloudlet.
*/
ICloudletController<XmlAnalyzerCloudletContext> cloudlet;
IAmqpQueueConsumerConnector<String, Void> consumer;
IAmqpQueuePublisherConnector<String, Void> publisher;
String Count="0";
}
}