Статьи

Модульная система GlassFish: как расширить CLI GlassFish и консоль веб-администрирования (часть I, Архитектура)

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

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

С точки зрения функциональности GlassFish предоставляет точки расширения для дальнейшего расширения : консоль администрирования, CLI, контейнеры и возможности мониторинга сервера приложений GlassFish ненавязчивым и модульным способом.

С развития точки зрения, GlassFish использует OSGI для модуля жизненного цикла управления в то время как он использует HK2 для уровня обслуживания функциональных возможностей, таких как инъекции зависимостей, службы экземпляров управления, служебной нагрузки и последовательности разгрузки, и так далее.

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

 

GlassFish Модульность

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

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

Модульная система GlassFish использует комбинацию двух модульных систем, включая хорошо известные OSGI и HK2, в качестве ранней реализации модульной системы Java ( JSR-277 ) . OSGI обеспечивает функциональность модулей и уровней жизненного цикла модулей, чтобы позволить серверу приложений вписаться в более широкое развертывание, использующее каркас OSGI . Это также дает возможность воспользоваться хорошо разработанными и протестированными методами модульности OSGI и управления жизненным циклом, которые включены в OSGI. НК2 обеспечивает функциональные возможности службы слоя и гарантирует более плавный переход к Java SE 7 модульной системы (JSR-277) .  Проще говоря, HK2 — это среда, которую мы используем для разработки классов Java, которые есть в нашем модуле, и для выполнения основных задач.

 

Мы говорили о модулях GlassFish, но эти модули нуждаются в другом объекте, чтобы загружать, выгружать и передавать их с их предполагаемыми обязанностями, которые модуль должен принять. Лицо , которое берет на себя л oading и выгрузки модулей GlassFish ядро , которое само по себе является OSGI расслоение , которое реализуется Kernel сек ervices. 

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

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

Модульная система GlassFish применяется не только к специфическим возможностям сервера приложений, таким как расширение консоли администрирования, но также применяется к реализации спецификаций Java EE . GlassFish использует разные модули OSGI для разных спецификаций Java EE, таких как Servlet 3 и JSF 2. Эти спецификации объединены с использованием OSGI, чтобы упростить обновление системы при появлении новой версии каждой спецификации.

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

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

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

Представляем OSGI 

OSGI — это обширная структура, представленная для добавления возможностей модульности в Java перед поставкой Java SE 7. По сути, OSGI представляет собой совокупность нескольких уровней функциональности, которые строятся друг на друге, чтобы освободить разработчиков Java от головной боли при преодолении сложности загрузчика классов, возможности динамического подключения, управления версиями библиотек, видимости кода, управления зависимостями; и модель публикации, поиска и привязки для разделения пакетов. Расслоение OSGI дает нам нечто похожее на рисунок 1.

Рисунок 1 OSGi слои , GlassFish использует все , кроме слоя обслуживания. Приложение на основе OSGI может использовать все или некоторые уровни в дополнение к платформе OS и Java, на которой работает OSGI.

OSGI работает на портативных устройствах с поддержкой профиля CDC и Java SE. Так что от OSGI могут выиграть различные операционные системы и устройства . Над этой минимальной платформе OSGi слои маршируют друг над другом и на основе принципов слоя эд архитектуры каждый слой может видеть только ее нижний слой , а не его верхний слой.

Bundle или модуль слой ближе к платформе Java SE, OSGi расслоения Jar файлы , которые еще некоторые мета информационных данных, эти метаданные обычно определяют модули , необходимые и предоставляемых интерфейсы, но это делает эту задачу очень эффективно. OSGi расслоения обеспечивают 7 дезертирства , чтобы помочь с зависимостями, управление версиями. Эти определения включают в себя:

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

  • Фрагменты пакета : позволяет расширять содержимое пакета , пакеты могут объединяться в один пакет и предоставлять унифицированные атрибуты экспорта и импорта .

  • Зависимости пакетов : позволяет при необходимости тесно связывать пакеты. Импортировать все, что экспортирует другой пакет. Позволяет реэкспортировать и разбивать пакеты.

  • Явные код границ и зависимости : Связки могут явно их внутренние пакеты или зависимости объявляют на внешних пакетах .
  • Произвольные атрибуты экспорта / импорта для большего контроля : экспортеры могут прикреплять произвольные атрибуты к своим экспортам; импортеры могут сопоставлять эти произвольные атрибуты, когда они находят требуемый пакет и перед импортом .
  • Сложная модель согласованности пространства классов
  • Фильтрация пакетов для детальной видимости классов : Экспортеры могут объявить, что определенные классы включены / исключены из экспортируемого пакета .

Все эти определения включены в файл MANIFEST.MF, который легко читать и создавать текстовый файл, расположенный в каталоге META-INF файлов jar. В листинге 4 приведен пример файла MANIFEST.MF.

Пример файла MANIFIST.MF в листинге 4, в котором показаны некоторые определения модулей OSGI

Bundle-ManifestVersion: 2                                       #1
Bundle-SymbolicName: gfbook.samples.chapter12 #2
Bundle-Version: 1.1.0 #2
Bundle-Activator: gfbook.samples.chapterActivator #3
Bundle-ClassPath: .,gfbook/lib/juice.jar #4
Bundle-NativeCode: #5
serialport.so; osname=Linux; processor=x86, #5
serialport.dll; osname=Windows 98; processor=x86 #5
Import-Package: gfbook.samples.chapter7; version="[1.0.0,1.1.0)"; #6
resolution:="optional" #6
Export-Package: #7
gfbook.samples.chapterservices.monitoring; version=1.1; #7
vendor="gfbook.samples:"; exclude:="*Impl", #7
gfbook.samples.chapterservices.logging; version=1.1; #8
uses:="samples.chapter7.services" #8

 

