Creates the Configuration service definition.
437000
private function createConfigurationDefinition()
    {
        $id = $this->getServiceId('configuration');
        if (!$this->container->has($id)) {
            $definition = new Definition(self::CONFIGURATION);
            $definition
                ->setFactory([new Reference('ekyna_admin.pool_factory'), 'createConfiguration'])
//                ->setFactoryService('ekyna_admin.pool_factory')
//                ->setFactoryMethod('createConfiguration')
                ->setArguments([
                    $this->prefix,
                    $this->resourceName,
                    $this->options['entity'],
                    $this->buildTemplateList($this->options['templates']),
                    $this->options['event'],
                    $this->options['parent']
                ])
                ->addTag('ekyna_admin.configuration', [
                    'alias' => sprintf('%s_%s', $this->prefix, $this->resourceName)]
                )
            ;
            $this->container->setDefinition($id, $definition);
        }
    }
126339
@Override
  protected void configure() {

    bind(DiscoveryService.class).to(BaseDiscoveryService.class);

    bind(OperatingSystemDetectionStrategy.class)
        .to(NameSubstringBasedOperatingSystemDetectionStrategy.class);
  }
527129
def create_service(self, *args, **kwargs):
        
        return self._client.create_service(*args, scope=self.id, **kwargs)
1367859
public static void createAndRegister(OcAgentMetricsExporterConfiguration configuration) {
    checkNotNull(configuration, "configuration");
    createInternal(
        configuration.getEndPoint(),
        configuration.getUseInsecure(),
        configuration.getSslContext(),
        configuration.getServiceName(),
        configuration.getExportInterval(),
        configuration.getRetryInterval());
  }
1286744
def create(self):
        
        self.service.create()

        predix.config.set_env_value(self.use_class, 'ingest_uri',
                self.get_ingest_uri())
        predix.config.set_env_value(self.use_class, 'ingest_zone_id',
                self.get_ingest_zone_id())

        predix.config.set_env_value(self.use_class, 'query_uri',
                self.get_query_uri())
        predix.config.set_env_value(self.use_class, 'query_zone_id',
                self.get_query_zone_id())
906724
def create(config, name, group, type):
        """"""
        if type not in ('user', 'service'):
            raise click.BadOptionUsage("--type must be 'user' or 'service'")
        client = Client()
        client.prepare_connection()
        user_api = API(client)
        group_api = GroupApi(client)
        user_api.create(name[0], name[1], group, type, group_api)
282713
def create(self):
        
        self.service.create()
        os.environ[self.__module__ + '.uri'] = self.service.settings.data['url']
        os.environ[self.__module__ + '.zone_id'] = self.get_predix_zone_id()
892452
@RequestMapping(value = "configurations/create", method = RequestMethod.POST)
    public SVNConfiguration newConfiguration(@RequestBody SVNConfiguration configuration) {
        return svnConfigurationService.newConfiguration(configuration);
    }
1261875
@Nullable
  public ServerServiceDefinition addService(ServerServiceDefinition service) {
    return services.put(service.getServiceDescriptor().getName(), service);
  }
212279
function createConfig(configObj, providerObj, platformPath) {
    forEach(configObj, function(value, namespace) {

      if (angular.isObject(configObj[namespace])) {
        // recursively drill down the config object so we can create a method for each one
        providerObj[namespace] = {};
        createConfig(configObj[namespace], providerObj[namespace], platformPath + '.' + namespace);

      } else {
        // create a method for the provider/config methods that will be exposed
        providerObj[namespace] = function(newValue) {
          if (arguments.length) {
            configObj[namespace] = newValue;
            return providerObj;
          }
          if (configObj[namespace] == PLATFORM) {
            // if the config is set to 'platform', then get this config's platform value
            var platformConfig = stringObj(configProperties.platform, ionic.Platform.platform() + platformPath + '.' + namespace);
            if (platformConfig || platformConfig === false) {
              return platformConfig;
            }
            // didnt find a specific platform config, now try the default
            return stringObj(configProperties.platform, 'default' + platformPath + '.' + namespace);
          }
          return configObj[namespace];
        };
      }

    });
  }
22435
public function loadConfiguration()
    {
        // Load extension configuration
        $config = $this->getConfig();

        if(!isset($config['path']))
        {
            throw new ServiceCreationException('Missing required path parameter in PaletteExtension configuration');
        }

        if(!isset($config['url']))
        {
            throw new ServiceCreationException('Missing required url parameter in PaletteExtension configuration');
        }

        // Register extension services
        $builder = $this->getContainerBuilder();

        // Register palette service
        $builder->addDefinition($this->prefix('service'))
                ->setClass('NettePalette\Palette', array(

                    $config['path'],
                    $config['url'],
                    $config['basepath'],
                    empty($config['fallbackImage']) ? NULL : $config['fallbackImage'],
                    empty($config['template']) ? NULL : $config['template'],
                    empty($config['websiteUrl']) ? NULL : $config['websiteUrl'],
                    empty($config['pictureLoader']) ? NULL : $config['pictureLoader'],
                ))
                ->addSetup('setHandleExceptions', [

                    !isset($config['handleException']) ? TRUE : $config['handleException'],
                ]);

        // Register latte filter service
        $builder->addDefinition($this->prefix('filter'))
                ->setClass('NettePalette\LatteFilter', [$this->prefix('@service')]);

        // Register latte filter
        $this->getLatteService()
             ->addSetup('addFilter', ['palette', $this->prefix('@filter')]);

        // Register extension presenter
        $builder->getDefinition('nette.presenterFactory')
                ->addSetup('setMapping', [['Palette' => 'NettePalette\*Presenter']]);
    }
