ArcGIS Engine 10.2 如何发布服务

by giser · 2019-04-24

Toggle

1
ArcGIS Engine 10.2 如何发布服务

ArcGIS Engine的代码不能直接将MXD地图文档作为数据源进行发布，如果要发布的话，需要用ArcMap将MXD转成MSD，然后使用转换成功的MSD文档进行发布，代码如下：

public void
Publish(string
host,string
username,string
password, string
service, string
msdDocument, string
outputDir)

{

//IAGSServerConnectionFactory3 pConnectionFactory = new AGSServerConnectionFactoryClass();

////admin connection file works fine, tested in ArcCatalog on the same server

//IAGSServerConnection4 server = pConnectionFactory.OpenFromFile(@”e:\admin-connection.ags”, 0) as IAGSServerConnection4;

// IAGSServerConnectionAdmin pAGSServerConnectionAdmin = server as IAGSServerConnectionAdmin;

IPropertySet
propertySet = new
PropertySetClass();

propertySet.SetProperty(“url”,
host);

propertySet.SetProperty(“ConnectionMode”,
esriAGSConnectionMode.esriAGSConnectionModeAdmin);

propertySet.SetProperty(“ServerType”,
esriAGSServerType.esriAGSServerTypeDiscovery);

propertySet.SetProperty(“user”,
username);

propertySet.SetProperty(“password”,
password);

propertySet.SetProperty(“ALLOWINSECURETOKENURL”,
true); //设置为false会弹出一个警告对话框

IAGSServerConnectionName3
pConnectName = new
AGSServerConnectionNameClass()
as IAGSServerConnectionName3;//10.1新增接口

pConnectName.ConnectionProperties =
propertySet;

IAGSServerConnectionAdmin
pAGSAdmin = ((IName)pConnectName).Open()
as IAGSServerConnectionAdmin;

IAGSServerConnectionAdmin
pAGSServerConnectionAdmin =
pAGSAdmin as IAGSServerConnectionAdmin;

IServerObjectAdmin
pServerObjectAdmin =
pAGSServerConnectionAdmin.ServerObjectAdmin;

IServerObjectConfiguration5
pConfiguration = (IServerObjectConfiguration5)pServerObjectAdmin.CreateConfiguration();

//Set the general configuration settings

pConfiguration.Name =
service;

pConfiguration.TypeName =
“MapServer”;

pConfiguration.TargetCluster =
“default”;

pConfiguration.StartupType =
esriStartupType.esriSTAutomatic;

pConfiguration.IsolationLevel =
esriServerIsolationLevel.esriServerIsolationHigh;

pConfiguration.IsPooled =
true;

pConfiguration.Description =
“Modsim Map Output”;

// pConfiguration.LoadBalancing = esriLoadBalancing.esriLoadBalancingNone;//没有集群的话可以不用设置

pConfiguration.MinInstances = 1;

pConfiguration.MaxInstances = 15;

pConfiguration.WaitTimeout = 60;

pConfiguration.UsageTimeout = 600;

pConfiguration.IdleTimeout = 1800;

//Set the configuration properties of the MapServer

IPropertySet
pProps = pConfiguration.Properties;

pProps.SetProperty(“FilePath”,
msdDocument);

pProps.SetProperty(“OutputDir”,
outputDir);

pProps.SetProperty(“MaxImageHeight”,
“2048”);

pProps.SetProperty(“MaxRecordCount”,
“1000”);

pProps.SetProperty(“MaxBufferCount”,
“100”);

pProps.SetProperty(“MaxImageWidth”,
“2048”);

pConfiguration.Properties =
pProps;

//MIME+URL (virtual directory)

IEnumServerDirectory
dirs = pServerObjectAdmin.GetServerDirectories();

dirs.Reset();

IServerDirectory
serverDir = dirs.Next();

while (serverDir !=
null)

{

if (((IServerDirectory2)serverDir).Type ==
esriServerDirectoryType.esriSDTypeOutput)

{

pProps.SetProperty(“OutputDir”,
serverDir.Path);

pProps.SetProperty(“VirtualOutputDir”,
serverDir.URL);

break;

// gp.AddMessage(“[DEBUG] Outputpath: ” + serverDir.Path + ” || Virtual: ” + serverDir.URL);

}

serverDir =
dirs.Next();

}

//Set the info segment properties

IPropertySet
info = pConfiguration.Info;

info.SetProperty(“WebEnabled”,
“true”);

info.SetProperty(“WebCapabilities”,
“Map,Query,Data”);

pConfiguration.Info =
info;

//Set the recycle properties of the MapServer object

IPropertySet
recycle = pConfiguration.RecycleProperties;

recycle.SetProperty(“StartTime”,
“1:00 AM”);

recycle.SetProperty(“Interval”,
“86400”);

pConfiguration.RecycleProperties =
recycle;

//Add the configuration to the server

pServerObjectAdmin.AddConfiguration(pConfiguration);

pServerObjectAdmin.StartConfiguration(service,
“MapServer”);

}