GlassFish использует OSGI Revision 4, и номер версии в # 1 указывает на это. На # 2 мы однозначно идентифицируем этот комплект с именем и его версией вместе. На # 3 мы определяем в классе каких орудия BundleActivator интерфейса для того , чтобы позволить сверток получить уведомление , когда он останавливается или начинается. Это позволяет разработчикам выполнить инициализацию и выполнить некоторые проверки при запуске пакета или выполнить некоторую очистку после его остановки. В # 4 мы определяем наш пучок внутреннего пути к классу, расслоение имеет JAR — файлы внутри него и погрузчик расслоения класса проверить этокласс путь , когда он ищет классы , что он требует в том же порядке , указанном в Bundle- пути к классам заголовка . На # 5 мы определяем собственные зависимости пакета для каждой операционной системы.

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

На # 7 мы описываем экспортированные пакеты вместе с версией и исключенными классами с использованием подстановочных знаков. На # 8 мы определяем, что если какой-либо пакет импортирует gfbook.samples.chapterservices.logging из нашего пакета, а пакет импортера нуждается в samples.chapter7.services, то он должен использовать тот же пакет для удовлетворения этого импорта, который использует наш пакет.

Уровень N ext в модульной системе OSGI — это уровень жизненного цикла, который позволяет устанавливать пакеты, проверять зависимости, запускать, активировать, останавливать и удалять динамически. Он опирается на уровень модуля для задач, связанных с путем к классу, таких как поиск классов и загрузка классов. Этот слой добавляет некоторые API для управления модулями во время выполнения. Рисунок 2 показывает функциональные возможности этого слоя.

Рисунок 2 Состояния уровня жизненного цикла OSGI . Модуль должен быть остановлен и не зависит от удаления.

  • Установлено: пакет был установлен, но все зависимости пакета не были удовлетворены, например, один из импортированных пакетов не экспортирован ни одним из разрешенных в настоящее время пакетов .
  • Решено : B undle установлен и все его зависимости выполнены, это транзитное состояние, и пакеты не остаются в этом состоянии.
  • Начиная : руга временного состояния , которое пучок проходит , когда он будет активирован
  • Active : B undle активен и работает
  • Остановка: А временное состояние , которое пучок проходит через , когда он собирается быть остановлен .
  • Uninstalled: Bundle больше не находится в рамках.

Следующим уровнем в режиме OSGI является модель Service, уровень, который не используется eclipse, предоставляет несколько функциональных возможностей для развернутых пакетов. Во-первых, он предоставляет некоторые общие службы, которые являются общими для всех приложений, такие как журналирование и безопасность. Во-вторых, он предоставляет набор API, которые разработчики пакетов могут использовать для разработки дружественных OSGI сервисов и публиковать их в реестре сервисов инфраструктуры OSGI, искать сервисы, которые нужны их пакетам, в реестре и связываться с нужными им сервисами. Этот слой не используется GlassFish .

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

 Представляем HK2

Мы сказали, что GlassFish использует HK2 для функциональности уровня обслуживания. Первый вопрос, который вы можете задать, это то, что модель сервиса OSGI не использовалась для GlassFish; Ответ заключается в том, что HK2 более согласован с модульной системой Java (JSR-277), которая станет частью Java Runtime в Java SE 7, и в конечном итоге замена HK2 на модульную систему Java SE будет проще, чем замена уровня модели сервиса OSGI на Уровень модели сервиса Java SE.

Что такое HK2

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

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

Служба HK2 должна придерживаться к контракту и я т средства ничего , кроме расширения интерфейса , который HK2 ядро знает его структуру и знает , как использовать его. Но только интерфейсы не могут предоставить всю информацию, которая может потребоваться модулю для идентификации себя в ядре. Таким образом, HK2 предоставляет набор аннотаций, которые позволяют разработчикам предоставлять некоторые данные META вместе с компонентом, чтобы ядро ​​могло разместить его в нужном месте.

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

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

Перво-наперво

Нужно ли нам обсуждать исходный код аннотации контракта и сервиса? После того, как мы разработали сервис, реализовав контракт, который является интерфейсом, мы должны иметь возможность сообщить HK2, что наша реализация — это сервис, у него есть имя и у него есть сфера. Для этого мы используем аннотацию @Service , в листинге 1 приведен пример использования аннотации @Service .

Перечисление 1 HK2 @Service аннотация

@Service (name="restart-domain",                                  #1
scope=org.jvnet.hk2.component.PerLookup.class,
factory=gfbook.chapterCommandFactory)
public class RestartDomain implements AdminCommand { #2
...
}

 

Очень просто, просто аннотированный POJO предоставляет системе всю необходимую информацию, чтобы принять ее в качестве команды CLI. На # 1 мы определяем имя сервиса, который мы хотим разработать, позже мы определяем область действия компонента. На # 2 реализуют интерфейс контракта , чтобы сделать возможным для ядра использовать наш сервис таким образом , что он знает . Область действия может быть одной из встроенных областей или любой настраиваемой областью, реализуя контракт org.jvnet.hk2.component.Scope . Пользовательские области должны заботиться о жизненном цикле объектов. Встроенные области видимости:

 

  • Для каждой области поиска. Компоненты в этой области будут создавать новые экземпляры каждый раз, когда кто-то просит об этом, класс реализации: org.jvnet.hk2.component .
  • Одноэлементная область: объекты в этой области остаются живыми до конца сеанса, и любой последующий вызов для создания экземпляров таких объектов заканчивает возвратом доступного объекта. Класс реализации s : org.jvne t.hk2.component.Singleton .

