Аглеты: мобильные Java-агенты

В результате получилась архитектура аглетов, которая состоит из двух наборов интерфейсов и двух слоев реализации:

• набор интерфейсов аглета (aglet API);
• слой реализации методов аглета;
• передача агента по сети и интерфейс связи между аглетами;
• транспортный слой.

Слой реализации аглета - это Java-коды программ, вызываемых аглетом через aglet API. Он содержит основные методы для создания, перемещения аглетов и управления ими, а также определяет поведение аглета (класс Aglet) и его связь с виртуальной машиной Java (класс AgletContext). Кроме того, в нем имеются механизмы взаимодействия аглетов друг с другом.

Транспортный слой обеспечивает передачу агента по сети в виде последовательности байтов, которая включает в себя определение классов (тоже в последовательном виде). Этот слой также имеет свой набор интерфейсов, называемый методами передачи агента и интерфейсом связи (Agent Transfer and Communication Interface, ATCI). Именно он позволяет аглетам обращаться к транспортному слою для перемещения по сети независимо от используемых протоколов.

Реализация интерфейсов ATCI обеспечивает передачу и получение аглета, а также позволяет устанавливать связь между различными аглетами. Для передачи аглетов используется протокол передачи агента (Agent Transfer Protocol, ATP), который является протоколом прикладного уровня. Модель ATP основывается на протоколе HTTP и может быть использована для передачи агента независимо от его содержания и состояния, а также от операционных систем отправителя и получателя. Чтобы дать возможность аглетам связываться друг с другом, в ATP предусмотрен механизм передачи удаленных сообщений.

Когда аглет пытается послать себя на другой компьютер, он перемещается на слой реализации аглетов, который преобразует его в последовательность байтов. Эта последовательность содержит тело аглета и его текущее состояние. После прохождения слоя реализации аглет превращается в массив байтов и может быть передан через сеть по протоколу ATP. Для того чтобы воспользоваться этим протоколом, аглет должен пройти еще и через интерфейс ATCI. Протокол передачи агента, реализующий ATCI, добавляет свой заголовок, который содержит общую информацию об аглете - имя агента и его идентификатор. Заметим, что транспортный уровень - ATCI - можно заменить на стандартный интерфейс MAF, который в настоящее время разрабатывается OMG.

API-интерфейсы аглетов

Набор API-интерфейсов аглета (aglet API) определяет основные функциональные возможности для создания, исполнения и перемещения агентов. На рис. 1 показаны основные элементы технологии аглетов, которые входят в этот API. Рассмотрим их более подробно.

Класс aglet.Aglet

Это абстрактный класс Aglet, который определяет основные методы агентов (например, метод пересылки аглета - dispatch(URL)), управляющие перемещением и жизненными циклами аглетов. Все мобильные агенты должны расширять абстрактный класс aglet.Aglet. Скажем, метод Aglet.dispatch(URL) является примитивом, с помощью которого аглет может переместиться на другой компьютер, указанный в аргументе. Метод Aglet.deactivate(long time) позволяет приостанавливать работу аглета на определенное время, записывая его в хранилище, а Aglet.clone() - создавать новый экземпляр аглета, который наследует состояние аглета-родителя. Следует отметить, что объект, возвращаемый методом clone, - не аглет, а интерфейс к вновь созданному аглету.

Класс Aglet также используется для доступа к признакам аглета. Объект aglet.AgletInfo, который может быть получен с помощью метода Aglet.getAgletInfo(), содержит связанные с аглетом атрибуты, например время создания, а также динамические признаки - время последнего перемещения и адрес текущего компьютера.

Интерфейс aglet.AgletProxy

Интерфейс AgletProxy выполняет задачу управления аглетами и обеспечивает стандартный способ взаимодействия с аглетом. Класс aglet имеет несколько общедоступных (public) методов, к которым нельзя обращаться непосредственно с другого аглета из соображений безопасности. Поэтому любой аглет, который хочет связаться с другим агентом, должен сначала получить объект AgletProxy, и только затем устанавливать связь через этот интерфейс. Другими словами, объект AgletProxy выполняет роль защитного буфера между аглетами. Такой механизм взаимодействия необходим для защиты от опасных аглетов.

Чтобы определить, можно ли какому-либо аглету выполнять определенный метод аглета, AgletProxy связывается с менеджером безопасности - SecurityManager. Не менее важна роль интерфейса AgletProxy - обеспечить аглету независимость от местоположения. Реальный аглет, который находится на определенном компьютере, может послать запрос на другой компьютер и получить от него ответ. При этом аглет не должен знать, что он обращается к удаленному компьютеру. Именно AgletProxy скрывает от аглета местоположение его "собеседника".

