OSGeo - User contributions [en]

File:AddUnmanagedData.JPG

2007-01-17T21:50:08Z

Wiki-Tonyfang:

File:EditUnmanagedData.JPG

2007-01-17T21:49:13Z

Wiki-Tonyfang: MapGuide RFC 12

MapGuide RFC 12

File:ConfigureUnmanagedData.JPG

2007-01-17T21:47:51Z

Wiki-Tonyfang:

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-18T22:54:23Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 18:34, 18 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Dec 18, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories. This section can be edited using the Server Admin API.

For windows, it may look like this:

<code>
[UnmanagedDataMappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[UnmanagedDataMappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the administrator to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The following API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

=Implications=

API documentation will need to be updated.

=Test Plan=

* Add webtier test pages which use the new API methods.
* Add unit tests which test the new API methods.

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-18T17:34:29Z

Wiki-Tonyfang: /* Status */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 18:34, 18 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Dec 18, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories. This section can be edited using the Server Admin API.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the administrator to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

=Implications=

API documentation will need to be updated.

=Test Plan=

* Add webtier test pages which use the new API methods.
* Add unit tests which test the new API methods.

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-18T17:32:25Z

Wiki-Tonyfang: /* Test Plan */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 20:46, 12 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Dec 18, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories. This section can be edited using the Server Admin API.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the administrator to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

=Implications=

API documentation will need to be updated.

=Test Plan=

* Add webtier test pages which use the new API methods.
* Add unit tests which test the new API methods.

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-12T19:46:02Z

Wiki-Tonyfang: /* Status */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 20:46, 12 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories. This section can be edited using the Server Admin API.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-12T19:45:19Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 20:14, 8 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories. This section can be edited using the Server Admin API.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-08T19:14:15Z

Wiki-Tonyfang:

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 20:14, 8 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories. This section can be edited using the Server Admin API.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

virtual STRING MgResourceService::GetUnmanagedDataMapping(CREFSTRING ''mappingName'');

Returns the unmanaged data mapping value.

'''Parameters:'''

''mappingName'' is the mapping name.

'''Returns:'''

Returns the unmanaged data mapping value.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-08T00:00:10Z

Wiki-Tonyfang: /* Status */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 01:00, 8 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

virtual void MgResourceService::SetUnmanagedDataMapping(CREFSTRING ''mappingName'', CREFSTRING ''mappingValue'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mappingName'' is the mapping name.

''mappingValue'' is the mapping path.

'''Returns:'''

Returns nothing.

virtual STRING MgResourceService::GetUnmanagedDataMapping(CREFSTRING ''mappingName'');

Returns the unmanaged data mapping value.

'''Parameters:'''

''mappingName'' is the mapping name.

'''Returns:'''

Returns the unmanaged data mapping value.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-07T23:59:08Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 23:50, 6 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

For cross platform compatibilities (i.e. Linux only supports ‘/’s while Windows supports both ‘/’s and ‘\’s), pathnames referenced in XML documents should always contain forward slashes (‘/’s) instead of backward slashes (‘\’s).

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''mappingName'', CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''mappingName'' specifies which mapping to use to return the unmanaged data. When set to empty string, it will use all mappings.

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. When set to empty string, it will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. -1 to search all depths, 0 to search only the top level, 1 to search 1 level, 2 to search 2 levels, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing only the mapping names.

virtual void MgResourceService::SetUnmanagedDataMapping(CREFSTRING ''mappingName'', CREFSTRING ''mappingValue'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mappingName'' is the mapping name.

''mappingValue'' is the mapping path.

'''Returns:'''

Returns nothing.

virtual STRING MgResourceService::GetUnmanagedDataMapping(CREFSTRING ''mappingName'');

Returns the unmanaged data mapping value.

'''Parameters:'''

''mappingName'' is the mapping name.

'''Returns:'''

Returns the unmanaged data mapping value.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T23:03:39Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 23:50, 6 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(CREFSTRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. Empty string will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(CREFSTRING ''mapping'', CREFSTRING ''path'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:57:15Z

Wiki-Tonyfang: /* Implications */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 23:50, 6 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. Empty string will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

API documentation will need to be updated.

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:51:24Z

Wiki-Tonyfang: /* Status */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 23:50, 6 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. Empty string will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:50:21Z

Wiki-Tonyfang: /* Status */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| --[[User:Tonyfang|Tonyfang]] 23:50, 6 December 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. Empty string will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:48:43Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER, FOLDER. Empty string will return all data types. FOLDER returns a list of subfolders.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:39:03Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

Enumerates the available unmanaged data from the server.

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

Enumerates the unmanaged data mappings.

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

Sets the unmanaged data mapping. If the mapping does not exist, it adds it. If it does exist, it will set it to the new path.

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:33:48Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

'''Parameters:'''

None.

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:33:12Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING ''dataTypeFilter'', INT32 ''depth'');

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

'''Parameters:'''

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING ''mapping'', STRING ''path'');

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:32:19Z

Wiki-Tonyfang: /* Technical */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);

'''Parameters:'''

''dataTypeFilter'' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

''depth'' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

'''Returns:'''

Returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

'''Parameters:'''

'''Returns:'''

Returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING mapping, STRING path);

'''Parameters:'''

''mapping'' is the mapping name.

''path'' is the mapped path.

'''Returns:'''

Returns nothing.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:27:28Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

The folllowing API functions will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);

'''dataTypeFilter''' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

'''depth''' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

EnumerateUnmanagedData returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

EnumerateUnmanagedDataMappings returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING mapping, STRING path);

