/** @param args [0] RabbitmqHost */
public static void main(String[] args) {
System.out.println(Constants.HEADER);
String RabbitmqHost = "localhost";
if (args.length > 0) RabbitmqHost = args[0];
ConnectionFactory factory = new ConnectionFactory();
factory.setHost(RabbitmqHost);
try {
Connection connection = factory.newConnection();
System.out.println("Connected: " + RabbitmqHost);
Channel channel = connection.createChannel();
channel.exchangeDeclare(Constants.exchange, "direct", false);
Stats stats = new Stats();
JSONWriter rabbitmqJson = new JSONWriter();
int msgCount = 0;
for (; ; ) {
stats.Update();
String statMsg = rabbitmqJson.write(stats);
System.out.println(stats.toString());
channel.basicPublish(Constants.exchange, Constants.routingKey, null, statMsg.getBytes());
++msgCount;
if (System.in.available() > 0) break;
Thread.sleep(1000);
}
channel.close();
System.out.println("Done: " + msgCount + " messages sent");
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public void run() {
System.out.println(" [x] Awaiting RPC requests");
while (run.get()) {
QueueingConsumer.Delivery delivery;
try {
delivery = consumer.nextDelivery(2000);
} catch (ShutdownSignalException e2) {
break;
} catch (ConsumerCancelledException e2) {
break;
} catch (InterruptedException e2) {
continue;
}
BasicProperties props = delivery.getProperties();
BasicProperties replyProps =
new BasicProperties.Builder().correlationId(props.getCorrelationId()).build();
try {
Object o;
synchronized (registry) {
o = Rmivm.deserialise(delivery.getBody(), registry);
}
byte[] outBytes = Rmivm.serialize(o);
synchronized (channel) {
channel.basicPublish("", props.getReplyTo(), replyProps, outBytes);
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
} catch (Exception e) {
try {
synchronized (channel) {
channel.basicPublish(
"", props.getReplyTo(), replyProps, Rmivm.serialize(new Exception("Boom!")));
}
} catch (IOException e1) {
// panic
}
}
}
System.out.println(" [x] Shutting Down");
}
public void sendMessage(String... varStrings) {
String msg = varStrings[0];
String exchangeName = varStrings[1];
String qName = varStrings[2];
String rabbitIp = varStrings[3];
logger.debug("RabbitMQ Properties Start...");
logger.debug("Message - " + msg);
logger.debug("Exchange Name - " + exchangeName);
logger.debug("QueueName - " + qName);
logger.debug("IP Address - " + rabbitIp);
logger.debug("RabbitMQ Properties End...");
try {
CachingConnectionFactory factory = new CachingConnectionFactory();
factory.setAddresses(rabbitIp);
org.springframework.amqp.rabbit.connection.Connection connection = factory.createConnection();
Channel channel = connection.createChannel(false);
channel.basicPublish(exchangeName, qName, null, msg.getBytes());
channel.close();
connection.close();
logger.debug("Message Sent...");
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] argv) {
Connection connection = null;
Channel channel = null;
try {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
connection = factory.newConnection();
channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "topic");
String routingKey = getRouting(argv);
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
} catch (Exception e) {
e.printStackTrace();
} finally {
if (connection != null) {
try {
connection.close();
} catch (Exception ignore) {
}
}
}
}
public static void main(String[] argv) throws java.io.IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
System.out.println(
"Type message to send to logs.\n"
+ "Format ${severity}:${message}\n"
+ " or ${message} (uses default severity 'error')\n"
+ "Type an empty message to exit this process.");
try {
while (true) {
Message message = getMessage();
if (message == null) {
break;
}
channel.basicPublish(EXCHANGE_NAME, message.severity, null, message.msg.getBytes());
System.out.println(" [x] Sent '" + message + "'");
}
} finally {
channel.close();
connection.close();
}
}
/** Test that an AMQP client can connect to and use the broker. */
@Test(groups = {"Integration", "WIP"})
public void testClientConnection() throws Exception {
rabbit = app.createAndManageChild(EntitySpec.create(RabbitBroker.class));
rabbit.start(ImmutableList.of(testLocation));
EntityTestUtils.assertAttributeEqualsEventually(rabbit, Startable.SERVICE_UP, true);
byte[] content = "MessageBody".getBytes(Charsets.UTF_8);
String queue = "queueName";
Channel producer = null;
Channel consumer = null;
try {
producer = getAmqpChannel(rabbit);
consumer = getAmqpChannel(rabbit);
producer.queueDeclare(queue, true, false, false, ImmutableMap.<String, Object>of());
producer.queueBind(queue, AmqpExchange.DIRECT, queue);
producer.basicPublish(AmqpExchange.DIRECT, queue, null, content);
QueueingConsumer queueConsumer = new QueueingConsumer(consumer);
consumer.basicConsume(queue, true, queueConsumer);
QueueingConsumer.Delivery delivery =
queueConsumer.nextDelivery(60 * 1000l); // one minute timeout
assertEquals(delivery.getBody(), content);
} finally {
closeSafely(producer, 10 * 1000);
closeSafely(consumer, 10 * 1000);
}
}
public static void main(String[] argv) throws IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("datdb.cphbusiness.dk");
factory.setUsername("student");
factory.setPassword("cph");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
String queueName = "Kender du hende der Arne";
channel.queueDeclare(queueName, false, false, false, null);
channel.queueBind(queueName, EXCHANGE_NAME, "");
String messageOut =
"{\"ssn\":1605789787,\"creditScore\":699,\"loanAmount\":10.0,\"loanDuration\":360}";
BasicProperties.Builder props = new BasicProperties().builder();
props.replyTo("");
BasicProperties bp = props.build();
channel.basicPublish(EXCHANGE_NAME, "", bp, messageOut.getBytes());
System.out.println(" [x] Sent by JSONtester: '" + messageOut + "'");
channel.close();
connection.close();
}
public boolean notice() {
try {
String searchServices = VrsMqConfig.VRS_MQ_SEARCH_SERVICE;
for (String service : searchServices.split(",")) {
String exchange = "";
String routingKey = VrsMqConfig.VRS_MQ_ROUTINGKEY + "_search_" + service;
cfconn.setUri(VrsMqConfig.VRS_MQ_HOSTNAME);
cfconn.setPort(VrsMqConfig.VRS_MQ_PORT);
cfconn.setUsername(VrsMqConfig.VRS_MQ_USERNAME);
cfconn.setPassword(VrsMqConfig.VRS_MQ_PASSWORD);
Connection conn = cfconn.newConnection();
Channel ch = conn.createChannel();
if (exchange.equals("")) {
ch.queueDeclare(routingKey, false, false, false, null);
}
String message = "sync";
logger.info("=========notice=========:" + message);
ch.basicPublish(exchange, routingKey, null, message.getBytes());
ch.close();
conn.close();
}
return true;
} catch (Exception e) {
System.err.println("Main thread caught exception: " + e);
e.printStackTrace();
return false;
}
}
// bug 26552
public void testServerNamedTransientAutoDeleteQueueAndBindingRecovery()
throws IOException, InterruptedException, TimeoutException {
String x = "tmp-fanout";
Channel ch = connection.createChannel();
ch.exchangeDelete(x);
ch.exchangeDeclare(x, "fanout");
String q = ch.queueDeclare("", false, false, true, null).getQueue();
final AtomicReference<String> nameBefore = new AtomicReference<String>(q);
final AtomicReference<String> nameAfter = new AtomicReference<String>();
final CountDownLatch listenerLatch = new CountDownLatch(1);
((AutorecoveringConnection) connection)
.addQueueRecoveryListener(
new QueueRecoveryListener() {
@Override
public void queueRecovered(String oldName, String newName) {
nameBefore.set(oldName);
nameAfter.set(newName);
listenerLatch.countDown();
}
});
ch.queueBind(nameBefore.get(), x, "");
restartPrimaryAndWaitForRecovery();
expectChannelRecovery(ch);
ch.confirmSelect();
ch.exchangeDeclare(x, "fanout");
ch.basicPublish(x, "", null, "msg".getBytes());
waitForConfirms(ch);
AMQP.Queue.DeclareOk ok = ch.queueDeclarePassive(nameAfter.get());
assertEquals(1, ok.getMessageCount());
ch.queueDelete(nameAfter.get());
ch.exchangeDelete(x);
}
@Test
public void testBasicConnectivity() {
String sentMsg = "sent";
String recvdMsg = "received";
try {
channel.queueDeclare(basicTestQueue, false, false, false, null);
sentMsg = "testBasicConnectivity";
channel.basicPublish("", basicTestQueue, null, sentMsg.getBytes());
QueueingConsumer consumer = new QueueingConsumer(channel);
channel.basicConsume(basicTestQueue, true, consumer);
QueueingConsumer.Delivery delivery = consumer.nextDelivery(1500);
if (delivery != null) {
recvdMsg = new String(delivery.getBody());
}
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
} finally {
try {
channel.close();
connection.close();
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
}
}
assertEquals(sentMsg, recvdMsg);
}
@Override
public Future<Message> sendMessageAsync(final Message message) {
return EXECUTOR_SERVICE.submit(
() -> {
String messageInvalid = messageValidator.validate(message);
if (messageInvalid != null) {
logger.info("### Couldn't forward Message .. -> {" + messageInvalid + "}");
return null;
} else {
try {
Channel rabbitMqChannel = USER_CHANNEL.get(message.getToUser());
Map<String, Object> headers = new HashMap<>();
headers.put(ARGUMENT_TO_ID, message.getToUser().getId());
AMQP.BasicProperties basicProperties =
new AMQP.BasicProperties.Builder().headers(headers).build();
rabbitMqChannel.basicPublish(
amqpExchange, "", basicProperties, gson.toJson(message).getBytes("UTF-8"));
return message;
} catch (Exception ex) {
logger.info("### Couldn't forward Message .. -> {" + ex.getMessage() + "}");
return null;
}
}
});
}
public static void main(String[] argv) throws java.io.IOException, TimeoutException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
/*
* The durability options let the tasks survive even if RabbitMQ is
* restarted
*/
boolean durable = true;
channel.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);
String message = getMessage(argv);
/*
* publish 設成 persistent 的用處是為了防止RabbitMQ server gg 時忘記message 的內容
*/
channel.basicPublish(
"", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
channel.close();
connection.close();
}
@Test
public void testStreamingEvent() {
// Instantiate the resource
ResourceImpl resourceImpl = new ResourceImpl(restItem);
try {
channel.queueDeclare(intTestQueue, false, false, false, null);
} catch (Exception ex) {
fail("Connectivity error to MQ while running Test" + ex);
try {
channel.close();
connection.close();
} catch (Exception otherEx) {
// We couldn't close a connection that's already closed or
// hasn't been open...
}
}
// Here we build the queue ResourceImpl is going to connect to and we
// will later publish to
try {
resourceImpl.startStreaming(createListeners());
} catch (Exception ex) {
fail("Error while starting streaming service: " + ex);
}
// Have a rest to let all the services start up properly
try {
Thread.sleep(5000);
channel.basicPublish("", intTestQueue, null, mqMessage.getBytes());
} catch (Exception ex) {
fail("Cannot publish to MQ on test environment" + ex);
}
// A little rest to let the publication go through
try {
Thread.sleep(2000);
} catch (Exception ex) {
}
// 1st test: did we get a callback on ConnectedEvent (Connected to MQ) ?
assertTrue(connectedEventCalled);
// 2nd test: The stream received event was triggered
assertTrue(streamEventCalled);
// 3rd test: And the message received was the same as posted on the
// Queue
assertEquals(mqMessage, recvdFromMq);
resourceImpl.mqDisconnectEvent();
// Have a rest to let all the services shut down up properly
try {
Thread.sleep(2000);
channel.queuePurge(intTestQueue);
} catch (Exception ex) {
// Bit of housekeeping
}
}
@Override
public void enmq(String exchange, Channel ch, MQPacket re) throws IOException {
byte[] data = re.data;
if (LOG.isDebugEnabled()) {
LOG.debug("send data to mq, length:" + data.length);
}
ch.basicPublish(exchange, "anomoy", MessageProperties.PERSISTENT_BASIC, data);
}
private void expectExchangeRecovery(Channel ch, String x)
throws IOException, InterruptedException, TimeoutException {
ch.confirmSelect();
String q = ch.queueDeclare().getQueue();
final String rk = "routing-key";
ch.queueBind(q, x, rk);
ch.basicPublish(x, rk, null, "msg".getBytes());
waitForConfirms(ch);
ch.exchangeDeclarePassive(x);
}
@Override
public void process(JCas jCas) throws AnalysisEngineProcessException {
try {
sendChannel.basicPublish("", queue, PERSISTENT_BASIC, serialize(jCas.getCas()));
// LOG.debug(" [RabbitWriter] '" + snippetize(jCas.getDocumentText(), 20)
// + "'");
} catch (IOException e) {
throw new AnalysisEngineProcessException(e);
}
}
private void expectQueueRecovery(Channel ch, String q)
throws IOException, InterruptedException, TimeoutException {
ch.confirmSelect();
ch.queuePurge(q);
AMQP.Queue.DeclareOk ok1 = declareClientNamedQueue(ch, q);
assertEquals(0, ok1.getMessageCount());
ch.basicPublish("", q, null, "msg".getBytes());
waitForConfirms(ch);
AMQP.Queue.DeclareOk ok2 = declareClientNamedQueue(ch, q);
assertEquals(1, ok2.getMessageCount());
}
@Override
protected void pushMessages(Channel ch) throws IOException {
String message =
"{ \"index\" : { \"_index\" : \"test\", \"_type\" : \"type1\", \"_id\" : \"1\" } }\n"
+ "{ \"type1\" : { \"field1\" : \"value1\" } }\n"
+ "{ \"delete\" : { \"_index\" : \"test\", \"_type\" : \"type1\", \"_id\" : \"2\" } }\n"
+ "{ \"create\" : { \"_index\" : \"test\", \"_type\" : \"type1\", \"_id\" : \"1\" }\n"
+ "{ \"type1\" : { \"field1\" : \"value1\" } }";
ch.basicPublish("elasticsearch", "elasticsearch", null, message.getBytes());
}
/**
*
* <!-- begin-custom-doc -->
* <!-- end-custom-doc -->
*
* @generated The implementation of this method defines the execution behavior of the synchronous
* activity. This method is called by the BusinessWorks Engine on a engine thread to perform
* the activity essential functions.
* @param input This is the activity input data. It is an XML Element which adheres to the input
* schema of the activity or <code>null</code> if the activity does not require an input. The
* activity input data should be processed using the XML processing context obtained from the
* method {@link ProcessContext#getXMLProcessingContext()}.
* @param processContext Context that is associated with a BusinessWorks Process instance. This
* context is unique per BusinessWorks Process instance and it is not visible to other
* BusinessWorks Process instances. Also this context is valid only within the BusinessWorks
* Engine thread on which this method is invoked. Therefore this context must not be saved or
* used by a different thread that is created or managed by the activity implementation.
* @return An XML Element which adheres to the output schema of the activity or may return <code>
* null</code> if the activity does not require an output. This is the activity output data
* and it should be created using the XML processing context obtained from the method {@link
* ProcessContext#getXMLProcessingContext()}.
* @throws ActivityFault Thrown if the activity execution is unsuccessful or encounters an error.
*/
@Override
public N execute(N input, ProcessContext<N> processContext) throws ActivityFault {
if (getActivityLogger().isDebugEnabled()) {
activityLogger.debug(
RuntimeMessageBundle.DEBUG_PLUGIN_ACTIVITY_METHOD_CALLED,
new Object[] {
"execute()",
activityContext.getActivityName(),
activityContext.getProcessName(),
activityContext.getDeploymentUnitName(),
activityContext.getDeploymentUnitVersion()
});
String serializedInputNode =
XMLUtils.serializeNode(input, processContext.getXMLProcessingContext());
activityLogger.debug(
RuntimeMessageBundle.DEBUG_PLUGIN_ACTIVITY_INPUT,
new Object[] {activityContext.getActivityName(), serializedInputNode});
}
N result = null;
try {
// begin-custom-code
String queue =
getInputParameterStringValueByName(
input, processContext.getXMLProcessingContext(), "queue");
String message =
getInputParameterStringValueByName(
input, processContext.getXMLProcessingContext(), "message");
channel.basicPublish("", queue, null, message.getBytes());
// end-custom-code
// create output data according the output structure
result = evalOutput(input, processContext.getXMLProcessingContext(), null);
} catch (Exception e) {
throw new ActivityFault(
activityContext,
new LocalizedMessage(
RuntimeMessageBundle.ERROR_OCCURED_RETRIEVE_RESULT,
new Object[] {activityContext.getActivityName()}));
}
if (getActivityLogger().isDebugEnabled()) {
String serializedOutputNode =
XMLUtils.serializeNode(result, processContext.getXMLProcessingContext());
activityLogger.debug(
RuntimeMessageBundle.DEBUG_PLUGIN_ACTIVITY_OUTPUT,
new Object[] {
activityContext.getActivityName(),
serializedOutputNode,
activityContext.getActivityName()
});
}
return result;
}
public static void main(String args[]) throws IOException {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("QUEUE_NAME", false, false, false, null);
String message = "Hello World!";
channel.basicPublish("", "QUEUE_NAME", null, message.getBytes());
System.out.println("[x] sent'" + message + "'");
channel.close();
connection.close();
}
public void publish(String msg) {
try {
mqConnection.connect();
Channel chan = mqConnection.conn.createChannel();
try {
Builder bob = new BasicProperties.Builder();
chan.basicPublish("amq.fanout", "chat", bob.build(), msg.getBytes("UTF-8"));
} finally {
chan.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("localhost");
Connection connection = connectionFactory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
String message = "Hello, World!";
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.printf("Sent: %s\n", message);
channel.close();
connection.close();
}
public void alert(String key, String json) {
String routingKey;
if (key == null) routingKey = getAlertRoutingKey();
else routingKey = getAlertRoutingKey() + key;
try {
byte[] messageBodyBytes = json.getBytes();
channel.basicPublish(
getAlertExchangeName(), routingKey, MessageProperties.TEXT_PLAIN, messageBodyBytes);
} catch (Exception e) {
e.printStackTrace();
try {
connect();
} catch (Exception ignored) {
}
}
}
@Override
protected void runJob(BackupJob job) {
try {
conn.beginOrJoin();
// we need a JPA-managed instance
BackupJob job2 = dal.createBackupJobDao().findById(job.getId());
log.info("Sending job to processing queue: " + job2.getId());
String json = JsonSerializer.serialize(job2);
mqChannel.basicPublish("", mqName, null, json.getBytes());
} catch (IOException e) {
// Should only happen if message queue is down
log.fatal(e.getMessage() + " - message queue down?");
throw new RuntimeException(e);
} finally {
conn.rollback();
}
}
public void serveRequests() {
while (true) {
try {
Delivery delivery = consumer.nextDelivery();
BasicProperties props = delivery.getProperties();
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
System.out.println("Received API call...replying...");
channel.basicPublish("", props.getReplyTo(), null, getResponse(delivery).getBytes("UTF-8"));
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
@Override
public boolean sendStringOnChannel(String string, String exchangeName) {
try {
Channel channel = subscribedChannels.get(exchangeName);
if (channel != null) {
channel.basicPublish(exchangeName, "", null, string.getBytes());
}
Log.i(LOGTAG, "send to: " + exchangeName);
return true;
} catch (AlreadyClosedException exception) {
Log.e(LOGTAG, exchangeName + " : " + exception.toString());
subscribedChannels.remove(exchangeName);
} catch (IOException e) {
Log.e(LOGTAG, "sendStringOnChannel: " + e.toString());
}
return false;
}
/**
* Helper method to inject x messages containing y index requests
*
* @param ch RabbitMQ channel
* @param nbMessages number of messages to inject (x)
* @param nbDocs number of docs per message to inject (y)
* @throws IOException
*/
protected static void pushMessages(Channel ch, int nbMessages, int nbDocs) throws IOException {
for (int i = 0; i < nbMessages; i++) {
StringBuffer message = new StringBuffer();
for (int j = 0; j < nbDocs; j++) {
message.append(
"{ \"index\" : { \"_index\" : \""
+ INDEX
+ "\", \"_type\" : \"typex\", \"_id\" : \""
+ i
+ "_"
+ j
+ "\" } }\n");
message.append("{ \"typex\" : { \"field\" : \"" + i + "_" + j + "\" } }\n");
}
ch.basicPublish("elasticsearch", "elasticsearch", null, message.toString().getBytes());
}
}
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String severity = getSeverity(argv);
String message = getMessage(argv);
channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
channel.close();
connection.close();
}
public static void sender(String[] args) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
// true 表示将消息持久化
channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
String message = getMessage(args);
// 持久化时，同时需要设置这里的messageProperties
channel.basicPublish(
"", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
channel.close();
connection.close();
}
public static void t3() throws Exception {
Channel channel = generateChannel();
channel.exchangeDeclare(TestAmqp.PingExchangerName, "direct", true, false, null);
channel.queueDeclare("rpc", false, false, false, null);
// channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName,
// TestAmqp.RouteingName);
// channel.queueBind(TestAmqp.TopicQueueName, TestAmqp.TopicExchangerName, "*");
channel.queueBind("rpc", TestAmqp.PingExchangerName, "ping");
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
channel.basicConsume("rpc", false, queueingConsumer);
while (true) {
QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
System.out.println("log: " + new String(delivery.getBody()));
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
System.out.println("reply to :" + delivery.getProperties().getReplyTo());
channel.basicPublish("", delivery.getProperties().getReplyTo(), null, "asfasdfas".getBytes());
}
}
