org.xdi.oxd.server.license.LicenseService クラス

org.xdi.oxd.server.license.LicenseService 連携図

公開メンバ関数
	LicenseService (OxdServerConfiguration conf, HttpService httpService, TimeService timeService)
void	start ()
LicenseMetadata	getMetadata ()
boolean	isLicenseValid ()
void	notifyClientUsed (final Rp rp, final boolean isClientLocal)

非公開メンバ関数
void	validateConfiguration ()
boolean	validateLicense ()
void	schedulePeriodicValidation (int initialDelayInHours)
boolean	shouldNotifyAboutClientUsage (Rp rp)
void	notifyClientUsedImpl (Rp rp, boolean isClientLocal)

静的非公開メンバ関数
static AppMetadata	appMetadata (String programmingLanguage, String serverName)

非公開変数類
final OxdServerConfiguration	conf
final LicenseFileUpdateService	updateService
final TimeService	timeService
final HttpService	httpService
volatile LicenseMetadata	metadata = null
volatile boolean	licenseValid = false
final Cache< String, Rp >	clientUpdateCache

静的非公開変数類
static final Logger	LOG = LoggerFactory.getLogger(LicenseService.class)

詳解

著者

Yuriy Zabrovarnyy

バージョン

0.9, 12/10/2014

構築子と解体子

LicenseService()

org.xdi.oxd.server.license.LicenseService.LicenseService ( OxdServerConfiguration  conf, HttpService  httpService, TimeService  timeService  )

inline

                                                                                                         {
        this.conf = conf;
        this.timeService = timeService;
        this.updateService = new LicenseFileUpdateService(conf, httpService);
        this.httpService = httpService;
    }

関数詳解

appMetadata()

static AppMetadata org.xdi.oxd.server.license.LicenseService.appMetadata ( String  programmingLanguage, String  serverName  )

inlinestaticprivate

                                                                                          {
        AppMetadata appMetadata = new AppMetadata();
        appMetadata.setAppName("oxd");
        appMetadata.setAppVersion(ConfigurationService.APP_VERSION);
        appMetadata.setProgrammingLanguage(programmingLanguage);

        Properties buildProperties = ServerLauncher.buildProperties();
        if (buildProperties != null) {
            for (String key : buildProperties.stringPropertyNames()) {
                appMetadata.getData().put(key, buildProperties.getProperty(key));
            }
        }
        appMetadata.getData().put("server_name", serverName);

        return appMetadata;
    }

getMetadata()

LicenseMetadata org.xdi.oxd.server.license.LicenseService.getMetadata ( )

inline

                                         {
        return metadata;
    }

isLicenseValid()

boolean org.xdi.oxd.server.license.LicenseService.isLicenseValid ( )

inline

                                    {
        return licenseValid && !updateService.isRetryLimitExceeded();
    }

notifyClientUsed()

void org.xdi.oxd.server.license.LicenseService.notifyClientUsed ( final Rp  rp, final boolean  isClientLocal  )

inline

                                                                           {
        CoreUtils.createExecutor().execute(new Runnable() {
            @Override
            public void run() {
                if (shouldNotifyAboutClientUsage(rp)) {
                    notifyClientUsedImpl(rp, isClientLocal);
                }
            }
        });
    }

notifyClientUsedImpl()

void org.xdi.oxd.server.license.LicenseService.notifyClientUsedImpl ( Rp  rp, boolean  isClientLocal  )

inlineprivate

                                                                    {
        try {
            String licenseId = conf.getLicenseId();
            String clientId = rp.getClientId();
            String oxdId = rp.getOxdId();
            String clientName = rp.getClientName();
            String macAddress = MacAddressProvider.macAddress();

            StatisticUpdateRequest request = StatisticUpdateRequest.clientUpdate(
                    licenseId, clientId, oxdId, clientName, macAddress, isClientLocal);
            request.setAppMetadata(appMetadata(rp.getOxdRpProgrammingLanguage(), conf.getServerName()));
            LOG.trace("Updating statistic ... , request: " + request);
            Response response = LicenseClient.statisticWs(LicenseFileUpdateService.LICENSE_SERVER_ENDPOINT, httpService.getClientExecutor()).update(request);
            if (response.getStatus() == 200) {
                LOG.trace("Updated statistic. oxdId: " + oxdId + ", response: " + response);
            } else {
                throw new RuntimeException("Failed to update statistic, rp: " + rp);
            }
        } catch (Exception e) {
            LOG.error("Failed to update statistic. Message: " + e.getMessage(), e);
        }
    }

schedulePeriodicValidation()

void org.xdi.oxd.server.license.LicenseService.schedulePeriodicValidation ( int  initialDelayInHours )