Объект, реализующий AgletProxy, можно получить следующими способами:

Технология аглетов включает стандартную реализацию интерфейса AgletProxy, поэтому программисты не обязаны его реализовывать. Однако, если приложение использует более сложную систему безопасности или модель обмена сообщениями между аглетами, то его разработчикам придется создавать свою собственную реализацию этого интерфейса.

Интерфейс Aglet.AgletContext

Интерфейс AgletContext обеспечивает связь со средой, в которой выполняется аглет, то есть с виртуальной машиной Java. Любой аглет может получить ссылку на объект AgletContext с помощью метода Aglet.getAgletContext() и использовать ее для получения локальной информации, например адреса своего местонахождения или списка доступных AgletProxies. С помощью этого интерфейса можно создать новый аглет. В принципе, стандартная библиотека аглетов реализует этот интерфейс, поэтому разработчикам Java-программ реализовывать его не нужно. Поскольку AgletContext зависит от виртуальной Java-машины, то и реализовывать его должны создатели виртуальных машин или те, кто хочет изменить взаимоотношения между аглетами и Java-машиной (например, для усиления безопасности).

Класс Aglet.Message

Аглеты взаимодействуют между собой с помощью объектов класса Message. Эти объекты содержат строку String, которая определяет тип сообщения и перечисляет объекты-аргумент. Аглет может отправить сообщение с помощью методов Object AgletProxy.sendMessage(Message msg), FutureReply AgletProxy.sendAsyncMessage(Message msg) или void AgletProxy.sendOnewayMessage(Message msg). Кроме того, необходимо вызвать метод Aglet.handleMessage(Message msg), в котором в качестве аргумента указать это же сообщение.

Механизм сообщений служит для обмена информацией между аглетами. Причем с его помощью можно передавать сообщения не только локальным аглетам, но и удаленным. Для этого предусмотрен специальный интерфейс (aglet.FutureReply), который позволяет корректно обрабатывать ситуации временного разрыва связи с удаленным компьютером. Таким образом, механизм сообщений являются связующим звеном при создании распределенных приложений.

Интерфейс Aglet.FutureReply

Асинхронная отправка сообщений на удаленный компьютер возвращает в качестве результата объект, реализующий интерфейс FutureReply. Этот объект используется для разрешения особых ситуаций в случае разрыва связи с дальнейшим ее восстановлением. С помощью этого интерфейса аглет, отправивший сообщение, может попытаться еще раз установить связь с получателем. Теоретически этот интерфейс определяет действия аглета и ответ на возможное отсутствие связи с получателем сообщения.

Здесь перечислены только основные классы и интерфейсы, которые входят в модель аглетов. Простейший пример аглета приведен во врезке "Пример". Сейчас работа над технологией аглетов еще не завершена и, вероятно, набор классов будет со временем расширен.

Протокол передачи агентов (ATP)

ATP - это простой протокол прикладного уровня, предназначенный для передачи агентов независимым от системы и агента способом. Его запрос состоит из строки запроса, нескольких полей заголовка и собственно содержания. Строка запроса определяет метод запроса, для исполнения которого в полях заголовка передаются аргументы. В ATP определены четыре стандартных метода:

Поскольку подготовка спецификации протокола ATP еще не завершена, в окончательном варианте могут появиться дополнительные методы. Следует отметить, что параллельно с разработчиками ATP аналогичный протокол - MAF - разрабатывает группа OMG. Если MAF будет принят как стандарт, то разработчикам ATP придется пересмотреть спецификацию своего протокола.

Элементы приложений

Библиотека аглетов предоставляет разработчику набор интерфейсов для создания и настройки программного обеспечения, которое использует технологию аглетов. Располагая одним и тем же набором интерфейсов, программа может иметь свою собственную систему управления аглетами, использовать часть возможностей сервера или создавать и запускать аглеты без обращения к нему. Есть несколько элементов для построения программ, использующих аглеты. Сервер может управлять и распределять аглеты, а клиент - создавать новые и удаленно управлять через сервер работой старых. Поэтому аглеты могут работать как на сервере, так и на клиенте, причем в разных местах решать разные задачи.

Обычно для построения приложения с использованием аглетов не нужны никакие дополнительные интерфейсы. Приложение в этом случае состоит исключительно из набора аглетов, опирающихся на набор интерфейсов Aglet API. Такая конфигурация обычно содержит постоянного агента, который имеет доступ к локальным ресурсам, таким как базы данных или файловая система, и обеспечивает все необходимое для работы с приходящими аглетами.