@Service аннотацию принимает несколько дополнительных элементов , как следовать, эти элементы просто ради лучшего и более читаемого, обслуживаемого и настраиваемого кода , в противном случае они не являются обязательными и HK2 определить значения по умолчанию для каждого элемента.

  • П AME элемент определяет на имя службы. Значением по умолчанию является пустая строка.
  • Элемент s cope определяет область, к которой привязана эта реализация сервиса. Значением по умолчанию является org.jvnet.hk2.component.PerLookup.class .

  • Завод элемент определяет класс фабрики для обслуживания осуществления , если служба создается с помощью класса фабрики , а не вызов конструктора по умолчанию. Если этот элемент указан, компонент фабрики активируется, и вместо конструктора по умолчанию используется Factory.getObject .

Что если нашему сервису требуется доступ к другому сервису или другому объекту? Как мы решим, следует ли нам инициировать новый объект и использовать его или использовать доступный в настоящее время объект? Должны ли мы, как разработчики сервисов, действительно заниматься сложной задачей инициализации сервиса или объекта?

 

Взгляд сначала давайте в конкретизации , HK2 является реализация шаблона МОК и так, нет объекта конкретизации нужно будет идти , хотя называя новый () метод , и вместо этого вы будете просить МОК вернуть экземпляр вашего необходимого компонента. В HK2 класс ComponentManager отвечает за предоставление реестра для созданных экземпляров компонентов , а также несет ответственность за инициализацию компонентов, которые не инициализируются по запросу клиента . Клиенты просят ComponentManager для компонента, вызывая getComponent ( контракт ClassT ), И диспетчер ComponentManager гарантирует, что он либо вернет правильный экземпляр на основе доступного экземпляра и их областей действия, либо создаст новый экземпляр , пройдя весь граф объектов, необходимый для инициализации компонента. В ComponentManager метода нарезание резьбы безопасна и не поддерживает информации о сеансе связи между последовательными вызовами.

Разработчики компонентов должны иметь некоторый контроль, чтобы гарантировать, что все необходимые ресурсы и конфигурация готовы после создания и перед любой другой операцией; также им может потребоваться выполнить уборку и уборку перед тем, как уничтожить объект. Таким образом, предоставляются два интерфейса, которые компоненты могут реализовать для регистрации для уведомления о строительстве и разрушении объекта . Там два интерфейса org.jvnet.hk2.component . PostConstruct и org.jvnet.hk2.component.PreDestroy , каждый интерфейс имеет только один метод с именем postConstruct и preDestroy . ComponentManager также отвечает за внедрение ресурсов в свойства компонентов во время строительства, а также за извлечение ресурсов из компонентов.

Во- первых , давайте посмотрим добычу ресурсов , которые могут быть незнакомы , некоторые компонентные s может создать внутренний объект , который несут в себе некую информацию , необходимую для некоторых других компонентов в системе или аналогичных компонентов , которые собираются построить. Эти внутренние объекты могут быть помечены @Extract аннотации , которая находится на или g.jvnet.hk2.annotations.Extract . Эта аннотация позволяет определить свойство, которое будет извлечено и помещено в предопределенную область или область по умолчанию, которая является областью PerLookup.

После того, как объект извлечен, HK2 поместит его в контейнер типа org.jvnet.hk2.component.Habitat, контейнер предоставит любой объект, который нуждается в одном из его обитателей. В листинге 2 показано, как свойство объекта может быть помечено как извлечение.

Перечисление 2 образец извлечения HK2

@Service (name="restart-domain",                                 scope=org.jvnet.hk2.component.PerLookup.class,                                    
factory=gfbook.chapterCommandFactory)
public class RestartDomain implements AdminCommand {
@Extract #1
LoggerService logger;
@Extract #2
public CounterService getCounterService() {...}
}

В # 1 мы помечаем свойство для извлечения, а в # 2 мы извлекаем объект из метода получателя, поэтому помните, что аннотация @Extract работает как на уровне свойства, так и на уровне получателя. Теперь давайте посмотрим , как й е С.Е. обитатель объекты могут использоваться другой службы , которая нуждается в этих двух функций .

Перечисление 3 образец извлечения HK2

@Service (name="restart-domain",                                 scope=org.jvnet.hk2.component.PerLookup.class,                                    
factory=gfbook.chapterCommandFactory)
public class RestartDomain implements AdminCommand {
@Inject protected Habitat habitat; #1
public void performAudition() {
LoggerService logger = habitat.getComponent(LoggerService.class); #2
CounterService counter = habitat.getComponent(CounterService.class); #2
}
}

 

В # 1 мы внедряем контейнер в свойство этого объекта , вы видите, что это мир IOC, и у нас нет явного создания объекта, в # 2 мы просим h abitat предоставить нам экземпляр LoggerService и CounterService.

Теперь вы должны иметь представление о слое OSGI Bundle и основах HK2, и мы сможем написать несколько модулей GlassFish, чтобы увидеть, как эти два можно использовать для модулей GlassFish в этой статье и в следующей.

Контейнеры и контейнеры GlassFish расширяются

GlassFish — это многоцелевой сервер приложений, на котором могут размещаться приложения различного типа, разработанные с использованием различных языков программирования, таких как Ruby, Groovy и PHP, в дополнение к поддержке приложений на основе платформы Java EE.

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