inlineprivate

                                                                     {
        final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(CoreUtils.daemonThreadFactory());
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                licenseValid = validateLicense();
            }
        }, initialDelayInHours, 24, TimeUnit.HOURS);
    }

shouldNotifyAboutClientUsage()

boolean org.xdi.oxd.server.license.LicenseService.shouldNotifyAboutClientUsage ( Rp  rp )

inlineprivate

                                                        {
        boolean hasInCache = clientUpdateCache.getIfPresent(rp.getClientId()) != null;
        if (hasInCache) {
            return false; // skip update, client was updated already
        }
        clientUpdateCache.put(rp.getClientId(), rp);
        return true;
    }

start()

void org.xdi.oxd.server.license.LicenseService.start ( )

inline

                        {
        validateConfiguration();

        Optional<LicenseFile> licenseFile = LicenseFile.load();

        // before license update, check existing license and make sure autoupdate=true, otherwise skip update
        if (validateLicense() && metadata != null && metadata.getAutoupdate() != null &&
                !metadata.getAutoupdate()) {
            licenseValid = true;
            schedulePeriodicValidation(Utils.hoursDiff(new Date(), metadata.getExpirationDate()));
            return; // skip update procedure, autoupdate=false !
        }

        this.updateService.start(licenseFile);

        licenseValid = validateLicense();
        if (licenseValid) {
            schedulePeriodicValidation(1);
        } else {
            ServerLauncher.shutdownDueToInvalidLicense();
        }
    }

validateConfiguration()

void org.xdi.oxd.server.license.LicenseService.validateConfiguration ( )

inlineprivate

                                         {
        if (Strings.isNullOrEmpty(conf.getLicenseId())) {
            LOG.error("Unable to validate license. license_id is not set in oxd configuration.");
            ServerLauncher.shutdown();
        }
        if (Strings.isNullOrEmpty(conf.getPublicKey())) {
            LOG.error("Unable to validate license. public_key is not set in oxd configuration.");
            ServerLauncher.shutdown();
        }
        if (Strings.isNullOrEmpty(conf.getPublicPassword())) {
            LOG.error("Unable to validate license. public_password is not set in oxd configuration.");
            ServerLauncher.shutdown();
        }
    }

validateLicense()

boolean org.xdi.oxd.server.license.LicenseService.validateLicense ( )

inlineprivate

                                      {
        try {
            LOG.trace("Validating license ...");

            metadata = null;
            licenseValid = false;

            Optional<LicenseFile> licenseFile = LicenseFile.load();
            if (!licenseFile.isPresent() || Strings.isNullOrEmpty(licenseFile.get().getEncodedLicense())) {
                LOG.error("Failed to load license file : " + LicenseFile.getLicenseFile().getAbsolutePath());
                return false;
            }

            if (StringUtils.isBlank(licenseFile.get().getLicenseId()) || !licenseFile.get().getLicenseId().equals(conf.getLicenseId())) {
                LOG.info(String.format("Deleting license file ... license id in file (%s) does not match license id from oxd-conf.json (%s)", licenseFile.get().getLicenseId(), conf.getLicenseId()));
                LicenseFile.deleteContent();
                this.updateService.updateLicenseFromServer();
                licenseFile = LicenseFile.load();
            }

            LicenseContent licenseContent = LicenseValidator.validate(
                    conf.getPublicKey(),
                    conf.getPublicPassword(),
                    conf.getLicensePassword(),
                    licenseFile.get().getEncodedLicense(),
                    Product.OXD,
                    timeService.getCurrentLicenseServerTime()
            );

            metadata = licenseContent.getMetadata();
            licenseValid = true;

            LOG.trace("License is validated successfully.");
            LOG.trace("License data: " + metadata);
            return true;
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
        return false;
    }

メンバ詳解

clientUpdateCache

final Cache<String, Rp> org.xdi.oxd.server.license.LicenseService.clientUpdateCache

private

初期値:

= CacheBuilder.newBuilder()
            .maximumSize(100000)
            .expireAfterWrite(24, TimeUnit.HOURS)
            .build()

conf

final OxdServerConfiguration org.xdi.oxd.server.license.LicenseService.conf

private

httpService

final HttpService org.xdi.oxd.server.license.LicenseService.httpService

private

licenseValid

volatile boolean org.xdi.oxd.server.license.LicenseService.licenseValid = false

private

LOG

final Logger org.xdi.oxd.server.license.LicenseService.LOG = LoggerFactory.getLogger(LicenseService.class)

staticprivate

metadata

volatile LicenseMetadata org.xdi.oxd.server.license.LicenseService.metadata = null

private

timeService

final TimeService org.xdi.oxd.server.license.LicenseService.timeService

private

updateService

final LicenseFileUpdateService org.xdi.oxd.server.license.LicenseService.updateService

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxd/oxd-server/src/main/java/org/xdi/oxd/server/license/LicenseService.java