'''mapping''' is the mapping name.

'''path''' is the mapped path.

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:26:12Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

A new API function will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);

'''dataTypeFilter''' is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

'''depth''' is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

EnumerateUnmanagedData returns an MgStringCollection containing the available unmanaged data files.

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedDataMappings();

EnumerateUnmanagedDataMappings returns an MgStringCollection containing the mappings.

virtual void MgResourceService::SetUnmanagedDataMapping(STRING mapping, STRING path);

'''mapping''' is the mapping name.

'''path''' is the mapped path.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:15:36Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

A new API function will be added to the Resource Service:

<code>
virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);

dataTypeFilter is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

depth is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.
</code>

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:15:10Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

A new API function will be added to the Resource Service:

<code>
virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);
dataTypeFilter is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.
depth is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.
</code>

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T22:14:32Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

A new API function will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);

dataTypeFilter is a filter on the returned data. E.g. SHP, SDF, DWF, RASTER. Empty string will return all data types.

depth is how many levels of subfolders it should search for data. 0 to search all subfolders, 1 to search only the top-level, 2 to search down one subfolder, etc.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T19:28:17Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

A new API function will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData(STRING dataTypeFilter, INT32 depth);

dataTypeFilter is a filter on the returned data. E.g. SHP, SDF, DWF. Empty string will return all data types.

depth is how many levels of subfolders it should search for data. 0 corresponds to the top level.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-06T18:25:52Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

A new method will be added to the Resource Service:

virtual MgStringCollection * MgResourceService::EnumerateUnmanagedData();

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-12-05T22:47:57Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-29T09:40:03Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

'''EnumerateUnmanagedData''' is called to return a list of available unmanaged data files. It takes the following parameters:

OPERATION = EnumerateUnmanagedData

VERSION = 1

FILETYPE = <return specific file type e.g. SHP, DWF, ECW or blank for all types> (defaults to blank)

MAPPING = <return unmanaged data files from a specific drive mapping or blank to return data from all drive mappings> (defaults to blank)

DEPTH = <the depth of subdirectories to search for data files or 0 for no limit> (defaults to 0)

It returns a list of available unmanaged data files. They will be prefaced with the drive mappings surrounded by square brackets.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-29T09:34:41Z

Wiki-Tonyfang: /* Proposed Solution */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

'''EnumerateUnmanagedData''' is called to return a list of available unmanaged data files. It takes the following parameters:

OPERATION = EnumerateUnmanagedData

VERSION = 1

DATATYPE = SHP, DWF, ECW, or blank for all types (defaults to blank)

DEPTH = <the depth of subdirectories to search for data files> (defaults to 0 which means there is no limit)

It returns a list of available unmanaged data files. They will be prefaced with the drive mappings surrounded by square brackets.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-29T04:57:18Z

Wiki-Tonyfang:

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

=Status=