GlassFish может иметь десятки контейнеров различного типа для приложений различного типа, поэтому, прежде всего, каждый контейнер должен иметь имя, чтобы ядро ​​GlassFish могло легко получить к ним доступ. На следующем этапе GlassFish должен иметь некоторый механизм для определения того, в какой контейнер должно быть развернуто приложение. Затем должен быть механизм для определения того, какие шаблоны URL должны быть переданы в конкретный контейнер для дальнейшей обработки. И, наконец, у каждого приложения есть некоторый набор классов, контейнер которых должен загружать их для обработки входящего запроса, поэтому для загрузки классов приложения требуется загрузчик классов с полным пониманием структуры каталога приложения.  На рисунке 3 показана процедура развертывания приложения с момента получения команды развертывания GlassFish до этапа, когда контейнер становится доступным для менеджера развертывания GlassFish.

Рис. 3. Действия по развертыванию приложений в GlassFish

Эта фигура слишком занята? Кроме того, есть некоторые опечатки, так что держите это помеченным

  от раннего запуска до получения GlassFish назначенного имени контейнера.

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

Рисунок 4 Действия, которые происходят после того, как GlassFish получает конкретное имя контейнера

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

Когда артефакт передается в GlassFish для развертывания, сначала артефакт проходит проверку, чтобы увидеть, какой это тип архива и в каком контейнере может размещаться это приложение. Таким образом, мы должны иметь возможность проверить архив и определить, совместим ли он с нашим контейнером или нет. Для этого мы должны реализовать интерфейс с полностью определенным именем, как org.glassfish.api.container.Sniffer, GlassFish создает список всех реализаций Sniffer и передает архив каждой из них, чтобы узнать, знает ли Sniffer архив или не. В листинге 4 показана фиктивная реализация Sniffer

 

Интерфейс Sniffer перечисления 4

@Service(name = "TextApplicationSniffer")
@Scoped(Singleton.class)
public interface TextApplicationSniffer implements Sniffer{
public boolean handles(ReadableArchive source, ClassLoader loader){} #1
public Class<? extends Annotation>[] getAnnotationTypes(){} #2
public String[] getURLPatterns(){} #3
public String getModuleType(){} #4
public Module[] setup(String containerHome, Logger logger) throws IOException(){} #9
public void tearDown(){} #5
public String[] getContainersNames(){} #6
public boolean isUserVisible(){} #7
public Map<String,String> getDeploymentConfigurations(final ReadableArchive source) throws IOException{} #8
}

Реализация интерфейса Sniffer должна возвращать true или false, основываясь на том факте, что он понимает архив или нет # 1 . Реализации интерфейса ReadableArchive предоставляют нам виртуальное представление содержимого архива и позволяют нам проверять определенные файлы или размер файла, или позволяют нам проверять наличие другого архива внутри текущего и так далее.

Если мы намерены использовать более сложный анализ архива, например , путем проверки на наличие в конкретной аннотации мы должны вернуть список аннотаций в getAnnotationTypes # 2 . GlassFish просканировать архив на наличие одного с аннотациями и продолжить работу с этим S Ниффера если класс помечается одним из этих аннотаций .

Если это S Niffer , который понимает архив затем GlassFish запрашивает для URL — адреса паттерн сек , что GlassFish должен вызвать метод обслуживания контейнера , когда запрос соответствует этому шаблону # 3 . В # 4 мы определяем имя модуля, которое может быть простой строкой.

В # 5 мы просто удаляем все, что связано с этим контейнером из системы модулей. На # 6 мы должны вернуть список всех контейнеров, которые этот конкретный Sniffer может включить.

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

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

Org.glassfish.api.container.Container является GlassFish контракта контейнера, каждый контейнер должен инвентарем, Container интерфейсом является точкой входа для GlassFish контейнера расширяемости. В листинге 5 показана фиктивная реализация контейнера . Контейнерный класс не должен выполнять ничего конкретного, все задачи делегируются другому классу, который выполняет

Реализация фиктивного контейнера перечисления 5

