ArcGIS Engine 10.2 如何发布服务

 

1         ArcGIS Engine 10.2 如何发布服务

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

 

public voidPublish(stringhost,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会弹出一个警告对话框

            IAGSServerConnectionName3pConnectName = newAGSServerConnectionNameClass() as IAGSServerConnectionName3;//10.1新增接口

            pConnectName.ConnectionProperties =propertySet;

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

            IAGSServerConnectionAdminpAGSServerConnectionAdmin = pAGSAdmin as IAGSServerConnectionAdmin;

            IServerObjectAdminpServerObjectAdmin = pAGSServerConnectionAdmin.ServerObjectAdmin;

            IServerObjectConfiguration5pConfiguration = (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)

            IEnumServerDirectorydirs = 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(stringfolderName, stringdescription)

        {

            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(stringdirectory, outstring 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(stringserviceName, ServiceTypeserviceType)

        {

            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(stringserviceName, ServiceTypeserviceType)

        {

            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(stringserviceName, ServiceTypeserviceType)

        {

            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(stringfolder)

        {

            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 (stringsubfolder 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(stringresult)

        {

            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(stringresult)

        {

            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(stringurl)

        {

            try

            {

                WebRequest request = WebRequest.Create(url);

                WebResponse response = request.GetResponse();

                using (StreamresponseStream = response.GetResponseStream())

                {

                    using (StreamReaderreader = 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(stringurl, 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 (StreamrequestStream = request.GetRequestStream())

                {

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

                    requestStream.Close();

                    WebResponseresponse = request.GetResponse();

                    using (StreamresponseStream = response.GetResponseStream())

                    {

                        using (StreamReaderreader = new StreamReader(responseStream))

                        {

                            returnreader.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;

            }

        }

    }

}