The SharePoint team shares this so far:
· Can be installed on x64 Server OS machines running SharePoint x64. Previously only x86 Server OS could be used.
· Separate build commands for package, deploy and retract are added
· Command line build, package and retract commands are included enabling continuous integration and build servers. Previously command line build of SharePoint projects was very difficult
· Refactoring support for renaming of Web Parts. Previously renaming a web part required changes in several files in the project
· WSP View improvements for consistency of deleting feature elements, merging features and adding event receivers to features
· Solution Generator can now generate solutions from publishing sites. Previously only regular sites could be generated
· Allowing partial trust BIN deployments of web parts. CAS configuration must still be provided by the developer.
· New project item template for SharePoint RootFiles items
· Deployment will now optionally remove conflicting existing features on the development server prior to redeployment. Previously any feature name conflicts would result in an error
· Ancillary assemblies such as for business logic can now be added to the SharePoint Solution WSP
· Hidden features related to Site Definition projects are now shown in WSP View. They are no longer hidden
· For advanced users a fast deploy is included to update only the compiled assembly on the SharePoint development installation
· The User Guide is now installed with the extensions instead of being a separate download
The final release of VSeWSS 1.3 is planned for the North American Spring of 2009.
Announcing: Community Technology Preview of Visual Studio 2008 extensions for SharePoint v1.3
One of my friends sent me this link to some really good articles compiled by INSEAD knowledge. Thanks Dhananjay!!
Top10Year2008
Microsoft releases a long awaited tool kit for WSRP producer support with the following components
Visual Studio sample projects that demonstrate two different approaches to producing WSRP conformant output from SharePoint lists and libraries that can be consumed from external portals like BEA Aqualogic Portal, WebSphere Portal, SAP Netweaver etc. A whitepaper that provides details on the two WSRP samples two WSRP producer samples with Screen casts showing how to use them WSRP Toolkit for SharePoint 2007 - Release: WSRPToolkit V1.0
Note that a WSRP consumer always existed, so its the producer that's new…
Cool stuff .. check it out
Just got an invitation code to play with the Azure stock - note that the activation code is per solution and you need a password
Creating a solution in Azure using .NET Services and SQL Services
Azure Services Create Solution
Remember to save the password for the solution. Password xxxxxx (save this in a notepad)
STEP 2 – Create your service.
These are the type of services that you are available..
Then you open your cloud solution it will look like this:
To run your first Internet Service Bus Service run the Echo Solution in the November CTP
Edition of .NET services add on for Visual Studio 2008 – compile and build both service and client projects and it will then ask you for your .NET Service Solution name and password. Once you enter these two credentials you have your first service running on the world. Okay this one just echo's anything you type into the client and nothing else – the interesting part is in the service configure file not the code. Notice the endpoint of my service…
Once you enter the solution name (must match the name of the solution name activated) and password, now you can run your client as well - screen shots below
Overview of the Echo solution in the .NET Services for Azure SDK.
This sample demonstrates how to use the Microsoft .NET Services Service Bus and the NetTcpRelayBinding. It's highly recommended that you take a look at the Technical Overview and the Service Bus Reference document to get yourself oriented on the Service Bus before diving into the samples.
This sample shows a simple service and client that communicate through the Service Bus. When the service application is started, it asks for your .NET Services Solution Credentials and opens an endpoint on the Service Bus. Once opened, this endpoint has a well-known URI on the Service Bus and is, irrespective of whether your machine is residing behind a Firewall or Network Address Translation, reachable from anywhere.
Clients accessing the endpoints must have permissions to talk to the endpoint. The client application therefore also asks for your Solution credentials, authenticates with the Access Control service, and acquires an access token that proves to the Service Bus infrastructure that the client is authorized to access the endpoint. Once the client is connected, you can type messages into the Client application which will be echoed back by the Service.
Like with all other samples in the Service Bus section of the .NET Service SDK you will likely only realize the significant difference between a normal Windows Communication Foundation service and a Service Bus service by running the Client and Service applications on different machines and, preferably, even on disjoint networks.
Prerequisites
If you haven't already done so, please read the common prerequisites document that explains how to sign up for a Microsoft .NET Services account and how to configure your environment. It also contains important information about the default security settings for your environment that you need to be aware of.
Echo Service
The service implements a very simple contract with a single operation named 'Echo'. The 'Echo' service doesn't do anything interesting from a functional perspective; it accepts a string and echoes the string back.
[ServiceBehavior(Name = "EchoService", Namespace = "http://samples.Microsoft.com/ServiceModel/Relay/")]
class EchoService : IEchoContract
{
public string Echo(string text)
{
Console.WriteLine("Echoing: {0}", text);
return text;
}
}
More interesting than the actual service implementation are the service's configuration (in App.config) and the hosting code for the service. The service configuration is shown below:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<services>
<!-- Application Service -->
<service name="Microsoft.ServiceBus.Samples.EchoService">
<endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract"
binding="netTcpRelayBinding" />
</service>
</services>
</system.serviceModel>
</configuration>
Assuming you have some prior knowledge of the structure of configuration files for the Windows Communication Foundation (Configuration Overview, Reference), you will find that the configuration file is just like any other WCF configuration file with the exception that configured service endpoint refers a "netTcpRelayBinding", which isn't part of the .NET Framework.
The NetTcpRelayBinding is one of the new bindings introduced with the Service Bus and the respective configuration element is added to the global configuration schema when the client runtime components are installed; at installation time, the respective configuration extensions are registered in the machine.config configuration file in the .NET Framework runtime directory.
Looking at the code hosting the service (in Program.cs), there are two key aspects of interest:
- How does addressing work?
- How does authentication and authorization work?
Console.Write("Your Solution Name: ");
string solutionName = Console.ReadLine();
Console.Write("Your Solution Password: ");
string solutionPassword = ReadPassword();
// create the endpoint address in the solution's namespace
Uri address = new Uri(String.Format("sb://{0}/services/{1}/EchoService/",
ServiceBusEnvironment.DefaultRelayHostName,
solutionName));
// create the credentials object for the endpoint
TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new TransportClientEndpointBehavior();
userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;
userNamePasswordServiceBusCredential.Credentials.UserName.UserName = solutionName;
userNamePasswordServiceBusCredential.Credentials.UserName.Password = solutionPassword;
// create the service host reading the configuration
ServiceHost host = new ServiceHost(typeof(EchoService), address);
// add the Service Bus credentials to all endpoints specified in configuration
foreach (ServiceEndpoint endpoint in host.Description.Endpoints)
{
endpoint.Behaviors.Add(userNamePasswordServiceBusCredential);
}
// open the service
host.Open();
Console.WriteLine("Service address: " + address);
Console.WriteLine("Press [Enter] to exit");
Console.ReadLine();
// close the service
host.Close();
In order to hook a listening service into the Service Bus, the Service Bus service needs to be able to verify that the owner of the listening service is authorized to do so.
Authentication and authorization are both performed by the Microsoft .NET Services Access Control Service. In order to make these steps simple, the Microsoft.ServiceBus Framework contains a set of transport client credential helpers that automatically deal acquiring required security tokens.
The credential used in this example is a simple Username/Password credential that is backed by the Solution credentials you set up when signing up for Microsoft .NET Services. To associate a listener endpoint with its Service Bus credentials, a TransportClientEndpointBehavior must be added to the respective endpoint's behavior collection. If your service were to expose multiple endpoints through the Relay, the same behavior instance can be added to all those endpoints.
Each Microsoft .NET Services solution automatically owns a branch of the Service Bus global namespace. "Your" Solution namespace branch is rooted at
[scheme]://servicebus.windows.net/services/solution-name/
whereby [scheme] is either "sb" (as in this example) or "http" or "https". The namespace owner can subdivide that namespace and organize services onto that namespace as needed and define rules in the Access Control Service to guard access to branches of the namespace.
The code above prompts for the Solution credential and then constructs the listening URI using that information. The static ServiceBusEnvironment.DefaultRelayHostName property currently yields the string "servicebus.windows.net", but it is strongly recommended to use the property and not the literal string value as the domain name may change in future releases. At present, the resulting listener URI is "sb://servicebus.windows.net/services/solution-name/EchoService/". These URIs can be used as an absolute listening URI for endpoints or as the service's base address.
Echo Service Client
The client application mirrors the service in terms of its configuration.
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<client>
<!-- Application Endpoint -->
<endpoint name="RelayEndpoint"
contract="Microsoft.ServiceBus.Samples.IEchoContract"
binding="netTcpRelayBinding"/>
</client>
</system.serviceModel>
</configuration>
When started, it asks for the Solution credentials, creates a channel to the Service and sends requests by calling the 'Echo' operation. Once the interaction is complete, the client closes the channel and exits.
Console.Write("Your Solution Name: ");
string solutionName = Console.ReadLine();
Console.Write("Your Solution Password: ");
string solutionPassword = ReadPassword();
// create the service URI based on the solution name
Uri serviceUri = new Uri(String.Format("sb://{0}/services/{1}/EchoService/",
ServiceBusEnvironment.DefaultRelayHostName,
solutionName));
// create the credentials object for the endpoint
TransportClientEndpointBehavior userNamePasswordServiceBusCredential = new TransportClientEndpointBehavior();
userNamePasswordServiceBusCredential.CredentialType = TransportClientCredentialType.UserNamePassword;
userNamePasswordServiceBusCredential.Credentials.UserName.UserName = solutionName;
userNamePasswordServiceBusCredential.Credentials.UserName.Password = solutionPassword;
// create the channel factory loading the configuration
ChannelFactory<IEchoChannel> channelFactory =
new ChannelFactory<IEchoChannel>("RelayEndpoint", new EndpointAddress(serviceUri));
// apply the Service Bus credentials
channelFactory.Endpoint.Behaviors.Add(userNamePasswordServiceBusCredential);
// create and open the client channel
IEchoChannel channel = channelFactory.CreateChannel();
channel.Open();
Console.WriteLine("Enter text to echo (or [Enter] to exit):");
string input = Console.ReadLine();
while (input != String.Empty)
{
try
{
Console.WriteLine("Server echoed: {0}", channel.Echo(input));
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.Message);
}
input = Console.ReadLine();
}
channel.Close();
channelFactory.Close();
Running the Sample
To run the sample, build the solution in Visual Studio or from the command line and run the two resulting executables. The 'service' should obviously be started first and the 'client' second. For either program you will be prompted for your Solution credentials.
Once the service and the client have been opened, you can start typing messages into the client application which will be echoed back by the service.
Expected Output – Client
Your Solution Name: solution-name
Your Solution Password: ******
Enter text to echo (or [Enter] to exit): Hello, World!
Server echoed: Hello, World!
Expected Output – Service
Your Solution Name: solution-name
Your Solution Password: ******
Service address: sb://servicebus.windows.net/services/solution-name/EchoService/
Press [Enter] to exit
Echoing: Hello, World!
Good news!! Don't forget to uninstall all the older versions first though !!
Silverlight 2 Released: New controls, tools, announcements!
Nice post on calling WCF from a webpart - but honestly - should this be so complex? I agree with the other comment about needing much tighter integration using json - too many moving parts. here in general..
Michael Washam's - SharePoint Blog : Calling a WCF WebService from a SharePoint WebPart using JavaScript
Check out Steve Martin's post around Microsoft .NET Framework 4.0 and “Dublin” Announcement
WCF 4.0 Enhancements - RESTful Singleton and collection support, ATOM feed and publishing support, POX support over HTTP. A unified XAML model that will let you create new apps just with XAML from presentation, data, services and even workflow - no code folks!! A decorative model is in the works here as well
For WF 4.0 a 10 fold improvement in performance and scalability is targeted - more pre-built activities around Powershell and messaging etc.
Dublin will consist of next set of capabilities for the next generation app server which will extend IIS to provide a standard host for both WF and WCF services. Keep reading Steve Martins posts for more info...
Life, Liberty and the Pursuit of Simple Middleware - Steven Martin, CSD Product Management
Visual Studio 2010 and .NET Framework 4.0 Overview
Check out the Architecture Modeling tool in Visual Studio 2010!!
.jpg)
Visual Studio 2010 and the .NET Framework 4.0 mark the next generation of developer tools from Microsoft. Designed to address the latest needs of developers, Visual Studio and the .NET Framework deliver key innovations in the following pillars:
- Democratizing Application Lifecycle Management
Application Lifecycle Management (ALM) crosses many roles within an organization and traditionally not every one of the roles has been an equal player in the process. Visual Studio Team System 2010 continues to build the platform for functional equality and shared commitment across an organization’s ALM process. - Enabling emerging trends
Every year the industry develops new technologies and new trends. With Visual Studio 2010, Microsoft delivers tooling and framework support for the latest innovations in application architecture, development and deployment. - Inspiring developer delight
Ever since the first release of Visual Studio, Microsoft has set the bar for developer productivity and flexibility. Visual Studio 2010 continues to deliver on the core developer experience by significantly improving upon it for roles involved with the software development process. - Riding the next generation platform wave
Microsoft continues to invest in the market leading operating system, productivity application and server platforms to deliver increased customer value in these offerings. With Visual Studio 2010 customers will have the tooling support needed to create amazing solutions around these technologies. - Breakthrough Departmental Applications
Customers continue to build applications that span from department to the enterprise. Visual Studio 2010 will ensure development is supported across this wide spectrum of applications.
Over the next few months we will provide more detail in each of these pillars. We will start with “Democratizing Application Lifecycle Management.”
Please check back shortly to see the next pillar, “Enabling emerging trends.”
Microsoft Visual Studio Team System 2010 – Democratizing Application Lifecycle Management
Visual Studio Team System 2010 will deliver new capabilities that embrace the needs of the users in the lifecycle – from architects to developers, from project managers to testers.
Among the great new functionality in VSTS 2010:
- Discover and identify existing code assets and architecture with the new Architecture Explorer.
- Design and share multiple diagram types, including use case, activity and sequence diagrams.
- Improve testing efforts with tooling for better documentation of test scenarios and more thorough collection of test data.
- Identify and run only the tests impacted by a code change easily with the new Test Impact View.
- Enhanced version control capabilities including gated check-in, branch visualization and build workflow.
Key to a shared understanding of the application is the use of modeling tools. Modeling has traditionally been done by professional architects and system designers. Our approach is to enable both technical and non-technical users to create and use models to collaborate and to define business and system functionality graphically.
From the design of the application through to the actual writing of the code, one of the most difficult problems has always been that of the bug that can’t be reproduced – the “no-repro” bug. There are a lot of factors that drive these types of bugs and we have worked to create tools to help isolate the issue and allow faster fixes. One of the common blockers to reproducing a bug is the collection of actionable data on the bug. By dramatically simplifying the tools required to integrate testing across the lifecycle, we are further introducing new non-technical users to the application lifecycle.
.jpg)
Visual Studio Team System 2010 provides testers with a set of tools for managing test cases and execution as well as improved support for filing actionable bugs.
Better Together – Visual Studio Team System Development Edition and Database Edition
In recognition of the increased need to integrate more of the lifecycle members together, we will provide a unified Development and Database product in Visual Studio Team System 2010. Beginning October 1, 2008 Development Edition and Database Edition MSDN subscribers will have access to both products.
See Visual Studio 2010 in Action on Channel 9
During the week of September 29, 2008, Channel 9 will be publishing new Visual Studio Team System 2010 videos daily. During the week you can watch videos covering many of the aspects of Visual Studio Team System 2010, including an overview of new capabilities, software quality, project management and Team Foundation Server, featuring Brian Harry. Watch the videos now.
Learn More About Visual Studio Team System 2010
To learn more about the new features and capabilities in Visual Studio Team System 2010 follow the links below.
- Modeling that Works with Code
Powerful modeling tools are important for both defining new systems as well as discovering architectural information about existing systems. Our new modeling tools have tight integration into the actual code of the application enabling a developer or architect to use models to enforce constraints on code, as well as to explore existing code assets. Learn more. - Eliminating “No-Repro”
One of the most difficult problems has always been that of the bug that can’t be reproduced – the “no repro” bug. There are a lot of factors that drive these types of bugs and we have worked to create tools to isolate the issue and enable faster fixes. Learn more. - Identify the Test Impact
After making a change to the code it is critical to test the changes to prove they work as expected and to ensure no unexpected downstream effect. Test Impact Analysis helps developers quickly check-in code with confidence by running only the necessary tests. Learn more.
Visual Studio 2010 and .NET Framework 4.0 Overview
Recently the BizTalk Customer Advisory Team and BizTalk UE team announced the first edition of the “Microsoft BizTalk Server 2006 R2 Hyper-V Guide”.
The Microsoft BizTalk Server 2006 R2 Hyper-V Guide is the third installment in a series of guides intended to provide easily accessible, hands-on guidance to our customer and partner community. This 145 page guide is available on MSDN, TechNet and as a separate DOCX, PDF or CHM download alongside the already available “Microsoft BizTalk Server Operations Guide” and “Microsoft BizTalk Server Performance Optimizations Guide”
The guide provides relevant information to IT professionals to enable them to make educated decisions about the advantages and tradeoffs of using Windows Server 2008 Hyper-V to virtualize BizTalk Server environments. This guidance was derived from a 6 week performance lab conducted by the BizTalk Customer Advisory Team and Premier Field Engineering. It will be refreshed for future versions of Microsoft BizTalk Server.
The key sections of the guide are:
- Getting Started: provides conceptual information about Hyper-V, the virtualization technology introduced with Windows Server 2008, and an introduction to the Hyper-V architecture.
- Deploying BizTalk Server on Hyper-V: describes the steps that were followed to set up the lab environment, which was used to compare the performance of a BizTalk Server solution running on Hyper-V environment to the same BizTalk Server solution running on comparable physical hardware.
- Evaluating BizTalk Server Performance on Hyper-V: details the important considerations when measuring the performance of a BizTalk Server solution running on a Hyper-V virtualized environment.
- Testing BizTalk Server Performance on Hyper-V: provides detailed results of four distinct testing scenarios that compare the performance of a BizTalk Server solution running on Hyper-V environment to the same BizTalk Server solution running on comparable physical hardware.
The target audience for this guide is Microsoft field, partner organizations, and customers who plan, deploy, and maintain BizTalk Server installations.
Full MSDN URL: http://msdn.microsoft.com/en-us/library/cc768518.aspx
Full TechNet URL: http://technet.microsoft.com/en-us/library/cc768518.aspx
Using BizTalk Server 2006 R2 with Windows Server 2008 Hyper-V
I recently read this post from Michael and I think I am ready to plunge into Hyper V on my laptop.. good post... basic summary is a 100% improvement - nice!!!
Michael O'Donovan's SharePoint and Stuff : SharePoint under Hyper-V versus Virtual Server 2005 R2
First let me start by saying this is not a blog bashing Google - quite the contrary -this blog just proves that whether your Google or Microsoft SDLC Agility remains a challenge. Just having technology is not a panacea for the problem at hand.
I recently watched this very good talk by Jeff Sutherland on SCRUM and lessons that he learnt as he was helping Google out with their "AdWord project" and I thought I would share my own 2 cents on SCRUM and some common pitfalls that I have seen in the field with various enterprise customers:
- Trying to scrum with team size of greater than 4 developers
- Trying to plug in waterfall process after doing a SCRUM to adhere to Enterprise Architecture doctrines - by this I mean - not following an iterative methodology trying to have a test or QA and deploy cycle at the release level rather than at the Sprint or Iteration level.
- Not monitoring the burn-down charts (this point is highlighted by Jeff as well quite well)
- Not having a Release Plan that is independent of the Sprint or Iterations!!
- SCRUM only works with smart developer who can work without detailed designs!!
- Having a Scrum Master than tries to be a Project Manager!!
InfoQ: Agile Project Management: Lessons Learned at Google
Microsoft BizTalk Server Performance Optimization Guide released....
The BizTalk Customer Advisory Team and BizTalk UE team are pleased to announce the first edition of the “Microsoft BizTalk Server Performance Optimization Guide”.
The Microsoft BizTalk Server Performance Optimization Guide is the second installment in a series of guides intended to provide easily accessible, hands-on guidance to our customer and partner community. This 228 page guide is available on MSDN, TechNet and as a separate DOCX or CHM download alongside the already available “Microsoft BizTalk Operations Guide”
The guide is based on real-world experience from BizTalk CAT (Rangers), Premier Field Engineering, MCS and other customer engagements. This guide is intended to serve two purposes. Firstly, to provide regularly maintained prescriptive guidance & best practices on optimizing BizTalk Server performance for demanding production environments. Secondly, to provide a foundation for the development of PFE, MCS and Partner training and service offerings.
The key sections of the guide are:
· Getting Started: Provides an overview of the BizTalk Server functional components that can affect performance. It also describes the phases of a BizTalk Server performance assessment.
· Finding and Eliminating Bottlenecks: The Finding and Eliminating Bottlenecks section describes various types of performance bottlenecks as they relate to BizTalk Server solutions and information about how to resolve the bottlenecks.
· Automating Testing: Describes how to implement an automated build process and how to automate functional and load testing using Visual Studio Team System, BizUnit and Loadgen.
· Optimizing Performance: The Optimizing Performance section provides guidance for optimizing performance of specific components in a BizTalk Server environment
The target audience for this guide is Microsoft field, partner organizations, and customers who plan, deploy, and maintain mission critical BizTalk Server installations. The guide was created from the key learnings, processes and methodology that have been developed by the Rangers to effectively run Performance Labs for our customers.
The guide has been carefully reviewed and vetted by experts from the community of BizTalk Server, whom we gratefully acknowledge. We believe that the information presented here will help BizTalk Server users optimize their solutions.
Full end-to-end performance testing is frequently overlooked during enterprise application deployment. Knowing that Microsoft has built a scalable messaging infrastructure, many organizations that use BizTalk Server spend little or no time conducting performance testing of their own applications. BizTalk Server applications consist of many parts, which may include custom-built components as well as those provided by Microsoft. It is impossible for Microsoft to performance test every possible combination of these components. Therefore, fully and properly conducting a performance test of your application is a critical step of any deployment. The purpose of this guide is to consolidate and provide prescriptive guidance on the best practices and techniques that should be followed to optimize BizTalk Server performance.
To download a copy of this guide, go to http://go.microsoft.com/fwlink/?LinkId=120792.
Microsoft BizTalk Server Performance Optimization Guide
Get field-tested best practices and proven techniques for designing, deploying, operating, and optimizing Microsoft Office SharePoint Server 2007 and Windows SharePoint Services 3.0. Part of the new Best Practices series for IT professionals from Microsoft Press®, this guide is written by leading SharePoint MVPs and Microsoft SharePoint team members who’ve worked extensively with real-world deployments and customers. You’ll find out how to deploy the software, design your environment, manage content, analyze and view data, perform disaster recovery, monitor performance, and more. You'll learn how to create SharePoint sites that help your organization collaborate, take advantage of business insights, and improve productivity—with practical insights from the experts. Ordering this book now myself and let you know how I like it...
Microsoft® Office SharePoint® Server 2007 Best Practices
I am working on a neat concept for the solutions team at Microsoft - its called OIF or the Operation Improvement Framework. Probably be delivered to the public later as part of the MOF Continuous Improvement Framework is my guess. The framework itself can be hosted on a MOSS platform but in its early stages is implemented as documentation in Excel Spreadsheet and Word that focuses on the human and process aspect of Operations. For example for the BizTalk Platform what a day of the life of the various roles in the RACI chart for the concerned platform look like?
I am developing a spreadsheet that contains daily, weekly, monthly tasks that say a BTS Admin would have to do. How long it each task would take and if the task is complicated than create new documentation called "work instructions" that explode this tasks into various steps and walk through's
I am interested in hearing form BizTalk Administrator, SharePoint Administrators etc and seeing what steps they do on a regular basis to ensure their systems are humming along smoothly without a hitch. Please ping me if you have anything that could make this document accurate and complete...
Here is some information on what ISA does vs IAG that I thought would be useful considering security solution in the context of exposing internal web services, SharePoint and Exchange Server services to the Internet.
ISA Server 2006 Features
General application access from Web-enabled clients when content-specific policy is not required.
- Protocol validation and filtering
- Pre-authentication
- OWA-specific content inspection
- Application and user-level policy
- SharePoint link translation
- Simple publishing wizards
Intelligent Application Gateway 2007 Features (Now part of Microsoft Edge Server Security Solution and will be a part of Microsoft Forefront Unified Access Gateway )http://www.microsoft.com/forefront/prodinfo/roadmap/uag.mspx
Highly customizable and differentiated application access based on user identity, content and file attributes, URL, and client security state.
- Comprehensive pre-authentication and single sign-on
- Application-specific data protection
- Block specific functions or areas within applications based on endpoint profile
- Endpoint security verification
- Client-side cache and session clean-up (Attachment Wiper)
- Multiple policy-based portal configurations with link translation
- Flexible and customizable portal experience with automated application launch
- Native SharePoint services support
Forefront Edge Web - Secure Remote Access