{|style="text-align:left" border="1"
!RFC Template Version
|(1.0)
|-
!Submission Date
|1 November 2006
|-
!Last Modified
| [[User:Tonyfang|Tonyfang]] 05:57, 29 November 2006 (CET)
|-
!Author
|Tony Fang
|-
!RFC Status
|draft
|-
!Implementation Status
|pending
|-
!Proposed Release Target
|1.2
|-
!Assigned PSC guide(s)
|(when determined)
|-
| colspan=2 |
{| style="text-align:left" border="1" width="100%"
|+ align="left" |'''Voting History'''
! width="20%" | Date
! width="20%" |+1
! width="20%" |+0
! width="20%" |-0
! width="20%" |-1
|-
|Nov 17, 2006
|
|
|
| style="color: red;" |
|}
|}

=Overview=

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

=Motivation=

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

=Proposed Solution=

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きい　ｓｄｆ = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きい　ｓｄｆ = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きい　ｓｄｆ]reallybig.sdf
</code>

The server will not be locked down such that it is restricted to those files in the Unmanaged Data Mappings. In other words, this means that a feature source can still reference a file that is not in one of the subdirectories specified by the mappings. The reason we don't have to restrict to those subdirectories is because we can use the operating system's or network's built-in security to limit access to files. It will be dependent upon the user to allow access to the files in the Unmanaged Data Mappings,
otherwise they won't be very useful. Thus manually created unmanaged features sources and those created by webstudio will continue to work.

==Technical==

TBD

=Implications=

TBD

=Test Plan=

TBD

=Funding/Resources=

Autodesk to supply the resources to make the required changes.

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-28T21:17:54Z

Wiki-Tonyfang: /* Technical */

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-27T23:31:02Z

Wiki-Tonyfang:

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-27T23:30:29Z

Wiki-Tonyfang:

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:37:03Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きsdf = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きsdf = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names. You may enumerate all files from all the available drive mappings, or you may select a single drive mapping.

A returned list from all available drive mappings may look like this:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きsdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:27:41Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きsdf = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きsdf = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the unmanaged data files available on the server machine. The files will be prefaced with their mapping names.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きsdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:22:41Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きsdf = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きsdf = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the mapping names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きsdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:21:43Z

Wiki-Tonyfang:

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory mappings will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きsdf = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Mappings] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きsdf = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the alias names. Spaces in the mappings are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged data mappings, set the mappings, and also verify that the mappings are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きsdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:18:00Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory aliases will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きsdf = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きsdf = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the alias names. Spaces in the aliases are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged drive aliases, set the aliases, and also verify that the aliases are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大な sdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:13:38Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory aliases will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きなsdf = c:\mydata\bigsdf
</code>

For linux, it may look like this:

<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = /usr/mydata/sdf 
Some Shp Files = /usr/otherdata/shp 
BigArseImages = /mnt/some_other_machine/data/images 
Some 很大中文 DwfFiles = /usr/mydata/很大中文Dwf 
大きなsdf = /usr/mydata/bigsdf
</code>

Unicode characters are supported in the alias names. Spaces in the aliases are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged drive aliases, set the aliases, and also verify that the aliases are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きな sdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:09:41Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory aliases will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きなsdf = c:\mydata\bigsdf
</code>

Unicode characters are supported in the alias names. Spaces in the aliases are also supported. Square brackets [ and ] are not allowed. They are reserved characters for the serverconfig.ini section titles.

We will add API methods to return the unmanaged drive aliases, set the aliases, and also verify that the aliases are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]large.dwf 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きな sdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:07:44Z

Wiki-Tonyfang: /* Proposed Changes */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory aliases will be used to specify the unmanaged data directories.

For windows, it may look like this:

<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きなsdf = c:\mydata\bigsdf
</code>

Unicode characters are supported in the alias names. Spaces in the aliases are also supported. Square brackets [ and ] are not allowed.

We will add API methods to return the unmanaged drive aliases, set the aliases, and also verify that the aliases are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きな sdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-04T00:07:19Z

Wiki-Tonyfang:

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 01:07, 4 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Directories accessible by the server machine can be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. A new section defining directory aliases will be used to specify the unmanaged data directories.

For windows, it may look like this:
<code>
[Unmanaged Data Aliases] 
SomeSdfFiles = c:\mydata\sdf 
Some Shp Files = d:\otherdata\shp 
BigArseImages = \\some_other_machine\data\images 
Some 很大中文 DwfFiles = c:\mydata\很大中文Dwf 
大きなsdf = c:\mydata\bigsdf
</code>

