Create namespace

REST: POST /caas/registry/{serviceName}/namespaces
@param body [required] A namespace in which a user can either read, write or delete images
@param serviceName [required] Service name

API beta
967486
public OvhNamespace serviceName_namespaces_POST(String serviceName, OvhInputNamespace body) throws IOException {
		String qPath = "/caas/registry/{serviceName}/namespaces";
		StringBuilder sb = path(qPath, serviceName);
		String resp = exec(qPath, "POST", sb.toString(), body);
		return convertTo(resp, OvhNamespace.class);
	}
1262458
public void serviceName_exchange_PUT(String serviceName, OvhExchangeService body) throws IOException {
		String qPath = "/msServices/{serviceName}/exchange";
		StringBuilder sb = path(qPath, serviceName);
		exec(qPath, "PUT", sb.toString(), body);
	}
341007
protected void _createBody(_IControl body,boolean includeStatusMessage){
    	int statusMessageIndex = body.getContainedControls().size();
    	showErrorsIfAny(body,statusMessageIndex, includeStatusMessage);
    	createBody(body);
    }
117516
public OvhPermissions serviceName_namespaces_namespaceId_permissions_permissionId_GET(String serviceName, String namespaceId, String permissionId) throws IOException {
		String qPath = "/caas/registry/{serviceName}/namespaces/{namespaceId}/permissions/{permissionId}";
		StringBuilder sb = path(qPath, serviceName, namespaceId, permissionId);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhPermissions.class);
	}
700638
public void serviceName_domains_domain_PUT(String serviceName, String domain, OvhDomain body) throws IOException {
		String qPath = "/cdn/dedicated/{serviceName}/domains/{domain}";
		StringBuilder sb = path(qPath, serviceName, domain);
		exec(qPath, "PUT", sb.toString(), body);
	}
1360401
@Override
    public void createNamespace() {
        // Use a temporary, no-keyspace session
        try (DBConn dbConn = createAndConnectConn(null)) {
            synchronized (m_schemaLock) {
                if (!m_schemaMgr.keyspaceExists(dbConn, m_keyspace)) {
                    m_schemaMgr.createKeyspace(dbConn, m_keyspace);
                }
            }
        }
    }
1322678
public void serviceId_PUT(Long serviceId, OvhService body) throws IOException {
		String qPath = "/service/{serviceId}";
		StringBuilder sb = path(qPath, serviceId);
		exec(qPath, "PUT", sb.toString(), body);
	}
573663
public void serviceName_sharepoint_PUT(String serviceName, OvhSharepointService body) throws IOException {
		String qPath = "/msServices/{serviceName}/sharepoint";
		StringBuilder sb = path(qPath, serviceName);
		exec(qPath, "PUT", sb.toString(), body);
	}
997280
<T> T deserialize(String body, Class<T> clazz) {
        if (body == null || body.isEmpty()) {
            throw new ServiceException(ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR,
                    ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR.getMessageTemplate(),
                    "the message body is empty");
        }

        try {
            return JsonSerializer.deserialize(body.getBytes(), clazz);
        } catch (Exception e) {
            throw new ServiceException(ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR, e,
                    ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR.getMessageTemplate(),
                    "unrecognized message, deserialize failed.");
        }
    }
115380
private synchronized void registerNamespace(String prefix, String uri, boolean persist) throws NamespaceException, RepositoryException
   {
      if (namespaces.containsKey(prefix))
      {
         unregisterNamespace(prefix);
      }
      else if (prefixes.containsKey(uri))
      {
         unregisterNamespace(prefixes.get(uri));
      }
      if (persister != null && persist)
      {
         persister.addNamespace(prefix, uri);
      }
      final String newPrefix = new String(prefix);
      final String newUri = new String(uri);

      namespaces.put(newPrefix, newUri);
      prefixes.put(newUri, newPrefix);
   }