96026
public OperationFuture<LoadBalancer> create(LoadBalancerConfig config) {
        String dataCenterId = dataCenterService.findByRef(config.getDataCenter()).getId();

        LoadBalancerMetadata loadBalancer = loadBalancerClient.create(
            dataCenterId,
            new LoadBalancerRequest()
                .name(config.getName())
                .description(config.getDescription())
                .status(config.getStatus())
        );

        LoadBalancer loadBalancerRef = LoadBalancer.refById(loadBalancer.getId(), DataCenter.refById(dataCenterId));

        return new OperationFuture<>(
            loadBalancerRef,
            new SequentialJobsFuture(
                () -> new CreateLoadBalancerJobFuture(this, loadBalancerRef),
                () -> addLoadBalancerPools(config, loadBalancerRef)
            )
        );
    }
1231519
@Override
    public ConfigurationAdmin getService(Bundle bundle, ServiceRegistration<ConfigurationAdmin> registration) {
        ServiceReference<ConfigurationAdmin> reference = registration.getReference();
        ced.setServiceReference(reference);
        return new ConfigurationAdminImpl(this, bundle);
    }
1354436
def create_config(cls, params, prefix=None, name=None):
        
        if isinstance(cls.cfg, Config):
            cfg = cls.cfg.copy(name=name, prefix=prefix)
        else:
            cfg = cls.cfg.copy()
            if name:
                cfg[name] = name
            if prefix:
                cfg[prefix] = prefix
            cfg = Config(**cfg)
        cfg.update_settings()
        cfg.update(params, True)
        return cfg
631413
private synchronized static ServiceFactory createServiceFactory(Class<?> aClass, String configurationFile)
      {
    	  String factoryClassName = null;
    	  if(aClass != null)
    	  {
    		  factoryClassName = Config.getProperty(new StringBuilder(ServiceFactory.class.getName()).append(".").append(aClass.getName()).toString());    
    	  }
    	  
    	  //check to use default
    	  if(factoryClassName == null || factoryClassName.length() == 0)
    		  factoryClassName = Config.getProperty(SERVICE_FACTORY_PROP_NM,DEFAULT_SERVICE_FACTORY);
        
         
         //Debugger.println(ServiceFactory.class,"factoryClassName="+factoryClassName);
         
         try
         {
                        
              Class<?> factoryClass =Class.forName(factoryClassName);
              
              if(configurationFile  == null || configurationFile.length() == 0)
              {
                 return (ServiceFactory)ClassPath.newInstance(factoryClassName);
              }
              //Called passing configuration file to constructor
              Object[] inputs = { configurationFile };
              Class<?> [] parameterTypes = { String.class};
               
              return (ServiceFactory)factoryClass.getConstructor(parameterTypes).newInstance(inputs);                
         }
         catch (SetupException e)
         {
        	 throw e;
         }
         catch (Exception e)
         {
        	 
            throw new SetupException(e.getMessage(),e);
         }
      }
911800
@RequestMapping(value = "configurations/create", method = RequestMethod.POST)
    public JIRAConfiguration newConfiguration(@RequestBody JIRAConfiguration configuration) {
        return jiraConfigurationService.newConfiguration(configuration);
    }
145785
protected static function initConfiguration()
    {
        $caching   = self::$registry->getParameter('doozr.kernel.caching');
        $namespace = self::$registry->getParameter('doozr.namespace.flat').'.cache.configuration';

        $cache = Doozr_Loader_Serviceloader::load(
            'cache',
            self::$registry->getParameter('doozr.kernel.caching.container'),
            $namespace,
            [],
            self::$registry->getParameter('doozr.unix'),
            $caching
        );

        // Wire the required instances ...
        self::$registry->getContainer()->getMap()->wire(
            [
                'doozr.configuration.reader.json' => new Doozr_Configuration_Reader_Json(
                    Doozr_Loader_Serviceloader::load('filesystem'),
                    $cache,
                    $caching
                ),
                'doozr.cache.service' => $cache,
            ]
        );

        $configuration = self::$registry->getContainer()->build(
            'doozr.configuration',
            [
                $caching,
            ]
        );

        // Read Kernel configuration
        $configuration->read(
            self::$registry->getPath()->get('configuration').'.config.json'
        );

        // Retrieve list of service configuration files and read them ...
        $serviceConfigurationFiles = self::retrieveServiceConfigurationFiles();

        foreach ($serviceConfigurationFiles as $serviceConfigurationFile) {
            $configuration->read($serviceConfigurationFile);
        }

        // Retrieve list of userland configuration files and read them ...
        $userlandConfigurationFiles = self::retrieveUserlandConfigurationFiles();

        foreach ($userlandConfigurationFiles as $userlandConfigurationFile) {
            $configuration->read($userlandConfigurationFile);
        }

        // Store configuration
        self::$registry->setConfiguration($configuration);

        // Check if debugging is enabled ...
        if (true === self::$registry->getParameter('doozr.kernel.debugging')) {

            // Now add a collector for configuration
            self::$registry->getDebugbar()->addCollector(
                new DebugBar\DataCollector\ConfigCollector(
                    json_decode(json_encode(self::$registry->getConfiguration()->get()), true)
                )
            );
        }

        // Important for bootstrap result
        return true;
    }