@Service(name = "gfbook.chaptercontainer.TextApplicationContainer")         #1
public class TextApplicationContainer implements Container { #2
public Class<? extends Deployer> getDeployer() { #3
return gfbook.chaptercontainer.TextApplicationDeployer.class;#3
}

public String getName() {
return " Text Container"; #4
}

На # 1 мы определяем уникальное имя для нашего контейнера, мы можем использовать полное имя класса, чтобы гарантировать его уникальность. На # 2 мы реализуем контейнерный контракт, чтобы позволить ядру GlassFish использовать наш контейнер так, как он знает. На # мы возвращаем имя класса реализации нашего интерфейса D eployer, который будет выполнять такие задачи, как загрузка, выгрузка, подготовка и другие задачи, связанные с приложением. В # 4 мы возвращаем удобочитаемое имя для нашего контейнера.

Вы можете видеть, что в контейнере нет ничего особенного, кроме того, что он имеет реализацию org.glassfish.api.deployment.Deployer, которую ядро ​​GlassFish будет использовать для делегирования задачи развертывания. В листинге 6 приведен фрагмент кода из реализации развертывания контейнера текстового приложения.

Реализация перечисления 6 Deployer контейнера TextApplication

@Service
public class TextApplicationDeployer implements Deployer<TextContainer, TextApplication> { #1
public boolean prepare(DeploymentContext context) { } #2

public <T> T loadMetaData(Class<T> type, DeploymentContext context) { }#3

public MetaData getMetaData() {}#4

public TextApplication load(TextContainer container, DeploymentContext context) {} #5

public void unload(TextApplication container, DeploymentContext context) {} #6

public void clean(DeploymentContext context) {} #6

}

 

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

На втором месте мы подготавливаем приложение для развертывания, это может быть разархивирование некоторых архивных файлов или предварительная обработка дескрипторов развертывания приложения для извлечения некоторой необходимой информации для задачи развертывания. Несколько методов в Deployer интерфейса принимают org.glassfish.api.deployment.DeploymentContext , как один из его параметров, этот интерфейс предоставляет всю контекстную информацию о себе в рамках обработки заявки. Например, содержимое приложения в виде файлов и каталогов , доступ к загрузчику классов приложения, все параметры, передаваемые команде развертывания, и так далее.

На # 3 мы возвращаем набор метаданных , связанных с нашим приложением , эти метаданные могут содержать такую ​​информацию, как имя приложения и так далее. На # 4 мы должны вернуть экземпляр org.glassfish.api.deployment.MetaData, который содержит специальное требование, в котором нуждается этот экземпляр D eployer. Этим требованием может быть загрузка набора классов перед загрузкой приложения с использованием отдельного загрузчика классов или набора метаданных, которые наш экземпляр Deployer предоставит после успешной загрузки приложения. Мы обсудим MetaD ata более подробно на следующем шаге. В# 5 загружает приложение и вернуть реализацию в org.glassfish.api.deployment . ApplicationContainer управления S Жизненный цикл приложения и его среду исполнения . На # 6 мы удаляем приложение из контейнера, что означает, что наше приложение больше не должно быть доступно в контейнере . На # 7 мы очищаем любой временный файл, созданный во время выполнения метода prepare .

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

 

Код фрагмента перечисления 7 для класса TextApplication

public class TextApplication extends TextApplicationAdapter
implements ApplicationContainer{ #1
public boolean start(ApplicationContext startupContext) { }

public boolean stop(ApplicationContext stopContext) { }

public boolean resume()

public ClassLoader getClassLoader() { }

public boolean suspend()

public Object getDescriptor() { } #2

}

 

Вся часть кода должна объясняться само собой, за исключением того, что в # 2 мы возвращаем дескриптор приложения на уровень развертывания GlassFish, а в # 1 мы выполняем много работ, в том числе и для переноса нашего контейнера с помощью G rizz ly (веб-слой GlassFish). ,

Вы помните, что в листинге 6 мы возвращали экземпляр TextApplication, когда контейнер вызывает метод load объекта Deployer, этот объект отвечает за жизненный цикл приложения, включая то, что вы видите в листинге 7, а также за взаимодействие нашего контейнера с Гризли слой. В листинге 8 показан фрагмент реализации абстрактного класса TextApplicationAdapter . Расширение com.sun.grizzly.tcp.http11.GrizzlyAdapter помогает в разработке пользовательских контейнеров, которые должны взаимодействовать с HTTP-слоем GlassFish . Com.sun.grizzly.tcp.http11.GrizzlyAdapterесть один абстрактный метод, о котором мы говорили, когда мы обсуждали реализацию интерфейса Sniffer, и этот метод является сервисом void (запрос GrizzlyRequest, ответ GrizzlyResponse), который вызывается всякий раз, когда запрос достигает URL, совпадающего с одним из развернутых приложений контейнера.

 

 

Центр обновления GlassFish

 

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

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

  • Доступные обновления : узел Доступные обновления содержит информацию о доступных обновлениях для установки. Он показывает основные сведения о каждом доступном обновлении и определяет, является ли обновление новым и требуется ли его установка для завершения перезагрузки. Вы можете выбрать нужный компонент из таблицы и нажать кнопку «Установить».
  • Установленное программное обеспечение : узел Установленное программное обеспечение показывает компоненты программного обеспечения, установленные в данный момент. Это место, где вы можете удалить любую ненужную часть программного обеспечения из вашей установки GlassFish и позволить ей работать легко. При попытке удалить любой компонент GlassFish проверит, чтобы найти, какие компоненты зависят от него, и позволит вам решить, хотите ли вы удалить их все или нет. В разделе «Подробнее» окна отображается дополнительная информация об установленном программном обеспечении, включая технические характеристики, поддержку продукта, документацию и другие полезные ресурсы.
  • Доступное программное обеспечение : узел Доступное программное обеспечение показывает все программные компоненты, доступные для установки через Центр обновлений . Это новый набор компонентов, таких как новые контейнеры, новые драйверы JDBC, новые веб-приложения и так далее. В разделе «Подробнее» окна отображается дополнительная информация об установленном программном обеспечении, включая технические характеристики, поддержку продукта, документацию и другие полезные ресурсы.

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

Установщик GlassFish загрузит Центр обновлений GlassFish во время установки, если было доступно подключение к Интернету. Если ваша среда не имела подключения к Интернету во время установки, вы можете загрузить центр обновлений, перейдя в GlassFish_Home / bin и запустив скрипт updatetool , это либо сценарий оболочки, либо командный файл. После выполнения команды она загрузит необходимые биты и настроит центр обновлений. Повторный запуск команды приведет к появлению графического интерфейса инструмента центра обновлений, подобного показанному на рисунке 5.

Рисунок 5 Update Center Tool, он может управлять установкой нескольких приложений

В дереве навигации вы можете видеть, что несколькими установками можно управлять с помощью одного интерфейса центра обновлений . Это установленный образ в системе вместе с созданным вручную образом для GlassFish в Action Book.

Центр обновлений в консоли администрирования

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

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

 

 

 


Рис. 6. Обновление страниц центра в консоли администрирования GlassFish с теми же функциями графического интерфейса рабочего стола.

Я знаю, что вы хотите спросить, как насчет уведомлений об обновлениях, как часто я должен проверять наличие обновлений. Команда разработчиков GlassFish знает, что администраторы любят получать уведомления о доступных обновлениях, поэтому есть два механизма для получения уведомлений о доступных обновлениях. Первый способ — текст уведомления, который появляется в верхней панели консоли администрирования, как показано на рисунке 7.

Рис. 7. Веб-сайт центра обновлений уведомлений и интеграция значка уведомления в рабочий стол Gnome

Вы запрашиваете более пассивный способ уведомления, являетесь адвокат адвокат CLI, а затем вы можете использовать систему уведомлений Try Icon, которая уведомляет вас о доступных обновлениях, показывая лампочку в вашей попытке системы. Нет разницы, если вы используете Solaris, Linux или Windows, вы можете активировать значок уведомления, просто выполнив следующую команду в каталоге GlassFish_Home / updatetool / bin /.

./updatetool —register

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

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

Эта универсальная и очень мощная система упаковки называется pkg (5) Image Packaging System или кратко IPS.

Распространение пакетов GlassFish

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

В GlassFish версии 2 имеется центр обновлений, который можно использовать для управления установкой GlassFish, однако этот инструмент обновлений использовал модель модуля, такую ​​как файлы NetBeans NBM, для передачи обновлений с сервера на локальную установку. Но в версии 3 GlassFish система центра обновлений и система установки GlassFish полностью изменились. Мы знаем, что установщик GlassFish и инфраструктура OpenInstaller, вы, возможно, помните из 2.2, что этот установщик GlassFish использует особый тип двоичной системы распространения, разработанной OpenSolaris с именем pkg (5) Image Packaging System (IPS). Теперь мы собираемся более подробно обсудить IPS и его связь с центром обновлений GlassFish. IPS разработан с использованием Python, чтобы гарантировать, что он не зависит от платформы и будет работать на любой платформе с минимальными необходимыми зависимостями.

PKG (5) Система упаковки изображений, просто IPS

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

ИПС , состоящий из нескольких компонентов , которые S при Оме из них являются обязательной для поддержания системы на основе IPS , и некоторые из них являются только при условии , чтобы позволить нам сделать общую процедуру создания , сохранения и использования IPS на основе распространения программного обеспечения проще.