520216
def addToService(self, service, namespace=None, seperator='.'):
        
        if namespace is None:
            namespace = []
        if isinstance(namespace, basestring):
            namespace = [namespace]

        for n, m in inspect.getmembers(self, inspect.ismethod):
            if hasattr(m, 'export_rpc'):
                try:
                    name = seperator.join(namespace + m.export_rpc)
                except TypeError:
                    name = seperator.join(namespace + [m.export_rpc])
                service.add(m, name)
1127314
public OvhNamespace serviceName_namespaces_namespaceId_GET(String serviceName, String namespaceId) throws IOException {
		String qPath = "/caas/registry/{serviceName}/namespaces/{namespaceId}";
		StringBuilder sb = path(qPath, serviceName, namespaceId);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhNamespace.class);
	}
163459
public OvhInstanceGroup project_serviceName_instance_group_POST(String serviceName, String name, String region, OvhInstanceGroupTypeEnum type) throws IOException {
		String qPath = "/cloud/project/{serviceName}/instance/group";
		StringBuilder sb = path(qPath, serviceName);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "name", name);
		addBody(o, "region", region);
		addBody(o, "type", type);
		String resp = exec(qPath, "POST", sb.toString(), o);
		return convertTo(resp, OvhInstanceGroup.class);
	}
1088167
def delete(self):
        

        body = client.V1DeleteOptions()

        try:
            status = self.api.delete_namespaced_service(self.name, self.namespace, body)

            logger.info(
                "Deleting Service %s in namespace: %s", self.name, self.namespace)
        except ApiException as e:
            raise ConuException(
                "Exception when calling Kubernetes API - delete_namespaced_service: {}\n".format(e))

        if status.status == 'Failure':
            raise ConuException("Deletion of Service failed")
1193559
public final ProtoParser.service_body_return service_body(Proto proto, Service service) throws RecognitionException {
        ProtoParser.service_body_return retval = new ProtoParser.service_body_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        ProtoParser.rpc_block_return rpc_block143 = null;

        ProtoParser.annotation_entry_return annotation_entry144 = null;

        ProtoParser.option_entry_return option_entry145 = null;



        try {
            // com/dyuproject/protostuff/parser/ProtoParser.g:576:5: ( rpc_block[proto, service] | annotation_entry[proto] | option_entry[proto, service] )
            int alt29=3;
            switch ( input.LA(1) ) {
            case RPC:
                {
                alt29=1;
                }
                break;
            case AT:
                {
                alt29=2;
                }
                break;
            case OPTION:
                {
                alt29=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }

            switch (alt29) {
                case 1 :
                    // com/dyuproject/protostuff/parser/ProtoParser.g:576:9: rpc_block[proto, service]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_rpc_block_in_service_body2325);
                    rpc_block143=rpc_block(proto, service);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, rpc_block143.getTree());

                    }
                    break;
                case 2 :
                    // com/dyuproject/protostuff/parser/ProtoParser.g:577:9: annotation_entry[proto]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_annotation_entry_in_service_body2336);
                    annotation_entry144=annotation_entry(proto);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotation_entry144.getTree());

                    }
                    break;
                case 3 :
                    // com/dyuproject/protostuff/parser/ProtoParser.g:578:9: option_entry[proto, service]
                    {
                    root_0 = (Object)adaptor.nil();

                    pushFollow(FOLLOW_option_entry_in_service_body2347);
                    option_entry145=option_entry(proto, service);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, option_entry145.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
716698
public void billingAccount_service_serviceName_PUT(String billingAccount, String serviceName, OvhTelephonyService body) throws IOException {
		String qPath = "/telephony/{billingAccount}/service/{serviceName}";
		StringBuilder sb = path(qPath, billingAccount, serviceName);
		exec(qPath, "PUT", sb.toString(), body);
	}
387676
function Namespace(server, name){
  this.name = name;
  this.server = server;
  this.sockets = {};
  this.connected = {};
  this.fns = [];
  this.ids = 0;
  this.rooms = [];
  this.flags = {};
  this.initAdapter();
}