2
使用ArcGIS Engie中的GP发布地图文档

ArcGIS 10.1 在发布服务的时候其实是按照下面的步骤来的，如果认真观察过也不难得出：

l 将MXD文档转成sddraft文件；

l 将sddraft文件转成sd文件；

l 将sd文件上传到ArcGIS for Server中

既然这个过程已经知道了，那么就可以通过Python按照这个流程来自动化的完成服务的发布：

import arcpy

# define local variables

wrkspc = ‘C:/Project/’

mapDoc = arcpy.mapping.MapDocument(wrkspc +
‘counties.mxd’)

con = r’GIS Servers\arcgis on MyServer_6080 (admin).ags’

service =
‘Counties’

sddraft = wrkspc + service +
‘.sddraft’

sd = wrkspc + service +
‘.sd’

# create service definition draft

arcpy.mapping.CreateMapSDDraft(mapDoc, sddraft, service,
‘ARCGIS_SERVER’, con, True, None)

# analyze the service definition draft

analysis = arcpy.mapping.AnalyzeForSD(sddraft)

# stage and upload the service if the sddraft analysis did not contain errors

if analysis[‘errors’] == {}:

# Execute StageService

arcpy.StageService_server(sddraft, sd)

# Execute UploadServiceDefinition

arcpy.UploadServiceDefinition_server(sd, con)

else:

# if the sddraft analysis contained errors, display them

print analysis[‘errors’]

可以将上面的脚本创建为一个tbx文件，然后在ArcGIS Engine中通过GP来实现服务的发布.

其实Esri在官网上发布了一个tbx里面就包含了对server服务管理的功能（有兴趣的可以下载，文档所在的目录下也包含了）：

3
使用Admin API 发布文档

ArcGIS for Server 10.1 增加了Admin API，那么，所谓的Admin API 其实就是一一http请求的方法，这些方法包含了对Server的管理，下面为Admin API 的代码：

namespace
ServerAPIAdmin.ArcGIS.Rest