  • Конечные пользователь утилиты : T здесь представляет собой набор из командной строки утилит , которые позволяют конечным пользователям взаимодействовать с серверной стороны программного обеспечения , которые служат в качестве хранилища конце фронта , чтобы позволить клиентам получать и INS высокие обновления и новые возможности для их установленного программного обеспечения.
  • Графический интерфейс на стороне клиента программного обеспечения : как основанная на Java U бновить C ввести , который используется на GlassFish 
  • API для взаимодействия с IPS. Для разработчиков Java предусмотрены некоторые API-интерфейсы Java, позволяющие выполнять связанные с IPS задачи из своих приложений J ava , он обеспечивает лучшую интеграцию с Java-приложениями и предоставляет больше возможностей для независимых поставщиков ПО и OEM- разработчиков при разработке собственных приложений на стороне клиента. ,
  • Установочные образы: A n Установочный образ — это набор пакетов для приложения, который обеспечивает некоторые или все его функциональные возможности .
  • Серверы S язь утилиты : сервер HTTP — который Сядьте перед физической репозитории для взаимодействия с клиентами .
  • Разработка утилиты: набор утилит , которые помогают разработчикам с созданием IPS пакетов. Интеграции системы сборки , как подмножество утилит развития . На данный момент доступна интеграция IPS с Maven и ANT, которая интегрирует и автоматизирует создание и публикацию пакета в репозитории с системой сборки.

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

  • Oper живать изображения на уровне системы: T его тип образов просто в использовании для распространения операционных систем и операционной модернизации системы. Изображения на этом уровне называются полными изображениями и частичными изображениями.
  • Пользовательское Прикладной уровень изображения: T его является уровнем изображения , который разработчики программного обеспечения и дистрибьюция могут использовать для распространения их применения. Этот образ называется образом пользователя и не требует, чтобы операционная система хоста основывалась на IPS.

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

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

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

  • Изображение с некоторой базовой необходимой функциональностью , например GlassFish веб — контейнера . T HESE основные функциональные возможности могут быть зависит от операционной системы для простоты в распространении основного изображения. Я маг может содержать полную систему IPS , включая его утилиту и клиентское приложение , как обновление GlassFish центр или он может просто содержать в сценарий для начальной загрузки IPS установки системы.
  • Изображение может содержит самые основные и минимальные пакеты для начальной загрузки системы IPS, пользователь будет запускать IPS скрипт самонастройки для установки более IPS связанных пакетов , таких как графический клиент Update Center , а позже установить все необходимые функции, используя эти IPS утилиты.