Unicode characters are supported in the alias names. Spaces in the aliases are also supported. Square brackets [ and ] are not allowed.

We will add API methods to return the unmanaged drive aliases, set the aliases, and also verify that the aliases are valid and accessible.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

A returned list may look something like:

<code>
[SomeSdfFiles]world.sdf 
[Some Shp Files]ecuador.shp 
[Some 很大中文 DwfFiles]subdir/Big.dwf 
[大きな sdf]reallybig.sdf
</code>

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T23:34:21Z

Wiki-Tonyfang: /* Status */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 00:34, 3 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, certain directories on the server machine will be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Certain directories on the server machine will be specified to be unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. We will add a new property to General Properties called UnmanagedDataPaths. Multiple paths will be semi-colon delimited. We will also update the GetServerInfo API method to return this information.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T23:32:53Z

Wiki-Tonyfang: /* Motivation */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 21:26, 1 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, certain directories on the server machine will be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Certain directories on the server machine will be specified to be unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in directories which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. We will add a new property to General Properties called UnmanagedDataPaths. Multiple paths will be semi-colon delimited. We will also update the GetServerInfo API method to return this information.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T23:16:53Z

Wiki-Tonyfang: /* Motivation */

This page contains an change request (RFC) for MapGuide Open Source.
More MapGuide RFCs can be found on the [[MapGuide RFCs]] page.

===Status===

*Submission Date: 21:26, 1 November 2006 (CET)
*Last Modified Date: 21:26, 1 November 2006 (CET)
*Author: Tony Fang [[User:Tonyfang|Tonyfang]]
*RFC Status: draft
*Implementation Status: pending
*Voting History:
*Assigned PSC guide(s):

===Overview===

Managed data is data contained inside the server's data repository. Unmanaged data is any data outside of the server's data repository.

We want to add server/web functionality and APIs which will allow Studio to create feature sources from unmanaged data. To accomplish this, certain directories on the server machine will be specified as unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files from the specified unmanaged data directories.

WebStudio can also make use of these APIs to create unmanaged feature sources.

===Motivation===

When Studio is used to create a feature source (e.g. using Load Procedure), the data files (e.g. sdf, shp, raster, dwf, odbc) are uploaded to the server's repository (managed data). This is not an issue when the data files are small. If Studio and Server are on the same machine, this uploading is an unnecessary duplication of the data file. If the data file is really large, the copying is slow and it consumes unnecessary hard-drive space.

Currently, a feature source which references unmanaged data can be created. But it must be done manually. The exact path to the data file on the server machine must be known. Then the Feature Source XML must be manually edited and uploaded to the server via the web tier. This is a cumbersome process.

We want to automate this workaround in Studio. To do this, additional APIs and functionality will be added to the server/web. Certain directories on the server machine will be specified to be unmanaged data directories. APIs will be added which will enumerate the available unmanaged data files. Thus direct access to the server machine's file system will no longer be required. Creation of unmanaged data feature sources can now be created remotely.

The API will only enumerate data files contained in the directories and subdirectories specified by the server. For security reasons we do not want to allow the API to return data files in direcotries which are not specified. For windows, specified directories can be physical drives or network paths. For linux, it can be any accessible path.

===Funding/Resources===

Tony Fang will be the resource to implement the changes outlined in this RFC.

===Proposed Changes===

The proposed changes are open for discussion.

The server's unmanaged data directories will be specified using the serverconfig.ini. We will add a new property to General Properties called UnmanagedDataPaths. Multiple paths will be semi-colon delimited. We will also update the GetServerInfo API method to return this information.

We will add an API to enumerate the full paths to the unmanaged data files available on the server machine.

====Technical====

TBD

===Implications===

TBD

===Test Plan===

TBD

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T21:36:13Z

Wiki-Tonyfang: /* Motivation */

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T21:34:14Z

Wiki-Tonyfang: /* Motivation */

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T21:13:20Z

Wiki-Tonyfang: /* Proposed Changes */

MapGuide RFC 2 - Unmanaged Data APIs

2006-11-02T20:15:21Z

Wiki-Tonyfang: /* Motivation */