{

using
System;

using
System.Collections;

using
System.Collections.Generic;

using
System.IO;

using
System.Linq;

using
System.Net;

using
System.Text;

using
System.Web;

using
ESRI.ArcGIS.SOESupport;

///<summary>

/// tipi di servizio arcgis server (mappa la tabella servizio tipo)

///</summary>

public
enum ServiceType

{

MapServer,

GeocodeServer,

SearchServer,

IndexingLauncher,

IndexGenerator,

GeometryServer,

GeoDataServer,

GPServer,

GlobeServer,

ImageServer

}

///<summary>

/// Load Balancing

///</summary>

public
enum LoadBalancing

{

ROUND_ROBIN,

FAIL_OVER

}

///<summary>

/// isolation level

///</summary>

public
enum IsolationLevel

{

LOW,

HIGH

}

///<summary>

/// administrative API Rest

///</summary>

public
class AGSAdmin

{

private
string username;

private
string password;

private
string urlRestAdmin;

private
string urlRestServer;

///<summary>

/// Initializes a new instance of the
<see cref=”AGSAdmin”/> class.

///</summary>

///<param name=”serverName”>server name</param>

///<param name=”port”>port of server</param>

///<param name=”username”>username administrator</param>

///<param name=”password”>password administrator</param>

public
AGSAdmin(string
serverName, int
port, string username,
string password)

{

this.username =
username;

this.password =
password;

string
url = string.Format(“http://{0}:{1}/arcgis”,
serverName, port.ToString());

this.urlRestAdmin =
url + “/admin”;

this.urlRestServer =
url + “/server”;

}

///<summary>

/// Prevents a default instance of the
<see cref=”AGSAdmin”/> class from being created.

///</summary>

private
AGSAdmin()

{

}

///<summary>

/// Create arcgis server folder

///</summary>

///<param name=”folderName”>Folder name</param>

///<param name=”description”>Description of the folder</param>

///<returns>True if successfully created</returns>

public
bool CreateServerFolder(string
folderName, string
description)

{

try

{

string
token = this.GenerateAGSToken();

string
folderUrl = this.urlRestAdmin +
“/services/” + folderName +
“?f=json&token=” +
token;

string
resultExistsFolder = this.GetResult(folderUrl);

if (!this.HasError(resultExistsFolder))

{

return
true; // exists

}

else

{

string
createFolderUrl = this.urlRestAdmin +
“/services/createFolder”;

string
postContent = string.Format(“folderName={0}&description={1}&f=json&token={2}”,
folderName, description,
token);

string
result = this.GetResult(createFolderUrl,
postContent);

return
this.HasSuccess(result);

}

catch

{

return
false;

}

///<summary>

/// Get physical Path and virtual Path from directory ags

///</summary>

///<param name=”directory”>directory ags</param>

///<param name=”physicalPath”>physical Path</param>

///<param name=”virtualPath”>virtual Path</param>

///<returns>True if successfully return path</returns>

public
bool GetServerDirectory(string
directory, out
string physicalPath,
out string
virtualPath)

{

physicalPath =
null;

virtualPath =
null;

try

{

string
token = this.GenerateAGSToken();

string
directoryUrl = this.urlRestAdmin +
“/system/directories/” +
directory + “?f=json&token=” +
token;

string
result = this.GetResult(directoryUrl);

JsonObject
jsonObject = new
JsonObject(result);

if (!jsonObject.Exists(“physicalPath”) || !jsonObject.TryGetString(“physicalPath”,
out physicalPath))

{

throw
new Exception();

}

jsonObject =
new JsonObject(result);

if (!jsonObject.Exists(“virtualPath”) || !jsonObject.TryGetString(“virtualPath”,
out virtualPath))

{

throw
new Exception();

}

return
true;

}

catch

{

return
false;

}

///<summary>

/// Delete Service

///</summary>

///<param name=”serviceName”>Service Name</param>

///<param name=”serviceType”>Server Type</param>

///<returns>True if successfully deleted</returns>

public
bool DeleteService(string
serviceName, ServiceType
serviceType)

{

try

{

string
token = this.GenerateAGSToken();

string
serviceUrl = this.urlRestAdmin +
“/services/” + serviceName +
“.” + Enum.GetName(typeof(ServiceType),
serviceType) + “/delete”;

string
result = this.GetResult(serviceUrl,
“f=json&token=” +
token);

return
this.HasSuccess(result);

}

catch

{

return
false;

}

///<summary>

/// Start Service

///</summary>

///<param name=”serviceName”>Service Name</param>

///<param name=”serviceType”>Server Type</param>

///<returns>True if successfully started</returns>

public
bool StartService(string
serviceName, ServiceType
serviceType)

{

try

{

string
token = this.GenerateAGSToken();

string
serviceUrl = this.urlRestAdmin +
“/services/” + serviceName +
“.” + Enum.GetName(typeof(ServiceType),
serviceType) + “/start”;

string
result = this.GetResult(serviceUrl,
“f=json&token=” +
token);

return
this.HasSuccess(result);

}

catch

{

return
false;

}

///<summary>

/// Stop Service

///</summary>

///<param name=”serviceName”>Service Name</param>

///<param name=”serviceType”>Server Type</param>

///<returns>True if successfully stopped</returns>

public
bool StopService(string
serviceName, ServiceType
serviceType)

{

try

{

string
token = this.GenerateAGSToken();

string
serviceUrl = this.urlRestAdmin +
“/services/” + serviceName +
“.” + Enum.GetName(typeof(ServiceType),
serviceType) + “/stop”;

string
result = this.GetResult(serviceUrl,
“f=json&token=” +
token);

return
this.HasSuccess(result);

}

catch

{

return
false;

}

///<summary>

/// list of services

///</summary>

public
void ListServices()

{

this.ListServices(null);

}

///<summary>

/// list of services in folder

///</summary>

///<param name=”folder”>name of folder</param>

public
void ListServices(string
folder)

{

try

{

string
token = this.GenerateAGSToken();

string
serviceUrl = this.urlRestAdmin +
“/services/” + folder;

string
postcontent = “f=json&token=” +
token;

string
result = this.GetResult(serviceUrl,
postcontent);

JsonObject
jsonObject = new
JsonObject(result);

object[]
folders = null;

if (jsonObject.Exists(“folders”) &&
jsonObject.TryGetArray(“folders”,
out folders))

{

foreach (string
subfolder in
folders)

{

this.ListServices(subfolder);

}

object[]
services = null;

if (jsonObject.Exists(“services”) &&
jsonObject.TryGetArray(“services”,
out services))

{

IEnumerable<JsonObject>
jsonObjectService =
services.Cast<JsonObject>();

jsonObjectService.ToList().ForEach(jo =>

{

string
serviceName;

jo.TryGetString(“serviceName”,
out serviceName);

string
folderName;

jo.TryGetString(“folderName”,
out folderName);

Console.WriteLine(folderName +
“/” + serviceName);

});

}

catch

{

throw;

}

///<summary>

/// create service type MapServer

///</summary>

///<returns>>True if successfully created</returns>

public
bool CreateService(String
msdPath)

{

try

{

string
token = this.GenerateAGSToken();

string
serviceUrl = this.urlRestAdmin +
“/services/createService”;

JsonObject
jsonObject = new
JsonObject();

jsonObject.AddString(“serviceName”,
“Test”);

jsonObject.AddString(“type”,
Enum.GetName(typeof(ServiceType),
ServiceType.MapServer));

jsonObject.AddString(“description”,
“This is an example”);

jsonObject.AddString(“capabilities”,
“Map,Query,Data”);

jsonObject.AddString(“clusterName”,
“default”);

jsonObject.AddLong(“minInstancesPerNode”, 1);

jsonObject.AddLong(“maxInstancesPerNode”, 2);

jsonObject.AddLong(“maxWaitTime”, 60);

jsonObject.AddLong(“maxStartupTime”, 300);

jsonObject.AddLong(“maxIdleTime”, 1800);

jsonObject.AddLong(“maxUsageTime”, 600);

jsonObject.AddLong(“recycleInterval”, 24);

jsonObject.AddString(“loadBalancing”,
Enum.GetName(typeof(LoadBalancing),
LoadBalancing.ROUND_ROBIN));

jsonObject.AddString(“isolationLevel”,
Enum.GetName(typeof(IsolationLevel),
IsolationLevel.HIGH));

JsonObject
jsonObjectProperties = new
JsonObject();

// see for a list complete http://resources.arcgis.com/en/help/server-admin-api/serviceTypes.html

jsonObjectProperties.AddLong(“maxBufferCount”, 100);
// optional 100

jsonObjectProperties.AddString(“virtualCacheDir”,
this.urlRestServer +
“/arcgiscache”); // optional

jsonObjectProperties.AddLong(“maxImageHeight”, 2048);
// optional 2048

jsonObjectProperties.AddLong(“maxRecordCount”, 1000);
// optional 500

// Other service types do not require you to use arcpy.mapping or create an MSD.

jsonObjectProperties.AddString(“filePath”, msdPath);
// required

jsonObjectProperties.AddLong(“maxImageWidth”, 2048);
// optional 2048

jsonObjectProperties.AddBoolean(“cacheOnDemand”,
false); // optional false

jsonObjectProperties.AddString(“virtualOutputDir”,
this.urlRestServer +
“/arcgisoutput”);

jsonObjectProperties.AddString(“outputDir”,
@”C:\arcgisserver\directories\arcgisoutput”);
// required

jsonObjectProperties.AddString(“supportedImageReturnTypes”,
“MIME+URL”); // optional MIME+URL

jsonObjectProperties.AddBoolean(“isCached”,
false); // optional false

jsonObjectProperties.AddBoolean(“ignoreCache”,
false); // optional false

jsonObjectProperties.AddBoolean(“clientCachingAllowed”,
false); // optional true

jsonObjectProperties.AddString(“cacheDir”,
@”C:\arcgisserver\directories\arcgiscache”);
// optional

jsonObject.AddJsonObject(“properties”,
jsonObjectProperties);

string
result = this.GetResult(serviceUrl,
“service=” + HttpUtility.UrlEncode(jsonObject.ToJson()) +
“&f=json&token=” +
token);

return
this.HasSuccess(result);

}

catch

{

return
false;

}

///<summary>

/// check is status is equal success

///</summary>

///<param name=”result”>result of request</param>

///<returns>True if status is equal success</returns>

private
bool HasSuccess(string
result)

{

JsonObject
jsonObject = new
JsonObject(result);

string
status = null;

if (!jsonObject.Exists(“status”) || !jsonObject.TryGetString(“status”,
out status))

{

return
false;

}

return
status == “success”;

}

///<summary>

/// check is status is equal error

///</summary>

///<param name=”result”>result of request</param>

///<returns>True if status is equal error</returns>

private
bool HasError(string
result)

{

JsonObject
jsonObject = new
JsonObject(result);

string
status = null;

if (!jsonObject.Exists(“status”) || !jsonObject.TryGetString(“status”,
out status))

{

return
false;

}

return
status == “error”;

}

///<summary>

/// Get request rest

///</summary>

///<param name=”url”>url of request</param>

///<returns>return response</returns>

private
string GetResult(string
url)

{

try

{

WebRequest
request = WebRequest.Create(url);

WebResponse
response = request.GetResponse();

using (Stream
responseStream = response.GetResponseStream())

{

using (StreamReader
reader = new
StreamReader(responseStream))

{

return
reader.ReadToEnd();

}

catch

{

throw;

}

///<summary>

/// Post request rest

///</summary>

///<param name=”url”>url of request</param>

///<param name=”postContent”>content of post</param>

///<returns>return response</returns>

private
string GetResult(string
url, string
postContent)

{

try

{

WebRequest
request = WebRequest.Create(url);

byte[]
content = Encoding.UTF8.GetBytes(postContent);

request.ContentLength =
content.Length;

request.ContentType =
“application/x-www-form-urlencoded”;

request.Method =
WebRequestMethods.Http.Post;

using (Stream
requestStream = request.GetRequestStream())

{

requestStream.Write(content, 0,
content.Length);

requestStream.Close();

WebResponse
response = request.GetResponse();

using (Stream
responseStream = response.GetResponseStream())

{

using (StreamReader
reader = new
StreamReader(responseStream))

{

return
reader.ReadToEnd();

}

catch

{

throw;

}

///<summary>

/// Generate a token

///</summary>

///<returns>A token that has default expiration time</returns>

private
string GenerateAGSToken()

{

try

{

string
urlGenerateToken = string.Format(“{0}/generateToken”,
this.urlRestAdmin);

string
credential = string.Format(“username={0}&password={1}&client=requestip&expiration=&f=json”,
this.username,
this.password);

string
result = this.GetResult(urlGenerateToken,
credential);

JsonObject
jsonObject = new
JsonObject(result);

string
token = null;

if (!jsonObject.Exists(“token”) || !jsonObject.TryGetString(“token”,
out token))

{

throw
new Exception(“Token not found!”);

}

return
token;

}

catch

{

return
string.Empty;

}

转载自：https://blog.csdn.net/arcgis_all/article/details/17376397

ArcGIS Engine 10.2 如何发布服务

1
ArcGIS Engine 10.2 如何发布服务

2
使用ArcGIS Engie中的GP发布地图文档

3
使用Admin API 发布文档

相关推荐

You may also like...

公众号

微信群

微信小程序

ArcGIS Engine 10.2 如何发布服务

1 ArcGIS Engine 10.2 如何发布服务

2 使用ArcGIS Engie中的GP发布地图文档

3 使用Admin API 发布文档

相关推荐

You may also like...

ArcGIS对未知坐标系要素建立拓扑查错修错

利用 arcpy 自定义 GP 工具箱，进行拓扑检查

【Arcpy】Arcpy核心

公众号

微信群

微信小程序

1
ArcGIS Engine 10.2 如何发布服务

2
使用ArcGIS Engie中的GP发布地图文档

3
使用Admin API 发布文档