 Создание пакетов с использованием IPS

Теперь, когда у нас есть понимание того, что такое IPS и как оно связано с установщиком GlassFish и самим GlassFish, мы можем воспользоваться утилитами IPS и посмотреть, как мы можем использовать утилиты командной строки или использовать IPS для создания новых пакетов. На рисунке 8 показана структура каталогов GlassFish после начальной загрузки Центра обновлений . Помните, что при загрузке Центра обновлений GlassFish будет установлена ​​утилита pkg (5) IPS.

Вы можете спросить, как соотносятся модульность, расширяемость GlassFish, OSGI и HK2 с IPS, образ IPS — это zip-файлы, содержащие макет каталога GlassFish, включая такие файлы, как его OSGI-браслеты, JAR-файлы, документация и т. Д. Позже, каждый пакет IPS, который может быть обновлением установленных в настоящее время функций или новой функцией, представляет собой zip-файл, который может содержать один или несколько OSGI-пакетов вместе с соответствующей документацией и тому подобным.

Два каталога в структуре каталогов GlassFish связаны с IPS и Центром обновлений GlassFish . Упак каталог включает в себя все необходимые файлы для системы IPS , которая включает в себя страницу человека, библиотеки, разработчики Java могут использовать для разработки своих собственных приложений поверх IPS системы или их собственного приложения для самонастройки ИПС ; он также включает минимальный дистрибутив Python, позволяющий пользователям выполнять сценарии IPS. В Vendor-пакеты содержат все пакеты загруженные и установленные для этого изображения , который является Update Center изображения.

С этого момента, мы рецензировать в упак папку с именем ips_home поэтому вы должны заменить его на реальный путь к упак каталогу или вы можете установить переменную окружения с таким именем , указывающий на этот каталог.

 

 

Рисунок 8 Центр обновлений и структура каталога IPS pkg (5)

Бен каталог , который находится внутри упак каталога включает в себя IPS скриптов для разработчиков и конечных пользователей, эти скрипты перечислены в таблице 1 , с их описанием.

Таблица 1 IPS сценария с соответствующей Descriptio п

скрипт

Описание

р кг

Может использоваться для создания и обновления изображений

pkg.depotd

Это сервер репозитория для системы упаковки изображений. Упак или другой ПОИСКОВОЙ клиента сек отправки пакеты и восстановление каталога запрос на сервер хранилища.

р кгсенд

 

Давайте опубликуем новые пакеты и новые версии пакетов на сервере хранилища пакетов изображений.

p kgrecv

Давайте загрузим содержимое пакета с сервера. Формат содержимого подходит для команды pkgsend .

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

Updatetool папка где U р дата центр GUI приложение найти д вместе с документацией и связанных с ними сценариев. Бен каталог содержит два сценария для запуска обновление центра и регистрации на рабочем столе Уведомителя которые держат S вас в курсе о новых обновлениях и доступной функции, показывая всплывающее окно с соответствующим сообщением в вашей системе Ьги раздела. В Vendor-пакеты папка содержит все пакеты загруженные и установленные для этого изображения , который является Update Center изображения.

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

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

./pkg.depotd -d ../repository -p 10005

Чтобы убедиться, что ваш репозиторий работает, откройте http://127.0.0.1:10005 в своем браузере, и вы должны увидеть нечто похожее на рисунок 9, который включает некоторую информацию о вашем статусе репозитория.

Рисунок 9 Статус репозитория, который мы можем увидеть, указав браузер на URL репозитория.

Теперь наш сервер репозитория работает и ждет, пока мы загрузим в него наши пакеты, а затем загрузим эти пакеты нашими утилитами на стороне клиента, такими как pkg или Update Center .

Наши пакеты должны быть помещены в репозиторий пакетов, и команда, которая может сделать это за нас, это команда pkgsend . Вы уже должны знать о необходимости описать содержимое пакета, его версию, описание и так далее. Команда pkgsend позволяет нам открыть транзакцию и добавить все атрибуты пакета, включенные в него файлы и макет каталога и, наконец, закрыть транзакцию, которая приводит к тому, что pkgsend отправляет наш пакет в хранилище. Команда pkgsend может действовать транзакционным способом, что означает, что у нас может быть набор пакетов, которые нам нужны либо в репозитории, либо ни в одном изих. Эта модель гарантировала, что у нас никогда не будет несовместимых пакетов в хранилище во время загрузки обновлений. Для создания примера пакета нам нужно некоторое содержимое, поэтому создайте каталог внутри каталога pkg и назовите его sample_package, поместите в него два текстовых файла с именами readme.txt и license.txt . Внутри sample_package директории создайте каталог с именем цифры с файлом изображения с именем figure1.jpg внутри него. Это фиктивные файлы, и их содержимое может быть чем угодно. Вы можете добавить еще несколько файлов и создать структуру каталогов для тестирования более сложных структурированных пакетов. В листинге 8 показан ряд команд который мы можем использовать для создания и отправки пакета, который мы только что подготовили, в репозиторий, который мы создали на предыдущем шаге. Я предположил, что вы используете Linux, поэтому команды являются Linuxish, и вы должны вводить их построчно в окне терминала, который может быть либо терминалом gnome, либо любым другим терминалом по вашему выбору. Если вы хотите увидеть, как работает транзакция, вы можете указать вашему браузеру http://127.0.0.1:10005/ во время выполнения списка 8 команд.

Перечисление 8 Создайте и отправьте образец пакета в наш репозиторий

export PKG_REPO=http://127.0.0.1:10005/                           #1
eval './pkgsend open GFiASample@1.0' #2
./pkgsend add set name="pkg.name" value="GFiASamplePackage" #3
./pkgsend add set name="pkg.description" value="sample description" #4
./pkgsend add set name="pkg.detailed_url" value="sample.com/kalali" #5
./pkgsend add file ../sample_package/readme.txt path=GFiA/README.txt #6
./pkgsend add dir path=GFiA/images/ #7
./pkgsend add file ../sample_package/figures/f.jpg path=GFiA/figs/f.jpg #8
./pkgsend add license ../sample_package/license.txt license=GPL #9
./pkgsend close #10

 

На первом месте мы экспортируем переменную среды, которую сценарии IPS будут использовать в качестве URL-адреса хранилища , в противном случае мы должны передавать URL с –s http://127.0.0.1:10005/ при каждом выполнении команды. На # 2 мы открываем транзакцию с именем GFiASample@1.0 для загрузки пакета. На # 3 мы добавляем имя пакета. На # 4 мы добавляем описание пакета, которое будет отображаться в столбце описания приложения с графическим интерфейсом Центра обновлений или получения информации о команде pkg . На # 5 мы добавляем URL, который содержит дополнительные    информация, Центр обновлений извлекает информацию из предоставленного URL, и он будет отображаться в области описания. На # 6 мы добавляем текстовый файл вместе с его путем извлечения ; На # 7 мы добавляем каталог, который будет создан нашей установкой пакета в образе назначения. На # 8 мы добавляем файл в наш ранее созданный каталог. На # 9 мы добавляем тип лицензии пакета вместе с файлом лицензии, позже тип лицензии может использоваться для запроса доступных пакетов на основе их лицензий. И, наконец, в # 10 мы закрываем транзакцию, что приведет к появлению пакета в репозитории пакетов.

Теперь у нас есть один пакет в нашем репозитории, вы можете найти номера пакетов в репозитории , открыв URL-адрес репозитория http://127.0.0.1:10005 / в своем браузере.

Вы уже можете распознать шаблон при использовании команды pkgsend и ее параметров, и если вы это сделали, вы правы, потому что команды pkgsend следуют шаблону, который похож на подкоманду pkgsend [параметры подкоманды]. Список важных подкоманд pkgsend приведен в таблице 2.

Таблица 2 Список подкоманд pkgsend, которые можно использовать для отправки пакета в хранилище

 

Подкоманда

Описание

открыть

Начинает транзакцию с пакета, указанного в имени пакета .

Синтаксис : pkgsend open pkg_name

добавлять

Добавляет ресурс, связанный с действием, в текущую транзакцию .

Синтаксис : pkgsend add action [атрибуты действия]

близко

Закройте текущую транзакцию .

Синтаксис : pkgsend close

 

Вы можете увидеть полный список подкоманд в файлах pkgsend man или на веб-сайте проекта pkg (5), расположенном по адресу http://www.opensolaris.org/os/project/pkg/ .

Подкоманда add является наиболее полезной подкомандой между подкомандами pkgsend, она выполняет действия, которые нам нужны для транзакции, вместе с атрибутами действий. Вы уже видели, как мы можем использовать действия set, file, dir и license . Как видите, каждое действие может принимать один или несколько именованных атрибутов. Другие важные действия перечислены в таблице 3.

Таблица 3 Список других важных действий добавления

действие

Описание и ключевые атрибуты

Ссылка на сайт

Действие ссылки представляет собой символическую ссылку. Путь атрибут определяет т он путь к файлу система , где символический установлен.

Hardlink

Действие hardlink представляет физическую ссылку. В пути атрибуты определяют т он файловая система пути , где установлен символический.

Водитель

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

зависеть

Действие зависимости представляет зависимость между пакетами. Пакет может зависеть от другого пакета для работы или установки. Зависимости не являются обязательными.

группа

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

пользователь

Пользователем действия определяет пользователя UNIX , как определено в / и т.д. / пароль, / и т.д. / тень, / и т.д. / / Ftpd / ftpusers файлов группы и / и т.д.. Пользователи, определенные с этим атрибутом, имеют записи, добавленные в соответствующие файлы.

 

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

Чтобы установить пакет в текущей установке GlassFish, откройте Центр обновлений, выберите узел GlassFish в дереве навигации и затем выберите «Свойства изображения» в меню «Файл» или нажмите CTRL + I, чтобы открыть окно свойств изображения. Добавить новый репозиторий; введите GFiA.Repository в качестве имени и http://127.0.0.1:10005/ в качестве URL-адреса хранилища. Теперь вы сможете обновить список доступных дополнений и выбрать образец пакета GFiA для установки.  

Процесс установки будет довольно простым, поскольку он будет просто выполнять указанные действия одно за другим, что приведет к созданию каталога GFiA внутри каталога установки GlassFish с двумя текстовыми файлами внутри него. При установке пакета также создается каталог figs внутри каталога GFiA вместе с добавлением в него файла изображения.

Вы получаете идею, что вы можете копировать файлы вашего пакета в любое место в образе хоста (в данном случае — в установку GlassFish), поэтому, когда вы хотите распространять ваш OSGI-пакет, вам нужно будет только поместить этот пакет в уже существующий каталог с именем modules в Каталог установки GlassFish.

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