Постоянный агент загружается либо с локального диска (из директории, указанной в переменной CLASSPATH), либо с удаленного сервера по URL. Если аглет загружается из директорий CLASSPATH, то на него не накладывается никаких ограничений безопасности. Такой аглет имеет самые высокие привилегии, то есть может делать все, что ему необходимо. Если аглет загружается по URL, то в зависимости от его идентификатора для него устанавливаются определенные полномочия, за соблюдением которых следит система безопасности.

В этой конфигурации пришедший аглет получает доступ к сервисам через обмен сообщениями с постоянным агентом. Причем внешний аглет может перейти на следующий сервер вместе с полученными результатами или послать их на домашний сервер с помощью механизма передачи удаленных сообщений. Передача сообщений также выполняется под присмотром службы безопасности, поэтому информация может и не дойти до получателя.

Сервер обеспечивает некоторому ограниченному набору внешних аглетов (наиболее надежных) доступ к локальным ресурсам или сервисам. В этом случае аглет может установить прямую связь с базой данных и делать прямые SQL-запросы. Таким образом, аглеты получают больше возможностей для использования ресурсов сервера, но, с другой стороны, это связано с определенным риском, если внешний аглет "вздумает" злоупотреблять своими полномочиями. В этом случае он выведет систему из строя.

Система управления

На сервере может работать система управления деятельностью аглетов, которая обрабатывает сообщения о происходящих событиях. На основе такой системы строятся сложные инструменты для администрирования работы сервера или простые и удобные в использовании приложения для конечных пользователей.

Например, хороший инструмент администрирования обеспечивает администратору возможность создать и поддерживать сервис аглетов, контролировать их передвижение и работу. Кроме того, система управления реализует сервисы для транзитной передачи аглета. Это может пригодиться, например, в шлюзовом сервере, который, получив аглет, должен передать его дальше, обработав соответствующим образом.

С другой стороны, систему управления можно настроить под нужды отдельных пользователей или сервисов. Например, рабочий стол пользователя может иметь иконку аглета, а для управления им будет достаточно перетащить в нее соответствующие операторы. Для новичка же можно использовать простой и привычный Web-интерфейс.

Сервер аглетов

Аглеты способны расширить функциональные возможности обычных приложений. Например, простое приложение для групповой работы может использовать аглеты для связи членов группы между собой. Однако для таких программ недостаточно возможностей простых аглетов, даже если разработчику удастся реализовать свою систему управления. Набор интерфейсов Aglets Server API позволяет разработчикам расширить возможности серверных аглетов и конфигурировать такие важные компоненты технологии аглетов, как менеджер безопасности, систему управления и другие.

Клиент

Клиентская программа не имеет тех возможностей, которые предусмотрены в серверной - в ее распоряжении есть только средства для удаленного создания, обслуживания и контроля аглетов или адресации им сообщений. Поэтому такое приложение требует меньше ресурсов для работы с аглетами, а это уменьшает потенциальную опасность, поскольку в этом случае невозможно загрузить любой аглет с внешнего компьютера и исполнить его.

Например, консоль системы управления сетью не обязана иметь всех возможностей сервера. Консольная программа, которая обычно выполняет роль клиента, может создать контролирующий аглет на одной машине и переслать его на все остальные для получения от них контрольной информации.

Технология аглетов позволяет разрабатывать распределенные приложения, элементы которых могут перемещаться с одного узла на другой, выполняя на каждом определенную часть работы или собирая информацию. Механизм передачи сообщений позволяет таким элементам обмениваться информацией между собой, синхронизируя свои действия. Таким образом, технология аглетов создает основу для разработки действительно распределенных систем.

Разработкой технологии аглетов занимается японское отделение компании IBM. На сегодняшний день доступна пятая альфа версия спецификации, и работа над ней продолжается.

Пример простейшего аглета

Когда аглет создается, он печатает "created!", когда запускается - печатает "hello!", когда получает сообщение sayHelloAgain - печатает "hello!" еще раз, когда передается на другой компьютер - печатает "bye!".

    public class HelloAglet extends Aglet {
        public void onCreation(Object init) {
            System.out.println("created!");
        }
        public void run() {
            System.out.println("hello!");
        }
        public boolean handleMessage(Message msg) {
            if (msg.sameKind("sayHelloAgain") {
                System.out.println("hello!");
                return true;
            }
            return false;
        }
        public void onDisposing() {
            System.out.println("bye!");
        }
    }

Архитектура аглетов

1. Аглет (класс COM.ibm.aglet.Aglet)

2. Интерфейс связи с другими аглетами (интерфейс COM.ibm.aglet.AgletProxy)

3. Сообщения, передаваемые между аглетами (класс COM.ibm.aglet.Message)

4. Интерфейс связи со средой (интерфейс COM.ibm.aglet.AgletContext)

5. Протокол связи с другими системами (ATP)