/** * Create the service wrapper for a SCA Component. In the event that the mapping * of the SCA Component methods the base_class and xmldas types are set to * null. * * @param string $class_name * @param string $wsdl_filename */ public function __construct($instance, $class_name, $wsdl_filename) { SCA::$logger->log("Entering"); $this->class_name = $class_name; $this->instance_of_the_base_class = $instance; SCA::fillInReferences($this->instance_of_the_base_class); // create a JSON DAS and populate it with the valid types // that this service can create. Not strinctly required // for json encoding but the JSON Server uses this // DAS for decoding $xsds = SCA_Helper::getAllXsds($class_name); $this->json_das = new SDO_DAS_Json(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $class_name); $this->json_das->addTypesXsdFile($xsd); } } }
/** * Create the service wrapper for a SCA Component. * * @param object $instance Instance * @param string $class_name Class * @param string $wsdl_filename WSDL */ public function __construct($instance, $class_name, $wsdl_filename) { SCA::$logger->log("Wrapper {$class_name}"); $this->class_name = $class_name; $this->instance_of_the_base_class = $instance; SCA::fillInReferences($this->instance_of_the_base_class); $this->annotations = new SCA_AnnotationReader($this->instance_of_the_base_class); // create an XML-RPC DAS and populate it with the valid types // that this service can create. $xsds = SCA_Helper::getAllXsds($class_name); $this->xmlrpc_das = new SCA_Bindings_Xmlrpc_DAS(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $class_name); $this->xmlrpc_das->addTypesXsdFile($xsd); } } $this->xmlrpc_server = xmlrpc_server_create(); $service_description = $this->annotations->reflectService(); $serviceDescGen = new SCA_Bindings_Xmlrpc_ServiceDescriptionGenerator(); $serviceDescGen->addIntrospectionData($this->xmlrpc_server, $service_description, $this->method_aliases, $this->xmlrpc_das); }
/** * Generate method and type information to add introspection data. * The information required is generated from annotations. * All methods are registered with the server, and introspection data * is added to the server. * * @param resource $xmlrpc_server XML RPC server * @param array $service_description Description * @param array &$method_aliases Aliases * @param object $xmlrpc_das Unknown * * @return string Method description */ public function addIntrospectionData($xmlrpc_server, $service_description, &$method_aliases, $xmlrpc_das = null) { if ($xmlrpc_das == null) { $xsds = SCA_Helper::getAllXsds($service_description->class_name); $xmlrpc_das = new SCA_Bindings_Xmlrpc_DAS(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $service_description->class_name); $xmlrpc_das->addTypesXsdFile($xsd); } } } $type_list = array(); $methodDesc = <<<END <?xml version='1.0'?> <introspection version='1.0'> <methodList> END; foreach ($service_description->operations as $methodName => $methodInfo) { $methodParams = ""; $methodReturn = ""; if (array_key_exists("name", $methodInfo) && array_key_exists("name", $methodInfo["name"]) && $methodInfo["name"]["name"] != null && strlen($methodInfo["name"]["name"]) > 0) { $xmlrpcMethodName = $methodInfo["name"]["name"]; $method_aliases[$xmlrpcMethodName] = $methodName; } else { $xmlrpcMethodName = $methodName; } xmlrpc_server_register_method($xmlrpc_server, $xmlrpcMethodName, $methodName); if (array_key_exists("parameters", $methodInfo) && $methodInfo["parameters"] != null) { foreach ($methodInfo["parameters"] as $param) { $paramName = $param["name"]; if (array_key_exists('objectType', $param)) { $paramType = $param["objectType"]; $this->generateType($param["namespace"], $param["objectType"], $type_list, $xmlrpc_das); } else { $paramType = $this->sdoTypeToXmlRpcType($param["type"]); } $methodParams = $methodParams . <<<END <value type='{$paramType}' desc='{$paramName}'> </value> END; } } if (array_key_exists("return", $methodInfo) && $methodInfo["return"] != null) { foreach ($methodInfo["return"] as $ret) { if (array_key_exists('objectType', $ret)) { $retType = $ret["objectType"]; $this->generateType($ret["namespace"], $ret["objectType"], $type_list, $xmlrpc_das); } else { $retType = $this->sdoTypeToXmlRpcType($ret["type"]); } $methodReturn = $methodReturn . <<<END <value type='{$retType}' desc='return'> </value> END; } } $methodDesc = $methodDesc . <<<END <methodDescription name='{$xmlrpcMethodName}'> <author></author> <purpose></purpose> <version></version> <signatures> <signature> <params> {$methodParams} </params> <returns> {$methodReturn} </returns> </signature> </signatures> </methodDescription> END; } $methodDesc = $methodDesc . "</methodList>\n"; if (count($type_list) > 0) { $methodDesc = $methodDesc . "<typeList>\n"; foreach ($type_list as $type) { $methodDesc = $methodDesc . <<<END <typeDescription name='{$type->name}' basetype='struct' desc='{$type->name}'> END; foreach ($type->typedef->properties as $prop) { $methodDesc = $methodDesc . <<<END <value type='{$prop->type}' name='{$prop->name}'></value> END; } $methodDesc = $methodDesc . <<<END </typeDescription> END; } $methodDesc = $methodDesc . "</typeList>\n"; } $methodDesc = $methodDesc . "</introspection>\n"; $descArray = xmlrpc_parse_method_descriptions($methodDesc); xmlrpc_server_add_introspection_data($xmlrpc_server, $descArray); }
/** * Am repeating this code here (it's in the previous method also) * as we are seeing a number of different combinitations of * creating and XMLDAS based on the \@type annotations in the * \@Service comment or in the \@Reference comment * * TODO - create a more complete model of the service in memory * so that we can pick bits from it rather than having to * rescan the class and regen it every time we need a bit * * @param string $class_name Class name * @param mixed $xsds XSDs * * @return SDO_DAS_XML */ public static function getXmldasFormXsdArray($class_name, $xsds) { $xmldas = SDO_DAS_XML::create(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $class_name); $xmldas->addTypes($xsd); } } return $xmldas; }
/** * THE OLD VERSION OF createInstanceAndFillInReferences(). INCLUDES * FUNCTIONALITY REQUIRED WHEN SCA IS RUNNING EMBEDDED IN TUSCANY SCA C++ * * Instantiate the component, examine the annotations, find the dependencies, * call getService to create a proxy for each one, and assign to the * instance variables. The call(s) to getService may recurse back through here * if those dependencies also have dependencies * * @param string $class_name name of the class * * @return class instance */ public static function createInstanceAndFillInReferences($class_name) { self::$logger->log("Entering"); self::$logger->log("Class name of component to instantiate is {$class_name}"); $instance = new $class_name(); $reader = new SCA_AnnotationReader($instance); $references = $reader->reflectReferencesFull($instance); self::$logger->log("There are " . count($references) . " references to be filled in"); $reflection = new ReflectionObject($instance); foreach ($references as $ref_name => $ref_type) { $ref_value = $ref_type->getBinding(); self::$logger->log("Reference name = {$ref_name}, binding = {$ref_value}"); $reference_proxy = null; if (self::$is_embedded) { $reference_proxy = new SCA_TuscanyProxy($ref_value); } else { if (SCA_Helper::isARelativePath($ref_value)) { $ref_value = SCA_Helper::constructAbsolutePath($ref_value, $class_name); } $reference_proxy = SCA::getService($ref_value); } $prop = $reflection->getProperty($ref_name); // add the reference information to the proxy // this is added just in case there are any // extra types specified in the doc comment // for this reference $ref_type->addClassName($class_name); $reference_proxy->addReferenceType($ref_type); $prop->setValue($instance, $reference_proxy); // NB recursion here } self::$logger->log("Exiting"); return $instance; }
public function getJsonDas($xsds, $class_name) { $json_das = new SDO_DAS_Json(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $class_name); $json_das->addTypesXsdFile($xsd); } } return $json_das; }
/** * Get XML DAS for Atom * * @param string $class_name Class name * @param string $namespace_uri Namespace * * @todo refactor this back into getXmldas - should just be able to load the atom schema if the namespace and type are http://www.w3.org/2005/Atom and entryType. This needs some thought though as the namespace could change, and someone else might use the type name entryType in a non-atom schema * * @return XML_DAS */ public static function getXmldasForAtom($class_name, $namespace_uri) { SCA::$logger->log("Entering"); $xmldas = SDO_DAS_XML::create(dirname(__FILE__) . '/Atom1.0.xsd'); // expect to find xsds along with the SCA code - automatically loads xhtml1.xsd and xml.xsd as part of this. // TODO examine this code again // one might imagine that what is wanted is a map: // array(namespace => Set Of xsd) // but this is not what we have // Code Analyser correctly picks up a number // of strangenesses $xsds = SCA_Helper::getAllXsds($class_name); //$atomhelperlog->log("SCA_ServiceWrapperAtom::getXmldasForAtom() Just tried to find xsds in the component: ". print_r($xsds, true) ." \n"); //$xmldas = SDO_DAS_XML::create(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $class_name); $xmldas->addTypes($xsd); } } // $atomhelperlog->log("SCA_ServiceWrapperAtom::getXmldasForAtom() xmldas after adding other types from the class:: $xmldas \n"); SCA::$logger->log("Exiting"); return $xmldas; }
/** * Create XMLRPCDAS * * @param SCA_ReferenceType $reference_type Reference type * * @return object */ protected function createXmlRpcDas($reference_type) { $xsds = $reference_type->getTypes(); $xmlrpc_das = new SCA_Bindings_Xmlrpc_DAS(); foreach ($xsds as $index => $xsds) { list($namespace, $xsdfile) = $xsds; if (SCA_Helper::isARelativePath($xsdfile)) { $xsd = SCA_Helper::constructAbsolutePath($xsdfile, $reference_type->getClassName()); $xmlrpc_das->addTypesXsdFile($xsd); } } return $xmlrpc_das; }