  1. Создайте локальный образ:

./ pkg image-create -U -a GFiA.Repository = http: // localhost: 10005 / / home / user / GFiA

Команда создаст пользователь изображение , которое определяется с помощьюU параметра ; его пакет по умолчанию хранилище наш локальный репозиторий , и определяетсяв параметре . И, наконец, путь к расположению изображения — это / home / user / GFiA, где и будет извлечено наше изображение.

  1. Установите заголовок и описание на изображении :

./pkg set-property title «GlassFish в действии»

./pkg set-property description «Изображение GlassFish в книге действий, созданное в главе»

  1. установить пакет GFiASamplePackage во вновь созданный образ

./ pkg / home / user / GFiA установить GFiASamplePackage 

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

Вы, как разработчик или менеджер проекта, можете использовать IPS, чтобы распространять собственное приложение с нуля и не допускать обновления препятствий. Инструментарий IPS доступен по адресу http://wikis.sun.com/display/IpsBestPractices/Downloads .

Резюме

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

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

Разработка контейнера GlassFish дает возможность разрабатывать серверы нового типа, которые могут содержать новые типы приложений, не углубляясь в разработку сетевого сервера. Это также подходит, поскольку контейнер может взаимодействовать с другими контейнерами на сервере приложений для использования управляемых ресурсов, таких как пулы соединений JDBC или EJB.

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

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

Т он Сервер приложений не зависит от платформы , и поэтому она должна платформой агностика раздаточного механизма и т он PKG (5) IPS является проверенным двоичной системой распределения , которая GlassFish используется для распределения его двоичного.

 

От http://weblogs.java.net/blog/kalali/archive/2010/03/13/glassfish-modularity-system-how-extend-glassfish-cli-and-web-administ